@openclaw/ai 2026.9.4 → 2026.9.5

package/dist/{openai-responses-shared-B8RdBPCv.mjs → openai-responses-shared-CwsziD_m.mjs}

@@ -1,23 +1,25 @@
+import { t as appendAssistantMessageDiagnostic } from "./diagnostics-CPeq9F7y.mjs";
 import { r as appendAssistantThinking } from "./event-stream-D8PARQfL.mjs";
 import { a as normalizeOptionalString } from "./string-coerce-fsri9iCu.mjs";
-import { M as clampThinkingLevel, _ as isImageWithMediaPayload, d as describeToolResultMediaPlaceholder, j as calculateCost, m as extractToolResultText, n as getAiTransportHost } from "./host-B8YfDGd4.mjs";
 import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { u as supportsOpenAITemperature } from "./openai-reasoning-effort-NlFZmfEu.mjs";
+import { _ as isImageWithMediaPayload, d as describeToolResultMediaPlaceholder, j as calculateCost, m as extractToolResultText, n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-B4MeUNBc.mjs";
 import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
-import { i as stableStringify } from "./provider-error-BA-v_tKd.mjs";
-import { a as resolveModelSseDebugMode, i as resolveModelPayloadDebugMode, r as emitModelTransportDebug } from "./diagnostics-QuErwCIl.mjs";
-import { r as asFiniteNumber } from "./base64-D-su8YVo.mjs";
-import { o as redactSensitiveText } from "./transport-utils-zrYjICLZ.mjs";
-import { s as transformTransportMessages } from "./host-policy-Zcg_cNz8.mjs";
-import { m as stripSystemPromptCacheBoundary, v as sortPromptCacheToolsByName } from "./simple-options-BQbb4yQL.mjs";
-import { O as redactIdentifier, _ as createOpenAIProviderAcceptanceHook, b as log, f as projectOpenAITools, g as createModelStreamCooperativeScheduler, k as sha256Hex, u as resolveOpenAIStrictToolFlagWithDiagnostics } from "./openai-transport-params-9aPuV5YY.mjs";
-import { E as parseStreamingJson, _ as sanitizeTransportPayloadText, b as withProviderResponseHook, g as sanitizeNonEmptyTransportPayloadText, h as parseTerminalToolCallArguments, k as shortHash, l as finalizeTransportStream, s as failTransportStream, t as IncompleteToolCallError, v as transportAbortError, w as createToolArgumentPreviewSchedule } from "./transport-stream-shared-zHll9BxO.mjs";
-import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-CJ_YvcEW.mjs";
+import { o as stableStringify } from "./provider-error-DDqw9Qda.mjs";
+import { a as resolveModelSseDebugMode, d as readResponsesReasoningTokens, f as resolveResponsesTerminalStopReason, i as resolveModelPayloadDebugMode, r as emitModelTransportDebug, u as mapResponsesTerminalUsage } from "./diagnostics-Dm4bisWG.mjs";
+import { o as redactSensitiveText } from "./transport-utils-1cyq5Y7x.mjs";
+import { s as transformTransportMessages } from "./host-policy-DUnXSx0I.mjs";
+import { m as stripSystemPromptCacheBoundary, v as sortPromptCacheToolsByName } from "./simple-options-C6cFWj_f.mjs";
+import { M as redactIdentifier, N as sha256Hex, b as createOpenAIProviderAcceptanceHook, d as prepareOpenAITools, h as resolveOpenAIRequestReasoning, u as resolveOpenAIStrictToolFlagWithDiagnostics, w as log, y as createModelStreamCooperativeScheduler } from "./openai-transport-params-DQeuAvBl.mjs";
+import { E as parseStreamingJson, _ as sanitizeTransportPayloadText, b as withProviderResponseHook, g as sanitizeNonEmptyTransportPayloadText, h as parseTerminalToolCallArguments, k as shortHash, l as finalizeTransportStream, s as failTransportStream, t as IncompleteToolCallError, v as transportAbortError, w as createToolArgumentPreviewSchedule, x as parseJsonObjectPreservingUnsafeIntegers } from "./transport-stream-shared-D-6FQSHm.mjs";
+import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-CnUSOwhr.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-2hfrquuz.mjs";
-import { t as transformProviderMessages } from "./provider-transcript-transform-V5YzU9zh.mjs";
-import { C as supportsOpenAITemperature, a as OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE, b as resolveOpenAIReasoningEffortForModel, c as OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE, f as RESPONSE_FAILED_NO_DETAILS_MESSAGE, o as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, s as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY, y as resolveOpenAIModelReasoningEfforts } from "./openai-responses-contracts-DDOHA62Y.mjs";
-import { a as resolveOpenAIProjectedToolsStrictToolFlag, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-CzjyYXun.mjs";
-import { n as isOpenAIResponsesCompactionOutput, r as readOpenAIResponsesCompactionWindow } from "./openai-responses-compaction-window-CIhBAkkq.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-C9ZadkJW.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform-BsRAhuWJ.mjs";
+import { a as resolveOpenAIProjectedToolsStrictToolFlag, f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-BO8rwyAD.mjs";
+import { a as OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE, c as OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE, f as RESPONSE_FAILED_NO_DETAILS_MESSAGE, o as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, p as isPreviousResponseRejection, s as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY } from "./openai-responses-contracts-DWrfMODE.mjs";
+import { n as isOpenAIResponsesCompactionOutput, r as readOpenAIResponsesCompactionWindow } from "./openai-responses-compaction-window-D6P5oZP5.mjs";
+import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
 import { createHash, randomUUID } from "node:crypto";
 //#region packages/ai/src/transports/openai-responses-replay.ts
 /** Resolves the assistant message id that can be replayed to OpenAI Responses. */
@@ -187,6 +189,199 @@ function buildOpenAIResponsesReasoningReplayMetadata(model, options) {
 	};
 }
 //#endregion
+//#region packages/ai/src/transports/openai-responses-reasoning-update.ts
+function isConfigurationUpdate(value) {
+	return isRecord(value) && value.type === "configuration_update" && isRecord(value.reasoning) && typeof value.reasoning.effort === "string";
+}
+function isResponsesReasoningUpdateCompatible(request) {
+	const mode = isRecord(request.reasoning) ? request.reasoning.mode : void 0;
+	return request.model === "gpt-6-astra" && (mode === void 0 || mode === "standard") && (!isRecord(request.multi_agent) || request.multi_agent.enabled !== true) && request.truncation !== "auto" && (!Array.isArray(request.context_management) || !request.context_management.some((item) => isRecord(item) && item.type === "compaction"));
+}
+function supportsResponsesReasoningUpdate(request) {
+	return isResponsesReasoningUpdateCompatible(request) && isRecord(request.reasoning) && typeof request.reasoning.effort === "string";
+}
+function canReferenceResponsesReasoningHistory(previous, request) {
+	return !previous.input?.some(isConfigurationUpdate) || isResponsesReasoningUpdateCompatible(request);
+}
+/** Rehydrate input controls only provisionally; continuation must validate the full prefix. */
+function replayResponsesReasoningUpdates(previous, request, previousOutputLength, steering) {
+	if (steering !== "required-input" && (!supportsResponsesReasoningUpdate(previous) || !supportsResponsesReasoningUpdate(request)) || !Array.isArray(previous.input) || !Array.isArray(request.input) || request.input.some(isConfigurationUpdate)) return request;
+	const input = [...request.input];
+	let activeEffort = isRecord(previous.reasoning) ? previous.reasoning.effort : void 0;
+	for (const [index, item] of previous.input.entries()) if (isConfigurationUpdate(item)) {
+		input.splice(index, 0, item);
+		activeEffort = item.reasoning.effort;
+	}
+	if (steering === "required-input") return input.length === request.input.length ? request : {
+		...request,
+		input
+	};
+	if (!isRecord(previous.reasoning) || !isRecord(request.reasoning) || typeof request.reasoning.effort !== "string") return request;
+	if (activeEffort !== request.reasoning.effort && steering !== "automatic") {
+		const baselineLength = previous.input.length + previousOutputLength;
+		const nextUser = input.findIndex((item, index) => index >= baselineLength && "role" in item && item.role === "user");
+		if (nextUser === -1) return request;
+		input.splice(nextUser, 0, {
+			type: "configuration_update",
+			reasoning: { effort: request.reasoning.effort }
+		});
+	}
+	if (input.length === request.input.length && activeEffort === request.reasoning.effort) return request;
+	return {
+		...request,
+		reasoning: {
+			...request.reasoning,
+			effort: previous.reasoning.effort
+		},
+		input
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-continuation.ts
+const HTTP_CONTINUATION_IDLE_TTL_MS = 3e5;
+const TURN_HEADERS = /* @__PURE__ */ new Set([
+	"traceparent",
+	"x-openclaw-turn-id",
+	"x-openclaw-turn-attempt"
+]);
+function jsonValuesEqual(left, right) {
+	const leftJson = JSON.stringify(left);
+	const normalizedLeft = stableStringify(JSON.parse(leftJson));
+	const rightJson = JSON.stringify(right);
+	return leftJson === rightJson || normalizedLeft === stableStringify(JSON.parse(rightJson));
+}
+function requestWithoutInput(request) {
+	const { input: _input, previous_response_id: _previousResponseId, instructions: _instructions, tools: _tools, ...rest } = request;
+	if (!isRecord(rest.metadata)) return rest;
+	const metadata = Object.fromEntries(Object.entries(rest.metadata).filter(([key]) => key !== "openclaw_turn_id" && key !== "openclaw_turn_attempt"));
+	return {
+		...rest,
+		metadata
+	};
+}
+function normalizeAssistantReplayInput(input, fromResponse = false) {
+	return input.map((item) => {
+		if (!isRecord(item)) return item;
+		if (item.type === "reasoning") return { type: "reasoning" };
+		if (item.type !== "function_call" && !(item.type === "message" && item.role === "assistant")) return item;
+		const { id: _id, status: _status, ...stableItem } = item;
+		if (fromResponse && item.type === "function_call") {
+			const args = parseJsonObjectPreservingUnsafeIntegers(stableItem.arguments);
+			stableItem.arguments = args ? JSON.stringify(args) : stableItem.arguments;
+		}
+		if (item.type === "message" && Array.isArray(stableItem.content)) stableItem.content = stableItem.content.map((part) => {
+			if (!isRecord(part) || part.type !== "output_text") return part;
+			const { annotations: _annotations, logprobs: _logprobs, ...stablePart } = part;
+			return stablePart;
+		});
+		return stableItem;
+	});
+}
+function responsesContinuationRequestFingerprint(request) {
+	const serialized = JSON.stringify(requestWithoutInput(request));
+	return sha256Hex(stableStringify(JSON.parse(serialized)));
+}
+function responsesContinuationPrefixFingerprint(input, output = []) {
+	const serialized = JSON.stringify([...normalizeAssistantReplayInput(input), ...normalizeAssistantReplayInput(output, true)]);
+	return sha256Hex(stableStringify(JSON.parse(serialized)));
+}
+function resolveResponsesContinuationRequest(continuation, request, steering) {
+	if (!continuation) return {
+		request,
+		continuationStatus: "no_previous_response"
+	};
+	if (request.previous_response_id) return {
+		request,
+		continuationStatus: "explicit_previous_response_id"
+	};
+	if (!canReferenceResponsesReasoningHistory(continuation.lastRequest, request)) return {
+		request,
+		continuationStatus: "request_changed"
+	};
+	const prepared = replayResponsesReasoningUpdates(continuation.lastRequest, request, continuation.lastResponseItems.length, steering);
+	if (steering !== "required-input" && !jsonValuesEqual(requestWithoutInput(prepared), requestWithoutInput(continuation.lastRequest))) return {
+		request,
+		continuationStatus: "request_changed"
+	};
+	const currentInput = prepared.input ?? [];
+	const previousInput = continuation.lastRequest.input ?? [];
+	const baselineLength = previousInput.length + continuation.lastResponseItems.length;
+	if (currentInput.length < baselineLength) return {
+		request,
+		continuationStatus: "history_shorter"
+	};
+	if (!jsonValuesEqual(normalizeAssistantReplayInput(currentInput.slice(0, previousInput.length)), normalizeAssistantReplayInput(previousInput)) || !jsonValuesEqual(normalizeAssistantReplayInput(currentInput.slice(previousInput.length, baselineLength)), normalizeAssistantReplayInput(continuation.lastResponseItems, true))) return {
+		request,
+		continuationStatus: "history_changed"
+	};
+	return {
+		request: {
+			...prepared,
+			previous_response_id: continuation.lastResponseId,
+			input: currentInput.slice(baselineLength)
+		},
+		...prepared !== request ? { fullRequest: prepared } : {},
+		continuationStatus: "continued"
+	};
+}
+const httpContinuationEntries = /* @__PURE__ */ new Map();
+function deleteHttpContinuationIfOwned(key, entry) {
+	if (httpContinuationEntries.get(key) === entry) httpContinuationEntries.delete(key);
+}
+function connectionIdentity(params) {
+	const headers = Object.entries(resolveAiTransportHeaderSentinels(params.headers) ?? {}).map(([name, value]) => [name.toLowerCase(), value]).filter(([name]) => !TURN_HEADERS.has(name)).toSorted(([a], [b]) => a.localeCompare(b));
+	return sha256Hex(JSON.stringify([
+		getAiTransportHost().resolveSecretSentinel(params.apiKey),
+		params.baseUrl,
+		headers
+	]));
+}
+function claimOpenAIResponsesHttpContinuation(params) {
+	const key = `${params.sessionId}\0${connectionIdentity(params)}`;
+	const previous = httpContinuationEntries.get(key);
+	if (previous?.kind === "claimed") return;
+	if (previous?.kind === "ready") clearTimeout(previous.idleTimer);
+	const claimed = {
+		kind: "claimed",
+		sessionId: params.sessionId
+	};
+	httpContinuationEntries.set(key, claimed);
+	try {
+		const request = previous?.kind === "ready" ? params.request : params.restoreRequest?.() ?? params.request;
+		const resolved = resolveResponsesContinuationRequest(previous?.kind === "ready" ? previous.state : void 0, request);
+		const fullRequest = resolved.fullRequest ?? request;
+		return {
+			request: params.request.store === false ? fullRequest : resolved.request,
+			fullRequest,
+			commit: (effectiveRequest, response) => {
+				if (httpContinuationEntries.get(key) !== claimed) return;
+				const ready = {
+					...claimed,
+					kind: "ready",
+					state: {
+						lastRequest: effectiveRequest,
+						lastResponseId: response.id,
+						lastResponseItems: response.output
+					},
+					idleTimer: setTimeout(() => deleteHttpContinuationIfOwned(key, ready), HTTP_CONTINUATION_IDLE_TTL_MS)
+				};
+				ready.idleTimer.unref?.();
+				httpContinuationEntries.set(key, ready);
+			},
+			release: () => deleteHttpContinuationIfOwned(key, claimed)
+		};
+	} catch (error) {
+		deleteHttpContinuationIfOwned(key, claimed);
+		throw error;
+	}
+}
+registerSessionResourceCleanup((sessionId) => {
+	for (const [key, entry] of httpContinuationEntries) if (!sessionId || entry.sessionId === sessionId) {
+		if (entry.kind === "ready") clearTimeout(entry.idleTimer);
+		httpContinuationEntries.delete(key);
+	}
+});
+//#endregion
 //#region packages/ai/src/transports/openai-responses-input-replay.ts
 function recordResponsesInputReplay(message, replay) {
 	if (replay) Object.assign(message, { openclawResponsesInputReplay: replay });
@@ -605,6 +800,83 @@ function convertProviderResponsesMessages(model, context, allowedToolCallProvide
 	return convertResponsesMessagesWithStyle(model, context, allowedToolCallProviders, options, "provider");
 }
 //#endregion
+//#region packages/ai/src/transports/openai-responses-context-usage.ts
+const TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
+	"openai",
+	"opencode",
+	"azure-openai-responses",
+	"github-copilot"
+]);
+function inputReplay(message) {
+	const value = "openclawResponsesInputReplay" in message ? message.openclawResponsesInputReplay : void 0;
+	return isRecord(value) ? value : void 0;
+}
+function contextFingerprint(input, output = []) {
+	const reasoning = [...input, ...output].flatMap((item) => {
+		if (!isRecord(item) || item.type !== "reasoning") return [];
+		const { id: _id, status: _status, ...content } = item;
+		return [content];
+	});
+	return sha256Hex(stableStringify({
+		prefix: responsesContinuationPrefixFingerprint(input, output),
+		reasoning
+	}));
+}
+/** Bind measured usage to the admitted replay prefix, without copying its content. */
+function recordResponsesContextUsage(message, model, identity, request, output, projection) {
+	const usage = message.usage.contextUsage;
+	if (usage?.state !== "available" || !Number.isSafeInteger(usage.totalTokens) || usage.totalTokens <= 0 || message.stopReason === "error" || message.stopReason === "aborted" || message.providerReplay || request.previous_response_id || !Array.isArray(request.input) || !request.input.some((item) => isRecord(item) && item.type === "compaction") || !Array.isArray(output) || output.some((item) => isRecord(item) && item.type === "compaction")) return;
+	const replayOutput = (projection === "transport" ? convertResponsesMessages$1 : convertProviderResponsesMessages)(model, { messages: [message] }, TOOL_CALL_PROVIDERS, {
+		...identity,
+		includeSystemPrompt: false
+	}).filter((item) => item.type !== "function_call_output");
+	const firstInput = request.input[0];
+	const contextUsage = {
+		...buildProviderReplayContext(model, identity),
+		projection,
+		includeSystemPrompt: request.instructions === void 0 && firstInput?.type === "message" && (firstInput.role === "developer" || firstInput.role === "system"),
+		prefixHash: contextFingerprint(request.input, replayOutput),
+		prefixLength: request.input.length + replayOutput.length,
+		promptTokens: usage.promptTokens,
+		totalTokens: usage.totalTokens
+	};
+	Object.assign(message, { openclawResponsesInputReplay: {
+		...inputReplay(message),
+		contextUsage
+	} });
+}
+/** Only matching provider input may replace the conservative local pressure estimate. */
+function resolveResponsesContextUsageBoundary(messages, model, identity, systemPrompt) {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (!message || !isAssistant(message)) continue;
+		const state = inputReplay(message)?.contextUsage;
+		const usage = message.usage.contextUsage;
+		if (!isRecord(state) || usage?.state !== "available") continue;
+		const { projection, prefixHash, prefixLength, promptTokens, totalTokens, includeSystemPrompt } = state;
+		if (!isOpenAIResponsesReplayContext(state) || !providerReplayContextMatches(state, buildProviderReplayContext(model, identity)) || message.provider !== model.provider || message.api !== model.api || message.model !== model.id || projection !== "transport" && projection !== "provider" || typeof prefixHash !== "string" || typeof prefixLength !== "number" || !Number.isSafeInteger(prefixLength) || prefixLength <= 0 || promptTokens !== usage.promptTokens || totalTokens !== usage.totalTokens || !Number.isSafeInteger(usage.totalTokens) || usage.totalTokens <= 0) return;
+		const input = (projection === "transport" ? convertResponsesMessages$1 : convertProviderResponsesMessages)(model, {
+			messages: messages.filter(isProviderMessage),
+			systemPrompt
+		}, TOOL_CALL_PROVIDERS, {
+			...identity,
+			includeSystemPrompt: includeSystemPrompt === true
+		});
+		if (input.length < prefixLength || contextFingerprint(input.slice(0, prefixLength)) !== prefixHash) return;
+		return {
+			index,
+			totalTokens: usage.totalTokens,
+			suffix: input.slice(prefixLength)
+		};
+	}
+}
+function isAssistant(message) {
+	return message.role === "assistant";
+}
+function isProviderMessage(message) {
+	return message.role === "user" || message.role === "assistant" || message.role === "toolResult";
+}
+//#endregion
 //#region packages/ai/src/transports/openai-responses-replay-internal.ts
 function isAsyncIterable(value) {
 	return (typeof value === "object" && value !== null || typeof value === "function") && Symbol.asyncIterator in value;
@@ -691,7 +963,7 @@ async function createResponsesStreamWithEncryptedContentRetry(params) {
 				};
 			} catch (error) {
 				let nextAttempt = await resolveNextResponsesEncryptedContentAttempt(attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest });
-				if (!nextAttempt && attempt.request.previous_response_id && error && typeof error === "object" && typeof error.status === "number" && error.code === "previous_response_not_found") {
+				if (!nextAttempt && attempt.request.previous_response_id && error && typeof error === "object" && typeof error.status === "number" && isPreviousResponseRejection(error)) {
 					const request = { ...params.buildFullHistoryRequest ? await params.buildFullHistoryRequest() : attempt.request };
 					delete request.previous_response_id;
 					nextAttempt = {
@@ -711,43 +983,40 @@ async function createResponsesStreamWithEncryptedContentRetry(params) {
 		request: params.request,
 		...params.initialRejectedCompaction ? { rejectedCompaction: params.initialRejectedCompaction } : {}
 	});
-	return {
-		...result,
-		stream: { async *[Symbol.asyncIterator]() {
-			let current = result;
-			for (;;) {
-				let rejectedEvent;
-				try {
-					for await (const event of params.wrapStream?.(current) ?? current.stream) {
-						if (isRecord(event)) {
-							const failure = event.type === "response.failed" && isRecord(event.response) ? event.response.error : event.type === "error" ? event.error ?? event : void 0;
-							if (isRecord(failure) && params.canRetryStream?.() === true && isInvalidEncryptedContentError(failure)) {
-								rejectedEvent = event;
-								const message = typeof failure.message === "string" ? failure.message : "";
-								throw Object.assign(new Error(message), {
-									code: failure.code,
-									status: failure.status
-								});
-							}
+	return { stream: { async *[Symbol.asyncIterator]() {
+		let current = result;
+		for (;;) {
+			let rejectedEvent;
+			try {
+				for await (const event of params.wrapStream?.(current) ?? current.stream) {
+					if (isRecord(event)) {
+						const failure = event.type === "response.failed" && isRecord(event.response) ? event.response.error : event.type === "error" ? event.error ?? event : void 0;
+						if (isRecord(failure) && params.canRetryStream?.() === true && isInvalidEncryptedContentError(failure)) {
+							rejectedEvent = event;
+							const message = typeof failure.message === "string" ? failure.message : "";
+							throw Object.assign(new Error(message), {
+								code: failure.code,
+								status: failure.status
+							});
 						}
-						yield event;
 					}
-					return;
-				} catch (error) {
-					const nextAttempt = params.canRetryStream?.() === true && !params.requestOptions?.signal?.aborted ? await resolveNextResponsesEncryptedContentAttempt(current.attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest }) : void 0;
-					if (!nextAttempt) {
-						if (rejectedEvent !== void 0) {
-							yield rejectedEvent;
-							return;
-						}
-						throw error;
+					yield event;
+				}
+				return;
+			} catch (error) {
+				const nextAttempt = params.canRetryStream?.() === true && !params.requestOptions?.signal?.aborted ? await resolveNextResponsesEncryptedContentAttempt(current.attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest }) : void 0;
+				if (!nextAttempt) {
+					if (rejectedEvent !== void 0) {
+						yield rejectedEvent;
+						return;
 					}
-					log.warn(`[responses] retrying streamed encrypted content provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
-					current = await send(nextAttempt);
+					throw error;
 				}
+				log.warn(`[responses] retrying streamed encrypted content provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
+				current = await send(nextAttempt);
 			}
-		} }
-	};
+		}
+	} } };
 }
 function resolveAzureOpenAIApiVersion(env = process.env) {
 	return env.AZURE_OPENAI_API_VERSION?.trim() || "preview";
@@ -1288,86 +1557,6 @@ function createResponsesOutputSlotTracker() {
 	};
 }
 //#endregion
-//#region packages/ai/src/providers/openai-responses-terminal-usage.ts
-/**
-* Canonical mapping for terminal OpenAI Responses events.
-*
-* `response.completed`, `response.incomplete`, and `response.failed` are terminal and can carry
-* usage, so every Responses path finalizes through the helpers here. Keeping one owner prevents
-* package and managed transports from drifting on token buckets, service-tier pricing, or future
-* terminal-event semantics.
-*/
-function readReportedCount(value) {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
-}
-function readCount(value) {
-	return readReportedCount(value) ?? 0;
-}
-/**
-* Split a terminal usage payload into the priced buckets.
-*
-* OpenAI includes cache reads and writes in `input_tokens`, so both are subtracted out of the
-* billable input bucket. `total_tokens` comes from the payload, but never below the sum of the
-* split buckets: proxies routinely omit it (reporting 0 would understate the turn), and a payload
-* whose `cached_tokens` exceeds `input_tokens` clamps the input bucket, leaving the reported total
-* short of what the buckets actually price.
-*/
-function mapResponsesTerminalUsage(usage) {
-	if (!usage) return;
-	const cacheRead = readCount(usage.input_tokens_details?.cached_tokens);
-	const cacheWrite = readCount(usage.input_tokens_details?.cache_write_tokens);
-	const input = Math.max(0, readCount(usage.input_tokens) - cacheRead - cacheWrite);
-	const output = readCount(usage.output_tokens);
-	const bucketTotal = input + output + cacheRead + cacheWrite;
-	const totalTokens = Math.max(bucketTotal, readCount(usage.total_tokens));
-	const reportedInput = readReportedCount(usage.input_tokens);
-	const reportedOutput = readReportedCount(usage.output_tokens);
-	const reportedTotal = readReportedCount(usage.total_tokens);
-	return {
-		input,
-		output,
-		cacheRead,
-		cacheWrite,
-		contextUsage: reportedInput !== void 0 && (reportedOutput !== void 0 || reportedTotal !== void 0 && reportedTotal >= reportedInput) && cacheRead + cacheWrite <= reportedInput ? {
-			state: "available",
-			promptTokens: reportedInput,
-			totalTokens: Math.max(totalTokens, reportedInput + (reportedOutput ?? 0))
-		} : { state: "unavailable" },
-		totalTokens
-	};
-}
-/** Reasoning tokens are reported by the agent path only; the package path does not track them. */
-function readResponsesReasoningTokens(usage) {
-	return asFiniteNumber(usage?.output_tokens_details?.reasoning_tokens);
-}
-function mapResponsesTerminalStopReason(status) {
-	if (!status) return "stop";
-	switch (status) {
-		case "completed": return "stop";
-		case "incomplete": return "length";
-		case "failed":
-		case "cancelled": return "error";
-		case "in_progress":
-		case "queued": return "stop";
-		default: throw new Error(`Unhandled stop reason: ${String(status)}`);
-	}
-}
-/**
-* Resolve the terminal stop reason, including the two overrides every Responses path shares: a
-* content-filtered turn is a provider error rather than a truncated answer, and a turn that
-* produced tool calls reports `toolUse` instead of a plain stop.
-*/
-function resolveResponsesTerminalStopReason(params) {
-	const status = params.status ?? (params.terminalEventType === "response.incomplete" ? "incomplete" : void 0);
-	if (status === "incomplete" && params.incompleteReason === "content_filter") return {
-		stopReason: "error",
-		errorMessage: "Provider incomplete_reason: content_filter"
-	};
-	const stopReason = mapResponsesTerminalStopReason(status);
-	if (stopReason === "stop" && params.hasToolCall) return { stopReason: "toolUse" };
-	return { stopReason };
-}
-//#endregion
 //#region packages/ai/src/transports/openai-responses-stream-terminal-internal.ts
 function splitToolCallId(id) {
 	const separator = id.indexOf("|");
@@ -1561,7 +1750,7 @@ function createResponsesTerminalController(params) {
 	};
 	const finalizeTerminalFacts = (response, responseId = response.id) => {
 		output.responseId = responseId || output.responseId;
-		output.responseModel = response.model?.trim() || void 0;
+		output.responseModel = options?.resolveResponseModel ? options.resolveResponseModel()?.trim() || void 0 : response.model?.trim() || void 0;
 		const usage = mapResponsesTerminalUsage(response.usage);
 		const reasoningTokens = readResponsesReasoningTokens(response.usage);
 		if (usage) output.usage = {
@@ -1592,6 +1781,17 @@ function createResponsesTerminalController(params) {
 		});
 		output.stopReason = terminal.stopReason;
 		output.errorMessage = terminal.errorMessage;
+		if (terminalEventType === "response.completed" && typeof response.end_turn === "boolean") output.endTurn = response.end_turn;
+		const incompleteReason = response.incomplete_details?.reason;
+		appendAssistantMessageDiagnostic(output, {
+			type: "openai_responses_terminal",
+			timestamp: Date.now(),
+			details: {
+				eventType: terminalEventType,
+				...terminalEventType === "response.incomplete" ? { incompleteReason: incompleteReason === "max_output_tokens" || incompleteReason === "max_messages" || incompleteReason === "content_filter" || incompleteReason === "steered" ? incompleteReason : "unknown" } : {},
+				endTurn: typeof response.end_turn === "boolean" ? response.end_turn : response.end_turn === void 0 ? "absent" : "invalid"
+			}
+		});
 	};
 	return {
 		finalizeResponse,
@@ -1807,6 +2007,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 						block: toolCallBlock,
 						contentIndex,
 						argumentStreamReliable: true,
+						argumentsStreamed: false,
 						previewSchedule: createToolArgumentPreviewSchedule(),
 						...readResponsesToolCallItemIdentity(item)
 					};
@@ -1900,6 +2101,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				const toolCall = streamingToolCalls.resolve(event);
 				if (toolCall) {
 					toolCall.block.partialJson += event.delta;
+					toolCall.argumentsStreamed = true;
 					if (toolCall.previewSchedule(toolCall.block.partialJson.length)) toolCall.block.arguments = parseStreamingJson(toolCall.block.partialJson);
 					stream.push({
 						type: "toolcall_delta",
@@ -1917,6 +2119,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 						toolCall.block.partialJson = doneArguments;
 						toolCall.block.arguments = parseStreamingJson(toolCall.block.partialJson);
 						toolCall.argumentStreamReliable = true;
+						toolCall.argumentsStreamed = true;
 					}
 					if (doneArguments?.startsWith(previousPartialJson)) {
 						const delta = doneArguments.slice(previousPartialJson.length);
@@ -2012,9 +2215,11 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 					if (!streamingToolCall && streamingToolCalls.hasActive()) continue;
 					const completedArguments = typeof item.arguments === "string" ? item.arguments : void 0;
 					if (streamingToolCall && !streamingToolCall.argumentStreamReliable && !completedArguments) continue;
+					const streamedArguments = streamingToolCall?.block.partialJson || "";
+					const preferredArguments = streamingToolCall?.argumentStreamReliable && streamingToolCall?.argumentsStreamed && streamedArguments.length > 0 && completedArguments !== void 0 && streamedArguments !== completedArguments && parseJsonObjectPreservingUnsafeIntegers(streamedArguments) !== null ? streamedArguments : completedArguments || streamedArguments;
 					const validated = resolveCompletedResponsesToolCall(item, {
 						name: streamingToolCall?.block.name,
-						arguments: completedArguments || streamingToolCall?.block.partialJson || ""
+						arguments: preferredArguments
 					});
 					finalizeToolCall(item, readResponsesOutputIndex(event), streamingToolCall, validated);
 				}
@@ -2055,23 +2260,33 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 //#region packages/ai/src/providers/openai-responses-tools.ts
 /** Projects direct provider descriptors before resolving their strict policy. */
 function convertResponsesToolPayload(tools, options) {
-	return convertProjectedResponsesTools(projectOpenAITools(tools), resolveResponsesStrictToolSetting(options), options?.model);
-}
-/** Uses caller-prepared facts without rereading descriptors or resolving host policy again. */
-function convertProjectedResponsesTools(projection, strictSetting, model) {
-	const strict = model ? resolveOpenAIStrictToolFlagWithDiagnostics(projection, strictSetting, {
-		transport: "responses",
-		model
-	}) : resolveOpenAIProjectedToolsStrictToolFlag(projection, strictSetting);
-	return sortPromptCacheToolsByName(projection.tools).map((tool) => {
-		const result = {
-			type: "function",
-			name: tool.name,
-			description: tool.description,
-			parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model?.compat)
-		};
-		if (strict !== void 0) result.strict = strict;
-		return result;
+	return convertPreparedResponsesTools(prepareOpenAITools(tools), resolveResponsesStrictToolSetting(options), options?.model);
+}
+/** The transport has already resolved policy before descriptor projection. */
+function prepareResponsesTools(tools, strictSetting, model) {
+	const prepared = prepareOpenAITools(tools);
+	return {
+		projection: prepared.projection,
+		tools: convertPreparedResponsesTools(prepared, strictSetting, model)
+	};
+}
+function convertPreparedResponsesTools(prepared, strictSetting, model) {
+	const { projection, schemas } = prepared;
+	return withPreparedToolSchemaNormalization(schemas, () => {
+		const strict = model ? resolveOpenAIStrictToolFlagWithDiagnostics(projection, strictSetting, {
+			transport: "responses",
+			model
+		}) : resolveOpenAIProjectedToolsStrictToolFlag(projection, strictSetting);
+		return sortPromptCacheToolsByName(projection.tools).map((tool) => {
+			const result = {
+				type: "function",
+				name: tool.name,
+				description: tool.description,
+				parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model?.compat)
+			};
+			if (strict !== void 0) result.strict = strict;
+			return result;
+		});
 	});
 }
 function resolveResponsesStrictToolSetting(options) {
@@ -2099,19 +2314,6 @@ function applyResponsesServiceTierPricing(usage, serviceTier, model) {
 	usage.cost.cacheWrite *= multiplier;
 	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
 }
-function resolveResponsesReasoningEffort(model, reasoning) {
-	if (!reasoning) return;
-	const clampedReasoning = model.reasoning && model.thinkingLevelMap?.[reasoning] === void 0 && resolveOpenAIModelReasoningEfforts(model)?.includes(reasoning) ? reasoning : clampThinkingLevel(model, reasoning);
-	return clampedReasoning === "off" ? void 0 : clampedReasoning;
-}
-function resolveResponsesRequestReasoningEffort(model, reasoning) {
-	const mapped = model.thinkingLevelMap?.[reasoning === "none" ? "off" : reasoning];
-	if (mapped !== void 0) return mapped ?? void 0;
-	return resolveOpenAIModelReasoningEfforts(model) === void 0 ? reasoning === "off" ? "none" : reasoning : resolveOpenAIReasoningEffortForModel({
-		model,
-		effort: reasoning
-	});
-}
 function applyCommonResponsesParams(params, model, context, options, config) {
 	if (options?.maxTokens) params.max_output_tokens = Math.max(options.maxTokens, 16);
 	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
@@ -2121,10 +2323,10 @@ function applyCommonResponsesParams(params, model, context, options, config) {
 	}
 	if (!model.reasoning) return;
 	const requestedEffort = options?.reasoningEffort ?? (options?.reasoningSummary ? "medium" : config?.setDefaultReasoningOff ?? true ? "off" : void 0);
-	const effort = requestedEffort === void 0 ? void 0 : resolveResponsesRequestReasoningEffort(model, requestedEffort);
+	const effort = requestedEffort === void 0 ? void 0 : resolveOpenAIRequestReasoning(model, requestedEffort).effort;
 	if (effort === void 0) return;
 	params.reasoning = { effort };
-	if (options?.reasoningEffort || options?.reasoningSummary) {
+	if (effort !== "none" && (options?.reasoningEffort || options?.reasoningSummary)) {
 		params.reasoning.summary = options?.reasoningSummary || "auto";
 		params.include = ["reasoning.encrypted_content"];
 	}
@@ -2158,6 +2360,7 @@ async function runResponsesStreamLifecycle(params) {
 		const firstEvent = createFirstStreamEventAbortController(options?.signal);
 		firstEventAbort = firstEvent;
 		let started = false;
+		let admittedRequest;
 		const { stream: hookedOpenAIStream } = await createResponsesStreamWithEncryptedContentRetry({
 			client,
 			request: requestParams,
@@ -2169,25 +2372,28 @@ async function runResponsesStreamLifecycle(params) {
 			buildFullHistoryRequest: () => buildRequest("full-history"),
 			onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, options, checkpoint),
 			canRetryStream: () => output.content.length === 0,
-			wrapStream: ({ stream: openaiStream, response }) => withProviderResponseHook({
-				stream: openaiStream,
-				signal: firstEvent.signal,
-				abort: firstEvent.abort,
-				hook: createOpenAIProviderAcceptanceHook(options, response, model),
-				onReady: () => {
-					if (!started) {
-						started = true;
-						stream.push({
-							type: "start",
-							partial: output
-						});
+			wrapStream: ({ stream: openaiStream, response, attempt }) => {
+				admittedRequest = attempt.kind === "initial" ? attempt.request : void 0;
+				return withProviderResponseHook({
+					stream: openaiStream,
+					signal: firstEvent.signal,
+					abort: firstEvent.abort,
+					hook: createOpenAIProviderAcceptanceHook(options, response, model),
+					onReady: () => {
+						if (!started) {
+							started = true;
+							stream.push({
+								type: "start",
+								partial: output
+							});
+						}
 					}
-				}
-			})
+				});
+			}
 		});
 		const firstEventTimeoutMs = getFirstStreamEventTimeoutMs(options);
 		const onFirstEventTimeout = getFirstStreamEventTimeoutHandler(options);
-		await processResponsesStream(hookedOpenAIStream, output, stream, model, {
+		const terminal = await processResponsesStream(hookedOpenAIStream, output, stream, model, {
 			...params.processStreamOptions || firstEventTimeoutMs !== void 0 || onFirstEventTimeout !== void 0 ? {
 				...params.processStreamOptions,
 				firstEventTimeoutMs: params.processStreamOptions?.firstEventTimeoutMs ?? firstEventTimeoutMs,
@@ -2200,6 +2406,7 @@ async function runResponsesStreamLifecycle(params) {
 				authProfileId: options?.authProfileId
 			})
 		});
+		if (terminal && admittedRequest && !options?.signal?.aborted) recordResponsesContextUsage(output, model, options, admittedRequest, terminal.output, "provider");
 		finalizeTransportStream({
 			stream,
 			output,
@@ -2218,4 +2425,4 @@ async function runResponsesStreamLifecycle(params) {
 	}
 }
 //#endregion
-export { resolveResponsesMessageSnapshotCollapse as A, responsesInputFingerprint as B, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as C, isAzureResponsesTextDeltaEventType as D, isAzureResponsesTextDeltaEvent as E, resolveNextResponsesEncryptedContentAttempt as F, resolveNewestOpenAIResponsesCompactionReplay as G, buildOpenAIResponsesReasoningReplayMetadata as H, buildResponsesInputMessage as I, suppressOpenAIResponsesCompaction as K, convertResponsesMessages$1 as L, createResponsesStreamWithEncryptedContentRetry as M, isInvalidEncryptedContentError as N, isResponsesTextContentPartType as O, resolveAzureOpenAIApiVersion as P, createOpenAIResponsesAssistantOutput as R, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as S, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as T, captureOpenAIResponsesCompaction as U, CompactionReplayRefreshRequiredError as V, isOpenAIResponsesReplayContext as W, safeDebugValue as _, resolveResponsesReasoningEffort as a, createResponsesToolCallTracker as b, convertProjectedResponsesTools as c, mapResponsesTerminalUsage as d, readResponsesReasoningTokens as f, logResponsesFailedNoDetails as g, ResponsesStreamFailure as h, createResponsesAssistantOutput as i, commitResponsesEncryptedContentAttempt as j, isResponsesTextDeltaEventType as k, convertResponsesToolPayload as l, observeResponsesStream as m, applyResponsesServiceTierPricing as n, resolveResponsesRequestReasoningEffort as o, resolveResponsesTerminalStopReason as p, resolveReplayableResponsesMessageId as q, convertResponsesMessages as r, runResponsesStreamLifecycle as s, applyCommonResponsesParams as t, processResponsesStream as u, summarizeOpenAITransportError as v, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as w, readResponsesToolCallItemIdentity as x, summarizeResponsesPayload as y, recordResponsesInputReplay as z };
+export { resolveNextResponsesEncryptedContentAttempt as A, responsesContinuationPrefixFingerprint as B, isResponsesTextContentPartType as C, createResponsesStreamWithEncryptedContentRetry as D, commitResponsesEncryptedContentAttempt as E, createOpenAIResponsesAssistantOutput as F, CompactionReplayRefreshRequiredError as G, isConfigurationUpdate as H, recordResponsesInputReplay as I, isOpenAIResponsesReplayContext as J, buildOpenAIResponsesReasoningReplayMetadata as K, responsesInputFingerprint as L, resolveResponsesContextUsageBoundary as M, buildResponsesInputMessage as N, isInvalidEncryptedContentError as O, convertResponsesMessages$1 as P, claimOpenAIResponsesHttpContinuation as R, isAzureResponsesTextDeltaEventType as S, resolveResponsesMessageSnapshotCollapse as T, replayResponsesReasoningUpdates as U, responsesContinuationRequestFingerprint as V, supportsResponsesReasoningUpdate as W, suppressOpenAIResponsesCompaction as X, resolveNewestOpenAIResponsesCompactionReplay as Y, resolveReplayableResponsesMessageId as Z, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as _, runResponsesStreamLifecycle as a, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as b, processResponsesStream as c, logResponsesFailedNoDetails as d, safeDebugValue as f, readResponsesToolCallItemIdentity as g, createResponsesToolCallTracker as h, createResponsesAssistantOutput as i, recordResponsesContextUsage as j, resolveAzureOpenAIApiVersion as k, observeResponsesStream as l, summarizeResponsesPayload as m, applyResponsesServiceTierPricing as n, convertResponsesToolPayload as o, summarizeOpenAITransportError as p, captureOpenAIResponsesCompaction as q, convertResponsesMessages as r, prepareResponsesTools as s, applyCommonResponsesParams as t, ResponsesStreamFailure as u, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as v, isResponsesTextDeltaEventType as w, isAzureResponsesTextDeltaEvent as x, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as y, resolveResponsesContinuationRequest as z };