@draht/ai 2026.7.13 → 2026.7.30

package/dist/api/anthropic-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../src/api/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAU1C,OAAO,KAAK,EAWX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AAoIrB,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AAkBhE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACtD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,wBAAwB,CAAC;IAC3C;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACnB;AAiOD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CAiRzE,CAAC;AA2BF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CAwClF,CAAC"}
+{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../src/api/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAU1C,OAAO,KAAK,EAWX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AAuIrB,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AAkChE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACtD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,wBAAwB,CAAC;IAC3C;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,CAAC;CACnB;AAiOD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CA+RzE,CAAC;AA2BF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CAwClF,CAAC"}

package/dist/api/anthropic-messages.js

@@ -1,10 +1,13 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { calculateCost } from "../models.js";
+import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } 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 { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -114,8 +117,25 @@ function getAnthropicCompat(model) {
         supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? true,
         supportsTemperature: model.compat?.supportsTemperature ?? true,
         allowEmptySignature: model.compat?.allowEmptySignature ?? false,
+        supportsStrictTools: model.compat?.supportsStrictTools ?? false,
+        supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
     };
 }
+/**
+ * Default for `supportsToolReferences`: first-party Anthropic models except
+ * Haiku (rejects client-side tool_reference blocks) and models that predate
+ * tool search (Claude 3.x, Opus/Sonnet 4.0, Opus 4.1).
+ */
+function defaultSupportsToolReferences(model) {
+    if (model.provider !== "anthropic" || model.id.includes("haiku"))
+        return false;
+    const version = model.id.match(/^claude-(?:opus|sonnet|fable)-(\d+)(?:-(\d+))?(?:-|$)/);
+    if (!version)
+        return false;
+    const major = Number(version[1]);
+    const minor = version[2] && version[2].length < 8 ? Number(version[2]) : 0;
+    return major > 4 || (major === 4 && minor >= 5);
+}
 function mergeHeaders(...headerSources) {
     const merged = {};
     for (const headers of headerSources) {
@@ -313,7 +333,7 @@ export const stream = (model, context, options) => {
                 totalTokens: 0,
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
             },
-            stopReason: "stop",
+            stopReason: "pending",
             timestamp: Date.now(),
         };
         try {
@@ -336,7 +356,7 @@ 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), options?.headers, copilotDynamicHeaders, cacheSessionId);
+                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, options?.fetch, copilotDynamicHeaders, cacheSessionId);
                 client = created.client;
                 isOAuth = created.isOAuthToken;
             }
@@ -348,9 +368,13 @@ export const stream = (model, context, options) => {
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-                maxRetries: options?.maxRetries ?? 0,
+                maxRetries: 0,
             };
-            const response = await client.messages.create({ ...params, stream: true }, requestOptions).asResponse();
+            const response = await retryProviderRequest(() => client.messages.create({ ...params, stream: true }, requestOptions).asResponse(), {
+                maxRetries: options?.maxRetries,
+                maxRetryDelayMs: options?.maxRetryDelayMs,
+                signal: options?.signal,
+            });
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
@@ -502,6 +526,7 @@ export const stream = (model, context, options) => {
                 }
                 else if (event.type === "message_delta") {
                     if (event.delta.stop_reason) {
+                        output.rawStopReason = event.delta.stop_reason;
                         const stopReasonResult = mapStopReason(event.delta.stop_reason, event.delta.stop_details);
                         output.stopReason = stopReasonResult.stopReason;
                         if (stopReasonResult.errorMessage) {
@@ -510,25 +535,27 @@ export const stream = (model, context, options) => {
                     }
                     // Only update usage fields if present (not null).
                     // Preserves input_tokens from message_start when proxies omit it in message_delta.
-                    if (event.usage.input_tokens != null) {
-                        output.usage.input = event.usage.input_tokens;
-                    }
-                    if (event.usage.output_tokens != null) {
-                        output.usage.output = event.usage.output_tokens;
-                    }
-                    if (event.usage.cache_read_input_tokens != null) {
-                        output.usage.cacheRead = event.usage.cache_read_input_tokens;
-                    }
-                    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;
-                    if (thinkingTokens != null) {
-                        output.usage.reasoning = thinkingTokens;
+                    if (event.usage) {
+                        if (event.usage.input_tokens != null) {
+                            output.usage.input = event.usage.input_tokens;
+                        }
+                        if (event.usage.output_tokens != null) {
+                            output.usage.output = event.usage.output_tokens;
+                        }
+                        if (event.usage.cache_read_input_tokens != null) {
+                            output.usage.cacheRead = event.usage.cache_read_input_tokens;
+                        }
+                        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;
+                        if (thinkingTokens != null) {
+                            output.usage.reasoning = thinkingTokens;
+                        }
                     }
                     // Anthropic doesn't provide total_tokens, compute from components
                     output.usage.totalTokens =
@@ -539,6 +566,9 @@ export const stream = (model, context, options) => {
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
+            if (output.stopReason === "pending") {
+                throw new Error("Anthropic stream ended without a stop reason");
+            }
             if (output.stopReason === "aborted" || output.stopReason === "error") {
                 throw new Error(output.errorMessage || "An unknown error occurred");
             }
@@ -610,7 +640,7 @@ export const streamSimple = (model, context, options) => {
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, optionsHeaders, dynamicHeaders, sessionId) {
+function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, 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 = [];
@@ -627,6 +657,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
             authToken: apiKey ?? null,
             baseURL: model.baseUrl,
             dangerouslyAllowBrowser: true,
+            fetch,
             defaultHeaders: mergeHeaders({
                 accept: "application/json",
                 "anthropic-dangerous-direct-browser-access": "true",
@@ -642,6 +673,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
             authToken: apiKey,
             baseURL: model.baseUrl,
             dangerouslyAllowBrowser: true,
+            fetch,
             defaultHeaders: mergeHeaders({
                 accept: "application/json",
                 "anthropic-dangerous-direct-browser-access": "true",
@@ -664,6 +696,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
         authToken: null,
         baseURL: model.baseUrl,
         dangerouslyAllowBrowser: true,
+        fetch,
         defaultHeaders,
     });
     return { client, isOAuthToken: false };
@@ -671,9 +704,19 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
 function buildParams(model, context, isOAuthToken, options) {
     const { cacheControl } = getCacheControl(model, options?.cacheRetention, options?.env);
     const compat = getAnthropicCompat(model);
+    const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+    const normalizeToolName = isOAuthToken ? toClaudeCodeName : (name) => name;
+    const toolPlacement = splitDeferredTools({ ...context, messages: transformedMessages }, compat.supportsToolReferences, normalizeToolName);
+    let immediateTools = toolPlacement.immediate;
+    let deferredTools = [...toolPlacement.deferred.values()];
+    if (immediateTools.length === 0 && deferredTools.length > 0) {
+        immediateTools = deferredTools;
+        deferredTools = [];
+    }
+    const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
     const params = {
         model: model.id,
-        messages: convertMessages(context.messages, model, isOAuthToken, cacheControl, compat.allowEmptySignature),
+        messages: convertMessages(transformedMessages, isOAuthToken, cacheControl, compat.allowEmptySignature, deferredToolNames, normalizeToolName),
         max_tokens: options?.maxTokens ?? model.maxTokens,
         stream: true,
     };
@@ -708,8 +751,11 @@ function buildParams(model, context, isOAuthToken, options) {
     if (options?.temperature !== undefined && !options?.thinkingEnabled && compat.supportsTemperature) {
         params.temperature = options.temperature;
     }
-    if (context.tools && context.tools.length > 0) {
-        params.tools = convertTools(context.tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined);
+    if (immediateTools.length > 0 || deferredTools.length > 0) {
+        params.tools = [
+            ...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.
     if (model.reasoning) {
@@ -761,10 +807,37 @@ function buildParams(model, context, isOAuthToken, options) {
 function normalizeToolCallId(id) {
     return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmptySignature = false) {
+function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName) {
+    const references = [];
+    for (const name of msg.addedToolNames ?? []) {
+        const normalizedName = normalizeToolName(name);
+        if (!deferredToolNames.has(normalizedName) || loadedToolNames.has(normalizedName))
+            continue;
+        loadedToolNames.add(normalizedName);
+        references.push({
+            type: "tool_reference",
+            tool_name: isOAuthToken ? toClaudeCodeName(name) : name,
+        });
+    }
+    const convertedContent = convertContentBlocks(msg.content);
+    // Anthropic rejects tool references mixed with ordinary tool-result content.
+    return {
+        toolResult: {
+            type: "tool_result",
+            tool_use_id: msg.toolCallId,
+            content: references.length > 0 ? references : convertedContent,
+            is_error: msg.isError,
+        },
+        siblingContent: references.length === 0
+            ? []
+            : typeof convertedContent === "string"
+                ? [{ type: "text", text: convertedContent }]
+                : convertedContent,
+    };
+}
+function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowEmptySignature = false, deferredToolNames = new Set(), normalizeToolName = (name) => name) {
     const params = [];
-    // Transform messages for cross-provider compatibility
-    const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
+    const loadedToolNames = new Set();
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
         if (msg.role === "user") {
@@ -873,33 +946,22 @@ function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmpty
             });
         }
         else if (msg.role === "toolResult") {
-            // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint
+            // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint.
             const toolResults = [];
-            // Add the current tool result
-            toolResults.push({
-                type: "tool_result",
-                tool_use_id: msg.toolCallId,
-                content: convertContentBlocks(msg.content),
-                is_error: msg.isError,
-            });
-            // Look ahead for consecutive toolResult messages
-            let j = i + 1;
+            const siblingContent = [];
+            let j = i;
             while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-                const nextMsg = transformedMessages[j]; // We know it's a toolResult
-                toolResults.push({
-                    type: "tool_result",
-                    tool_use_id: nextMsg.toolCallId,
-                    content: convertContentBlocks(nextMsg.content),
-                    is_error: nextMsg.isError,
-                });
+                const converted = convertToolResult(transformedMessages[j], isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName);
+                toolResults.push(converted.toolResult);
+                siblingContent.push(...converted.siblingContent);
                 j++;
             }
-            // Skip the messages we've already processed
+            // Skip the messages we've already processed.
             i = j - 1;
-            // Add a single user message with all tool results
+            // Displaced reference-bearing results must follow every tool_result block.
             params.push({
                 role: "user",
-                content: toolResults,
+                content: [...toolResults, ...siblingContent],
             });
         }
     }
@@ -930,20 +992,30 @@ function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmpty
 function shouldUseFineGrainedToolStreamingBeta(model, context) {
     return !!context.tools?.length && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
 }
-function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cacheControl) {
+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 } : {}),
         };
     });
@@ -966,7 +1038,7 @@ function mapStopReason(reason, stopDetails) {
         case "stop_sequence":
             return { stopReason: "stop" }; // We don't supply stop sequences, so this should never happen
         case "sensitive": // Content flagged by safety filters (not yet in SDK types)
-            return { stopReason: "error" };
+            return { stopReason: "error", errorMessage: "Provider stopped with: sensitive" };
         default:
             // Handle unknown stop reasons gracefully (API may add new values)
             throw new Error(`Unhandled stop reason: ${reason}`);