Val Town Code SearchReturn to Val Town

12
13Frontend: React 18, TailwindCSS
14APIs: Open-Meteo, OpenAI GPT-4o
15Hosting: ESM-based module imports

360
361export default async function server(request: Request): Promise<Response> {
362  const { OpenAI } = await import("https://esm.town/v/std/openai");
363
364  // Enhanced server-side logging
375  }
376
377  const openai = new OpenAI();
378
379  const url = new URL(request.url);
421
422      // Call AgentA to create the tool definition
423      const agentACompletion = await openai.chat.completions.create({
424        model: "gpt-4o-mini",
425        response_format: { type: "json_object" },
470      `;
471
472      const agentBCompletion = await openai.chat.completions.create({
473        model: "gpt-4o-mini",
474        response_format: { type: "json_object" },
519      });
520
521      // Use AgentB (a separate OpenAI instance) to process the tool request
522      const agentBPrompt = `
523        You are AgentB, a specialized tool agent designed to process specific information requests.
538      `;
539
540      const agentBCompletion = await openai.chat.completions.create({
541        model: "gpt-4o-mini",
542        response_format: { type: "json_object" },
582      });
583
584      // Fallback response if OpenAI fails
585      let agentAResponse: AgentResponse = {
586        actionType: "direct_response",
627        `;
628
629        const agentACompletion = await openai.chat.completions.create({
630          model: "gpt-4o-mini",
631          response_format: { type: "json_object" },

6    "description": "A sample blah manifest demonstrating various tool types and configurations.",
7    "env": {
8      "OPENAI_API_KEY": Deno.env.get("OPENAI_API_KEY"),
9    },
10    "tools": [

1import { openai } from "npm:@ai-sdk/openai";
2import { generateText } from "npm:ai";
3
8  try {
9    const { text: fact } = await generateText({
10      model: openai("gpt-4o-mini"),
11      system: "You are an expert in conspiracy.",
12      prompt: `Provide an interesting conspiracy for fun`,

askSMHIREADME.md4 matches

@ljus•Updated 1 month ago

1# askSMHI
2Using OpenAI chat completion with function calls to [SMHI](https://en.wikipedia.org/wiki/Swedish_Meteorological_and_Hydrological_Institute) api
3
4The API is instructed to use the current time in Europe/Stockholm timezone. 
8## Relevant API documentation
9* [SMHI, forecast  documentation](https://opendata.smhi.se/apidocs/metfcst/get-forecast.html)
10* [OPEN AI, GPT function calling  documentation](https://platform.openai.com/docs/guides/function-calling?api-mode=chat&lang=javascript)
11
12## How to use this endpoint
41
42## Enviroment variables
43* OPENAI_CHAT: Needs to be authorized to write chat completions and to the moderation API.
44## Packages used
45* openai: For typesafe API request and responses
46* valibot: for describing the SMHI API response and function API input
47* valibot/to-json-schema: Transform the schema to json schema (readable by the GPT API)

askSMHIservice6 matches

@ljus•Updated 1 month ago

3import { offset, removeOffset } from "npm:@formkit/tempo";
4import { isWithinTokenLimit } from "npm:gpt-tokenizer/model/gpt-4o";
5import { OpenAI } from "npm:openai";
6import * as v from "npm:valibot";
7import { openAIModeration } from "./gpt/moderation";
8import { getWeatherAtCoordinate } from "./smhi/forecast/service";
9import { getSmhiForecastResponseZodSchema } from "./smhi/schema";
18    return { error: "Too many tokens in question" };
19  }
20  const { flagged } = await openAIModeration([question]);
21  if (flagged) {
22    return { error: "Be nice in your question" };
42    }[],
43  };
44  const openai = new OpenAI({ apiKey: process.env.OPENAI_CHAT });
45
46  const completion = await openai.chat.completions.create({
47    model: completionOptions.model,
48    store: completionOptions.store,
130    }]
131    : [];
132  const formattedFunctionResponseData = await openai.chat.completions.create({
133    model: completionOptions.model,
134    store: completionOptions.store,

askSMHImoderation6 matches

@ljus•Updated 1 month ago

1import { fetch } from "https://esm.town/v/std/fetch";
2import process from "node:process";
3import { OpenAI } from "npm:openai";
4
5export async function openAIModeration(publicMessages: string[]) {
6  const openAIKey = process.env.OPENAI_CHAT;
7  const headers = {
8    "Content-Type": "application/json",
9    Authorization: `Bearer ${openAIKey}`,
10  };
11  const openai = new OpenAI({ apiKey: process.env.OPENAI_CHAT });
12  const responseData = await openai.moderations.create({ input: publicMessages });
13  return { flagged: responseData.results.some((r) => r.flagged) };
14}

2import process from "node:process";
3import { marked } from "npm:marked";
4import { OpenAI } from "npm:openai";
5
6function pm(...lines: string[]): string {
16  );
17
18  const client = new OpenAI({ apiKey: process.env.PERPLEXITY_API_KEY, baseURL: "https://api.perplexity.ai" });
19  const response = await client.chat.completions.create({
20    model: "sonar",

6    "description": "A sample blah manifest demonstrating various tool types and configurations.",
7    "env": {
8      "OPENAI_API_KEY": Deno.env.get("OPENAI_API_KEY"),
9    },
10    "tools": [

2 * This is a Townie clone for Val Town.
3 * It creates a chat interface that helps users generate Val Town applications.
4 * Uses OpenAI's API to generate code responses in the proper format.
5 */
6/** @jsxImportSource https://esm.sh/react@18.2.0 */
91If you are changing a SQLite table's schema, you should also change the table's name so it creates a fresh table, ie by adding _2 or _3 after it everywhere. Ensure that tables are created before they are used.
92
93OPENAI
94
95Val Town includes a free, proxied OpenAI:
96
97import { OpenAI } from "https://esm.town/v/std/openai";
98const openai = new OpenAI();
99const completion = await openai.chat.completions.create({
100  messages: [
101    { role: "user", content: "Say hello in a creative way" },
176): Promise<string> {
177  try {
178    // Try using the proxied OpenAI first, if that fails, fall back to direct API call
179    try {
180      return await processWithValTownOpenAI(messages, systemPrompt, stream);
181    } catch (error) {
182      console.error("Error with Val Town OpenAI:", error);
183      console.log("Falling back to direct OpenAI API call");
184      return await processWithDirectOpenAI(messages, systemPrompt, stream);
185    }
186  } catch (error) {
191
192/**
193 * Process chat using Val Town's proxied OpenAI
194 */
195async function processWithValTownOpenAI(
196  messages: Message[],
197  systemPrompt: string,
199): Promise<string> {
200  try {
201    const { OpenAI } = await import("https://esm.town/v/std/openai");
202    const openai = new OpenAI();
203    
204    // Prepare the messages array with system prompt
205    const openaiMessages = [
206      { role: "system", content: systemPrompt },
207      ...messages.map(m => ({ role: m.role, content: m.content }))
208    ];
209    
210    console.log("Sending to Val Town OpenAI:", { 
211      messageCount: openaiMessages.length,
212      firstUserMessage: messages[0]?.content?.substring(0, 20) + "..." 
213    });
215    // If streaming is not required, get a complete response
216    if (!stream) {
217      const completion = await openai.chat.completions.create({
218        messages: openaiMessages,
219        model: "gpt-4o-mini", // Using Val Town's available model
220        temperature: 0.7,
223      return completion.choices[0]?.message?.content || "Sorry, I couldn't generate a response.";
224    } else {
225      // Streaming is not directly supported by Val Town OpenAI wrapper
226      // Falling back to direct API
227      throw new Error("Streaming not supported by Val Town OpenAI wrapper");
228    }
229  } catch (error) {
230    console.error("Error in processWithValTownOpenAI:", error);
231    throw error;
232  }
234
235/**
236 * Process chat using direct OpenAI API
237 */
238async function processWithDirectOpenAI(
239  messages: Message[],
240  systemPrompt: string,
242): Promise<string> {
243  // Get API key from environment
244  const apiKey = Deno.env.get("OPENAI_API_KEY");
245  
246  if (!apiKey) {
247    throw new Error("OpenAI API Key not found. Please set the OPENAI_API_KEY environment variable.");
248  }
249  
250  // Format messages for OpenAI API
251  const openaiMessages = [
252    { role: "system", content: systemPrompt },
253    ...messages.map(m => ({ role: m.role, content: m.content }))
254  ];
255  
256  console.log("Sending to Direct OpenAI:", { 
257    messageCount: openaiMessages.length,
258    firstUserMessage: messages[0]?.content?.substring(0, 20) + "..." 
259  });
261  if (stream) {
262    // Stream the response if a stream is provided
263    return await streamChatResponse(openaiMessages, apiKey, stream);
264  } else {
265    // Otherwise, return the complete response
266    return await fetchChatResponse(openaiMessages, apiKey);
267  }
268}
269
270/**
271 * Fetch a complete chat response from OpenAI
272 */
273async function fetchChatResponse(messages: any[], apiKey: string): Promise<string> {
274  try {
275    const response = await fetch("https://api.openai.com/v1/chat/completions", {
276      method: "POST",
277      headers: {
288    if (!response.ok) {
289      const errorText = await response.text();
290      console.error("OpenAI API error response:", errorText);
291      try {
292        const errorData = JSON.parse(errorText);
293        throw new Error(`OpenAI API error: ${response.status} ${errorData.error?.message || errorText}`);
294      } catch (e) {
295        throw new Error(`OpenAI API error: ${response.status} ${errorText}`);
296      }
297    }
306
307/**
308 * Stream a chat response from OpenAI
309 */
310async function streamChatResponse(messages: any[], apiKey: string, stream: any): Promise<string> {
311  try {
312    const response = await fetch("https://api.openai.com/v1/chat/completions", {
313      method: "POST",
314      headers: {
326    if (!response.ok) {
327      const errorText = await response.text();
328      console.error("OpenAI API streaming error:", errorText);
329      throw new Error(`OpenAI API error: ${response.status} ${errorText}`);
330    }
331    
374    status: "ok", 
375    message: "Backend is working",
376    hasOpenAiKey: Boolean(Deno.env.get("OPENAI_API_KEY")),
377    hasValTownOpenAI: true
378  };
379});