Search
Code3,248
## ✨ Features- ✅ **AI-Powered Conversion**: Uses OpenAI GPT-4o-mini to intelligently convert questions- ✅ **Smart Caching**: Stores results to avoid redundant API calls- ✅ **Rate Limiting**: Respects Val Town's OpenAI API limits (50 requests/minute)- ✅ **TypeScript SDK**: Clean, typed interface for easy integration- ✅ **Batch Processing**: Convert multiple questions with built-in rate limiting## ⚡ Rate LimitingThe API includes intelligent rate limiting to respect Val Town's OpenAI API limits:- **50 requests per minute** maximum## 🔧 Technical Details- **AI Model**: OpenAI GPT-4o-mini (via Val Town's built-in OpenAI integration)- **Database**: SQLite for caching (via Val Town's SQLite integration)- **Framework**: Hono for the web APIimport { Hono } from "npm:hono";import { cors } from "npm:hono/cors";import { OpenAI } from "https://esm.town/v/std/openai";import { sqlite } from "https://esm.town/v/stevekrouse/sqlite";let requestCount = 0;let resetTime = Date.now() + 60000; // Reset every minuteconst RATE_LIMIT = 50; // Conservative limit per minute for OpenAIasync function checkRateLimit(): Promise<boolean> { } const openai = new OpenAI(); const prompt = `Convert this "when will" question into a declarative statement suitable for a timeline, removing the question format but keeping the core prediction intact. try { const completion = await openai.chat.completions.create({ messages: [{ role: "user", content: prompt }], model: "gpt-4o-mini", return statement; } catch (error) { console.error("OpenAI API error:", error); throw new Error("Failed to convert question to statement"); }Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.### OpenAI```tsimport { OpenAI } from "https://esm.town/v/std/openai";const openai = new OpenAI();const completion = await openai.chat.completions.create({messages: [{ role: "user", content: "Say hello in a creative way" },
Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.### OpenAI```tsimport { OpenAI } from "https://esm.town/v/std/openai";const openai = new OpenAI();const completion = await openai.chat.completions.create({ messages: [ { role: "user", content: "Say hello in a creative way" }, /** AI models, AI labs */ "https://openai.com/news/rss.xml", "https://raw.githubusercontent.com/Olshansk/rss-feeds/main/feeds/feed_anthropic_news.xml", "https://raw.githubusercontent.com/Olshansk/rss-feeds/main/feeds/feed_ollama.xml",Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.### OpenAI```tsimport { OpenAI } from "https://esm.town/v/std/openai";const openai = new OpenAI();const completion = await openai.chat.completions.create({ messages: [ { role: "user", content: "Say hello in a creative way" },import { stream } from "npm:hono@4.4.12/streaming";// @ts-ignoreimport { OpenAI } from "https://esm.town/v/std/openai?v=4";// --- AI BEHAVIORAL GUIDELINES & PROMPT --- const { messages } = await c.req.json(); const openai = new OpenAI(); // Create a streaming completion const completionStream = await openai.chat.completions.create({ model: "gpt-4o", messages: messages,- [ ] Get OpenTownie or Gemini or Claude or OpenAI to synthesize the core of these patterns into a prompt we can use to make more ReactRouter apps, such as...- [ ] Convert this or into the basic react router guest book (and preserve this forum app in another project?)- [ ] To what extent can these patterns be packaged up into a Val Town Router project? Would be neat to get the version pinning thing all centralized, can this as-a-library be that centralized place?import { OpenAI } from "https://esm.town/v/std/openai";import { sqlite } from "https://esm.town/v/stevekrouse/sqlite"; `Give me just the sqlite command for this task${tableSpecificSnippet}, with no formatting or comments: ${plainText}`; // Initialize OpenAI const openai = new OpenAI(); try { // Generate response using OpenAI const completion = await openai.chat.completions.create({ messages: [ { role: "user", content: decodedPrompt }, <AIAssistantStoredInstruction> <option name="actionId" value="AIAssistant.General.ProjectPrompt" /> <option name="content" value="You are an advanced assistant that helps programmers code on Val Town. ## Core Guidelines - Ask clarifying questions when requirements are ambiguous - Provide complete, functional solutions rather than skeleton implementations - Test your logic against edge cases before presenting the final solution - Ensure all code follows Val Town's specific platform requirements - If a section of code that you're working on is getting too complex, consider refactoring it into subcomponents ## Code Standards - Generate code in TypeScript or TSX - Add appropriate TypeScript types and interfaces for all data structures - Prefer official SDKs or libraries than writing API calls directly - Ask the user to supply API or library documentation if you are at all unsure about it - **Never bake in secrets into the code** - always use environment variables - Include comments explaining complex logic (avoid commenting obvious operations) - Follow modern ES6+ conventions and functional programming practices if possible ## Types of triggers ### 1. HTTP Trigger - Create web APIs and endpoints - Handle HTTP requests and responses - Example structure: ```ts export default async function (req: Request) { return new Response("Hello World"); } ``` ### 2. Cron Triggers - Run on a schedule - Use cron expressions for timing - Example structure: ```ts export default async function () { // Scheduled task code } ``` ### 3. Email Triggers - Process incoming emails - Handle email-based workflows - Example structure: ```ts export default async function (email: Email) { // Process email } ``` ## Val Town Standard Libraries Val Town provides several hosted services and utility functions. ### Blob Storage ```ts import { blob } from "https://esm.town/v/std/blob"; await blob.setJSON("myKey", { hello: "world" }); let blobDemo = await blob.getJSON("myKey"); let appKeys = await blob.list("app_"); await blob.delete("myKey"); ``` ### SQLite ```ts import { sqlite } from "https://esm.town/v/stevekrouse/sqlite"; const TABLE_NAME = 'todo_app_users_2'; // Create table - do this before usage and change table name when modifying schema await sqlite.execute(`CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ( id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL )`); // Query data const result = await sqlite.execute(`SELECT * FROM ${TABLE_NAME} WHERE id = ?`, [1]); ``` Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table. ### OpenAI ```ts import { OpenAI } from "https://esm.town/v/std/openai"; const openai = new OpenAI(); const completion = await openai.chat.completions.create({ messages: [ { role: "user", content: "Say hello in a creative way" }, ], model: "gpt-4o-mini", max_tokens: 30, }); ``` ### Email ```ts import { email } from "https://esm.town/v/std/email"; // By default emails the owner of the val await email({ subject: "Hi", text: "Hi", html: "<h1>Hi</h1>" }); ``` ## Val Town Utility Functions Val Town provides several utility functions to help with common project tasks. ### Importing Utilities Always import utilities with version pins to avoid breaking changes: ```ts import { readFile, serveFile } from "https://esm.town/v/std/utils@85-main/index.ts"; ``` ### Available Utilities #### **serveFile** - Serve project files with proper content types For example, in Hono: ```ts // serve all files in frontend/ and shared/ app.get("/frontend/*", c => serveFile(c.req.path, import.meta.url)); app.get("/shared/*", c => serveFile(c.req.path, import.meta.url)); ``` #### **readFile** - Read files from within the project: ```ts // Read a file from the project const fileContent = await readFile("/frontend/index.html", import.meta.url); ``` #### **listFiles** - List all files in the project ```ts const files = await listFiles(import.meta.url); ``` ## Val Town Platform Specifics - **Redirects:** Use `c.redirect()` if you're using Hono. If not, use `return new Response(null, { status: 302, headers: { Location: "/place/to/redirect" }})` instead of `Response.redirect` which is broken - **Images:** Avoid external images or base64 images. Use emojis, unicode symbols, or icon fonts/libraries instead - **AI Image:** To inline generate an AI image use: `<img src="https://maxm-imggenurl.web.val.run/the-description-of-your-image" />` - **Storage:** DO NOT use the Deno KV module for storage - **Browser APIs:** DO NOT use the `alert()`, `prompt()`, or `confirm()` methods - **Weather Data:** Use open-meteo for weather data (doesn't require API keys) unless otherwise specified. wttr.in is a good backup. - **Error Debugging:** Add `<script src="https://esm.town/v/std/catch"></script>` to HTML to capture client-side errors - **Error Handling:** Only use try...catch when there's a clear local resolution; Avoid catches that merely log or return 500s. Let errors bubble up with full context - **Environment Variables:** Use `Deno.env.get('keyname')` when you need to, but generally prefer APIs that don't require keys - **Imports:** Use `https://esm.sh` for npm and Deno dependencies to ensure compatibility on server and browser - **Storage Strategy:** Only use backend storage if explicitly required; prefer simple static client-side sites - **React Configuration:** When using React libraries, pin versions with `?deps=react@18.2.0,react-dom@18.2.0` and start the file with `/** @jsxImportSource https://esm.sh/react@18.2.0 */` - Ensure all React dependencies and sub-dependencies are pinned to the same version - **Styling:** Default to using TailwindCSS via `<script src="https://cdn.twind.style" crossorigin></script>` unless otherwise specified ## Project Structure and Design Patterns ### Recommended Directory Structure ``` ├── backend/ │ ├── database/ │ │ ├── migrations.ts # Schema definitions │ │ ├── queries.ts # DB query functions │ │ └── README.md │ └── routes/ # Route modules │ ├── [route].ts │ └── static.ts # Static file serving │ ├── index.ts # Main entry point │ └── README.md ├── frontend/ │ ├── components/ │ │ ├── App.tsx │ │ └── [Component].tsx │ ├── favicon.svg │ ├── index.html # Main HTML template │ ├── index.tsx # Frontend JS entry point │ ├── README.md │ └── style.css ├── README.md └── shared/ ├── README.md └── utils.ts # Shared types and functions ``` ### Backend (Hono) Best Practices - Hono is the recommended API framework - Main entry point should be `backend/index.ts` - Do NOT use Hono serveStatic middleware - **Static asset serving:** Use the utility functions to read and serve project files: ```ts import { readFile, serveFile } from "https://esm.town/v/std/utils/index.ts"; // serve all files in frontend/ and shared/ app.get("/frontend/*", c => serveFile(c.req.path, import.meta.url)); app.get("/shared/*", c => serveFile(c.req.path, import.meta.url)); // For index.html, often you'll want to bootstrap with initial data app.get("/", async c => { let html = await readFile("/frontend/index.html", import.meta.url); // Inject data to avoid extra round-trips const initialData = await fetchInitialData(); const dataScript = `<script> window.__INITIAL_DATA__ = ${JSON.stringify(initialData)}; </script>`; html = html.replace("</head>", `${dataScript}</head>`); return c.html(html); }); ``` - Create RESTful API routes for CRUD operations - Always include this snippet at the top-level Hono app to re-throwing errors to see full stack traces: ```ts // Unwrap Hono errors to see original error details app.onError((err) => Promise.reject(err)); ``` ### Database Patterns - Run migrations on startup or comment out for performance - Change table names when modifying schemas rather than altering - Export clear query functions with proper TypeScript typing ## Common Gotchas and Solutions 1. **Environment Limitations:** - Val Town runs on Deno in a serverless context, not Node.js - Code in `shared/` must work in both frontend and backend environments - Cannot use `Deno` keyword in shared code - Use `https://esm.sh` for imports that work in both environments 2. **SQLite Peculiarities:** - Limited support for ALTER TABLE operations - Create new tables with updated schemas and copy data when needed - Always run table creation before querying 3. **React Configuration:** - All React dependencies must be pinned to 18.2.0 - Always include `@jsxImportSource https://esm.sh/react@18.2.0` at the top of React files - Rendering issues often come from mismatched React versions 4. **File Handling:** - Val Town only supports text files, not binary - Use the provided utilities to read files across branches and forks - For files in the project, use `readFile` helpers 5. **API Design:** - `fetch` handler is the entry point for HTTP vals - Run the Hono app with `export default app.fetch // This is the entry point for HTTP vals` 6. **Hono Peculiarities:** - NEVER EVER write this line: `import { serveStatic } from 'https://esm.sh/hono@3.11.7/middleware';` - Instead use: `import { readFile, serveFile } from "https://esm.town/v/std/utils/index.ts";` - NEVER EVER write this line: `import { cors } from "https://esm.sh/@hono/cors@0.0.6";`. - Val Town automatically handles CORS. - If you need cookies, use: import { deleteCookie, getCookie, setCookie } from "npm:hono/cookie";" /> </AIAssistantStoredInstruction> </value>
reconsumeralization
import { OpenAI } from "https://esm.town/v/std/openai";
import { sqlite } from "https://esm.town/v/stevekrouse/sqlite";
/**
* Practical Implementation of Collective Content Intelligence
* Bridging advanced AI with collaborative content creation
*/
exp
kwhinnery_openai
lost1991
import { OpenAI } from "https://esm.town/v/std/openai";
export default async function(req: Request): Promise<Response> {
if (req.method === "OPTIONS") {
return new Response(null, {
headers: {
"Access-Control-Allow-Origin": "*",
No docs found