@openclaw/ai 2026.9.4 → 2026.9.5

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

@@ -1,26 +1,27 @@
 import { r as appendAssistantThinking } from "./event-stream-D8PARQfL.mjs";
-import { _ as isImageWithMediaPayload, d as describeToolResultMediaPlaceholder, m as extractToolResultText, v as sanitizeSurrogates } from "./host-B8YfDGd4.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-Bds-n_9Q.mjs";
-import { r as emitModelTransportDebug } from "./diagnostics-QuErwCIl.mjs";
-import { i as asNonNegativeFiniteNumber } from "./base64-D-su8YVo.mjs";
-import { c as supportsModelTools, r as estimateStringChars } from "./transport-utils-zrYjICLZ.mjs";
-import { n as uniqueStrings } from "./string-normalization-CmLIasuf.mjs";
-import { i as resolveProviderEndpoint, r as resolveOpenAIStrictToolSetting } from "./host-policy-Zcg_cNz8.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 { f as splitSystemPromptCacheBoundary, h as stripSystemPromptRelocatableBoundary, m as stripSystemPromptCacheBoundary, p as splitSystemPromptRelocatableBoundary, v as sortPromptCacheToolsByName } from "./simple-options-BQbb4yQL.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-9aPuV5YY.mjs";
-import { E as parseStreamingJson, c as finalizeTerminalToolCallArguments, w as createToolArgumentPreviewSchedule } from "./transport-stream-shared-zHll9BxO.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 { 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-V5YzU9zh.mjs";
-import { _ as isOpenAIGpt56Model, b as resolveOpenAIReasoningEffortForModel, g as isOpenAIGpt55Model, h as isOpenAIGpt54MiniModel } from "./openai-responses-contracts-DDOHA62Y.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-BcR5pztD.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 = [
@@ -640,12 +641,9 @@ function relocateNonBehavioralRegion(args) {
 }
 //#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
@@ -657,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;
@@ -838,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 {
@@ -847,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,
@@ -870,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);
@@ -930,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) ? {
@@ -940,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" });
@@ -1071,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) {
@@ -1078,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-B4eYo2-I.d.mts → openai-prompt-cache-CJ_xEevu.d.mts}

@@ -1,5 +1,5 @@
-import { M as OpenAICompletionsCompat, O as Model, l as CacheRetention } from "./types-Ntv5z2g2.mjs";
-import "./types-DlfwzH3T.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-S2gCrM2Z.mjs → openai-provider-client-DPo0Hmak.mjs}

@@ -1,5 +1,5 @@
-import { n as getAiTransportHost } from "./host-B8YfDGd4.mjs";
-import { T as resolveOpenAIClientBaseUrl } from "./openai-transport-params-9aPuV5YY.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-NlFZmfEu.mjs

@@ -0,0 +1,235 @@
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.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",
+	"medium",
+	"high"
+];
+const GPT_51_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high"
+];
+const GPT_52_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_56_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const GPT_6_ASTRA_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const GPT_CODEX_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_PRO_REASONING_EFFORTS = [
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_5_PRO_REASONING_EFFORTS = ["high"];
+const GPT_51_CODEX_MAX_REASONING_EFFORTS = [
+	"none",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_51_CODEX_MINI_REASONING_EFFORTS = ["medium"];
+const GENERIC_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high"
+];
+const CANONICAL_REASONING_EFFORTS = /* @__PURE__ */ new Set([
+	"none",
+	...ENABLED_REASONING_EFFORTS,
+	"off"
+]);
+function normalizeModelId(id) {
+	return normalizeLowercaseStringOrEmpty(id ?? "").replace(/-\d{4}-\d{2}-\d{2}$/u, "");
+}
+/** Return whether a model is the GPT-5.4 mini family. */
+function isOpenAIGpt54MiniModel(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return /^gpt-5\.4-mini(?:-|$)/u.test(id);
+}
+/** Return whether a model is the GPT-5.5 family. */
+function isOpenAIGpt55Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
+	return /^gpt-5\.5(?:-|$)/u.test(id) || /^gpt-5\.5(?:\s|\(|-|$)/u.test(name);
+}
+/** Return whether a model is the GPT-5.6 family. */
+function isOpenAIGpt56Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
+	return /^gpt-5\.6(?:-|$)/u.test(id) || /^gpt-5\.6(?:\s|\(|-|$)/u.test(name);
+}
+/** Normalize user-facing reasoning effort names to API effort names. */
+function normalizeOpenAIReasoningEffort(effort) {
+	const trimmed = effort.trim();
+	const folded = trimmed.toLowerCase();
+	return CANONICAL_REASONING_EFFORTS.has(folded) ? folded : trimmed;
+}
+function readCompatReasoningEfforts(compat) {
+	if (!compat || typeof compat !== "object") return;
+	if (compat.supportsReasoningEffort === false) return [];
+	const raw = compat.supportedReasoningEfforts;
+	if (!Array.isArray(raw)) return;
+	return normalizeUniqueTrimmedStringList(raw);
+}
+function isDisabledReasoningEffort(effort) {
+	return effort === "none" || effort === "off";
+}
+/** Resolve the reasoning efforts accepted by a specific OpenAI-compatible model. */
+function resolveOpenAISupportedReasoningEfforts(model) {
+	return resolveOpenAIModelReasoningEfforts(model) ?? GENERIC_REASONING_EFFORTS;
+}
+/** Read a declared or known model contract, leaving unknown compatible models unspecified. */
+function resolveOpenAIModelReasoningEfforts(model) {
+	const compatEfforts = readCompatReasoningEfforts(model.compat);
+	if (compatEfforts) return compatEfforts;
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	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;
+	if (id === "gpt-5-pro") return GPT_5_PRO_REASONING_EFFORTS;
+	if (/^gpt-5\.[2-9](?:\.\d+)?-pro(?:-|$)/u.test(id)) return GPT_PRO_REASONING_EFFORTS;
+	if (/^gpt-5\.[2-9](?:\.\d+)?(?:-|$)/u.test(id)) return GPT_52_REASONING_EFFORTS;
+	if (/^gpt-5\.1(?:-|$)/u.test(id)) return GPT_51_REASONING_EFFORTS;
+	if (/^gpt-5(?:-|$)/u.test(id)) return GPT_5_REASONING_EFFORTS;
+}
+/**
+* Return whether a model accepts temperature. GPT-5.6 and GPT-6 Astra
+* reject it with a 400; catalog compat can override per model.
+*/
+function supportsOpenAITemperature(model) {
+	const compat = model.compat;
+	if (compat && typeof compat === "object") {
+		const declared = compat.supportsTemperature;
+		if (typeof declared === "boolean") return declared;
+	}
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	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 = 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;
+	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, 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-DaYwH05E.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-Bds-n_9Q.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-BQbb4yQL.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 { C as supportsOpenAITemperature } from "./openai-responses-contracts-DDOHA62Y.mjs";
-import { n as resolveProviderSimpleCompletionHeaders } from "./provider-transport-turn-state-D5EXOFL2.mjs";
-import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, r as convertResponsesMessages, s as runResponsesStreamLifecycle, t as applyCommonResponsesParams } from "./openai-responses-shared-B8RdBPCv.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-S2gCrM2Z.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);
@@ -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;