whale-code 6.4.0

package/dist/server/providers/anthropic.js

@@ -0,0 +1,199 @@
+/**
+ * Anthropic Provider Adapter — direct Anthropic API passthrough.
+ *
+ * Simplest adapter: system prompt gets cache_control blocks, tools get
+ * { name, description, input_schema }, streaming events pass through as-is.
+ *
+ * Phase 7.1: Also encapsulates thinking config, context management,
+ * output token limits, and compaction config for Anthropic/Claude models.
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { sanitizeError } from "../../shared/agent-core.js";
+import { getCapabilities } from "../lib/provider-capabilities.js";
+import { registerProvider } from "./registry.js";
+import { jsonResponse, writeSSEHeaders } from "./shared.js";
+// ============================================================================
+// CONSTANTS — Anthropic-specific model config
+// ============================================================================
+const COMPACTION_TRIGGER_TOKENS = 120_000;
+const COMPACTION_TOTAL_BUDGET = 2_000_000;
+const DEFAULT_OUTPUT_TOKENS = 16384;
+const MODEL_MAX_OUTPUT_TOKENS = {
+    "claude-opus-4-6": 128000,
+    "claude-sonnet-4-6": 64000,
+    "claude-haiku-4-5-20251001": 64000,
+    "claude-sonnet-4-5-20250929": 64000,
+    "claude-opus-4-5-20251101": 64000,
+    "claude-opus-4-1-20250805": 32768,
+    "claude-sonnet-4-20250514": 64000,
+    "claude-opus-4-20250514": 32768,
+    "claude-3-7-sonnet-20250219": 64000,
+    "claude-3-haiku-20240307": 4096,
+};
+// ============================================================================
+// ADAPTER
+// ============================================================================
+export class AnthropicAdapter {
+    name = "anthropic";
+    async handleStream(res, config, corsHeaders) {
+        const { model, messages, system, tools, max_tokens, temperature, stream = true, betas, context_management, thinking, tool_choice, documents, } = config;
+        const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+        const anthropic = new Anthropic({ apiKey: ANTHROPIC_API_KEY });
+        const apiParams = { model, max_tokens, messages, stream: true };
+        if (system) {
+            if (typeof system === "string") {
+                apiParams.system = [{ type: "text", text: system, cache_control: { type: "ephemeral" } }];
+            }
+            else {
+                apiParams.system = system;
+            }
+        }
+        if (tools?.length) {
+            apiParams.tools = tools.map((t) => ({
+                name: t.name,
+                description: typeof t.description === "string" ? t.description.slice(0, 4096) : "",
+                input_schema: t.input_schema,
+            }));
+        }
+        if (temperature !== undefined)
+            apiParams.temperature = temperature;
+        // Citations API: add beta and documents when source documents are provided
+        const effectiveBetas = betas?.length ? [...betas] : [];
+        if (documents?.length) {
+            if (!effectiveBetas.includes("citations-2025-04-15")) {
+                effectiveBetas.push("citations-2025-04-15");
+            }
+            apiParams.documents = documents;
+        }
+        if (effectiveBetas.length)
+            apiParams.betas = effectiveBetas;
+        if (context_management?.edits?.length)
+            apiParams.context_management = context_management;
+        if (thinking)
+            apiParams.thinking = thinking;
+        // Map tool_choice to Anthropic format
+        if (tool_choice) {
+            if (tool_choice === "auto") {
+                apiParams.tool_choice = { type: "auto" };
+            }
+            else if (tool_choice === "any") {
+                apiParams.tool_choice = { type: "any" };
+            }
+            else if (tool_choice === "none") {
+                // "none" means no tools — remove tools from request
+                delete apiParams.tools;
+            }
+            else if (typeof tool_choice === "object" && tool_choice.type === "tool") {
+                apiParams.tool_choice = { type: "tool", name: tool_choice.name };
+            }
+        }
+        if (!stream) {
+            try {
+                const response = effectiveBetas.length
+                    ? await anthropic.beta.messages.create({ ...apiParams, stream: false })
+                    : await anthropic.messages.create({ ...apiParams, stream: false });
+                jsonResponse(res, 200, response, corsHeaders);
+            }
+            catch (err) {
+                jsonResponse(res, 500, { error: sanitizeError(err) }, corsHeaders);
+            }
+            return;
+        }
+        // Streaming: defer SSE headers until stream is successfully created
+        // so we can return proper HTTP errors if the initial API call fails.
+        let heartbeat;
+        try {
+            const response = effectiveBetas.length
+                ? await anthropic.beta.messages.create({ ...apiParams, stream: true })
+                : await anthropic.messages.create(apiParams);
+            // 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);
+            for await (const event of response) {
+                res.write(`data: ${JSON.stringify(event)}\n\n`);
+            }
+            res.write("data: [DONE]\n\n");
+        }
+        catch (err) {
+            if (!res.headersSent) {
+                // Haven't started streaming yet — return proper HTTP error
+                jsonResponse(res, 502, { error: `anthropic error: ${sanitizeError(err)}` }, corsHeaders);
+            }
+            else {
+                // Mid-stream failure — send error event so client doesn't hang
+                res.write(`data: ${JSON.stringify({ type: "error", error: sanitizeError(err) })}\n\n`);
+                res.write("data: [DONE]\n\n");
+            }
+        }
+        finally {
+            if (heartbeat)
+                clearInterval(heartbeat);
+        }
+        res.end();
+    }
+    // ---- Provider-specific config methods ----
+    getThinkingConfig(model, enabled) {
+        if (!enabled) {
+            return { thinking: { type: "disabled" }, beta: "" };
+        }
+        if (model.includes("opus-4-6") || model.includes("sonnet-4-6")) {
+            return {
+                thinking: { type: "adaptive" },
+                beta: "adaptive-thinking-2026-01-28",
+            };
+        }
+        // Sonnet 4.5/4.0 / Haiku: fixed budget
+        return {
+            thinking: { type: "enabled", budget_tokens: 10_000 },
+            beta: "interleaved-thinking-2025-05-14",
+        };
+    }
+    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) {
+        const edits = [];
+        const betas = ["context-management-2025-06-27"];
+        // Thinking block clearing — must come FIRST in edits array (API requirement).
+        edits.push({
+            type: "clear_thinking_20251015",
+            keep: { type: "thinking_turns", value: 2 },
+        });
+        // Server-side compaction for models that support compact_20260112.
+        const supportsCompaction = model.includes("opus-4-6") || model.includes("sonnet-4-6");
+        if (supportsCompaction) {
+            edits.push({
+                type: "compact_20260112",
+                trigger: { type: "input_tokens", value: COMPACTION_TRIGGER_TOKENS },
+                pause_after_compaction: true,
+                instructions: "Summarize the conversation preserving: (1) task goals and constraints, (2) files created/modified with paths, (3) decisions made and rationale, (4) errors encountered and resolutions, (5) exact next steps. Be concise but preserve all state needed to continue work without repeating mistakes.",
+            });
+            betas.push("compact-2026-01-12");
+        }
+        edits.push({
+            type: "clear_tool_uses_20250919",
+            trigger: { type: "input_tokens", value: 80_000 },
+            keep: { type: "tool_uses", value: 3 },
+        });
+        return { betas, config: { edits } };
+    }
+    getCompactionConfig(_model) {
+        return {
+            triggerTokens: COMPACTION_TRIGGER_TOKENS,
+            totalBudget: COMPACTION_TOTAL_BUDGET,
+            isNative: true,
+        };
+    }
+    getCapabilities() {
+        return getCapabilities("anthropic");
+    }
+}
+// Auto-register on import
+registerProvider("anthropic", new AnthropicAdapter());

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

@@ -0,0 +1,20 @@
+/**
+ * Bedrock Provider Adapter — AWS Bedrock Claude streaming.
+ *
+ * Similar to Anthropic but: strips cache_control from system blocks,
+ * uses AWS SDK credentials, parses event.chunk.bytes for streaming.
+ *
+ * Phase 7.1: Also encapsulates thinking config, context management,
+ * output token limits, and compaction config for Bedrock Claude models.
+ */
+import type { ProviderAdapter, ProviderStreamConfig, ProviderCapabilities, ThinkingConfigResult, ContextManagementConfig, CompactionConfig } from "./types.js";
+import type http from "node:http";
+export declare class BedrockAdapter 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;
+}

package/dist/server/providers/bedrock.js

@@ -0,0 +1,194 @@
+/**
+ * Bedrock Provider Adapter — AWS Bedrock Claude streaming.
+ *
+ * Similar to Anthropic but: strips cache_control from system blocks,
+ * uses AWS SDK credentials, parses event.chunk.bytes for streaming.
+ *
+ * Phase 7.1: Also encapsulates thinking config, context management,
+ * output token limits, and compaction config for Bedrock Claude models.
+ */
+import { BedrockRuntimeClient, InvokeModelWithResponseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
+import { sanitizeError } from "../../shared/agent-core.js";
+import { getCapabilities } from "../lib/provider-capabilities.js";
+import { registerProvider } from "./registry.js";
+import { jsonResponse, writeSSEHeaders, resolveProviderCredentials } from "./shared.js";
+// ============================================================================
+// CONSTANTS — Bedrock-specific model config
+// ============================================================================
+const COMPACTION_TRIGGER_TOKENS = 120_000;
+const COMPACTION_TOTAL_BUDGET = 2_000_000;
+const DEFAULT_OUTPUT_TOKENS = 16384;
+const MODEL_MAX_OUTPUT_TOKENS = {
+    "anthropic.claude-sonnet-4-6": 64000,
+    "us.anthropic.claude-sonnet-4-20250514-v1:0": 64000,
+    "us.anthropic.claude-sonnet-4-5-20250929-v1:0": 64000,
+    "us.anthropic.claude-haiku-4-5-20251001-v1:0": 64000,
+};
+// ============================================================================
+// ADAPTER
+// ============================================================================
+export class BedrockAdapter {
+    name = "bedrock";
+    async handleStream(res, config, corsHeaders) {
+        const { model, messages, system, tools, max_tokens, temperature, thinking, storeId, tool_choice } = config;
+        const creds = await resolveProviderCredentials("bedrock", storeId);
+        if (!creds.bedrock) {
+            jsonResponse(res, 422, { error: "Bedrock credentials not configured. Add aws_access_key_id and aws_secret_access_key to platform_secrets." }, corsHeaders);
+            return;
+        }
+        const client = new BedrockRuntimeClient({
+            region: creds.bedrock.region,
+            credentials: {
+                accessKeyId: creds.bedrock.accessKeyId,
+                secretAccessKey: creds.bedrock.secretAccessKey,
+            },
+        });
+        // Build Anthropic Messages API body (Bedrock Claude understands this natively)
+        const bedrockBody = {
+            anthropic_version: "bedrock-2023-10-16",
+            max_tokens,
+            messages,
+        };
+        if (system) {
+            bedrockBody.system = typeof system === "string"
+                ? [{ type: "text", text: system }]
+                : system.map((s) => {
+                    // Strip cache_control — Bedrock doesn't support it
+                    const { cache_control: _, ...rest } = s;
+                    return rest;
+                });
+        }
+        if (tools?.length) {
+            bedrockBody.tools = tools.map((t) => ({
+                name: t.name,
+                description: typeof t.description === "string" ? t.description.slice(0, 4096) : "",
+                input_schema: t.input_schema,
+            }));
+        }
+        if (temperature !== undefined)
+            bedrockBody.temperature = temperature;
+        if (thinking)
+            bedrockBody.thinking = thinking;
+        // Map tool_choice to Anthropic/Bedrock format
+        if (tool_choice) {
+            if (tool_choice === "auto") {
+                bedrockBody.tool_choice = { type: "auto" };
+            }
+            else if (tool_choice === "any") {
+                bedrockBody.tool_choice = { type: "any" };
+            }
+            else if (tool_choice === "none") {
+                // "none" means no tools — remove tools from request
+                delete bedrockBody.tools;
+            }
+            else if (typeof tool_choice === "object" && tool_choice.type === "tool") {
+                bedrockBody.tool_choice = { type: "tool", name: tool_choice.name };
+            }
+        }
+        const command = new InvokeModelWithResponseStreamCommand({
+            modelId: model,
+            contentType: "application/json",
+            accept: "application/json",
+            body: new TextEncoder().encode(JSON.stringify(bedrockBody)),
+        });
+        // Stream SSE — defer headers until stream is successfully created
+        // so we can return proper HTTP errors if the initial API call fails.
+        let heartbeat;
+        try {
+            const response = await client.send(command);
+            // 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);
+            if (response.body) {
+                for await (const event of response.body) {
+                    if (event.chunk?.bytes) {
+                        const chunk = JSON.parse(new TextDecoder().decode(event.chunk.bytes));
+                        res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+                    }
+                }
+            }
+            res.write("data: [DONE]\n\n");
+        }
+        catch (err) {
+            if (!res.headersSent) {
+                // Haven't started streaming yet — return proper HTTP error
+                jsonResponse(res, 502, { error: `bedrock error: ${sanitizeError(err)}` }, corsHeaders);
+            }
+            else {
+                // Mid-stream failure — send error event so client doesn't hang
+                res.write(`data: ${JSON.stringify({ type: "error", error: sanitizeError(err) })}\n\n`);
+                res.write("data: [DONE]\n\n");
+            }
+        }
+        finally {
+            if (heartbeat)
+                clearInterval(heartbeat);
+        }
+        res.end();
+    }
+    // ---- Provider-specific config methods ----
+    // Bedrock uses same thinking/context management as Anthropic (it's Claude underneath)
+    getThinkingConfig(model, enabled) {
+        if (!enabled) {
+            return { thinking: { type: "disabled" }, beta: "" };
+        }
+        // Bedrock model IDs contain the Claude model name
+        if (model.includes("opus-4-6") || model.includes("sonnet-4-6")) {
+            return {
+                thinking: { type: "adaptive" },
+                beta: "adaptive-thinking-2026-01-28",
+            };
+        }
+        return {
+            thinking: { type: "enabled", budget_tokens: 10_000 },
+            beta: "interleaved-thinking-2025-05-14",
+        };
+    }
+    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) {
+        // Bedrock Claude supports the same context management as direct Anthropic
+        const edits = [];
+        const betas = ["context-management-2025-06-27"];
+        edits.push({
+            type: "clear_thinking_20251015",
+            keep: { type: "thinking_turns", value: 2 },
+        });
+        const supportsCompaction = model.includes("opus-4-6") || model.includes("sonnet-4-6");
+        if (supportsCompaction) {
+            edits.push({
+                type: "compact_20260112",
+                trigger: { type: "input_tokens", value: COMPACTION_TRIGGER_TOKENS },
+                pause_after_compaction: true,
+                instructions: "Summarize the conversation preserving: (1) task goals and constraints, (2) files created/modified with paths, (3) decisions made and rationale, (4) errors encountered and resolutions, (5) exact next steps. Be concise but preserve all state needed to continue work without repeating mistakes.",
+            });
+            betas.push("compact-2026-01-12");
+        }
+        edits.push({
+            type: "clear_tool_uses_20250919",
+            trigger: { type: "input_tokens", value: 80_000 },
+            keep: { type: "tool_uses", value: 3 },
+        });
+        return { betas, config: { edits } };
+    }
+    getCompactionConfig(_model) {
+        return {
+            triggerTokens: COMPACTION_TRIGGER_TOKENS,
+            totalBudget: COMPACTION_TOTAL_BUDGET,
+            isNative: true,
+        };
+    }
+    getCapabilities() {
+        return getCapabilities("bedrock");
+    }
+}
+// Auto-register on import
+registerProvider("bedrock", new BedrockAdapter());

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

@@ -0,0 +1,24 @@
+/**
+ * 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 type { ProviderAdapter, ProviderStreamConfig, ProviderCapabilities, ThinkingConfigResult, ContextManagementConfig, CompactionConfig } from "./types.js";
+import type http from "node:http";
+export declare class GeminiAdapter 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;
+}