Search

import { Hono } from "npm:hono@4.4.12";
import { OpenAI } from "https://esm.town/v/std/openai";
import type { Context } from "npm:hono@4.4.12";
import { streamText } from "npm:hono@4.4.12/streaming";
/**
 * 3. OpenAI Call Tool (Streaming and Non-Streaming)
 * This single function handles both modes.
 */
async function handleOpenAICall(
  payload: {
    messages: any[];
): Promise<any> {
  const { messages, model = "gpt-4o-mini", stream, ...rest } = payload;
  log("INFO", `Making OpenAI call to ${model}`, { stream, messages });
  try {
    const openai = new OpenAI();
    // Non-streaming call (default)
    if (!stream) {
      const completion = await openai.chat.completions.create({
        model,
        messages,
        ...rest,
      });
      log("SUCCESS", "OpenAI non-streaming call successful.");
      return completion;
    }
    // here for completeness, but the router will call streamText directly.
    log("INFO", "Preparing for streaming call...");
    return await openai.chat.completions.create({
      model,
      messages,
    });
  } catch (e) {
    log("ERROR", "OpenAI API call failed.", e.message);
    throw e;
  }
  "http_fetch": handleHttpFetch,
  "run_script": handleRunScript,
  "openai_call": handleOpenAICall,
};
          "id": "generate_summary",
          "description": "Summarize package (Streaming)",
          "endpoint": "/api/tools/openai_call",
          "inputs": {
            "messages": [
          "id": "generate_questions",
          "description": "Generate follow-up questions (JSON)",
          "endpoint": "/api/tools/openai_call",
          "inputs": {
            "messages": [
                    };
                    const isStreaming = step.endpoint === "/api/tools/openai_call" && resolvedInputs.stream === true;
                    
                    const response = await fetch(step.endpoint, {
                        }
                        
                        // Mock an OpenAI payload structure so the output mapping works
                        rawResultPayload = { 
                          choices: [{ message: { content: fullStreamedResponse } }] 
  try {
    // *** SPECIAL CASE: STREAMING OPENAI CALL ***
    if (toolName === "openai_call" && payload.stream === true) {
      const stream = await handleOpenAICall(payload, log);
      // Return the stream directly to the client
      return streamText(c, async (s) => {

_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" },

// - Serves the client-side orchestrator HTML/JS (from "first" file)
// - Exposes all tools and custom functions (from "first" file) via a Hono route
// - Adds streaming capability to the 'openai_call' endpoint (from "second" file)
import { Hono } from "npm:hono@4.4.12";
import type { Context } from "npm:hono@4.4.12";
import { fetch } from "https://esm.town/v/std/fetch";
import { OpenAI } from "https://esm.town/v/std/openai";
// --- COMMON TYPES (from "first" file) ---
  timestamp: string;
  level: LogLevel;
  component: string; // e.g., "Tool:OpenAI", "CustomFunc:ValidateData"
  message: string;
  details?: string; // Stringified JSON for complex objects
}
// 2. OpenAI Call Tool Endpoint (NON-STREAMING version)
// This is the original function from "first", renamed.
// It's called by the router when payload.stream is NOT true.
async function handleOpenAICall_nonStreaming(
  reqPayload: {
    messages: Array<{ role: "system" | "user" | "assistant"; content: string }>;
    max_tokens,
  } = reqPayload;
  logger.log("INFO", `Making NON-STREAMING OpenAI call to ${model}`, {
    messageCount: messages.length,
  });
  try {
    const openai = new OpenAI(); // Assumes OPENAI_API_KEY is in environment
    const completion = await openai.chat.completions.create({
      model,
      messages,
      stream: false, // Explicitly false
    });
    logger.log("SUCCESS", "OpenAI call successful.", {
      modelUsed: completion.model,
    });
    return completion;
  } catch (e: any) {
    logger.log("ERROR", "OpenAI API call failed.", e);
    throw e;
  }
        {
          "id": "clean_petal_width_llm",
          "endpoint": "/api/tools/openai_call",
          "description": "LLM cleaning for 'petal.width'",
          "inputs": { 
        {
          "id": "insights_llm",
          "endpoint": "/api/tools/openai_call",
          "description": "Get LLM insights on summary",
          "inputs": {
* Main API Router
* Replicates the single router function from "first" file, but using Hono.
* Adds streaming logic for 'openai_call'.
----------------------------------------- */
app.post("/api/:endpointType/:endpointName", async (c: Context) => {
  try {
    // *** SPECIAL CASE: STREAMING OPENAI CALL ***
    // This logic is from the "second" file, integrated here.
    if (
      endpointType === "tools" &&
      endpointName === "openai_call" &&
      payload.stream === true
    ) {
      logger.log("INFO", "Handling as STREAMING OpenAI call.", payload);
      const { messages, model, ...rest } = payload;
      const openai = new OpenAI();
      const completionStream = await openai.chat.completions.create({
        model: model || "gpt-4o-mini",
        messages,
          responsePayload = await handleHttpFetch(payload, logger);
          break;
        case "openai_call":
          // Calls the non-streaming version
          responsePayload = await handleOpenAICall_nonStreaming(
            payload,
            logger,

    "https://kill-the-newsletter.com/feeds/sqpw3htkhocwl299i9t8.xml"
  ],
  ["openaiNews", ["AI"], "https://openai.com/news/rss.xml"],
  [
    "anthropicNews",

        } // 🤖 Détection IA (ChatGPT, Perplexity, Copilot, Gemini, etc.)
        else if (
          /(chat\.openai\.com|perplexity\.ai|claude\.ai|bard\.google\.com|gemini\.google\.com|you\.com|copilot\.microsoft\.com|chat\.bing\.com|huggingface\.co)/i
            .test(ref)
        ) {

_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" },

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" },

_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" },

const REALTIME_BASE_URL = "https://api.openai.com/v1/realtime";
const OPENAI_API_KEY = Deno.env.get("OPENAI_API_KEY");
if (!OPENAI_API_KEY) {
  throw new Error("🔴 OpenAI API key not configured");
}
export function makeHeaders(contentType?: string) {
  const obj: Record<string, string> = {
    Authorization: `Bearer ${OPENAI_API_KEY}`,
  };
  if (contentType) obj["Content-Type"] = contentType;

sip.post("/", async (c) => {
  // Verify the webhook.
  const OPENAI_SIGNING_SECRET = Deno.env.get("OPENAI_SIGNING_SECRET");
  if (!OPENAI_SIGNING_SECRET) {
    console.error("🔴 webhook secret not configured");
    return c.text("Internal error", 500);
  }
  const webhook = new Webhook(OPENAI_SIGNING_SECRET);
  const bodyStr = await c.req.text();
  let callId: string | undefined;