@earendil-works/pi-ai 1.1.0 → 1.3.0

package/README.md

@@ -26,7 +26,6 @@ Unified LLM API with provider collections, automatic auth resolution, token and
   - [Streaming Tool Calls with Partial JSON](#streaming-tool-calls-with-partial-json)
   - [Validating Tool Arguments](#validating-tool-arguments)
   - [Complete Event Reference](#complete-event-reference)
-  - [Compact Assistant Message Frames](#compact-assistant-message-frames)
 - [Image Input](#image-input)
 - [Image Generation](#image-generation)
 - [Classification](#classification)
@@ -723,34 +722,6 @@ All streaming events emitted during assistant message generation:
 
 Streaming events for different content blocks are not guaranteed to be contiguous. Providers may emit deltas for text, thinking, and tool calls in the same upstream chunk, and pi may surface corresponding events interleaved, for example `text_start`, `text_delta`, `toolcall_start`, `text_delta`, `toolcall_delta`. Consumers must use `contentIndex` to associate each delta/end event with its block and must not assume that a block's `*_start`/`*_delta`/`*_end` sequence is uninterrupted by events for other blocks.
 
-### Compact Assistant Message Frames
-
-`AssistantMessageFrameEncoder` converts one stream into compact, persistable `AssistantMessageFrame` values. Create one encoder per stream and feed it every event in order. The encoder understands that `partial` is live: a block-start event consumed after the provider has already queued later deltas snapshots the current block once, and covered queued text/thinking deltas produce no duplicate frame. It retains only per-open-block counters plus, temporarily, the raw prefix needed to synchronize an already-advanced tool call. It never clones the growing full partial per token.
-
-The start frame contains message metadata with empty content. Text and thinking frames store each generated character at most once before the authoritative end frame. Tool calls that were already advanced when their start event was consumed use one compact JSON checkpoint before ordinary deltas resume. Terminal `done` and `error` events produce no frame because final message settlement is separate. A pre-generation `error` therefore produces no frames.
-
-`reduceAssistantMessageFrames()` is the canonical pure reducer. It reconstructs text, thinking, and tool-call arguments, including interleaved blocks identified by `contentIndex`, and rejects malformed sequences. It performs a single pass over the iterable and returns `undefined` when there is no start frame. End frames replace blocks with the provider's authoritative completed content and metadata. The reducer does not validate tool arguments against a TypeBox schema; call `validateToolCall` before execution.
-
-```typescript
-import {
-  AssistantMessageFrameEncoder,
-  reduceAssistantMessageFrames,
-  type AssistantMessageFrame,
-} from '@earendil-works/pi-ai';
-
-const encoder = new AssistantMessageFrameEncoder();
-const frames: AssistantMessageFrame[] = [];
-for await (const event of s) {
-  const frame = encoder.encode(event);
-  if (frame) frames.push(frame);
-}
-
-const reconstructedPartial = reduceAssistantMessageFrames(frames);
-const finalMessage = await s.result(); // Persist terminal settlement separately.
-```
-
-An encoder rejects duplicate starts, updates before start, `done` before start, events after a terminal event, duplicate block starts, and block-kind mismatches. An `error` before start is valid and returns no frame.
-
 ## Image Input
 
 Models with vision capabilities can process images. You can check if a model supports images via the `input` property. If you pass images to a non-vision model, they are silently ignored.
@@ -1527,13 +1498,13 @@ Notes:
 
 ## Cross-Provider Handoffs
 
-The library supports seamless handoffs between different LLM providers within the same conversation. This allows you to switch models mid-conversation while preserving context, including thinking blocks, tool calls, and tool results.
+The library supports seamless handoffs between different LLM providers within the same conversation. This allows you to switch models mid-conversation while preserving context, including text, tool calls, and tool results.
 
 When messages from one provider are sent to a different provider, the library automatically transforms them for compatibility:
 
 - **User and tool result messages** are passed through unchanged
-- **Assistant messages from the same provider/API** are preserved as-is
-- **Assistant messages from different providers** have their thinking blocks converted to text with `<thinking>` tags
+- **Assistant messages from the same provider, API, and model** are preserved as-is, including thinking blocks
+- **Assistant messages from a different model** have their thinking blocks dropped. Signatures and encrypted reasoning only work with the model that produced them, and readable thinking sent as plain text makes the new model treat it as part of the reply
 - **Tool calls and regular text** are preserved unchanged
 
 ```typescript
@@ -1554,7 +1525,7 @@ const claude = models.getModel('anthropic', 'claude-sonnet-4-5')!;
 context.messages.push({ role: 'user', content: 'What is 25 * 18?', timestamp: Date.now() });
 context.messages.push(await models.completeSimple(claude, context, { reasoning: 'medium' }));
 
-// Switch to GPT-5 - it will see Claude's thinking as <thinking> tagged text
+// Switch to GPT-5 - it sees Claude's answer, but not Claude's thinking
 const gpt5 = models.getModel('openai', 'gpt-5-mini')!;
 context.messages.push({ role: 'user', content: 'Is that calculation correct?', timestamp: Date.now() });
 context.messages.push(await models.complete(gpt5, context));
@@ -1565,7 +1536,7 @@ context.messages.push({ role: 'user', content: 'What was the original question?'
 const geminiResponse = await models.complete(gemini, context);
 ```
 
-All providers can handle messages from other providers — text, tool calls and results (including images), thinking blocks (transformed to tagged text), and aborted messages with partial content. This enables flexible workflows: start with a fast model, switch to a more capable one for complex reasoning, or maintain continuity across provider outages.
+All providers can handle messages from other providers — text, tool calls and results (including images), thinking blocks (dropped when the model changes), and aborted messages with partial content. This enables flexible workflows: start with a fast model, switch to a more capable one for complex reasoning, or maintain continuity across provider outages.
 
 ## System Messages
 

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,SAAiC,MAAM,mBAAmB,CAAC;AAoBlE,OAAO,KAAK,EASX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AAmJrB,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AA2ChE,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;AAwRD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CA0UzE,CAAC;AA2BF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CAgDlF,CAAC"}
+{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../src/api/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,SAAiC,MAAM,mBAAmB,CAAC;AAoBlE,OAAO,KAAK,EASX,mBAAmB,EAEnB,cAAc,EACd,aAAa,EAMb,MAAM,aAAa,CAAC;AAuJrB,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAE1E,MAAM,MAAM,wBAAwB,GAAG,YAAY,GAAG,SAAS,CAAC;AA2ChE,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;AAwRD,eAAO,MAAM,MAAM,EAAE,cAAc,CAAC,oBAAoB,EAAE,gBAAgB,CA0WzE,CAAC;AA2BF,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,oBAAoB,EAAE,mBAAmB,CAgDlF,CAAC"}

package/dist/api/anthropic-messages.js

@@ -4,7 +4,7 @@ import { calculateCost } from "../models.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";
+import { parseJsonWithRepair, parseStreamingJson, parseToolCallArguments } from "../utils/json-parse.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
@@ -14,7 +14,7 @@ import { getCurrentTools, getInitialSystemMessage, resolveTranscript, } from "..
 import { getJsonSchemaToolParameters, 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";
+import { splitErrorToolResultImages, transformMessages } from "./transform-messages.js";
 /**
  * Resolve cache retention preference.
  * Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
@@ -75,6 +75,16 @@ const fromClaudeCodeName = (name, tools) => {
     }
     return name;
 };
+function convertImageBlock(image) {
+    return {
+        type: "image",
+        source: {
+            type: "base64",
+            media_type: image.mimeType,
+            data: image.data,
+        },
+    };
+}
 /**
  * Convert content blocks to Anthropic API format
  */
@@ -92,14 +102,7 @@ function convertContentBlocks(content) {
                 text: sanitizeSurrogates(block.text),
             };
         }
-        return {
-            type: "image",
-            source: {
-                type: "base64",
-                media_type: block.mimeType,
-                data: block.data,
-            },
-        };
+        return convertImageBlock(block);
     });
     // If only images (no text), add placeholder text block
     const hasText = blocks.some((b) => b.type === "text");
@@ -378,14 +381,12 @@ export const stream = (model, context, options) => {
     const normalizedContext = resolveTranscript(context, getAnthropicCompat(model).supportsMidConvoSystemMessages);
     const currentTools = getCurrentTools(normalizedContext.messages);
     (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,
@@ -425,21 +426,55 @@ export const stream = (model, context, options) => {
                 client = created.client;
                 isOAuth = created.isOAuthToken;
             }
-            let params = buildParams(model, normalizedContext, isOAuth, options);
-            const nextParams = await options?.onPayload?.(params, model);
-            if (nextParams !== undefined) {
-                params = { ...nextParams, stream: true };
-            }
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
                 maxRetries: 0,
             };
-            const response = await retryProviderRequest(() => client.beta.messages.create(params, requestOptions).asResponse(), {
-                maxRetries: options?.maxRetries,
-                maxRetryDelayMs: options?.maxRetryDelayMs,
-                signal: options?.signal,
-            });
+            let disablePreferredStrictTools = false;
+            let response;
+            for (;;) {
+                options?.signal?.throwIfAborted();
+                const built = buildParams(model, normalizedContext, isOAuth, options, disablePreferredStrictTools);
+                if (built.providerThinkingLevel)
+                    output.providerThinkingLevel = built.providerThinkingLevel;
+                let params = built.params;
+                const nextParams = await options?.onPayload?.(params, model);
+                if (nextParams !== undefined) {
+                    params = { ...nextParams, stream: true };
+                }
+                try {
+                    response = await retryProviderRequest(() => client.beta.messages.create(params, requestOptions).asResponse(), {
+                        maxRetries: options?.maxRetries,
+                        maxRetryDelayMs: options?.maxRetryDelayMs,
+                        signal: options?.signal,
+                    });
+                    break;
+                }
+                catch (error) {
+                    // Only downgrade a rejected request, never an already-started stream.
+                    if (options?.signal?.aborted ||
+                        disablePreferredStrictTools ||
+                        !built.hasPreferredStrictTools ||
+                        !(error instanceof Anthropic.APIError) ||
+                        error.status !== 400 ||
+                        error.type !== "invalid_request_error" ||
+                        ![
+                            "The compiled grammar is too large",
+                            "Too many strict tools (",
+                            "Schemas contains too many parameters with union types (",
+                        ].some((message) => error.message.includes(message))) {
+                        throw error;
+                    }
+                    disablePreferredStrictTools = true;
+                    appendAssistantMessageDiagnostic(output, {
+                        type: "anthropic_strict_tools_fallback",
+                        timestamp: Date.now(),
+                        error: { message: error.message },
+                        details: { reason: "strict_tool_limits_exceeded" },
+                    });
+                }
+            }
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
@@ -593,7 +628,7 @@ export const stream = (model, context, options) => {
                             });
                         }
                         else if (block.type === "toolCall") {
-                            block.arguments = parseStreamingJson(block.partialJson);
+                            Object.assign(block, parseToolCallArguments(block.partialJson));
                             // Finalize in-place and strip the scratch buffer so replay only
                             // carries parsed arguments.
                             delete block.partialJson;
@@ -855,7 +890,7 @@ function getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, option
         features.push(INLINE_TOOLS_BETA);
     return [...new Set(features)];
 }
-function buildParams(model, context, isOAuthToken, options) {
+function buildParams(model, context, isOAuthToken, options, disablePreferredStrictTools = false) {
     const { cacheControl } = getCacheControl(model, options?.cacheRetention, options?.env);
     const compat = getAnthropicCompat(model);
     const initialSystemMessage = getInitialSystemMessage(context.messages);
@@ -866,18 +901,28 @@ function buildParams(model, context, isOAuthToken, options) {
     // by value in a `tool_addition` block, which also expresses same-name redefinitions.
     // Anthropic rejects a tool list where every tool is deferred, so there must be an initial
     // active tool to anchor the placeholder. Otherwise the current tool list is sent.
+    let hasPreferredStrictTools = false;
+    const convertToolDefinitions = (tools, toolCacheControl) => {
+        const definitions = convertTools(tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl, disablePreferredStrictTools);
+        if (definitions.some((definition, index) => {
+            const config = tools[index].constrainedSampling;
+            return definition.strict === true && config && config.type === "json_schema" && config.strict === "prefer";
+        })) {
+            hasPreferredStrictTools = true;
+        }
+        return definitions;
+    };
     const initialTools = initialSystemMessage?.toolsAdded ?? [];
     const nativeToolChanges = compat.supportsMidConvoSystemMessages && compat.supportsMidConvoToolChanges && initialTools.length > 0;
-    const converted = convertMessages(conversationMessages, isOAuthToken, cacheControl, compat.allowEmptySignature, model.compat?.supportsMidConvoEffort === true ? model.provider : undefined, nativeToolChanges
-        ? (tools) => convertTools(tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools)
-        : undefined);
+    const thinkingDisabled = model.reasoning && options?.thinkingEnabled === false && model.thinkingLevelMap?.off !== null;
+    // Effort cannot change between messages while thinking is disabled, so "off" sends no effort markers.
+    const effortMessages = model.compat?.supportsMidConvoEffort === true && !thinkingDisabled;
+    const converted = convertMessages(conversationMessages, isOAuthToken, cacheControl, compat.allowEmptySignature, effortMessages ? model.provider : undefined, nativeToolChanges ? convertToolDefinitions : undefined);
     const activeEffort = options?.effort ?? "high";
     const betaFeatures = getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, options);
     const params = {
         model: model.id,
-        messages: model.compat?.supportsMidConvoEffort === true
-            ? insertThinkingLevelMessages(converted, activeEffort)
-            : converted.messages,
+        messages: effortMessages ? insertThinkingLevelMessages(converted, activeEffort) : converted.messages,
         max_tokens: options?.maxTokens ?? model.maxTokens,
         stream: true,
         ...(betaFeatures.length > 0 ? { betas: betaFeatures } : {}),
@@ -922,20 +967,22 @@ function buildParams(model, context, isOAuthToken, options) {
         // placeholder. The list never changes afterwards: later tools are defined by value in
         // `tool_addition` blocks and withdrawn by `tool_removal`, so the cached prefix survives
         // every tool change.
-        params.tools = [
-            ...convertTools(initialTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl),
-            DEFERRED_TOOL_PLACEHOLDER,
-        ];
+        params.tools = [...convertToolDefinitions(initialTools, toolCacheControl), DEFERRED_TOOL_PLACEHOLDER];
     }
     else {
         const tools = getCurrentTools(context.messages);
         if (tools.length > 0) {
-            params.tools = convertTools(tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl);
+            params.tools = convertToolDefinitions(tools, toolCacheControl);
         }
     }
-    // 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) {
+    if (thinkingDisabled) {
+        // No effort is sent, so the model default applies. Anthropic rejects `block_binding`
+        // with disabled thinking.
+        params.thinking = { type: "disabled" };
+    }
+    else if (effortMessages) {
+        // Managed effort models use adaptive thinking so prefix mismatches can
+        // be dropped instead of surfacing as persistent 400 responses.
         params.thinking = {
             type: "adaptive",
             display: options?.thinkingDisplay ?? "summarized",
@@ -943,29 +990,24 @@ function buildParams(model, context, isOAuthToken, options) {
         };
         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").
-            const display = options.thinkingDisplay ?? "summarized";
-            if (model.compat?.forceAdaptiveThinking === true) {
-                // Adaptive thinking: Claude decides when and how much to think.
-                params.thinking = { type: "adaptive", display };
-                if (options.effort) {
-                    params.output_config = { effort: options.effort };
-                }
-            }
-            else {
-                // Budget-based thinking for older models
-                params.thinking = {
-                    type: "enabled",
-                    budget_tokens: options.thinkingBudgetTokens || 1024,
-                    display,
-                };
+    else if (model.reasoning && 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 (model.compat?.forceAdaptiveThinking === true) {
+            // Adaptive thinking: Claude decides when and how much to think.
+            params.thinking = { type: "adaptive", display };
+            if (options.effort) {
+                params.output_config = { effort: options.effort };
             }
         }
-        else if (options?.thinkingEnabled === false && model.thinkingLevelMap?.off !== null) {
-            params.thinking = { type: "disabled" };
+        else {
+            // Budget-based thinking for older models
+            params.thinking = {
+                type: "enabled",
+                budget_tokens: options.thinkingBudgetTokens || 1024,
+                display,
+            };
         }
     }
     if (options?.metadata) {
@@ -986,17 +1028,17 @@ function buildParams(model, context, isOAuthToken, options) {
     if (allowedFallbackModels && allowedFallbackModels.length > 0) {
         params.fallbacks = allowedFallbackModels.map((fallback) => ({ model: fallback.model }));
     }
-    return params;
+    return { params, hasPreferredStrictTools, providerThinkingLevel: effortMessages ? activeEffort : undefined };
 }
 // Normalize tool call IDs to match Anthropic's required pattern and length
 function normalizeToolCallId(id) {
     return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-function convertToolResult(msg) {
+function convertToolResult(msg, content = msg.content) {
     return {
         type: "tool_result",
         tool_use_id: msg.toolCallId,
-        content: convertContentBlocks(msg.content),
+        content: convertContentBlocks(content),
         is_error: msg.isError,
     };
 }
@@ -1061,14 +1103,7 @@ convertToolDefinitions) {
                         };
                     }
                     else {
-                        return {
-                            type: "image",
-                            source: {
-                                type: "base64",
-                                media_type: item.mimeType,
-                                data: item.data,
-                            },
-                        };
+                        return convertImageBlock(item);
                     }
                 });
                 const filteredBlocks = blocks.filter((b) => {
@@ -1159,16 +1194,24 @@ convertToolDefinitions) {
         else if (msg.role === "toolResult") {
             // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint.
             const toolResults = [];
+            // Anthropic rejects error tool results that contain anything but text, so their images follow
+            // all tool results of the turn, which must come first in the user message (#10794).
+            const errorImages = [];
             let j = i;
             while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-                toolResults.push(convertToolResult(transformedMessages[j]));
+                const toolMsg = transformedMessages[j];
+                const split = splitErrorToolResultImages(toolMsg);
+                toolResults.push(convertToolResult(toolMsg, split?.content));
+                if (split) {
+                    errorImages.push({ type: "text", text: split.caption }, ...split.images.map(convertImageBlock));
+                }
                 j++;
             }
             // Skip the messages we've already processed.
             i = j - 1;
             params.push({
                 role: "user",
-                content: toolResults,
+                content: [...toolResults, ...errorImages],
             });
         }
     }
@@ -1255,11 +1298,14 @@ const isAnthropicStrictUnsupportedKeyword = (key, value) => {
         return typeof value !== "string" || !ANTHROPIC_STRICT_STRING_FORMATS.has(value);
     return false;
 };
-function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl) {
+function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl, disablePreferredStrictTools = false) {
     if (!tools)
         return [];
     return tools.map((tool, index) => {
-        const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictTools, isAnthropicStrictUnsupportedKeyword);
+        const config = tool.constrainedSampling;
+        const strict = disablePreferredStrictTools && config && config.type === "json_schema" && config.strict === "prefer"
+            ? undefined
+            : resolveJsonSchemaStrictSampling(tool, supportsStrictTools, isAnthropicStrictUnsupportedKeyword);
         const parameters = getJsonSchemaToolParameters(tool, strict);
         const schema = parameters;
         const legacyInputSchema = {