@openclaw/ai 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{openai-completions-DPR_O2RW.mjs → openai-completions-exO8NFQf.mjs}

@@ -1,16 +1,299 @@
-import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DnhYpc27.mjs";
+import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost } from "./host-4t713IeR.mjs";
-import { n as calculateCost, r as clampThinkingLevel, t as applyProviderReportedUsageCost } from "./model-utils-Q1LSRIdo.mjs";
+import { n as getAiTransportHost } from "./host-XYGZcgO8.mjs";
+import { C as isImageWithMediaPayload, D as buildBaseOptions, a as stripSystemPromptCacheBoundary, c as transformMessages, g as normalizeLowercaseStringOrEmpty, i as splitSystemPromptCacheBoundary, x as extractToolResultText, y as describeToolResultMediaPlaceholder } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
+import { n as calculateCost, r as clampThinkingLevel, t as applyProviderReportedUsageCost } from "./model-utils-1GiZ2_rr.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
 import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { C as stripSystemPromptCacheBoundary, S as splitSystemPromptCacheBoundary, i as extractToolResultText, l as buildBaseOptions, n as describeToolResultMediaPlaceholder, o as isImageWithMediaPayload, t as transformMessages } from "./transform-messages-BmS70CP5.mjs";
 import { a as resolveCacheRetention, i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-BsH5cqGj.mjs";
 import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-BlVe67g6.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-RjWszj8c.mjs";
-import { a as clampOpenAIPromptCacheKey, n as reconcileOpenAICompletionsToolChoice, t as projectOpenAITools } from "./openai-tool-projection-CFqm42J2.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DP4xEyBY.mjs";
+import { t as formatProviderError } from "./provider-error-C4VvV_3t.mjs";
+import { a as clampOpenAIPromptCacheKey, n as reconcileOpenAICompletionsToolChoice, t as projectOpenAITools } from "./openai-tool-projection-ITOU9bG1.mjs";
 import OpenAI from "openai";
+//#region packages/ai/src/utils/assistant-text-phase.ts
+function isAssistantTextPhaseBlock(block) {
+	if (!block || typeof block !== "object") return false;
+	const record = block;
+	return record.type === "text" && typeof record.text === "string";
+}
+function encodeAssistantTextSignatureV1(id, phase) {
+	return JSON.stringify({
+		v: 1,
+		id,
+		...phase ? { phase } : {}
+	});
+}
+/** Tags unphased narration before a tool-call event becomes consumer-visible. */
+function tagPendingCommentaryText(content) {
+	const textBlocks = content.filter(isAssistantTextPhaseBlock);
+	let commentaryIndex = textBlocks.filter((block) => block.textSignature !== void 0).length;
+	const tagged = /* @__PURE__ */ new Map();
+	for (const block of textBlocks) {
+		if (block.text.trim().length === 0 || block.textSignature !== void 0) continue;
+		const signature = encodeAssistantTextSignatureV1(`commentary-${commentaryIndex}`, "commentary");
+		block.textSignature = signature;
+		tagged.set(block, signature);
+		commentaryIndex += 1;
+	}
+	return tagged;
+}
+/** Rolls back only the exact provisional signatures created by this transport turn. */
+function clearPendingCommentaryText(tags) {
+	for (const [block, signature] of tags) if (block.textSignature === signature) delete block.textSignature;
+	tags.clear();
+}
+function rememberPendingCommentaryTags(target, tagged) {
+	for (const [block, signature] of tagged) target.set(block, signature);
+}
+//#endregion
+//#region packages/ai/src/transports/openai-reasoning-compat.ts
+/**
+* OpenAI reasoning-effort compatibility helpers.
+*
+* Keeps provider metadata and built-in model exceptions on one path before request payloads are built.
+*/
+const OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS = /* @__PURE__ */ new Set(["gpt-5.1-codex-mini"]);
+function readCompatReasoningEffortMap(compat) {
+	if (!compat || typeof compat !== "object") return {};
+	const rawMap = compat.reasoningEffortMap;
+	if (!rawMap || typeof rawMap !== "object") return {};
+	return Object.fromEntries(Object.entries(rawMap).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string"));
+}
+/** Resolves the reasoning effort remap for an OpenAI-compatible model. */
+function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
+	const provider = normalizeLowercaseStringOrEmpty(model.provider ?? "");
+	const id = normalizeLowercaseStringOrEmpty(model.id ?? "");
+	const builtinMap = provider === "openai" && OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS.has(id) ? {
+		minimal: "medium",
+		low: "medium"
+	} : {};
+	return {
+		...fallbackMap,
+		...builtinMap,
+		...readCompatReasoningEffortMap(model.compat)
+	};
+}
+//#endregion
+//#region packages/ai/src/providers/openai-completions-compat.ts
+const DEFAULT_OPENAI_COMPLETIONS_COMPAT = {
+	supportsStore: true,
+	supportsDeveloperRole: true,
+	supportsReasoningEffort: true,
+	supportsUsageInStreaming: true,
+	maxTokensField: "max_completion_tokens",
+	requiresToolResultName: false,
+	requiresAssistantAfterToolResult: false,
+	requiresThinkingAsText: false,
+	requiresReasoningContentOnAssistantMessages: false,
+	thinkingFormat: "openai",
+	vercelGatewayRouting: {},
+	zaiToolStream: false,
+	supportsStrictMode: true,
+	cacheControlFormat: void 0,
+	sessionAffinityFormat: "openai",
+	supportsPromptCacheKey: false,
+	supportsLongCacheRetention: true
+};
+const OPENAI_COMPLETIONS_COMPAT_MATRIX = {
+	openrouter: {
+		priority: 10,
+		providers: ["openrouter"],
+		baseUrlIncludes: ["openrouter.ai"],
+		compat: {
+			supportsDeveloperRole: false,
+			thinkingFormat: "openrouter",
+			sessionAffinityFormat: "openrouter"
+		}
+	},
+	cerebras: {
+		priority: 20,
+		providers: ["cerebras"],
+		baseUrlIncludes: ["cerebras.ai"],
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false
+		}
+	},
+	xai: {
+		priority: 20,
+		providers: ["xai"],
+		baseUrlIncludes: ["api.x.ai"],
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			supportsReasoningEffort: false
+		}
+	},
+	moonshot: {
+		priority: 20,
+		providers: ["moonshotai", "moonshotai-cn"],
+		baseUrlIncludes: ["api.moonshot."],
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			supportsReasoningEffort: false,
+			maxTokensField: "max_tokens",
+			supportsStrictMode: false
+		}
+	},
+	cloudflareWorkersAi: {
+		priority: 20,
+		providers: ["cloudflare-workers-ai"],
+		baseUrlIncludes: ["api.cloudflare.com"],
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			supportsLongCacheRetention: false
+		}
+	},
+	cloudflareAiGateway: {
+		priority: 20,
+		providers: ["cloudflare-ai-gateway"],
+		baseUrlIncludes: ["gateway.ai.cloudflare.com"],
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			supportsReasoningEffort: false,
+			maxTokensField: "max_tokens",
+			supportsStrictMode: false,
+			supportsLongCacheRetention: false
+		}
+	},
+	opencode: {
+		priority: 20,
+		providers: ["opencode"],
+		baseUrlIncludes: ["opencode.ai"],
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false
+		}
+	},
+	chutes: {
+		priority: 20,
+		baseUrlIncludes: ["chutes.ai"],
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			maxTokensField: "max_tokens"
+		}
+	},
+	together: {
+		priority: 30,
+		providers: ["together"],
+		baseUrlIncludes: ["api.together.ai", "api.together.xyz"],
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			supportsReasoningEffort: false,
+			maxTokensField: "max_tokens",
+			thinkingFormat: "together",
+			supportsStrictMode: false,
+			supportsLongCacheRetention: false
+		}
+	},
+	zai: {
+		priority: 40,
+		providers: ["zai"],
+		baseUrlIncludes: ["api.z.ai"],
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			supportsReasoningEffort: false,
+			maxTokensField: "max_tokens",
+			thinkingFormat: "zai"
+		}
+	},
+	xiaomi: {
+		priority: 50,
+		providers: ["xiaomi"],
+		baseUrlIncludes: ["xiaomimimo.com"],
+		compat: {
+			thinkingFormat: "deepseek",
+			requiresReasoningContentOnAssistantMessages: true
+		}
+	},
+	deepseekProvider: {
+		priority: 60,
+		providers: ["deepseek"],
+		compat: {
+			thinkingFormat: "deepseek",
+			requiresReasoningContentOnAssistantMessages: true
+		}
+	},
+	deepseekEndpoint: {
+		priority: 60,
+		baseUrlIncludes: ["deepseek.com"],
+		compat: {
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			thinkingFormat: "deepseek",
+			requiresReasoningContentOnAssistantMessages: true
+		}
+	}
+};
+const OPENAI_COMPLETIONS_MODEL_COMPAT_MATRIX = [{
+	profile: "openrouter",
+	modelIdPrefixes: ["anthropic/", "openai/"],
+	compat: { supportsDeveloperRole: true }
+}, {
+	providers: ["openrouter"],
+	modelIdPrefixes: ["anthropic/"],
+	compat: { cacheControlFormat: "anthropic" }
+}];
+const SORTED_OPENAI_COMPLETIONS_COMPAT_RULES = Object.entries(OPENAI_COMPLETIONS_COMPAT_MATRIX).toSorted(([, left], [, right]) => left.priority - right.priority);
+function matchesCompatRule(model, rule) {
+	return rule.providers?.includes(model.provider) === true || rule.baseUrlIncludes?.some((fragment) => model.baseUrl.includes(fragment)) === true;
+}
+function matchesModelCompatRule(model, matchedProfiles, rule) {
+	if (rule.profile !== void 0 && !matchedProfiles.has(rule.profile)) return false;
+	if (rule.providers !== void 0 && !rule.providers.includes(model.provider)) return false;
+	return rule.modelIdPrefixes.some((prefix) => model.id.startsWith(prefix));
+}
+/** Detects request compatibility from the provider, endpoint, and model family matrices. */
+function detectOpenAICompletionsCompat(model) {
+	const compat = { ...DEFAULT_OPENAI_COMPLETIONS_COMPAT };
+	const matchedProfiles = /* @__PURE__ */ new Set();
+	for (const [profile, rule] of SORTED_OPENAI_COMPLETIONS_COMPAT_RULES) {
+		if (!matchesCompatRule(model, rule)) continue;
+		Object.assign(compat, rule.compat);
+		matchedProfiles.add(profile);
+	}
+	for (const rule of OPENAI_COMPLETIONS_MODEL_COMPAT_MATRIX) if (matchesModelCompatRule(model, matchedProfiles, rule)) Object.assign(compat, rule.compat);
+	return compat;
+}
+function resolveSessionAffinity(model, detectedFormat) {
+	if (model.compat?.sendSessionAffinityHeaders !== true) return "none";
+	if (detectedFormat === "openrouter" || model.compat.thinkingFormat === "openrouter" || model.compat.openRouterRouting !== void 0) return "openrouter";
+	return "openai";
+}
+/** Applies explicit model overrides to the detected compatibility defaults. */
+function resolveOpenAICompletionsCompat(model) {
+	const detected = detectOpenAICompletionsCompat(model);
+	const configured = model.compat;
+	return {
+		supportsStore: configured?.supportsStore ?? detected.supportsStore,
+		supportsDeveloperRole: configured?.supportsDeveloperRole ?? detected.supportsDeveloperRole,
+		supportsReasoningEffort: configured?.supportsReasoningEffort ?? detected.supportsReasoningEffort,
+		supportsUsageInStreaming: configured?.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
+		maxTokensField: configured?.maxTokensField ?? detected.maxTokensField,
+		requiresToolResultName: configured?.requiresToolResultName ?? detected.requiresToolResultName,
+		requiresAssistantAfterToolResult: configured?.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
+		requiresThinkingAsText: configured?.requiresThinkingAsText ?? detected.requiresThinkingAsText,
+		requiresReasoningContentOnAssistantMessages: configured?.requiresReasoningContentOnAssistantMessages ?? detected.requiresReasoningContentOnAssistantMessages,
+		thinkingFormat: configured?.thinkingFormat ?? detected.thinkingFormat,
+		openRouterRouting: configured?.openRouterRouting,
+		vercelGatewayRouting: configured?.vercelGatewayRouting ?? detected.vercelGatewayRouting,
+		zaiToolStream: configured?.zaiToolStream ?? detected.zaiToolStream,
+		supportsStrictMode: configured?.supportsStrictMode ?? detected.supportsStrictMode,
+		cacheControlFormat: configured?.cacheControlFormat ?? detected.cacheControlFormat,
+		sessionAffinity: resolveSessionAffinity(model, detected.sessionAffinityFormat),
+		supportsPromptCacheKey: configured?.supportsPromptCacheKey ?? detected.supportsPromptCacheKey,
+		supportsLongCacheRetention: configured?.supportsLongCacheRetention ?? detected.supportsLongCacheRetention
+	};
+}
+//#endregion
 //#region packages/ai/src/providers/openai-stop-reason.ts
 function mapOpenAIStopReason(reason, options) {
 	if (reason === null) return { stopReason: "stop" };
@@ -72,6 +355,11 @@ function sanitizeToolResultText(text, fallback) {
 	const sanitized = sanitizeSurrogates(text);
 	return sanitized.trim().length > 0 ? sanitized : fallback;
 }
+function isEncryptedReasoningDetail(detail) {
+	if (typeof detail !== "object" || detail === null) return false;
+	const candidate = detail;
+	return candidate.type === "reasoning.encrypted" && typeof candidate.id === "string" && candidate.id.length > 0 && typeof candidate.data === "string" && candidate.data.length > 0;
+}
 const streamOpenAICompletions = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
 	(async () => {
@@ -98,10 +386,11 @@ const streamOpenAICompletions = (model, context, options) => {
 			stopReason: "stop",
 			timestamp: Date.now()
 		};
+		const provisionalCommentaryTags = /* @__PURE__ */ new Map();
 		let firstEventAbort;
 		try {
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-			const compat = getCompat(model);
+			const compat = resolveOpenAICompletionsCompat(model);
 			const cacheRetention = resolveCacheRetention(options?.cacheRetention);
 			const cacheSessionId = cacheRetention === "none" ? void 0 : options?.sessionId;
 			const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat);
@@ -112,7 +401,7 @@ const streamOpenAICompletions = (model, context, options) => {
 			const requestOptions = {
 				signal: firstEventAbort.signal,
 				...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
-				...options?.maxRetries !== void 0 ? { maxRetries: options.maxRetries } : {}
+				maxRetries: options?.maxRetries ?? 0
 			};
 			const { data: openaiStream, response } = await client.chat.completions.create(params, requestOptions).withResponse();
 			await options?.onResponse?.({
@@ -129,6 +418,7 @@ const streamOpenAICompletions = (model, context, options) => {
 			const toolCallBlocksByIndex = /* @__PURE__ */ new Map();
 			const toolCallBlocksById = /* @__PURE__ */ new Map();
 			const toolCallBlocksByFirstId = /* @__PURE__ */ new Map();
+			const pendingReasoningDetailsByToolCallId = /* @__PURE__ */ new Map();
 			const blocks = output.content;
 			const finishedBlocks = /* @__PURE__ */ new Set();
 			const contentIndices = /* @__PURE__ */ new WeakMap();
@@ -138,7 +428,13 @@ const streamOpenAICompletions = (model, context, options) => {
 			};
 			const getContentIndex = (block) => contentIndices.get(block) ?? -1;
 			const rememberFirstToolCallById = (id, block) => {
-				if (!toolCallBlocksByFirstId.has(id)) toolCallBlocksByFirstId.set(id, block);
+				if (toolCallBlocksByFirstId.has(id)) return;
+				toolCallBlocksByFirstId.set(id, block);
+				const pendingDetail = pendingReasoningDetailsByToolCallId.get(id);
+				if (pendingDetail) {
+					block.thoughtSignature = pendingDetail;
+					pendingReasoningDetailsByToolCallId.delete(id);
+				}
 			};
 			const finishBlock = (block) => {
 				const contentIndex = getContentIndex(block);
@@ -315,9 +611,10 @@ const streamOpenAICompletions = (model, context, options) => {
 					if (choiceDelta.content !== null && choiceDelta.content !== void 0 && choiceDelta.content.length > 0) appendPartitionedContent(choiceDelta.content, Boolean(foundReasoningField));
 					const refusalText = typeof choiceDelta.refusal === "string" ? choiceDelta.refusal : "";
 					if (refusalText.length > 0) appendPartitionedContent(refusalText, Boolean(foundReasoningField));
-					if (choiceDelta.tool_calls) {
+					if (choiceDelta.tool_calls && choiceDelta.tool_calls.length > 0) {
 						flushPartitionedContent();
 						sealNativeReasoningBeforeText();
+						rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
 						for (const toolCall of choiceDelta.tool_calls) {
 							const block = ensureToolCallBlock(toolCall);
 							if (!block.id && toolCall.id) {
@@ -341,10 +638,12 @@ const streamOpenAICompletions = (model, context, options) => {
 						}
 					}
 					const reasoningDetails = choiceDelta.reasoning_details;
-					if (reasoningDetails && Array.isArray(reasoningDetails)) {
-						for (const detail of reasoningDetails) if (detail.type === "reasoning.encrypted" && detail.id && detail.data) {
+					if (Array.isArray(reasoningDetails)) {
+						for (const detail of reasoningDetails) if (isEncryptedReasoningDetail(detail)) {
+							const serializedDetail = JSON.stringify(detail);
 							const matchingToolCall = toolCallBlocksByFirstId.get(detail.id);
-							if (matchingToolCall) matchingToolCall.thoughtSignature = JSON.stringify(detail);
+							if (matchingToolCall) matchingToolCall.thoughtSignature = serializedDetail;
+							else pendingReasoningDetailsByToolCallId.set(detail.id, serializedDetail);
 						}
 					}
 				}
@@ -360,6 +659,8 @@ const streamOpenAICompletions = (model, context, options) => {
 			if (output.stopReason === "toolUse" && !hasToolCalls) output.stopReason = "stop";
 			if (output.stopReason === "stop" && hasToolCalls && !hasVisibleText) output.stopReason = "toolUse";
 			if (hasToolCalls && output.stopReason !== "toolUse") output.content = output.content.filter((block) => block.type !== "toolCall");
+			if (output.stopReason !== "toolUse") clearPendingCommentaryText(provisionalCommentaryTags);
+			if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
 			stream.push({
 				type: "done",
 				reason: output.stopReason,
@@ -373,9 +674,9 @@ const streamOpenAICompletions = (model, context, options) => {
 				delete block.streamIndex;
 			}
 			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+			output.errorMessage = formatProviderError(error);
 			const rawMetadata = error?.error?.metadata?.raw;
-			if (rawMetadata) output.errorMessage += `\n${rawMetadata}`;
+			if (rawMetadata && !output.errorMessage.includes(rawMetadata)) output.errorMessage += `\n${rawMetadata}`;
 			stream.push({
 				type: "error",
 				reason: output.stopReason,
@@ -401,7 +702,7 @@ const streamSimpleOpenAICompletions = (model, context, options) => {
 		toolChoice
 	});
 };
-function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = getCompat(model)) {
+function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = resolveOpenAICompletionsCompat(model)) {
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 	const headers = { ...model.headers };
 	if (model.provider === "github-copilot") {
@@ -412,7 +713,8 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
 		});
 		Object.assign(headers, copilotHeaders);
 	}
-	if (sessionId && compat.sendSessionAffinityHeaders) {
+	if (sessionId && compat.sessionAffinity !== "none") if (compat.sessionAffinity === "openrouter") headers["x-session-id"] = sessionId;
+	else {
 		headers.session_id = sessionId;
 		headers["x-client-request-id"] = sessionId;
 		headers["x-session-affinity"] = sessionId;
@@ -431,7 +733,7 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
 		fetch: getAiTransportHost().buildModelFetch(model)
 	});
 }
-function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention)) {
+function buildParams(model, context, options, compat = resolveOpenAICompletionsCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention)) {
 	const cacheControl = getCompatCacheControl(compat, cacheRetention);
 	const cacheOptOutIndexes = /* @__PURE__ */ new Set();
 	const messages = convertMessages(model, context, compat, {
@@ -469,29 +771,35 @@ function buildParams(model, context, options, compat = getCompat(model), cacheRe
 		const toolChoice = reconcileOpenAICompletionsToolChoice(options.toolChoice, toolProjection ?? projectOpenAITools([]));
 		if (toolChoice !== void 0) params.tool_choice = toolChoice;
 	}
-	if (compat.thinkingFormat === "zai" && model.reasoning) params.thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
-	else if (compat.thinkingFormat === "qwen" && model.reasoning) params.enable_thinking = Boolean(options?.reasoningEffort);
+	const reasoningEffortMap = resolveOpenAIReasoningEffortMap(model);
+	const reasoningEffort = options?.reasoningEffort === void 0 ? void 0 : reasoningEffortMap[options.reasoningEffort] ?? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+	const reasoningEnabled = reasoningEffort !== void 0;
+	const offReasoningEffort = reasoningEffortMap.off ?? model.thinkingLevelMap?.off;
+	if (compat.thinkingFormat === "zai" && model.reasoning) params.thinking = reasoningEnabled ? {
+		type: "enabled",
+		clear_thinking: false
+	} : { type: "disabled" };
+	else if (compat.thinkingFormat === "qwen" && model.reasoning) params.enable_thinking = reasoningEnabled;
 	else if (compat.thinkingFormat === "qwen-chat-template" && model.reasoning) params.chat_template_kwargs = {
-		enable_thinking: Boolean(options?.reasoningEffort),
+		enable_thinking: reasoningEnabled,
 		preserve_thinking: true
 	};
 	else if (compat.thinkingFormat === "deepseek" && model.reasoning) {
-		params.thinking = { type: options?.reasoningEffort ? "enabled" : "disabled" };
-		if (options?.reasoningEffort && compat.supportsReasoningEffort) params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
+		params.thinking = { type: reasoningEnabled ? "enabled" : "disabled" };
+		if (reasoningEnabled && compat.supportsReasoningEffort) params.reasoning_effort = reasoningEffort;
 	} else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
 		const openRouterParams = params;
-		if (options?.reasoningEffort) openRouterParams.reasoning = { effort: model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort };
-		else if (model.thinkingLevelMap?.off !== null) openRouterParams.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
+		if (reasoningEnabled) openRouterParams.reasoning = { effort: reasoningEffort };
+		else if (offReasoningEffort !== null) openRouterParams.reasoning = { effort: offReasoningEffort ?? "none" };
 	} else if (compat.thinkingFormat === "together" && model.reasoning) {
 		const togetherParams = params;
-		togetherParams.reasoning = { enabled: Boolean(options?.reasoningEffort) };
-		if (options?.reasoningEffort && compat.supportsReasoningEffort) togetherParams.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
-	} else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) params.reasoning_effort = model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort;
-	else if (!options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
-		const offValue = model.thinkingLevelMap?.off;
-		if (typeof offValue === "string") params.reasoning_effort = offValue;
+		togetherParams.reasoning = { enabled: reasoningEnabled };
+		if (reasoningEnabled && compat.supportsReasoningEffort) togetherParams.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 (model.baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) params.provider = model.compat.openRouterRouting;
+	if (compat.openRouterRouting) params.provider = compat.openRouterRouting;
 	if (model.baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
 		const routing = model.compat.vercelGatewayRouting;
 		if (routing.only || routing.order) {
@@ -772,73 +1080,5 @@ function parseChunkUsage(rawUsage, model) {
 	applyProviderReportedUsageCost(usage, rawUsage.cost);
 	return usage;
 }
-/**
-* Detect compatibility settings from provider and baseUrl for known providers.
-* Provider takes precedence over URL-based detection since it's explicitly configured.
-* Returns a fully resolved OpenAICompletionsCompat object with all fields set.
-*/
-function detectCompat(model) {
-	const provider = model.provider;
-	const baseUrl = model.baseUrl;
-	const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
-	const isTogether = provider === "together" || baseUrl.includes("api.together.ai") || baseUrl.includes("api.together.xyz");
-	const isMoonshot = provider === "moonshotai" || provider === "moonshotai-cn" || baseUrl.includes("api.moonshot.");
-	const isCloudflareWorkersAI = provider === "cloudflare-workers-ai" || baseUrl.includes("api.cloudflare.com");
-	const isCloudflareAiGateway = provider === "cloudflare-ai-gateway" || baseUrl.includes("gateway.ai.cloudflare.com");
-	const isNonStandard = provider === "cerebras" || baseUrl.includes("cerebras.ai") || provider === "xai" || baseUrl.includes("api.x.ai") || isTogether || baseUrl.includes("chutes.ai") || baseUrl.includes("deepseek.com") || isZai || isMoonshot || provider === "opencode" || baseUrl.includes("opencode.ai") || isCloudflareWorkersAI || isCloudflareAiGateway;
-	const useMaxTokens = baseUrl.includes("chutes.ai") || isMoonshot || isCloudflareAiGateway || isTogether || isZai;
-	const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-	const isDeepSeek = provider === "deepseek" || baseUrl.includes("deepseek.com");
-	const isXiaomi = provider === "xiaomi" || baseUrl.includes("xiaomimimo.com");
-	const cacheControlFormat = provider === "openrouter" && model.id.startsWith("anthropic/") ? "anthropic" : void 0;
-	return {
-		supportsStore: !isNonStandard,
-		supportsDeveloperRole: !isNonStandard,
-		supportsReasoningEffort: !isGrok && !isZai && !isMoonshot && !isTogether && !isCloudflareAiGateway,
-		supportsUsageInStreaming: true,
-		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
-		requiresToolResultName: false,
-		requiresAssistantAfterToolResult: false,
-		requiresThinkingAsText: false,
-		requiresReasoningContentOnAssistantMessages: isDeepSeek || isXiaomi,
-		thinkingFormat: isDeepSeek ? "deepseek" : isXiaomi ? "deepseek" : isZai ? "zai" : isTogether ? "together" : provider === "openrouter" || baseUrl.includes("openrouter.ai") ? "openrouter" : "openai",
-		openRouterRouting: {},
-		vercelGatewayRouting: {},
-		zaiToolStream: false,
-		supportsStrictMode: !isMoonshot && !isTogether && !isCloudflareAiGateway,
-		cacheControlFormat,
-		sendSessionAffinityHeaders: false,
-		supportsPromptCacheKey: false,
-		supportsLongCacheRetention: !(isTogether || isCloudflareWorkersAI || isCloudflareAiGateway)
-	};
-}
-/**
-* Get resolved compatibility settings for a model.
-* Uses explicit model.compat if provided, otherwise auto-detects from provider/URL.
-*/
-function getCompat(model) {
-	const detected = detectCompat(model);
-	if (!model.compat) return detected;
-	return {
-		supportsStore: model.compat.supportsStore ?? detected.supportsStore,
-		supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
-		supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
-		supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
-		maxTokensField: model.compat.maxTokensField ?? detected.maxTokensField,
-		requiresToolResultName: model.compat.requiresToolResultName ?? detected.requiresToolResultName,
-		requiresAssistantAfterToolResult: model.compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
-		requiresThinkingAsText: model.compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
-		requiresReasoningContentOnAssistantMessages: model.compat.requiresReasoningContentOnAssistantMessages ?? detected.requiresReasoningContentOnAssistantMessages,
-		thinkingFormat: model.compat.thinkingFormat ?? detected.thinkingFormat,
-		openRouterRouting: model.compat.openRouterRouting ?? {},
-		vercelGatewayRouting: model.compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
-		zaiToolStream: model.compat.zaiToolStream ?? detected.zaiToolStream,
-		supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
-		cacheControlFormat: model.compat.cacheControlFormat ?? detected.cacheControlFormat,
-		sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ?? detected.sendSessionAffinityHeaders,
-		supportsPromptCacheKey: model.compat.supportsPromptCacheKey ?? detected.supportsPromptCacheKey,
-		supportsLongCacheRetention: model.compat.supportsLongCacheRetention ?? detected.supportsLongCacheRetention
-	};
-}
 //#endregion
-export { mapOpenAIStopReason as a, streamSimpleOpenAICompletions as i, openai_completions_exports as n, streamOpenAICompletions as r, convertMessages as t };
+export { mapOpenAIStopReason as a, rememberPendingCommentaryTags as c, streamSimpleOpenAICompletions as i, tagPendingCommentaryText as l, openai_completions_exports as n, resolveOpenAIReasoningEffortMap as o, streamOpenAICompletions as r, clearPendingCommentaryText as s, convertMessages as t };

package/dist/{openai-responses-Cov-Vdc2.mjs → openai-responses-BHpmtUKo.mjs}

@@ -1,10 +1,10 @@
-import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DnhYpc27.mjs";
+import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost } from "./host-4t713IeR.mjs";
-import { l as buildBaseOptions } from "./transform-messages-BmS70CP5.mjs";
+import { n as getAiTransportHost } from "./host-XYGZcgO8.mjs";
+import { D as buildBaseOptions } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
 import { a as resolveCacheRetention, i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-BsH5cqGj.mjs";
-import { M as supportsOpenAITemperature, a as resolveResponsesReasoningEffort, n as convertResponsesMessages, o as runResponsesStreamLifecycle, r as createResponsesAssistantOutput, t as applyCommonResponsesParams } from "./openai-responses-shared-Befb4D6R.mjs";
-import { a as clampOpenAIPromptCacheKey } from "./openai-tool-projection-CFqm42J2.mjs";
+import { L as supportsOpenAITemperature, a as resolveResponsesReasoningEffort, n as convertResponsesMessages, o as runResponsesStreamLifecycle, r as createResponsesAssistantOutput, t as applyCommonResponsesParams } from "./openai-responses-shared-CzCurmY1.mjs";
+import { a as clampOpenAIPromptCacheKey } from "./openai-tool-projection-ITOU9bG1.mjs";
 import OpenAI from "openai";
 //#region packages/ai/src/providers/openai-responses.ts
 var openai_responses_exports = /* @__PURE__ */ __exportAll({