@earendil-works/pi-ai 0.84.4 → 0.85.1

package/dist/api/anthropic-messages.js

@@ -1,6 +1,7 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { calculateCost } from "../models.js";
 import { splitDeferredTools } from "../utils/deferred-tools.js";
+import { appendAssistantMessageDiagnostic } from "../utils/diagnostics.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
@@ -37,7 +38,7 @@ function getCacheControl(model, cacheRetention, env) {
     };
 }
 // Stealth mode: Mimic Claude Code's tool naming exactly
-const claudeCodeVersion = "2.1.75";
+const claudeCodeVersion = "2.1.251";
 // 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
@@ -111,6 +112,8 @@ function convertContentBlocks(content) {
 const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
 const SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
+const MID_CONVERSATION_OUTPUT_CONFIG_BETA = "mid-conversation-output-config-2026-07-01";
+const THINKING_BINDING_CONTROLS_BETA = "thinking-binding-controls-2026-08-01";
 function shouldUseServerSideFallbackBeta(model) {
     return (model.compat?.allowedFallbackModels?.length ?? 0) > 0;
 }
@@ -327,12 +330,14 @@ async function* iterateAnthropicEvents(response, signal) {
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
     (async () => {
+        const providerThinkingLevel = model.compat?.supportsMidConvoEffort ? (options?.effort ?? "high") : undefined;
         const output = {
             role: "assistant",
             content: [],
             api: model.api,
             provider: model.provider,
             model: model.id,
+            ...(providerThinkingLevel === undefined ? {} : { providerThinkingLevel }),
             usage: {
                 input: 0,
                 output: 0,
@@ -348,6 +353,7 @@ export const stream = (model, context, options) => {
             let client;
             let isOAuth;
             let usageModel = model;
+            let inputTransformations;
             if (options?.client) {
                 client = options.client;
                 isOAuth = false;
@@ -365,21 +371,21 @@ export const stream = (model, context, options) => {
                 }
                 const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
                 const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), shouldUseServerSideFallbackBeta(model), options?.headers, options?.fetch, copilotDynamicHeaders, cacheSessionId);
+                const created = createClient(model, apiKey, options?.headers, options?.fetch, 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;
+                params = { ...nextParams, stream: true };
             }
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
                 maxRetries: 0,
             };
-            const response = await retryProviderRequest(() => client.messages.create({ ...params, stream: true }, requestOptions).asResponse(), {
+            const response = await retryProviderRequest(() => client.beta.messages.create(params, requestOptions).asResponse(), {
                 maxRetries: options?.maxRetries,
                 maxRetryDelayMs: options?.maxRetryDelayMs,
                 signal: options?.signal,
@@ -390,6 +396,9 @@ export const stream = (model, context, options) => {
             for await (const event of iterateAnthropicEvents(response, options?.signal)) {
                 if (event.type === "message_start") {
                     output.responseId = event.message.id;
+                    const transformations = event.message.input_transformations;
+                    if (Array.isArray(transformations))
+                        inputTransformations = transformations;
                     output.model = event.message.model;
                     const fallbackCost = output.model === model.id
                         ? undefined
@@ -408,6 +417,12 @@ export const stream = (model, context, options) => {
                     calculateCost(usageModel, output.usage);
                 }
                 else if (event.type === "content_block_start") {
+                    if (event.content_block.type === "fallback") {
+                        if (output.content.length > 0) {
+                            throw new Error("Anthropic performed an unsupported mid-output model fallback");
+                        }
+                        continue;
+                    }
                     if (event.content_block.type === "text") {
                         const block = {
                             type: "text",
@@ -539,6 +554,9 @@ export const stream = (model, context, options) => {
                     }
                 }
                 else if (event.type === "message_delta") {
+                    const transformations = event.input_transformations;
+                    if (Array.isArray(transformations))
+                        inputTransformations = transformations;
                     if (event.delta.stop_reason) {
                         output.rawStopReason = event.delta.stop_reason;
                         const stopReasonResult = mapStopReason(event.delta.stop_reason, event.delta.stop_details);
@@ -562,11 +580,8 @@ export const stream = (model, context, options) => {
                         if (event.usage.cache_creation_input_tokens != null) {
                             output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
                         }
-                        // Anthropic reports reasoning tokens in `output_tokens_details.thinking_tokens` on the
-                        // final message_delta usage (a subset of output_tokens). SDK 0.91.1 omits the field from
-                        // its Usage type, so read it through a narrow cast. Verified against the live API.
-                        const thinkingTokens = event.usage
-                            .output_tokens_details?.thinking_tokens;
+                        // Anthropic reports reasoning tokens as a subset of output tokens.
+                        const thinkingTokens = event.usage.output_tokens_details?.thinking_tokens;
                         if (thinkingTokens != null) {
                             output.usage.reasoning = thinkingTokens;
                         }
@@ -586,6 +601,19 @@ export const stream = (model, context, options) => {
             if (output.stopReason === "aborted" || output.stopReason === "error") {
                 throw new Error(output.errorMessage || "An unknown error occurred");
             }
+            if (inputTransformations && inputTransformations.length > 0) {
+                appendAssistantMessageDiagnostic(output, {
+                    type: "anthropic_input_transformations",
+                    timestamp: Date.now(),
+                    details: {
+                        transformations: inputTransformations.map((transformation) => ({
+                            type: transformation.type ?? undefined,
+                            path: transformation.path ?? undefined,
+                            reason: transformation.reason ?? undefined,
+                        })),
+                    },
+                });
+            }
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
@@ -660,20 +688,8 @@ export const streamSimple = (model, context, options) => {
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, useServerSideFallbackBeta, optionsHeaders, fetch, dynamicHeaders, sessionId) {
-    // Adaptive thinking models have interleaved thinking built in, so skip the beta header.
-    const needsInterleavedBeta = interleavedThinking && model.compat?.forceAdaptiveThinking !== true;
-    const betaFeatures = [];
-    if (useFineGrainedToolStreamingBeta) {
-        betaFeatures.push(FINE_GRAINED_TOOL_STREAMING_BETA);
-    }
-    if (needsInterleavedBeta) {
-        betaFeatures.push(INTERLEAVED_THINKING_BETA);
-    }
-    if (useServerSideFallbackBeta) {
-        betaFeatures.push(SERVER_SIDE_FALLBACK_BETA);
-    }
-    // Copilot: Bearer auth, selective betas.
+function createClient(model, apiKey, optionsHeaders, fetch, dynamicHeaders, sessionId) {
+    // Copilot: Bearer auth.
     if (model.provider === "github-copilot") {
         const client = new Anthropic({
             apiKey: null,
@@ -684,7 +700,6 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
             defaultHeaders: mergeClientHeaders({
                 accept: "application/json",
                 "anthropic-dangerous-direct-browser-access": "true",
-                ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
             }, model.headers, dynamicHeaders, optionsHeaders),
         });
         return { client, isOAuthToken: false };
@@ -700,7 +715,6 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
             defaultHeaders: mergeClientHeaders({
                 accept: "application/json",
                 "anthropic-dangerous-direct-browser-access": "true",
-                "anthropic-beta": ["claude-code-20250219", "oauth-2025-04-20", ...betaFeatures].join(","),
                 "user-agent": `claude-cli/${claudeCodeVersion}`,
                 "x-app": "cli",
             }, model.headers, optionsHeaders),
@@ -712,7 +726,6 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     const defaultHeaders = mergeClientHeaders({
         accept: "application/json",
         "anthropic-dangerous-direct-browser-access": "true",
-        ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
     }, sessionAffinityHeaders, model.headers, optionsHeaders);
     const client = new Anthropic({
         apiKey: apiKey ?? null,
@@ -724,6 +737,42 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     });
     return { client, isOAuthToken: false };
 }
+function getBetaFeatures(model, context, isOAuthToken, options) {
+    let configuredFeatures;
+    for (const headers of [model.headers, options?.headers]) {
+        for (const [name, value] of Object.entries(headers ?? {})) {
+            if (name.toLowerCase() === "anthropic-beta")
+                configuredFeatures = value;
+        }
+    }
+    if (configuredFeatures === null)
+        return [];
+    if (configuredFeatures !== undefined) {
+        return [
+            ...new Set(configuredFeatures
+                .split(",")
+                .map((feature) => feature.trim())
+                .filter((feature) => feature.length > 0)),
+        ];
+    }
+    const features = [];
+    if (isOAuthToken)
+        features.push("claude-code-20250219", "oauth-2025-04-20");
+    if (shouldUseFineGrainedToolStreamingBeta(model, context))
+        features.push(FINE_GRAINED_TOOL_STREAMING_BETA);
+    if (model.reasoning &&
+        options?.thinkingEnabled === true &&
+        (options.interleavedThinking ?? true) &&
+        model.compat?.forceAdaptiveThinking !== true) {
+        features.push(INTERLEAVED_THINKING_BETA);
+    }
+    if (shouldUseServerSideFallbackBeta(model))
+        features.push(SERVER_SIDE_FALLBACK_BETA);
+    if (model.compat?.supportsMidConvoEffort === true) {
+        features.push(MID_CONVERSATION_OUTPUT_CONFIG_BETA, THINKING_BINDING_CONTROLS_BETA);
+    }
+    return [...new Set(features)];
+}
 function buildParams(model, context, isOAuthToken, options) {
     const { cacheControl } = getCacheControl(model, options?.cacheRetention, options?.env);
     const compat = getAnthropicCompat(model);
@@ -737,11 +786,17 @@ function buildParams(model, context, isOAuthToken, options) {
         deferredTools = [];
     }
     const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
+    const converted = convertMessages(transformedMessages, isOAuthToken, cacheControl, compat.allowEmptySignature, deferredToolNames, normalizeToolName, model.compat?.supportsMidConvoEffort === true ? model.provider : undefined);
+    const activeEffort = options?.effort ?? "high";
+    const betaFeatures = getBetaFeatures(model, context, isOAuthToken, options);
     const params = {
         model: model.id,
-        messages: convertMessages(transformedMessages, isOAuthToken, cacheControl, compat.allowEmptySignature, deferredToolNames, normalizeToolName),
+        messages: model.compat?.supportsMidConvoEffort === true
+            ? insertThinkingLevelMessages(converted, activeEffort)
+            : converted.messages,
         max_tokens: options?.maxTokens ?? model.maxTokens,
         stream: true,
+        ...(betaFeatures.length > 0 ? { betas: betaFeatures } : {}),
     };
     // For OAuth tokens, we MUST include Claude Code identity
     if (isOAuthToken) {
@@ -771,7 +826,10 @@ function buildParams(model, context, isOAuthToken, options) {
         ];
     }
     // Temperature is incompatible with extended thinking and unsupported on Claude Opus 4.7+.
-    if (options?.temperature !== undefined && !options?.thinkingEnabled && compat.supportsTemperature) {
+    if (options?.temperature !== undefined &&
+        !options?.thinkingEnabled &&
+        model.compat?.supportsMidConvoEffort !== true &&
+        compat.supportsTemperature) {
         params.temperature = options.temperature;
     }
     if (immediateTools.length > 0 || deferredTools.length > 0) {
@@ -780,8 +838,17 @@ function buildParams(model, context, isOAuthToken, options) {
             ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
         ];
     }
-    // Configure thinking mode: adaptive, budget-based, or explicitly disabled.
-    if (model.reasoning) {
+    // Managed effort models always use adaptive thinking so prefix mismatches can
+    // be dropped instead of surfacing as persistent 400 responses.
+    if (model.compat?.supportsMidConvoEffort === true) {
+        params.thinking = {
+            type: "adaptive",
+            display: options?.thinkingDisplay ?? "summarized",
+            block_binding: { prefix_mismatch_behavior: "drop_block" },
+        };
+        params.output_config = { effort: "high" };
+    }
+    else 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").
@@ -790,11 +857,7 @@ function buildParams(model, context, isOAuthToken, options) {
                 // 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 };
+                    params.output_config = { effort: options.effort };
                 }
             }
             else {
@@ -862,8 +925,9 @@ function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames
                 : convertedContent,
     };
 }
-function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowEmptySignature = false, deferredToolNames = new Set(), normalizeToolName = (name) => name) {
+function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowEmptySignature = false, deferredToolNames = new Set(), normalizeToolName = (name) => name, managedProvider) {
     const params = [];
+    const assistantLevels = new Map();
     const loadedToolNames = new Set();
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
@@ -967,10 +1031,17 @@ function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowE
             }
             if (blocks.length === 0)
                 continue;
+            const messageIndex = params.length;
             params.push({
                 role: "assistant",
                 content: blocks,
             });
+            if (managedProvider !== undefined &&
+                msg.api === "anthropic-messages" &&
+                msg.provider === managedProvider &&
+                isAnthropicEffort(msg.providerThinkingLevel)) {
+                assistantLevels.set(messageIndex, msg.providerThinkingLevel);
+            }
         }
         else if (msg.role === "toolResult") {
             // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint.
@@ -1014,7 +1085,22 @@ function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowE
             }
         }
     }
-    return params;
+    return { messages: params, assistantLevels };
+}
+function isAnthropicEffort(value) {
+    return value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+}
+function insertThinkingLevelMessages(converted, activeEffort) {
+    const messages = [];
+    for (let index = 0; index < converted.messages.length; index++) {
+        const historicalEffort = converted.assistantLevels.get(index);
+        if (historicalEffort !== undefined) {
+            messages.push({ role: "system", content: [], output_config: { effort: historicalEffort } });
+        }
+        messages.push(converted.messages[index]);
+    }
+    messages.push({ role: "system", content: [], output_config: { effort: activeEffort } });
+    return messages;
 }
 function shouldUseFineGrainedToolStreamingBeta(model, context) {
     return !!context.tools?.length && !getAnthropicCompat(model).supportsEagerToolInputStreaming;