@openclaw/ai 2026.9.3 → 2026.9.5

package/dist/{openai-completions-stream-BQk3SkLD.mjs → openai-completions-stream-Bu98b0Hv.mjs}

@@ -1,28 +1,27 @@
 import { r as appendAssistantThinking } from "./event-stream-D8PARQfL.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-Bb-v9meu.mjs";
-import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload } from "./host-CWuF-sS3.mjs";
 import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { n as isOpenAIGpt55Model, r as isOpenAIGpt56Model, t as isOpenAIGpt54MiniModel } from "./openai-reasoning-effort-NlFZmfEu.mjs";
+import { r as uniqueStrings } from "./string-normalization-J9ZiLfGO.mjs";
+import { _ as isImageWithMediaPayload, d as describeToolResultMediaPlaceholder, m as extractToolResultText, v as sanitizeSurrogates } from "./host-B4MeUNBc.mjs";
 import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
-import { d as shouldOmitOllamaCompatResponseFormat, i as detectOpenAICompletionsCompat, r as resolveOpenAIPromptCacheParams, u as resolveOpenAICompletionsResponseFormat } from "./openai-prompt-cache-BI0rkM-5.mjs";
-import { r as emitModelTransportDebug } from "./diagnostics-dV98PqIy.mjs";
-import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-BQBi4B9d.mjs";
-import { i as asNonNegativeFiniteNumber } from "./base64-D-su8YVo.mjs";
-import { l as supportsModelTools, r as estimateStringChars } from "./transport-utils-CCooe-cr.mjs";
-import { n as uniqueStrings } from "./string-normalization-CmLIasuf.mjs";
-import { i as resolveProviderEndpoint, r as resolveOpenAIStrictToolSetting } from "./host-policy-CAopLRKA.mjs";
+import { r as resolveOpenAIPromptCacheParams } from "./openai-prompt-cache-1wfaIszn.mjs";
+import { r as emitModelTransportDebug } from "./diagnostics-Dm4bisWG.mjs";
+import { i as asNonNegativeFiniteNumber } from "./base64-BQOzsvUH.mjs";
+import { c as supportsModelTools, r as estimateStringChars } from "./transport-utils-1cyq5Y7x.mjs";
+import { c as shouldOmitOllamaCompatResponseFormat, n as isNativeOpenAIEndpoint, s as resolveOpenAICompletionsResponseFormat, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-CkwdxTZx.mjs";
+import { i as resolveProviderEndpoint, r as resolveOpenAIStrictToolSetting } from "./host-policy-DUnXSx0I.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName, u as splitSystemPromptCacheBoundary } from "./simple-options-tcKOqnpF.mjs";
-import { C as readOpenAICompletionsContentDeltas, D as throwIfModelStreamAborted, E as resolvePromptCacheKey, S as parseOpenAICompletionsUsage, b as log, d as resolveOpenAIReasoningEffortMap, f as projectOpenAITools, g as createModelStreamCooperativeScheduler, h as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, p as reconcileOpenAICompletionsToolChoice, s as getCompat, u as resolveOpenAIStrictToolFlagWithDiagnostics, w as readOpenAICompletionsReasoningBatch, x as measureUtf8AppendBytes, y as isOpenAICompletionsThinkingEnabled } from "./openai-transport-params-DNasp2fU.mjs";
-import { s as finalizeTerminalToolCallArguments } from "./transport-stream-shared-Cu3ZPhNW.mjs";
+import { f as splitSystemPromptCacheBoundary, h as stripSystemPromptRelocatableBoundary, m as stripSystemPromptCacheBoundary, p as splitSystemPromptRelocatableBoundary, v as sortPromptCacheToolsByName } from "./simple-options-C6cFWj_f.mjs";
+import { A as resolvePromptCacheKey, C as isOpenAICompletionsThinkingEnabled, D as readOpenAICompletionsContentDeltas, E as parseOpenAICompletionsUsage, O as readOpenAICompletionsReasoningBatch, T as measureUtf8AppendBytes, d as prepareOpenAITools, f as projectOpenAITools, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, j as throwIfModelStreamAborted, p as reconcileOpenAICompletionsToolChoice, s as getCompat, u as resolveOpenAIStrictToolFlagWithDiagnostics, v as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, w as log, y as createModelStreamCooperativeScheduler } from "./openai-transport-params-DQeuAvBl.mjs";
+import { E as parseStreamingJson, c as finalizeTerminalToolCallArguments, w as createToolArgumentPreviewSchedule } from "./transport-stream-shared-D-6FQSHm.mjs";
 import { a as tagUnresolvedTextAsCommentary, i as tagPendingCommentaryText, n as rememberPendingCommentaryTags, r as tagInterruptedTextPhases, t as clearPendingCommentaryText } from "./assistant-text-phase-C20rxWwP.mjs";
-import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-Dw_hnxsA.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { a as withFirstStreamEventTimeout } from "./stream-first-event-timeout-2hfrquuz.mjs";
-import { t as transformProviderMessages } from "./provider-transcript-transform-pPmUIwKt.mjs";
-import { n as isOpenAIGpt55Model, o as resolveOpenAIReasoningEffortForModel, r as isOpenAIGpt56Model, t as isOpenAIGpt54MiniModel } from "./openai-reasoning-effort-BK7FbcLT.mjs";
-import { r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-CzjyYXun.mjs";
+import { a as withFirstStreamEventTimeout } from "./stream-first-event-timeout-C9ZadkJW.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform-BsRAhuWJ.mjs";
+import { f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-BO8rwyAD.mjs";
 import { isGoogleGemini3FlashModel, isGoogleGemini3ProModel } from "./internal/google-model-family.mjs";
 import { t as mapOpenAIStopReason } from "./openai-stop-reason-Drnn_6Qj.mjs";
+import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-Dy9IO8Dc.mjs";
 import { randomUUID } from "node:crypto";
 //#region packages/ai/src/transports/deepseek-dsml-grammar.ts
 const DEEPSEEK_DSML_MARKERS = [
@@ -458,9 +457,18 @@ function convertMessages(model, context, compat, options = {}) {
 		return id;
 	};
 	const transformedMessages = transformProviderMessages(context.messages, model, (id) => normalizeToolCallId(id));
+	let relocatableSplit;
+	let systemParamIndex;
 	if (context.systemPrompt) {
 		const role = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
-		const systemPrompt = options.preserveSystemPromptCacheBoundary ? context.systemPrompt : stripSystemPromptCacheBoundary(context.systemPrompt);
+		let systemPrompt;
+		if (options.preserveSystemPromptCacheBoundary) systemPrompt = stripSystemPromptRelocatableBoundary(context.systemPrompt);
+		else {
+			const split = splitSystemPromptRelocatableBoundary(context.systemPrompt);
+			if (split && split.relocatable.length > 0) relocatableSplit = split;
+			systemPrompt = stripSystemPromptCacheBoundary(context.systemPrompt);
+		}
+		systemParamIndex = params.length;
 		params.push({
 			role,
 			content: sanitizeSurrogates(systemPrompt)
@@ -605,16 +613,37 @@ function convertMessages(model, context, compat, options = {}) {
 		}
 		lastRole = msg.role;
 	}
+	if (relocatableSplit !== void 0 && systemParamIndex !== void 0) relocateNonBehavioralRegion({
+		params,
+		systemParamIndex,
+		split: relocatableSplit,
+		cacheOptOutIndexes: options.cacheOptOutIndexes
+	});
 	return params;
 }
+/** Commit relocation only after finding an emitted carrier. */
+function relocateNonBehavioralRegion(args) {
+	const text = sanitizeSurrogates(stripSystemPromptCacheBoundary(args.split.relocatable));
+	for (let index = args.systemParamIndex + 1; index < args.params.length; index++) {
+		const param = args.params[index];
+		if (!param || param.role !== "user") continue;
+		if (typeof param.content === "string") param.content = `${param.content}\n\n${text}`;
+		else if (Array.isArray(param.content)) param.content = [...param.content, {
+			type: "text",
+			text
+		}];
+		else continue;
+		const systemParam = args.params[args.systemParamIndex];
+		if (systemParam) systemParam.content = sanitizeSurrogates(stripSystemPromptCacheBoundary(args.split.remainingPrompt));
+		args.cacheOptOutIndexes?.add(index);
+		return;
+	}
+}
 //#endregion
 //#region packages/ai/src/transports/openai-completions-direct-policy.ts
-function applyDirectCompletionsReasoningAndRouting(params, model, options, compat) {
-	const reasoningEffortMap = resolveOpenAIReasoningEffortMap(model);
-	const thinkingLevelMap = model.thinkingLevelMap;
-	const offReasoningEffort = reasoningEffortMap.off ?? model.thinkingLevelMap?.off;
-	const reasoningEffort = options?.reasoningEffort === void 0 ? offReasoningEffort ?? void 0 : reasoningEffortMap[options.reasoningEffort] ?? thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
-	const reasoningEnabled = reasoningEffort !== void 0 && reasoningEffort !== "none";
+function applyDirectCompletionsReasoningAndRouting(params, model, reasoning, compat) {
+	const nativeEffort = compat.thinkingFormat === "openrouter" ? void 0 : reasoning.effort;
+	const reasoningEnabled = reasoning.thinkingEnabled ?? false;
 	if (compat.thinkingFormat === "zai" && model.reasoning) params.thinking = reasoningEnabled ? {
 		type: "enabled",
 		clear_thinking: false
@@ -626,17 +655,11 @@ function applyDirectCompletionsReasoningAndRouting(params, model, options, compa
 	};
 	else if (compat.thinkingFormat === "deepseek" && model.reasoning) {
 		params.thinking = { type: reasoningEnabled ? "enabled" : "disabled" };
-		if (reasoningEnabled && compat.supportsReasoningEffort) params.reasoning_effort = reasoningEffort;
-	} else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
-		if (reasoningEnabled) params.reasoning = { effort: reasoningEffort };
-		else if (offReasoningEffort !== null) params.reasoning = { effort: offReasoningEffort ?? "none" };
+		if (reasoningEnabled && compat.supportsReasoningEffort && nativeEffort !== void 0) params.reasoning_effort = nativeEffort;
 	} else if (compat.thinkingFormat === "together" && model.reasoning) {
 		params.reasoning = { enabled: reasoningEnabled };
-		if (reasoningEnabled && compat.supportsReasoningEffort) params.reasoning_effort = reasoningEffort;
-	} else if (reasoningEnabled && model.reasoning && compat.supportsReasoningEffort) params.reasoning_effort = reasoningEffort;
-	else if (model.reasoning && compat.supportsReasoningEffort) {
-		if (typeof offReasoningEffort === "string") params.reasoning_effort = offReasoningEffort;
-	}
+		if (reasoningEnabled && compat.supportsReasoningEffort && nativeEffort !== void 0) params.reasoning_effort = nativeEffort;
+	} else if (model.reasoning && compat.supportsReasoningEffort && nativeEffort !== void 0) params.reasoning_effort = nativeEffort;
 	if (compat.openRouterRouting) params.provider = compat.openRouterRouting;
 	if (model.baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
 		const routing = model.compat.vercelGatewayRouting;
@@ -807,7 +830,7 @@ function applyCompletionsReplay(outgoingMessages, context, model, compat) {
 //#endregion
 //#region packages/ai/src/transports/openai-completions-params.ts
 function isKnownOpenAICompletionsEndpoint(model) {
-	if (!model.baseUrl.trim()) return true;
+	if (!model.baseUrl.trim() || isNativeOpenAIEndpoint(model)) return true;
 	const endpointClass = resolveProviderEndpoint(model).endpointClass;
 	if (endpointClass === "openai-public" || endpointClass === "azure-openai") return true;
 	try {
@@ -816,9 +839,6 @@ function isKnownOpenAICompletionsEndpoint(model) {
 		return false;
 	}
 }
-function resolveOpenAICompletionsReasoningEffort(options) {
-	return options?.reasoningEffort ?? options?.reasoning ?? "high";
-}
 function resolveOpenAICompletionsMaxTokens(model, options) {
 	if (options?.maxTokens) return {
 		maxTokens: options.maxTokens,
@@ -839,6 +859,7 @@ function resolveOpenAICompletionsModelMaxTokens(model) {
 }
 const OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN = 1.25;
 const OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE = 8e3;
+const MIN_USEFUL_OUTPUT_TOKENS = 16;
 function estimateOpenAICompletionsInputTokens(payload) {
 	let adjustedChars = 0;
 	adjustedChars += estimateOpenAICompletionsMessagesChars(payload.messages);
@@ -899,9 +920,6 @@ function resolveOpenAICompletionsEffectiveContextTokens(model) {
 	if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0) return contextTokens;
 	return typeof model.contextWindow === "number" && Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : void 0;
 }
-function isQwenOpenAICompletionsThinkingFormat(format) {
-	return format === "qwen" || format === "qwen-chat-template";
-}
 function setQwenChatTemplateThinking(params, enabled) {
 	const existing = params.chat_template_kwargs;
 	params.chat_template_kwargs = existing && typeof existing === "object" && !Array.isArray(existing) ? {
@@ -909,41 +927,51 @@ function setQwenChatTemplateThinking(params, enabled) {
 		enable_thinking: enabled
 	} : { enable_thinking: enabled };
 }
-function applyQwenOpenAICompletionsThinkingParams(params) {
-	if (!params.modelReasoning || !isQwenOpenAICompletionsThinkingFormat(params.compatThinkingFormat)) return false;
-	const enabled = isOpenAICompletionsThinkingEnabled(params.requestedEffort);
-	if (params.compatThinkingFormat === "qwen-chat-template") setQwenChatTemplateThinking(params.payload, enabled);
-	else params.payload.enable_thinking = enabled;
-	return true;
-}
-function applyTogetherOpenAICompletionsThinkingParams(params) {
-	if (!params.modelReasoning || params.compatThinkingFormat !== "together") return;
-	params.payload.reasoning = { enabled: isOpenAICompletionsThinkingEnabled(params.requestedEffort) };
+/** Return whether the binary control replaces scalar reasoning effort. */
+function applyBinaryCompletionsThinkingParams(params) {
+	if (!params.modelReasoning) return false;
+	const enabled = params.thinkingEnabled;
+	switch (params.compatThinkingFormat) {
+		case "qwen-chat-template":
+			setQwenChatTemplateThinking(params.payload, enabled);
+			return true;
+		case "qwen":
+			params.payload.enable_thinking = enabled;
+			return true;
+		case "together":
+			params.payload.reasoning = { enabled };
+			return !enabled;
+		default: return false;
+	}
 }
 function convertTools(tools, compat, model, mode) {
-	const projection = projectOpenAITools(tools);
-	const strict = mode === "direct" ? compat.supportsStrictMode ? false : void 0 : resolveOpenAIStrictToolFlagWithDiagnostics(projection, resolveOpenAIStrictToolSetting(model, {
-		transport: "stream",
-		supportsStrictMode: compat?.supportsStrictMode
-	}), {
-		transport: "completions",
-		model
-	});
-	return {
-		projection,
-		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
-			const functionTool = {
-				name: tool.name,
-				description: tool.description,
-				parameters: mode === "direct" ? tool.parameters : normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
-			};
-			if (strict !== void 0) functionTool.strict = strict;
-			return {
-				type: "function",
-				function: functionTool
-			};
-		})
+	const prepared = mode === "managed" ? prepareOpenAITools(tools) : void 0;
+	const projection = prepared?.projection ?? projectOpenAITools(tools);
+	const convert = () => {
+		const strict = mode === "direct" ? compat.supportsStrictMode ? false : void 0 : resolveOpenAIStrictToolFlagWithDiagnostics(projection, resolveOpenAIStrictToolSetting(model, {
+			transport: "stream",
+			supportsStrictMode: compat?.supportsStrictMode
+		}), {
+			transport: "completions",
+			model
+		});
+		return {
+			projection,
+			tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
+				const functionTool = {
+					name: tool.name,
+					description: tool.description,
+					parameters: mode === "direct" ? tool.parameters : normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
+				};
+				if (strict !== void 0) functionTool.strict = strict;
+				return {
+					type: "function",
+					function: functionTool
+				};
+			})
+		};
 	};
+	return prepared ? withPreparedToolSchemaNormalization(prepared.schemas, convert) : convert();
 }
 function buildOpenAICompletionsParams(model, context, options) {
 	return buildOpenAICompletionsRequest(model, context, options, { mode: "managed" });
@@ -1040,6 +1068,7 @@ function buildOpenAICompletionsRequest(model, context, options, policy) {
 			if (clampedMaxTokens > remainingBudget) {
 				clampedMaxTokens = remainingBudget;
 				emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} effectiveContext=${effectiveContextTokens} estimatedInput=${estimatedInputTokens}`);
+				if (remainingBudget < MIN_USEFUL_OUTPUT_TOKENS) log.warn(`[completions] insufficient_output_budget provider=${model.provider} api=${model.api} model=${model.id} output=${clampedMaxTokens} effectiveContext=${effectiveContextTokens} estimatedInput=${estimatedInputTokens}`);
 			}
 		}
 		if (policy.mode === "direct" ? options?.maxTokens : clampedMaxTokens) {
@@ -1047,34 +1076,34 @@ function buildOpenAICompletionsRequest(model, context, options, policy) {
 			else params.max_completion_tokens = clampedMaxTokens;
 		}
 	}
-	if (policy.mode === "direct") {
-		applyDirectCompletionsReasoningAndRouting(params, model, options, compat);
-		return params;
+	const isOpenRouter = compat.thinkingFormat === "openrouter";
+	const usesBinaryOpenRouterThinking = isOpenRouter && (model.compat?.supportsReasoningEffort === false || model.compat?.supportedReasoningEfforts?.length === 0);
+	const simpleReasoning = options?.reasoning;
+	const requestedEffort = policy.mode === "direct" ? options?.reasoningEffort : options?.reasoningEffort ?? (simpleReasoning === "none" ? "none" : resolveOpenAISimpleReasoningEffort({
+		...model,
+		compat: model.compat ?? void 0
+	}, simpleReasoning)) ?? (usesBinaryOpenRouterThinking ? void 0 : "high");
+	const reasoning = resolveOpenAIRequestReasoning(model, requestedEffort);
+	const { effort, thinkingEnabled } = reasoning;
+	if (isOpenRouter && model.reasoning) {
+		if (usesBinaryOpenRouterThinking && thinkingEnabled !== void 0) params.reasoning = { enabled: thinkingEnabled };
+		else if (effort !== void 0) params.reasoning = { effort };
+	}
+	if (policy.mode === "direct") applyDirectCompletionsReasoningAndRouting(params, model, reasoning, compat);
+	else {
+		const suppressScalarEffort = applyBinaryCompletionsThinkingParams({
+			compatThinkingFormat: compat.thinkingFormat,
+			modelReasoning: model.reasoning,
+			payload: params,
+			thinkingEnabled: thinkingEnabled ?? false
+		});
+		if (!isOpenRouter && effort && model.reasoning && compat.supportsReasoningEffort && !suppressScalarEffort) params.reasoning_effort = effort;
+		if (compat.cacheControlFormat === "anthropic") applyCompletionsAnthropicCacheControl(params, cacheControl ?? null, cacheOptOutIndexes, markTools, !managedCompat?.requiresStringContent);
+	}
+	if (params.tools?.length && isKnownOpenAICompletionsEndpoint(model)) {
+		if (isOpenAIGpt56Model(model)) params.reasoning_effort = "none";
+		else if (isOpenAIGpt54MiniModel(model) || isOpenAIGpt55Model(model)) delete params.reasoning_effort;
 	}
-	const completionsReasoningEffort = resolveOpenAICompletionsReasoningEffort(options);
-	const resolvedCompletionsReasoningEffort = completionsReasoningEffort ? resolveOpenAIReasoningEffortForModel({
-		model,
-		effort: completionsReasoningEffort,
-		fallbackMap: managedCompat?.reasoningEffortMap
-	}) : void 0;
-	const omitChatCompletionsToolReasoningEffort = Array.isArray(params.tools) && params.tools.length > 0 && (isOpenAIGpt54MiniModel(model) || isOpenAIGpt55Model(model) && isKnownOpenAICompletionsEndpoint(model));
-	const disableChatCompletionsToolReasoning = Array.isArray(params.tools) && params.tools.length > 0 && isOpenAIGpt56Model(model) && isKnownOpenAICompletionsEndpoint(model);
-	const handledQwenThinkingFormat = applyQwenOpenAICompletionsThinkingParams({
-		compatThinkingFormat: compat.thinkingFormat,
-		modelReasoning: model.reasoning,
-		payload: params,
-		requestedEffort: completionsReasoningEffort
-	});
-	applyTogetherOpenAICompletionsThinkingParams({
-		compatThinkingFormat: compat.thinkingFormat,
-		modelReasoning: model.reasoning,
-		payload: params,
-		requestedEffort: completionsReasoningEffort
-	});
-	if (disableChatCompletionsToolReasoning) params.reasoning_effort = "none";
-	else if (compat.thinkingFormat === "openrouter" && model.reasoning && resolvedCompletionsReasoningEffort) params.reasoning = { effort: resolvedCompletionsReasoningEffort };
-	else if (resolvedCompletionsReasoningEffort && model.reasoning && compat.supportsReasoningEffort && !handledQwenThinkingFormat && !omitChatCompletionsToolReasoningEffort) params.reasoning_effort = resolvedCompletionsReasoningEffort;
-	if (compat.cacheControlFormat === "anthropic") applyCompletionsAnthropicCacheControl(params, cacheControl ?? null, cacheOptOutIndexes, markTools, !managedCompat?.requiresStringContent);
 	return params;
 }
 //#endregion

package/dist/openai-prompt-cache-1wfaIszn.mjs

@@ -0,0 +1,46 @@
+import { n as isNativeOpenAIEndpoint } from "./openai-completions-compat-CkwdxTZx.mjs";
+//#region packages/normalization-core/src/code-points.ts
+/** Truncates to a nonnegative code-point budget; grapheme clusters may be split. */
+function truncateCodePoints(text, maxCodePoints) {
+	const limit = Math.max(0, Math.trunc(maxCodePoints) || 0);
+	if (text.length <= limit) return text;
+	const prefix = [];
+	for (const codePoint of text) {
+		if (prefix.length >= limit) break;
+		prefix.push(codePoint);
+	}
+	return prefix.join("");
+}
+//#endregion
+//#region packages/ai/src/providers/openai-prompt-cache.ts
+const EXTENDED_RETENTION_MODELS = /* @__PURE__ */ new Set([
+	"gpt-5.5",
+	"gpt-5.5-pro",
+	"gpt-5.4",
+	"gpt-5.2",
+	"gpt-5.1-codex-max",
+	"gpt-5.1",
+	"gpt-5.1-codex",
+	"gpt-5.1-codex-mini",
+	"gpt-5.1-chat-latest",
+	"gpt-5",
+	"gpt-5-codex",
+	"gpt-4.1"
+]);
+/** Selects documented lifetime fields shared by Responses and Chat Completions. */
+function resolveOpenAIPromptCacheParams(model, cacheRetention, compat) {
+	if (cacheRetention !== "long" || !compat.supportsPromptCacheKey || !compat.supportsLongCacheRetention) return {};
+	const version = /^gpt-(\d+)(?:\.(\d+))?(?:-|$)/.exec(model.id);
+	if (version && (Number(version[1]) > 5 || Number(version[1]) === 5 && Number(version[2]) >= 6)) return { prompt_cache_options: { ttl: "30m" } };
+	const modelId = model.id.replace(/-\d{4}-\d{2}-\d{2}$/, "");
+	return !isNativeOpenAIEndpoint(model) || EXTENDED_RETENTION_MODELS.has(modelId) ? { prompt_cache_retention: "24h" } : {};
+}
+/** Maximum prompt cache key length accepted by OpenAI-compatible request metadata. */
+const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+/** Truncates a prompt cache key by Unicode code point count. */
+function clampOpenAIPromptCacheKey(key) {
+	if (key === void 0) return;
+	return truncateCodePoints(key, 64);
+}
+//#endregion
+export { clampOpenAIPromptCacheKey as n, resolveOpenAIPromptCacheParams as r, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH as t };

package/dist/{openai-prompt-cache-rrutvqxq.d.mts → openai-prompt-cache-CJ_xEevu.d.mts}

@@ -1,5 +1,5 @@
-import { D as Model, j as OpenAICompletionsCompat, l as CacheRetention } from "./types-Dy1q0CSu.mjs";
-import "./types-BADKjDBI.mjs";
+import { M as OpenAICompletionsCompat, O as Model, l as CacheRetention } from "./types-4_uVs5WH.mjs";
+import "./types-DkJfb4W3.mjs";
 //#region packages/ai/src/providers/openai-prompt-cache.d.ts
 /** Selects documented lifetime fields shared by Responses and Chat Completions. */
 declare function resolveOpenAIPromptCacheParams(model: Pick<Model, "id" | "provider" | "baseUrl">, cacheRetention: CacheRetention, compat: Required<Pick<OpenAICompletionsCompat, "supportsPromptCacheKey" | "supportsLongCacheRetention">>): {

package/dist/{openai-provider-client-ha_WxTyj.mjs → openai-provider-client-DPo0Hmak.mjs}

@@ -1,5 +1,5 @@
-import { n as getAiTransportHost } from "./host-CWuF-sS3.mjs";
-import { T as resolveOpenAIClientBaseUrl } from "./openai-transport-params-DNasp2fU.mjs";
+import { n as getAiTransportHost } from "./host-B4MeUNBc.mjs";
+import { k as resolveOpenAIClientBaseUrl } from "./openai-transport-params-DQeuAvBl.mjs";
 import { i as resolveCloudflareBaseUrl, r as isCloudflareProvider } from "./github-copilot-headers-B37TB3rB.mjs";
 import OpenAI from "openai";
 //#region packages/ai/src/providers/openai-provider-client.ts

package/dist/{openai-reasoning-effort-BK7FbcLT.mjs → openai-reasoning-effort-NlFZmfEu.mjs}

@@ -1,11 +1,80 @@
 import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
-import { n as uniqueStrings, t as normalizeStringEntries } from "./string-normalization-CmLIasuf.mjs";
+import { i as asOptionalRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { n as normalizeUniqueTrimmedStringList } from "./string-normalization-J9ZiLfGO.mjs";
+//#region packages/llm-core/src/model-data.ts
+const MODEL_DATA_APIS = [
+	"openai-completions",
+	"openai-responses",
+	"openai-chatgpt-responses",
+	"anthropic-messages",
+	"google-generative-ai",
+	"google-vertex",
+	"github-copilot",
+	"bedrock-converse-stream",
+	"ollama",
+	"pi-messages",
+	"azure-openai-responses"
+];
+const MODEL_DATA_THINKING_FORMATS = [
+	"openai",
+	"openrouter",
+	"deepseek",
+	"together",
+	"qwen",
+	"qwen-chat-template",
+	"zai"
+];
+const MODEL_DATA_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+[...MODEL_DATA_APIS];
+[...MODEL_DATA_THINKING_FORMATS];
+/** Model-level thinking settings carried by provider catalog metadata. */
+const MODEL_CATALOG_THINKING_LEVELS = [...MODEL_DATA_THINKING_LEVELS];
+const OPENAI_THINKING_APIS = /* @__PURE__ */ new Set([
+	"openai-completions",
+	"openai-responses",
+	"openai-chatgpt-responses",
+	"azure-openai-responses"
+]);
+/** Managed API aliases retain the source adapter's reasoning contract. */
+function resolveOpenAIThinkingApi(api) {
+	if (typeof api !== "string") return;
+	const sourceApi = api.replace(/^openclaw-(.+)-transport$/u, "$1");
+	return OPENAI_THINKING_APIS.has(sourceApi) ? sourceApi : void 0;
+}
+/** Map keys describe logical choices; provider-native values retain their spelling. */
+function listMappedModelThinkingLevels(model) {
+	const compat = asOptionalRecord(model.compat);
+	const efforts = compat?.supportedReasoningEfforts;
+	const api = resolveOpenAIThinkingApi(model.api);
+	const format = compat?.thinkingFormat;
+	if (!api || api === "openai-completions" && (format === "qwen" || format === "qwen-chat-template" || format === "zai") || compat?.supportsReasoningEffort === false || Array.isArray(efforts) && efforts.length === 0) return [];
+	const mapping = asOptionalRecord(compat?.reasoningEffortMap);
+	const mapped = new Set(Object.entries(mapping ?? {}).flatMap(([level, effort]) => typeof effort === "string" && effort.trim() ? [level.trim().toLowerCase()] : []));
+	return MODEL_CATALOG_THINKING_LEVELS.filter((level) => mapped.has(level));
+}
+//#endregion
 //#region packages/ai/src/providers/openai-reasoning-effort.ts
 /**
 * OpenAI-compatible reasoning-effort normalization. Different GPT families
 * expose different accepted effort enums, so callers map requested values here
 * before constructing provider payloads.
 */
+const ENABLED_REASONING_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
 const GPT_5_REASONING_EFFORTS = [
 	"minimal",
 	"low",
@@ -66,12 +135,7 @@ const GENERIC_REASONING_EFFORTS = [
 ];
 const CANONICAL_REASONING_EFFORTS = /* @__PURE__ */ new Set([
 	"none",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max",
+	...ENABLED_REASONING_EFFORTS,
 	"off"
 ]);
 function normalizeModelId(id) {
@@ -105,8 +169,7 @@ function readCompatReasoningEfforts(compat) {
 	if (compat.supportsReasoningEffort === false) return [];
 	const raw = compat.supportedReasoningEfforts;
 	if (!Array.isArray(raw)) return;
-	const supported = uniqueStrings(normalizeStringEntries(raw.filter((value) => typeof value === "string")));
-	return supported.length > 0 ? supported : void 0;
+	return normalizeUniqueTrimmedStringList(raw);
 }
 function isDisabledReasoningEffort(effort) {
 	return effort === "none" || effort === "off";
@@ -120,8 +183,10 @@ function resolveOpenAIModelReasoningEfforts(model) {
 	const compatEfforts = readCompatReasoningEfforts(model.compat);
 	if (compatEfforts) return compatEfforts;
 	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
-	if (id === "gpt-6-astra" && model.api !== "azure-openai-responses") return GPT_6_ASTRA_REASONING_EFFORTS;
-	if (/^gpt-5\.6(?:-|$)/u.test(id)) return GPT_56_REASONING_EFFORTS;
+	const api = resolveOpenAIThinkingApi(model.api);
+	const supportsMax = api !== "openai-completions";
+	if (id === "gpt-6-astra" && api !== "azure-openai-responses") return supportsMax ? GPT_6_ASTRA_REASONING_EFFORTS : GPT_CODEX_REASONING_EFFORTS;
+	if (/^gpt-5\.6(?:-|$)/u.test(id)) return supportsMax ? GPT_56_REASONING_EFFORTS : GPT_52_REASONING_EFFORTS;
 	if (id === "gpt-5.1-codex-mini") return GPT_51_CODEX_MINI_REASONING_EFFORTS;
 	if (id === "gpt-5.1-codex-max") return GPT_51_CODEX_MAX_REASONING_EFFORTS;
 	if (/^gpt-5(?:\.\d+)?-codex(?:-|$)/u.test(id)) return GPT_CODEX_REASONING_EFFORTS;
@@ -142,26 +207,29 @@ function supportsOpenAITemperature(model) {
 		if (typeof declared === "boolean") return declared;
 	}
 	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
-	return (id !== "gpt-6-astra" || model.api === "azure-openai-responses") && !/^gpt-5\.6(?:-|$)/u.test(id);
+	return (id !== "gpt-6-astra" || resolveOpenAIThinkingApi(model.api) === "azure-openai-responses") && !/^gpt-5\.6(?:-|$)/u.test(id);
 }
 /** Return whether a model accepts a requested reasoning effort. */
 function supportsOpenAIReasoningEffort(model, effort) {
 	return resolveOpenAISupportedReasoningEfforts(model).includes(normalizeOpenAIReasoningEffort(effort));
 }
+/** Read provider mappings without folding provider-native labels. */
+function resolveOpenAIReasoningEffortMapping(effort, mapping) {
+	const requested = normalizeOpenAIReasoningEffort(effort);
+	return mapping?.[requested] ?? (mapping && CANONICAL_REASONING_EFFORTS.has(requested) ? Object.entries(mapping).find(([key]) => normalizeOpenAIReasoningEffort(key) === requested)?.[1] : void 0);
+}
 /** Resolve a requested reasoning effort to the closest value supported by the model. */
 function resolveOpenAIReasoningEffortForModel(params) {
 	const requested = normalizeOpenAIReasoningEffort(params.effort);
-	const mapped = params.fallbackMap?.[requested] ?? (params.fallbackMap && CANONICAL_REASONING_EFFORTS.has(requested) ? Object.entries(params.fallbackMap).find(([effort]) => normalizeOpenAIReasoningEffort(effort) === requested)?.[1] : void 0);
+	const mapped = resolveOpenAIReasoningEffortMapping(requested, params.fallbackMap);
 	const normalized = mapped === void 0 ? requested : mapped.trim();
 	const supported = resolveOpenAISupportedReasoningEfforts(params.model);
 	if (supported.includes(normalized)) return normalized;
 	if (requested === "off" && supported.includes("none")) return "none";
 	if (isDisabledReasoningEffort(requested) || isDisabledReasoningEffort(normalized)) return;
-	if (requested === "minimal" && supported.includes("low")) return "low";
-	if ((requested === "minimal" || requested === "low") && supported.includes("medium")) return "medium";
-	if (requested === "xhigh" && supported.includes("high")) return "high";
-	if (requested === "max" && supported.includes("xhigh")) return "xhigh";
-	return supported.find((effort) => !isDisabledReasoningEffort(normalizeOpenAIReasoningEffort(effort)));
+	const requestedRank = ENABLED_REASONING_EFFORTS.findIndex((effort) => effort === normalized);
+	const ranked = ENABLED_REASONING_EFFORTS.filter((effort) => supported.includes(effort));
+	return (requestedRank < 0 ? void 0 : ranked.findLast((effort) => ENABLED_REASONING_EFFORTS.indexOf(effort) <= requestedRank) ?? ranked[0]) ?? supported.find((effort) => !isDisabledReasoningEffort(normalizeOpenAIReasoningEffort(effort)));
 }
 //#endregion
-export { resolveOpenAIModelReasoningEfforts as a, supportsOpenAIReasoningEffort as c, normalizeOpenAIReasoningEffort as i, supportsOpenAITemperature as l, isOpenAIGpt55Model as n, resolveOpenAIReasoningEffortForModel as o, isOpenAIGpt56Model as r, resolveOpenAISupportedReasoningEfforts as s, isOpenAIGpt54MiniModel as t };
+export { resolveOpenAIModelReasoningEfforts as a, resolveOpenAISupportedReasoningEfforts as c, MODEL_CATALOG_THINKING_LEVELS as d, listMappedModelThinkingLevels as f, normalizeOpenAIReasoningEffort as i, supportsOpenAIReasoningEffort as l, isOpenAIGpt55Model as n, resolveOpenAIReasoningEffortForModel as o, resolveOpenAIThinkingApi as p, isOpenAIGpt56Model as r, resolveOpenAIReasoningEffortMapping as s, isOpenAIGpt54MiniModel as t, supportsOpenAITemperature as u };

package/dist/{openai-responses-D99dOzKI.mjs → openai-responses-BejZzQCP.mjs}

@@ -1,14 +1,15 @@
 import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
-import { n as clampOpenAIPromptCacheKey, r as resolveOpenAIPromptCacheParams, s as resolveOpenAICompletionsCompat } from "./openai-prompt-cache-BI0rkM-5.mjs";
+import { n as clampOpenAIPromptCacheKey, r as resolveOpenAIPromptCacheParams } from "./openai-prompt-cache-1wfaIszn.mjs";
+import { i as resolveOpenAICompletionsCompat } from "./openai-completions-compat-CkwdxTZx.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { n as buildBaseOptions } from "./simple-options-tcKOqnpF.mjs";
+import { n as buildBaseOptions } from "./simple-options-C6cFWj_f.mjs";
+import { g as resolveOpenAISimpleReasoningEffort } from "./openai-transport-params-DQeuAvBl.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-import { t as resolveOpencodeSessionHeaders } from "./session-affinity-CCH7eYdB.mjs";
-import { l as supportsOpenAITemperature } from "./openai-reasoning-effort-BK7FbcLT.mjs";
-import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, r as convertResponsesMessages, s as runResponsesStreamLifecycle, t as applyCommonResponsesParams } from "./openai-responses-shared-ZyQEzS5i.mjs";
+import { n as resolveProviderSimpleCompletionHeaders } from "./provider-transport-turn-state-CkGToCD2.mjs";
+import { a as runResponsesStreamLifecycle, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, r as convertResponsesMessages, t as applyCommonResponsesParams } from "./openai-responses-shared-CwsziD_m.mjs";
 import { n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-B37TB3rB.mjs";
-import { t as createOpenAIProviderClient } from "./openai-provider-client-ha_WxTyj.mjs";
+import { t as createOpenAIProviderClient } from "./openai-provider-client-DPo0Hmak.mjs";
 //#region packages/ai/src/providers/openai-responses.ts
 var openai_responses_exports = /* @__PURE__ */ __exportAll({
 	streamOpenAIResponses: () => streamOpenAIResponses,
@@ -21,9 +22,6 @@ function getCompat(model) {
 		sendSessionIdHeader: model.compat?.sendSessionIdHeader ?? true
 	};
 }
-/**
-* Generate function for OpenAI Responses API
-*/
 const streamOpenAIResponses = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
 	const output = createResponsesAssistantOutput(model);
@@ -35,7 +33,7 @@ const streamOpenAIResponses = (model, context, options) => {
 		createClient: () => {
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
 			const cacheSessionId = resolveCacheRetention(options?.cacheRetention) === "none" ? void 0 : options?.sessionId;
-			return createClient(model, context, apiKey, resolveOpencodeSessionHeaders(model, options), cacheSessionId);
+			return createClient(model, context, apiKey, resolveProviderSimpleCompletionHeaders(model, options), cacheSessionId);
 		},
 		buildParams: (_requestModel, replayMode) => buildParams(model, context, options, replayMode),
 		processStreamOptions: {
@@ -53,7 +51,7 @@ const streamSimpleOpenAIResponses = (model, context, options) => {
 	return streamOpenAIResponses(model, context, {
 		...base,
 		authProfileId: replayOptions?.authProfileId,
-		reasoningEffort: resolveResponsesReasoningEffort(model, options?.reasoning),
+		reasoningEffort: resolveOpenAISimpleReasoningEffort(model, options?.reasoning),
 		replayResponsesItemIds: replayOptions?.replayResponsesItemIds
 	});
 };
@@ -92,8 +90,6 @@ function buildParams(model, context, options, replayMode = "checkpoint") {
 		...resolveOpenAIPromptCacheParams(model, cacheRetention, compat),
 		store: false
 	};
-	if (options?.maxTokens) params.max_output_tokens = options?.maxTokens;
-	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options?.temperature;
 	if (options?.serviceTier !== void 0) params.service_tier = options.serviceTier;
 	applyCommonResponsesParams(params, model, context, options, { setDefaultReasoningOff: model.provider !== "github-copilot" });
 	return params;