whale-code 6.5.5 → 6.5.6

package/dist/server/providers/openai.js

@@ -11,6 +11,7 @@
  * Phase 7.1: Also encapsulates thinking config, context management,
  * output token limits, and compaction config for OpenAI models.
  */
+
 import { randomUUID } from "node:crypto";
 import OpenAI from "openai";
 import { sanitizeError } from "../../shared/agent-core.js";
@@ -21,18 +22,21 @@ import { jsonResponse, writeSSEHeaders, emitError, resolveProviderCredentials }
 // ============================================================================
 // CONSTANTS — OpenAI-specific model config
 // ============================================================================
+
 const DEFAULT_OUTPUT_TOKENS = 16384;
 const MODEL_MAX_OUTPUT_TOKENS = {
-    "gpt-5": 128000,
-    "gpt-5-mini": 128000,
-    "gpt-5-nano": 128000,
-    "o3": 100000,
-    "o4-mini": 100000,
-    "gpt-4o": 16384,
+  "gpt-5": 128000,
+  "gpt-5-mini": 128000,
+  "gpt-5-nano": 128000,
+  "o3": 100000,
+  "o4-mini": 100000,
+  "gpt-4o": 16384
 };
+
 // ============================================================================
 // MESSAGE CONVERSION
 // ============================================================================
+
 /**
  * Convert Anthropic messages to OpenAI Responses API input format.
  *
@@ -44,479 +48,609 @@ const MODEL_MAX_OUTPUT_TOKENS = {
  * - call_id is used directly (no ID mapping needed)
  */
 function anthropicToResponsesInput(messages) {
-    // Pass 1: collect all tool_use call_ids so we can match function_call_output items
-    const knownCallIds = new Set();
-    for (const msg of messages) {
-        if (msg.role === "assistant" && Array.isArray(msg.content)) {
-            for (const block of msg.content) {
-                if (block.type === "tool_use" && block.id && block.name) {
-                    knownCallIds.add(block.id);
-                }
-            }
+  // Pass 1: collect all tool_use call_ids so we can match function_call_output items
+  const knownCallIds = new Set();
+  for (const msg of messages) {
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_use" && block.id && block.name) {
+          knownCallIds.add(block.id);
         }
+      }
     }
-    // Pass 2: build input array
-    const input = [];
-    for (const msg of messages) {
-        if (msg.role === "user") {
-            if (typeof msg.content === "string") {
-                input.push({ role: "user", content: msg.content });
-            }
-            else if (Array.isArray(msg.content)) {
-                const contentParts = [];
-                for (const block of msg.content) {
-                    if (block.type === "tool_result" && block.tool_use_id) {
-                        // Only emit if there's a matching function_call (prevents orphaned outputs after compaction)
-                        if (knownCallIds.has(block.tool_use_id)) {
-                            let output = "";
-                            if (typeof block.content === "string") {
-                                output = block.content;
-                            }
-                            else if (Array.isArray(block.content)) {
-                                output = block.content
-                                    .filter((c) => c.type === "text")
-                                    .map((c) => c.text)
-                                    .join("\n");
-                            }
-                            input.push({
-                                type: "function_call_output",
-                                call_id: block.tool_use_id,
-                                output: output || "(no output)",
-                            });
-                        }
-                    }
-                    else if (block.type === "text" && block.text) {
-                        contentParts.push({ type: "input_text", text: block.text });
-                    }
-                    else if (block.type === "image" && block.source?.data) {
-                        contentParts.push({
-                            type: "input_image",
-                            image_url: `data:${block.source.media_type};base64,${block.source.data}`,
-                        });
-                    }
-                }
-                // Emit content parts as user message
-                if (contentParts.length === 1 && contentParts[0].type === "input_text") {
-                    input.push({ role: "user", content: contentParts[0].text });
-                }
-                else if (contentParts.length > 0) {
-                    input.push({ role: "user", content: contentParts });
-                }
+  }
+
+  // Pass 2: build input array
+  const input = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        input.push({
+          role: "user",
+          content: msg.content
+        });
+      } else if (Array.isArray(msg.content)) {
+        const contentParts = [];
+        for (const block of msg.content) {
+          if (block.type === "tool_result" && block.tool_use_id) {
+            // Only emit if there's a matching function_call (prevents orphaned outputs after compaction)
+            if (knownCallIds.has(block.tool_use_id)) {
+              let output = "";
+              if (typeof block.content === "string") {
+                output = block.content;
+              } else if (Array.isArray(block.content)) {
+                output = block.content.filter(c => c.type === "text").map(c => c.text).join("\n");
+              }
+              input.push({
+                type: "function_call_output",
+                call_id: block.tool_use_id,
+                output: output || "(no output)"
+              });
             }
+          } else if (block.type === "text" && block.text) {
+            contentParts.push({
+              type: "input_text",
+              text: block.text
+            });
+          } else if (block.type === "image" && block.source?.data) {
+            contentParts.push({
+              type: "input_image",
+              image_url: `data:${block.source.media_type};base64,${block.source.data}`
+            });
+          }
         }
-        else if (msg.role === "assistant") {
-            if (typeof msg.content === "string") {
-                input.push({ role: "assistant", content: msg.content });
-            }
-            else if (Array.isArray(msg.content)) {
-                let textContent = "";
-                for (const block of msg.content) {
-                    if (block.type === "text" && block.text) {
-                        textContent += block.text;
-                    }
-                    else if (block.type === "tool_use" && block.name) {
-                        // Emit accumulated text as assistant message first
-                        if (textContent) {
-                            input.push({ role: "assistant", content: textContent });
-                            textContent = "";
-                        }
-                        // Emit function_call as top-level input item
-                        input.push({
-                            type: "function_call",
-                            call_id: block.id || `call_${randomUUID().slice(0, 12)}`,
-                            name: block.name,
-                            arguments: JSON.stringify(block.input || {}),
-                        });
-                    }
-                    // Skip thinking/compaction blocks — not relevant for OpenAI
-                }
-                if (textContent) {
-                    input.push({ role: "assistant", content: textContent });
-                }
+
+        // Emit content parts as user message
+        if (contentParts.length === 1 && contentParts[0].type === "input_text") {
+          input.push({
+            role: "user",
+            content: contentParts[0].text
+          });
+        } else if (contentParts.length > 0) {
+          input.push({
+            role: "user",
+            content: contentParts
+          });
+        }
+      }
+    } else if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        input.push({
+          role: "assistant",
+          content: msg.content
+        });
+      } else if (Array.isArray(msg.content)) {
+        let textContent = "";
+        for (const block of msg.content) {
+          if (block.type === "text" && block.text) {
+            textContent += block.text;
+          } else if (block.type === "tool_use" && block.name) {
+            // Emit accumulated text as assistant message first
+            if (textContent) {
+              input.push({
+                role: "assistant",
+                content: textContent
+              });
+              textContent = "";
             }
+            // Emit function_call as top-level input item
+            input.push({
+              type: "function_call",
+              call_id: block.id || `call_${randomUUID().slice(0, 12)}`,
+              name: block.name,
+              arguments: JSON.stringify(block.input || {})
+            });
+          }
+          // Skip thinking/compaction blocks — not relevant for OpenAI
         }
+        if (textContent) {
+          input.push({
+            role: "assistant",
+            content: textContent
+          });
+        }
+      }
     }
-    return input;
+  }
+  return input;
 }
+
 // ============================================================================
 // SCHEMA SANITIZATION
 // ============================================================================
+
 /** Sanitize JSON Schema for OpenAI — ensure arrays have items, objects have properties */
 function sanitizeSchemaForOpenAI(schema) {
-    if (!schema || typeof schema !== "object")
-        return schema;
-    if (Array.isArray(schema))
-        return schema.map(sanitizeSchemaForOpenAI);
-    const result = {};
-    for (const [key, value] of Object.entries(schema)) {
-        if (key === "properties" && typeof value === "object" && value !== null && !Array.isArray(value)) {
-            const props = {};
-            for (const [propName, propSchema] of Object.entries(value)) {
-                props[propName] = sanitizeSchemaForOpenAI(propSchema);
-            }
-            result[key] = props;
-        }
-        else {
-            result[key] = sanitizeSchemaForOpenAI(value);
-        }
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) return schema.map(sanitizeSchemaForOpenAI);
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "properties" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const props = {};
+      for (const [propName, propSchema] of Object.entries(value)) {
+        props[propName] = sanitizeSchemaForOpenAI(propSchema);
+      }
+      result[key] = props;
+    } else {
+      result[key] = sanitizeSchemaForOpenAI(value);
     }
-    // OpenAI requires arrays to have items
-    if (result.type === "array" && !result.items) {
-        result.items = { type: "string" };
-    }
-    // Filter required to only include defined properties
-    if (result.required && Array.isArray(result.required) && result.properties) {
-        const validProps = new Set(Object.keys(result.properties));
-        result.required = result.required.filter((r) => validProps.has(r));
-        if (result.required.length === 0)
-            delete result.required;
-    }
-    return result;
+  }
+
+  // OpenAI requires arrays to have items
+  if (result.type === "array" && !result.items) {
+    result.items = {
+      type: "string"
+    };
+  }
+
+  // Filter required to only include defined properties
+  if (result.required && Array.isArray(result.required) && result.properties) {
+    const validProps = new Set(Object.keys(result.properties));
+    result.required = result.required.filter(r => validProps.has(r));
+    if (result.required.length === 0) delete result.required;
+  }
+  return result;
 }
+
 /** Convert Anthropic tools to OpenAI Responses API FunctionTool format */
 function anthropicToResponsesTools(tools) {
-    return tools.map((t) => ({
-        type: "function",
-        name: t.name,
-        description: typeof t.description === "string" ? t.description.slice(0, 4096) : "",
-        parameters: sanitizeSchemaForOpenAI(t.input_schema || {}),
-        strict: false,
-    }));
+  return tools.map(t => ({
+    type: "function",
+    name: t.name,
+    description: typeof t.description === "string" ? t.description.slice(0, 4096) : "",
+    parameters: sanitizeSchemaForOpenAI(t.input_schema || {}),
+    strict: false
+  }));
 }
+
 // ============================================================================
 // ADAPTER
 // ============================================================================
+
 export class OpenAIAdapter {
-    name = "openai";
-    async handleStream(res, config, corsHeaders) {
-        const { model, messages, system, tools, max_tokens, temperature, storeId, tool_choice } = config;
-        const creds = await resolveProviderCredentials("openai", storeId);
-        if (!creds.openai) {
-            jsonResponse(res, 422, { error: "OpenAI credentials not configured. Add OPENAI_API_KEY to user_tool_secrets." }, corsHeaders);
-            return;
-        }
-        const client = new OpenAI({ apiKey: creds.openai.apiKey });
-        const isReasoning = isOpenAIReasoningModel(model);
-        // Convert Anthropic format → Responses API format
-        const openaiInput = anthropicToResponsesInput(messages);
-        const openaiTools = tools?.length ? anthropicToResponsesTools(tools) : undefined;
-        // Extract system prompt → instructions parameter
-        let instructions = "";
-        if (typeof system === "string") {
-            instructions = system;
-        }
-        else if (Array.isArray(system)) {
-            instructions = system.map((s) => s.text || "").join("\n");
-        }
-        // Build Responses API request
-        const params = {
-            model,
-            input: openaiInput,
-            stream: true,
-            store: false,
-            max_output_tokens: max_tokens,
-            parallel_tool_calls: true,
-            truncation: "auto",
+  name = "openai";
+  async handleStream(res, config, corsHeaders) {
+    const {
+      model,
+      messages,
+      system,
+      tools,
+      max_tokens,
+      temperature,
+      storeId,
+      tool_choice
+    } = config;
+    const creds = await resolveProviderCredentials("openai", storeId);
+    if (!creds.openai) {
+      jsonResponse(res, 422, {
+        error: "OpenAI credentials not configured. Add OPENAI_API_KEY to user_tool_secrets."
+      }, corsHeaders);
+      return;
+    }
+    const client = new OpenAI({
+      apiKey: creds.openai.apiKey
+    });
+    const isReasoning = isOpenAIReasoningModel(model);
+
+    // Convert Anthropic format → Responses API format
+    const openaiInput = anthropicToResponsesInput(messages);
+    const openaiTools = tools?.length ? anthropicToResponsesTools(tools) : undefined;
+
+    // Extract system prompt → instructions parameter
+    let instructions = "";
+    if (typeof system === "string") {
+      instructions = system;
+    } else if (Array.isArray(system)) {
+      instructions = system.map(s => s.text || "").join("\n");
+    }
+
+    // Build Responses API request
+    const params = {
+      model,
+      input: openaiInput,
+      stream: true,
+      store: false,
+      max_output_tokens: max_tokens,
+      parallel_tool_calls: true,
+      truncation: "auto"
+    };
+    if (instructions) params.instructions = instructions;
+    if (openaiTools?.length) params.tools = openaiTools;
+    if (isReasoning) {
+      params.reasoning = {
+        effort: "high",
+        summary: "detailed"
+      };
+    } else {
+      if (temperature !== undefined) params.temperature = temperature;
+    }
+
+    // Map tool_choice to OpenAI Responses API format
+    if (tool_choice) {
+      if (tool_choice === "auto") {
+        // "auto" is default for OpenAI — no-op
+      } else if (tool_choice === "any") {
+        params.tool_choice = "required";
+      } else if (tool_choice === "none") {
+        params.tool_choice = "none";
+        delete params.tools;
+      } else if (typeof tool_choice === "object" && tool_choice.type === "tool") {
+        params.tool_choice = {
+          type: "function",
+          function: {
+            name: tool_choice.name
+          }
         };
-        if (instructions)
-            params.instructions = instructions;
-        if (openaiTools?.length)
-            params.tools = openaiTools;
-        if (isReasoning) {
-            params.reasoning = { effort: "high", summary: "detailed" };
+      }
+    }
+
+    // Defer SSE headers until stream is successfully created
+    // so we can return proper HTTP errors if the initial API call fails.
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalReasoningTokens = 0;
+    let totalCacheReadTokens = 0;
+    let heartbeat;
+    try {
+      const stream = await client.responses.create(params);
+
+      // Stream created successfully — now safe to commit to SSE
+      writeSSEHeaders(res, corsHeaders);
+
+      // Heartbeat keeps the connection alive and helps detect dead clients
+      heartbeat = setInterval(() => {
+        if (!res.writableEnded) res.write(":ping\n\n");
+      }, 15_000);
+
+      // Emit Anthropic-format message_start
+      res.write(`data: ${JSON.stringify({
+        type: "message_start",
+        message: {
+          id: `msg_openai_${randomUUID().slice(0, 8)}`,
+          type: "message",
+          role: "assistant",
+          content: [],
+          model,
+          stop_reason: null,
+          usage: {
+            input_tokens: 0,
+            output_tokens: 0
+          }
         }
-        else {
-            if (temperature !== undefined)
-                params.temperature = temperature;
+      })}\n\n`);
+      let blockIndex = 0;
+      let hasOpenTextBlock = false;
+      let hasOpenThinkingBlock = false;
+      let hasToolUse = false;
+      let hasEmittedContent = false;
+      // Per-request function call tracking (not shared between concurrent requests)
+      const pendingFunctionCalls = new Map();
+
+      // Helper to close any open content blocks
+      const closeOpenBlocks = () => {
+        if (hasOpenThinkingBlock) {
+          res.write(`data: ${JSON.stringify({
+            type: "content_block_stop",
+            index: blockIndex
+          })}\n\n`);
+          blockIndex++;
+          hasOpenThinkingBlock = false;
         }
-        // Map tool_choice to OpenAI Responses API format
-        if (tool_choice) {
-            if (tool_choice === "auto") {
-                // "auto" is default for OpenAI — no-op
+        if (hasOpenTextBlock) {
+          res.write(`data: ${JSON.stringify({
+            type: "content_block_stop",
+            index: blockIndex
+          })}\n\n`);
+          blockIndex++;
+          hasOpenTextBlock = false;
+        }
+      };
+      for await (const event of stream) {
+        switch (event.type) {
+          // ---- Reasoning summary → Anthropic thinking block ----
+          case "response.reasoning_summary_text.delta":
+            {
+              const text = event.delta;
+              if (!text) break;
+              if (hasOpenTextBlock) {
+                res.write(`data: ${JSON.stringify({
+                  type: "content_block_stop",
+                  index: blockIndex
+                })}\n\n`);
+                blockIndex++;
+                hasOpenTextBlock = false;
+              }
+              if (!hasOpenThinkingBlock) {
+                res.write(`data: ${JSON.stringify({
+                  type: "content_block_start",
+                  index: blockIndex,
+                  content_block: {
+                    type: "thinking",
+                    thinking: ""
+                  }
+                })}\n\n`);
+                hasOpenThinkingBlock = true;
+                hasEmittedContent = true;
+              }
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: blockIndex,
+                delta: {
+                  type: "thinking_delta",
+                  thinking: text
+                }
+              })}\n\n`);
+              break;
             }
-            else if (tool_choice === "any") {
-                params.tool_choice = "required";
+          case "response.reasoning_summary_text.done":
+            {
+              break;
             }
-            else if (tool_choice === "none") {
-                params.tool_choice = "none";
-                delete params.tools;
+
+          // ---- Text content → Anthropic text block ----
+          case "response.output_text.delta":
+            {
+              const text = event.delta;
+              if (!text) break;
+              if (hasOpenThinkingBlock) {
+                res.write(`data: ${JSON.stringify({
+                  type: "content_block_stop",
+                  index: blockIndex
+                })}\n\n`);
+                blockIndex++;
+                hasOpenThinkingBlock = false;
+              }
+              if (!hasOpenTextBlock) {
+                res.write(`data: ${JSON.stringify({
+                  type: "content_block_start",
+                  index: blockIndex,
+                  content_block: {
+                    type: "text",
+                    text: ""
+                  }
+                })}\n\n`);
+                hasOpenTextBlock = true;
+                hasEmittedContent = true;
+              }
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: blockIndex,
+                delta: {
+                  type: "text_delta",
+                  text
+                }
+              })}\n\n`);
+              break;
             }
-            else if (typeof tool_choice === "object" && tool_choice.type === "tool") {
-                params.tool_choice = { type: "function", function: { name: tool_choice.name } };
+          case "response.output_text.done":
+            {
+              break;
             }
-        }
-        // Defer SSE headers until stream is successfully created
-        // so we can return proper HTTP errors if the initial API call fails.
-        let totalInputTokens = 0;
-        let totalOutputTokens = 0;
-        let totalReasoningTokens = 0;
-        let totalCacheReadTokens = 0;
-        let heartbeat;
-        try {
-            const stream = await client.responses.create(params);
-            // Stream created successfully — now safe to commit to SSE
-            writeSSEHeaders(res, corsHeaders);
-            // Heartbeat keeps the connection alive and helps detect dead clients
-            heartbeat = setInterval(() => {
-                if (!res.writableEnded)
-                    res.write(":ping\n\n");
-            }, 15_000);
-            // Emit Anthropic-format message_start
-            res.write(`data: ${JSON.stringify({
-                type: "message_start",
-                message: {
-                    id: `msg_openai_${randomUUID().slice(0, 8)}`,
-                    type: "message",
-                    role: "assistant",
-                    content: [],
-                    model,
-                    stop_reason: null,
-                    usage: { input_tokens: 0, output_tokens: 0 },
-                },
-            })}\n\n`);
-            let blockIndex = 0;
-            let hasOpenTextBlock = false;
-            let hasOpenThinkingBlock = false;
-            let hasToolUse = false;
-            let hasEmittedContent = false;
-            // Per-request function call tracking (not shared between concurrent requests)
-            const pendingFunctionCalls = new Map();
-            // Helper to close any open content blocks
-            const closeOpenBlocks = () => {
-                if (hasOpenThinkingBlock) {
-                    res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                    blockIndex++;
-                    hasOpenThinkingBlock = false;
+
+          // ---- Function calls → Anthropic tool_use blocks ----
+          case "response.output_item.added":
+            {
+              const item = event.item;
+              if (item?.type === "function_call" && item.id && item.name) {
+                pendingFunctionCalls.set(item.id, {
+                  name: item.name,
+                  callId: item.call_id || item.id
+                });
+              }
+              break;
+            }
+          case "response.function_call_arguments.done":
+            {
+              closeOpenBlocks();
+              hasToolUse = true;
+              hasEmittedContent = true;
+              const pending = pendingFunctionCalls.get(event.item_id);
+              const name = pending?.name || event.name || "unknown_tool";
+              const callId = pending?.callId || event.call_id || event.item_id;
+              if (pending) pendingFunctionCalls.delete(event.item_id);
+              const args = event.arguments;
+              let parsedInput = {};
+              try {
+                parsedInput = JSON.parse(args || "{}");
+              } catch {/* use empty */}
+              const toolUseId = callId || `toolu_openai_${randomUUID().slice(0, 12)}`;
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_start",
+                index: blockIndex,
+                content_block: {
+                  type: "tool_use",
+                  id: toolUseId,
+                  name,
+                  input: {}
                 }
-                if (hasOpenTextBlock) {
-                    res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                    blockIndex++;
-                    hasOpenTextBlock = false;
+              })}\n\n`);
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: blockIndex,
+                delta: {
+                  type: "input_json_delta",
+                  partial_json: JSON.stringify(parsedInput)
                 }
-            };
-            for await (const event of stream) {
-                switch (event.type) {
-                    // ---- Reasoning summary → Anthropic thinking block ----
-                    case "response.reasoning_summary_text.delta": {
-                        const text = event.delta;
-                        if (!text)
-                            break;
-                        if (hasOpenTextBlock) {
-                            res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                            blockIndex++;
-                            hasOpenTextBlock = false;
-                        }
-                        if (!hasOpenThinkingBlock) {
-                            res.write(`data: ${JSON.stringify({
-                                type: "content_block_start",
-                                index: blockIndex,
-                                content_block: { type: "thinking", thinking: "" },
-                            })}\n\n`);
-                            hasOpenThinkingBlock = true;
-                            hasEmittedContent = true;
-                        }
-                        res.write(`data: ${JSON.stringify({
-                            type: "content_block_delta",
-                            index: blockIndex,
-                            delta: { type: "thinking_delta", thinking: text },
-                        })}\n\n`);
-                        break;
-                    }
-                    case "response.reasoning_summary_text.done": {
-                        break;
-                    }
-                    // ---- Text content → Anthropic text block ----
-                    case "response.output_text.delta": {
-                        const text = event.delta;
-                        if (!text)
-                            break;
-                        if (hasOpenThinkingBlock) {
-                            res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                            blockIndex++;
-                            hasOpenThinkingBlock = false;
-                        }
-                        if (!hasOpenTextBlock) {
-                            res.write(`data: ${JSON.stringify({
-                                type: "content_block_start",
-                                index: blockIndex,
-                                content_block: { type: "text", text: "" },
-                            })}\n\n`);
-                            hasOpenTextBlock = true;
-                            hasEmittedContent = true;
-                        }
-                        res.write(`data: ${JSON.stringify({
-                            type: "content_block_delta",
-                            index: blockIndex,
-                            delta: { type: "text_delta", text },
-                        })}\n\n`);
-                        break;
-                    }
-                    case "response.output_text.done": {
-                        break;
-                    }
-                    // ---- Function calls → Anthropic tool_use blocks ----
-                    case "response.output_item.added": {
-                        const item = event.item;
-                        if (item?.type === "function_call" && item.id && item.name) {
-                            pendingFunctionCalls.set(item.id, { name: item.name, callId: item.call_id || item.id });
-                        }
-                        break;
-                    }
-                    case "response.function_call_arguments.done": {
-                        closeOpenBlocks();
-                        hasToolUse = true;
-                        hasEmittedContent = true;
-                        const pending = pendingFunctionCalls.get(event.item_id);
-                        const name = pending?.name || event.name || "unknown_tool";
-                        const callId = pending?.callId || event.call_id || event.item_id;
-                        if (pending)
-                            pendingFunctionCalls.delete(event.item_id);
-                        const args = event.arguments;
-                        let parsedInput = {};
-                        try {
-                            parsedInput = JSON.parse(args || "{}");
-                        }
-                        catch { /* use empty */ }
-                        const toolUseId = callId || `toolu_openai_${randomUUID().slice(0, 12)}`;
-                        res.write(`data: ${JSON.stringify({
-                            type: "content_block_start",
-                            index: blockIndex,
-                            content_block: {
-                                type: "tool_use",
-                                id: toolUseId,
-                                name,
-                                input: {},
-                            },
-                        })}\n\n`);
-                        res.write(`data: ${JSON.stringify({
-                            type: "content_block_delta",
-                            index: blockIndex,
-                            delta: {
-                                type: "input_json_delta",
-                                partial_json: JSON.stringify(parsedInput),
-                            },
-                        })}\n\n`);
-                        res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                        blockIndex++;
-                        break;
-                    }
-                    // ---- Completion → usage + stop ----
-                    case "response.completed": {
-                        const response = event.response;
-                        if (response?.usage) {
-                            totalInputTokens = response.usage.input_tokens || 0;
-                            totalOutputTokens = response.usage.output_tokens || 0;
-                            if (response.usage.output_tokens_details?.reasoning_tokens) {
-                                totalReasoningTokens = response.usage.output_tokens_details.reasoning_tokens;
-                            }
-                            if (response.usage.input_tokens_details?.cached_tokens) {
-                                totalCacheReadTokens = response.usage.input_tokens_details.cached_tokens;
-                            }
-                        }
-                        break;
-                    }
-                    // ---- Error during streaming ----
-                    case "response.failed": {
-                        const error = event.response?.error;
-                        const errMsg = error?.message || "Unknown OpenAI error";
-                        console.error("[openai-proxy] Response failed:", errMsg);
-                        closeOpenBlocks();
-                        if (!hasEmittedContent) {
-                            res.write(`data: ${JSON.stringify({
-                                type: "content_block_start",
-                                index: blockIndex,
-                                content_block: { type: "text", text: "" },
-                            })}\n\n`);
-                            res.write(`data: ${JSON.stringify({
-                                type: "content_block_delta",
-                                index: blockIndex,
-                                delta: { type: "text_delta", text: `[OpenAI error: ${errMsg}]` },
-                            })}\n\n`);
-                            res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                            hasEmittedContent = true;
-                        }
-                        break;
-                    }
-                    case "response.incomplete": {
-                        console.warn("[openai-proxy] Response incomplete:", event.response?.incomplete_details);
-                        break;
-                    }
-                    default:
-                        break;
+              })}\n\n`);
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_stop",
+                index: blockIndex
+              })}\n\n`);
+              blockIndex++;
+              break;
+            }
+
+          // ---- Completion → usage + stop ----
+          case "response.completed":
+            {
+              const response = event.response;
+              if (response?.usage) {
+                totalInputTokens = response.usage.input_tokens || 0;
+                totalOutputTokens = response.usage.output_tokens || 0;
+                if (response.usage.output_tokens_details?.reasoning_tokens) {
+                  totalReasoningTokens = response.usage.output_tokens_details.reasoning_tokens;
+                }
+                if (response.usage.input_tokens_details?.cached_tokens) {
+                  totalCacheReadTokens = response.usage.input_tokens_details.cached_tokens;
                 }
+              }
+              break;
             }
-            // Close any remaining open blocks
-            closeOpenBlocks();
-            // Handle empty response
-            if (!hasEmittedContent) {
+
+          // ---- Error during streaming ----
+          case "response.failed":
+            {
+              const error = event.response?.error;
+              const errMsg = error?.message || "Unknown OpenAI error";
+              console.error("[openai-proxy] Response failed:", errMsg);
+              closeOpenBlocks();
+              if (!hasEmittedContent) {
+                res.write(`data: ${JSON.stringify({
+                  type: "content_block_start",
+                  index: blockIndex,
+                  content_block: {
+                    type: "text",
+                    text: ""
+                  }
+                })}\n\n`);
                 res.write(`data: ${JSON.stringify({
-                    type: "content_block_start",
-                    index: 0,
-                    content_block: { type: "text", text: "" },
+                  type: "content_block_delta",
+                  index: blockIndex,
+                  delta: {
+                    type: "text_delta",
+                    text: `[OpenAI error: ${errMsg}]`
+                  }
                 })}\n\n`);
                 res.write(`data: ${JSON.stringify({
-                    type: "content_block_delta",
-                    index: 0,
-                    delta: { type: "text_delta", text: "[OpenAI returned an empty response. Please try again.]" },
+                  type: "content_block_stop",
+                  index: blockIndex
                 })}\n\n`);
-                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: 0 })}\n\n`);
+                hasEmittedContent = true;
+              }
+              break;
             }
-            // Determine stop reason
-            const stopReason = hasToolUse ? "tool_use" : "end_turn";
-            // Emit message_delta with usage
-            res.write(`data: ${JSON.stringify({
-                type: "message_delta",
-                delta: { stop_reason: stopReason, stop_sequence: null },
-                usage: {
-                    input_tokens: totalInputTokens,
-                    output_tokens: totalOutputTokens,
-                    ...(totalReasoningTokens > 0 ? { thinking_tokens: totalReasoningTokens } : {}),
-                    ...(totalCacheReadTokens > 0 ? { cache_read_input_tokens: totalCacheReadTokens } : {}),
-                },
-            })}\n\n`);
-            res.write(`data: ${JSON.stringify({ type: "message_stop" })}\n\n`);
-            res.write("data: [DONE]\n\n");
-        }
-        catch (err) {
-            emitError(res, err, corsHeaders, sanitizeError, {
-                provider: "openai",
-                inputTokens: totalInputTokens,
-                outputTokens: totalOutputTokens,
-                thinkingTokens: totalReasoningTokens,
-                cacheReadTokens: totalCacheReadTokens,
-            });
-        }
-        finally {
-            if (heartbeat)
-                clearInterval(heartbeat);
+          case "response.incomplete":
+            {
+              console.warn("[openai-proxy] Response incomplete:", event.response?.incomplete_details);
+              break;
+            }
+          default:
+            break;
         }
-        res.end();
-    }
-    // ---- Provider-specific config methods ----
-    getThinkingConfig(model, enabled) {
-        if (!enabled) {
-            return { thinking: { type: "disabled" }, beta: "" };
+      }
+
+      // Close any remaining open blocks
+      closeOpenBlocks();
+
+      // Handle empty response
+      if (!hasEmittedContent) {
+        res.write(`data: ${JSON.stringify({
+          type: "content_block_start",
+          index: 0,
+          content_block: {
+            type: "text",
+            text: ""
+          }
+        })}\n\n`);
+        res.write(`data: ${JSON.stringify({
+          type: "content_block_delta",
+          index: 0,
+          delta: {
+            type: "text_delta",
+            text: "[OpenAI returned an empty response. Please try again.]"
+          }
+        })}\n\n`);
+        res.write(`data: ${JSON.stringify({
+          type: "content_block_stop",
+          index: 0
+        })}\n\n`);
+      }
+
+      // Determine stop reason
+      const stopReason = hasToolUse ? "tool_use" : "end_turn";
+
+      // Emit message_delta with usage
+      res.write(`data: ${JSON.stringify({
+        type: "message_delta",
+        delta: {
+          stop_reason: stopReason,
+          stop_sequence: null
+        },
+        usage: {
+          input_tokens: totalInputTokens,
+          output_tokens: totalOutputTokens,
+          ...(totalReasoningTokens > 0 ? {
+            thinking_tokens: totalReasoningTokens
+          } : {}),
+          ...(totalCacheReadTokens > 0 ? {
+            cache_read_input_tokens: totalCacheReadTokens
+          } : {})
         }
-        // OpenAI reasoning models (o-series) have built-in reasoning, GPT models don't support thinking
-        const isReasoning = /^o\d/.test(model);
-        return { thinking: { type: isReasoning ? "enabled" : "disabled" }, beta: "" };
-    }
-    getMaxOutputTokens(model, agentMax) {
-        const modelMax = MODEL_MAX_OUTPUT_TOKENS[model] ?? DEFAULT_OUTPUT_TOKENS;
-        if (agentMax)
-            return Math.min(agentMax, modelMax);
-        return Math.min(DEFAULT_OUTPUT_TOKENS, modelMax);
-    }
-    getContextManagement(_model) {
-        // OpenAI doesn't use Anthropic betas or context management
-        return { betas: [], config: { edits: [] } };
-    }
-    getCompactionConfig(_model) {
-        return { triggerTokens: 120_000, totalBudget: 2_000_000, isNative: false };
+      })}\n\n`);
+      res.write(`data: ${JSON.stringify({
+        type: "message_stop"
+      })}\n\n`);
+      res.write("data: [DONE]\n\n");
+    } catch (err) {
+      emitError(res, err, corsHeaders, sanitizeError, {
+        provider: "openai",
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens,
+        thinkingTokens: totalReasoningTokens,
+        cacheReadTokens: totalCacheReadTokens
+      });
+    } finally {
+      if (heartbeat) clearInterval(heartbeat);
     }
-    getCapabilities() {
-        return getCapabilities("openai");
+    res.end();
+  }
+
+  // ---- Provider-specific config methods ----
+
+  getThinkingConfig(model, enabled) {
+    if (!enabled) {
+      return {
+        thinking: {
+          type: "disabled"
+        },
+        beta: ""
+      };
     }
+    // OpenAI reasoning models (o-series) have built-in reasoning, GPT models don't support thinking
+    const isReasoning = /^o\d/.test(model);
+    return {
+      thinking: {
+        type: isReasoning ? "enabled" : "disabled"
+      },
+      beta: ""
+    };
+  }
+  getMaxOutputTokens(model, agentMax) {
+    const modelMax = MODEL_MAX_OUTPUT_TOKENS[model] ?? DEFAULT_OUTPUT_TOKENS;
+    if (agentMax) return Math.min(agentMax, modelMax);
+    return Math.min(DEFAULT_OUTPUT_TOKENS, modelMax);
+  }
+  getContextManagement(_model) {
+    // OpenAI doesn't use Anthropic betas or context management
+    return {
+      betas: [],
+      config: {
+        edits: []
+      }
+    };
+  }
+  getCompactionConfig(_model) {
+    return {
+      triggerTokens: 120_000,
+      totalBudget: 2_000_000,
+      isNative: false
+    };
+  }
+  getCapabilities() {
+    return getCapabilities("openai");
+  }
 }
+
 // Auto-register on import
 registerProvider("openai", new OpenAIAdapter());
+//# sourceMappingURL=openai.js.map