Search

import { createRoot } from "https://esm.sh/react-dom/client";

function App() {

const [messages, setMessages] = useState([]);

</div>

function client() {

createRoot(document.getElementById("root")).render(<App />);

client();

function generateSessionId() {

return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);

export default async function server(request: Request): Promise<Response> {

const { OpenAI } = await import("https://esm.town/v/std/openai");

const { sqlite } = await import("https://esm.town/v/stevekrouse/sqlite");

const openai = new OpenAI();

const SCHEMA_VERSION = 2;

// Generate AI response

const completion = await openai.chat.completions.create({

messages: [

Bot for Cama discord server. To initialize new slash commands, you have to run a separate bit of code. This is for modifying their functionality

req.headers.get("X-Signature-Ed25519"),

req.headers.get("X-Signature-Timestamp"),

// Get the user calling this slash command

const userId = await body.member?.user?.id;

if (bank[userId] === undefined) bank[userId] = starting_amount;

export async function val_DxjKDGJFD8(req) {

try {

// Create a function from the provided code and execute it

const userCode = async () => {

return const findPrimes = (n) => {

export function myApi(name) {

return "hi " + name;

export async function val_4INpGNAf93(req) {

try {

function mandelbrotPoint(x0, y0, maxIter) {

let x = 0;

return iter;

function createMandelbrotVisualization(width, height, maxIter) {

let visualization = '';

const MODELS = ["llama3.1-8b", "llama3.1-70b"];

function App() {

const [messages, setMessages] = useState<Array<{ role: string; content: string }>>([]);

</div>

function client() {

createRoot(document.getElementById("root")).render(<App />);

client();

async function server(request: Request): Promise<Response> {

if (request.method === "POST" && new URL(request.url).pathname === "/api/chat") {

This val exports a function that takes a lowdb instance and returns a [Hono](https://hono.dev) router that can be used to interact with the data. This is the beginning of an implementation of something like [json-server](https://github.com/typicode/json-server) for Val Town.

The resulting server also comes with a frontend at `/`. The code for the frontend can be found [here](https://www.val.town/v/nbbaier/dbToAPIFrontend).

import { Hono } from "npm:hono";

export async function createServer(db, options: Options & { auth?: { username: string; password: string } } = {}) {

const app = new Hono();

if (options.auth) {

header: { sessiontoken: this.#sessionToken },

return await resp.json();

export default async function(req: Request): Promise<Response> {

// Use your Val Town API Token to create a session

const wide = new Wide(await ValSession.new(Deno.env.get("valtown")));

- Uses `NOTION_API_KEY`, `OPENAI_API_KEY` stored in env variables and uses [Valtown blob storage](https://esm.town/v/std/blob) to store information about the database.

import OpenAI from "npm:openai";

const oai = new OpenAI({

apiKey: process.env.OPENAI_API_KEY ?? undefined,

function createPrompt(title, description, properties) {

function processProperties(jsonObject) {

async function get_and_save_notion_db_processed_properties(databaseId)

async function get_notion_db_info(databaseId) {

async function get_and_save_notion_db_info(databaseId) {

function createZodSchema(filteredProps) {

function convertToNotionProperties(responseValues, filteredProps) {

import OpenAI from "npm:openai";

unless strictly necessary, for example use APIs that don't require a key, prefer internal function

functions where possible. Unless specified, don't add error handling,

The val should create a "export default async function main() {" which

is the main function that gets executed on every HTTP request.

function write(text) {

function updateValName(valName) {

function saveVal() {

function openTab(tab) {

function toggleTab() {

export async function val_Rb1F0hdOA9(req) {

try {

// Execute the code directly and capture its result

export function myApi(name) {

return "hi " + name;

Uses [Turso](https://turso.tech/) to search embeddings of all vals, using the [sqlite-vss](https://github.com/asg017/sqlite-vss) extension.

- Call OpenAI to generate an embedding for the search query.

- Query the `vss_vals_embeddings` table in Turso using `vss_search`.

import { db as allValsDb } from "https://esm.town/v/sqlite/db?v=9";

import OpenAI from "npm:openai";

export default async function semanticSearchPublicVals(query) {

const sqlite = createClient({

authToken: Deno.env.get("TURSO_AUTH_TOKEN_VALSEMBEDDINGS"),

const openai = new OpenAI();

const embedding = await openai.embeddings.create({

model: "text-embedding-3-small",

The QueryWriter class is a utility for generating and executing SQL queries using natural language and OpenAI. It provides a simplified interface for interacting with your Val Town SQLite database and generating SQL queries based on user inputs.

- `apiKey` (optional): An OpenAI API key. Defaults to `Deno.env.get("OPENAI_API_KEY")`.

import OpenAI from "npm:openai";

openai: OpenAI;

const { table, model, ...openaiOptions } = options;

// this.apiKey = openaiOptions.apiKey ? openaiOptions.apiKey : Deno.env.get("OPENAI_API_KEY");

this.openai = new OpenAI(openaiOptions);

const response = await this.openai.chat.completions.create({

throw new Error("No response from OpenAI");

throw new Error("No SQL returned from OpenAI. Try again.");

const response = await this.openai.chat.completions.create({

throw new Error("No response from OpenAI");

import { falProxyRequest } from "https://esm.town/v/stevekrouse/falProxyRequest";

function App() {

const [prompt, setPrompt] = useState("");

</div>

function client() {

createRoot(document.getElementById("root")).render(<App />);

if (typeof document !== "undefined") { client(); }

export default async function server(req: Request): Promise<Response> {

const url = new URL(req.url);