phi-code-ai 0.56.3 → 0.74.0

package/dist/providers/anthropic.js

@@ -2,8 +2,10 @@ import Anthropic from "@anthropic-ai/sdk";
 import { getEnvApiKey } from "../env-api-keys.js";
 import { calculateCost } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
-import { parseStreamingJson } from "../utils/json-parse.js";
+import { headersToRecord } from "../utils/headers.js";
+import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { adjustMaxTokensForThinking, buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -20,19 +22,19 @@ function resolveCacheRetention(cacheRetention) {
     }
     return "short";
 }
-function getCacheControl(baseUrl, cacheRetention) {
+function getCacheControl(model, cacheRetention) {
     const retention = resolveCacheRetention(cacheRetention);
     if (retention === "none") {
         return { retention };
     }
-    const ttl = retention === "long" && baseUrl.includes("api.anthropic.com") ? "1h" : undefined;
+    const ttl = retention === "long" && getAnthropicCompat(model).supportsLongCacheRetention ? "1h" : undefined;
     return {
         retention,
         cacheControl: { type: "ephemeral", ...(ttl && { ttl }) },
     };
 }
 // Stealth mode: Mimic Claude Code's tool naming exactly
-const claudeCodeVersion = "2.1.62";
+const claudeCodeVersion = "2.1.75";
 // Claude Code 2.x tool names (canonical casing)
 // Source: https://cchistory.mariozechner.at/data/prompts-2.1.11.md
 // To update: https://github.com/badlogic/cchistory
@@ -103,6 +105,19 @@ function convertContentBlocks(content) {
     }
     return blocks;
 }
+const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+function getAnthropicCompat(model) {
+    // Auto-detect session affinity and cache control support from provider
+    const isFireworks = model.provider === "fireworks";
+    const isCloudflareAiGatewayAnthropic = model.provider === "cloudflare-ai-gateway" && model.baseUrl.includes("anthropic");
+    return {
+        supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? !isFireworks,
+        supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? !isFireworks,
+        sendSessionAffinityHeaders: model.compat?.sendSessionAffinityHeaders ?? !!(isFireworks || isCloudflareAiGatewayAnthropic),
+        supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? !isFireworks,
+    };
+}
 function mergeHeaders(...headerSources) {
     const merged = {};
     for (const headers of headerSources) {
@@ -112,6 +127,157 @@ function mergeHeaders(...headerSources) {
     }
     return merged;
 }
+const ANTHROPIC_MESSAGE_EVENTS = new Set([
+    "message_start",
+    "message_delta",
+    "message_stop",
+    "content_block_start",
+    "content_block_delta",
+    "content_block_stop",
+]);
+function flushSseEvent(state) {
+    if (!state.event && state.data.length === 0) {
+        return null;
+    }
+    const event = {
+        event: state.event,
+        data: state.data.join("\n"),
+        raw: [...state.raw],
+    };
+    state.event = null;
+    state.data = [];
+    state.raw = [];
+    return event;
+}
+function decodeSseLine(line, state) {
+    if (line === "") {
+        return flushSseEvent(state);
+    }
+    state.raw.push(line);
+    if (line.startsWith(":")) {
+        return null;
+    }
+    const delimiterIndex = line.indexOf(":");
+    const fieldName = delimiterIndex === -1 ? line : line.slice(0, delimiterIndex);
+    let value = delimiterIndex === -1 ? "" : line.slice(delimiterIndex + 1);
+    if (value.startsWith(" ")) {
+        value = value.slice(1);
+    }
+    if (fieldName === "event") {
+        state.event = value;
+    }
+    else if (fieldName === "data") {
+        state.data.push(value);
+    }
+    return null;
+}
+function nextLineBreakIndex(text) {
+    const carriageReturnIndex = text.indexOf("\r");
+    const newlineIndex = text.indexOf("\n");
+    if (carriageReturnIndex === -1) {
+        return newlineIndex;
+    }
+    if (newlineIndex === -1) {
+        return carriageReturnIndex;
+    }
+    return Math.min(carriageReturnIndex, newlineIndex);
+}
+function consumeLine(text) {
+    const lineBreakIndex = nextLineBreakIndex(text);
+    if (lineBreakIndex === -1) {
+        return null;
+    }
+    let nextIndex = lineBreakIndex + 1;
+    if (text[lineBreakIndex] === "\r" && text[nextIndex] === "\n") {
+        nextIndex += 1;
+    }
+    return {
+        line: text.slice(0, lineBreakIndex),
+        rest: text.slice(nextIndex),
+    };
+}
+async function* iterateSseMessages(body, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const state = { event: null, data: [], raw: [] };
+    let buffer = "";
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
+            const { value, done } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let consumed = consumeLine(buffer);
+            while (consumed) {
+                buffer = consumed.rest;
+                const event = decodeSseLine(consumed.line, state);
+                if (event) {
+                    yield event;
+                }
+                consumed = consumeLine(buffer);
+            }
+        }
+        buffer += decoder.decode();
+        let consumed = consumeLine(buffer);
+        while (consumed) {
+            buffer = consumed.rest;
+            const event = decodeSseLine(consumed.line, state);
+            if (event) {
+                yield event;
+            }
+            consumed = consumeLine(buffer);
+        }
+        if (buffer.length > 0) {
+            const event = decodeSseLine(buffer, state);
+            if (event) {
+                yield event;
+            }
+        }
+        const trailingEvent = flushSseEvent(state);
+        if (trailingEvent) {
+            yield trailingEvent;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+async function* iterateAnthropicEvents(response, signal) {
+    if (!response.body) {
+        throw new Error("Attempted to iterate over an Anthropic response with no body");
+    }
+    let sawMessageStart = false;
+    let sawMessageEnd = false;
+    for await (const sse of iterateSseMessages(response.body, signal)) {
+        if (sse.event === "error") {
+            throw new Error(sse.data);
+        }
+        if (!ANTHROPIC_MESSAGE_EVENTS.has(sse.event ?? "")) {
+            continue;
+        }
+        try {
+            const event = parseJsonWithRepair(sse.data);
+            if (event.type === "message_start") {
+                sawMessageStart = true;
+            }
+            else if (event.type === "message_stop") {
+                sawMessageEnd = true;
+            }
+            yield event;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Could not parse Anthropic SSE event ${sse.event}: ${message}; data=${sse.data}; raw=${sse.raw.join("\\n")}`);
+        }
+    }
+    if (sawMessageStart && !sawMessageEnd) {
+        throw new Error("Anthropic stream ended before message_stop");
+    }
+}
 export const streamAnthropic = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
     (async () => {
@@ -133,23 +299,45 @@ export const streamAnthropic = (model, context, options) => {
             timestamp: Date.now(),
         };
         try {
-            const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
-            let copilotDynamicHeaders;
-            if (model.provider === "github-copilot") {
-                const hasImages = hasCopilotVisionInput(context.messages);
-                copilotDynamicHeaders = buildCopilotDynamicHeaders({
-                    messages: context.messages,
-                    hasImages,
-                });
+            let client;
+            let isOAuth;
+            if (options?.client) {
+                client = options.client;
+                isOAuth = false;
+            }
+            else {
+                const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
+                let copilotDynamicHeaders;
+                if (model.provider === "github-copilot") {
+                    const hasImages = hasCopilotVisionInput(context.messages);
+                    copilotDynamicHeaders = buildCopilotDynamicHeaders({
+                        messages: context.messages,
+                        hasImages,
+                    });
+                }
+                const cacheRetention = options?.cacheRetention ?? resolveCacheRetention();
+                const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
+                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, copilotDynamicHeaders, cacheSessionId);
+                client = created.client;
+                isOAuth = created.isOAuthToken;
+            }
+            let params = buildParams(model, context, isOAuth, options);
+            const nextParams = await options?.onPayload?.(params, model);
+            if (nextParams !== undefined) {
+                params = nextParams;
             }
-            const { client, isOAuthToken } = createClient(model, apiKey, options?.interleavedThinking ?? true, options?.headers, copilotDynamicHeaders);
-            const params = buildParams(model, context, isOAuthToken, options);
-            options?.onPayload?.(params);
-            const anthropicStream = client.messages.stream({ ...params, stream: true }, { signal: options?.signal });
+            const requestOptions = {
+                ...(options?.signal ? { signal: options.signal } : {}),
+                ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+                ...(options?.maxRetries !== undefined ? { maxRetries: options.maxRetries } : {}),
+            };
+            const response = await client.messages.create({ ...params, stream: true }, requestOptions).asResponse();
+            await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
-            for await (const event of anthropicStream) {
+            for await (const event of iterateAnthropicEvents(response, options?.signal)) {
                 if (event.type === "message_start") {
+                    output.responseId = event.message.id;
                     // Capture initial token usage from message_start event
                     // This ensures we have input token counts even if the stream is aborted early
                     output.usage.input = event.message.usage.input_tokens || 0;
@@ -196,7 +384,7 @@ export const streamAnthropic = (model, context, options) => {
                         const block = {
                             type: "toolCall",
                             id: event.content_block.id,
-                            name: isOAuthToken
+                            name: isOAuth
                                 ? fromClaudeCodeName(event.content_block.name, context.tools)
                                 : event.content_block.name,
                             arguments: event.content_block.input ?? {},
@@ -280,6 +468,8 @@ export const streamAnthropic = (model, context, options) => {
                         }
                         else if (block.type === "toolCall") {
                             block.arguments = parseStreamingJson(block.partialJson);
+                            // Finalize in-place and strip the scratch buffer so replay only
+                            // carries parsed arguments.
                             delete block.partialJson;
                             stream.push({
                                 type: "toolcall_end",
@@ -324,8 +514,11 @@ export const streamAnthropic = (model, context, options) => {
             stream.end();
         }
         catch (error) {
-            for (const block of output.content)
+            for (const block of output.content) {
                 delete block.index;
+                // partialJson is only a streaming scratch buffer; never persist it.
+                delete block.partialJson;
+            }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
             output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
             stream.push({ type: "error", reason: output.stopReason, error: output });
@@ -335,31 +528,33 @@ export const streamAnthropic = (model, context, options) => {
     return stream;
 };
 /**
- * Check if a model supports adaptive thinking (Opus 4.6 and Sonnet 4.6)
+ * Check if a model supports adaptive thinking (Opus 4.6+, Sonnet 4.6)
  */
 function supportsAdaptiveThinking(modelId) {
-    // Opus 4.6 and Sonnet 4.6 model IDs (with or without date suffix)
+    // Adaptive-thinking model IDs (with or without date suffix)
     return (modelId.includes("opus-4-6") ||
         modelId.includes("opus-4.6") ||
+        modelId.includes("opus-4-7") ||
+        modelId.includes("opus-4.7") ||
         modelId.includes("sonnet-4-6") ||
         modelId.includes("sonnet-4.6"));
 }
 /**
  * Map ThinkingLevel to Anthropic effort levels for adaptive thinking.
- * Note: effort "max" is only valid on Opus 4.6.
+ * Note: effort "max" is only valid on Opus 4.6, while Opus 4.7 supports "xhigh".
  */
-function mapThinkingLevelToEffort(level, modelId) {
+function mapThinkingLevelToEffort(model, level) {
+    const mapped = level ? model.thinkingLevelMap?.[level] : undefined;
+    if (typeof mapped === "string")
+        return mapped;
     switch (level) {
         case "minimal":
-            return "low";
         case "low":
             return "low";
         case "medium":
             return "medium";
         case "high":
             return "high";
-        case "xhigh":
-            return modelId.includes("opus-4-6") || modelId.includes("opus-4.6") ? "max" : "high";
         default:
             return "high";
     }
@@ -376,7 +571,7 @@ export const streamSimpleAnthropic = (model, context, options) => {
     // For Opus 4.6 and Sonnet 4.6: use adaptive thinking with effort level
     // For older models: use budget-based thinking
     if (supportsAdaptiveThinking(model.id)) {
-        const effort = mapThinkingLevelToEffort(options.reasoning, model.id);
+        const effort = mapThinkingLevelToEffort(model, options.reasoning);
         return streamAnthropic(model, context, {
             ...base,
             thinkingEnabled: true,
@@ -394,16 +589,36 @@ export const streamSimpleAnthropic = (model, context, options) => {
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynamicHeaders) {
+function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, optionsHeaders, dynamicHeaders, sessionId) {
     // Adaptive thinking models (Opus 4.6, Sonnet 4.6) have interleaved thinking built-in.
     // The beta header is deprecated on Opus 4.6 and redundant on Sonnet 4.6, so skip it.
     const needsInterleavedBeta = interleavedThinking && !supportsAdaptiveThinking(model.id);
-    // Copilot: Bearer auth, selective betas (no fine-grained-tool-streaming)
+    const betaFeatures = [];
+    if (useFineGrainedToolStreamingBeta) {
+        betaFeatures.push(FINE_GRAINED_TOOL_STREAMING_BETA);
+    }
+    if (needsInterleavedBeta) {
+        betaFeatures.push(INTERLEAVED_THINKING_BETA);
+    }
+    if (model.provider === "cloudflare-ai-gateway") {
+        const client = new Anthropic({
+            apiKey: null,
+            authToken: null,
+            baseURL: resolveCloudflareBaseUrl(model),
+            dangerouslyAllowBrowser: true,
+            defaultHeaders: mergeHeaders({
+                accept: "application/json",
+                "anthropic-dangerous-direct-browser-access": "true",
+                "cf-aig-authorization": `Bearer ${apiKey}`,
+                "x-api-key": null,
+                Authorization: null,
+                ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
+            }, model.headers, optionsHeaders),
+        });
+        return { client, isOAuthToken: false };
+    }
+    // Copilot: Bearer auth, selective betas.
     if (model.provider === "github-copilot") {
-        const betaFeatures = [];
-        if (needsInterleavedBeta) {
-            betaFeatures.push("interleaved-thinking-2025-05-14");
-        }
         const client = new Anthropic({
             apiKey: null,
             authToken: apiKey,
@@ -417,10 +632,6 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynami
         });
         return { client, isOAuthToken: false };
     }
-    const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
-    if (needsInterleavedBeta) {
-        betaFeatures.push("interleaved-thinking-2025-05-14");
-    }
     // OAuth: Bearer auth, Claude Code identity headers
     if (isOAuthToken(apiKey)) {
         const client = new Anthropic({
@@ -431,7 +642,7 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynami
             defaultHeaders: mergeHeaders({
                 accept: "application/json",
                 "anthropic-dangerous-direct-browser-access": "true",
-                "anthropic-beta": `claude-code-20250219,oauth-2025-04-20,${betaFeatures.join(",")}`,
+                "anthropic-beta": ["claude-code-20250219", "oauth-2025-04-20", ...betaFeatures].join(","),
                 "user-agent": `claude-cli/${claudeCodeVersion}`,
                 "x-app": "cli",
             }, model.headers, optionsHeaders),
@@ -439,6 +650,7 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynami
         return { client, isOAuthToken: true };
     }
     // API key auth
+    const sessionAffinityHeaders = sessionId && getAnthropicCompat(model).sendSessionAffinityHeaders ? { "x-session-affinity": sessionId } : {};
     const client = new Anthropic({
         apiKey,
         baseURL: model.baseUrl,
@@ -446,13 +658,13 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynami
         defaultHeaders: mergeHeaders({
             accept: "application/json",
             "anthropic-dangerous-direct-browser-access": "true",
-            "anthropic-beta": betaFeatures.join(","),
-        }, model.headers, optionsHeaders),
+            ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
+        }, sessionAffinityHeaders, model.headers, optionsHeaders),
     });
     return { client, isOAuthToken: false };
 }
 function buildParams(model, context, isOAuthToken, options) {
-    const { cacheControl } = getCacheControl(model.baseUrl, options?.cacheRetention);
+    const { cacheControl } = getCacheControl(model, options?.cacheRetention);
     const params = {
         model: model.id,
         messages: convertMessages(context.messages, model, isOAuthToken, cacheControl),
@@ -490,24 +702,39 @@ function buildParams(model, context, isOAuthToken, options) {
     if (options?.temperature !== undefined && !options?.thinkingEnabled) {
         params.temperature = options.temperature;
     }
-    if (context.tools) {
-        params.tools = convertTools(context.tools, isOAuthToken);
+    if (context.tools && context.tools.length > 0) {
+        const compat = getAnthropicCompat(model);
+        params.tools = convertTools(context.tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined);
     }
-    // Configure thinking mode: adaptive (Opus 4.6 and Sonnet 4.6) or budget-based (older models)
-    if (options?.thinkingEnabled && model.reasoning) {
-        if (supportsAdaptiveThinking(model.id)) {
-            // Adaptive thinking: Claude decides when and how much to think
-            params.thinking = { type: "adaptive" };
-            if (options.effort) {
-                params.output_config = { effort: options.effort };
+    // Configure thinking mode: adaptive (Opus 4.6+ and Sonnet 4.6),
+    // budget-based (older models), or explicitly disabled.
+    if (model.reasoning) {
+        if (options?.thinkingEnabled) {
+            // Default to "summarized" so Opus 4.7 and Mythos Preview behave like
+            // older Claude 4 models (whose API default is also "summarized").
+            const display = options.thinkingDisplay ?? "summarized";
+            if (supportsAdaptiveThinking(model.id)) {
+                // Adaptive thinking: Claude decides when and how much to think.
+                params.thinking = { type: "adaptive", display };
+                if (options.effort) {
+                    // The Anthropic SDK types can lag newly supported effort values such as "xhigh".
+                    params.output_config =
+                        options.effort === "xhigh"
+                            ? { effort: options.effort }
+                            : { effort: options.effort };
+                }
+            }
+            else {
+                // Budget-based thinking for older models
+                params.thinking = {
+                    type: "enabled",
+                    budget_tokens: options.thinkingBudgetTokens || 1024,
+                    display,
+                };
             }
         }
-        else {
-            // Budget-based thinking for older models
-            params.thinking = {
-                type: "enabled",
-                budget_tokens: options.thinkingBudgetTokens || 1024,
-            };
+        else if (options?.thinkingEnabled === false) {
+            params.thinking = { type: "disabled" };
         }
     }
     if (options?.metadata) {
@@ -564,8 +791,7 @@ function convertMessages(messages, model, isOAuthToken, cacheControl) {
                         };
                     }
                 });
-                let filteredBlocks = !model?.input.includes("image") ? blocks.filter((b) => b.type !== "image") : blocks;
-                filteredBlocks = filteredBlocks.filter((b) => {
+                const filteredBlocks = blocks.filter((b) => {
                     if (b.type === "text") {
                         return b.text.trim().length > 0;
                     }
@@ -689,19 +915,24 @@ function convertMessages(messages, model, isOAuthToken, cacheControl) {
     }
     return params;
 }
-function convertTools(tools, isOAuthToken) {
+function shouldUseFineGrainedToolStreamingBeta(model, context) {
+    return !!context.tools?.length && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
+}
+function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cacheControl) {
     if (!tools)
         return [];
-    return tools.map((tool) => {
-        const jsonSchema = tool.parameters; // TypeBox already generates JSON Schema
+    return tools.map((tool, index) => {
+        const schema = tool.parameters;
         return {
             name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
             description: tool.description,
+            ...(supportsEagerToolInputStreaming ? { eager_input_streaming: true } : {}),
             input_schema: {
                 type: "object",
-                properties: jsonSchema.properties || {},
-                required: jsonSchema.required || [],
+                properties: schema.properties ?? {},
+                required: schema.required ?? [],
             },
+            ...(cacheControl && index === tools.length - 1 ? { cache_control: cacheControl } : {}),
         };
     });
 }