Val Town Code SearchReturn to Val Town

94Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.
95
96### OpenAI
97
98```ts
99import { OpenAI } from "https://esm.town/v/std/openai";
100const openai = new OpenAI();
101const completion = await openai.chat.completions.create({
102  messages: [
103    { role: "user", content: "Say hello in a creative way" },

300    { getRandomRegexExplanation, saveRegexExplanation, getRegexExplanationById },
301    ReactMarkdown,
302    { OpenAI },
303    { renderToString },
304    { jsx, jsxs, Fragment },
306    import("https://esm.town/v/stainless_em/brainrotdb"),
307    import("npm:react-markdown@7"),
308    import("https://esm.town/v/std/openai"),
309    import("npm:react-dom@19/server.browser"),
310    import("npm:react@19/jsx-runtime"),
336      }
337
338      const openai = new OpenAI();
339
340      const abortController = new AbortController();
341      const completion = await openai.chat.completions.create({
342        messages: [
343          {

6 * Users input their birth details, a sign to focus on, and a life domain.
7 * The backend then uses the "Astrologer Prompt" (a detailed system prompt)
8 * to query an OpenAI model, which generates a comprehensive astrological report.
9 *
10 * Core Logic:
13 * 2. Backend (Deno Val Function):
14 * - Receives these inputs.
15 * - Constructs a user message for the OpenAI API. This message includes
16 * the raw birth details, focus sign, domain, etc.
17 * - Uses the **ENTIRE** "Astrologer Prompt" (with {{sign}} and {{domain}}
18 * placeholders filled) as the system prompt for an OpenAI API call.
19 * - Calls a powerful OpenAI model (e.g., gpt-4o).
20 * - Receives the structured JSON astrological report from OpenAI.
21 * - Sends this report back to the client for display.
22 *
30 * May 28, 2025. The LLM primed by it is assumed to have access to or
31 * knowledge of transit data for this date.
32 * - OpenAI API Key: An `OPENAI_API_KEY` environment variable must be available
33 * in the Val Town environment for `std/openai` to work.
34 *
35 * Inspired by the structure of the "Goal-Oriented Multi-Agent Stock Analysis Val".
39
40// --- Imports ---
41import { OpenAI } from "https://esm.town/v/std/openai";
42// NOTE: Deno.env is used directly for environment variables.
43
55}
56
57// --- THE ASTROLOGER PROMPT (System Prompt for OpenAI) ---
58// This will be used by the backend to instruct the AI.
59// Placeholders {{sign}} and {{domain}} will be replaced dynamically.
411}
412
413// --- Helper Function: Call OpenAI API (Adapted - Robust error handling retained) ---
414async function callOpenAI(
415  systemPrompt: string,
416  userMessage: string,
422  // Simple hash for prompt might not be as useful if {{placeholders}} change content significantly.
423  // Consider logging snippet of system prompt if needed for debugging.
424  const logPrefix = `OpenAI Call [${callId}] (${model}, JSON: ${isJsonOutputRequired})`;
425  log(
426    `[INFO] ${logPrefix}: Initiating... System prompt (template used). User message snippet: ${
430
431  try {
432    const openai = new OpenAI(); // API Key from environment
433    const response = await openai.chat.completions.create({
434      model: model,
435      messages: [{ role: "system", content: systemPrompt }, { role: "user", content: userMessage }],
439    const content = response.choices?.[0]?.message?.content;
440    if (!content) {
441      log(`[ERROR] ${logPrefix}: OpenAI API returned unexpected or empty response structure.`);
442      throw new Error("Received invalid or empty response content from AI model.");
443    }
444    log(`[SUCCESS] ${logPrefix}: OpenAI call successful.`);
445    return { role: "assistant", content: content };
446  } catch (error) {
452
453    if (errorResponseData?.message) {
454      errorMessage = `OpenAI Error (${statusCode || "unknown status"}): ${errorResponseData.message}`;
455    } else if (errorResponseData?.error?.message) {
456      errorMessage = `OpenAI Error (${statusCode || "unknown status"}): ${errorResponseData.error.message}`;
457    }
458    // ... (retain other specific error message constructions from original Val)
486    .replace(new RegExp("{{domain}}", "g"), inputs.focusDomain);
487
488  // 2. Construct the User Message for the OpenAI API call
489  // The Astrologer Prompt expects `birth_chart_data`. We will pass raw birth details
490  // and let the LLM (primed with Astrologer Prompt) handle interpretation.
509  );
510
511  // 3. Call OpenAI
512  log("[STEP] Calling OpenAI with Astrologer Prompt...");
513  // Using gpt-4o as it's capable and the astrological prompt is complex.
514  // The ASTROLOGER_SYSTEM_PROMPT_TEMPLATE implies the model should generate JSON.
515  const aiResponse = await callOpenAI(populatedSystemPrompt, userMessageJson, "gpt-4o", true, log);
516
517  // 4. Parse and Return Result
522    // (e.g., if the AI itself couldn't perform the analysis and returned an error structure as per its instructions)
523    // The ASTROLOGER_SYSTEM_PROMPT_TEMPLATE does not explicitly define an error structure from the AI side,
524    // but callOpenAI returns its own {"error": "..."} if the call itself failed.
525    if (parsedAiResponse.error && aiResponse.role === "system") { // Error from callOpenAI wrapper
526      log(`[ERROR] OpenAI call wrapper reported an error: ${parsedAiResponse.error}`);
527      return { error: "Failed to get report from Astrologer AI.", details: parsedAiResponse.error };
528    }

100Note: When changing a SQLite table's schema, change the table's name (e.g., add _2 or _3) to create a fresh table.
101
102### OpenAI
103```ts
104import { OpenAI } from "https://esm.town/v/std/openai";
105const openai = new OpenAI();
106const completion = await openai.chat.completions.create({
107  messages: [
108    { role: "user", content: "Say hello in a creative way" },

1import { OpenAI } from "https://esm.town/v/std/openai";
2import type { LLMRequest, LLMResponse, SystemDesignRequest, SOARESystem, SystemComponent } from "../../../shared/types/core.ts";
3
4export class SOAREBrain {
5  private openai: OpenAI;
6  
7  constructor() {
8    this.openai = new OpenAI();
9  }
10
11  async reason(request: LLMRequest): Promise<LLMResponse> {
12    try {
13      const completion = await this.openai.chat.completions.create({
14        model: "gpt-4o",
15        messages: [

1import { OpenAI } from "https://esm.town/v/std/openai";
2import * as cheerio from "https://esm.sh/cheerio@1.0.0-rc.12";
3import { EarningOpportunity, WebPageContent, AnalysisResult } from "../shared/types.ts";
4
5const openai = new OpenAI();
6
7export async function analyzeWebPage(url: string, focus?: string): Promise<AnalysisResult> {
247
248  try {
249    const completion = await openai.chat.completions.create({
250      model: "gpt-4o-mini",
251      messages: [

7 * Uses 'npm:pdf.js-extract' for PDF extraction.
8 * Serves HTML UI & API endpoint from the same Val.
9 * Assumes 'openai' secret is set in Val Town environment variables.
10 *
11 * Last Updated: {{current_date}} (Templated Version)
18 * max_pdf_size_mb: {{max_pdf_size_mb}}, // e.g., 10
19 * text_truncation_length: {{text_truncation_length}}, // e.g., 25000
20 * openai_model_name: "{{openai_model_name}}", // e.g., "gpt-4o"
21 * contact_form_placeholders_en: { name: "Your Name", email: "Your Email", message: "Message" },
22 * contact_form_placeholders_es: { name: "Tu Nombre", email: "Tu Correo", message: "Mensaje" },
639export default async function(req: Request) {
640  // --- Dynamic Imports (Unchanged) ---
641  const { OpenAI } = await import("https://esm.town/v/std/openai");
642  // const { z } = await import("npm:zod"); // Zod might be optional if config is trusted
643  const { fetch } = await import("https://esm.town/v/std/fetch");
645
646  // --- CONFIGURATION (These would be replaced by the template variables at generation time) ---
647  const APP_CONFIG = `\{{\app_config_json}}`; // e.g., { openai_model_name: "gpt-4o", text_truncation_length: 25000, ... }
648  const ANALYSIS_AGENTS = `\{\{analysis_agents_json}}`; // Array of agent objects
649
651  async function extractPdfTextNative(data: ArrayBuffer, fileName: string, log: LogEntry[]): Promise<string | null> { /* ... original ... */ }
652
653  // --- Helper Function: Call OpenAI API (Uses APP_CONFIG for model) ---
654  async function callOpenAI(
655    openai: OpenAI,
656    systemPrompt: string,
657    userMessage: string,
658    modelFromConfig = APP_CONFIG.openai_model_name || "gpt-4o", // Use configured model
659    expectJson = false,
660  ): Promise<{ role: "assistant" | "system"; content: string | object }> {
661    /* ... original logic, but use modelFromConfig ... */
662    const model = modelFromConfig;
663    // ... rest of the original callOpenAI function
664     try {
665      const response = await openai.chat.completions.create({
666        model,
667        messages: [{ role: "system", content: systemPrompt }, { role: "user", content: userMessage }],
701    log: LogEntry[],
702  ): Promise<LogEntry[]> {
703    const openai = new OpenAI();
704    log.push({ agent: "System", type: "step", message: "Workflow started." });
705    // ... initial logging of input type ...
730      // If chaining is needed, {{previous_output}} could be another placeholder in prompts.
731
732      const agentResult = await callOpenAI(
733        openai,
734        agentSystemPrompt, // The agent's specific prompt
735        truncText, // User message is the doc text itself, or could be empty if prompt is self-contained
736        APP_CONFIG.openai_model_name,
737        agentConfig.expects_json
738      );
830 * 1. Define Application Configuration:
831 * Fill in the \`{{app_config_json}}\` placeholder with general settings for your app
832 * (e.g., OpenAI model, max file size, default language).
833 *
834 * 2. Define Analysis Agents:
836 * - `agent_id`: A unique machine-readable ID.
837 * - `agent_name_en`/`agent_name_es`: Human-readable names for UI and logs.
838 * - `system_prompt`: The OpenAI prompt for this agent. Can use `{{document_text}}`.
839 * - `expects_json`: Boolean, if the prompt asks OpenAI for JSON output.
840 * - `ui_display_info`: How to render this agent's results:
841 * - `card_title_en`/`card_title_es`: Title for the results card.
857 * and `{{app_config.document_format_accepted_label}}` (e.g. "PDF") for UI text.
858 *
859 * 5. OpenAI API Key:
860 * Ensure your environment (e.g., Val Town secrets) has the `OPENAI_API_KEY` (or the appropriate
861 * environment variable name for the `OpenAI` library) set.
862 *
863 * 6. Deployment:

74### Tech Stack
75- **Backend**: Hono.js for API routing
76- **AI**: OpenAI GPT-4o-mini for content analysis
77- **Web Scraping**: Cheerio for HTML parsing
78- **Frontend**: Vanilla JavaScript with TailwindCSS
91## 🔧 Environment Setup
92
93The analyzer uses OpenAI's API which is automatically configured in Val Town. No additional setup required!
94
95## 📊 What It Analyzes

1import { Hono } from "https://esm.sh/hono@3.11.7";
2import { OpenAI } from "https://esm.town/v/std/openai";
3import { readFile } from "https://esm.town/v/std/utils/index.ts";
4import { analyzeWebPage } from "./analyzer.ts";
111    }
112    
113    if (error.message.includes("OpenAI") || error.message.includes("API key")) {
114      return c.json({ error: "AI analysis service requires API key configuration. Please contact the administrator." }, 503);
115    }

4// SERVER-SIDE LOGIC (TypeScript)
5// =============================================================================
6import { OpenAI } from "https://esm.town/v/std/openai";
7
8// --- Configuration ---
23  maskSrc?: string;
24}
25interface OpenAIResponse {
26  races: RaceInfo[];
27}
105];
106
107// --- OpenAI Generation Function ---
108async function generateRaceDataWithOpenAI(): Promise<RaceInfo[]> {
109  const openai = new OpenAI();
110  const numToRequest = Math.max(1, NUM_CARDS_TO_GENERATE);
111  const prompt =
126Return STRICTLY as a single JSON object: { "races": [ { race1 }, { race2 }, ... ] }. No introductory text or explanations outside the JSON structure.`;
127  try {
128    console.info(`Requesting ${numToRequest} race data generation from OpenAI...`);
129    const completion = await openai.chat.completions.create({
130      model: "gpt-4o",
131      messages: [{ role: "user", content: prompt }],
134    });
135    const rawContent = completion.choices[0]?.message?.content;
136    if (!rawContent) throw new Error("OpenAI returned an empty response message.");
137
138    let parsedJson;
140      parsedJson = JSON.parse(rawContent);
141    } catch (parseError) {
142      console.error("Failed to parse OpenAI JSON response:", parseError);
143      console.error("Raw OpenAI response:", rawContent);
144      throw new Error(`JSON Parsing Error: ${parseError.message}`);
145    }
160    ) {
161      console.warn(
162        `OpenAI response JSON failed validation for ${numToRequest} races:`,
163        JSON.stringify(parsedJson, null, 2),
164      );
165      throw new Error(
166        "OpenAI response JSON structure, count, data types, color format, hint value, or mask URL invalid.",
167      );
168    }
169
170    const generatedData = (parsedJson as OpenAIResponse).races.map(race => ({
171      ...race,
172      borderAnimationHint: race.borderAnimationHint || "none",
173    }));
174    console.info(`Successfully generated and validated ${generatedData.length} races from OpenAI.`);
175    return generatedData;
176  } catch (error) {
177    console.error("Error fetching or processing data from OpenAI:", error);
178    console.warn("Using fallback race data due to the error.");
179    return fallbackRaceData.slice(0, numToRequest).map(race => ({
186// --- Main HTTP Handler (Val Town Entry Point) ---
187export default async function server(request: Request): Promise<Response> {
188  const activeRaceData = await generateRaceDataWithOpenAI();
189
190  const css = `