@code-yeongyu/senpi 2026.7.23 → 2026.7.25-2

package/node_modules/@earendil-works/pi-ai/dist/api/anthropic-messages.js

@@ -1,14 +1,18 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { calculateCost } from "../models.js";
 import { isVideoMimeType } from "../types.js";
+import { combineAbortSignals } from "../utils/abort-signals.js";
 import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord, providerHeadersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
+import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { applyServerFallbackAbort, parseServerFallbackReceipt, parseStickyFallbackReceipt, } from "../utils/server-fallback-receipt.js";
 import { isForcedToolChoiceUnsupportedError, omitToolChoiceParam } from "../utils/tool-choice-fallback.js";
 import { resolveCloudflareBaseUrl } from "./cloudflare.js";
+import { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { ANTHROPIC_RESERVED_BODY_KEYS, adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -134,7 +138,35 @@ const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
 const COMPUTER_USE_BETA_PREFIX = "computer-use-";
 const NATIVE_COMPUTER_TOOL_TYPE = "computer_20250124";
-const ADAPTIVE_THINKING_MODEL_MARKERS = ["opus-4-6", "opus-4-7", "sonnet-4-6"];
+const ADAPTIVE_THINKING_MODEL_MARKERS = [
+    "opus-4-6",
+    "opus-4-7",
+    "opus-4-8",
+    "opus-5",
+    "sonnet-4-6",
+    "sonnet-5",
+    "fable-5",
+    "mythos-5",
+];
+/**
+ * Adaptive families that expose the real `xhigh` effort tier. Everything else on the
+ * adaptive ladder tops out at `max` (Opus/Sonnet 4.6 are four-tier: low/medium/high/max).
+ */
+const NATIVE_XHIGH_EFFORT_MODEL_MARKERS = [
+    "opus-4-7",
+    "opus-4-8",
+    "opus-5",
+    "sonnet-5",
+    "fable-5",
+    "mythos-5",
+];
+/**
+ * Adaptive families that reject `thinking: {type: "disabled"}` outright (verified 400:
+ * `"thinking.type.disabled" is not supported for this model`). The generated catalog also encodes
+ * this as `compat.supportsDisabledThinking: false`, but `models.json` entries and third-party
+ * gateway rows carry no generated compat, so the family fact has to live here as well.
+ */
+const DISABLED_THINKING_REJECTING_MODEL_MARKERS = ["fable-5", "mythos-5"];
 const CLAUDE_FABLE_OR_MYTHOS_MODEL_ID = /^claude-(?:fable|mythos)(?:-|$)/i;
 const UNSUPPORTED_NATIVE_COMPUTER_TOOL_MODEL_MARKERS = [
     "opus-4-6",
@@ -174,6 +206,7 @@ function getAnthropicCompat(model) {
         supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? !CLAUDE_FABLE_OR_MYTHOS_MODEL_ID.test(model.id),
         allowEmptySignature: model.compat?.allowEmptySignature ?? false,
         unsignedThinkingReplay: model.compat?.unsignedThinkingReplay ?? (model.compat?.allowEmptySignature ? "empty-signature" : "text"),
+        supportsStrictTools: model.compat?.supportsStrictTools ?? false,
         supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
         // Default: first-party Anthropic only. Anthropic-compatible providers
         // (kimi-coding, fireworks, copilot, gateways) may execute the server-side
@@ -207,6 +240,9 @@ function mergeHeaders(...headerSources) {
     }
     return merged;
 }
+function hasAuthorizationHeader(headers) {
+    return Object.keys(headers ?? {}).some((name) => name.toLowerCase() === "authorization");
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
@@ -646,6 +682,10 @@ export const stream = (model, context, options) => {
             stopReason: "stop",
             timestamp: Date.now(),
         };
+        const serverFallbackAbort = new AbortController();
+        let serverFallbackReceipt;
+        const combinedAbort = combineAbortSignals([options?.signal, serverFallbackAbort.signal]);
+        const requestSignal = combinedAbort.signal;
         try {
             let client;
             let isOAuth;
@@ -655,7 +695,8 @@ export const stream = (model, context, options) => {
             }
             else {
                 const apiKey = options?.apiKey;
-                if (!apiKey) {
+                const optionsHeaders = providerHeadersToRecord(options?.headers);
+                if (!apiKey && !hasAuthorizationHeader(optionsHeaders)) {
                     throw new Error(`No API key for provider: ${model.provider}`);
                 }
                 let copilotDynamicHeaders;
@@ -668,7 +709,7 @@ export const stream = (model, context, options) => {
                 }
                 const cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env, "long");
                 const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), providerHeadersToRecord(options?.headers), copilotDynamicHeaders, cacheSessionId, options?.env);
+                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), optionsHeaders, copilotDynamicHeaders, cacheSessionId, options?.env);
                 client = created.client;
                 isOAuth = created.isOAuthToken;
             }
@@ -687,9 +728,9 @@ export const stream = (model, context, options) => {
                 const payloadRequestMetadata = extractPayloadRequestMetadata(params);
                 params = payloadRequestMetadata.params;
                 const requestOptions = {
-                    ...(options?.signal ? { signal: options.signal } : {}),
+                    ...(requestSignal ? { signal: requestSignal } : {}),
                     ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                    maxRetries: options?.maxRetries ?? 0,
+                    maxRetries: 0,
                     ...(payloadRequestMetadata.headers ? { headers: payloadRequestMetadata.headers } : {}),
                 };
                 try {
@@ -707,26 +748,28 @@ export const stream = (model, context, options) => {
                     throw error;
                 }
             };
-            let request;
-            try {
-                request = await createRequest();
-            }
-            catch (error) {
-                if (unsignedThinkingReplay !== "text" && isInvalidUnsignedThinkingSignatureError(error)) {
-                    unsignedThinkingReplay = "text";
-                    if (fallbackKey)
-                        unsignedThinkingTextReplayFallbacks.add(fallbackKey);
-                    request = await createRequest();
+            const { params: sentParams, response } = await retryProviderRequest(async () => {
+                try {
+                    return await createRequest();
                 }
-                else {
+                catch (error) {
+                    if (unsignedThinkingReplay !== "text" && isInvalidUnsignedThinkingSignatureError(error)) {
+                        unsignedThinkingReplay = "text";
+                        if (fallbackKey)
+                            unsignedThinkingTextReplayFallbacks.add(fallbackKey);
+                        return createRequest();
+                    }
                     throw error;
                 }
-            }
-            const { response } = request;
+            }, {
+                maxRetries: options?.maxRetries,
+                maxRetryDelayMs: options?.maxRetryDelayMs,
+                signal: requestSignal,
+            });
             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 iterateAnthropicEvents(response, options?.signal)) {
+            for await (const event of iterateAnthropicEvents(response, requestSignal)) {
                 if (event.type === "message_start") {
                     output.responseId = event.message.id;
                     // Capture initial token usage from message_start event
@@ -740,8 +783,24 @@ export const stream = (model, context, options) => {
                     output.usage.totalTokens =
                         output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
                     calculateCost(model, output.usage);
+                    const stickyReceipt = options?.abortServerSideFallback === true
+                        ? parseStickyFallbackReceipt(event.message.usage, sentParams.model, event.message.model)
+                        : undefined;
+                    if (stickyReceipt !== undefined) {
+                        serverFallbackReceipt = stickyReceipt;
+                        serverFallbackAbort.abort();
+                        break;
+                    }
                 }
                 else if (event.type === "content_block_start") {
+                    const receipt = options?.abortServerSideFallback === true
+                        ? parseServerFallbackReceipt(event.content_block)
+                        : undefined;
+                    if (receipt !== undefined) {
+                        serverFallbackReceipt = receipt;
+                        serverFallbackAbort.abort();
+                        break;
+                    }
                     if (event.content_block.type === "text") {
                         const block = {
                             type: "text",
@@ -939,13 +998,18 @@ export const stream = (model, context, options) => {
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
+            if (serverFallbackReceipt !== undefined) {
+                applyServerFallbackAbort(output, serverFallbackReceipt);
+            }
             if (output.stopReason === "aborted" || output.stopReason === "error") {
                 throw new Error(output.errorMessage || "An unknown error occurred");
             }
+            combinedAbort.cleanup();
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
         catch (error) {
+            combinedAbort.cleanup();
             for (const block of output.content) {
                 delete block.index;
                 // An aborted stream never reaches content_block_stop; keep whatever
@@ -980,11 +1044,16 @@ function matchesModelMarker(model, markers) {
     const candidates = getModelMatchCandidates(model);
     return candidates.some((candidate) => markers.some((marker) => candidate.includes(marker)));
 }
-function isOpus46(model) {
-    return matchesModelMarker(model, ["opus-4-6"]);
+function supportsNativeXhighEffort(model) {
+    return matchesModelMarker(model, NATIVE_XHIGH_EFFORT_MODEL_MARKERS);
 }
-function isOpus47(model) {
-    return matchesModelMarker(model, ["opus-4-7"]);
+/** True when the model cannot accept `thinking: {type: "disabled"}` on the wire. */
+function cannotDisableThinking(model, compat) {
+    if (!compat.supportsDisabledThinking)
+        return true;
+    if (model.thinkingLevelMap?.off === null)
+        return true;
+    return matchesModelMarker(model, DISABLED_THINKING_REJECTING_MODEL_MARKERS);
 }
 function supportsAdaptiveThinking(model) {
     if (model.compat?.forceAdaptiveThinking !== undefined) {
@@ -995,7 +1064,7 @@ function supportsAdaptiveThinking(model) {
 /**
  * Map ThinkingLevel to Anthropic effort levels for adaptive thinking.
  * Note: effort "max" is available on all adaptive-thinking Claude models, while native
- * "xhigh" is only available on Opus 4.7/4.8, Sonnet 5, and Fable 5.
+ * "xhigh" is only available on Opus 4.7/4.8, Opus 5, Sonnet 5, and Fable 5.
  */
 function mapThinkingLevelToEffort(model, level) {
     const mapped = level ? model.thinkingLevelMap?.[level] : undefined;
@@ -1010,22 +1079,18 @@ function mapThinkingLevelToEffort(model, level) {
         case "high":
             return "high";
         case "xhigh":
-            if (isOpus47(model))
-                return "xhigh";
-            if (isOpus46(model))
-                return "max";
-            return "high";
+            // Only called for adaptive models, so the floor is the adaptive ladder's top
+            // tier (`max`), never `high` — degrading xhigh to high silently under-thinks.
+            return supportsNativeXhighEffort(model) ? "xhigh" : "max";
         case "max":
-            if (isOpus47(model) || isOpus46(model))
-                return "max";
-            return "high";
+            return "max";
         default:
             return "high";
     }
 }
 export const streamSimple = (model, context, options) => {
     const apiKey = options?.apiKey;
-    if (!apiKey) {
+    if (!apiKey && !hasAuthorizationHeader(providerHeadersToRecord(options?.headers))) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
     const base = buildBaseOptions(model, context, options, options?.apiKey);
@@ -1099,7 +1164,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
         return { client, isOAuthToken: false };
     }
     // OAuth: Bearer auth, Claude Code identity headers
-    if (isOAuthToken(apiKey)) {
+    if (apiKey && isOAuthToken(apiKey)) {
         const client = new Anthropic({
             apiKey: null,
             authToken: apiKey,
@@ -1118,7 +1183,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     // API key auth
     const sessionAffinityHeaders = sessionId && getAnthropicCompat(model).sendSessionAffinityHeaders ? { "x-session-affinity": sessionId } : {};
     const client = new Anthropic({
-        apiKey,
+        apiKey: apiKey ?? null,
         authToken: null,
         baseURL: model.baseUrl,
         dangerouslyAllowBrowser: true,
@@ -1195,8 +1260,8 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
     }
     if (immediateTools.length > 0 || deferredTools.length > 0) {
         params.tools = [
-            ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined),
-            ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, undefined, true),
+            ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, compat.supportsCacheControlOnTools ? cacheControl : undefined),
+            ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
         ];
     }
     // Configure thinking mode: adaptive, budget-based, or explicitly disabled.
@@ -1222,10 +1287,19 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
                 };
             }
         }
-        else if (options?.thinkingEnabled === false &&
-            compat.supportsDisabledThinking &&
-            model.thinkingLevelMap?.off !== null) {
-            params.thinking = { type: "disabled" };
+        else if (options?.thinkingEnabled === false) {
+            if (cannotDisableThinking(model, compat)) {
+                // These families reject `thinking.type: "disabled"` with a 400 AND default to adaptive
+                // thinking when the field is absent, so omitting it silently bills full reasoning for a
+                // "thinking off" turn. The API exposes no true off switch here, so pin the cheapest
+                // effort: the request stays valid and reasoning stays at the documented minimum.
+                if (supportsAdaptiveThinking(model)) {
+                    params.output_config = { effort: "low" };
+                }
+            }
+            else {
+                params.thinking = { type: "disabled" };
+            }
         }
     }
     if (options?.metadata) {
@@ -1495,20 +1569,29 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
 function shouldUseFineGrainedToolStreamingBeta(model, context) {
     return !!context.tools?.length && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
 }
-function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cacheControl, deferLoading = false) {
+function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl, deferLoading = false) {
     if (!tools)
         return [];
     return tools.map((tool, index) => {
+        const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictTools);
         const schema = tool.parameters;
+        const legacyInputSchema = {
+            type: "object",
+            properties: schema.properties ?? {},
+            required: schema.required ?? [],
+        };
+        const inputSchema = strict === true
+            ? {
+                ...tool.parameters,
+                ...legacyInputSchema,
+            }
+            : legacyInputSchema;
         return {
             name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
             description: tool.description,
             ...(supportsEagerToolInputStreaming ? { eager_input_streaming: true } : {}),
-            input_schema: {
-                type: "object",
-                properties: schema.properties ?? {},
-                required: schema.required ?? [],
-            },
+            ...(strict === true ? { strict: true } : {}),
+            input_schema: inputSchema,
             ...(deferLoading ? { defer_loading: true } : {}),
             ...(cacheControl && index === tools.length - 1 ? { cache_control: cacheControl } : {}),
         };