@openclaw/ai 2026.7.2-beta.7 → 2026.8.1-beta.1

package/dist/{openai-chatgpt-responses-B84Ibtrd.mjs → openai-chatgpt-responses-SC9m0FSf.mjs}

@@ -1,18 +1,17 @@
 import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
 import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-COpOtRwq.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-Dog2WQiR.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-CEV9t6da.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-Bl7Kgddo.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { d as stripSystemPromptCacheBoundary } from "./tool-result-text-CTpIRbYd.mjs";
-import { t as toErrorObject } from "./error-coercion-DgxlWC0n.mjs";
-import { n as clampTimerTimeoutMs, o as resolveTimerTimeoutMs } from "./number-coercion-DvG7SNMg.mjs";
+import { c as buildBaseOptions, h as stripSystemPromptCacheBoundary } from "./tool-result-text-Dvkp2Dus.mjs";
+import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-DDZPxRfr.mjs";
+import { B as responsesPromptObserver, n as processResponsesStream, pt as supportsOpenAITemperature, t as ResponsesStreamFailure } from "./openai-responses-stream-internal-Bl8YyVtF.mjs";
+import { n as clampTimerTimeoutMs, o as resolveTimerTimeoutMs } from "./number-coercion-1Miyb5MO.mjs";
 import { parseRetryAfterHttpDateMs } from "./internal/retry-after.mjs";
-import { d as transportAbortError } from "./transport-stream-shared-D81p90xq.mjs";
-import { _t as supportsOpenAITemperature, n as processResponsesStream } from "./openai-responses-stream-internal-Cw5txaGW.mjs";
-import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BBys9hSb.mjs";
+import { d as transportAbortError, f as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-stream-shared-CPNv7A3r.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BIBomOGq.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { n as buildBaseOptions } from "./simple-options-9lhRrN73.mjs";
-import { i as resolveResponsesReasoningEffort, n as convertResponsesMessages, o as convertResponsesToolPayload } from "./openai-responses-shared-pXl6Wd8S.mjs";
+import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, r as convertResponsesMessages, s as convertResponsesToolPayload } from "./openai-responses-shared-CCyMvg7M.mjs";
 import { i as registerSessionResourceCleanup, n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-DhAAzLkj.mjs";
 import { t as createSseByteGuard } from "./streaming-byte-guard-BrbkbwUu.mjs";
 import { t as inspectTlsCertificateError } from "./tls-certificate-errors-DXSpluKI.mjs";
@@ -116,29 +115,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 		let requestTimeoutSignal;
 		let activeSignal;
 		let firstEventAbort;
-		const output = {
-			role: "assistant",
-			content: [],
-			api: "openai-chatgpt-responses",
-			provider: model.provider,
-			model: model.id,
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			},
-			stopReason: "stop",
-			timestamp: Date.now()
-		};
+		const output = createResponsesAssistantOutput(model);
 		try {
 			const unresolvedApiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
 			if (!unresolvedApiKey) throw new Error(`No API key for provider: ${model.provider}`);
@@ -149,6 +126,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			let body = buildRequestBody(model, context, options);
 			const nextBody = await options?.onPayload?.(body, model);
 			if (nextBody !== void 0) body = nextBody;
+			const observePromptEgress = createResponsesPromptEgressObserver(options, context.systemPrompt);
 			const sessionId = clampOpenAIPromptCacheKey(options?.sessionId);
 			requestTimeoutMs = resolveRequestTimeoutMs(options);
 			requestTimeoutSignal = buildRequestSignal(options?.signal, requestTimeoutMs);
@@ -169,8 +147,9 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					try {
 						await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
 							websocketStarted = true;
-						}, requestOptions, firstEventAbort.abort);
+						}, requestOptions, firstEventAbort.abort, observePromptEgress);
 						if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+						if (output.stopReason === "aborted" || output.stopReason === "error") throw new CodexApiError(output.errorMessage ?? "An unknown error occurred");
 						stream.push({
 							type: "done",
 							reason: output.stopReason,
@@ -212,6 +191,10 @@ const streamOpenAICodexResponses = (model, context, options) => {
 				let attemptResponse;
 				let errorText;
 				try {
+					observePromptEgress?.(body, {
+						egress: "native-codex-sse",
+						payloadVariant: "initial"
+					});
 					attemptResponse = await fetch(resolveCodexUrl(model.baseUrl), {
 						method: "POST",
 						headers: sseHeaders,
@@ -254,6 +237,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			});
 			await processStream(response, output, stream, model, options, firstEventAbort.abort);
 			if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
 			stream.push({
 				type: "done",
 				reason: output.stopReason,
@@ -280,11 +264,12 @@ const streamOpenAICodexResponses = (model, context, options) => {
 const streamSimpleOpenAICodexResponses = (model, context, options) => {
 	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
-	const base = buildBaseOptions(model, options, apiKey);
-	return streamOpenAICodexResponses(model, context, {
-		...base,
+	const resolvedOptions = {
+		...buildBaseOptions(model, options, apiKey),
 		reasoningEffort: resolveResponsesReasoningEffort(model, options?.reasoning)
-	});
+	};
+	responsesPromptObserver.copy(options, resolvedOptions);
+	return streamOpenAICodexResponses(model, context, resolvedOptions);
 };
 function buildRequestBody(model, context, options) {
 	const messages = convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
@@ -299,21 +284,16 @@ function buildRequestBody(model, context, options) {
 		input: messages,
 		text: { verbosity: options?.textVerbosity || "low" },
 		include: ["reasoning.encrypted_content"],
-		prompt_cache_key: options?.cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId),
-		tool_choice: "auto",
-		parallel_tool_calls: true
+		prompt_cache_key: options?.cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId)
 	};
 	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) body.temperature = options.temperature;
 	if (options?.serviceTier !== void 0) body.service_tier = options.serviceTier;
 	if (context.tools) {
 		const converted = convertResponsesToolPayload(context.tools, { strict: null });
-		if (converted.projection.inputToolCount > 0 || converted.projection.diagnostics.length > 0) {
+		if (converted.tools.length > 0) {
 			body.tools = converted.tools;
-			if (body.tools.length === 0) {
-				delete body.tools;
-				delete body.tool_choice;
-				delete body.parallel_tool_calls;
-			}
+			body.tool_choice = "auto";
+			body.parallel_tool_calls = true;
 		}
 	}
 	if (options?.reasoningEffort !== void 0) {
@@ -325,22 +305,6 @@ function buildRequestBody(model, context, options) {
 	}
 	return body;
 }
-function getServiceTierCostMultiplier(model, serviceTier) {
-	switch (serviceTier) {
-		case "flex": return .5;
-		case "priority": return model.id === "gpt-5.5" ? 2.5 : 2;
-		default: return 1;
-	}
-}
-function applyServiceTierPricing(usage, serviceTier, model) {
-	const multiplier = getServiceTierCostMultiplier(model, serviceTier);
-	if (multiplier === 1) return;
-	usage.cost.input *= multiplier;
-	usage.cost.output *= multiplier;
-	usage.cost.cacheRead *= multiplier;
-	usage.cost.cacheWrite *= multiplier;
-	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-}
 function resolveCodexServiceTier(responseServiceTier, requestServiceTier) {
 	if (responseServiceTier === "default" && (requestServiceTier === "flex" || requestServiceTier === "priority")) return requestServiceTier;
 	return responseServiceTier ?? requestServiceTier;
@@ -365,7 +329,7 @@ async function processStream(response, output, stream, model, options, abortFirs
 		onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
 		signal: options?.signal,
 		resolveServiceTier: resolveCodexServiceTier,
-		applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
+		applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
 	});
 }
 var CodexApiError = class extends Error {
@@ -386,7 +350,7 @@ var CodexProtocolError = class extends Error {
 	}
 };
 function isCodexNonTransportError(error) {
-	return error instanceof CodexApiError || error instanceof CodexProtocolError;
+	return error instanceof CodexApiError || error instanceof CodexProtocolError || error instanceof ResponsesStreamFailure;
 }
 function isWebSocketConnectionLimitReachedError(error) {
 	return error instanceof CodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
@@ -409,15 +373,6 @@ async function* mapCodexEvents(events) {
 				payload: event
 			});
 		}
-		if (type === "response.failed") {
-			const response = event.response;
-			const code = response?.error?.code;
-			const message = response?.error?.message;
-			throw new CodexApiError(message || "Codex response failed", {
-				code,
-				payload: event
-			});
-		}
 		if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
 			const response = event.response;
 			const normalizedResponse = response ? {
@@ -426,7 +381,7 @@ async function* mapCodexEvents(events) {
 			} : response;
 			yield {
 				...event,
-				type: "response.completed",
+				type: type === "response.done" ? "response.completed" : type,
 				response: normalizedResponse
 			};
 			return;
@@ -450,26 +405,30 @@ async function* parseSSE(response) {
 	try {
 		while (true) {
 			const { done, value } = await guard.read();
-			if (done) break;
-			buffer += decoder.decode(value, { stream: true });
-			let idx = buffer.indexOf("\n\n");
-			while (idx !== -1) {
-				const chunk = buffer.slice(0, idx);
-				buffer = buffer.slice(idx + 2);
-				const dataLines = chunk.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim());
+			if (value) buffer += decoder.decode(value, { stream: true });
+			if (done) buffer += decoder.decode();
+			while (true) {
+				const searchable = !done && buffer.endsWith("\r") && !buffer.endsWith("\r\r") && !buffer.endsWith("\n\r") ? buffer.slice(0, -1) : buffer;
+				const boundary = /(?:\r\n|\r(?!\n)|\n)(?:\r\n|\r(?!\n)|\n)/.exec(searchable);
+				if (!boundary) break;
+				const chunk = buffer.slice(0, boundary.index);
+				buffer = buffer.slice(boundary.index + boundary[0].length);
+				const dataLines = chunk.split(/\r\n|\r|\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim());
 				if (dataLines.length > 0) {
 					const data = dataLines.join("\n").trim();
-					if (data && data !== "[DONE]") try {
-						yield JSON.parse(data);
-					} catch (cause) {
-						throw new CodexProtocolError(`Invalid Codex SSE JSON: ${formatThrownValue(cause)}`, {
-							cause,
-							payload: data
-						});
+					if (data && data !== "[DONE]") {
+						let event;
+						try {
+							event = JSON.parse(data);
+						} catch (cause) {
+							if (!(cause instanceof SyntaxError)) throw cause;
+							throw new CodexProtocolError(MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, { cause });
+						}
+						yield event;
 					}
 				}
-				idx = buffer.indexOf("\n\n");
 			}
+			if (done) break;
 		}
 	} finally {
 		try {
@@ -497,6 +456,7 @@ function closeOpenAICodexWebSocketSessions(sessionId) {
 		closeWebSocketSilently(entry.socket, 1e3, "debug_close");
 	};
 	if (sessionId) {
+		websocketSseFallbackSessions.delete(sessionId);
 		const entry = websocketSessionCache.get(sessionId);
 		if (entry) closeEntry(entry);
 		websocketSessionCache.delete(sessionId);
@@ -504,6 +464,7 @@ function closeOpenAICodexWebSocketSessions(sessionId) {
 	}
 	for (const entry of websocketSessionCache.values()) closeEntry(entry);
 	websocketSessionCache.clear();
+	websocketSseFallbackSessions.clear();
 }
 registerSessionResourceCleanup(closeOpenAICodexWebSocketSessions);
 function isWebSocketSseFallbackActive(sessionId) {
@@ -559,6 +520,13 @@ function closeWebSocketSilently(socket, code = 1e3, reason = "done") {
 function deleteOwnedWebSocketSession(sessionId, entry) {
 	if (websocketSessionCache.get(sessionId) === entry) websocketSessionCache.delete(sessionId);
 }
+function setOwnedWebSocketSession(sessionId, entry, expected) {
+	if (websocketSessionCache.get(sessionId) === expected) {
+		websocketSessionCache.set(sessionId, entry);
+		return true;
+	}
+	return false;
+}
 function scheduleSessionWebSocketExpiry(sessionId, entry) {
 	if (entry.idleTimer) clearTimeout(entry.idleTimer);
 	entry.idleTimer = setTimeout(() => {
@@ -639,6 +607,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 		};
 	}
 	const cached = websocketSessionCache.get(sessionId);
+	let expectedCacheValue = cached;
 	if (cached) {
 		if (cached.idleTimer) {
 			clearTimeout(cached.idleTimer);
@@ -646,7 +615,8 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 		}
 		if (!cached.busy && isWebSocketSessionExpired(cached)) {
 			closeWebSocketSilently(cached.socket, 1e3, "connection_age_limit");
-			websocketSessionCache.delete(sessionId);
+			deleteOwnedWebSocketSession(sessionId, cached);
+			expectedCacheValue = void 0;
 		} else if (!cached.busy && isWebSocketReusable(cached.socket)) {
 			cached.busy = true;
 			return {
@@ -674,7 +644,8 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 		}
 		if (!isWebSocketReusable(cached.socket)) {
 			closeWebSocketSilently(cached.socket);
-			websocketSessionCache.delete(sessionId);
+			deleteOwnedWebSocketSession(sessionId, cached);
+			expectedCacheValue = void 0;
 		}
 	}
 	const socket = await connectWebSocket(url, headers, signal);
@@ -683,12 +654,12 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 		busy: true,
 		createdAt: Date.now()
 	};
-	websocketSessionCache.set(sessionId, entry);
+	const ownsCache = setOwnedWebSocketSession(sessionId, entry, expectedCacheValue);
 	return {
 		socket,
-		entry,
+		entry: ownsCache ? entry : void 0,
 		release: ({ keep } = {}) => {
-			if (!keep || !isWebSocketReusable(entry.socket)) {
+			if (!ownsCache || !keep || !isWebSocketReusable(entry.socket)) {
 				closeWebSocketSilently(entry.socket);
 				if (entry.idleTimer) clearTimeout(entry.idleTimer);
 				deleteOwnedWebSocketSession(sessionId, entry);
@@ -728,19 +699,6 @@ function extractWebSocketCloseError(event) {
 	}
 	return /* @__PURE__ */ new Error("WebSocket closed");
 }
-async function decodeWebSocketData(data) {
-	if (typeof data === "string") return data;
-	if (data instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(data));
-	if (ArrayBuffer.isView(data)) {
-		const view = data;
-		return new TextDecoder().decode(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
-	}
-	if (data && typeof data === "object" && "arrayBuffer" in data) {
-		const arrayBuffer = await data.arrayBuffer();
-		return new TextDecoder().decode(new Uint8Array(arrayBuffer));
-	}
-	return null;
-}
 async function* parseWebSocket(socket, signal) {
 	const queue = [];
 	let pending = null;
@@ -754,29 +712,30 @@ async function* parseWebSocket(socket, signal) {
 		resolve();
 	};
 	const onMessage = (event) => {
-		(async () => {
-			let text = null;
-			try {
-				if (!event || typeof event !== "object" || !("data" in event)) return;
-				text = await decodeWebSocketData(event.data);
-				if (!text) return;
-				const parsed = JSON.parse(text);
-				const type = typeof parsed.type === "string" ? parsed.type : "";
-				if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
-					sawCompletion = true;
-					done = true;
-				}
-				queue.push(parsed);
-				wake();
-			} catch (cause) {
-				failed = new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, {
-					cause,
-					payload: text
-				});
+		const data = event && typeof event === "object" && "data" in event ? event.data : void 0;
+		if (typeof data !== "string") {
+			failed = new CodexProtocolError(MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, { payload: data });
+			done = true;
+			wake();
+			return;
+		}
+		try {
+			const parsed = JSON.parse(data);
+			const type = typeof parsed.type === "string" ? parsed.type : "";
+			if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
+				sawCompletion = true;
 				done = true;
-				wake();
 			}
-		})();
+			queue.push(parsed);
+			wake();
+		} catch (cause) {
+			failed = new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, {
+				cause,
+				payload: data
+			});
+			done = true;
+			wake();
+		}
 	};
 	const onError = (event) => {
 		failed = extractWebSocketError(event);
@@ -870,7 +829,7 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart
 		yield event;
 	}
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, options, abortFirstEventStream) {
+async function processWebSocketStream(url, body, headers, output, stream, model, onStart, options, abortFirstEventStream, observePromptEgress) {
 	const { socket, entry, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
 	let keepConnection = true;
 	const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
@@ -878,6 +837,10 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 	const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
 	try {
 		if (options?.signal?.aborted) throw transportAbortError(options.signal);
+		observePromptEgress?.(requestBody, {
+			egress: "native-codex-websocket",
+			payloadVariant: "initial"
+		});
 		socket.send(JSON.stringify({
 			type: "response.create",
 			...requestBody
@@ -889,7 +852,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 			onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
 			signal: options?.signal,
 			resolveServiceTier: resolveCodexServiceTier,
-			applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
+			applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
 		});
 		if (options?.signal?.aborted) keepConnection = false;
 		else if (useCachedContext && entry && output.responseId) {

package/dist/{openai-completions-DsOxhOD1.mjs → openai-completions-BaIpl93j.mjs}

@@ -1,21 +1,20 @@
 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-Dog2WQiR.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-CEV9t6da.mjs";
+import { n as getAiTransportHost } from "./host-Bl7Kgddo.mjs";
+import { r as clampThinkingLevel } from "./model-utils-Dau5dlgm.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { u as splitSystemPromptCacheBoundary } from "./tool-result-text-CTpIRbYd.mjs";
-import { n as reconcileOpenAICompletionsToolChoice, t as projectOpenAITools } from "./openai-tool-projection-OhX64DoP.mjs";
-import { c as calculateCost, l as clampThinkingLevel, s as applyProviderReportedUsageCost } from "./number-coercion-DvG7SNMg.mjs";
-import { a as resolveOpenAICompletionsCompat, c as clearPendingCommentaryText, l as rememberPendingCommentaryTags, n as mapOpenAIStopReason, o as resolveOpenAICompletionsResponseFormat, r as convertMessages, s as shouldOmitOllamaCompatResponseFormat, t as resolveOpenAIReasoningEffortMap, u as tagPendingCommentaryText } from "./openai-reasoning-compat-YgeLncHw.mjs";
+import { c as buildBaseOptions, m as splitSystemPromptCacheBoundary } from "./tool-result-text-Dvkp2Dus.mjs";
+import { a as convertMessages, c as resolveOpenAICompletionsResponseFormat, d as rememberPendingCommentaryTags, f as tagPendingCommentaryText, i as finalizeOpenAICompletionsToolCalls, l as shouldOmitOllamaCompatResponseFormat, n as mapOpenAIStopReason, r as createOpenAICompletionsToolCallDeltaNormalizer, s as resolveOpenAICompletionsCompat, t as resolveOpenAIReasoningEffortMap, u as clearPendingCommentaryText } from "./openai-reasoning-compat-DKebnIBL.mjs";
 import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { d as transportAbortError } from "./transport-stream-shared-D81p90xq.mjs";
+import { d as transportAbortError } from "./transport-stream-shared-CPNv7A3r.mjs";
+import { a as parseOpenAICompletionsUsage, l as projectOpenAITools, o as readOpenAICompletionsContentDeltas, r as isOpenAICompletionsThinkingEnabled, u as reconcileOpenAICompletionsToolChoice } from "./openai-transport-shared-Cipt7egQ.mjs";
 import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-CGDyLWUR.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BBys9hSb.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BIBomOGq.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { t as formatProviderError } from "./provider-error-CAEvRjry.mjs";
+import { t as formatProviderError } from "./provider-error-DI0Ts28U.mjs";
 import { i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-NCJtz9i0.mjs";
-import { n as buildBaseOptions } from "./simple-options-9lhRrN73.mjs";
 import OpenAI from "openai";
 //#region packages/ai/src/providers/openai-completions.ts
 var openai_completions_exports = /* @__PURE__ */ __exportAll({
@@ -100,6 +99,7 @@ const streamOpenAICompletions = (model, context, options) => {
 			const toolCallBlocksByIndex = /* @__PURE__ */ new Map();
 			const toolCallBlocksById = /* @__PURE__ */ new Map();
 			const toolCallBlocksByFirstId = /* @__PURE__ */ new Map();
+			const normalizeToolCallDeltas = createOpenAICompletionsToolCallDeltaNormalizer();
 			const pendingReasoningDetailsByToolCallId = /* @__PURE__ */ new Map();
 			const blocks = output.content;
 			const finishedBlocks = /* @__PURE__ */ new Set();
@@ -134,16 +134,12 @@ const streamOpenAICompletions = (model, context, options) => {
 					content: block.thinking,
 					partial: output
 				});
-				else if (block.type === "toolCall") {
-					delete block.partialArgs;
-					delete block.streamIndex;
-					stream.push({
-						type: "toolcall_end",
-						contentIndex,
-						toolCall: block,
-						partial: output
-					});
-				}
+				else if (block.type === "toolCall") stream.push({
+					type: "toolcall_end",
+					contentIndex,
+					toolCall: block,
+					partial: output
+				});
 			};
 			const ensureTextBlock = () => {
 				if (!textBlock) {
@@ -165,7 +161,7 @@ const streamOpenAICompletions = (model, context, options) => {
 					thinkingBlock = {
 						type: "thinking",
 						thinking: "",
-						thinkingSignature
+						...thinkingSignature ? { thinkingSignature } : {}
 					};
 					appendBlock(thinkingBlock);
 					stream.push({
@@ -258,26 +254,27 @@ const streamOpenAICompletions = (model, context, options) => {
 				notifyLlmRequestActivity(options?.signal);
 				output.responseId ||= chunk.id;
 				if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== model.id) output.responseModel ||= chunk.model;
-				if (chunk.usage) output.usage = parseChunkUsage(chunk.usage, model);
+				if (chunk.usage) output.usage = parseOpenAICompletionsUsage(chunk.usage, model, { includeReasoningTokens: false });
 				const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
 				if (!choice) continue;
 				const choiceUsage = choice.usage;
-				if (!chunk.usage && choiceUsage) output.usage = parseChunkUsage(choiceUsage, model);
+				if (!chunk.usage && choiceUsage) output.usage = parseOpenAICompletionsUsage(choiceUsage, model, { includeReasoningTokens: false });
 				if (choice.finish_reason) {
 					const finishReasonResult = mapOpenAIStopReason(choice.finish_reason);
 					output.stopReason = finishReasonResult.stopReason;
 					if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
 					hasFinishReason = true;
 				}
-				const choiceDelta = choice.delta ?? choice.message;
-				if (choiceDelta) {
+				const rawChoiceDelta = choice.delta ?? choice.message;
+				if (rawChoiceDelta) for (const normalizedDelta of normalizeToolCallDeltas(rawChoiceDelta, choice.finish_reason)) {
+					const choiceDelta = normalizedDelta.delta;
 					const reasoningFields = [
 						"reasoning_content",
 						"reasoning",
 						"reasoning_text"
 					];
 					const deltaFields = choiceDelta;
-					const shouldEmitReasoning = Boolean(model.reasoning && options?.reasoningEffort);
+					const shouldEmitReasoning = Boolean(model.reasoning && options?.reasoningEffort && isOpenAICompletionsThinkingEnabled(options.reasoningEffort));
 					let foundReasoningField = null;
 					for (const field of reasoningFields) {
 						const value = deltaFields[field];
@@ -291,14 +288,16 @@ const streamOpenAICompletions = (model, context, options) => {
 						const delta = deltaFields[foundReasoningField];
 						if (typeof delta === "string" && delta.length > 0) appendThinkingDelta(model.provider === "opencode-go" && foundReasoningField === "reasoning" ? "reasoning_content" : foundReasoningField, delta);
 					}
-					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 && choiceDelta.tool_calls.length > 0) {
+					for (const contentDelta of readOpenAICompletionsContentDeltas(choiceDelta.content, choiceDelta.refusal, foundReasoningField ? [deltaFields[foundReasoningField]] : [])) if (contentDelta.kind === "thinking") {
+						if (reasoningTagTextPartitioner.hasPending()) reasoningTagTextPartitioner.markStrict();
+						if (shouldEmitReasoning) appendThinkingDelta(contentDelta.signature, contentDelta.text);
+					} else appendPartitionedContent(contentDelta.text, Boolean(foundReasoningField));
+					const toolCallDeltas = normalizedDelta.toolCalls;
+					if (toolCallDeltas.length > 0) {
 						flushPartitionedContent();
 						sealNativeReasoningBeforeText();
 						rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
-						for (const toolCall of choiceDelta.tool_calls) {
+						for (const toolCall of toolCallDeltas) {
 							const block = ensureToolCallBlock(toolCall);
 							if (!block.id && toolCall.id) {
 								block.id = toolCall.id;
@@ -332,16 +331,21 @@ const streamOpenAICompletions = (model, context, options) => {
 				}
 			}
 			flushPartitionedContent();
-			for (const block of blocks) finishBlock(block);
-			if (options?.signal?.aborted) throw transportAbortError(options.signal);
-			if (output.stopReason === "aborted") throw new Error("Request was aborted");
-			if (output.stopReason === "error") throw new Error(output.errorMessage || "Provider returned an error stop reason");
-			if (!hasFinishReason) throw new Error("Stream ended without finish_reason");
-			const hasToolCalls = output.content.some((block) => block.type === "toolCall");
-			const hasVisibleText = output.content.some((block) => block.type === "text" && block.text.trim().length > 0);
-			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");
+			let terminalError;
+			if (options?.signal?.aborted) terminalError = transportAbortError(options.signal);
+			else if (output.stopReason === "aborted") terminalError = /* @__PURE__ */ new Error("Request was aborted");
+			else if (output.stopReason === "error") terminalError = new Error(output.errorMessage || "Provider returned an error stop reason");
+			else if (!hasFinishReason) terminalError = /* @__PURE__ */ new Error("Stream ended without finish_reason");
+			if (terminalError) {
+				for (const block of blocks) if (block.type !== "toolCall") finishBlock(block);
+				throw terminalError;
+			}
+			finalizeOpenAICompletionsToolCalls(output);
+			if (output.stopReason === "aborted" || output.stopReason === "error") {
+				for (const block of blocks) if (block.type !== "toolCall") finishBlock(block);
+				throw new Error(output.errorMessage || (output.stopReason === "aborted" ? "Request was aborted" : "Provider returned an invalid tool call"));
+			}
+			for (const block of blocks) if (block.type !== "toolCall" || output.stopReason === "toolUse") finishBlock(block);
 			if (output.stopReason !== "toolUse") clearPendingCommentaryText(provisionalCommentaryTags);
 			if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
 			stream.push({
@@ -351,12 +355,13 @@ const streamOpenAICompletions = (model, context, options) => {
 			});
 			stream.end();
 		} catch (error) {
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
 			for (const block of output.content) {
 				delete block.index;
 				delete block.partialArgs;
 				delete block.streamIndex;
 			}
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
 			output.errorMessage = formatProviderError(error);
 			const rawMetadata = error?.error?.metadata?.raw;
 			if (rawMetadata && !output.errorMessage.includes(rawMetadata)) output.errorMessage += `\n${rawMetadata}`;
@@ -602,29 +607,5 @@ function convertTools(tools, compat) {
 		}))
 	};
 }
-function parseChunkUsage(rawUsage, model) {
-	const promptTokens = rawUsage.prompt_tokens || 0;
-	const cacheReadTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
-	const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
-	const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
-	const outputTokens = rawUsage.completion_tokens || 0;
-	const usage = {
-		input,
-		output: outputTokens,
-		cacheRead: cacheReadTokens,
-		cacheWrite: cacheWriteTokens,
-		totalTokens: input + outputTokens + cacheReadTokens + cacheWriteTokens,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	};
-	calculateCost(model, usage);
-	applyProviderReportedUsageCost(usage, rawUsage.cost);
-	return usage;
-}
 //#endregion
 export { streamOpenAICompletions as n, streamSimpleOpenAICompletions as r, openai_completions_exports as t };