@openclaw/ai 2026.9.8 → 2026.10.1-beta.1

package/dist/{openai-completions-stream-dju_5F3P.mjs → openai-completions-transport-DWM2mQDB.mjs}

@@ -1,28 +1,35 @@
-import { r as appendAssistantThinking } from "./event-stream-vd9UnCAU.mjs";
+import { _ as runtimeContextContentToText, f as hasRuntimeContextMarker, p as isRuntimeContextMessage } from "./types-CQc6JNG4.mjs";
+import { r as appendAssistantThinking } from "./event-stream-C5AbCAaZ.mjs";
 import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
-import { k as isImageWithMediaPayload, n as getAiTransportHost } from "./host-DwBmNMCC.mjs";
-import { n as isOpenAIGpt55Model, r as isOpenAIGpt56Model, t as isOpenAIGpt54MiniModel } from "./openai-reasoning-effort-C_0p3psG.mjs";
-import { r as uniqueStrings } from "./string-normalization-J9ZiLfGO.mjs";
-import { o as truncateUtf16Safe } from "./provider-error-CwT_j2v0.mjs";
-import { r as resolveOpenAIPromptCacheParams } from "./openai-prompt-cache-BTMs80_O.mjs";
-import { r as emitModelTransportDebug } from "./diagnostics-CJaB6g8J.mjs";
-import { i as asNonNegativeFiniteNumber } from "./base64-C1PsYcRQ.mjs";
-import { c as supportsModelTools, r as estimateStringChars } from "./transport-utils-CqXzku3R.mjs";
-import { c as shouldOmitOllamaCompatResponseFormat, n as isNativeOpenAIEndpoint, s as resolveOpenAICompletionsResponseFormat, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-BJf57ZxN.mjs";
-import { r as resolveProviderEndpoint } from "./host-policy-wK-ay_RK.mjs";
-import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { E as createToolArgumentPreviewSchedule, O as parseStreamingJson, d as iterateModelStream, j as sanitizeSurrogates, l as finalizeTerminalToolCallArguments, y as throwIfModelStreamAborted } from "./transport-stream-shared-BU5pwY6W.mjs";
-import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, S as splitSystemPromptRelocatableBoundary, d as describeToolResultMediaPlaceholder, m as extractToolResultText, w as stripSystemPromptRelocatableBoundary, x as splitSystemPromptCacheBoundary } from "./simple-options-BkDPMuxw.mjs";
-import { C as log, D as readOpenAICompletionsReasoningBatch, E as readOpenAICompletionsContentDeltas, S as isOpenAICompletionsThinkingEnabled, T as parseOpenAICompletionsUsage, d as prepareOpenAITools, f as projectOpenAITools, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, k as resolvePromptCacheKey, p as reconcileOpenAICompletionsToolChoice, s as getCompat, u as resolveOpenAIStrictToolFlagWithDiagnostics, v as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, w as measureUtf8AppendBytes } from "./openai-transport-params-DyFJ4cgR.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 { t as transformProviderMessages } from "./provider-transcript-transform-DjA5Fk2P.mjs";
-import { a as withFirstStreamEventTimeout } from "./stream-first-event-timeout-B9o0S4SZ.mjs";
-import { f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-vsl-cE-n.mjs";
-import { isGoogleGemini3FlashModel, isGoogleGemini3ProModel } from "./internal/google-model-family.mjs";
+import { s as readNonEmptyStringPreservingWhitespace, t as hasNonEmptyString } from "./string-coerce-CtgOVOSv.mjs";
+import { n as asNonNegativeFiniteNumber } from "./number-coercion-V8-BhME4.mjs";
+import { N as isImageWithMediaPayload, r as getAiTransportHost } from "./host-DCW52iHe.mjs";
+import { _ as isOpenAIGpt54MiniModel, v as isOpenAIGpt55Model, y as isOpenAIGpt56Model } from "./openai-responses-contracts-BKu8O7l4.mjs";
+import { r as uniqueStrings } from "./string-normalization-PN10hf6d.mjs";
+import { o as truncateUtf16Safe } from "./provider-error-DQBE1bUQ.mjs";
+import { r as resolveOpenAIPromptCacheParams } from "./openai-prompt-cache-I8YQTzf8.mjs";
+import { r as emitModelTransportDebug } from "./diagnostics-Caj-4RBA.mjs";
+import { c as supportsModelTools, r as estimateStringChars } from "./text-signature-MLwfi6fq.mjs";
+import { i as resolveOpenAICompletionsCompat, l as shouldOmitOllamaCompatResponseFormat, n as isNativeOpenAIEndpoint, s as resolveOpenAICompletionsResponseFormat, t as detectOpenAICompletionsCompat } from "./openai-completions-compat-BdmlhD4u.mjs";
+import { i as resolveProviderEndpoint, t as buildGuardedModelFetch } from "./host-policy-B3jc4Rpn.mjs";
+import { i as resolveCacheRetention, r as buildCopilotDynamicHeaders } from "./cloudflare-5qSGvIUH.mjs";
+import { E as createToolArgumentPreviewSchedule, O as parseStreamingJson, P as sanitizeSurrogates, S as withProviderResponseHook, _ as sanitizeNonEmptyTransportPayloadText, b as transportAbortError, c as failTransportStream, d as iterateModelStream, l as finalizeTerminalToolCallArguments, s as createWritableTransportEventStream, u as finalizeTransportStream, y as throwIfModelStreamAborted } from "./transport-stream-shared-CxXXz_Dd.mjs";
+import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, S as splitSystemPromptRelocatableBoundary, d as describeToolResultMediaPlaceholder, l as codeModeToolSurfaceObserver, m as extractToolResultText, s as prepareModelRequestBody, u as reasoningTagTextPolicy, w as stripSystemPromptRelocatableBoundary, x as splitSystemPromptCacheBoundary } from "./simple-options-BkKTXxhp.mjs";
+import { C as log, D as readOpenAICompletionsReasoningBatch, E as readOpenAICompletionsContentDeltas, O as resolveOpenAIClientBaseUrl, S as isOpenAICompletionsThinkingEnabled, T as parseOpenAICompletionsUsage, a as enforceCodeModeResponsesToolSurface, d as prepareOpenAITools, f as projectOpenAITools, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, i as buildOpenAISdkRequestOptions, k as resolvePromptCacheKey, l as resolveCodeModeResponsesVisibleToolNames, n as buildOpenAIClientHeaders, p as reconcileOpenAICompletionsToolChoice, r as buildOpenAISdkClientOptions, s as getCompat, t as assertCodeModeResponsesToolSurface, u as resolveOpenAIStrictToolFlagWithDiagnostics, v as GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP, w as measureUtf8AppendBytes, y as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-JFsnIyto.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-CyX4VKGO.mjs";
+import { n as transformProviderMessages, t as createAssistantOutput } from "./assistant-output-OLm-Oln0.mjs";
+import { a as tagUnresolvedTextAsCommentary, i as tagPendingCommentaryText, n as rememberPendingCommentaryTags, r as tagInterruptedTextPhases, t as clearPendingCommentaryText } from "./assistant-text-phase-Bl1aDCB7.mjs";
+import { t as notifyLlmRequestActivity } from "./llm-request-activity-D8f_oxHj.mjs";
+import { n as resolveOpencodeSessionHeaders } from "./session-affinity-DA4WHv1h.mjs";
+import "./types.mjs";
+import { i as createOpenAIProviderClient, n as resolveProviderSimpleCompletionHeaders, r as resolveProviderTransportTurnState, t as filterProviderTurnHeadersForExplicitOpencodeSession } from "./provider-transport-turn-state-_M2kLdUE.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-D9ZmL_s9.mjs";
+import { f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-DYNePiF8.mjs";
+import { isGoogleGemini3ThinkingLevelModel } from "./internal/google-model-family.mjs";
 import { t as mapOpenAIStopReason } from "./openai-stop-reason-8s70vDXj.mjs";
-import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-B6FIIBt6.mjs";
+import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-Ju9VpUGl.mjs";
 import { randomUUID } from "node:crypto";
+import OpenAI from "openai";
 //#region packages/ai/src/transports/deepseek-dsml-grammar.ts
 const DEEPSEEK_DSML_MARKERS = [
 	"|",
@@ -152,6 +159,34 @@ function canonicalizeMaxTokensParam(params) {
 	params.merged.maxTokens = resolved;
 }
 //#endregion
+//#region packages/ai/src/transports/openai-compatible-conversation-turn.ts
+function hasNonEmptyContentPart(part) {
+	if (!part || typeof part !== "object") return false;
+	const record = part;
+	if (record.type === "text") return hasNonEmptyString(record.text);
+	return true;
+}
+function hasNonEmptyMessageContent(content) {
+	if (hasNonEmptyString(content)) return true;
+	if (!Array.isArray(content)) return false;
+	return content.some(hasNonEmptyContentPart);
+}
+/** Returns whether an OpenAI-compatible messages payload contains a usable turn. */
+function hasOpenAICompatibleConversationTurn(messages) {
+	if (!Array.isArray(messages)) return false;
+	return messages.some((message) => {
+		if (!message || typeof message !== "object") return false;
+		const record = message;
+		if (record.role === "user") return hasNonEmptyMessageContent(record.content);
+		if (record.role === "assistant") {
+			if (hasNonEmptyMessageContent(record.content)) return true;
+			const toolCalls = record.tool_calls;
+			return Array.isArray(toolCalls) && toolCalls.some((toolCall) => toolCall && typeof toolCall === "object");
+		}
+		return false;
+	});
+}
+//#endregion
 //#region packages/ai/src/transports/openai-completions-cache-control.ts
 const shapedPayloads = /* @__PURE__ */ new WeakSet();
 function resolveCompletionsCacheControl(compat, retention, openRouterRoute) {
@@ -307,21 +342,16 @@ function createOpenAICompletionsToolCallDeltaNormalizer() {
 		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);
+		const ordinaryDelta = { ...delta };
+		delete ordinaryDelta.function_call;
+		delete ordinaryDelta.tool_calls;
 		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;
@@ -353,7 +383,7 @@ function createOpenAICompletionsToolCallDeltaNormalizer() {
 		}];
 		const hadPendingLegacyCall = pendingLegacyToolCall !== void 0;
 		const leadingDeltas = [];
-		if (hasOrdinaryContent(ordinaryDelta)) {
+		if (Object.entries(ordinaryDelta).some(([field, value]) => field !== "role" && hasObservableContent(value))) {
 			if (hadPendingLegacyCall) bufferFollowingDelta(ordinaryDelta);
 			else leadingDeltas.push({
 				delta: ordinaryDelta,
@@ -449,11 +479,6 @@ function isAzureOpenAICompatibleHost(hostname) {
 }
 //#endregion
 //#region packages/ai/src/openai-completions-messages.ts
-const EMPTY_TOOL_RESULT_TEXT = "(no output)";
-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"));
@@ -492,7 +517,13 @@ function convertMessages(model, context, compat, options = {}) {
 			role: "assistant",
 			content: "I have processed the tool results."
 		});
-		if (msg.role === "user") {
+		if (isRuntimeContextMessage(msg)) {
+			params.push({
+				role: model.reasoning && compat.supportsDeveloperRole ? "developer" : "system",
+				content: sanitizeSurrogates(runtimeContextContentToText(msg.content))
+			});
+			options.cacheOptOutIndexes?.add(params.length - 1);
+		} else if (msg.role === "user") {
 			let userParam;
 			if (typeof msg.content === "string") userParam = {
 				role: "user",
@@ -519,7 +550,7 @@ function convertMessages(model, context, compat, options = {}) {
 					content
 				};
 			}
-			if (msg.runtimeContextCarrier === true) options.cacheOptOutIndexes?.add(params.length);
+			if (hasRuntimeContextMarker(msg)) options.cacheOptOutIndexes?.add(params.length);
 			params.push(userParam);
 		} else if (msg.role === "assistant") {
 			const assistantMsg = {
@@ -586,7 +617,7 @@ function convertMessages(model, context, compat, options = {}) {
 				const images = toolMsg.content.filter(isImageWithMediaPayload);
 				const toolResultMsg = {
 					role: "tool",
-					content: sanitizeToolResultText(textResult, mediaPlaceholder ?? EMPTY_TOOL_RESULT_TEXT),
+					content: sanitizeNonEmptyTransportPayloadText(textResult, mediaPlaceholder),
 					tool_call_id: toolMsg.toolCallId
 				};
 				if (compat.requiresToolResultName && toolMsg.toolName) toolResultMsg.name = toolMsg.toolName;
@@ -660,11 +691,9 @@ function applyDirectCompletionsReasoningAndRouting(params, model, reasoning, com
 		enable_thinking: reasoningEnabled,
 		preserve_thinking: true
 	};
-	else if (compat.thinkingFormat === "deepseek" && model.reasoning) {
-		params.thinking = { type: reasoningEnabled ? "enabled" : "disabled" };
-		if (reasoningEnabled && compat.supportsReasoningEffort && nativeEffort !== void 0) params.reasoning_effort = nativeEffort;
-	} else if (compat.thinkingFormat === "together" && model.reasoning) {
-		params.reasoning = { enabled: reasoningEnabled };
+	else if ((compat.thinkingFormat === "deepseek" || compat.thinkingFormat === "together") && model.reasoning) {
+		if (compat.thinkingFormat === "deepseek") params.thinking = { type: reasoningEnabled ? "enabled" : "disabled" };
+		else params.reasoning = { enabled: reasoningEnabled };
 		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;
@@ -684,9 +713,6 @@ function isGoogleOpenAICompatModel(model) {
 	const endpointClass = detectOpenAICompletionsCompat(model).capabilities.endpointClass;
 	return model.provider === "google" || endpointClass === "google-generative-ai" || endpointClass === "google-vertex";
 }
-function requiresGoogleCompatToolCallThoughtSignature(model) {
-	return isGoogleGemini3ProModel(model.id) || isGoogleGemini3FlashModel(model.id);
-}
 const GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE = /[\u2026]|\.\.\./;
 const GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE = /^[A-Za-z0-9+/=]+$/;
 function hasGoogleCompatThoughtSignatureTruncationFootprint(value) {
@@ -695,17 +721,16 @@ function hasGoogleCompatThoughtSignatureTruncationFootprint(value) {
 function injectToolCallThoughtSignatures(outgoingMessages, context, model) {
 	if (!isGoogleOpenAICompatModel(model)) return;
 	const sigById = /* @__PURE__ */ new Map();
-	const fallbackSig = requiresGoogleCompatToolCallThoughtSignature(model) ? GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP : void 0;
+	const fallbackSig = isGoogleGemini3ThinkingLevelModel(model.id) ? GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP : void 0;
 	for (const msg of context.messages ?? []) {
 		if (msg.role !== "assistant") continue;
-		const source = msg;
-		if (!Array.isArray(source.content)) continue;
-		for (const block of source.content) {
+		if (!Array.isArray(msg.content)) continue;
+		for (const block of msg.content) {
 			if (block.type !== "toolCall") continue;
 			const id = block.id;
 			const sig = block.thoughtSignature;
 			if (typeof id === "string" && typeof sig === "string" && sig.length > 0) {
-				const isSameRoute = source.api === model.api && source.provider === model.provider && source.model === model.id;
+				const isSameRoute = msg.api === model.api && msg.provider === model.provider && msg.model === model.id;
 				if (!isSameRoute && !fallbackSig) continue;
 				sigById.set(id, isSameRoute ? sig : fallbackSig ?? sig);
 			}
@@ -738,7 +763,7 @@ const COMPLETIONS_REASONING_REPLAY_FIELDS = [
 	"reasoning_text"
 ];
 function stripCompletionsReasoningReplayFields(record) {
-	for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) if (field in record) delete record[field];
+	for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) delete record[field];
 }
 function sanitizeOpenRouterReasoningReplayFields(record) {
 	const reasoningDetails = record.reasoning_details;
@@ -746,11 +771,10 @@ function sanitizeOpenRouterReasoningReplayFields(record) {
 		if (reasoningDetails.length > 0 && typeof record.reasoning !== "string") record.reasoning = reasoningDetails;
 		delete record.reasoning_details;
 	} else if (reasoningDetails !== void 0 && !Array.isArray(reasoningDetails)) delete record.reasoning_details;
-	if ("reasoning" in record && (typeof record.reasoning !== "string" || record.reasoning === "")) delete record.reasoning;
-	if ("reasoning_content" in record && (typeof record.reasoning_content !== "string" || record.reasoning_content === "")) delete record.reasoning_content;
+	for (const field of ["reasoning", "reasoning_content"]) if (field in record && (typeof record[field] !== "string" || record[field] === "")) delete record[field];
 	const reasoningText = record.reasoning_text;
 	if (typeof reasoningText === "string" && reasoningText.length > 0 && typeof record.reasoning !== "string" && typeof record.reasoning_content !== "string") record.reasoning = reasoningText;
-	if ("reasoning_text" in record) delete record.reasoning_text;
+	delete record.reasoning_text;
 }
 function sanitizeReasoningContentReplayFields(record) {
 	if ("reasoning_content" in record && typeof record.reasoning_content !== "string") delete record.reasoning_content;
@@ -795,10 +819,7 @@ function getReasoningContentReplayModelIdCandidates(modelId) {
 	const candidates = [finalPart];
 	const colonParts = finalPart.split(":").filter(Boolean);
 	if (colonParts.length > 1) candidates.push(colonParts[0] ?? "", colonParts[colonParts.length - 1] ?? "");
-	const baseCount = candidates.length;
-	for (let index = 0; index < baseCount; index += 1) {
-		const candidate = candidates[index];
-		if (typeof candidate !== "string") continue;
+	for (const candidate of candidates.slice()) {
 		const stripped = stripReasoningContentReplayTierSuffix(candidate);
 		if (stripped !== candidate) candidates.push(stripped);
 	}
@@ -842,11 +863,8 @@ function isKnownOpenAICompletionsEndpoint(model) {
 	if (!model.baseUrl.trim() || isNativeOpenAIEndpoint(model)) return true;
 	const endpointClass = resolveProviderEndpoint(model).endpointClass;
 	if (endpointClass === "openai-public" || endpointClass === "azure-openai") return true;
-	try {
-		return isAzureOpenAICompatibleHost(new URL(model.baseUrl).hostname.toLowerCase());
-	} catch {
-		return false;
-	}
+	const endpoint = URL.parse(model.baseUrl);
+	return endpoint !== null && isAzureOpenAICompatibleHost(endpoint.hostname.toLowerCase());
 }
 function resolveOpenAICompletionsMaxTokens(model, options) {
 	if (options?.maxTokens) return {
@@ -1262,8 +1280,16 @@ function parseDeepSeekDsmlInvokeArguments(body) {
 		const name = parseDsmlNameAttribute(parameterMatch[2] ?? "");
 		if (!name) continue;
 		const rawValue = parameterMatch[3] ?? "";
-		if (rawValue.length === 0) continue;
-		args[name] = decodeDeepSeekDsmlText(rawValue);
+		if (rawValue.length === 0) {
+			const stringAttribute = Array.from((parameterMatch[2] ?? "").matchAll(/(?:^|\s)([^\s=]+)=(?:"([^"]*)"|'([^']*)'|([^\s"']+))(?=\s|$)/g)).find((attribute) => attribute[1] === "string");
+			if ((stringAttribute?.[2] ?? stringAttribute?.[3] ?? stringAttribute?.[4]) !== "true") continue;
+		}
+		Object.defineProperty(args, name, {
+			value: decodeDeepSeekDsmlText(rawValue),
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
 	}
 	if (Object.keys(args).length > 0) return args;
 	const trimmed = body.trim();
@@ -1361,12 +1387,8 @@ function scanDeepSeekDsmlToolBlock(text, closeToken, contentStartIndex, state) {
 function extractToolCallThoughtSignature(toolCall) {
 	const tc = toolCall;
 	if (!tc) return;
-	const fromExtra = (tc.extra_content?.google)?.thought_signature;
-	if (typeof fromExtra === "string" && fromExtra.length > 0) return fromExtra;
-	const fromFunction = tc.function?.thought_signature;
-	if (typeof fromFunction === "string" && fromFunction.length > 0) return fromFunction;
-	const fromToolCall = tc.thought_signature;
-	return typeof fromToolCall === "string" && fromToolCall.length > 0 ? fromToolCall : void 0;
+	const extra = tc.extra_content?.google;
+	return readNonEmptyStringPreservingWhitespace(extra?.thought_signature) ?? readNonEmptyStringPreservingWhitespace(tc.function?.thought_signature) ?? readNonEmptyStringPreservingWhitespace(tc.thought_signature);
 }
 async function processCompletionsStream(responseStream, output, model, stream, options) {
 	const MAX_POST_TOOL_CALL_BUFFER_BYTES = 256e3;
@@ -1757,12 +1779,303 @@ async function processCompletionsStream(responseStream, output, model, stream, o
 function shouldEmitOpenAICompletionsReasoning(model, options) {
 	if (!model.reasoning) return false;
 	const effort = options?.reasoningEffort ?? options?.reasoning ?? "high";
-	if (!effort || !isOpenAICompletionsThinkingEnabled(effort)) return false;
-	return true;
+	return Boolean(effort) && isOpenAICompletionsThinkingEnabled(effort);
 }
 function hasOpenAICompletionsReasoningUsageActivity(rawUsage) {
 	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
 	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) && reasoningTokens > 0;
 }
 //#endregion
-export { convertMessages as a, flattenCompletionMessagesToStringContent as c, canonicalizeMaxTokensParam as d, resolveMaxTokensParam as f, buildOpenAICompletionsRequest as i, stripCompletionMessagesToRoleContent as l, shouldEmitOpenAICompletionsReasoning as n, isAzureOpenAICompatibleHost as o, createDeepSeekTextFilter as p, buildOpenAICompletionsParams as r, finalizeOpenAICompletionsToolCalls as s, processCompletionsStream as t, applyCompletionsAnthropicCacheControl as u };
+//#region packages/ai/src/transports/openai-completions-transport.ts
+function assertOpenAICompletionsPayloadHasConversationTurn(params, model) {
+	const messages = params.messages;
+	if (!Array.isArray(messages) || hasOpenAICompatibleConversationTurn(messages)) return;
+	throw new Error(`OpenAI-compatible chat payload for ${model.provider}/${model.id} contains no non-empty user or assistant messages after compaction and transport transforms; refusing to send a system/tool-only request. Start a new user turn or repair the compacted session history.`);
+}
+const SSE_DONE_LINE_RE = /^data:[ \t]*\[DONE\][ \t]*$/i;
+const SSE_DONE_MAX_LINE_CHARS = 1024;
+function createSseDoneDetector() {
+	const decoder = new TextDecoder();
+	let line = "";
+	let lineOverflowed = false;
+	let sawDone = false;
+	const finishLine = () => {
+		if (!lineOverflowed && SSE_DONE_LINE_RE.test(line)) sawDone = true;
+		line = "";
+		lineOverflowed = false;
+	};
+	const observeText = (text) => {
+		for (const char of text) {
+			if (char === "\n" || char === "\r") {
+				finishLine();
+				continue;
+			}
+			if (!lineOverflowed && line.length < SSE_DONE_MAX_LINE_CHARS) line += char;
+			else lineOverflowed = true;
+		}
+	};
+	return {
+		observe(chunk) {
+			if (!sawDone) observeText(decoder.decode(chunk, { stream: true }));
+		},
+		finish() {
+			if (sawDone) return;
+			observeText(decoder.decode());
+			if (line || lineOverflowed) finishLine();
+		},
+		sawDone: () => sawDone
+	};
+}
+function buildOpenAICompletionsClientConfig(model, headers) {
+	const defaultQuery = {};
+	let baseURL = model.baseUrl;
+	let isAzureHost = false;
+	const parsed = URL.parse(model.baseUrl);
+	if (parsed) {
+		isAzureHost = isAzureOpenAICompatibleHost(parsed.hostname.toLowerCase());
+		parsed.searchParams.forEach((value, key) => {
+			if (value) defaultQuery[key] = value;
+		});
+		parsed.search = "";
+		baseURL = parsed.toString().replace(/\/$/, "");
+	}
+	if (isAzureHost) {
+		const apiVersionHeader = Object.keys(headers).find((key) => key.toLowerCase() === "api-version");
+		if (apiVersionHeader) {
+			const apiVersion = headers[apiVersionHeader]?.trim();
+			delete headers[apiVersionHeader];
+			if (apiVersion && !defaultQuery["api-version"]) defaultQuery["api-version"] = apiVersion;
+		}
+	}
+	return {
+		baseURL: resolveOpenAIClientBaseUrl(model, baseURL),
+		defaultHeaders: headers,
+		defaultQuery: Object.keys(defaultQuery).length > 0 ? defaultQuery : void 0
+	};
+}
+function createDirectCompletionsEventStream(output, stream) {
+	const finishedBlocks = /* @__PURE__ */ new Set();
+	const contentIndices = /* @__PURE__ */ new WeakMap();
+	let openTextBlock;
+	let openThinkingBlock;
+	const finishBlock = (block) => {
+		const contentIndex = contentIndices.get(block);
+		if (contentIndex === void 0 || finishedBlocks.has(block)) return;
+		finishedBlocks.add(block);
+		if (block.type === "text") {
+			openTextBlock = void 0;
+			stream.push({
+				type: "text_end",
+				contentIndex,
+				content: block.text,
+				partial: output
+			});
+		} else if (block.type === "thinking") {
+			openThinkingBlock = void 0;
+			stream.push({
+				type: "thinking_end",
+				contentIndex,
+				content: block.thinking,
+				partial: output
+			});
+		} else if (block.type === "toolCall") stream.push({
+			type: "toolcall_end",
+			contentIndex,
+			toolCall: block,
+			partial: output
+		});
+	};
+	return {
+		stream: { push(event) {
+			if (event.type === "text_start" || event.type === "thinking_start" || event.type === "toolcall_start") {
+				const block = output.content[event.contentIndex];
+				if (block) {
+					contentIndices.set(block, event.contentIndex);
+					if (block.type === "text") openTextBlock = block;
+					else if (block.type === "thinking") openThinkingBlock = block;
+				}
+			}
+			stream.push(event);
+		} },
+		beforeContentBlock: (nextType) => {
+			if (openThinkingBlock) finishBlock(openThinkingBlock);
+			if (openTextBlock && nextType !== "toolCall") finishBlock(openTextBlock);
+		},
+		finish(includeToolCalls) {
+			for (const block of output.content) if (block.type !== "toolCall" || includeToolCalls) finishBlock(block);
+		}
+	};
+}
+function createOpenAICompletionsTransportStreamFn() {
+	return (model, context, options) => streamOpenAICompletionsRequest(model, context, options, "managed");
+}
+function streamOpenAICompletionsRequest(model, context, options, mode) {
+	const { eventStream, stream } = createWritableTransportEventStream();
+	(async () => {
+		const output = createAssistantOutput(model);
+		const provisionalCommentaryTags = /* @__PURE__ */ new Map();
+		let firstEventAbort;
+		try {
+			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+			const directEmitReasoning = Boolean(mode === "direct" && model.reasoning && options?.reasoningEffort && isOpenAICompletionsThinkingEnabled(options.reasoningEffort));
+			const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+			const policy = mode === "direct" ? {
+				mode,
+				compat: resolveOpenAICompletionsCompat(model),
+				cacheRetention
+			} : { mode };
+			const { client, sawStreamDONE } = policy.mode === "direct" ? {
+				client: createDirectCompletionsClient(model, context, apiKey, resolveProviderSimpleCompletionHeaders(model, options), cacheRetention === "none" ? void 0 : options?.sessionId, policy.compat),
+				sawStreamDONE: void 0
+			} : createManagedCompletionsClient(model, context, options, apiKey, cacheRetention);
+			let params = buildOpenAICompletionsRequest(model, context, options, policy);
+			const encodeBody = prepareModelRequestBody(options);
+			const nextParams = await options?.onPayload?.(params, model);
+			if (nextParams !== void 0) params = nextParams;
+			if (mode === "managed") {
+				if (options?.openclawCodeModeToolSurface === true) {
+					const visibleToolNames = resolveCodeModeResponsesVisibleToolNames(context);
+					enforceCodeModeResponsesToolSurface(params, visibleToolNames, void 0, codeModeToolSurfaceObserver.get(options));
+					assertCodeModeResponsesToolSurface(params, visibleToolNames);
+				}
+				if (getCompat(model).requiresNonEmptyUserOrAssistantMessage) assertOpenAICompletionsPayloadHasConversationTurn(params, model);
+			}
+			const emitReasoning = mode === "direct" ? directEmitReasoning : shouldEmitOpenAICompletionsReasoning(model, options);
+			firstEventAbort = createFirstStreamEventAbortController(options?.signal);
+			const requestOptions = mode === "direct" ? {
+				...await encodeBody(params),
+				signal: firstEventAbort.signal,
+				...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
+				maxRetries: 0
+			} : {
+				...buildOpenAISdkRequestOptions(model, firstEventAbort.signal, { timeoutMs: options?.timeoutMs }),
+				...await encodeBody(params)
+			};
+			const { data: responseStream, response } = await client.chat.completions.create(params, requestOptions).withResponse();
+			const hookedResponseStream = withProviderResponseHook({
+				stream: responseStream,
+				signal: firstEventAbort.signal,
+				abort: firstEventAbort.abort,
+				hook: createOpenAIProviderAcceptanceHook(options, response, model),
+				onReady: () => stream.push({
+					type: "start",
+					partial: output
+				})
+			});
+			const directEvents = mode === "direct" ? createDirectCompletionsEventStream(output, stream) : void 0;
+			try {
+				await processCompletionsStream(hookedResponseStream, output, model, directEvents?.stream ?? stream, {
+					...directEvents ? {
+						mode: "direct",
+						beforeContentBlock: directEvents.beforeContentBlock,
+						provisionalCommentaryTags
+					} : { mode: "managed" },
+					signal: options?.signal,
+					emitReasoning,
+					strictReasoningTags: reasoningTagTextPolicy.isStrict(options),
+					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
+					abortFirstEventStream: firstEventAbort.abort,
+					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
+					sawStreamDONE
+				});
+				if (directEvents) {
+					if (options?.signal?.aborted) throw transportAbortError(options.signal);
+					if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage || (output.stopReason === "aborted" ? "Request was aborted" : "Provider returned an invalid tool call"));
+				}
+			} catch (error) {
+				directEvents?.finish(false);
+				throw error;
+			}
+			directEvents?.finish(output.stopReason === "toolUse");
+			finalizeTransportStream({
+				stream,
+				output,
+				signal: options?.signal
+			});
+		} catch (error) {
+			failTransportStream({
+				stream,
+				output,
+				signal: options?.signal,
+				error,
+				cleanup: () => {
+					if (mode === "managed") output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+					finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
+					clearPendingCommentaryText(provisionalCommentaryTags);
+					tagUnresolvedTextAsCommentary(output);
+					if (mode === "direct") for (const block of output.content) {
+						delete block.index;
+						delete block.partialArgs;
+						delete block.streamIndex;
+					}
+				}
+			});
+		} finally {
+			firstEventAbort?.dispose();
+		}
+	})();
+	return eventStream;
+}
+function createDirectCompletionsClient(model, context, apiKey, optionsHeaders, sessionId, compat) {
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+	const headers = { ...model.headers };
+	if (model.provider === "github-copilot") Object.assign(headers, buildCopilotDynamicHeaders(context.messages));
+	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;
+		}
+	}
+	return createOpenAIProviderClient(model, apiKey, headers, optionsHeaders);
+}
+function createManagedCompletionsClient(model, context, options, apiKey, cacheRetention) {
+	const turnState = resolveProviderTransportTurnState(model, {
+		sessionId: options?.sessionId,
+		turnId: randomUUID(),
+		attempt: 1,
+		transport: "stream"
+	});
+	const optionHeaders = resolveOpencodeSessionHeaders(model, options);
+	const turnHeaders = filterProviderTurnHeadersForExplicitOpencodeSession(model, options, turnState?.headers);
+	const doneDetector = createSseDoneDetector();
+	const baseFetch = buildGuardedModelFetch(model);
+	const doneDetectingFetch = async (url, init) => {
+		const response = await baseFetch(url, init);
+		if (!response.body || !response.ok) return response;
+		if (typeof TransformStream === "undefined" || !response.body.pipeThrough) return response;
+		const transformed = response.body.pipeThrough(new TransformStream({
+			transform(chunk, controller) {
+				doneDetector.observe(chunk);
+				controller.enqueue(chunk);
+			},
+			flush() {
+				doneDetector.finish();
+			}
+		}));
+		return new Response(transformed, {
+			headers: response.headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	};
+	const clientConfig = buildOpenAICompletionsClientConfig(model, buildOpenAIClientHeaders(model, context, {
+		...turnHeaders,
+		...optionHeaders
+	}, void 0, resolvePromptCacheKey(options, cacheRetention), cacheRetention));
+	return {
+		client: new OpenAI({
+			apiKey,
+			baseURL: clientConfig.baseURL,
+			dangerouslyAllowBrowser: true,
+			defaultHeaders: clientConfig.defaultHeaders,
+			defaultQuery: clientConfig.defaultQuery,
+			fetch: doneDetectingFetch,
+			...buildOpenAISdkClientOptions(model)
+		}),
+		sawStreamDONE: doneDetector.sawDone
+	};
+}
+//#endregion
+export { flattenCompletionMessagesToStringContent as a, hasOpenAICompatibleConversationTurn as c, createDeepSeekTextFilter as d, convertMessages as i, canonicalizeMaxTokensParam as l, streamOpenAICompletionsRequest as n, stripCompletionMessagesToRoleContent as o, buildOpenAICompletionsParams as r, applyCompletionsAnthropicCacheControl as s, createOpenAICompletionsTransportStreamFn as t, resolveMaxTokensParam as u };

package/dist/{openai-prompt-cache-CouErLh7.d.mts → openai-prompt-cache-45-AH_xv.d.mts}

@@ -1,5 +1,5 @@
-import { M as OpenAICompletionsCompat, O as Model, l as CacheRetention } from "./types-CLLR3eB4.mjs";
-import "./types-CB-_vNyI.mjs";
+import { N as OpenAICompletionsCompat, k as Model, l as CacheRetention } from "./types-DvzmWW8J.mjs";
+import "./types-BuiEBM3u.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-prompt-cache-BTMs80_O.mjs → openai-prompt-cache-I8YQTzf8.mjs}

@@ -1,4 +1,4 @@
-import { n as isNativeOpenAIEndpoint } from "./openai-completions-compat-BJf57ZxN.mjs";
+import { n as isNativeOpenAIEndpoint } from "./openai-completions-compat-BdmlhD4u.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) {

package/dist/{openai-responses-compaction-replay-DiYn-gFM.d.mts → openai-responses-compaction-replay-BClApUIf.d.mts}

@@ -1,7 +1,7 @@
-import "./index-D6KsSE74.mjs";
-import { O as Model, a as AssistantMessage } from "./types-CLLR3eB4.mjs";
-import "./provider-options-Df7ov0K1.mjs";
-import { i as ReplayableResponseCompactionItem, r as OpenAIResponsesReasoningReplayMetadata, s as OpenAIResponsesCompactionOutput } from "./openai-responses-contracts-D1iZ0njF.mjs";
+import "./index-a8e_oKnu.mjs";
+import { a as AssistantMessage, k as Model } from "./types-DvzmWW8J.mjs";
+import "./provider-options-D5ABCV_l.mjs";
+import { i as ReplayableResponseCompactionItem, l as OpenAIResponsesCompactionOutput, r as OpenAIResponsesReasoningReplayMetadata } from "./openai-responses-contracts-Br5IIw_h.mjs";
 import "openai/resources/responses/responses.js";
 //#region packages/ai/src/transports/openai-responses-compaction-replay.d.ts
 declare function captureOpenAIResponsesCompaction(output: Pick<AssistantMessage, "providerReplay">, item: ReplayableResponseCompactionItem, boundary: number | "retained-users", model: Model, captureMetadata?: OpenAIResponsesReasoningReplayMetadata, compactedOutput?: OpenAIResponsesCompactionOutput): void;