whale-code 6.4.0

package/dist/server/providers/openai.js

@@ -0,0 +1,522 @@
+/**
+ * OpenAI Provider Adapter — Responses API (2026) with format conversion to Anthropic SSE.
+ *
+ * Contains:
+ * - anthropicToResponsesInput() — messages → Responses API format
+ * - sanitizeSchemaForOpenAI() — schema cleanup
+ * - anthropicToResponsesTools() — tool format conversion
+ * - Streaming with 12 event type handlers
+ * - pendingFunctionCalls tracking (per-request, not shared)
+ *
+ * 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";
+import { isOpenAIReasoningModel } from "../../shared/constants.js";
+import { getCapabilities } from "../lib/provider-capabilities.js";
+import { registerProvider } from "./registry.js";
+import { jsonResponse, writeSSEHeaders, emitError, resolveProviderCredentials } from "./shared.js";
+// ============================================================================
+// 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,
+};
+// ============================================================================
+// MESSAGE CONVERSION
+// ============================================================================
+/**
+ * Convert Anthropic messages to OpenAI Responses API input format.
+ *
+ * Key differences from Chat Completions:
+ * - System prompt goes to `instructions` param (not in input array)
+ * - tool_use blocks become top-level `function_call` items
+ * - tool_result blocks become top-level `function_call_output` items
+ * - Images use `input_image` type with data URL in `image_url`
+ * - 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 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 });
+                }
+            }
+        }
+        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;
+}
+// ============================================================================
+// 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);
+        }
+    }
+    // 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,
+    }));
+}
+// ============================================================================
+// 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",
+        };
+        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 } };
+            }
+        }
+        // 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;
+                }
+                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;
+                    }
+                    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;
+                }
+            }
+            // 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 } : {}),
+                },
+            })}\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);
+        }
+        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());

package/dist/server/providers/registry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Provider Adapter Registry — central lookup for provider adapters.
+ *
+ * Phase 7.1: Replaces ad-hoc provider switching with a single registry.
+ * Adapters self-register on import. External code calls getProviderAdapter()
+ * instead of maintaining its own switch/if-else chains.
+ */
+import type { ProviderAdapter } from "./types.js";
+/**
+ * Register a provider adapter. Called by each adapter module on import.
+ * Overwrites if a provider with the same name is already registered.
+ */
+export declare function registerProvider(name: string, adapter: ProviderAdapter): void;
+/**
+ * Get the adapter for a provider name or model ID.
+ *
+ * Accepts either:
+ * - A provider name directly ("anthropic", "gemini", "openai", "bedrock")
+ * - A full model ID (uses getProvider() to resolve the provider name)
+ *
+ * Falls back to "anthropic" if no adapter is found for the resolved provider.
+ * Throws if no adapters are registered at all (indicates missing initialization).
+ */
+export declare function getProviderAdapter(modelOrProvider: string): ProviderAdapter;
+/**
+ * Check if a provider is registered.
+ */
+export declare function hasProvider(name: string): boolean;
+/**
+ * Get all registered provider names.
+ */
+export declare function getRegisteredProviders(): string[];

package/dist/server/providers/registry.js

@@ -0,0 +1,58 @@
+/**
+ * Provider Adapter Registry — central lookup for provider adapters.
+ *
+ * Phase 7.1: Replaces ad-hoc provider switching with a single registry.
+ * Adapters self-register on import. External code calls getProviderAdapter()
+ * instead of maintaining its own switch/if-else chains.
+ */
+import { getProvider } from "../../shared/constants.js";
+// ============================================================================
+// REGISTRY
+// ============================================================================
+const providers = new Map();
+/**
+ * Register a provider adapter. Called by each adapter module on import.
+ * Overwrites if a provider with the same name is already registered.
+ */
+export function registerProvider(name, adapter) {
+    providers.set(name, adapter);
+}
+/**
+ * Get the adapter for a provider name or model ID.
+ *
+ * Accepts either:
+ * - A provider name directly ("anthropic", "gemini", "openai", "bedrock")
+ * - A full model ID (uses getProvider() to resolve the provider name)
+ *
+ * Falls back to "anthropic" if no adapter is found for the resolved provider.
+ * Throws if no adapters are registered at all (indicates missing initialization).
+ */
+export function getProviderAdapter(modelOrProvider) {
+    // Direct provider name match
+    const direct = providers.get(modelOrProvider);
+    if (direct)
+        return direct;
+    // Resolve model ID → provider name
+    const providerName = getProvider(modelOrProvider);
+    const resolved = providers.get(providerName);
+    if (resolved)
+        return resolved;
+    // Fallback to anthropic
+    const fallback = providers.get("anthropic");
+    if (fallback)
+        return fallback;
+    throw new Error(`No provider adapter registered for "${modelOrProvider}" (resolved: "${providerName}"). ` +
+        `Registered providers: [${Array.from(providers.keys()).join(", ")}]`);
+}
+/**
+ * Check if a provider is registered.
+ */
+export function hasProvider(name) {
+    return providers.has(name);
+}
+/**
+ * Get all registered provider names.
+ */
+export function getRegisteredProviders() {
+    return Array.from(providers.keys());
+}

package/dist/server/providers/shared.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Provider Shared Utilities — credential resolution, SSE helpers, error emission.
+ *
+ * Extracted from proxy-handlers.ts. Used by all provider adapters.
+ */
+import http from "node:http";
+export declare function jsonResponse(res: http.ServerResponse, status: number, data: unknown, corsHeaders: Record<string, string>): void;
+export declare function writeSSEHeaders(res: http.ServerResponse, corsHeaders: Record<string, string>): void;
+/**
+ * Emit an error — as SSE if headers already sent, otherwise as JSON response.
+ * Always emits message_delta + message_stop so clients don't hang.
+ */
+export declare function emitError(res: http.ServerResponse, err: unknown, corsHeaders: Record<string, string>, sanitize: (e: unknown) => string, opts?: {
+    provider?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    thinkingTokens?: number;
+    cacheReadTokens?: number;
+}): void;
+export declare function resolveProviderCredentials(provider: "google" | "bedrock" | "openai", storeId: string | undefined): Promise<{
+    google?: {
+        apiKey: string;
+    };
+    bedrock?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        region: string;
+    };
+    openai?: {
+        apiKey: string;
+    };
+}>;