whale-code 6.4.0

package/dist/server/providers/gemini.js

@@ -0,0 +1,486 @@
+/**
+ * Gemini Provider Adapter — full format conversion to/from Anthropic SSE.
+ *
+ * Contains:
+ * - anthropicToGeminiMessages() — message format conversion
+ * - sanitizeSchemaForGemini() — type uppercase, enum stringification, key stripping
+ * - anthropicToGeminiFunctions() — tool conversion
+ * - Streaming event loop with thinking/text/function call detection
+ * - seenFunctionCalls deduplication
+ *
+ * Phase 7.1: Also encapsulates thinking config, context management,
+ * output token limits, and compaction config for Gemini models.
+ */
+import { randomUUID } from "node:crypto";
+import { GoogleGenAI } from "@google/genai";
+import { sanitizeError } from "../../shared/agent-core.js";
+import { getCapabilities } from "../lib/provider-capabilities.js";
+import { registerProvider } from "./registry.js";
+import { jsonResponse, writeSSEHeaders, emitError, resolveProviderCredentials } from "./shared.js";
+// ============================================================================
+// CONSTANTS — Gemini-specific model config
+// ============================================================================
+const GEMINI_MAX_TOKENS = 65536;
+const DEFAULT_OUTPUT_TOKENS = 16384;
+const MODEL_MAX_OUTPUT_TOKENS = {
+    "gemini-3-pro-preview": 65536,
+    "gemini-3-flash-preview": 65536,
+    "gemini-2.5-pro": 65536,
+    "gemini-2.5-flash": 65536,
+    "gemini-2.5-flash-lite": 65536,
+};
+// ============================================================================
+// MESSAGE CONVERSION
+// ============================================================================
+/** Convert Anthropic messages to Gemini Content format */
+function anthropicToGeminiMessages(messages) {
+    const contents = [];
+    // Track tool_use_id → name for tool_result conversion
+    const toolIdMap = new Map();
+    for (const msg of messages) {
+        const role = msg.role === "assistant" ? "model" : "user";
+        const parts = [];
+        if (typeof msg.content === "string") {
+            parts.push({ text: msg.content });
+        }
+        else if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.type === "text" && block.text) {
+                    parts.push({ text: block.text });
+                }
+                else if (block.type === "tool_use") {
+                    toolIdMap.set(block.id, block.name);
+                    parts.push({
+                        functionCall: { name: block.name, args: block.input || {} },
+                        // Preserve Gemini thought signature for function call round-trips
+                        ...(block.thought_signature ? { thoughtSignature: block.thought_signature } : {}),
+                    });
+                }
+                else if (block.type === "image" && block.source?.data) {
+                    parts.push({
+                        inlineData: {
+                            mimeType: block.source.media_type,
+                            data: block.source.data,
+                        },
+                    });
+                }
+                else if (block.type === "tool_result") {
+                    const toolName = toolIdMap.get(block.tool_use_id) || block.tool_use_id;
+                    let resultContent = "";
+                    if (typeof block.content === "string") {
+                        resultContent = block.content;
+                    }
+                    else if (Array.isArray(block.content)) {
+                        resultContent = block.content
+                            .filter((c) => c.type === "text")
+                            .map((c) => c.text)
+                            .join("\n");
+                    }
+                    parts.push({
+                        functionResponse: {
+                            name: toolName,
+                            response: { result: resultContent },
+                        },
+                    });
+                }
+            }
+        }
+        if (parts.length > 0) {
+            contents.push({ role, parts });
+        }
+    }
+    return contents;
+}
+// ============================================================================
+// SCHEMA SANITIZATION
+// ============================================================================
+/** Gemini uses uppercase OpenAPI schema types, not lowercase JSON Schema types. */
+const GEMINI_TYPE_MAP = {
+    string: "STRING",
+    number: "NUMBER",
+    integer: "INTEGER",
+    boolean: "BOOLEAN",
+    array: "ARRAY",
+    object: "OBJECT",
+};
+/**
+ * Keys that are JSON Schema-only and not supported by Gemini's OpenAPI Schema.
+ * IMPORTANT: Only strip keys that can't collide with property names in our tools.
+ */
+const GEMINI_SCHEMA_ONLY_KEYS = new Set([
+    "$schema", "additionalProperties", "propertyNames",
+    "minProperties", "maxProperties",
+    "anyOf", "oneOf", "allOf", "not", "const",
+]);
+/** Keys to strip only from schema definition objects (objects with a "type" field) */
+const GEMINI_SCHEMA_VALIDATION_KEYS = new Set([
+    "exclusiveMinimum", "exclusiveMaximum",
+    "minItems", "maxItems", "minLength", "maxLength",
+    "minimum", "maximum", "pattern",
+    "default",
+]);
+/**
+ * Sanitize JSON Schema → Gemini OpenAPI Schema:
+ * - Convert type values to uppercase (string → STRING)
+ * - Stringify all enum values
+ * - Remove unsupported JSON Schema keys (carefully — don't strip property names)
+ * - Ensure arrays have items, objects have properties
+ * - Filter required to only include defined properties
+ */
+function sanitizeSchemaForGemini(schema) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map((s) => sanitizeSchemaForGemini(s));
+    const result = {};
+    const isSchemaNode = "type" in schema;
+    for (const [key, value] of Object.entries(schema)) {
+        // Always strip structural JSON Schema keys
+        if (GEMINI_SCHEMA_ONLY_KEYS.has(key))
+            continue;
+        // Strip validation keys only from schema nodes (not property name maps)
+        if (isSchemaNode && GEMINI_SCHEMA_VALIDATION_KEYS.has(key))
+            continue;
+        if (key === "type" && typeof value === "string") {
+            result[key] = GEMINI_TYPE_MAP[value] || value.toUpperCase();
+        }
+        else if (key === "enum" && Array.isArray(value)) {
+            result[key] = value.map((v) => String(v));
+        }
+        else if (key === "properties" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+            // Properties map: keys are property names, values are schema definitions
+            const props = {};
+            for (const [propName, propSchema] of Object.entries(value)) {
+                props[propName] = sanitizeSchemaForGemini(propSchema);
+            }
+            result[key] = props;
+        }
+        else {
+            result[key] = sanitizeSchemaForGemini(value);
+        }
+    }
+    // Gemini requires array items to have a type
+    if (result.type === "ARRAY") {
+        if (!result.items || (typeof result.items === "object" && Object.keys(result.items).length === 0)) {
+            result.items = { type: "STRING" };
+        }
+    }
+    // Gemini requires object types to have properties
+    if (result.type === "OBJECT" && !result.properties) {
+        result.properties = {};
+    }
+    // Gemini only allows enum on STRING type — force type to STRING if enum is present
+    if (result.enum && Array.isArray(result.enum) && result.type && result.type !== "STRING") {
+        result.type = "STRING";
+    }
+    // Filter required to only include properties that actually exist
+    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;
+}
+function anthropicToGeminiFunctions(tools) {
+    return tools.map((t) => ({
+        name: t.name,
+        description: typeof t.description === "string" ? t.description.slice(0, 4096) : "",
+        parameters: sanitizeSchemaForGemini(t.input_schema || {}),
+    }));
+}
+// ============================================================================
+// ADAPTER
+// ============================================================================
+export class GeminiAdapter {
+    name = "gemini";
+    async handleStream(res, config, corsHeaders) {
+        const { model, messages, system, tools, max_tokens, temperature, storeId, tool_choice } = config;
+        const creds = await resolveProviderCredentials("google", storeId);
+        if (!creds.google) {
+            jsonResponse(res, 422, { error: "Google AI credentials not configured. Add google_ai_api_key to platform_secrets." }, corsHeaders);
+            return;
+        }
+        const client = new GoogleGenAI({ apiKey: creds.google.apiKey });
+        // Extract system prompt text
+        let systemText = "";
+        if (typeof system === "string") {
+            systemText = system;
+        }
+        else if (Array.isArray(system)) {
+            systemText = system.map((s) => s.text || "").join("\n");
+        }
+        // Build generation config
+        const genConfig = { maxOutputTokens: max_tokens };
+        if (temperature !== undefined)
+            genConfig.temperature = temperature;
+        // Map tool_choice to Gemini functionCallingConfig
+        let geminiFunctionCallingConfig = { mode: "AUTO" };
+        let omitGeminiTools = false;
+        if (tool_choice) {
+            if (tool_choice === "auto") {
+                geminiFunctionCallingConfig = { mode: "AUTO" };
+            }
+            else if (tool_choice === "any") {
+                geminiFunctionCallingConfig = { mode: "ANY" };
+            }
+            else if (tool_choice === "none") {
+                geminiFunctionCallingConfig = { mode: "NONE" };
+                omitGeminiTools = true;
+            }
+            else if (typeof tool_choice === "object" && tool_choice.type === "tool") {
+                geminiFunctionCallingConfig = { mode: "ANY", allowedFunctionNames: [tool_choice.name] };
+            }
+        }
+        // Build request config for the new SDK — model is passed per-request
+        const requestConfig = {
+            model,
+            config: {
+                ...genConfig,
+                ...(systemText ? { systemInstruction: systemText } : {}),
+                ...(!omitGeminiTools && tools?.length ? {
+                    tools: [{ functionDeclarations: anthropicToGeminiFunctions(tools) }],
+                    toolConfig: { functionCallingConfig: geminiFunctionCallingConfig },
+                } : {}),
+            },
+        };
+        const genModel = client.models;
+        // Convert messages
+        const contents = anthropicToGeminiMessages(messages);
+        // Track tokens outside try so catch block can reference them
+        let totalOutputTokens = 0;
+        let totalInputTokens = 0;
+        let totalThinkingTokens = 0;
+        let totalCacheReadTokens = 0;
+        // Defer SSE headers until stream is successfully created
+        // so we can return proper HTTP errors if the initial API call fails.
+        let heartbeat;
+        try {
+            // Request with includeThoughts so we stream Gemini's thinking process
+            const streamResult = await genModel.generateContentStream({
+                ...requestConfig,
+                contents,
+                config: {
+                    ...requestConfig.config,
+                    thinkingConfig: { includeThoughts: true },
+                },
+            });
+            // 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_gemini_${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;
+            const seenFunctionCalls = new Set();
+            for await (const chunk of streamResult) {
+                const candidates = chunk.candidates || [];
+                const usage = chunk.usageMetadata;
+                if (usage) {
+                    totalOutputTokens = usage.candidatesTokenCount || usage.totalTokenCount || 0;
+                    totalInputTokens = usage.promptTokenCount || 0;
+                    totalThinkingTokens = usage.thoughtsTokenCount || 0;
+                    if (usage.cachedContentTokenCount) {
+                        totalCacheReadTokens = usage.cachedContentTokenCount;
+                    }
+                }
+                for (const candidate of candidates) {
+                    const allParts = candidate.content?.parts || [];
+                    for (const part of allParts) {
+                        const isThought = !!part.thought;
+                        // Thinking text delta
+                        if (isThought && part.text) {
+                            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: part.text },
+                            })}\n\n`);
+                            continue;
+                        }
+                        // Response text delta
+                        if (part.text && !isThought) {
+                            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: part.text },
+                            })}\n\n`);
+                            continue;
+                        }
+                        // Function call
+                        if (part.functionCall) {
+                            const fc = {
+                                name: part.functionCall.name || "",
+                                args: part.functionCall.args || {},
+                                thoughtSignature: part.thoughtSignature,
+                            };
+                            const fcKey = `${fc.name}:${JSON.stringify(fc.args)}`;
+                            if (seenFunctionCalls.has(fcKey))
+                                continue;
+                            seenFunctionCalls.add(fcKey);
+                            // Close any open thinking block
+                            if (hasOpenThinkingBlock) {
+                                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
+                                blockIndex++;
+                                hasOpenThinkingBlock = false;
+                            }
+                            // Close any open text block
+                            if (hasOpenTextBlock) {
+                                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
+                                blockIndex++;
+                                hasOpenTextBlock = false;
+                            }
+                            hasToolUse = true;
+                            hasEmittedContent = true;
+                            const toolUseId = `toolu_gemini_${randomUUID().slice(0, 12)}`;
+                            res.write(`data: ${JSON.stringify({
+                                type: "content_block_start",
+                                index: blockIndex,
+                                content_block: {
+                                    type: "tool_use",
+                                    id: toolUseId,
+                                    name: fc.name,
+                                    input: {},
+                                    // Preserve Gemini thought_signature — required for tool call round-trips with thinking
+                                    ...(fc.thoughtSignature ? { thought_signature: fc.thoughtSignature } : {}),
+                                },
+                            })}\n\n`);
+                            res.write(`data: ${JSON.stringify({
+                                type: "content_block_delta",
+                                index: blockIndex,
+                                delta: {
+                                    type: "input_json_delta",
+                                    partial_json: JSON.stringify(fc.args || {}),
+                                },
+                            })}\n\n`);
+                            res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
+                            blockIndex++;
+                        }
+                    }
+                }
+            }
+            // Close any open blocks — no signature_delta for Gemini thinking
+            if (hasOpenThinkingBlock) {
+                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
+            }
+            if (hasOpenTextBlock) {
+                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
+            }
+            // Handle empty response — Gemini sometimes returns finishReason: STOP with no content
+            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: "[Gemini 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 stop reason + full usage
+            res.write(`data: ${JSON.stringify({
+                type: "message_delta",
+                delta: { stop_reason: stopReason, stop_sequence: null },
+                usage: {
+                    input_tokens: totalInputTokens,
+                    output_tokens: totalOutputTokens,
+                    ...(totalThinkingTokens > 0 ? { thinking_tokens: totalThinkingTokens } : {}),
+                    ...(totalCacheReadTokens > 0 ? { cache_read_input_tokens: totalCacheReadTokens } : {}),
+                },
+            })}\n\n`);
+            // Emit message_stop
+            res.write(`data: ${JSON.stringify({ type: "message_stop" })}\n\n`);
+            res.write("data: [DONE]\n\n");
+        }
+        catch (err) {
+            emitError(res, err, corsHeaders, sanitizeError, {
+                provider: "gemini",
+                inputTokens: totalInputTokens,
+                outputTokens: totalOutputTokens,
+                thinkingTokens: totalThinkingTokens,
+                cacheReadTokens: totalCacheReadTokens,
+            });
+        }
+        finally {
+            if (heartbeat)
+                clearInterval(heartbeat);
+        }
+        res.end();
+    }
+    // ---- Provider-specific config methods ----
+    getThinkingConfig(_model, enabled) {
+        if (!enabled) {
+            return { thinking: { type: "disabled" }, beta: "" };
+        }
+        // Gemini models: thinking is always-on for 2.5+/3.x — signal pass-through
+        return { thinking: { type: "enabled" }, 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) {
+        // Gemini doesn't use Anthropic betas or context management
+        return { betas: [], config: { edits: [] } };
+    }
+    getCompactionConfig(_model) {
+        return { triggerTokens: 700_000, totalBudget: 4_000_000, isNative: false };
+    }
+    getCapabilities() {
+        return getCapabilities("gemini");
+    }
+}
+// Auto-register on import
+registerProvider("gemini", new GeminiAdapter());

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

@@ -0,0 +1,24 @@
+/**
+ * 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 type { ProviderAdapter, ProviderStreamConfig, ProviderCapabilities, ThinkingConfigResult, ContextManagementConfig, CompactionConfig } from "./types.js";
+import type http from "node:http";
+export declare class OpenAIAdapter implements ProviderAdapter {
+    name: string;
+    handleStream(res: http.ServerResponse, config: ProviderStreamConfig, corsHeaders: Record<string, string>): Promise<void>;
+    getThinkingConfig(model: string, enabled: boolean): ThinkingConfigResult;
+    getMaxOutputTokens(model: string, agentMax?: number): number;
+    getContextManagement(_model: string): ContextManagementConfig;
+    getCompactionConfig(_model: string): CompactionConfig;
+    getCapabilities(): ProviderCapabilities;
+}