@openclaw/ai 2026.10.5-beta.4 → 2026.10.10-beta.1

package/dist/internal/tool-schema.d.mts

@@ -1,4 +1,5 @@
-import { a as resolveOpenAIProjectedToolsStrictToolFlag, i as normalizeStrictOpenAIJsonSchema, n as isStrictOpenAIJsonSchemaCompatible, o as findOpenAIStrictSchemaViolations, r as normalizeOpenAIStrictToolParameters, s as normalizeOpenAIStrictCompatSchema, t as findOpenAIStrictToolProjectionDiagnostics } from "../openai-tool-schema-a5ysBBga.mjs";
+import { m as OpenAIToolProjection } from "../provider-options-DeYeaflL.mjs";
+import { a as prepareAnthropicInputSchema } from "../anthropic-tool-projection-DKH-aEWU.mjs";
 import { TSchema } from "typebox";
 //#region packages/ai/src/providers/agent-tools-parameter-schema.d.ts
 /**
@@ -24,6 +25,7 @@ export declare function shouldOmitEmptyArrayItems(modelOrCompat: {
   compat?: unknown;
 } | ToolSchemaModelCompat | undefined): boolean;
 export type ToolParameterSchemaOptions = {
+  toolName?: string;
   modelProvider?: string;
   modelId?: string;
   modelCompat?: ToolSchemaModelCompat;
@@ -33,20 +35,88 @@ export declare function normalizeToolParameterSchema(schema: unknown, options?:
 //#endregion
 //#region packages/ai/src/providers/clean-for-gemini.d.ts
 export declare const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS: Set<string>;
-export declare function cleanSchemaForGemini(schema: unknown): TSchema;
+export declare function cleanSchemaForGemini(schema: unknown, toolName?: string): TSchema;
 //#endregion
 //#region packages/ai/src/providers/clean-for-llamacpp-gbnf.d.ts
 /** llama.cpp rejects grammar repetitions whose expanded rule count reaches 2000. */
 export declare const LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD = 2000;
 /** Removes JSON Schema constraints that llama.cpp cannot compile into GBNF. */
-export declare function cleanSchemaForLlamacppGbnf(schema: unknown): unknown;
+export declare function cleanSchemaForLlamacppGbnf(schema: unknown, toolName?: string): unknown;
 /** Reports schema paths that llama.cpp cannot compile into GBNF. */
 export declare function findLlamacppGbnfSchemaViolations(schema: unknown, path: string): string[];
 //#endregion
+//#region packages/ai/src/providers/openai-tool-schema-compat.d.ts
+/** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
+export declare function normalizeOpenAIStrictCompatSchema(schema: unknown): TSchema;
+/** Finds schema paths that violate OpenAI strict tool-schema requirements. */
+export declare function findOpenAIStrictSchemaViolations(schema: unknown, path: string, options?: {
+  requireObjectRoot?: boolean;
+}): string[];
+//#endregion
+//#region packages/ai/src/providers/openai-tool-schema.d.ts
+type ToolSchemaCompatInput = {
+  unsupportedToolSchemaKeywords?: unknown;
+  omitEmptyArrayItems?: unknown;
+};
+/** Normalizes a tool parameter schema into the OpenAI strict JSON-schema subset. */
+export declare function normalizeStrictOpenAIJsonSchema(schema: unknown, modelCompat?: ToolSchemaCompatInput | null): unknown;
+/** Normalizes tool parameters using strict OpenAI rules only when strict mode is active. */
+export declare function normalizeOpenAIStrictToolParameters<T>(schema: T, strict: boolean, modelCompat?: ToolSchemaCompatInput | null): T;
+/** Returns whether a schema already satisfies OpenAI strict tool-schema constraints. */
+export declare function isStrictOpenAIJsonSchemaCompatible(schema: unknown): boolean;
+type OpenAIStrictToolSchemaDiagnostic = {
+  toolIndex: number;
+  toolName?: string;
+  violations: string[];
+};
+/** Returns strict-schema diagnostics for an already materialized OpenAI tool projection. */
+export declare function findOpenAIStrictToolProjectionDiagnostics(projection: OpenAIToolProjection): OpenAIStrictToolSchemaDiagnostic[];
+/** Resolves strict mode for the projected tools that will be emitted in the request payload. */
+export declare function resolveOpenAIProjectedToolsStrictToolFlag(projection: OpenAIToolProjection, strict: boolean | null | undefined): boolean | undefined;
+//#endregion
+//#region packages/ai/src/providers/openai-function-tool.d.ts
+type OpenAIFunctionDescriptor = {
+  name: string;
+  description: string | undefined;
+  parameters: Record<string, unknown>;
+  strict?: boolean;
+};
+type PreparedOpenAIFunctionTool = {
+  responses: OpenAIFunctionDescriptor & {
+    type: "function";
+  };
+  completions: {
+    type: "function";
+    function: OpenAIFunctionDescriptor;
+  };
+};
+/** Reuse wire descriptors only when their parameter owner published immutable JSON. */
+export declare function prepareOpenAIFunctionTool(name: string, description: string | undefined, parameters: Record<string, unknown>, strict: boolean | undefined): PreparedOpenAIFunctionTool;
+//#endregion
 //#region packages/ai/src/providers/schema-keyword-strip.d.ts
 /** Remove schema keywords unsupported by a target provider/tool surface. */
 export declare function stripUnsupportedSchemaKeywords(schema: unknown, unsupportedKeywords: ReadonlySet<string>): unknown;
 //#endregion
+//#region packages/ai/src/providers/tool-schema-depth.d.ts
+/** Schema nodes and expanded references share this budget; containers are transparent. */
+export declare const MAX_TOOL_SCHEMA_DEPTH = 128;
+export type ToolSchemaPosition = {
+  kind: "schema" | "map" | "array" | "dependencies";
+  depth: number;
+};
+/** Classify children after toJSON when serializing, or directly when normalizing. */
+export declare function toolSchemaChildPosition(position: ToolSchemaPosition | undefined, parent: object, key: string, child: unknown): ToolSchemaPosition | undefined;
+export declare function wasToolSchemaTruncated(schema: unknown): boolean;
+/** Preserve reduced-validation provenance across schema copies without repeating diagnostics. */
+export declare function inheritToolSchemaTruncation<T>(source: unknown, result: T, truncated?: boolean): T;
+export declare function reportToolSchemaTruncation(schema: unknown, toolName?: string): void;
+/** Bound schema structure without changing literal data or caching mutable provider inputs. */
+export declare function truncateToolSchemaDepth(schema: unknown, toolName?: string): unknown;
+//#endregion
+//#region packages/ai/src/providers/schema-walk.d.ts
+export declare const SCHEMA_MAP_KEYS: Set<string>;
+export declare const SCHEMA_NESTED_KEYS: Set<string>;
+//#endregion
 //#region packages/ai/src/providers/tool-schema-json-projection.d.ts
 /** JSON-safe schema value used when projecting runtime tool parameters. */
 type RuntimeToolInputSchemaJson = null | boolean | number | string | RuntimeToolInputSchemaJson[] | {
@@ -57,7 +127,15 @@ type RuntimeToolInputSchemaProjection = {
   readonly schema: RuntimeToolInputSchemaJson;
   readonly violations: readonly string[];
 };
+type PublishedRuntimeToolInputSchema = {
+  readonly projection: RuntimeToolInputSchemaProjection;
+  readonly json: string;
+  readonly fingerprint: string;
+};
+export declare function getPublishedRuntimeToolInputSchema(schema: unknown): PublishedRuntimeToolInputSchema | undefined;
+/** Only an owner's detached JSON publication can bypass later schema traversals. */
+export declare function publishRuntimeToolInputSchema(schema: unknown, path?: string, toolName?: string): RuntimeToolInputSchemaProjection;
 /** Projects one runtime tool input schema to JSON and reports runtime incompatibilities. */
-export declare function projectRuntimeToolInputSchema(schema: unknown, path?: string): RuntimeToolInputSchemaProjection;
+export declare function projectRuntimeToolInputSchema(schema: unknown, path?: string, toolName?: string): RuntimeToolInputSchemaProjection;
 //#endregion
-export { type RuntimeToolInputSchemaJson, type RuntimeToolInputSchemaProjection, findOpenAIStrictSchemaViolations, findOpenAIStrictToolProjectionDiagnostics, isStrictOpenAIJsonSchemaCompatible, normalizeOpenAIStrictCompatSchema, normalizeOpenAIStrictToolParameters, normalizeStrictOpenAIJsonSchema, resolveOpenAIProjectedToolsStrictToolFlag };
+export { type RuntimeToolInputSchemaJson, type RuntimeToolInputSchemaProjection, prepareAnthropicInputSchema };

package/dist/internal/tool-schema.mjs

@@ -1,3 +1,4 @@
-import { n as projectRuntimeToolInputSchema } from "../tool-schema-json-projection-B8sG1I9v.mjs";
-import { _ as GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS, a as resolveOpenAIProjectedToolsStrictToolFlag, c as extractToolSchemaModelCompat, d as shouldOmitEmptyArrayItems, g as findLlamacppGbnfSchemaViolations, h as cleanSchemaForLlamacppGbnf, i as normalizeStrictOpenAIJsonSchema, l as normalizeToolParameterSchema, m as LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD, n as isStrictOpenAIJsonSchemaCompatible, o as findOpenAIStrictSchemaViolations, p as stripUnsupportedSchemaKeywords, r as normalizeOpenAIStrictToolParameters, s as normalizeOpenAIStrictCompatSchema, t as findOpenAIStrictToolProjectionDiagnostics, u as resolveUnsupportedToolSchemaKeywords, v as cleanSchemaForGemini } from "../openai-tool-schema-DDPXsvJP.mjs";
-export { GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD, cleanSchemaForGemini, cleanSchemaForLlamacppGbnf, extractToolSchemaModelCompat, findLlamacppGbnfSchemaViolations, findOpenAIStrictSchemaViolations, findOpenAIStrictToolProjectionDiagnostics, isStrictOpenAIJsonSchemaCompatible, normalizeOpenAIStrictCompatSchema, normalizeOpenAIStrictToolParameters, normalizeStrictOpenAIJsonSchema, normalizeToolParameterSchema, projectRuntimeToolInputSchema, resolveOpenAIProjectedToolsStrictToolFlag, resolveUnsupportedToolSchemaKeywords, shouldOmitEmptyArrayItems, stripUnsupportedSchemaKeywords };
+import { _ as SCHEMA_MAP_KEYS, d as inheritToolSchemaTruncation, f as reportToolSchemaTruncation, h as wasToolSchemaTruncated, i as publishRuntimeToolInputSchema, m as truncateToolSchemaDepth, p as toolSchemaChildPosition, r as projectRuntimeToolInputSchema, t as getPublishedRuntimeToolInputSchema, u as MAX_TOOL_SCHEMA_DEPTH, v as SCHEMA_NESTED_KEYS } from "../tool-schema-json-projection-B0hHDV7N.mjs";
+import { r as prepareAnthropicInputSchema } from "../anthropic-tool-projection-BdAS3rtJ.mjs";
+import { _ as findLlamacppGbnfSchemaViolations, a as resolveOpenAIProjectedToolsStrictToolFlag, b as prepareOpenAIFunctionTool, c as extractToolSchemaModelCompat, d as shouldOmitEmptyArrayItems, g as cleanSchemaForLlamacppGbnf, h as LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD, i as normalizeStrictOpenAIJsonSchema, l as normalizeToolParameterSchema, m as stripUnsupportedSchemaKeywords, n as isStrictOpenAIJsonSchemaCompatible, o as findOpenAIStrictSchemaViolations, r as normalizeOpenAIStrictToolParameters, s as normalizeOpenAIStrictCompatSchema, t as findOpenAIStrictToolProjectionDiagnostics, u as resolveUnsupportedToolSchemaKeywords, v as GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS, y as cleanSchemaForGemini } from "../openai-tool-schema-Buv0GXFb.mjs";
+export { GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD, MAX_TOOL_SCHEMA_DEPTH, SCHEMA_MAP_KEYS, SCHEMA_NESTED_KEYS, cleanSchemaForGemini, cleanSchemaForLlamacppGbnf, extractToolSchemaModelCompat, findLlamacppGbnfSchemaViolations, findOpenAIStrictSchemaViolations, findOpenAIStrictToolProjectionDiagnostics, getPublishedRuntimeToolInputSchema, inheritToolSchemaTruncation, isStrictOpenAIJsonSchemaCompatible, normalizeOpenAIStrictCompatSchema, normalizeOpenAIStrictToolParameters, normalizeStrictOpenAIJsonSchema, normalizeToolParameterSchema, prepareAnthropicInputSchema, prepareOpenAIFunctionTool, projectRuntimeToolInputSchema, publishRuntimeToolInputSchema, reportToolSchemaTruncation, resolveOpenAIProjectedToolsStrictToolFlag, resolveUnsupportedToolSchemaKeywords, shouldOmitEmptyArrayItems, stripUnsupportedSchemaKeywords, toolSchemaChildPosition, truncateToolSchemaDepth, wasToolSchemaTruncated };

package/dist/{mistral-dCDCR5ur.mjs → mistral-CATJrwne.mjs}

@@ -1,16 +1,36 @@
 import { r as appendAssistantThinking, t as AssistantMessageEventStream } from "./event-stream-X2gmsUWv.mjs";
-import { N as isImageWithMediaPayload, O as calculateCost, k as clampThinkingLevel, r as getAiTransportHost } from "./host-Bf3NjYNj.mjs";
-import { A as shortHash, E as createToolArgumentPreviewSchedule, O as parseStreamingJson, P as sanitizeSurrogates, l as finalizeTerminalToolCallArguments, m as notifyProviderHttpResponse, n as assignTransportErrorDetails, u as finalizeTransportStream } from "./transport-stream-shared-CWGOuLcA.mjs";
-import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, d as describeToolResultMediaPlaceholder, h as formatToolResultText, m as extractToolResultText, n as buildBaseOptions, r as clampMaxTokensToModel } from "./simple-options-BAu4B54D.mjs";
-import { n as transformProviderMessages, t as createAssistantOutput } from "./assistant-output-BuhRpLeD.mjs";
+import { N as isImageWithMediaPayload, O as calculateCost, k as clampThinkingLevel, r as getAiTransportHost } from "./host-B2gk-d1H.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-CRGuMONI.mjs";
+import { r as sortPromptCacheToolsByName } from "./prompt-cache-stability-D_MeCQFI.mjs";
+import { f as extractToolResultText, l as describeToolResultMediaPlaceholder, n as buildBaseOptions, p as formatToolResultText, r as clampMaxTokensToModel, w as stripSystemPromptCacheBoundary } from "./simple-options-BYgC6kse.mjs";
+import { A as shortHash, E as createToolArgumentPreviewSchedule, O as parseStreamingJson, l as finalizeTerminalToolCallArguments, m as notifyProviderHttpResponse, n as assignTransportErrorDetails, u as finalizeTransportStream } from "./transport-stream-shared-CzQlAzJH.mjs";
+import { n as transformProviderMessages, t as createAssistantOutput } from "./assistant-output-6iFA1nbC.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-CfMuh5cC.mjs";
 import { t as boundResponseBody } from "./streaming-byte-guard-DBXr1XYn.mjs";
 import { t as mapOpenAIStopReason } from "./openai-stop-reason-8s70vDXj.mjs";
-import { t as requireApiKey } from "./required-api-key-CFJvcFy_.mjs";
+import { t as requireApiKey } from "./required-api-key-D088S4Cd.mjs";
 import { randomUUID } from "node:crypto";
 import { HTTPClient } from "@mistralai/mistralai/lib/http";
 import { ReasoningEffort$inboundSchema } from "@mistralai/mistralai/models/components/reasoningeffort.js";
 import { Chat } from "@mistralai/mistralai/sdk/chat";
+//#region packages/ai/src/providers/mistral-usage.ts
+function readMistralCachedPromptTokens(usage, promptTokens) {
+	const record = usage;
+	const rawCachedTokens = record.promptTokensDetails?.cachedTokens ?? record.prompt_tokens_details?.cached_tokens ?? record.cachedTokens ?? record.cached_tokens;
+	return Math.min(promptTokens, Math.max(0, typeof rawCachedTokens === "number" && Number.isFinite(rawCachedTokens) ? rawCachedTokens : 0));
+}
+function applyMistralUsage(output, usage, model, terminal) {
+	const promptTokens = usage.promptTokens || 0;
+	const cacheRead = readMistralCachedPromptTokens(usage, promptTokens);
+	output.input = Math.max(0, promptTokens - cacheRead);
+	output.output = usage.completionTokens || 0;
+	output.cacheRead = cacheRead;
+	output.cacheWrite = 0;
+	output.totalTokens = usage.totalTokens || output.input + output.output + cacheRead;
+	output.usageReport = { state: terminal ? "available" : "unavailable" };
+	calculateCost(model, output);
+}
+//#endregion
 //#region packages/ai/src/providers/mistral.ts
 const MISTRAL_TOOL_CALL_ID_LENGTH = 9;
 const MISTRAL_STREAM_BODY_MAX_BYTES = 16777216;
@@ -168,11 +188,6 @@ function resolveMistralPromptCacheKey(options) {
 	if (options?.cacheRetention === "none") return;
 	return options?.promptCacheKey?.trim() || options?.sessionId?.trim() || void 0;
 }
-function readMistralCachedPromptTokens(usage, promptTokens) {
-	const record = usage;
-	const rawCachedTokens = record.promptTokensDetails?.cachedTokens ?? record.prompt_tokens_details?.cached_tokens ?? record.cachedTokens ?? record.cached_tokens;
-	return Math.min(promptTokens, Math.max(0, typeof rawCachedTokens === "number" && Number.isFinite(rawCachedTokens) ? rawCachedTokens : 0));
-}
 async function consumeChatStream(model, output, stream, mistralStream, signal) {
 	let currentBlock = null;
 	let terminalFinishReason;
@@ -251,16 +266,7 @@ async function consumeChatStream(model, output, stream, mistralStream, signal) {
 		const chunk = event.data;
 		output.responseId ||= chunk.id;
 		if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== model.id) output.responseModel ||= chunk.model;
-		if (chunk.usage) {
-			const promptTokens = chunk.usage.promptTokens || 0;
-			const cachedPromptTokens = readMistralCachedPromptTokens(chunk.usage, promptTokens);
-			output.usage.input = Math.max(0, promptTokens - cachedPromptTokens);
-			output.usage.output = chunk.usage.completionTokens || 0;
-			output.usage.cacheRead = cachedPromptTokens;
-			output.usage.cacheWrite = 0;
-			output.usage.totalTokens = chunk.usage.totalTokens || output.usage.input + output.usage.output + output.usage.cacheRead;
-			calculateCost(model, output.usage);
-		}
+		if (chunk.usage) applyMistralUsage(output.usage, chunk.usage, model, Boolean(terminalFinishReason || chunk.choices[0]?.finishReason));
 		const choice = chunk.choices[0];
 		if (!choice) continue;
 		if (choice.finishReason) {
@@ -304,7 +310,7 @@ async function consumeChatStream(model, output, stream, mistralStream, signal) {
 					id: providedCallId ?? createMissingToolCallId(contentIndex),
 					name: functionName ?? "",
 					arguments: {},
-					partialArgs: ""
+					partialJson: ""
 				};
 				output.content.push(block);
 				identity = {
@@ -335,8 +341,8 @@ async function consumeChatStream(model, output, stream, mistralStream, signal) {
 			}
 			if (toolCallIndex !== void 0) identity.indexes.add(toolCallIndex);
 			const argsDelta = typeof toolCall.function.arguments === "string" ? toolCall.function.arguments : JSON.stringify(toolCall.function.arguments || {});
-			block.partialArgs = (block.partialArgs || "") + argsDelta;
-			if (identity.preview(block.partialArgs.length)) block.arguments = parseStreamingJson(block.partialArgs);
+			block.partialJson = (block.partialJson || "") + argsDelta;
+			if (identity.preview(block.partialJson.length)) block.arguments = parseStreamingJson(block.partialJson);
 			stream.push({
 				type: "toolcall_delta",
 				contentIndex,
@@ -351,9 +357,9 @@ async function consumeChatStream(model, output, stream, mistralStream, signal) {
 		if (!terminalFinishReason) throw new Error("Mistral stream ended without a terminal finish reason");
 		return;
 	}
-	finalizeTerminalToolCallArguments(toolBlocks.map(({ block }) => block), (block) => block.partialArgs ?? "", "Mistral completed tool call has invalid JSON arguments");
+	finalizeTerminalToolCallArguments(toolBlocks.map(({ block }) => block), (block) => block.partialJson ?? "", "Mistral completed tool call has invalid JSON arguments");
 	for (const { block, contentIndex } of toolBlocks) {
-		delete block.partialArgs;
+		delete block.partialJson;
 		stream.push({
 			type: "toolcall_end",
 			contentIndex,
@@ -375,7 +381,7 @@ function toFunctionTools(tools) {
 					function: {
 						name,
 						description,
-						parameters: stripSymbolKeys(tool.parameters),
+						parameters: structuredClone(tool.parameters),
 						strict: false
 					}
 				}
@@ -386,15 +392,6 @@ function toFunctionTools(tools) {
 	});
 	return sortPromptCacheToolsByName(converted).map(({ value }) => value);
 }
-function stripSymbolKeys(value) {
-	if (Array.isArray(value)) return value.map((item) => stripSymbolKeys(item));
-	if (value && typeof value === "object") {
-		const result = {};
-		for (const [key, entry] of Object.entries(value)) result[key] = stripSymbolKeys(entry);
-		return result;
-	}
-	return value;
-}
 function toChatMessages(messages, supportsImages) {
 	const result = [];
 	for (const msg of messages) {

package/dist/model-request-body-BD5vy4rP.d.mts

@@ -0,0 +1,17 @@
+//#region packages/ai/src/transports/model-request-body.d.ts
+type EncodedModelRequestBody = {
+  body: Uint8Array<ArrayBuffer>;
+  stream: boolean;
+};
+type ModelRequestBodyState = {
+  enabled?: boolean;
+  encode?: (payload: unknown) => Promise<EncodedModelRequestBody>;
+  onEncoded?: (body: Blob, payload: unknown) => void;
+  onBytes?: (bytes: number) => void;
+};
+/** Call-local state survives option spreads; no payload is cached across requests. */
+declare function modelRequestBodyState(options: object, inheritFrom?: object): ModelRequestBodyState;
+declare function serializeModelRequestBody(payload: unknown, onSerializedPayload?: (payload: unknown) => void): EncodedModelRequestBody;
+declare function encodedModelRequestBodyStream(body: unknown): boolean | undefined;
+//#endregion
+export { modelRequestBodyState as n, serializeModelRequestBody as r, encodedModelRequestBodyStream as t };

package/dist/{number-coercion-C3hztWoY.mjs → number-coercion-37gmNkuA.mjs}

@@ -1,4 +1,4 @@
-import { a as normalizeOptionalString } from "./string-coerce-CtgOVOSv.mjs";
+import { o as normalizeOptionalString } from "./string-coerce-Cj8sqWHx.mjs";
 //#region packages/normalization-core/src/number-coercion.ts
 function asFiniteNumber(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : void 0;

package/dist/{openai-chatgpt-responses-BHI3uCcA.mjs → openai-chatgpt-responses-CtdnpWwe.mjs}

@@ -1,24 +1,24 @@
 import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-DzrF1h4J.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-X2gmsUWv.mjs";
 import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
-import { i as clampPositiveTimerTimeoutMs } from "./number-coercion-C3hztWoY.mjs";
-import { E as headersToRecord, a as resolveAiTransportHeaderSentinels, r as getAiTransportHost } from "./host-Bf3NjYNj.mjs";
-import { h as responsesPromptObserver, k as supportsOpenAITemperature } from "./openai-responses-contracts-DlKMMTxK.mjs";
-import { r as registerSessionResourceCleanup } from "./session-resources-D1wgDQ8C.mjs";
-import "./provider-error-CF9GWCs2.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-r93BJhjm.mjs";
-import { s as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, v as extractErrorCodeOrErrno, y as toErrorObject } from "./diagnostics-tQasYct1.mjs";
-import { a as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, d as streamFragmentError, p as consumeResponseBytes } from "./text-signature-Drb4Erb8.mjs";
+import { i as clampPositiveTimerTimeoutMs } from "./number-coercion-37gmNkuA.mjs";
+import { E as headersToRecord, a as resolveAiTransportHeaderSentinels, r as getAiTransportHost } from "./host-B2gk-d1H.mjs";
+import { A as supportsOpenAITemperature, g as responsesPromptObserver } from "./openai-responses-contracts-Bx-16mnf.mjs";
+import { r as registerSessionResourceCleanup } from "./session-resources-vKvGIE3J.mjs";
+import "./provider-error-qtZD2inE.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-DJ_P143P.mjs";
+import { s as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, v as extractErrorCodeOrErrno, y as toErrorObject } from "./diagnostics-Cv7cW3pS.mjs";
+import { f as consumeResponseBytes, i as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, u as streamFragmentError } from "./provider-replay-context-J6CfU3m1.mjs";
 import { parseRetryAfterHeadersSeconds } from "./internal/retry-after.mjs";
-import { c as resolveOpenAIResponsesTextFormat } from "./openai-completions-compat-CYX18uDk.mjs";
-import { n as buildManagedModelFetch } from "./host-policy-BzZluO6_.mjs";
-import { S as withProviderResponseHook, b as transportAbortError, h as notifyProviderStreamOpened, n as assignTransportErrorDetails } from "./transport-stream-shared-CWGOuLcA.mjs";
-import { C as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-BAu4B54D.mjs";
-import { Dt as createResponseModelTracker, E as ResponsesStreamFailure, Et as createOpenAIResponseHook, F as convertProviderResponsesMessages, S as isInvalidEncryptedContentError, T as resolveNextResponsesEncryptedContentAttempt, Tt as createOpenAIProviderAcceptanceHook, _t as resolveOpenAISimpleReasoningEffort, at as suppressOpenAIResponsesCompaction, b as commitResponsesEncryptedContentAttempt, gt as resolveOpenAIRequestReasoning, i as convertResponsesToolPayload, j as recordResponsesContextUsage, n as applyResponsesServiceTierPricing, nt as buildOpenAIResponsesReasoningReplayMetadata, o as readOpenAIMisalignmentReview, s as processResponsesStream } from "./openai-responses-shared-D-aDYAkJ.mjs";
-import { t as createAssistantOutput } from "./assistant-output-BuhRpLeD.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-Dc42hKv6.mjs";
-import { n as withResponsesRequestAcceptance, r as createResponsesPromptEgressObserver, t as responsesRequestLifecycle } from "./openai-responses-request-lifecycle-NSIJo9jY.mjs";
-import { t as requireApiKey } from "./required-api-key-CFJvcFy_.mjs";
+import { c as resolveOpenAIResponsesTextFormat } from "./openai-completions-compat-CFhQ3UVU.mjs";
+import { n as buildManagedModelFetch } from "./host-policy-mpqGhbeM.mjs";
+import { n as buildBaseOptions, w as stripSystemPromptCacheBoundary } from "./simple-options-BYgC6kse.mjs";
+import { S as withProviderResponseHook, b as transportAbortError, h as notifyProviderStreamOpened, n as assignTransportErrorDetails } from "./transport-stream-shared-CzQlAzJH.mjs";
+import { t as createAssistantOutput } from "./assistant-output-6iFA1nbC.mjs";
+import { Dt as createOpenAIResponseHook, E as ResponsesStreamFailure, Et as createOpenAIProviderAcceptanceHook, F as convertProviderResponsesMessages, Ot as createResponseModelTracker, S as isInvalidEncryptedContentError, T as resolveNextResponsesEncryptedContentAttempt, _t as resolveOpenAIRequestReasoning, b as commitResponsesEncryptedContentAttempt, i as convertResponsesToolPayload, j as recordResponsesContextUsage, n as applyResponsesServiceTierPricing, o as readOpenAIMisalignmentReview, ot as suppressOpenAIResponsesCompaction, rt as buildOpenAIResponsesReasoningReplayMetadata, s as processResponsesStream, vt as resolveOpenAISimpleReasoningEffort } from "./openai-responses-shared-Bv_1NtH9.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-D_TfJHRJ.mjs";
+import { a as createResponsesV2CompactionCollector, i as createResponsesPromptEgressObserver, n as responsesRequestLifecycle, o as claimResponsesCompactRequest, r as withResponsesRequestAcceptance, s as copyResponsesCompactRequest, t as independentResponsesRequest } from "./openai-responses-request-lifecycle-CTdAb2v1.mjs";
+import { t as requireApiKey } from "./required-api-key-D088S4Cd.mjs";
 import { n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-KWcgd0d_.mjs";
 //#region packages/ai/src/providers/openai-chatgpt-responses-events.ts
 var CodexApiError = class extends Error {
@@ -160,6 +160,48 @@ function resolveCodexWebSocketUrl(baseUrl) {
 	return url.toString();
 }
 //#endregion
+//#region packages/ai/src/providers/openai-chatgpt-responses-request.ts
+function buildRequestBody(model, context, allowedToolCallProviders, options, replayMode = "checkpoint", retainUserProvenance = false) {
+	const messages = convertProviderResponsesMessages(model, context, allowedToolCallProviders, {
+		includeSystemPrompt: false,
+		replayResponsesItemIds: false,
+		sessionId: options?.sessionId,
+		authProfileId: options?.authProfileId,
+		replayMode,
+		retainUserProvenance
+	});
+	const body = {
+		model: model.id,
+		store: false,
+		stream: true,
+		instructions: stripSystemPromptCacheBoundary(context.systemPrompt ?? "") || "You are a helpful assistant.",
+		input: messages,
+		text: { verbosity: options?.textVerbosity || "low" },
+		include: ["reasoning.encrypted_content"],
+		prompt_cache_key: options?.cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId)
+	};
+	if (options?.responseFormat !== void 0) body.text = {
+		...body.text,
+		format: resolveOpenAIResponsesTextFormat(options.responseFormat)
+	};
+	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) body.temperature = options.temperature;
+	if (options?.serviceTier !== void 0) body.service_tier = options.serviceTier;
+	if (context.tools) {
+		const tools = convertResponsesToolPayload(context.tools, { strict: false });
+		if (tools.length > 0) {
+			body.tools = tools;
+			body.tool_choice = "auto";
+			body.parallel_tool_calls = true;
+		}
+	}
+	const effort = options?.reasoningEffort === void 0 ? void 0 : resolveOpenAIRequestReasoning(model, options.reasoningEffort).effort;
+	if (effort !== void 0) body.reasoning = {
+		effort,
+		...effort === "none" ? {} : { summary: options?.reasoningSummary ?? "auto" }
+	};
+	return body;
+}
+//#endregion
 //#region packages/ai/src/providers/openai-chatgpt-responses-websocket-authority.ts
 const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
 function resolveCodexWebSocketAuthority(params) {
@@ -334,6 +376,8 @@ function compressRequestBodyZstd(bodyJson) {
 }
 const streamOpenAICodexResponses = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
+	const compactRequest = claimResponsesCompactRequest(options);
+	const v2Compaction = compactRequest?.mode === "v2" ? createResponsesV2CompactionCollector(compactRequest.replayBudget) : void 0;
 	(async () => {
 		const startedAt = Date.now();
 		let requestTimeoutMs;
@@ -342,6 +386,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 		let firstEventAbort;
 		const output = createAssistantOutput(model);
 		try {
+			if (compactRequest && (!v2Compaction || responsesRequestLifecycle.get(options))) throw new Error("Native ChatGPT compaction requires an unreviewed V2 request");
 			const unresolvedApiKey = requireApiKey(model.provider, options?.apiKey);
 			const transportHost = getAiTransportHost();
 			const websocketState = getOpenAICodexWebSocketRuntimeState(transportHost);
@@ -350,9 +395,14 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			const optionHeaders = resolveAiTransportHeaderSentinels(options?.headers);
 			const accountId = extractOpenAICodexAccountId(apiKey);
 			const buildBody = async (replayMode) => {
-				let body = buildRequestBody(model, context, options, replayMode);
+				let body = buildRequestBody(model, context, CODEX_TOOL_CALL_PROVIDERS, options, replayMode, Boolean(v2Compaction));
+				const restoreUsers = v2Compaction?.preserveUsers(body.input ?? []);
 				const nextBody = await options?.onPayload?.(body, model);
 				if (nextBody !== void 0) body = nextBody;
+				if (restoreUsers) {
+					body.input = [...restoreUsers(body.input ?? []), { type: "compaction_trigger" }];
+					v2Compaction?.assertReplayFits(body.input, model);
+				}
 				return body;
 			};
 			let semanticAttempt = {
@@ -374,7 +424,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 				...options,
 				signal: activeSignal
 			};
-			const processStream = (events, streamOptions, activitySignal) => processResponsesStream(events, output, stream, model, {
+			const processStream = (events, streamOptions, activitySignal) => processResponsesStream(v2Compaction ? v2Compaction.observe(events) : events, output, stream, model, {
 				serviceTier: streamOptions?.serviceTier,
 				firstEventTimeoutMs: getFirstStreamEventTimeoutMs(streamOptions),
 				abortFirstEventStream: firstEventAbort?.abort,
@@ -390,7 +440,23 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			const completeStream = (terminal, attempt, ErrorType) => {
 				if (activeSignal?.aborted) throw transportAbortError(activeSignal);
 				if (output.stopReason === "aborted" || output.stopReason === "error") throw new ErrorType(output.errorMessage ?? "An unknown error occurred");
-				if (terminal && attempt.kind === "initial") recordResponsesContextUsage(output, model, options, attempt.request, terminal.output, "provider");
+				if (v2Compaction && compactRequest) {
+					const compacted = v2Compaction.finish({
+						terminal: terminal ?? void 0,
+						input: attempt.request.input ?? [],
+						model,
+						options: {
+							signal: options?.signal,
+							sessionId: options?.sessionId,
+							authProfileId: options?.authProfileId
+						}
+					});
+					compactRequest.resolve({
+						...compacted,
+						modelUsage: output.usage
+					});
+				}
+				if (!v2Compaction && terminal && attempt.kind === "initial") recordResponsesContextUsage(output, model, options, attempt.request, terminal.output, "provider");
 				stream.push({
 					type: "done",
 					reason: output.stopReason,
@@ -455,7 +521,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 							phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
 							requestBytes: new TextEncoder().encode(JSON.stringify(activeAttempt.request)).byteLength
 						}));
-						if (transport === "auto" && options?.sessionId) addCodexWebSocketSseFallback(websocketState.sseFallbacks, options.sessionId, websocketAuthority);
+						if (transport === "auto" && options?.sessionId && !independentResponsesRequest.has(options)) addCodexWebSocketSseFallback(websocketState.sseFallbacks, options.sessionId, websocketAuthority);
 						if (websocketStarted || transport !== "auto") throw transportError;
 						break;
 					}
@@ -477,13 +543,15 @@ const streamOpenAICodexResponses = (model, context, options) => {
 				});
 				let attemptResponse;
 				try {
+					const requestFetch = independentResponsesRequest.has(options) ? transportHost.buildModelFetch(model) : buildManagedModelFetch(model, transportHost) ?? fetch;
+					if (!requestFetch) throw new Error("Independent ChatGPT requests require a host model fetch");
 					const lifecycle = responsesRequestLifecycle.get(options);
 					if (lifecycle) {
 						await lifecycle.beforeDispatch(activeSignal);
 						activeSignal?.throwIfAborted();
 						lifecycle.assertCurrent();
 					}
-					attemptResponse = await (buildManagedModelFetch(model, transportHost) ?? fetch)(resolveCodexUrl(model.baseUrl), {
+					attemptResponse = await requestFetch(resolveCodexUrl(model.baseUrl), {
 						method: "POST",
 						headers: sseHeaders,
 						body: sseBody,
@@ -538,7 +606,8 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			await responsesRequestLifecycle.get(options)?.settle().catch(() => void 0);
 			const requestTimedOut = isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0;
 			const normalizedError = requestTimedOut && requestTimeoutMs !== void 0 ? formatRequestTimeoutError(requestTimeoutMs, error) : error;
-			for (const block of output.content) delete block.partialJson;
+			compactRequest?.reject(normalizedError);
+			for (const block of output.content.filter((candidate) => candidate.type === "toolCall")) delete block.partialJson;
 			const providerRefusal = readCodexProviderRefusal(normalizedError);
 			if (providerRefusal) appendAssistantMessageDiagnostic(output, {
 				type: "provider_refusal",
@@ -578,50 +647,13 @@ const streamSimpleOpenAICodexResponses = (model, context, options) => {
 		authProfileId: options?.authProfileId,
 		reasoningEffort: resolveOpenAISimpleReasoningEffort(model, options?.reasoning)
 	};
+	copyResponsesCompactRequest(options, resolvedOptions);
 	responsesPromptObserver.copy(options, resolvedOptions);
+	if (independentResponsesRequest.has(options)) independentResponsesRequest.set(resolvedOptions);
 	const lifecycle = responsesRequestLifecycle.get(options);
 	if (lifecycle) responsesRequestLifecycle.set(resolvedOptions, lifecycle);
 	return streamOpenAICodexResponses(model, context, resolvedOptions);
 };
-function buildRequestBody(model, context, options, replayMode = "checkpoint") {
-	const messages = convertProviderResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
-		includeSystemPrompt: false,
-		replayResponsesItemIds: false,
-		sessionId: options?.sessionId,
-		authProfileId: options?.authProfileId,
-		replayMode
-	});
-	const body = {
-		model: model.id,
-		store: false,
-		stream: true,
-		instructions: stripSystemPromptCacheBoundary(context.systemPrompt ?? "") || "You are a helpful assistant.",
-		input: messages,
-		text: { verbosity: options?.textVerbosity || "low" },
-		include: ["reasoning.encrypted_content"],
-		prompt_cache_key: options?.cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId)
-	};
-	if (options?.responseFormat !== void 0) body.text = {
-		...body.text,
-		format: resolveOpenAIResponsesTextFormat(options.responseFormat)
-	};
-	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) body.temperature = options.temperature;
-	if (options?.serviceTier !== void 0) body.service_tier = options.serviceTier;
-	if (context.tools) {
-		const tools = convertResponsesToolPayload(context.tools, { strict: false });
-		if (tools.length > 0) {
-			body.tools = tools;
-			body.tool_choice = "auto";
-			body.parallel_tool_calls = true;
-		}
-	}
-	const effort = options?.reasoningEffort === void 0 ? void 0 : resolveOpenAIRequestReasoning(model, options.reasoningEffort).effort;
-	if (effort !== void 0) body.reasoning = {
-		effort,
-		...effort === "none" ? {} : { summary: options?.reasoningSummary ?? "auto" }
-	};
-	return body;
-}
 function resolveCodexServiceTier(responseServiceTier, requestServiceTier) {
 	if (responseServiceTier === "default" && (requestServiceTier === "flex" || requestServiceTier === "priority")) return requestServiceTier;
 	return responseServiceTier ?? requestServiceTier;
@@ -907,7 +939,7 @@ function buildCachedWebSocketRequestBody(entry, body) {
 	};
 }
 async function processWebSocketStream(state, authority, body, output, stream, model, onFirstProviderEvent, onStart, options, processStream, observePromptEgress, payloadVariant = "initial", onRequestSent, activitySignal) {
-	const { socket, entry, release } = await acquireWebSocket(state, authority, options?.sessionId, options?.signal);
+	const { socket, entry, release } = await acquireWebSocket(state, authority, independentResponsesRequest.has(options) ? void 0 : options?.sessionId, options?.signal);
 	let keepConnection = true;
 	const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
 	const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, body) : body;

package/dist/{openai-completions-CrVgnFrV.mjs → openai-completions-B6sET3oI.mjs}

@@ -1,8 +1,8 @@
-import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
-import { k as clampThinkingLevel } from "./host-Bf3NjYNj.mjs";
-import { n as buildBaseOptions } from "./simple-options-BAu4B54D.mjs";
-import { c as convertMessages, n as streamOpenAICompletionsRequest } from "./openai-completions-transport-Dy4CZo9Q.mjs";
-import { t as requireApiKey } from "./required-api-key-CFJvcFy_.mjs";
+import { n as __exportAll } from "./reasoning-tag-text-partitioner-DzlRubwU.mjs";
+import { k as clampThinkingLevel } from "./host-B2gk-d1H.mjs";
+import { n as buildBaseOptions } from "./simple-options-BYgC6kse.mjs";
+import { n as streamOpenAICompletionsRequest, s as convertMessages } from "./openai-completions-transport-DviPEqw3.mjs";
+import { t as requireApiKey } from "./required-api-key-D088S4Cd.mjs";
 //#region packages/ai/src/providers/openai-completions.ts
 var openai_completions_exports = /* @__PURE__ */ __exportAll({
 	convertMessages: () => convertMessages,
@@ -15,12 +15,14 @@ const streamSimpleOpenAICompletions = (model, context, options) => {
 	const base = buildBaseOptions(model, options, apiKey);
 	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
 	const completionsOptions = options;
-	return streamOpenAICompletions(model, context, {
+	const providerOptions = {
 		...base,
 		reasoningEffort: clampedReasoning,
 		toolChoice: completionsOptions?.toolChoice,
-		streaming: completionsOptions?.streaming
-	});
+		streaming: completionsOptions?.streaming,
+		openclawThinkingExplicit: completionsOptions?.openclawThinkingExplicit ?? options?.reasoning !== void 0
+	};
+	return streamOpenAICompletions(model, context, providerOptions);
 };
 //#endregion
 export { streamOpenAICompletions as n, streamSimpleOpenAICompletions as r, openai_completions_exports as t };

package/dist/{openai-completions-compat-i-nLZxFy.d.mts → openai-completions-compat-1gsjP-KO.d.mts}

@@ -1,6 +1,6 @@
-import "./index-BYDvopUB.mjs";
-import { N as OpenAICompletionsCompat, k as Model } from "./types-Bd2T86VJ.mjs";
-import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-CTDz7LXD.mjs";
+import "./index-DSprYWaz.mjs";
+import { N as OpenAICompletionsCompat, k as Model } from "./types-CVYzKrMl.mjs";
+import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-jJOffdlW.mjs";
 //#region packages/ai/src/transports/openai-completions-compat.d.ts
 type OpenAICompletionsSessionAffinity = "none" | "openai" | "openrouter";
 type OpenAICompletionsCompatDefaults = {
@@ -12,6 +12,7 @@ type OpenAICompletionsCompatDefaults = {
   thinkingFormat: "openai" | "openrouter" | "deepseek" | "together" | "zai";
   visibleReasoningDetailTypes: string[];
   supportsStrictMode: boolean;
+  requiresTypedUnionBranches: boolean;
   supportsJsonSchemaResponseFormat: boolean;
   requiresReasoningContentOnAssistantMessages: boolean;
   requiresNonEmptyUserOrAssistantMessage: boolean;
@@ -25,8 +26,10 @@ type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "
   sessionAffinity: OpenAICompletionsSessionAffinity;
   visibleReasoningDetailTypes: string[];
   requiresNonEmptyUserOrAssistantMessage: boolean;
+  requiresTypedUnionBranches: boolean;
   configuredSupportsLongCacheRetention?: boolean;
   reasoningEffortForOff: "none" | null;
+  thinkingOffControlUndeclared: boolean;
 };
 /** Native OpenAI defaults never apply to a configured proxy endpoint. */
 declare function isNativeOpenAIEndpoint(model: {