@openclaw/ai 2026.8.1-beta.1 → 2026.8.1-beta.3

package/dist/{openai-reasoning-compat-DKebnIBL.mjs → openai-stop-reason-9OONKyAm.mjs}

@@ -1,9 +1,15 @@
-import { _ as normalizeLowercaseStringOrEmpty, b as isRecord, i as transformMessages } from "./host-Bl7Kgddo.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { a as isImageWithMediaPayload, h as stripSystemPromptCacheBoundary, o as truncateUtf16Safe, r as extractToolResultText, t as describeToolResultMediaPlaceholder } from "./tool-result-text-Dvkp2Dus.mjs";
-import { o as resolveProviderRequestCapabilities } from "./tool-schema-json-projection-B1b-XCn5.mjs";
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-BP7HLLZn.mjs";
+import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload } from "./host-DF_yxOsA.mjs";
+import { a as isRecord, r as asOptionalObjectRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
+import { d as finalizeTerminalToolCallArguments, j as stripSystemPromptCacheBoundary } from "./simple-options-oqsXB6U3.mjs";
+import { o as resolveProviderRequestCapabilities } from "./tool-schema-json-projection-FEr-jOoZ.mjs";
+import { u as measureUtf8AppendBytes } from "./openai-tool-projection-CHGLt03m.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform--gtf0ZbR.mjs";
 import { randomUUID } from "node:crypto";
 //#region packages/ai/src/utils/assistant-text-phase.ts
+const EMPTY_ASSISTANT_TEXT_BLOCK_SET = /* @__PURE__ */ new Set();
 function isAssistantTextPhaseBlock(block) {
 	if (!block || typeof block !== "object") return false;
 	const record = block;
@@ -16,20 +22,36 @@ function encodeAssistantTextSignatureV1(id, phase) {
 		...phase ? { phase } : {}
 	});
 }
-/** Tags unphased narration before a tool-call event becomes consumer-visible. */
-function tagPendingCommentaryText(content) {
+function tagUnphasedText(content, phase, idPrefix) {
 	const textBlocks = content.filter(isAssistantTextPhaseBlock);
-	let commentaryIndex = textBlocks.filter((block) => block.textSignature !== void 0).length;
+	let phaseIndex = 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");
+		const signature = encodeAssistantTextSignatureV1(`${idPrefix}-${phaseIndex}`, phase);
 		block.textSignature = signature;
 		tagged.set(block, signature);
-		commentaryIndex += 1;
+		phaseIndex += 1;
 	}
 	return tagged;
 }
+/** Tags unphased narration before a tool-call event becomes consumer-visible. */
+function tagPendingCommentaryText(content) {
+	return tagUnphasedText(content, "commentary", "commentary");
+}
+/** Records the confirmed final-answer boundary after reasoning resumes. */
+function tagInterruptedTextPhases(content, interruptedText, preservedVisibleText = EMPTY_ASSISTANT_TEXT_BLOCK_SET) {
+	const interruptedTextIndex = content.indexOf(interruptedText);
+	if (interruptedTextIndex === -1) return;
+	const finalAnswerIndex = content.findIndex((block, index) => index > interruptedTextIndex && isAssistantTextPhaseBlock(block) && block.text.trim().length > 0);
+	if (finalAnswerIndex === -1) return;
+	tagUnphasedText(content.slice(0, finalAnswerIndex).filter((block) => !preservedVisibleText.has(block)), "commentary", "commentary");
+	tagUnphasedText(content.filter((block, index) => index >= finalAnswerIndex || preservedVisibleText.has(block)), "final_answer", "final-answer");
+}
+/** Prevents unresolved completion text from becoming a fallback answer after stream failure. */
+function tagUnresolvedTextAsCommentary(message) {
+	if (message.openclawDelivery?.textPhaseRequiresTerminal) tagUnphasedText(message.content, "commentary", "commentary");
+}
 /** 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;
@@ -122,8 +144,8 @@ function resolveOpenAICompletionsCompatDefaultsFromCapabilities(input) {
 	return resolveOpenAICompletionsCompatDefaults(input);
 }
 /** Detects endpoint capabilities and defaults for an OpenAI-completions model. */
-function detectOpenAICompletionsCompat(model, resolveCapabilities = resolveProviderRequestCapabilities) {
-	const capabilities = resolveCapabilities({
+function detectOpenAICompletionsCompat(model, resolveCapabilities) {
+	const capabilities = (resolveCapabilities ?? ((input) => resolveProviderRequestCapabilities(input, model)))({
 		provider: model.provider,
 		api: "openai-completions",
 		baseUrl: model.baseUrl,
@@ -148,7 +170,7 @@ function resolveSessionAffinity(model, detectedFormat) {
 	return "openai";
 }
 /** Applies explicit model overrides once on top of the canonical transport defaults. */
-function resolveOpenAICompletionsCompat(model, resolveCapabilities = resolveProviderRequestCapabilities) {
+function resolveOpenAICompletionsCompat(model, resolveCapabilities) {
 	const { defaults } = detectOpenAICompletionsCompat(model, resolveCapabilities);
 	const configured = model.compat;
 	return {
@@ -175,7 +197,160 @@ function resolveOpenAICompletionsCompat(model, resolveCapabilities = resolveProv
 		requiresNonEmptyUserOrAssistantMessage: defaults.requiresNonEmptyUserOrAssistantMessage
 	};
 }
-if (process.env.VITEST || false) globalThis[Symbol.for("openclaw.openAICompletionsCompatTestApi")] = { resolveOpenAICompletionsCompatDefaults };
+//#endregion
+//#region packages/ai/src/providers/openai-completions-tool-calls.ts
+const MAX_BUFFERED_TOOL_CALL_ARGUMENT_BYTES = 256e3;
+const MAX_BUFFERED_LEGACY_FOLLOWING_DELTA_BYTES = 256e3;
+const MAX_BUFFERED_LEGACY_FOLLOWING_DELTAS = 1024;
+/** Normalize the SDK's legacy single-function lane into its modern tool-call shape. */
+function createOpenAICompletionsToolCallDeltaNormalizer() {
+	let sawModernToolCall = false;
+	let pendingLegacyArgumentBytes = 0;
+	let pendingFollowingDeltaBytes = 0;
+	let pendingLegacyToolCall;
+	const modernArguments = /* @__PURE__ */ new Map();
+	const pendingFollowingDeltas = [];
+	const takePendingFollowingDeltas = () => {
+		pendingFollowingDeltaBytes = 0;
+		return pendingFollowingDeltas.splice(0).map((delta) => ({
+			delta,
+			toolCalls: []
+		}));
+	};
+	const bufferFollowingDelta = (delta) => {
+		const nextDeltaBytes = Buffer.byteLength(JSON.stringify(delta), "utf8");
+		if (pendingFollowingDeltaBytes + nextDeltaBytes > MAX_BUFFERED_LEGACY_FOLLOWING_DELTA_BYTES || pendingFollowingDeltas.length >= MAX_BUFFERED_LEGACY_FOLLOWING_DELTAS) throw new Error("Exceeded legacy tool-call content buffer limit");
+		pendingFollowingDeltaBytes += nextDeltaBytes;
+		pendingFollowingDeltas.push(delta);
+	};
+	const withoutToolCalls = (delta) => {
+		const ordinaryDelta = { ...delta };
+		delete ordinaryDelta.function_call;
+		delete ordinaryDelta.tool_calls;
+		return ordinaryDelta;
+	};
+	const hasObservableContent = (value) => {
+		if (typeof value === "string") return value.length > 0;
+		if (Array.isArray(value)) return value.some(hasObservableContent);
+		if (isRecord(value)) return Object.entries(value).some(([field, nestedValue]) => field !== "type" && field !== "id" && field !== "index" && hasObservableContent(nestedValue));
+		return false;
+	};
+	const hasOrdinaryContent = (delta) => Object.entries(delta).some(([field, value]) => field !== "role" && hasObservableContent(value));
+	return (delta, finishReason) => {
+		const ordinaryDelta = withoutToolCalls(delta);
+		if (delta.tool_calls && delta.tool_calls.length > 0) {
+			for (const toolCall of delta.tool_calls) {
+				const index = typeof toolCall.index === "number" ? toolCall.index : void 0;
+				const state = (index === void 0 ? void 0 : modernArguments.get(index)) ?? (toolCall.id ? modernArguments.get(toolCall.id) : void 0) ?? {
+					bytes: 0,
+					pendingHighSurrogate: false
+				};
+				if (index !== void 0) modernArguments.set(index, state);
+				if (toolCall.id) modernArguments.set(toolCall.id, state);
+				const argumentDelta = toolCall.function?.arguments ?? "";
+				const append = measureUtf8AppendBytes(state.pendingHighSurrogate, argumentDelta);
+				state.bytes += append.bytes;
+				if (state.bytes > MAX_BUFFERED_TOOL_CALL_ARGUMENT_BYTES) throw new Error("Exceeded tool-call argument buffer limit");
+				state.pendingHighSurrogate = append.endsWithHighSurrogate;
+			}
+			const precedingDeltas = takePendingFollowingDeltas();
+			sawModernToolCall = true;
+			pendingLegacyArgumentBytes = 0;
+			pendingLegacyToolCall = void 0;
+			return [...precedingDeltas, {
+				delta: ordinaryDelta,
+				toolCalls: delta.tool_calls
+			}];
+		}
+		const functionCall = delta.function_call;
+		if (sawModernToolCall) return [{
+			delta: ordinaryDelta,
+			toolCalls: []
+		}];
+		const hadPendingLegacyCall = pendingLegacyToolCall !== void 0;
+		const leadingDeltas = [];
+		if (hasOrdinaryContent(ordinaryDelta)) if (hadPendingLegacyCall) bufferFollowingDelta(ordinaryDelta);
+		else leadingDeltas.push({
+			delta: ordinaryDelta,
+			toolCalls: []
+		});
+		if (functionCall && (functionCall.name || functionCall.arguments)) {
+			const nextFunctionName = pendingLegacyToolCall?.function?.name ? void 0 : functionCall.name;
+			const nextArgumentBytes = Buffer.byteLength(functionCall.arguments ?? "", "utf8") + Buffer.byteLength(nextFunctionName ?? "", "utf8");
+			if (pendingLegacyArgumentBytes + nextArgumentBytes > MAX_BUFFERED_TOOL_CALL_ARGUMENT_BYTES) throw new Error("Exceeded tool-call argument buffer limit");
+			pendingLegacyArgumentBytes += nextArgumentBytes;
+			pendingLegacyToolCall ??= {
+				index: 0,
+				id: `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`,
+				type: "function",
+				function: {}
+			};
+			const pendingFunction = pendingLegacyToolCall.function ??= {};
+			if (nextFunctionName) pendingFunction.name = nextFunctionName;
+			if (functionCall.arguments) pendingFunction.arguments = (pendingFunction.arguments ?? "") + functionCall.arguments;
+		}
+		if (!pendingLegacyToolCall) return leadingDeltas.length > 0 ? leadingDeltas : [{
+			delta: ordinaryDelta,
+			toolCalls: []
+		}];
+		if (finishReason === "function_call") {
+			const confirmedLegacyToolCall = pendingLegacyToolCall;
+			pendingLegacyToolCall = void 0;
+			pendingLegacyArgumentBytes = 0;
+			return [
+				...leadingDeltas,
+				{
+					delta: {},
+					toolCalls: [confirmedLegacyToolCall]
+				},
+				...takePendingFollowingDeltas()
+			];
+		}
+		if (finishReason) {
+			pendingLegacyArgumentBytes = 0;
+			pendingLegacyToolCall = void 0;
+			return [...leadingDeltas, ...takePendingFollowingDeltas()];
+		}
+		return leadingDeltas;
+	};
+}
+/** Publish only executable calls; streaming scratch state never belongs in replay. */
+function finalizeOpenAICompletionsToolCalls(output, options = {}) {
+	const isToolCall = (block) => block.type === "toolCall";
+	const hasToolCalls = output.content.some(isToolCall);
+	if (output.stopReason === "toolUse" && !hasToolCalls) output.stopReason = "stop";
+	if (output.stopReason === "stop" && hasToolCalls && options.allowSilentToolCallPromotion !== false && !output.content.some((block) => {
+		const candidate = block;
+		return candidate.type === "text" && typeof candidate.text === "string" && candidate.text.trim().length > 0;
+	})) output.stopReason = "toolUse";
+	if (output.stopReason !== "toolUse") {
+		if (hasToolCalls) output.content = output.content.filter((block) => !isToolCall(block));
+		return;
+	}
+	const toolCalls = output.content.filter(isToolCall);
+	const rejectToolCalls = () => {
+		output.stopReason = "error";
+		output.errorMessage = "Provider returned an incomplete or malformed tool call";
+		output.content = output.content.filter((candidate) => !isToolCall(candidate));
+	};
+	if (toolCalls.some((call) => typeof call.name !== "string" || call.name.trim().length === 0 || typeof call.partialArgs !== "string" || call.partialArgs.trim().length === 0)) {
+		rejectToolCalls();
+		return;
+	}
+	try {
+		finalizeTerminalToolCallArguments(toolCalls, (call) => call.partialArgs);
+	} catch {
+		rejectToolCalls();
+		return;
+	}
+	for (let contentIndex = 0; contentIndex < output.content.length; contentIndex += 1) {
+		const block = output.content[contentIndex];
+		if (!block || !isToolCall(block)) continue;
+		delete block.partialArgs;
+		delete block.streamIndex;
+		options.onConfirmedToolCall?.(block, contentIndex);
+	}
+}
 //#endregion
 //#region packages/ai/src/openai-completions-messages.ts
 const EMPTY_TOOL_RESULT_TEXT = "(no output)";
@@ -192,6 +367,10 @@ function sanitizeToolResultText(text, fallback) {
 	const sanitized = sanitizeSurrogates(text);
 	return sanitized.trim().length > 0 ? sanitized : fallback;
 }
+/** Whether replayed messages require a tools marker for proxy compatibility. */
+function hasToolCallHistory(messages) {
+	return messages.some((message) => message.role === "toolResult" || message.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "toolCall"));
+}
 /** Convert a normalized transcript to OpenAI Chat Completions messages. */
 function convertMessages(model, context, compat, options = {}) {
 	const params = [];
@@ -200,7 +379,7 @@ function convertMessages(model, context, compat, options = {}) {
 		if (model.provider === "openai") return id.length > 40 ? truncateUtf16Safe(id, 40) : id;
 		return id;
 	};
-	const transformedMessages = transformMessages(context.messages, model, (id) => normalizeToolCallId(id));
+	const transformedMessages = transformProviderMessages(context.messages, model, (id) => normalizeToolCallId(id));
 	if (context.systemPrompt) {
 		const role = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
 		const systemPrompt = options.preserveSystemPromptCacheBoundary ? context.systemPrompt : stripSystemPromptCacheBoundary(context.systemPrompt);
@@ -232,6 +411,10 @@ function convertMessages(model, context, compat, options = {}) {
 						type: "text",
 						text: sanitizeSurrogates(item.text)
 					};
+					if (item.type === "video") return {
+						type: "video_url",
+						video_url: { url: `data:${item.mimeType};base64,${item.data}` }
+					};
 					return {
 						type: "image_url",
 						image_url: { url: `data:${item.mimeType};base64,${item.data}` }
@@ -339,144 +522,31 @@ function convertMessages(model, context, compat, options = {}) {
 	return params;
 }
 //#endregion
-//#region packages/ai/src/providers/openai-completions-tool-calls.ts
-const MAX_BUFFERED_LEGACY_TOOL_CALL_ARGUMENT_BYTES = 256e3;
-const MAX_BUFFERED_LEGACY_FOLLOWING_DELTA_BYTES = 256e3;
-const MAX_BUFFERED_LEGACY_FOLLOWING_DELTAS = 1024;
-/** Normalize the SDK's legacy single-function lane into its modern tool-call shape. */
-function createOpenAICompletionsToolCallDeltaNormalizer() {
-	let sawModernToolCall = false;
-	let pendingLegacyArgumentBytes = 0;
-	let pendingFollowingDeltaBytes = 0;
-	let pendingLegacyToolCall;
-	const pendingFollowingDeltas = [];
-	const takePendingFollowingDeltas = () => {
-		pendingFollowingDeltaBytes = 0;
-		return pendingFollowingDeltas.splice(0).map((delta) => ({
-			delta,
-			toolCalls: []
-		}));
-	};
-	const bufferFollowingDelta = (delta) => {
-		const nextDeltaBytes = Buffer.byteLength(JSON.stringify(delta), "utf8");
-		if (pendingFollowingDeltaBytes + nextDeltaBytes > MAX_BUFFERED_LEGACY_FOLLOWING_DELTA_BYTES || pendingFollowingDeltas.length >= MAX_BUFFERED_LEGACY_FOLLOWING_DELTAS) throw new Error("Exceeded legacy tool-call content buffer limit");
-		pendingFollowingDeltaBytes += nextDeltaBytes;
-		pendingFollowingDeltas.push(delta);
-	};
-	const withoutToolCalls = (delta) => {
-		const ordinaryDelta = { ...delta };
-		delete ordinaryDelta.function_call;
-		delete ordinaryDelta.tool_calls;
-		return ordinaryDelta;
-	};
-	const hasObservableContent = (value) => {
-		if (typeof value === "string") return value.length > 0;
-		if (Array.isArray(value)) return value.some(hasObservableContent);
-		if (isRecord(value)) return Object.entries(value).some(([field, nestedValue]) => field !== "type" && field !== "id" && field !== "index" && hasObservableContent(nestedValue));
-		return false;
-	};
-	const hasOrdinaryContent = (delta) => Object.entries(delta).some(([field, value]) => field !== "role" && hasObservableContent(value));
-	return (delta, finishReason) => {
-		const ordinaryDelta = withoutToolCalls(delta);
-		if (delta.tool_calls && delta.tool_calls.length > 0) {
-			const precedingDeltas = takePendingFollowingDeltas();
-			sawModernToolCall = true;
-			pendingLegacyArgumentBytes = 0;
-			pendingLegacyToolCall = void 0;
-			return [...precedingDeltas, {
-				delta: ordinaryDelta,
-				toolCalls: delta.tool_calls
-			}];
-		}
-		const functionCall = delta.function_call;
-		if (sawModernToolCall) return [{
-			delta: ordinaryDelta,
-			toolCalls: []
-		}];
-		const hadPendingLegacyCall = pendingLegacyToolCall !== void 0;
-		const leadingDeltas = [];
-		if (hasOrdinaryContent(ordinaryDelta)) if (hadPendingLegacyCall) bufferFollowingDelta(ordinaryDelta);
-		else leadingDeltas.push({
-			delta: ordinaryDelta,
-			toolCalls: []
-		});
-		if (functionCall && (functionCall.name || functionCall.arguments)) {
-			const nextFunctionName = pendingLegacyToolCall?.function?.name ? void 0 : functionCall.name;
-			const nextArgumentBytes = Buffer.byteLength(functionCall.arguments ?? "", "utf8") + Buffer.byteLength(nextFunctionName ?? "", "utf8");
-			if (pendingLegacyArgumentBytes + nextArgumentBytes > MAX_BUFFERED_LEGACY_TOOL_CALL_ARGUMENT_BYTES) throw new Error("Exceeded tool-call argument buffer limit");
-			pendingLegacyArgumentBytes += nextArgumentBytes;
-			pendingLegacyToolCall ??= {
-				index: 0,
-				id: `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`,
-				type: "function",
-				function: {}
-			};
-			const pendingFunction = pendingLegacyToolCall.function ??= {};
-			if (nextFunctionName) pendingFunction.name = nextFunctionName;
-			if (functionCall.arguments) pendingFunction.arguments = (pendingFunction.arguments ?? "") + functionCall.arguments;
-		}
-		if (!pendingLegacyToolCall) return leadingDeltas.length > 0 ? leadingDeltas : [{
-			delta: ordinaryDelta,
-			toolCalls: []
-		}];
-		if (finishReason === "function_call") {
-			const confirmedLegacyToolCall = pendingLegacyToolCall;
-			pendingLegacyToolCall = void 0;
-			pendingLegacyArgumentBytes = 0;
-			return [
-				...leadingDeltas,
-				{
-					delta: {},
-					toolCalls: [confirmedLegacyToolCall]
-				},
-				...takePendingFollowingDeltas()
-			];
-		}
-		if (finishReason) {
-			pendingLegacyArgumentBytes = 0;
-			pendingLegacyToolCall = void 0;
-			return [...leadingDeltas, ...takePendingFollowingDeltas()];
-		}
-		return leadingDeltas;
-	};
+//#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) {
+	const rawMap = asOptionalObjectRecord(asOptionalObjectRecord(compat)?.reasoningEffortMap);
+	if (!rawMap) return {};
+	return Object.fromEntries(Object.entries(rawMap).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string"));
 }
-/** Publish only executable calls; streaming scratch state never belongs in replay. */
-function finalizeOpenAICompletionsToolCalls(output, options = {}) {
-	const isToolCall = (block) => block.type === "toolCall";
-	const hasToolCalls = output.content.some(isToolCall);
-	if (output.stopReason === "toolUse" && !hasToolCalls) output.stopReason = "stop";
-	if (output.stopReason === "stop" && hasToolCalls && options.allowSilentToolCallPromotion !== false && !output.content.some((block) => {
-		const candidate = block;
-		return candidate.type === "text" && typeof candidate.text === "string" && candidate.text.trim().length > 0;
-	})) output.stopReason = "toolUse";
-	if (output.stopReason !== "toolUse") {
-		if (hasToolCalls) output.content = output.content.filter((block) => !isToolCall(block));
-		return;
-	}
-	for (const block of output.content) {
-		if (!isToolCall(block)) continue;
-		const toolCall = block;
-		let completeArguments;
-		try {
-			completeArguments = typeof toolCall.partialArgs === "string" && toolCall.partialArgs.trim().length > 0 ? JSON.parse(toolCall.partialArgs) : void 0;
-		} catch {
-			completeArguments = void 0;
-		}
-		if (typeof toolCall.name !== "string" || toolCall.name.trim().length === 0 || !isRecord(completeArguments)) {
-			output.stopReason = "error";
-			output.errorMessage = "Provider returned an incomplete or malformed tool call";
-			output.content = output.content.filter((candidate) => !isToolCall(candidate));
-			return;
-		}
-		toolCall.arguments = completeArguments;
-	}
-	for (let contentIndex = 0; contentIndex < output.content.length; contentIndex += 1) {
-		const block = output.content[contentIndex];
-		if (!block || !isToolCall(block)) continue;
-		delete block.partialArgs;
-		delete block.streamIndex;
-		options.onConfirmedToolCall?.(block, contentIndex);
-	}
+/** 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-stop-reason.ts
@@ -506,32 +576,4 @@ function mapOpenAIStopReason(reason, options) {
 	};
 }
 //#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
-export { convertMessages as a, resolveOpenAICompletionsResponseFormat as c, rememberPendingCommentaryTags as d, tagPendingCommentaryText as f, finalizeOpenAICompletionsToolCalls as i, shouldOmitOllamaCompatResponseFormat as l, mapOpenAIStopReason as n, detectOpenAICompletionsCompat as o, createOpenAICompletionsToolCallDeltaNormalizer as r, resolveOpenAICompletionsCompat as s, resolveOpenAIReasoningEffortMap as t, clearPendingCommentaryText as u };
+export { createOpenAICompletionsToolCallDeltaNormalizer as a, resolveOpenAICompletionsCompat as c, clearPendingCommentaryText as d, rememberPendingCommentaryTags as f, tagUnresolvedTextAsCommentary as h, hasToolCallHistory as i, resolveOpenAICompletionsResponseFormat as l, tagPendingCommentaryText as m, resolveOpenAIReasoningEffortMap as n, finalizeOpenAICompletionsToolCalls as o, tagInterruptedTextPhases as p, convertMessages as r, detectOpenAICompletionsCompat as s, mapOpenAIStopReason as t, shouldOmitOllamaCompatResponseFormat as u };