narraeon 0.1.1 → 0.2.0

package/dist/node/runtime/model/FileNativeModelAdapters.js

@@ -2,18 +2,50 @@ import { createHash } from "node:crypto";
 import { appendFile, chmod, mkdir, stat } from "node:fs/promises";
 import { dirname } from "node:path";
 import { defaultAppLocale, } from "../../protocol/appPreferences.js";
-import { ModelHostFailureError, ModelHostOutcomeUnknownError, } from "./ModelHost.js";
+import { hasCLIProxyThinkingSuffix, modelReasoningPolicyIssue, } from "../../protocol/modelConnections.js";
+import { ModelHostBindingMismatchError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, } from "./ModelHost.js";
 import { renderPromptDeltaMessage, } from "../prompt/FileNativePromptCompiler.js";
 import { aggregateAnthropicSettingStream, aggregateChatSettingStream, } from "./SettingAuthorStream.js";
 import { aggregateAnthropicModelStream, aggregateChatModelStream, aggregateResponsesModelStream, } from "./ModelHostStream.js";
-import { defaultRuntimeToolDefinitionStrategy, } from "../prompt/FileNativeToolRegistry.js";
+import { defaultRuntimeToolDefinitionStrategy, portableRuntimeToolInputSchema, } from "../prompt/FileNativeToolRegistry.js";
 import { AiExchangeCapture, errorDescription, } from "./AiFailureLog.js";
+const providerContinuationCodecVersion = 1;
+function resolveConnection(connection) {
+    const resolved = structuredClone({
+        ...connection,
+        dialect: connection.dialect ?? "standard",
+        reasoningEffort: connection.reasoningEffort ?? "provider_default",
+        reasoningSummary: connection.reasoningSummary ?? "provider_default",
+        thinkingMode: connection.thinkingMode ?? "provider_default",
+        thinkingBudgetTokens: connection.thinkingBudgetTokens ?? null,
+    });
+    const issue = modelReasoningPolicyIssue({
+        provider: resolved.provider,
+        dialect: resolved.dialect,
+        modelId: resolved.modelId,
+        effort: resolved.reasoningEffort,
+        summary: resolved.reasoningSummary,
+        thinking: resolved.thinkingMode,
+        thinkingBudgetTokens: resolved.thinkingBudgetTokens,
+        maxOutputTokens: resolved.maxOutputTokens,
+    });
+    if (issue !== null)
+        throw new Error(issue);
+    return resolved;
+}
+function modelCacheStrategy(connection) {
+    if (connection.provider === "anthropic_messages")
+        return "explicit_anthropic_blocks";
+    if (connection.dialect === "cliproxyapi")
+        return "explicit_cliproxyapi_message";
+    return "provider_managed";
+}
 export class FileNativeModelHost {
     #connection;
     #fetch;
     #failureLog;
     constructor(connection, fetchImplementation = fetch, failureLog) {
-        this.#connection = structuredClone(connection);
+        this.#connection = resolveConnection(connection);
         this.#fetch = fetchImplementation;
         this.#failureLog = failureLog;
     }
@@ -24,6 +56,7 @@ export class FileNativeModelHost {
             modelId,
             contextWindowTokens,
             maxOutputTokens,
+            cacheStrategy: modelCacheStrategy(this.#connection),
             endpointFingerprint: createHash("sha256")
                 .update(`${provider}\0${this.#connection.baseUrl}`)
                 .digest("hex"),
@@ -35,11 +68,19 @@ export class FileNativeModelHost {
                 responseStorage: provider === "openai_responses" ? "disabled" : "provider_default",
                 encryptedReasoningContinuation: provider === "openai_responses" ? "included" : "not_requested",
                 anthropicVersion: provider === "anthropic_messages" ? "2023-06-01" : null,
+                dialect: this.#connection.dialect,
+                reasoningEffort: this.#connection.reasoningEffort,
+                reasoningSummary: this.#connection.reasoningSummary,
+                thinkingMode: this.#connection.thinkingMode,
+                thinkingBudgetTokens: this.#connection.thinkingBudgetTokens,
+                cachePolicy: modelCacheStrategy(this.#connection),
+                providerContinuationCodecVersion,
             }))
                 .digest("hex"),
         };
     }
     async exchange(request, observer) {
+        assertExchangeCompatibility(this.#connection, request);
         await trace("model_host_exchange", modelHostTrace(request));
         if (this.#connection.provider === "chat_completions")
             return this.#chat(request, observer?.onDelta);
@@ -47,23 +88,29 @@ export class FileNativeModelHost {
             return this.#responses(request, observer?.onDelta);
         return this.#anthropic(request, observer?.onDelta);
     }
+    /** Uses the production encoders and deliberately omits credentials. */
+    previewRequest(request) {
+        assertExchangeCompatibility(this.#connection, request);
+        const provider = this.#connection.provider;
+        const body = provider === "chat_completions"
+            ? chatRequestBody(this.#connection, request)
+            : provider === "openai_responses"
+                ? responsesRequestBody(responsesRequestInput(this.#connection, request))
+                : anthropicRequestBody(this.#connection, request);
+        return {
+            provider,
+            method: "POST",
+            endpointPath: providerUrl(this.#connection).pathname,
+            headerNames: provider === "anthropic_messages"
+                ? ["Accept", "anthropic-version", "x-api-key", "Content-Type"]
+                : ["Accept", "Authorization", "Content-Type"],
+            body: cloneProviderValue(body),
+        };
+    }
     async #responses(request, onDelta) {
         return openAIResponsesRequest({
-            connection: this.#connection,
+            ...responsesRequestInput(this.#connection, request),
             fetchImplementation: this.#fetch,
-            input: [
-                ...request.bootstrap.provider.messages.map(responsesBootstrapMessage),
-                ...responsesAppend(request),
-            ],
-            tools: providerToolDefinitions(request).map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                parameters: tool.inputSchema,
-            })),
-            allowedTools: providerAllowedTools(request),
-            toolStrategy: providerToolStrategy(request, this.#connection.provider),
-            hasFrozenToolPolicy: hasFrozenToolPolicy(request),
-            maxOutputTokens: request.maxOutputTokens,
             tracePrefix: "responses",
             ...(this.#failureLog === undefined
                 ? {}
@@ -73,37 +120,7 @@ export class FileNativeModelHost {
         });
     }
     async #chat(request, onDelta) {
-        const messages = [
-            ...request.bootstrap.provider.messages,
-            ...chatAppend(request),
-        ];
-        const tools = providerToolDefinitions(request);
-        const allowedTools = providerAllowedTools(request);
-        const hasPolicy = hasFrozenToolPolicy(request);
-        const body = {
-            model: this.#connection.modelId,
-            messages,
-            ...(tools.length === 0
-                ? {}
-                : {
-                    tools: tools.map((tool) => ({
-                        type: "function",
-                        function: {
-                            name: tool.name,
-                            description: tool.description,
-                            parameters: tool.inputSchema,
-                        },
-                    })),
-                }),
-            ...(hasPolicy && allowedTools.length === 0
-                ? { tool_choice: "none" }
-                : tools.length === 0
-                    ? {}
-                    : { tool_choice: "auto" }),
-            max_tokens: request.maxOutputTokens,
-            stream: true,
-            stream_options: { include_usage: true },
-        };
+        const body = chatRequestBody(this.#connection, request);
         const bodyJson = JSON.stringify(body);
         await trace("chat_request", body);
         const url = providerUrl(this.#connection);
@@ -135,6 +152,9 @@ export class FileNativeModelHost {
                         assistantMessage: cloneProviderValue(streamed.assistantMessage),
                     },
                     usage: normalizeChatUsage(streamed.usage),
+                    ...(streamed.stopReason === undefined
+                        ? {}
+                        : { stopReason: streamed.stopReason }),
                     toolCalls: streamed.toolCalls.map((call) => ({
                         id: call.id,
                         name: call.name,
@@ -151,21 +171,14 @@ export class FileNativeModelHost {
             const payload = rawPayload;
             await trace("chat_response", payload);
             const message = payload.choices?.[0]?.message;
+            const finishReason = payload.choices?.[0]?.finish_reason;
             if (message === undefined)
                 throw unknownProviderResponse("Chat Completions");
-            if ((message.content !== undefined &&
-                message.content !== null &&
-                typeof message.content !== "string") ||
-                (message.reasoning_content !== undefined &&
-                    message.reasoning_content !== null &&
-                    typeof message.reasoning_content !== "string") ||
-                (message.tool_calls !== undefined &&
-                    (!Array.isArray(message.tool_calls) ||
-                        message.tool_calls.some((call) => !isRecord(call) ||
-                            typeof call.id !== "string" ||
-                            !isRecord(call.function) ||
-                            typeof call.function.name !== "string" ||
-                            typeof call.function.arguments !== "string"))))
+            if (finishReason !== undefined &&
+                finishReason !== null &&
+                typeof finishReason !== "string")
+                throw unknownProviderResponse("Chat Completions");
+            if (!validChatAssistantMessage(message))
                 throw unknownProviderResponse("Chat Completions");
             capture?.setReasoning(message.reasoning_content ?? undefined);
             return {
@@ -178,6 +191,9 @@ export class FileNativeModelHost {
                     assistantMessage: cloneProviderValue(message),
                 },
                 usage: normalizeChatUsage(payload.usage),
+                ...(typeof finishReason === "string"
+                    ? { stopReason: finishReason }
+                    : {}),
                 toolCalls: (message.tool_calls ?? []).map((call) => ({
                     id: call.id,
                     name: call.function.name,
@@ -187,26 +203,7 @@ export class FileNativeModelHost {
         });
     }
     async #anthropic(request, onDelta) {
-        const tools = providerToolDefinitions(request);
-        const body = {
-            model: this.#connection.modelId,
-            system: request.bootstrap.provider.system,
-            messages: [
-                ...request.bootstrap.provider.messages.filter(({ role }) => role !== "system"),
-                ...anthropicAppend(request),
-            ],
-            ...(tools.length === 0
-                ? {}
-                : {
-                    tools: tools.map((tool) => ({
-                        name: tool.name,
-                        description: tool.description,
-                        input_schema: tool.inputSchema,
-                    })),
-                }),
-            max_tokens: request.maxOutputTokens,
-            stream: true,
-        };
+        const body = anthropicRequestBody(this.#connection, request);
         const bodyJson = JSON.stringify(body);
         await trace("anthropic_request", body);
         const url = providerUrl(this.#connection);
@@ -253,6 +250,9 @@ export class FileNativeModelHost {
                             : { stopReason: streamed.stopReason }),
                     },
                     usage: normalizeAnthropicUsage(streamed.usage),
+                    ...(typeof streamed.stopReason === "string"
+                        ? { stopReason: streamed.stopReason }
+                        : {}),
                 };
             }
             const rawPayload = await providerJson(response, "Anthropic Messages");
@@ -260,14 +260,7 @@ export class FileNativeModelHost {
                 throw unknownProviderResponse("Anthropic Messages");
             const payload = rawPayload;
             const content = payload.content;
-            if (content.some((item) => !isRecord(item) ||
-                typeof item.type !== "string" ||
-                (item.type === "text" && typeof item.text !== "string") ||
-                (item.type === "thinking" && typeof item.thinking !== "string") ||
-                (item.type === "tool_use" &&
-                    (typeof item.id !== "string" ||
-                        typeof item.name !== "string" ||
-                        !("input" in item)))))
+            if (!validAnthropicContent(content))
                 throw unknownProviderResponse("Anthropic Messages");
             await trace("anthropic_response", payload);
             const reasoningContent = content
@@ -298,10 +291,21 @@ export class FileNativeModelHost {
                         : { stopReason: payload.stop_reason }),
                 },
                 usage: normalizeAnthropicUsage(payload.usage),
+                ...(typeof payload.stop_reason === "string"
+                    ? { stopReason: payload.stop_reason }
+                    : {}),
             };
         });
     }
 }
+function assertExchangeCompatibility(connection, request) {
+    if (request.bootstrap.provider.protocol !== connection.provider)
+        throw new ModelHostBindingMismatchError("The compiled prompt protocol does not match the selected model host");
+    if (request.bootstrap.cache.strategy !== modelCacheStrategy(connection))
+        throw new ModelHostBindingMismatchError("The compiled prompt cache policy does not match the selected model host");
+    if (request.maxOutputTokens > connection.maxOutputTokens)
+        throw new ModelHostBindingMismatchError("The request output limit exceeds the selected model host binding");
+}
 function modelHostTrace(request) {
     return {
         requestId: request.requestId,
@@ -420,7 +424,7 @@ export class FileNativeSettingAuthorProvider {
     #locale;
     #exchange = 0;
     constructor(connection, fetchImplementation = fetch, diagnostics) {
-        this.#connection = structuredClone(connection);
+        this.#connection = resolveConnection(connection);
         this.#fetch = fetchImplementation;
         this.#failureLog = diagnostics?.failureLog;
         this.#operationId = diagnostics?.operationId;
@@ -441,7 +445,13 @@ export class FileNativeSettingAuthorProvider {
         if (this.#connection.provider === "chat_completions") {
             const body = {
                 model: this.#connection.modelId,
-                messages: request.messages.map(chatSettingMessage),
+                ...chatReasoningRequest(this.#connection),
+                messages: chatSettingMessages(this.#connection, request.messages),
+                ...(this.#connection.dialect === "cliproxyapi"
+                    ? {
+                        prompt_cache_key: settingPromptCacheKey(this.#connection, request.messages, this.#operationId),
+                    }
+                    : {}),
                 ...(tools.length === 0
                     ? {}
                     : {
@@ -485,6 +495,10 @@ export class FileNativeSettingAuthorProvider {
                     ...(streamed.reasoningContent === ""
                         ? {}
                         : { reasoningContent: streamed.reasoningContent }),
+                    providerState: {
+                        protocol: "chat_completions",
+                        assistantMessage: cloneProviderValue(streamed.assistantMessage),
+                    },
                     toolCalls: streamed.toolCalls.map((call) => ({
                         id: call.id,
                         name: call.name,
@@ -498,13 +512,14 @@ export class FileNativeSettingAuthorProvider {
             const response = await openAIResponsesRequest({
                 connection: this.#connection,
                 fetchImplementation: this.#fetch,
-                input: request.messages.flatMap(responsesSettingMessage),
+                input: responsesSettingInput(this.#connection, request.messages),
                 tools: tools.map((tool) => ({
                     name: tool.name,
                     description: tool.description,
                     parameters: tool.schema,
                 })),
                 maxOutputTokens: Math.min(request.maxOutputTokens, this.#connection.maxOutputTokens),
+                promptCacheKey: settingPromptCacheKey(this.#connection, request.messages, this.#operationId),
                 tracePrefix: "setting_responses",
                 ...(this.#failureLog === undefined
                     ? {}
@@ -515,6 +530,9 @@ export class FileNativeSettingAuthorProvider {
             return {
                 role: "assistant",
                 content: response.text ?? "",
+                ...(response.reasoningContent === undefined
+                    ? {}
+                    : { reasoningContent: response.reasoningContent }),
                 providerState: response.providerState,
                 toolCalls: (response.toolCalls ?? []).map((call) => ({
                     ...call,
@@ -528,14 +546,18 @@ export class FileNativeSettingAuthorProvider {
         }
         const system = request.messages
             .filter(({ role }) => role === "system")
-            .map(({ content }) => content)
-            .join("\n\n");
+            .map(({ content }, index, messages) => ({
+            type: "text",
+            text: content,
+            ...(index === messages.length - 1
+                ? { cache_control: { type: "ephemeral" } }
+                : {}),
+        }));
         const body = {
             model: this.#connection.modelId,
+            ...anthropicReasoningRequest(this.#connection),
             ...(system.length === 0 ? {} : { system }),
-            messages: request.messages
-                .filter(({ role }) => role !== "system")
-                .map(anthropicSettingMessage),
+            messages: anthropicSettingMessages(request.messages),
             ...(tools.length === 0
                 ? {}
                 : {
@@ -576,25 +598,41 @@ export class FileNativeSettingAuthorProvider {
                 ...(streamed.reasoningContent === ""
                     ? {}
                     : { reasoningContent: streamed.reasoningContent }),
+                providerState: {
+                    protocol: "anthropic_messages",
+                    content: cloneProviderValue(streamed.providerContent),
+                    ...(streamed.responseId === undefined
+                        ? {}
+                        : { responseId: streamed.responseId }),
+                    ...(streamed.model === undefined ? {} : { model: streamed.model }),
+                    ...(streamed.stopReason === undefined
+                        ? {}
+                        : { stopReason: streamed.stopReason }),
+                },
                 toolCalls: streamed.toolCalls.map((call) => ({
                     id: call.id,
                     name: call.name,
-                    arguments: asArguments(parseArguments(call.arguments)),
+                    arguments: asArguments(structuredClone(call.arguments)),
                 })),
                 usage: settingAuthorUsage(normalizeAnthropicUsage(streamed.usage)),
             };
         });
     }
 }
-// The progress projection only counts tokens, so the nullable per-field
-// provenance of ModelHostUsage collapses to two numbers here.
+// Setting authoring uses the same complete usage projection as play. Missing
+// Provider usage stays unavailable instead of being counted as zero.
 function settingAuthorUsage(usage) {
-    if (usage === undefined)
-        return { inputTokens: 0, outputTokens: 0 };
-    return {
-        inputTokens: usage.inputTokens ?? 0,
-        outputTokens: usage.outputTokens ?? 0,
-    };
+    if (usage !== undefined)
+        return structuredClone(usage);
+    return usageRecord({
+        inputTokens: null,
+        uncachedInputTokens: null,
+        cacheReadTokens: null,
+        cacheWriteTokens: null,
+        reasoningTokens: null,
+        outputTokens: null,
+        totalTokens: null,
+    });
 }
 function settingToolDefinition(name, locale = defaultAppLocale) {
     const descriptions = settingToolDescriptions[locale];
@@ -698,6 +736,126 @@ const settingToolDescriptions = {
 function items(request) {
     return request.appended;
 }
+function chatRequestBody(connection, request) {
+    const tools = providerToolDefinitions(request);
+    const allowedTools = providerAllowedTools(request);
+    const hasPolicy = hasFrozenToolPolicy(request);
+    return {
+        model: connection.modelId,
+        ...chatReasoningRequest(connection),
+        messages: [
+            ...chatBootstrapMessages(connection, request),
+            ...chatAppend(request),
+        ],
+        ...(connection.dialect === "cliproxyapi"
+            ? { prompt_cache_key: promptCacheKey(connection, request) }
+            : {}),
+        ...(tools.length === 0
+            ? {}
+            : {
+                tools: tools.map((tool) => ({
+                    type: "function",
+                    function: {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: tool.inputSchema,
+                    },
+                })),
+            }),
+        ...(hasPolicy && allowedTools.length === 0
+            ? { tool_choice: "none" }
+            : tools.length === 0
+                ? {}
+                : { tool_choice: "auto" }),
+        max_tokens: request.maxOutputTokens,
+        stream: true,
+        stream_options: { include_usage: true },
+    };
+}
+function anthropicRequestBody(connection, request) {
+    const tools = providerToolDefinitions(request);
+    return {
+        model: connection.modelId,
+        ...anthropicReasoningRequest(connection),
+        system: request.bootstrap.provider.system,
+        messages: [
+            ...request.bootstrap.provider.messages.filter(({ role }) => role !== "system"),
+            ...anthropicAppend(request),
+        ],
+        ...(tools.length === 0
+            ? {}
+            : {
+                tools: tools.map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    input_schema: tool.inputSchema,
+                })),
+            }),
+        ...(hasFrozenToolPolicy(request) &&
+            providerAllowedTools(request).length === 0
+            ? { tool_choice: { type: "none" } }
+            : {}),
+        max_tokens: request.maxOutputTokens,
+        stream: true,
+    };
+}
+function responsesRequestInput(connection, request) {
+    return {
+        connection,
+        input: [
+            ...responsesBootstrapMessages(connection, request),
+            ...responsesAppend(request),
+        ],
+        tools: providerToolDefinitions(request).map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema,
+        })),
+        allowedTools: providerAllowedTools(request),
+        toolStrategy: providerToolStrategy(request, connection.provider),
+        hasFrozenToolPolicy: hasFrozenToolPolicy(request),
+        maxOutputTokens: request.maxOutputTokens,
+        promptCacheKey: promptCacheKey(connection, request),
+    };
+}
+function responsesRequestBody(input) {
+    const allowedTools = input.allowedTools ?? input.tools.map((tool) => tool.name);
+    const toolChoice = input.hasFrozenToolPolicy === true && allowedTools.length === 0
+        ? "none"
+        : input.hasFrozenToolPolicy === true &&
+            input.toolStrategy === "native_allowed_subset"
+            ? {
+                type: "allowed_tools",
+                mode: "auto",
+                tools: allowedTools.map((name) => ({ type: "function", name })),
+            }
+            : "auto";
+    return {
+        model: input.connection.modelId,
+        ...responsesReasoningRequest(resolveConnection(input.connection)),
+        input: input.input,
+        ...(input.tools.length === 0
+            ? input.hasFrozenToolPolicy === true && allowedTools.length === 0
+                ? { tool_choice: "none" }
+                : {}
+            : {
+                tools: input.tools.map((tool) => ({
+                    type: "function",
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.parameters,
+                })),
+                tool_choice: toolChoice,
+            }),
+        max_output_tokens: input.maxOutputTokens,
+        ...(input.promptCacheKey === undefined
+            ? {}
+            : { prompt_cache_key: input.promptCacheKey }),
+        store: false,
+        include: ["reasoning.encrypted_content"],
+        stream: true,
+    };
+}
 /**
  * A frozen policy is present when the caller supplies the logical operation's
  * complete tool universe. All play lifecycles share this one ModelHost seam.
@@ -712,7 +870,26 @@ function frozenToolPolicy(request) {
 }
 function providerToolDefinitions(request) {
     const policy = frozenToolPolicy(request);
-    return policy?.toolUniverse ?? request.tools;
+    return (policy?.toolUniverse ?? request.tools).map((tool) => {
+        if (!hasUnsupportedProviderToolSchemaRoot(tool.inputSchema))
+            return tool;
+        const portableInputSchema = portableRuntimeToolInputSchema(tool.name);
+        if (portableInputSchema === null)
+            throw new Error(`Provider tool ${tool.name} uses oneOf, allOf, or anyOf at the input schema root`);
+        if (hasUnsupportedProviderToolSchemaRoot(portableInputSchema))
+            throw new Error(`Provider tool ${tool.name} has no portable root-object input schema`);
+        // Released play contexts freeze their logical tool universe. Migrate only
+        // the Provider wire projection of the old root-union schema; Runtime keeps
+        // validating the original source-specific contract and the persisted
+        // transcript remains untouched.
+        return {
+            ...tool,
+            inputSchema: portableInputSchema,
+        };
+    });
+}
+function hasUnsupportedProviderToolSchemaRoot(schema) {
+    return ["oneOf", "allOf", "anyOf"].some((keyword) => Object.prototype.hasOwnProperty.call(schema, keyword));
 }
 function providerAllowedTools(request) {
     const policy = frozenToolPolicy(request);
@@ -726,82 +903,127 @@ function providerToolStrategy(request, provider) {
         return policy.toolStrategy;
     return defaultRuntimeToolDefinitionStrategy(provider);
 }
+function chatBootstrapMessages(connection, request) {
+    const messages = request.bootstrap.provider.messages.map((message) => cloneProviderValue(message));
+    return connection.dialect === "cliproxyapi"
+        ? attachCacheControlToLastRole(messages, "system")
+        : messages;
+}
+function responsesBootstrapMessages(connection, request) {
+    const messages = request.bootstrap.provider.messages.map((message) => responsesBootstrapMessage(message, connection.dialect === "cliproxyapi"));
+    return connection.dialect === "cliproxyapi"
+        ? attachCacheControlToLastRole(messages, "system")
+        : messages;
+}
+function attachCacheControlToLastRole(messages, role) {
+    const result = cloneProviderValue(messages);
+    let target = -1;
+    for (const [index, message] of result.entries())
+        if (isRecord(message) && message.role === role)
+            target = index;
+    if (target < 0)
+        return result;
+    const message = result[target];
+    if (!isRecord(message))
+        return result;
+    result[target] = {
+        ...message,
+        cache_control: { type: "ephemeral" },
+    };
+    return result;
+}
+function promptCacheKey(connection, request) {
+    const stablePrefixScope = request.bootstrap.cache.stablePrefixFingerprint ??
+        createHash("sha256")
+            .update(JSON.stringify({
+            provider: request.bootstrap.provider,
+            tools: request.toolUniverse ?? request.tools,
+            toolStrategy: request.toolStrategy,
+        }))
+            .digest("hex");
+    // OpenAI uses this as a cache-routing hint, so equal frozen prefixes should
+    // share it. CLIProxyAPI additionally treats it as execution-session identity;
+    // there it must stay stable within one chain and isolated across chains.
+    const scope = connection.dialect === "cliproxyapi"
+        ? (request.operationId ?? stablePrefixScope)
+        : stablePrefixScope;
+    return createHash("sha256")
+        .update(`${connection.provider}\0${connection.dialect}\0${connection.modelId}\0${scope}`)
+        .digest("hex");
+}
+function settingPromptCacheKey(connection, messages, operationId) {
+    const firstAssistant = messages.findIndex(({ role }) => role === "assistant");
+    const initialPrefix = messages.slice(0, firstAssistant < 0 ? messages.length : firstAssistant);
+    const stablePrefixScope = JSON.stringify(initialPrefix);
+    const scope = connection.dialect === "cliproxyapi"
+        ? (operationId ?? stablePrefixScope)
+        : stablePrefixScope;
+    return createHash("sha256")
+        .update(`${connection.provider}\0${connection.dialect}\0${connection.modelId}\0${scope}`)
+        .digest("hex");
+}
 function chatAppend(request) {
     return items(request).flatMap((item) => {
         if (item.kind === "player")
-            return { role: "user", content: item.text };
+            return [{ role: "user", content: item.text }];
         if (item.kind === "prompt_delta")
             return promptDeltaProviderMessages(item.logicalMessages);
         if (item.kind === "tool")
-            return {
-                role: "tool",
-                tool_call_id: item.toolCallId,
-                content: item.markdown,
-            };
+            return [
+                {
+                    role: "tool",
+                    tool_call_id: item.toolCallId,
+                    content: item.markdown,
+                },
+            ];
         if (item.providerState?.protocol === "chat_completions") {
             const message = item.providerState.assistantMessage;
-            if (isRecord(message))
+            if (validChatAssistantMessage(message))
                 return [cloneProviderValue(message)];
         }
-        const assistant = {
-            role: "assistant",
-            content: item.text,
-            ...(item.reasoningContent === undefined
-                ? {}
-                : { reasoning_content: item.reasoningContent }),
-            ...(item.toolCalls.length === 0
-                ? {}
-                : {
-                    tool_calls: item.toolCalls.map((call) => ({
-                        id: call.id,
-                        type: "function",
-                        function: {
-                            name: call.name,
-                            arguments: JSON.stringify(call.arguments),
-                        },
-                    })),
-                }),
-        };
-        return assistant;
+        throw continuationError("Chat Completions");
     });
 }
 function anthropicAppend(request) {
-    return items(request).flatMap((item) => {
-        if (item.kind === "player")
-            return { role: "user", content: item.text };
-        if (item.kind === "prompt_delta")
-            return promptDeltaProviderMessages(item.logicalMessages);
-        if (item.kind === "tool")
-            return {
-                role: "user",
-                content: [
-                    {
-                        type: "tool_result",
-                        tool_use_id: item.toolCallId,
-                        content: item.markdown,
-                    },
-                ],
-            };
-        if (item.providerState?.protocol === "anthropic_messages")
-            return [
-                {
-                    role: "assistant",
-                    content: cloneProviderValue(item.providerState.content),
-                },
-            ];
-        return {
-            role: "assistant",
-            content: [
-                ...(item.text.length === 0 ? [] : [{ type: "text", text: item.text }]),
-                ...item.toolCalls.map((call) => ({
-                    type: "tool_use",
-                    id: call.id,
-                    name: call.name,
-                    input: call.arguments,
-                })),
-            ],
-        };
-    });
+    const messages = [];
+    let toolResults = [];
+    const flushToolResults = () => {
+        if (toolResults.length === 0)
+            return;
+        messages.push({ role: "user", content: toolResults });
+        toolResults = [];
+    };
+    for (const item of items(request)) {
+        if (item.kind === "tool") {
+            toolResults.push({
+                type: "tool_result",
+                tool_use_id: item.toolCallId,
+                content: item.markdown,
+                ...(item.isError === true ? { is_error: true } : {}),
+            });
+            continue;
+        }
+        flushToolResults();
+        if (item.kind === "player") {
+            messages.push({ role: "user", content: item.text });
+            continue;
+        }
+        if (item.kind === "prompt_delta") {
+            messages.push(...promptDeltaProviderMessages(item.logicalMessages));
+            continue;
+        }
+        if (item.providerState?.protocol === "anthropic_messages" &&
+            validAnthropicContent(item.providerState.content)) {
+            messages.push({
+                role: "assistant",
+                content: cloneProviderValue(item.providerState.content),
+            });
+            continue;
+        }
+        throw continuationError("Anthropic Messages");
+    }
+    flushToolResults();
+    return messages;
 }
 function responsesAppend(request) {
     return items(request).flatMap((item) => {
@@ -817,9 +1039,10 @@ function responsesAppend(request) {
                     output: item.markdown,
                 },
             ];
-        if (item.providerState?.protocol === "openai_responses")
+        if (item.providerState?.protocol === "openai_responses" &&
+            validResponsesOutput(item.providerState.output))
             return cloneResponseOutput(item.providerState.output);
-        return fallbackResponsesAssistant(item.text, item.toolCalls);
+        throw continuationError("OpenAI Responses");
     });
 }
 function promptDeltaProviderMessages(messages) {
@@ -828,6 +1051,77 @@ function promptDeltaProviderMessages(messages) {
         content: renderPromptDeltaMessage(message.role, message.markdown),
     }));
 }
+function chatReasoningRequest(connection) {
+    return {
+        ...(connection.reasoningEffort === "provider_default"
+            ? {}
+            : { reasoning_effort: connection.reasoningEffort }),
+        ...(connection.dialect !== "cliproxyapi" ||
+            connection.reasoningSummary === "provider_default"
+            ? {}
+            : {
+                // Chat Completions has no standard summary switch. CLIProxyAPI
+                // deliberately accepts the OpenRouter-compatible visibility bit and
+                // maps it to the target protocol without changing effort.
+                reasoning: {
+                    exclude: connection.reasoningSummary === "none",
+                },
+            }),
+    };
+}
+function responsesReasoningRequest(connection) {
+    const reasoning = {
+        ...(connection.reasoningEffort === "provider_default"
+            ? {}
+            : { effort: connection.reasoningEffort }),
+        ...(connection.reasoningSummary === "provider_default" ||
+            (connection.reasoningSummary === "none" &&
+                connection.dialect === "standard")
+            ? {}
+            : {
+                summary: connection.reasoningSummary === "none"
+                    ? null
+                    : connection.reasoningSummary,
+            }),
+    };
+    return Object.keys(reasoning).length === 0 ? {} : { reasoning };
+}
+function anthropicReasoningRequest(connection) {
+    const display = connection.reasoningSummary === "provider_default"
+        ? {}
+        : {
+            display: connection.reasoningSummary === "auto" ? "summarized" : "omitted",
+        };
+    const thinking = connection.thinkingMode === "provider_default"
+        ? connection.dialect === "cliproxyapi" &&
+            hasCLIProxyThinkingSuffix(connection.modelId) &&
+            connection.reasoningSummary !== "provider_default"
+            ? {
+                // CLIProxyAPI extracts visibility from a valid source thinking
+                // block before the model suffix replaces its mode. The suffix is
+                // still the sole mode/effort authority; adaptive is only the
+                // proxy's protocol-valid summary carrier.
+                thinking: { type: "adaptive", ...display },
+            }
+            : {}
+        : connection.thinkingMode === "disabled"
+            ? { thinking: { type: "disabled" } }
+            : connection.thinkingMode === "adaptive"
+                ? { thinking: { type: "adaptive", ...display } }
+                : {
+                    thinking: {
+                        type: "enabled",
+                        budget_tokens: connection.thinkingBudgetTokens,
+                        ...display,
+                    },
+                };
+    return {
+        ...thinking,
+        ...(connection.reasoningEffort === "provider_default"
+            ? {}
+            : { output_config: { effort: connection.reasoningEffort } }),
+    };
+}
 function providerUrl(connection) {
     const url = new URL(connection.baseUrl);
     const suffix = connection.provider === "chat_completions"
@@ -863,6 +1157,12 @@ async function providerError(response) {
     });
     return new ModelHostFailureError(`Provider request failed: ${response.status} ${text}`);
 }
+function chatSettingMessages(connection, messages) {
+    const translated = messages.map(chatSettingMessage);
+    if (connection.dialect !== "cliproxyapi")
+        return translated;
+    return attachCacheControlAtIndex(attachCacheControlToLastRole(translated, "system"), settingPrefixUserIndex(messages));
+}
 function chatSettingMessage(message) {
     if (message.role === "tool")
         return {
@@ -870,58 +1170,91 @@ function chatSettingMessage(message) {
             tool_call_id: message.toolCallId,
             content: message.content,
         };
+    if (message.role === "assistant") {
+        const state = message.providerState;
+        if (state?.protocol === "chat_completions" &&
+            validChatAssistantMessage(state.assistantMessage))
+            return cloneProviderValue(state.assistantMessage);
+        throw continuationError("Chat Completions setting improvement");
+    }
     return {
-        role: message.role === "assistant"
-            ? "assistant"
-            : message.role === "system"
-                ? "system"
-                : "user",
+        role: message.role === "system" ? "system" : "user",
         content: message.content,
-        ...(message.role !== "assistant" || message.reasoningContent === undefined
-            ? {}
-            : { reasoning_content: message.reasoningContent }),
-        ...(message.role !== "assistant" || (message.toolCalls?.length ?? 0) === 0
-            ? {}
-            : {
-                tool_calls: message.toolCalls.map((call) => ({
-                    id: call.id,
-                    type: "function",
-                    function: {
-                        name: call.name,
-                        arguments: JSON.stringify(call.arguments),
-                    },
-                })),
-            }),
     };
 }
-function anthropicSettingMessage(message) {
-    if (message.role === "tool")
-        return {
+function anthropicSettingMessages(source) {
+    const messages = [];
+    const cacheableUserIndex = settingPrefixUserIndex(source);
+    let toolResults = [];
+    const flushToolResults = () => {
+        if (toolResults.length === 0)
+            return;
+        messages.push({ role: "user", content: toolResults });
+        toolResults = [];
+    };
+    for (const [index, message] of source.entries()) {
+        if (message.role === "system")
+            continue;
+        if (message.role === "tool") {
+            toolResults.push({
+                type: "tool_result",
+                tool_use_id: message.toolCallId,
+                content: message.content,
+                ...(message.isError === true ? { is_error: true } : {}),
+            });
+            continue;
+        }
+        flushToolResults();
+        if (message.role === "assistant") {
+            if (message.providerState?.protocol !== "anthropic_messages" ||
+                !validAnthropicContent(message.providerState.content))
+                throw continuationError("Anthropic Messages setting improvement");
+            messages.push({
+                role: "assistant",
+                content: cloneProviderValue(message.providerState.content),
+            });
+            continue;
+        }
+        messages.push({
             role: "user",
-            content: [
-                {
-                    type: "tool_result",
-                    tool_use_id: message.toolCallId,
-                    content: message.content,
-                },
-            ],
-        };
-    if (message.role === "assistant")
-        return {
-            role: "assistant",
-            content: [
-                ...(message.content.length === 0
-                    ? []
-                    : [{ type: "text", text: message.content }]),
-                ...(message.toolCalls ?? []).map((call) => ({
-                    type: "tool_use",
-                    id: call.id,
-                    name: call.name,
-                    input: call.arguments,
-                })),
-            ],
-        };
-    return { role: "user", content: message.content };
+            content: index === cacheableUserIndex
+                ? [
+                    {
+                        type: "text",
+                        text: message.content,
+                        cache_control: { type: "ephemeral" },
+                    },
+                ]
+                : message.content,
+        });
+    }
+    flushToolResults();
+    return messages;
+}
+function responsesSettingInput(connection, messages) {
+    const translated = messages.flatMap(responsesSettingMessage);
+    if (connection.dialect !== "cliproxyapi")
+        return translated;
+    return attachCacheControlAtIndex(attachCacheControlToLastRole(translated, "system"), settingPrefixUserIndex(messages));
+}
+function settingPrefixUserIndex(messages) {
+    const firstAssistant = messages.findIndex(({ role }) => role === "assistant");
+    const end = firstAssistant < 0 ? messages.length : firstAssistant;
+    let target = -1;
+    for (let index = 0; index < end; index += 1)
+        if (messages[index]?.role === "user")
+            target = index;
+    return target;
+}
+function attachCacheControlAtIndex(messages, index) {
+    const result = cloneProviderValue(messages);
+    if (index < 0 || !isRecord(result[index]))
+        return result;
+    result[index] = {
+        ...result[index],
+        cache_control: { type: "ephemeral" },
+    };
+    return result;
 }
 function responsesSettingMessage(message) {
     if (message.role === "tool")
@@ -933,14 +1266,32 @@ function responsesSettingMessage(message) {
             },
         ];
     if (message.role === "assistant" &&
-        message.providerState?.protocol === "openai_responses")
+        message.providerState?.protocol === "openai_responses" &&
+        validResponsesOutput(message.providerState.output))
         return cloneResponseOutput(message.providerState.output);
     if (message.role === "assistant")
-        return fallbackResponsesAssistant(message.content, message.toolCalls ?? []);
+        throw continuationError("OpenAI Responses setting improvement");
     return [{ role: message.role, content: message.content }];
 }
-function responsesBootstrapMessage(message) {
-    return { role: message.role, content: providerText(message.content) };
+function responsesBootstrapMessage(message, preserveCacheControl = false) {
+    return {
+        role: message.role,
+        content: preserveCacheControl && Array.isArray(message.content)
+            ? message.content.flatMap((item) => {
+                if (!isRecord(item) || typeof item.text !== "string")
+                    return [];
+                return [
+                    {
+                        type: "input_text",
+                        text: item.text,
+                        ...(isRecord(item.cache_control)
+                            ? { cache_control: cloneProviderValue(item.cache_control) }
+                            : {}),
+                    },
+                ];
+            })
+            : providerText(message.content),
+    };
 }
 function providerText(content) {
     if (typeof content === "string")
@@ -953,50 +1304,71 @@ function providerText(content) {
     }
     return JSON.stringify(content) ?? "";
 }
-function fallbackResponsesAssistant(text, toolCalls) {
-    return [
-        ...(text.length === 0 ? [] : [{ role: "assistant", content: text }]),
-        ...toolCalls.map((call) => ({
-            type: "function_call",
-            call_id: call.id,
-            name: call.name,
-            arguments: JSON.stringify(call.arguments),
-        })),
-    ];
+function validChatAssistantMessage(value) {
+    if (!isRecord(value) || value.role !== "assistant")
+        return false;
+    if (value.content !== undefined &&
+        value.content !== null &&
+        typeof value.content !== "string")
+        return false;
+    if (value.reasoning_content !== undefined &&
+        value.reasoning_content !== null &&
+        typeof value.reasoning_content !== "string")
+        return false;
+    return (value.tool_calls === undefined ||
+        (Array.isArray(value.tool_calls) &&
+            value.tool_calls.every((call) => isRecord(call) &&
+                typeof call.id === "string" &&
+                isRecord(call.function) &&
+                typeof call.function.name === "string" &&
+                typeof call.function.arguments === "string")));
+}
+function validAnthropicContent(value) {
+    return (Array.isArray(value) &&
+        value.every((item) => {
+            if (!isRecord(item) || typeof item.type !== "string")
+                return false;
+            if (item.type === "text")
+                return typeof item.text === "string";
+            if (item.type === "thinking")
+                return (typeof item.thinking === "string" &&
+                    (item.signature === undefined || typeof item.signature === "string"));
+            if (item.type === "redacted_thinking")
+                return typeof item.data === "string";
+            if (item.type === "tool_use")
+                return (typeof item.id === "string" &&
+                    typeof item.name === "string" &&
+                    isRecord(item.input));
+            return true;
+        }));
+}
+function validResponsesOutput(value) {
+    return (Array.isArray(value) &&
+        value.every((item) => {
+            if (!isRecord(item) || typeof item.type !== "string")
+                return false;
+            if (item.type === "message")
+                return Array.isArray(item.content);
+            if (item.type === "function_call")
+                return (typeof item.call_id === "string" &&
+                    typeof item.name === "string" &&
+                    typeof item.arguments === "string");
+            if (item.type === "reasoning")
+                return ((item.summary === undefined || Array.isArray(item.summary)) &&
+                    (item.content === undefined ||
+                        item.content === null ||
+                        Array.isArray(item.content)) &&
+                    (item.encrypted_content === undefined ||
+                        item.encrypted_content === null ||
+                        typeof item.encrypted_content === "string"));
+            return true;
+        }));
+}
+function continuationError(protocol) {
+    return new ModelHostContinuationError(`${protocol} continuation payload is missing or incompatible; start a fresh model context instead of rebuilding it from parsed text, reasoning, or tool calls`);
 }
 async function openAIResponsesRequest(input) {
-    const allowedTools = input.allowedTools ?? input.tools.map((tool) => tool.name);
-    const toolChoice = input.hasFrozenToolPolicy === true && allowedTools.length === 0
-        ? "none"
-        : input.hasFrozenToolPolicy === true &&
-            input.toolStrategy === "native_allowed_subset"
-            ? {
-                type: "allowed_tools",
-                mode: "auto",
-                tools: allowedTools.map((name) => ({ type: "function", name })),
-            }
-            : "auto";
-    const body = {
-        model: input.connection.modelId,
-        input: input.input,
-        ...(input.tools.length === 0
-            ? input.hasFrozenToolPolicy === true && allowedTools.length === 0
-                ? { tool_choice: "none" }
-                : {}
-            : {
-                tools: input.tools.map((tool) => ({
-                    type: "function",
-                    name: tool.name,
-                    description: tool.description,
-                    parameters: tool.parameters,
-                })),
-                tool_choice: toolChoice,
-            }),
-        max_output_tokens: input.maxOutputTokens,
-        store: false,
-        include: ["reasoning.encrypted_content"],
-        stream: true,
-    };
+    const body = responsesRequestBody(input);
     await trace(`${input.tracePrefix}_request`, body);
     const bodyJson = JSON.stringify(body);
     const url = providerUrl(input.connection);
@@ -1021,13 +1393,7 @@ async function openAIResponsesRequest(input) {
         if (!isRecord(payload) || !Array.isArray(payload.output))
             throw unknownProviderResponse("Responses API");
         const output = cloneResponseOutput(payload.output);
-        if (output.some((item) => !isRecord(item) ||
-            typeof item.type !== "string" ||
-            (item.type === "message" && !Array.isArray(item.content)) ||
-            (item.type === "function_call" &&
-                (typeof item.call_id !== "string" ||
-                    typeof item.name !== "string" ||
-                    typeof item.arguments !== "string"))))
+        if (!validResponsesOutput(output))
             throw unknownProviderResponse("Responses API");
         const text = output
             .flatMap((item) => {
@@ -1042,6 +1408,7 @@ async function openAIResponsesRequest(input) {
                 : []);
         })
             .join("");
+        const reasoningContent = responsesReturnedReasoning(output);
         const toolCalls = output.flatMap((item) => {
             if (!isRecord(item) ||
                 item.type !== "function_call" ||
@@ -1057,18 +1424,61 @@ async function openAIResponsesRequest(input) {
                 },
             ];
         });
+        const stopReason = responsesStopReason(payload);
         return {
             ...(text.length === 0 ? {} : { text }),
+            ...(reasoningContent.length === 0 ? {} : { reasoningContent }),
             providerState: {
                 protocol: "openai_responses",
                 output,
                 ...(typeof payload.id === "string" ? { responseId: payload.id } : {}),
             },
             usage: normalizeResponsesUsage(payload.usage),
+            ...(stopReason === undefined ? {} : { stopReason }),
             toolCalls,
         };
     });
 }
+function responsesStopReason(payload) {
+    const status = typeof payload.status === "string" && payload.status !== ""
+        ? payload.status
+        : undefined;
+    const details = isRecord(payload.incomplete_details)
+        ? payload.incomplete_details
+        : undefined;
+    const reason = details !== undefined &&
+        typeof details.reason === "string" &&
+        details.reason !== ""
+        ? details.reason
+        : undefined;
+    if (status !== undefined && reason !== undefined)
+        return `${status}:${reason}`;
+    return reason ?? status;
+}
+function responsesReturnedReasoning(output) {
+    return output
+        .flatMap((item) => {
+        if (!isRecord(item) || item.type !== "reasoning")
+            return [];
+        const summary = Array.isArray(item.summary)
+            ? item.summary.flatMap((part) => isRecord(part) &&
+                part.type === "summary_text" &&
+                typeof part.text === "string"
+                ? [part.text]
+                : [])
+            : [];
+        if (summary.length > 0)
+            return summary;
+        return Array.isArray(item.content)
+            ? item.content.flatMap((part) => isRecord(part) &&
+                part.type === "reasoning_text" &&
+                typeof part.text === "string"
+                ? [part.text]
+                : [])
+            : [];
+    })
+        .join("");
+}
 function cloneResponseOutput(value) {
     if (!Array.isArray(value))
         throw new Error("Responses output must be an array");
@@ -1094,7 +1504,8 @@ function normalizeChatUsage(value) {
         : {};
     const inputTokens = providerNumber(usage.prompt_tokens);
     const cacheReadTokens = providerNumber(promptDetails.cached_tokens);
-    const cacheWriteTokens = providerNumber(promptDetails.cache_write_tokens);
+    const cacheWriteTokens = providerNumber(promptDetails.cache_write_tokens) ??
+        providerNumber(promptDetails.cached_creation_tokens);
     return usageRecord({
         inputTokens,
         uncachedInputTokens: subtractCachedInput(inputTokens, cacheReadTokens, cacheWriteTokens),
@@ -1107,6 +1518,9 @@ function normalizeChatUsage(value) {
 }
 function normalizeAnthropicUsage(value) {
     const usage = isRecord(value) ? value : {};
+    const outputDetails = isRecord(usage.output_tokens_details)
+        ? usage.output_tokens_details
+        : {};
     const uncachedInputTokens = providerNumber(usage.input_tokens);
     const cacheReadTokens = providerNumber(usage.cache_read_input_tokens);
     const cacheWriteTokens = providerNumber(usage.cache_creation_input_tokens);
@@ -1117,7 +1531,8 @@ function normalizeAnthropicUsage(value) {
         uncachedInputTokens,
         cacheReadTokens,
         cacheWriteTokens,
-        reasoningTokens: null,
+        reasoningTokens: providerNumber(outputDetails.thinking_tokens) ??
+            providerNumber(usage.thinking_tokens),
         outputTokens,
         totalTokens: inputTokens === null || outputTokens === null
             ? null
@@ -1134,7 +1549,8 @@ function normalizeResponsesUsage(value) {
         : {};
     const inputTokens = providerNumber(usage.input_tokens);
     const cacheReadTokens = providerNumber(inputDetails.cached_tokens);
-    const cacheWriteTokens = providerNumber(inputDetails.cache_write_tokens);
+    const cacheWriteTokens = providerNumber(inputDetails.cache_write_tokens) ??
+        providerNumber(inputDetails.cached_creation_tokens);
     return usageRecord({
         inputTokens,
         uncachedInputTokens: subtractCachedInput(inputTokens, cacheReadTokens, cacheWriteTokens),