@code-yeongyu/senpi-ai 2026.9.29 → 2026.10.1-2

package/dist/api/anthropic-messages.js

@@ -21,9 +21,11 @@ import { appendRetryAfterMsMarker, extract429RetryAfterMs } from "../utils/retry
 import { normalizeAnthropicRetryFailure } from "../utils/retry-profile/failure.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { applyServerFallbackAbort, applyServerFallbackContinuation, parseServerFallbackReceipt, parseStickyFallbackReceipt, } from "../utils/server-fallback-receipt.js";
+import { getSystemMessageText, renderSystemMessageUpdate } from "../utils/text.js";
 import { normalizeToolCallId } from "../utils/tool-call-id.js";
 import { sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.js";
 import { resolveRootObjectSchema } from "../utils/tool-schema-compat.js";
+import { getCurrentTools, getDeclaredTools, getInitialSystemMessage, hasToolRedefinitions, normalizeContext, resolveTranscript, } from "../utils/transcript.js";
 import { sanitizeAnthropicToolPairs } from "./anthropic-tool-pairs.js";
 import { demoteUnavailableToolReferences } from "./anthropic-tool-references.js";
 import { resolveCloudflareBaseUrl } from "./cloudflare.js";
@@ -68,7 +70,7 @@ function getCacheControl(model, cacheRetention, env) {
 // The bundled Claude Code version and the floor of the advertised `claude-cli/<version>`
 // (see utils/claude-code-version.ts). Keep this exact declaration: a downstream installer
 // (oh-my-openagent) rewrites it byte-for-byte in the installed dist and bundle.
-const claudeCodeVersion = "2.1.284";
+const claudeCodeVersion = "2.1.285";
 // 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
@@ -204,6 +206,28 @@ function shouldUseServerSideFallbackBeta(model) {
 }
 const MID_CONVERSATION_OUTPUT_CONFIG_BETA = "mid-conversation-output-config-2026-07-01";
 const THINKING_BINDING_CONTROLS_BETA = "thinking-binding-controls-2026-08-01";
+const MID_CONVERSATION_TOOL_CHANGES_BETA = "mid-conversation-tool-changes-2026-07-01";
+/**
+ * Stable deferred tool declared whenever native tool changes are in use. Anthropic adds
+ * hidden prompt scaffolding as soon as any tool has `defer_loading`; declaring this
+ * placeholder from the first request keeps that scaffolding in the cached prefix, so the
+ * first real late tool does not invalidate the cache (measured: full miss without it).
+ * It is never activated and the model cannot see it.
+ */
+const DEFERRED_TOOL_PLACEHOLDER = {
+    name: "__pi_deferred_placeholder__",
+    description: "Reserved placeholder. Never available. Never call this.",
+    input_schema: { type: "object", properties: {}, required: [] },
+    defer_loading: true,
+};
+// Upstream mid-conversation system messages and native tool changes. Read from the model
+// compat directly: both default off, and the shared getAnthropicCompat keeps fork defaults.
+function supportsMidConvoSystemMessages(model) {
+    return model.compat?.supportsMidConvoSystemMessages ?? false;
+}
+function supportsMidConvoToolChanges(model) {
+    return model.compat?.supportsMidConvoToolChanges ?? false;
+}
 // A provider can reject its own empty signatures. Learn that capability for one
 // conversation without changing the shared model definition used by other sessions.
 const unsignedThinkingTextReplayFallbacks = new Set();
@@ -658,6 +682,15 @@ function isToolLoopContinuation(messages) {
         Array.isArray(preceding.content) &&
         preceding.content.some((block) => block.type === "tool_use"));
 }
+function markSystemMessageCacheCheckpoint(message, cacheControl) {
+    if (!Array.isArray(message.content))
+        return;
+    const lastBlock = message.content[message.content.length - 1];
+    if (lastBlock &&
+        (lastBlock.type === "text" || lastBlock.type === "tool_addition" || lastBlock.type === "tool_removal")) {
+        lastBlock.cache_control = cacheControl;
+    }
+}
 function markUserMessageCacheCheckpoint(message, cacheControl) {
     if (message.role !== "user")
         return false;
@@ -832,6 +865,8 @@ async function* iterateAnthropicEvents(response, signal) {
 }
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const normalizedContext = resolveTranscript(context, supportsMidConvoSystemMessages(model));
+    const currentTools = getCurrentTools(normalizedContext.messages);
     (async () => {
         const providerThinkingLevel = model.compat?.supportsMidConvoEffort ? (options?.effort ?? "high") : undefined;
         const output = {
@@ -872,16 +907,16 @@ export const stream = (model, context, options) => {
                 assertRequestAuth(model.provider, apiKey, optionsHeaders);
                 let copilotDynamicHeaders;
                 if (model.provider === "github-copilot") {
-                    const hasImages = hasCopilotVisionInput(context.messages);
+                    const hasImages = hasCopilotVisionInput(normalizedContext.messages);
                     copilotDynamicHeaders = buildCopilotDynamicHeaders({
-                        messages: context.messages,
+                        messages: normalizedContext.messages,
                         hasImages,
                     });
                 }
                 const cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env, "short");
                 const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
                 openClient = () => {
-                    const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.refusalFallbacks !== undefined, optionsHeaders, options?.fetch, copilotDynamicHeaders, cacheSessionId, options?.env);
+                    const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, normalizedContext), options?.refusalFallbacks !== undefined, optionsHeaders, options?.fetch, copilotDynamicHeaders, cacheSessionId, options?.env);
                     client = created.client;
                     isOAuth = created.isOAuthToken;
                     advertisedClaudeCodeVersion = created.claudeCodeVersion;
@@ -915,7 +950,7 @@ export const stream = (model, context, options) => {
                 ? "text"
                 : getAnthropicCompat(model).unsignedThinkingReplay;
             const createRequest = async () => {
-                let params = buildParams(model, context, isOAuth, options, unsignedThinkingReplay);
+                let params = buildParams(model, normalizedContext, isOAuth, options, unsignedThinkingReplay);
                 const nextParams = await options?.onPayload?.(params, model);
                 if (nextParams !== undefined) {
                     params = nextParams;
@@ -994,19 +1029,29 @@ export const stream = (model, context, options) => {
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
             for await (const event of iterateAnthropicEvents(response, requestSignal)) {
+                await options?.onProviderStreamEvent?.(event, model);
                 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 fallback = output.model === model.id
+                    // Relays may report a renamed model for the same deployment, so the requested id stays
+                    // on the message (signed thinking keeps replaying) and the reported id is recorded
+                    // separately. A served model that is one of the request's allowed server-side
+                    // fallbacks is a real substitution: it becomes the message model, as the fork's
+                    // fallback-boundary replay and receipts expect.
+                    const responseModel = event.message.model;
+                    if (responseModel !== model.id)
+                        output.responseModel = responseModel;
+                    const fallback = responseModel === model.id
                         ? undefined
-                        : model.compat?.allowedFallbackModels?.find((candidate) => typeof candidate !== "string" &&
-                            candidate.provider === model.provider &&
-                            candidate.model === output.model);
+                        : model.compat?.allowedFallbackModels?.find((candidate) => typeof candidate === "string"
+                            ? candidate === responseModel
+                            : candidate.provider === model.provider && candidate.model === responseModel);
+                    if (fallback !== undefined)
+                        output.model = responseModel;
                     const fallbackCost = typeof fallback === "string" ? undefined : fallback?.cost;
-                    usageModel = fallbackCost ? { ...model, id: output.model, cost: fallbackCost } : model;
+                    usageModel = fallbackCost ? { ...model, id: responseModel, cost: fallbackCost } : model;
                     // 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;
@@ -1072,9 +1117,11 @@ export const stream = (model, context, options) => {
                             type: "toolCall",
                             id: event.content_block.id,
                             name: isOAuth
-                                ? fromClaudeCodeName(event.content_block.name, context.tools)
+                                ? fromClaudeCodeName(event.content_block.name, currentTools)
                                 : event.content_block.name,
-                            arguments: isRecord(event.content_block.input) ? event.content_block.input : {},
+                            arguments: isRecord(event.content_block.input)
+                                ? event.content_block.input
+                                : {},
                             partialJson: "",
                             index: event.index,
                         };
@@ -1220,6 +1267,11 @@ export const stream = (model, context, options) => {
                         if (event.usage.cache_creation_input_tokens != null) {
                             output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
                         }
+                        // Vercel AI Gateway includes the TTL breakdown in deltas, though the SDK only types it on message_start.
+                        const cacheCreation = event.usage.cache_creation;
+                        if (cacheCreation?.ephemeral_1h_input_tokens != null) {
+                            output.usage.cacheWrite1h = cacheCreation.ephemeral_1h_input_tokens;
+                        }
                         // Anthropic reports reasoning tokens as a subset of output tokens.
                         const thinkingTokens = event.usage.output_tokens_details?.thinking_tokens;
                         if (thinkingTokens != null) {
@@ -1510,7 +1562,10 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     return { client, isOAuthToken: false };
 }
 export function buildAnthropicWarmPromptCacheParams(model, context, options) {
-    const params = buildParams(model, context, false, {
+    // Public fork entry (warmPromptCache, cache-keepalive): accepts a raw Context and builds
+    // the same transcript the turn's stream() resolves, so the warmed prefix matches.
+    const transcript = resolveTranscript(normalizeContext(context), supportsMidConvoSystemMessages(model));
+    const params = buildParams(model, transcript, false, {
         ...options,
         maxTokens: 0,
         thinkingEnabled: undefined,
@@ -1522,7 +1577,7 @@ export function buildAnthropicWarmPromptCacheParams(model, context, options) {
         max_tokens: 0,
     });
 }
-function getBetaFeatures(model, context, isOAuthToken, options) {
+function getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, options) {
     let configuredFeatures;
     for (const headers of [model.headers, options?.headers]) {
         for (const [name, value] of Object.entries(headers ?? {})) {
@@ -1556,22 +1611,41 @@ function getBetaFeatures(model, context, isOAuthToken, options) {
     if (model.compat?.supportsMidConvoEffort === true) {
         features.push(MID_CONVERSATION_OUTPUT_CONFIG_BETA, THINKING_BINDING_CONTROLS_BETA);
     }
+    if (nativeToolChanges)
+        features.push(MID_CONVERSATION_TOOL_CHANGES_BETA);
     return [...new Set(features)];
 }
 function buildParams(model, context, isOAuthToken, options, unsignedThinkingReplay = getAnthropicCompat(model).unsignedThinkingReplay) {
     const compat = getAnthropicCompat(model);
     const { cacheControl } = getCacheControl(model, options?.cacheRetention ?? model.cacheRetention, options?.env);
+    const initialSystemMessage = getInitialSystemMessage(context.messages);
+    const initialSystemText = initialSystemMessage ? getSystemMessageText(initialSystemMessage) : "";
     const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId, {
         preserveThinking: options?.thinkingEnabled === true,
         preserveUnsignedThinking: true,
     });
+    // The prompt travels in `params.system`; the leading system message is not a turn.
+    const conversationMessages = initialSystemMessage ? transformedMessages.slice(1) : transformedMessages;
+    // Native tool changes reference tools by name, so a redefined name cannot be expressed,
+    // and Anthropic rejects a tool list where every tool is deferred, so there must be an
+    // initial active tool to anchor the deferred ones. Otherwise the current tool list is sent.
+    const initialTools = initialSystemMessage?.toolsAdded ?? [];
+    const nativeToolChanges = supportsMidConvoSystemMessages(model) &&
+        supportsMidConvoToolChanges(model) &&
+        initialTools.length > 0 &&
+        !hasToolRedefinitions(context.messages);
     const normalizeToolName = isOAuthToken ? toClaudeCodeName : (name) => name;
     // A marker on a discarded pre-fallback result must not defer its tool:
     // convertMessages drops that result, so no tool_reference would replay to
     // load the deferred definition.
-    const discardedFallbackToolCallIds = collectDiscardedFallbackToolCallIds(transformedMessages, model);
-    const partitionMessages = transformedMessages.filter((message) => !(message.role === "toolResult" && discardedFallbackToolCallIds.has(message.toolCallId)));
-    const toolPlacement = splitDeferredTools({ ...context, messages: partitionMessages }, compat.supportsToolReferences, normalizeToolName);
+    const discardedFallbackToolCallIds = collectDiscardedFallbackToolCallIds(conversationMessages, model);
+    const partitionMessages = conversationMessages.filter((message) => !(message.role === "toolResult" && discardedFallbackToolCallIds.has(message.toolCallId)));
+    // Without native tool changes, the fork's transcript-loaded deferral applies to the current
+    // tool list: tools first surfaced by a tool result's `addedToolNames` are declared with
+    // `defer_loading` and loaded by a `tool_reference`. Native tool changes own deferral otherwise.
+    const toolPlacement = nativeToolChanges
+        ? { immediate: [], deferred: new Map() }
+        : splitDeferredTools({ tools: getCurrentTools(context.messages), messages: partitionMessages }, compat.supportsToolReferences, normalizeToolName);
     let immediateTools = toolPlacement.immediate;
     let deferredTools = [...toolPlacement.deferred.values()];
     if (immediateTools.length === 0 && deferredTools.length > 0) {
@@ -1580,8 +1654,8 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
     }
     const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
     const activeEffort = options?.effort ?? "high";
-    const betaFeatures = getBetaFeatures(model, context, isOAuthToken, options);
-    const convertedMessages = convertMessages(transformedMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay, deferredToolNames, normalizeToolName, model.compat?.supportsMidConvoEffort === true ? model.provider : undefined);
+    const betaFeatures = getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, options);
+    const convertedMessages = convertMessages(conversationMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay, deferredToolNames, normalizeToolName, model.compat?.supportsMidConvoEffort === true ? model.provider : undefined, nativeToolChanges);
     const messages = model.compat?.supportsMidConvoEffort === true
         ? insertThinkingLevelMessages(convertedMessages, activeEffort)
         : convertedMessages.messages;
@@ -1589,8 +1663,13 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
     // against the actual last user/tool-result message so the marker cannot displace cache_control.
     if (model.compat?.supportsMidConvoEffort === true && cacheControl) {
         for (let index = messages.length - 1; index >= 0; index--) {
-            if (messages[index].role === "user") {
-                markUserMessageCacheCheckpoint(messages[index], cacheControl);
+            const message = messages[index];
+            // A native system update after the last turn already holds the checkpoint;
+            // effort markers carry no content.
+            if (message.role === "system" && Array.isArray(message.content) && message.content.length > 0)
+                break;
+            if (message.role === "user") {
+                markUserMessageCacheCheckpoint(message, cacheControl);
                 break;
             }
         }
@@ -1608,23 +1687,23 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
             {
                 type: "text",
                 text: "You are Claude Code, Anthropic's official CLI for Claude.",
-                ...(!context.systemPrompt && cacheControl ? { cache_control: cacheControl } : {}),
+                ...(!initialSystemText && cacheControl ? { cache_control: cacheControl } : {}),
             },
         ];
-        if (context.systemPrompt) {
+        if (initialSystemText) {
             params.system.push({
                 type: "text",
-                text: sanitizeSurrogates(context.systemPrompt),
+                text: sanitizeSurrogates(initialSystemText),
                 ...(cacheControl ? { cache_control: cacheControl } : {}),
             });
         }
     }
-    else if (context.systemPrompt) {
+    else if (initialSystemText) {
         // Add cache control to system prompt for non-OAuth tokens
         params.system = [
             {
                 type: "text",
-                text: sanitizeSurrogates(context.systemPrompt),
+                text: sanitizeSurrogates(initialSystemText),
                 ...(cacheControl ? { cache_control: cacheControl } : {}),
             },
         ];
@@ -1638,9 +1717,23 @@ function buildParams(model, context, isOAuthToken, options, unsignedThinkingRepl
             configurable: true,
         });
     }
-    if (immediateTools.length > 0 || deferredTools.length > 0) {
+    const toolCacheControl = compat.supportsCacheControlOnTools ? cacheControl : undefined;
+    if (nativeToolChanges) {
+        // Initial tools stay active with the cache breakpoint on the last one. Every later
+        // declaration is deferred and only surfaced by its `tool_addition` block; removed
+        // tools stay declared and are withdrawn by `tool_removal`. The request-level list
+        // therefore only grows, keeping the cached prefix intact across tool changes.
+        const initialNames = new Set(initialTools.map((tool) => tool.name));
+        const laterTools = getDeclaredTools(context.messages).filter((tool) => !initialNames.has(tool.name));
         params.tools = [
-            ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, compat.supportsCacheControlOnTools ? cacheControl : undefined),
+            ...convertTools(initialTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl),
+            DEFERRED_TOOL_PLACEHOLDER,
+            ...convertTools(laterTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
+        ];
+    }
+    else if (immediateTools.length > 0 || deferredTools.length > 0) {
+        params.tools = [
+            ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl),
             ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
         ];
     }
@@ -1791,10 +1884,20 @@ function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames
                 : convertedContent,
     };
 }
-function convertMessages(transformedMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay = "text", deferredToolNames = new Set(), normalizeToolName = (name) => name, managedProvider) {
+function convertMessages(transformedMessages, model, isOAuthToken, cacheControl, unsignedThinkingReplay = "text", deferredToolNames = new Set(), normalizeToolName = (name) => name, managedProvider, nativeToolChanges = false) {
     const params = [];
     const assistantLevels = new Map();
     const loadedToolNames = new Set();
+    // Later system messages are held back and emitted directly before the next assistant
+    // message (or at the end of the transcript). Anthropic requires `tool_result` blocks to
+    // immediately follow their `tool_use`, so a system message between them is rejected; this
+    // also mirrors where the managed-effort system messages are inserted. As a result an
+    // update placed before a user message in the transcript lands after it on the wire.
+    const pendingSystemMessages = [];
+    const flushPendingSystemMessages = () => {
+        params.push(...pendingSystemMessages);
+        pendingSystemMessages.length = 0;
+    };
     // Tool calls from a declined pre-fallback attempt are dropped from their
     // assistant turn below; drop their tool_results in lockstep so none dangle.
     const discardedFallbackToolCallIds = collectDiscardedFallbackToolCallIds(transformedMessages, model);
@@ -1802,7 +1905,31 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
     const providerNativeToolPairing = collectProviderNativeToolPairing(transformedMessages, model, deferredToolNames, normalizeToolName, discardedFallbackToolCallIds);
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
-        if (msg.role === "user") {
+        if (msg.role === "system") {
+            // Later system messages only reach this point when the model accepts them natively;
+            // otherwise the transcript was collapsed into the leading message before conversion.
+            const text = renderSystemMessageUpdate(msg);
+            const blocks = [];
+            if (text.length > 0)
+                blocks.push({ type: "text", text: sanitizeSurrogates(text) });
+            if (nativeToolChanges) {
+                for (const tool of msg.toolsRemoved ?? []) {
+                    blocks.push({
+                        type: "tool_removal",
+                        tool: { type: "tool_reference", name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name },
+                    });
+                }
+                for (const tool of msg.toolsAdded ?? []) {
+                    blocks.push({
+                        type: "tool_addition",
+                        tool: { type: "tool_reference", name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name },
+                    });
+                }
+            }
+            if (blocks.length > 0)
+                pendingSystemMessages.push({ role: "system", content: blocks });
+        }
+        else if (msg.role === "user") {
             if (typeof msg.content === "string") {
                 if (msg.content.trim().length > 0) {
                     const content = sanitizeSurrogates(msg.content);
@@ -1855,6 +1982,7 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
             }
         }
         else if (msg.role === "assistant") {
+            flushPendingSystemMessages();
             const blocks = [];
             const isSameModel = isSameAnthropicModel(msg, model);
             // Blocks before the final fallback marker are the declined attempt; the
@@ -1977,6 +2105,14 @@ function convertMessages(transformedMessages, model, isOAuthToken, cacheControl,
             appendUserBlocks(params, [...toolResults, ...siblingContent]);
         }
     }
+    flushPendingSystemMessages();
+    // A trailing native system update carries the history checkpoint itself (upstream);
+    // otherwise the fork's final-user and tool-loop checkpoints apply.
+    const lastParam = params[params.length - 1];
+    if (cacheControl && lastParam?.role === "system") {
+        markSystemMessageCacheCheckpoint(lastParam, cacheControl);
+        return { messages: params, assistantLevels };
+    }
     const retainPrecedingCheckpoint = isToolLoopContinuation(params);
     if (cacheControl && params.length > 0 && markUserMessageCacheCheckpoint(params[params.length - 1], cacheControl)) {
         if (retainPrecedingCheckpoint) {
@@ -2004,7 +2140,7 @@ function insertThinkingLevelMessages(converted, activeEffort) {
     return messages;
 }
 function shouldUseFineGrainedToolStreamingBeta(model, context) {
-    return !!context.tools?.length && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
+    return getCurrentTools(context.messages).length > 0 && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
 }
 function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl, deferLoading = false) {
     if (!tools)

package/dist/api/azure-openai-responses.js

@@ -6,6 +6,7 @@ import { headersToRecord } from "../utils/headers.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
+import { getDeclaredTools, resolveTranscript, resolveTranscriptTools } from "../utils/transcript.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
@@ -44,6 +45,7 @@ function formatAzureOpenAIError(error) {
  */
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const normalizedContext = resolveTranscript(context, model.compat?.supportsMidConvoSystemMessages);
     // Start async processing
     (async () => {
         const deploymentName = resolveDeploymentName(model, options);
@@ -71,8 +73,8 @@ export const stream = (model, context, options) => {
                 throw new Error(`No API key for provider: ${model.provider}`);
             }
             const client = createClient(model, apiKey, options);
-            const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false);
-            let params = buildParams(model, context, options, deploymentName, grammarToolInputProperties);
+            const grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(normalizedContext.messages), model.compat?.supportsOpenAIGrammarTools ?? false);
+            let params = buildParams(model, normalizedContext, options, deploymentName, grammarToolInputProperties);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
                 params = nextParams;
@@ -89,7 +91,10 @@ export const stream = (model, context, options) => {
             });
             await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
-            await processResponsesStream(openaiStream, output, stream, model, { grammarToolInputProperties });
+            await processResponsesStream(openaiStream, output, stream, model, {
+                onProviderStreamEvent: options?.onProviderStreamEvent,
+                grammarToolInputProperties,
+            });
             if (options?.signal?.aborted) {
                 throw new Error("Request was aborted");
             }
@@ -203,14 +208,24 @@ function createClient(model, apiKey, options) {
         baseURL: baseUrl,
     });
 }
-function buildParams(model, context, options, deploymentName, grammarToolInputProperties = createGrammarToolInputProperties(context.tools, model.compat?.supportsOpenAIGrammarTools ?? false)) {
+function buildParams(model, context, options, deploymentName, grammarToolInputProperties = createGrammarToolInputProperties(getDeclaredTools(context.messages), model.compat?.supportsOpenAIGrammarTools ?? false)) {
     const requestedReasoningEffort = options?.reasoningEffort ?? (options?.reasoningSummary ? "medium" : undefined);
     const mappedReasoningEffort = requestedReasoningEffort === undefined ? undefined : model.thinkingLevelMap?.[requestedReasoningEffort];
     const reasoningEffort = mappedReasoningEffort === undefined ? requestedReasoningEffort : mappedReasoningEffort;
     const reasoningRequested = reasoningEffort !== undefined && reasoningEffort !== null;
     const reasoningUnavailable = reasoningEffort === null;
+    const supportsAdditionalTools = model.compat?.supportsAdditionalTools ?? false;
+    const supportsToolSearch = model.compat?.supportsToolSearch ?? false;
+    const transcriptTools = resolveTranscriptTools(context.messages, supportsAdditionalTools || supportsToolSearch);
     const messages = convertResponsesMessages(model, context, AZURE_TOOL_CALL_PROVIDERS, {
         grammarToolInputProperties,
+        supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+        supportsAdditionalTools,
+        supportsToolSearch,
+        toolOptions: {
+            supportsStrictMode: model.compat?.supportsStrictMode ?? true,
+            supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
+        },
     });
     const params = {
         model: deploymentName,
@@ -227,8 +242,8 @@ function buildParams(model, context, options, deploymentName, grammarToolInputPr
     if (options?.temperature !== undefined) {
         params.temperature = options?.temperature;
     }
-    if (context.tools && context.tools.length > 0) {
-        params.tools = convertResponsesTools(context.tools, {
+    if (transcriptTools.requestTools.length > 0) {
+        params.tools = convertResponsesTools(transcriptTools.requestTools, {
             supportsStrictMode: model.compat?.supportsStrictMode ?? true,
             supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
         });
@@ -250,10 +265,8 @@ function buildParams(model, context, options, deploymentName, grammarToolInputPr
             };
         }
     }
-    // Last so custom keys override the named request fields.
-    if (options?.samplingParams) {
-        Object.assign(params, options.samplingParams);
-    }
+    // Last so custom keys override the named request fields. Per-request keys override model defaults.
+    Object.assign(params, model.samplingParams, options?.samplingParams);
     return params;
 }
 //# sourceMappingURL=azure-openai-responses.js.map

package/dist/api/bedrock-converse-stream.js

@@ -12,7 +12,10 @@ import { resolveHttpProxyUrlForTarget } from "../utils/node-http-proxy.js";
 import { getBedrockModelMatchCandidates as getModelMatchCandidates, supportsOneHourCacheTtl, supportsPromptCaching, } from "../utils/prompt-cache-ttl.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { getSystemMessageText } from "../utils/text.js";
 import { normalizeToolCallId } from "../utils/tool-call-id.js";
+import { normalizeToolParametersForBedrock } from "../utils/tool-schema-compat.js";
+import { collapseSystemMessages, getCurrentTools, getInitialSystemMessage, withoutInitialSystemMessage, } from "../utils/transcript.js";
 import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
 import { adjustMaxTokensForThinking, applyExtraBody, BEDROCK_RESERVED_BODY_KEYS, buildBaseOptions, clampMaxTokensToContext, clampReasoning, } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -22,6 +25,8 @@ const EMPTY_TEXT_PLACEHOLDER = "<empty>";
 const REDACTED_THINKING_PLACEHOLDER = "[Reasoning redacted]";
 export const stream = (model, context, options = {}) => {
     const stream = new AssistantMessageEventStream();
+    // Bedrock has no mid-conversation system messages; fold them into the leading prompt.
+    const normalizedContext = collapseSystemMessages(context);
     (async () => {
         const output = {
             role: "assistant",
@@ -139,18 +144,20 @@ export const stream = (model, context, options = {}) => {
             }
             const cacheRetention = resolveCacheRetention(options.cacheRetention ?? model.cacheRetention, options.env);
             const inferenceMaxTokens = options.maxTokens ?? (isAnthropicClaudeModel(model) ? model.maxTokens : undefined);
+            const initialSystemMessage = getInitialSystemMessage(normalizedContext.messages);
+            const initialSystemPrompt = initialSystemMessage ? getSystemMessageText(initialSystemMessage) : undefined;
             let commandInput = {
                 modelId: model.id,
-                messages: convertMessages(context, model, cacheRetention, {
+                messages: convertMessages(normalizedContext, model, cacheRetention, {
                     preserveThinking: options.reasoning !== undefined,
                     env: options.env,
                 }),
-                system: buildSystemPrompt(context.systemPrompt, model, cacheRetention, options.env),
+                system: buildSystemPrompt(initialSystemPrompt, model, cacheRetention, options.env),
                 inferenceConfig: {
                     ...(inferenceMaxTokens !== undefined && { maxTokens: inferenceMaxTokens }),
                     ...(options.temperature !== undefined && { temperature: options.temperature }),
                 },
-                toolConfig: convertToolConfig(context.tools, options.toolChoice, supportsStrictMode),
+                toolConfig: convertToolConfig(getCurrentTools(normalizedContext.messages), options.toolChoice, supportsStrictMode),
                 additionalModelRequestFields: buildAdditionalModelRequestFields(model, options),
                 ...(options.requestMetadata !== undefined && { requestMetadata: options.requestMetadata }),
             };
@@ -170,6 +177,7 @@ export const stream = (model, context, options = {}) => {
                 await options?.onResponse?.({ status: response.$metadata.httpStatusCode, headers: responseHeaders }, model);
             }
             for await (const item of response.stream) {
+                await options.onProviderStreamEvent?.(item, model);
                 if (item.messageStart) {
                     if (item.messageStart.role !== ConversationRole.ASSISTANT) {
                         throw new Error("Unexpected assistant message start but got user message start instead");
@@ -541,6 +549,7 @@ function handleMetadata(event, model, output) {
         output.usage.output = event.usage.outputTokens || 0;
         output.usage.cacheRead = event.usage.cacheReadInputTokens || 0;
         output.usage.cacheWrite = event.usage.cacheWriteInputTokens || 0;
+        output.usage.cacheWrite1h = event.usage.cacheDetails?.reduce((total, detail) => total + (detail.ttl === CacheTTL.ONE_HOUR ? (detail.inputTokens ?? 0) : 0), 0);
         output.usage.totalTokens = event.usage.totalTokens || output.usage.input + output.usage.output;
         calculateCost(model, output.usage);
     }
@@ -735,7 +744,7 @@ function appendMessage(result, message) {
 }
 function convertMessages(context, model, cacheRetention, options = {}) {
     const result = [];
-    const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId, {
+    const transformedMessages = transformMessages(withoutInitialSystemMessage(context.messages), model, normalizeToolCallId, {
         preserveThinking: options.preserveThinking,
     });
     for (let i = 0; i < transformedMessages.length; i++) {
@@ -908,12 +917,13 @@ function convertToolConfig(tools, toolChoice, supportsStrictMode) {
     if (toolChoice === "none")
         return undefined;
     const bedrockTools = tools.map((tool) => {
-        const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
+        const wireTool = { ...tool, parameters: normalizeToolParametersForBedrock({ ...tool.parameters }) };
+        const strict = resolveJsonSchemaStrictSampling(wireTool, supportsStrictMode);
         return {
             toolSpec: {
                 name: tool.name,
                 description: tool.description,
-                inputSchema: { json: toDocumentType(getJsonSchemaToolParameters(tool, strict)) },
+                inputSchema: { json: toDocumentType(getJsonSchemaToolParameters(wireTool, strict)) },
                 ...(strict === true ? { strict: true } : {}),
             },
         };

package/dist/api/cloudflare-workers-ai-system-one.d.ts

@@ -0,0 +1,4 @@
+import type { ClassifierFunction, ClassifierOptions } from "../types.ts";
+/** Cloudflare Workers AI System One classification with public `bool` values mapped to wire-level `noul`. */
+export declare const classify: ClassifierFunction<ClassifierOptions>;
+//# sourceMappingURL=cloudflare-workers-ai-system-one.d.ts.map

package/dist/api/cloudflare-workers-ai-system-one.js

@@ -0,0 +1,43 @@
+import { classifySystemOne, isRecord } from "./system-one-shared.js";
+const LABEL = "Cloudflare Workers AI";
+function cloudflareErrorMessage(errors) {
+    if (Array.isArray(errors)) {
+        const messages = errors
+            .map((error) => (isRecord(error) && typeof error.message === "string" ? error.message : undefined))
+            .filter((message) => message !== undefined);
+        if (messages.length > 0)
+            return `${LABEL} error: ${messages.join("; ")}`;
+    }
+    return `${LABEL} request failed`;
+}
+/**
+ * System One models on the Workers AI REST endpoint:
+ * `POST /accounts/{account}/ai/run` with `{ model, input }`. The REST API
+ * wraps the model output in Cloudflare's API envelope and a run record:
+ * `{ success, result: { state: "Completed", result: { answers, usage } } }`.
+ * https://developers.cloudflare.com/ai/models/typesafe/jev/
+ */
+const transport = {
+    api: "cloudflare-workers-ai-system-one",
+    label: LABEL,
+    url: (model) => new URL("run", `${model.baseUrl.replace(/\/+$/u, "")}/`),
+    payload: (model, request) => ({ model: model.id, input: request }),
+    output: (body) => {
+        if (!isRecord(body))
+            throw new Error(`${LABEL} returned an unexpected response`);
+        if (body.success === false)
+            throw new Error(cloudflareErrorMessage(body.errors));
+        const run = body.result;
+        if (!isRecord(run))
+            throw new Error(`${LABEL} returned an unexpected response`);
+        if (run.state !== "Completed") {
+            throw new Error(`${LABEL} run did not complete (state: ${String(run.state)})`);
+        }
+        if (!isRecord(run.result))
+            throw new Error(`${LABEL} returned an unexpected response`);
+        return run.result;
+    },
+};
+/** Cloudflare Workers AI System One classification with public `bool` values mapped to wire-level `noul`. */
+export const classify = (model, context, options) => classifySystemOne(transport, model, context, options);
+//# sourceMappingURL=cloudflare-workers-ai-system-one.js.map

package/dist/api/cloudflare-workers-ai-system-one.lazy.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderClassifier } from "../types.ts";
+export declare const cloudflareWorkersAISystemOneApi: () => ProviderClassifier;
+//# sourceMappingURL=cloudflare-workers-ai-system-one.lazy.d.ts.map

package/dist/api/cloudflare-workers-ai-system-one.lazy.js

@@ -0,0 +1,4 @@
+export const cloudflareWorkersAISystemOneApi = () => ({
+    classify: async (model, context, options) => (await import("./cloudflare-workers-ai-system-one.js")).classify(model, context, options),
+});
+//# sourceMappingURL=cloudflare-workers-ai-system-one.lazy.js.map

package/dist/api/cloudflare.d.ts

@@ -1,6 +1,8 @@
 import type { Api, Model, ProviderEnv } from "../types.ts";
 /** Workers AI direct endpoint. */
 export declare const CLOUDFLARE_WORKERS_AI_BASE_URL = "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1";
+/** Workers AI REST endpoint root; model runs are posted to `run`. */
+export declare const CLOUDFLARE_WORKERS_AI_REST_BASE_URL = "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai";
 /** AI Gateway Unified API. https://developers.cloudflare.com/ai-gateway/usage/unified-api/ */
 export declare const CLOUDFLARE_AI_GATEWAY_COMPAT_BASE_URL = "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/compat";
 /** AI Gateway → OpenAI passthrough. Used until /compat supports /v1/responses. */