Search

      }
      // Dynamically import OpenAI with error handling
      let OpenAI;
      try {
        const module = await import("https://esm.town/v/std/openai");
        OpenAI = module.OpenAI;
      } catch (importError) {
        console.error("OpenAI Import Error:", importError);
        return new Response(
          JSON.stringify({
            error: "Failed to import OpenAI module",
            details: String(importError),
          }),
      }
      // Ensure OpenAI is available
      if (!OpenAI) {
        return new Response(
          JSON.stringify({
            error: "OpenAI module not found",
          }),
          {
      }
      // Create OpenAI instance
      const openai = new OpenAI();
      // Create OpenAI completion with comprehensive error handling
      let completion;
      try {
        completion = await openai.chat.completions.create({
          messages: body.messages,
          model: "gpt-4o-mini",
        });
      } catch (completionError) {
        console.error("OpenAI Completion Error:", completionError);
        return new Response(
          JSON.stringify({

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 KEY = extractKey(new URL(import.meta.url));
  const SCHEMA_VERSION = 3; // Increment schema version for tool support
      // Call Maverick to create the tool definition
      const maverickCompletion = await openai.chat.completions.create({
        model: "gpt-4o-mini",
        response_format: { type: "json_object" },
      `;
      const oracleCompletion = await openai.chat.completions.create({
        model: "gpt-4o-mini",
        response_format: { type: "json_object" },
      `;
      const agentBCompletion = await openai.chat.completions.create({
        model: "gpt-4o-mini",
        response_format: { type: "json_object" },
      `;
      const agentBCompletion = await openai.chat.completions.create({
        model: "gpt-4o-mini",
        response_format: { type: "json_object" },
      // Make completion call with the appropriate agent prompt
      const analysisCompletion = await openai.chat.completions.create({
        model: "gpt-4o-mini",
        response_format: { type: "json_object" },
      // Make completion call with the appropriate agent prompt
      const agentCompletion = await openai.chat.completions.create({
        model: "gpt-4o-mini",
        response_format: { type: "json_object" },

import { sqlite } from "https://esm.town/v/stevekrouse/sqlite";
import OpenAI from "openai";
import { ITERATIONS_TABLE, KEY, PROJECTS_TABLE, SCHEMA_VERSION } from "./migrations";
const openai = new OpenAI({ apiKey: Deno.env.get("OPENAI_API_KEY") });
export async function createProject(prompt: string) {
}
// Example of using OpenAI (you'll need to adapt this to your specific use case)
export async function generateText(prompt: string) {
  try {
    const completion = await openai.chat.completions.create({
      messages: [{ role: "user", content: prompt }],
      model: "gpt-4-turbo-preview",
    return completion.choices[0].message?.content || "No response";
  } catch (error) {
    console.error("OpenAI Error:", error);
    return "Error generating text";
  }

import { sqlite } from "https://esm.town/v/stevekrouse/sqlite";
import OpenAI from "openai";
import { ITERATIONS_TABLE, KEY, PROJECTS_TABLE, SCHEMA_VERSION } from "./migrations";
const openai = new OpenAI({ apiKey: Deno.env.get("OPENAI_API_KEY") });
export async function createProject(prompt: string) {
}
// Example of using OpenAI (you'll need to adapt this to your specific use case)
export async function generateText(prompt: string) {
  try {
    const completion = await openai.chat.completions.create({
      messages: [{ role: "user", content: prompt }],
      model: "gpt-4-turbo-preview",
    return completion.choices[0].message?.content || "No response";
  } catch (error) {
    console.error("OpenAI Error:", error);
    return "Error generating text";
  }

import OpenAI from "openai";
import STARTER_PROMPTS from "../public/starter-prompts.js";
    };
  } else {
    const openai = new OpenAI({
      apiKey: Deno.env.get(
        "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",
      ),
    });
    const completion = await openai.chat.completions.create({
      messages: [
        {
        },
      ].filter(Boolean),
      model: "gpt-4-turbo-preview", // Or another suitable OpenAI model
      max_tokens: 2000, // Adjust as needed
    });
    return {
      code: extractCodeFromFence(completion.choices[0].message.content),
      time: 0, // OpenAI doesn't directly provide completion time
      totalTokens: completion.usage?.total_tokens || 1,
    };

export default async function server(request: Request): Promise<Response> {
  if (request.method === "POST" && new URL(request.url).pathname === "/chat") {
    const { OpenAI } = await import("https://esm.town/v/std/openai");
    const openai = new OpenAI();
    const { messages, rawInput } = await request.json();
    ];
    const stream = await openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: constrainedMessages,

    setIsLoading(true);
    try {
      const { OpenAI } = await import("https://esm.town/v/std/openai");
      const openai = new OpenAI();
      const analysisPrompt = `Comprehensive Medical Report Analysis:
Respond with a structured, compassionate, and informative analysis that prioritizes patient understanding and next steps.`;
      const analysis = await openai.chat.completions.create({
        model: "gpt-4o-mini",
        messages: [
export default async function server(request: Request): Promise<Response> {
  if (request.method === 'POST' && new URL(request.url).pathname === '/chat') {
    const { OpenAI } = await import("https://esm.town/v/std/openai");
    const openai = new OpenAI();
    const { messages } = await request.json();
    const stream = await openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: messages,

import { openai } from "npm:@ai-sdk/openai";
import { generateText } from "npm:ai";
  try {
    const { text: compliments } = await generateText({
      model: openai("gpt-4o-mini"),
      system: "You are a creative compliment generator.",
      prompt: "Generate 5 unique, thoughtful, and specific compliments about a person named Traves.",

import { openai } from "npm:@ai-sdk/openai";
import { generateText } from "npm:ai";

import { openai } from "npm:@ai-sdk/openai";
import { generateText } from "npm:ai";
    const { text: generatedCompliment } = await generateText({
      model: openai("gpt-4o-mini"),
      system: "You are a creative compliment generator.",
      prompt: `Generate a compliment for: ${compliment}`,