@openclaw/ai 2026.9.4 → 2026.9.6

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

@@ -1,23 +1,26 @@
+import { o as readProviderRefusalReview, t as appendAssistantMessageDiagnostic } from "./diagnostics-DzrF1h4J.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 { a as normalizeOptionalString, o as normalizeStringifiedOptionalString, s as readStringValue } from "./string-coerce-fsri9iCu.mjs";
 import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { d as supportsOpenAITemperature } from "./openai-reasoning-effort-ash8dPrd.mjs";
+import { M as calculateCost, _ as isImageWithMediaPayload, d as describeToolResultMediaPlaceholder, m as extractToolResultText, n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-yTvBrYM2.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-CRhW7lkJ.mjs";
+import { a as resolveModelSseDebugMode, d as isResponsesProviderTool, g as resolveResponsesTerminalStopReason, h as readResponsesReasoningTokens, i as resolveModelPayloadDebugMode, l as ResponsesOutputIdentityError, m as mapResponsesTerminalUsage, r as emitModelTransportDebug, u as hasOnlyResponsesFunctionTools } from "./diagnostics-CH8j2wIG.mjs";
+import { o as redactSensitiveText } from "./transport-utils-03Qi0CN2.mjs";
+import { i as resolveOpenAICompletionsCompat } from "./openai-completions-compat-CUollwl6.mjs";
+import { s as transformTransportMessages } from "./host-policy-DZO3oPPk.mjs";
+import { m as stripSystemPromptCacheBoundary, v as sortPromptCacheToolsByName } from "./simple-options-np1XPuhm.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-DZKOTSfH.mjs";
+import { E as parseStreamingJson, O as shortHash, _ as sanitizeTransportPayloadText, b as withProviderResponseHook, g as sanitizeNonEmptyTransportPayloadText, h as parseTerminalToolCallArguments, l as finalizeTransportStream, s as failTransportStream, t as IncompleteToolCallError, v as transportAbortError, w as createToolArgumentPreviewSchedule, x as parseJsonObjectPreservingUnsafeIntegers } from "./transport-stream-shared-B5RioB_Q.mjs";
+import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-DPr3w20a.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-BeptfRL6.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform-BTocjCRs.mjs";
+import { a as resolveOpenAIProjectedToolsStrictToolFlag, f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-D4BMcj2D.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-BiNCT0bS.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 +190,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,325 +801,148 @@ function convertProviderResponsesMessages(model, context, allowedToolCallProvide
 	return convertResponsesMessagesWithStyle(model, context, allowedToolCallProviders, options, "provider");
 }
 //#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;
-}
-function isInvalidEncryptedContentError(error) {
-	if (!error || typeof error !== "object") return false;
-	const record = error;
-	if (record.code === "invalid_encrypted_content" || record.code === "thinking_signature_invalid") return true;
-	const message = typeof record.message === "string" ? record.message.toLowerCase() : "";
-	return message.includes("invalid_encrypted_content") || message.includes("thinking_signature_invalid") || (record.status === 400 || record.status == null && /(?:^|[\s(])400(?:[\s):]|$)/.test(message)) && (message.includes("could not decrypt the provided encrypted_content") || message.includes("encrypted content") && (message.includes("could not be verified") || message.includes("could not be decrypted or parsed")));
-}
-function isOrphanedFunctionCallOutputError(error) {
-	if (!error || typeof error !== "object") return false;
-	const record = error;
-	const message = typeof record.message === "string" ? record.message : "";
-	return /No tool call found for function call output with call_id [A-Za-z0-9_-]+/.test(message);
-}
-function commitResponsesEncryptedContentAttempt(attempt, commit) {
-	if (attempt.kind === "compaction-stripped") commit(attempt.rejectedCompaction);
-}
-function stripResponsesRequestEncryptedReasoning(request) {
-	const stripped = stripEncryptedReasoningContentFields(request.input);
-	if (!stripped.changed) return request;
-	return {
-		...request,
-		input: stripped.value
-	};
+//#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
+	}));
 }
-function stripResponsesRequestCompaction(request) {
-	if (!Array.isArray(request.input)) return request;
-	const input = request.input.filter((item) => !(item !== null && typeof item === "object" && item.type === "compaction"));
-	return input.length === request.input.length ? request : {
-		...request,
-		input
+/** 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
+	} });
 }
-function readOpenAIResponsesCompactionRejection(request) {
-	if (!Array.isArray(request.input)) return;
-	const item = request.input.find((candidate) => candidate !== null && typeof candidate === "object" && candidate.type === "compaction" && typeof candidate.encrypted_content === "string");
-	return item ? {
-		data: item.encrypted_content,
-		...typeof item.id === "string" ? { id: item.id } : {}
-	} : void 0;
-}
-async function resolveNextResponsesEncryptedContentAttempt(attempt, error, options) {
-	const orphanedFunctionOutput = isOrphanedFunctionCallOutputError(error);
-	if (!isInvalidEncryptedContentError(error) && !orphanedFunctionOutput || attempt.kind === "compaction-stripped") return;
-	if (!orphanedFunctionOutput && (attempt.kind === "initial" || attempt.kind === "continuation-rejected")) {
-		const reasoningStripped = stripResponsesRequestEncryptedReasoning(attempt.request);
-		if (reasoningStripped !== attempt.request) return {
-			kind: "reasoning-stripped",
-			request: reasoningStripped
+/** 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)
 		};
 	}
-	const locallyStripped = stripResponsesRequestCompaction(attempt.request);
-	if (locallyStripped === attempt.request) return;
-	let compactionStripped = options?.buildFullHistoryRequest ? await options.buildFullHistoryRequest() : locallyStripped;
-	compactionStripped = stripResponsesRequestCompaction(compactionStripped);
-	if (attempt.kind === "reasoning-stripped") compactionStripped = stripResponsesRequestEncryptedReasoning(compactionStripped);
-	return {
-		kind: "compaction-stripped",
-		request: compactionStripped,
-		rejectedCompaction: readOpenAIResponsesCompactionRejection(attempt.request)
-	};
 }
-async function createResponsesStreamWithEncryptedContentRetry(params) {
-	const send = async (initialAttempt) => {
-		let attempt = initialAttempt;
-		for (;;) {
-			params.observePrompt?.(attempt.request, {
-				egress: "responses-sdk",
-				payloadVariant: attempt.kind
-			});
-			try {
-				const { data, response } = await params.client.responses.create(attempt.request, params.requestOptions).withResponse();
-				commitResponsesEncryptedContentAttempt(attempt, (checkpoint) => {
-					if (checkpoint) params.onCompactionRejected?.(checkpoint);
-				});
-				if (!isAsyncIterable(data)) throw new Error("OpenAI Responses streaming request returned a non-stream response");
-				return {
-					stream: data,
-					response,
-					attempt
-				};
-			} 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") {
-					const request = { ...params.buildFullHistoryRequest ? await params.buildFullHistoryRequest() : attempt.request };
-					delete request.previous_response_id;
-					nextAttempt = {
-						kind: "continuation-rejected",
-						request
-					};
-				}
-				if (!nextAttempt) throw error;
-				const retryDescription = nextAttempt.kind === "reasoning-stripped" ? "without encrypted reasoning content" : nextAttempt.kind === "compaction-stripped" ? "without encrypted compaction content" : "full history after rejected previous_response_id";
-				log.warn(`[responses] retrying ${retryDescription} provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
-				attempt = nextAttempt;
-			}
-		}
-	};
-	const result = await send({
-		kind: params.initialAttemptKind ?? "initial",
-		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
-								});
-							}
-						}
-						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;
-					}
-					log.warn(`[responses] retrying streamed encrypted content provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
-					current = await send(nextAttempt);
-				}
-			}
-		} }
-	};
+function isAssistant(message) {
+	return message.role === "assistant";
 }
-function resolveAzureOpenAIApiVersion(env = process.env) {
-	return env.AZURE_OPENAI_API_VERSION?.trim() || "preview";
+function isProviderMessage(message) {
+	return message.role === "user" || message.role === "assistant" || message.role === "toolResult";
 }
 //#endregion
-//#region packages/ai/src/providers/openai-responses-stream-compat.ts
-const OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE = "output_text";
-const AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE = "text";
-const OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE = "response.output_text.delta";
-const AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE = "response.text.delta";
-function isResponsesTextContentPartType(type) {
-	return type === "output_text" || type === "text";
-}
-function isResponsesTextDeltaEventType(type) {
-	return type === "response.output_text.delta" || type === "response.text.delta";
+//#region packages/ai/src/transports/openai-responses-debug.ts
+function stringifyUnknown(value, fallback = "") {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return fallback;
 }
-function isAzureResponsesTextDeltaEventType(type) {
-	return type === AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
+function safeDebugValue(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	return Array.isArray(value) ? "array" : typeof value;
 }
-function isAzureResponsesTextDeltaEvent(event) {
-	return isAzureResponsesTextDeltaEventType(event.type) && typeof event.delta === "string";
+function responseInputTextChars(input) {
+	if (typeof input === "string") return input.length;
+	if (Array.isArray(input)) return input.reduce((total, item) => total + responseInputTextChars(item), 0);
+	if (!input || typeof input !== "object") return 0;
+	const record = input;
+	let total = 0;
+	if (typeof record.text === "string") total += record.text.length;
+	if (typeof record.content === "string") total += record.content.length;
+	else if (Array.isArray(record.content)) total += responseInputTextChars(record.content);
+	return total;
 }
-function resolveResponsesMessageSnapshotCollapse(params) {
-	const { prior, nextText } = params;
-	if (!prior?.text || !nextText || prior.phase !== params.nextPhase) return { kind: "keep" };
-	if (nextText.length > prior.text.length && nextText.startsWith(prior.text)) return {
-		kind: "extend",
-		text: nextText
-	};
-	return { kind: "keep" };
+function responseInputRoles(input) {
+	if (!Array.isArray(input)) return "";
+	const roles = /* @__PURE__ */ new Set();
+	for (const item of input) if (item && typeof item === "object") {
+		const role = item.role;
+		if (typeof role === "string" && role.trim()) roles.add(role.trim());
+	}
+	return [...roles].toSorted().join(",");
 }
-//#endregion
-//#region packages/ai/src/providers/openai-responses-tool-call-tracker.ts
-function readOutputIndex(event) {
-	return typeof event.output_index === "number" && Number.isInteger(event.output_index) && event.output_index >= 0 ? event.output_index : void 0;
+function responseInputItemShape(input) {
+	if (!Array.isArray(input)) return "none";
+	return input.map((item) => {
+		if (!isRecord(item) || typeof item.type !== "string") return "unknown";
+		if (item.type === "message" && typeof item.role === "string") return `message:${item.role}`;
+		return item.type;
+	}).join(",") || "none";
 }
-function readEventIdentity(event) {
-	return { itemId: normalizeOptionalString(event.item_id) };
+function hashOpaqueResponsesValue(value) {
+	return createHash("sha256").update(value).digest("hex");
 }
-function readResponsesToolCallItemIdentity(item) {
-	return {
-		itemId: normalizeOptionalString(item.id),
-		callId: normalizeOptionalString(item.call_id)
-	};
-}
-function createResponsesToolCallTracker() {
-	const indexedCalls = /* @__PURE__ */ new Map();
-	const unindexedCalls = /* @__PURE__ */ new Set();
-	const identitiesConflict = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId !== identity.itemId || state.callId && identity.callId && state.callId !== identity.callId);
-	const sharesIdentity = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId === identity.itemId || state.callId && identity.callId && state.callId === identity.callId);
-	const adoptIdentity = (state, identity) => {
-		state.itemId ??= identity.itemId;
-		state.callId ??= identity.callId;
-		return state;
-	};
-	const resolveCompatible = (candidates, identity, allowUnmatchedIdentity) => {
-		const uniqueCandidates = [...new Set(candidates)];
-		if (!identity.itemId && !identity.callId) return allowUnmatchedIdentity && uniqueCandidates.length === 1 ? uniqueCandidates.at(0) : void 0;
-		const compatible = uniqueCandidates.filter((state) => !identitiesConflict(state, identity));
-		const matches = compatible.filter((state) => sharesIdentity(state, identity));
-		const matched = matches.length === 1 ? matches.at(0) : void 0;
-		if (matched) return adoptIdentity(matched, identity);
-		const soleCompatible = allowUnmatchedIdentity && uniqueCandidates.length === 1 && compatible.length === 1 && matches.length === 0 ? compatible.at(0) : void 0;
-		return soleCompatible ? adoptIdentity(soleCompatible, identity) : void 0;
-	};
-	return {
-		register(event, state) {
-			const outputIndex = readOutputIndex(event);
-			if (outputIndex === void 0) {
-				unindexedCalls.add(state);
-				return;
-			}
-			if (indexedCalls.has(outputIndex)) throw new Error(`Responses stream reused active tool-call output index ${outputIndex}`);
-			state.outputIndex = outputIndex;
-			indexedCalls.set(outputIndex, state);
-		},
-		resolve(event, identity = readEventIdentity(event), allowUnmatchedIdentity = true) {
-			const outputIndex = readOutputIndex(event);
-			if (outputIndex !== void 0) {
-				const indexed = indexedCalls.get(outputIndex);
-				if (indexed) {
-					if (indexed.callId && identity.callId && indexed.callId !== identity.callId) return;
-					return adoptIdentity(indexed, identity);
-				}
-				const unindexed = resolveCompatible(unindexedCalls, identity, allowUnmatchedIdentity);
-				if (unindexed) {
-					unindexedCalls.delete(unindexed);
-					unindexed.outputIndex = outputIndex;
-					indexedCalls.set(outputIndex, unindexed);
-				}
-				return unindexed;
-			}
-			return resolveCompatible([...indexedCalls.values(), ...unindexedCalls], identity, allowUnmatchedIdentity);
-		},
-		forget(toolCall) {
-			for (const [outputIndex, tracked] of indexedCalls) if (tracked === toolCall) indexedCalls.delete(outputIndex);
-			unindexedCalls.delete(toolCall);
-		},
-		markArgumentsUnreliable() {
-			for (const toolCall of /* @__PURE__ */ new Set([...indexedCalls.values(), ...unindexedCalls])) toolCall.argumentStreamReliable = false;
-		},
-		hasActive() {
-			return indexedCalls.size > 0 || unindexedCalls.size > 0;
-		},
-		hasExactlyActive(expected) {
-			const active = /* @__PURE__ */ new Set([...indexedCalls.values(), ...unindexedCalls]);
-			return active.size === expected.length && expected.every((state) => active.has(state));
-		}
-	};
-}
-//#endregion
-//#region packages/ai/src/transports/openai-responses-debug.ts
-function stringifyUnknown(value, fallback = "") {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	return fallback;
-}
-function safeDebugValue(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (value === null) return "null";
-	if (value === void 0) return "undefined";
-	return Array.isArray(value) ? "array" : typeof value;
-}
-function responseInputTextChars(input) {
-	if (typeof input === "string") return input.length;
-	if (Array.isArray(input)) return input.reduce((total, item) => total + responseInputTextChars(item), 0);
-	if (!input || typeof input !== "object") return 0;
-	const record = input;
-	let total = 0;
-	if (typeof record.text === "string") total += record.text.length;
-	if (typeof record.content === "string") total += record.content.length;
-	else if (Array.isArray(record.content)) total += responseInputTextChars(record.content);
-	return total;
-}
-function responseInputRoles(input) {
-	if (!Array.isArray(input)) return "";
-	const roles = /* @__PURE__ */ new Set();
-	for (const item of input) if (item && typeof item === "object") {
-		const role = item.role;
-		if (typeof role === "string" && role.trim()) roles.add(role.trim());
-	}
-	return [...roles].toSorted().join(",");
-}
-function responseInputItemShape(input) {
-	if (!Array.isArray(input)) return "none";
-	return input.map((item) => {
-		if (!isRecord(item) || typeof item.type !== "string") return "unknown";
-		if (item.type === "message" && typeof item.role === "string") return `message:${item.role}`;
-		return item.type;
-	}).join(",") || "none";
-}
-function hashOpaqueResponsesValue(value) {
-	return createHash("sha256").update(value).digest("hex");
-}
-function summarizeResponsesCompactionItems(input) {
-	if (!Array.isArray(input)) return [
-		"compactionItems=0",
-		"compactionIdHashes=none",
-		"compactionPayloadHashes=none",
-		"compactionInputIndexes=none"
-	];
-	const compactions = input.flatMap((item, inputIndex) => {
-		if (!isRecord(item) || item.type !== "compaction") return [];
-		return [{
-			idHash: typeof item.id === "string" ? hashOpaqueResponsesValue(item.id) : void 0,
-			inputIndex,
-			payloadHash: typeof item.encrypted_content === "string" ? hashOpaqueResponsesValue(item.encrypted_content) : void 0
-		}];
-	});
-	return [
-		`compactionItems=${compactions.length}`,
-		`compactionIdHashes=${compactions.flatMap((item) => item.idHash ?? []).join(",") || "none"}`,
-		`compactionPayloadHashes=${compactions.flatMap((item) => item.payloadHash ?? []).join(",") || "none"}`,
-		`compactionInputIndexes=${compactions.map((item) => item.inputIndex).join(",") || "none"}`
-	];
+function summarizeResponsesCompactionItems(input) {
+	if (!Array.isArray(input)) return [
+		"compactionItems=0",
+		"compactionIdHashes=none",
+		"compactionPayloadHashes=none",
+		"compactionInputIndexes=none"
+	];
+	const compactions = input.flatMap((item, inputIndex) => {
+		if (!isRecord(item) || item.type !== "compaction") return [];
+		return [{
+			idHash: typeof item.id === "string" ? hashOpaqueResponsesValue(item.id) : void 0,
+			inputIndex,
+			payloadHash: typeof item.encrypted_content === "string" ? hashOpaqueResponsesValue(item.encrypted_content) : void 0
+		}];
+	});
+	return [
+		`compactionItems=${compactions.length}`,
+		`compactionIdHashes=${compactions.flatMap((item) => item.idHash ?? []).join(",") || "none"}`,
+		`compactionPayloadHashes=${compactions.flatMap((item) => item.payloadHash ?? []).join(",") || "none"}`,
+		`compactionInputIndexes=${compactions.map((item) => item.inputIndex).join(",") || "none"}`
+	];
 }
 function readToolPayloadField(record, field) {
 	try {
@@ -1036,131 +1055,382 @@ function collectResponseFailedIdentifierHashes(value, opts = {}) {
 	}
 	return out;
 }
-function redactResponseFailedDiagnosticValue(value, opts = {}) {
-	const key = opts.key ?? "";
-	const depth = opts.depth ?? 0;
-	if (typeof value === "string" || typeof value === "number") return key && isResponseFailedIdentifierKey(key) ? redactIdentifier(String(value), { len: 12 }) : value;
-	if (depth > 6 || !value || typeof value !== "object") return value;
-	const seen = opts.seen ?? /* @__PURE__ */ new WeakSet();
-	if (seen.has(value)) return "<circular>";
-	seen.add(value);
-	if (Array.isArray(value)) return value.slice(0, 16).map((item) => redactResponseFailedDiagnosticValue(item, {
-		key,
-		depth: depth + 1,
-		seen
-	}));
-	const out = {};
-	for (const [childKey, child] of Object.entries(value)) out[childKey] = redactResponseFailedDiagnosticValue(child, {
-		key: childKey,
-		depth: depth + 1,
-		seen
-	});
-	return out;
+function redactResponseFailedDiagnosticValue(value, opts = {}) {
+	const key = opts.key ?? "";
+	const depth = opts.depth ?? 0;
+	if (typeof value === "string" || typeof value === "number") return key && isResponseFailedIdentifierKey(key) ? redactIdentifier(String(value), { len: 12 }) : value;
+	if (depth > 6 || !value || typeof value !== "object") return value;
+	const seen = opts.seen ?? /* @__PURE__ */ new WeakSet();
+	if (seen.has(value)) return "<circular>";
+	seen.add(value);
+	if (Array.isArray(value)) return value.slice(0, 16).map((item) => redactResponseFailedDiagnosticValue(item, {
+		key,
+		depth: depth + 1,
+		seen
+	}));
+	const out = {};
+	for (const [childKey, child] of Object.entries(value)) out[childKey] = redactResponseFailedDiagnosticValue(child, {
+		key: childKey,
+		depth: depth + 1,
+		seen
+	});
+	return out;
+}
+function buildResponsesFailedFailureFields(response) {
+	if (!response) return {};
+	const fields = {};
+	for (const key of RESPONSE_FAILED_FAILURE_FIELD_KEYS) if (response[key] !== void 0 && response[key] !== null) fields[key] = response[key];
+	return fields;
+}
+function buildResponsesFailedNoDetailsObservation(event, model, response = isRecord(event.response) ? event.response : void 0) {
+	const failureFields = redactResponseFailedDiagnosticValue(buildResponsesFailedFailureFields(response));
+	const metadataKeys = isRecord(response?.metadata) ? Object.keys(response.metadata).toSorted() : [];
+	const responsePreview = {
+		id: readResponseFailedString(response, "id"),
+		status: readResponseFailedString(response, "status"),
+		model: readResponseFailedString(response, "model"),
+		object: readResponseFailedString(response, "object"),
+		failureFields,
+		metadataKeys
+	};
+	return {
+		event: "openai_responses_response_failed_without_details",
+		provider: model.provider,
+		api: model.api,
+		transportModel: model.id,
+		providerRuntimeFailureKind: "no_error_details",
+		responseId: responsePreview.id,
+		responseStatus: responsePreview.status,
+		responseModel: responsePreview.model,
+		responseObject: responsePreview.object,
+		metadataKeys,
+		requestIdHashes: collectResponseFailedIdentifierHashes(event),
+		failureFieldsPreview: stringifyRedactedEvent(failureFields),
+		responsePreview: stringifyRedactedEvent(responsePreview)
+	};
+}
+function summarizeResponsesFailedNoDetailsObservation(observation) {
+	const requestIds = observation.requestIdHashes.join(",");
+	const metadataKeys = observation.metadataKeys.join(",");
+	return `responseId=${safeDebugValue(observation.responseId || void 0)} responseStatus=${safeDebugValue(observation.responseStatus || void 0)} responseModel=${safeDebugValue(observation.responseModel || void 0)} requestIds=${requestIds || "none"} metadataKeys=${metadataKeys || "none"} failureFields=${observation.failureFieldsPreview}`;
+}
+function normalizeResponsesFailedEvent(event, model) {
+	const response = isRecord(event.response) ? event.response : void 0;
+	const responseId = readResponseFailedString(response, "id") || void 0;
+	const error = isRecord(response?.error) ? response.error : void 0;
+	if (error) {
+		const code = readResponseFailedString(error, "code").trim();
+		const message = readResponseFailedString(error, "message").trim();
+		if (code || message) return buildResponsesFailedEventSummary(`${code || "unknown"}: ${message || "no message"}`, responseId, code || void 0);
+	}
+	const incompleteReason = readResponseFailedString(isRecord(response?.incomplete_details) ? response.incomplete_details : void 0, "reason");
+	if (incompleteReason) return buildResponsesFailedEventSummary(`incomplete: ${incompleteReason}`, responseId);
+	return buildResponsesFailedEventSummary(RESPONSE_FAILED_NO_DETAILS_MESSAGE, responseId, void 0, buildResponsesFailedNoDetailsObservation(event, model, response));
+}
+var ResponsesStreamFailure = class extends Error {
+	constructor(failure, response) {
+		super(failure.message);
+		this.name = "ResponsesStreamFailure";
+		this.responseId = failure.responseId;
+		this.response = response;
+		this.code = failure.code;
+		this.observation = failure.observation;
+	}
+};
+function logResponsesFailedNoDetails(observation) {
+	log.warn(`[responses] response.failed missing error details provider=${observation.provider} api=${observation.api} model=${observation.transportModel} ` + summarizeResponsesFailedNoDetailsObservation(observation), observation);
+}
+function summarizeResponsesPayload(params) {
+	if (!params || typeof params !== "object") return "payload=non-object";
+	const record = params;
+	const input = record.input;
+	const reasoning = record.reasoning && typeof record.reasoning === "object" ? record.reasoning : void 0;
+	const text = record.text && typeof record.text === "object" ? record.text : void 0;
+	const parts = [
+		`fields=${Object.keys(record).toSorted().join(",")}`,
+		`model=${safeDebugValue(record.model)}`,
+		`stream=${safeDebugValue(record.stream)}`,
+		`inputItems=${Array.isArray(input) ? input.length : typeof input}`,
+		`inputItemShape=${responseInputItemShape(input)}`,
+		`inputRoles=${responseInputRoles(input) || "none"}`,
+		`inputTextChars=${responseInputTextChars(input)}`,
+		`tools=${summarizeResponsesTools(record.tools)}`,
+		`reasoningEffort=${safeDebugValue(reasoning?.effort)}`,
+		`reasoningSummary=${safeDebugValue(reasoning?.summary)}`,
+		`textVerbosity=${safeDebugValue(text?.verbosity)}`,
+		`serviceTier=${safeDebugValue(record.service_tier)}`,
+		...summarizeResponsesCompactionItems(input),
+		`store=${safeDebugValue(record.store)}`,
+		`promptCacheKey=${record.prompt_cache_key === void 0 ? "absent" : "present"}`,
+		`metadataKeys=${record.metadata && typeof record.metadata === "object" ? Object.keys(record.metadata).toSorted().join(",") : "none"}`
+	];
+	if (resolveModelPayloadDebugMode() === "full-redacted") parts.push(`payload=${stringifyRedactedPayload(record)}`);
+	return parts.join(" ");
+}
+function summarizeOpenAITransportError(error) {
+	if (!error || typeof error !== "object") return `type=${typeof error} message=${safeDebugValue(error)}`;
+	const record = error;
+	const cause = record.cause && typeof record.cause === "object" ? record.cause : void 0;
+	return [
+		`name=${safeDebugValue(record.name)}`,
+		`status=${safeDebugValue(record.status)}`,
+		`code=${safeDebugValue(record.code)}`,
+		`type=${safeDebugValue(record.type)}`,
+		`causeName=${safeDebugValue(cause?.name)}`,
+		`causeCode=${safeDebugValue(cause?.code)}`,
+		`message=${error instanceof Error ? error.message : safeDebugValue(error)}`
+	].join(" ");
+}
+//#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;
+}
+function isInvalidEncryptedContentError(error) {
+	if (!error || typeof error !== "object") return false;
+	const record = error;
+	if (record.code === "invalid_encrypted_content" || record.code === "thinking_signature_invalid") return true;
+	const message = typeof record.message === "string" ? record.message.toLowerCase() : "";
+	return message.includes("invalid_encrypted_content") || message.includes("thinking_signature_invalid") || (record.status === 400 || record.status == null && /(?:^|[\s(])400(?:[\s):]|$)/.test(message)) && (message.includes("could not decrypt the provided encrypted_content") || message.includes("encrypted content") && (message.includes("could not be verified") || message.includes("could not be decrypted or parsed")));
+}
+function isOrphanedFunctionCallOutputError(error) {
+	if (!error || typeof error !== "object") return false;
+	const record = error;
+	const message = typeof record.message === "string" ? record.message : "";
+	return /No tool call found for function call output with call_id [A-Za-z0-9_-]+/.test(message);
+}
+function commitResponsesEncryptedContentAttempt(attempt, commit) {
+	if (attempt.kind === "compaction-stripped") commit(attempt.rejectedCompaction);
+}
+function stripResponsesRequestEncryptedReasoning(request) {
+	const stripped = stripEncryptedReasoningContentFields(request.input);
+	if (!stripped.changed) return request;
+	return {
+		...request,
+		input: stripped.value
+	};
+}
+function stripResponsesRequestCompaction(request) {
+	if (!Array.isArray(request.input)) return request;
+	const input = request.input.filter((item) => !(item !== null && typeof item === "object" && item.type === "compaction"));
+	return input.length === request.input.length ? request : {
+		...request,
+		input
+	};
+}
+function readOpenAIResponsesCompactionRejection(request) {
+	if (!Array.isArray(request.input)) return;
+	const item = request.input.find((candidate) => candidate !== null && typeof candidate === "object" && candidate.type === "compaction" && typeof candidate.encrypted_content === "string");
+	return item ? {
+		data: item.encrypted_content,
+		...typeof item.id === "string" ? { id: item.id } : {}
+	} : void 0;
+}
+async function resolveNextResponsesEncryptedContentAttempt(attempt, error, options) {
+	const orphanedFunctionOutput = isOrphanedFunctionCallOutputError(error);
+	if (!isInvalidEncryptedContentError(error) && !orphanedFunctionOutput || attempt.kind === "compaction-stripped") return;
+	if (!orphanedFunctionOutput && (attempt.kind === "initial" || attempt.kind === "continuation-rejected")) {
+		const reasoningStripped = stripResponsesRequestEncryptedReasoning(attempt.request);
+		if (reasoningStripped !== attempt.request) return {
+			kind: "reasoning-stripped",
+			request: reasoningStripped
+		};
+	}
+	const locallyStripped = stripResponsesRequestCompaction(attempt.request);
+	if (locallyStripped === attempt.request) return;
+	let compactionStripped = options?.buildFullHistoryRequest ? await options.buildFullHistoryRequest() : locallyStripped;
+	compactionStripped = stripResponsesRequestCompaction(compactionStripped);
+	if (attempt.kind === "reasoning-stripped") compactionStripped = stripResponsesRequestEncryptedReasoning(compactionStripped);
+	return {
+		kind: "compaction-stripped",
+		request: compactionStripped,
+		rejectedCompaction: readOpenAIResponsesCompactionRejection(attempt.request)
+	};
+}
+async function createResponsesStreamWithEncryptedContentRetry(params) {
+	const send = async (initialAttempt) => {
+		let attempt = initialAttempt;
+		for (;;) {
+			params.observePrompt?.(attempt.request, {
+				egress: "responses-sdk",
+				payloadVariant: attempt.kind
+			});
+			try {
+				const { data, response } = await params.client.responses.create(attempt.request, params.requestOptions).withResponse();
+				commitResponsesEncryptedContentAttempt(attempt, (checkpoint) => {
+					if (checkpoint) params.onCompactionRejected?.(checkpoint);
+				});
+				if (!isAsyncIterable(data)) throw new Error("OpenAI Responses streaming request returned a non-stream response");
+				return {
+					stream: data,
+					response,
+					attempt
+				};
+			} 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" && isPreviousResponseRejection(error)) {
+					const request = { ...params.buildFullHistoryRequest ? await params.buildFullHistoryRequest() : attempt.request };
+					delete request.previous_response_id;
+					nextAttempt = {
+						kind: "continuation-rejected",
+						request
+					};
+				}
+				if (!nextAttempt) throw error;
+				const retryDescription = nextAttempt.kind === "reasoning-stripped" ? "without encrypted reasoning content" : nextAttempt.kind === "compaction-stripped" ? "without encrypted compaction content" : "full history after rejected previous_response_id";
+				log.warn(`[responses] retrying ${retryDescription} provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
+				attempt = nextAttempt;
+			}
+		}
+	};
+	const result = await send({
+		kind: params.initialAttemptKind ?? "initial",
+		request: params.request,
+		...params.initialRejectedCompaction ? { rejectedCompaction: params.initialRejectedCompaction } : {}
+	});
+	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;
+				}
+				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";
+}
+//#endregion
+//#region packages/ai/src/providers/openai-responses-stream-compat.ts
+const OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE = "output_text";
+const AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE = "text";
+const OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE = "response.output_text.delta";
+const AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE = "response.text.delta";
+function isResponsesTextContentPartType(type) {
+	return type === "output_text" || type === "text";
+}
+function isResponsesTextDeltaEventType(type) {
+	return type === "response.output_text.delta" || type === "response.text.delta";
 }
-function buildResponsesFailedFailureFields(response) {
-	if (!response) return {};
-	const fields = {};
-	for (const key of RESPONSE_FAILED_FAILURE_FIELD_KEYS) if (response[key] !== void 0 && response[key] !== null) fields[key] = response[key];
-	return fields;
+function isAzureResponsesTextDeltaEventType(type) {
+	return type === AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
 }
-function buildResponsesFailedNoDetailsObservation(event, model, response = isRecord(event.response) ? event.response : void 0) {
-	const failureFields = redactResponseFailedDiagnosticValue(buildResponsesFailedFailureFields(response));
-	const metadataKeys = isRecord(response?.metadata) ? Object.keys(response.metadata).toSorted() : [];
-	const responsePreview = {
-		id: readResponseFailedString(response, "id"),
-		status: readResponseFailedString(response, "status"),
-		model: readResponseFailedString(response, "model"),
-		object: readResponseFailedString(response, "object"),
-		failureFields,
-		metadataKeys
-	};
-	return {
-		event: "openai_responses_response_failed_without_details",
-		provider: model.provider,
-		api: model.api,
-		transportModel: model.id,
-		providerRuntimeFailureKind: "no_error_details",
-		responseId: responsePreview.id,
-		responseStatus: responsePreview.status,
-		responseModel: responsePreview.model,
-		responseObject: responsePreview.object,
-		metadataKeys,
-		requestIdHashes: collectResponseFailedIdentifierHashes(event),
-		failureFieldsPreview: stringifyRedactedEvent(failureFields),
-		responsePreview: stringifyRedactedEvent(responsePreview)
-	};
+function isAzureResponsesTextDeltaEvent(event) {
+	return isAzureResponsesTextDeltaEventType(event.type) && typeof event.delta === "string";
 }
-function summarizeResponsesFailedNoDetailsObservation(observation) {
-	const requestIds = observation.requestIdHashes.join(",");
-	const metadataKeys = observation.metadataKeys.join(",");
-	return `responseId=${safeDebugValue(observation.responseId || void 0)} responseStatus=${safeDebugValue(observation.responseStatus || void 0)} responseModel=${safeDebugValue(observation.responseModel || void 0)} requestIds=${requestIds || "none"} metadataKeys=${metadataKeys || "none"} failureFields=${observation.failureFieldsPreview}`;
+function resolveResponsesMessageSnapshotCollapse(params) {
+	const { prior, nextText } = params;
+	if (!prior?.text || !nextText || prior.phase !== params.nextPhase) return { kind: "keep" };
+	if (nextText.length > prior.text.length && nextText.startsWith(prior.text)) return {
+		kind: "extend",
+		text: nextText
+	};
+	return { kind: "keep" };
 }
-function normalizeResponsesFailedEvent(event, model) {
-	const response = isRecord(event.response) ? event.response : void 0;
-	const responseId = readResponseFailedString(response, "id") || void 0;
-	const error = isRecord(response?.error) ? response.error : void 0;
-	if (error) {
-		const code = readResponseFailedString(error, "code").trim();
-		const message = readResponseFailedString(error, "message").trim();
-		if (code || message) return buildResponsesFailedEventSummary(`${code || "unknown"}: ${message || "no message"}`, responseId, code || void 0);
-	}
-	const incompleteReason = readResponseFailedString(isRecord(response?.incomplete_details) ? response.incomplete_details : void 0, "reason");
-	if (incompleteReason) return buildResponsesFailedEventSummary(`incomplete: ${incompleteReason}`, responseId);
-	return buildResponsesFailedEventSummary(RESPONSE_FAILED_NO_DETAILS_MESSAGE, responseId, void 0, buildResponsesFailedNoDetailsObservation(event, model, response));
+//#endregion
+//#region packages/ai/src/providers/openai-responses-tool-call-tracker.ts
+function readOutputIndex(event) {
+	return typeof event.output_index === "number" && Number.isInteger(event.output_index) && event.output_index >= 0 ? event.output_index : void 0;
 }
-var ResponsesStreamFailure = class extends Error {
-	constructor(failure, response) {
-		super(failure.message);
-		this.name = "ResponsesStreamFailure";
-		this.responseId = failure.responseId;
-		this.response = response;
-		this.code = failure.code;
-		this.observation = failure.observation;
-	}
-};
-function logResponsesFailedNoDetails(observation) {
-	log.warn(`[responses] response.failed missing error details provider=${observation.provider} api=${observation.api} model=${observation.transportModel} ` + summarizeResponsesFailedNoDetailsObservation(observation), observation);
+function readEventIdentity(event) {
+	return { itemId: normalizeOptionalString(event.item_id) };
 }
-function summarizeResponsesPayload(params) {
-	if (!params || typeof params !== "object") return "payload=non-object";
-	const record = params;
-	const input = record.input;
-	const reasoning = record.reasoning && typeof record.reasoning === "object" ? record.reasoning : void 0;
-	const text = record.text && typeof record.text === "object" ? record.text : void 0;
-	const parts = [
-		`fields=${Object.keys(record).toSorted().join(",")}`,
-		`model=${safeDebugValue(record.model)}`,
-		`stream=${safeDebugValue(record.stream)}`,
-		`inputItems=${Array.isArray(input) ? input.length : typeof input}`,
-		`inputItemShape=${responseInputItemShape(input)}`,
-		`inputRoles=${responseInputRoles(input) || "none"}`,
-		`inputTextChars=${responseInputTextChars(input)}`,
-		`tools=${summarizeResponsesTools(record.tools)}`,
-		`reasoningEffort=${safeDebugValue(reasoning?.effort)}`,
-		`reasoningSummary=${safeDebugValue(reasoning?.summary)}`,
-		`textVerbosity=${safeDebugValue(text?.verbosity)}`,
-		`serviceTier=${safeDebugValue(record.service_tier)}`,
-		...summarizeResponsesCompactionItems(input),
-		`store=${safeDebugValue(record.store)}`,
-		`promptCacheKey=${record.prompt_cache_key === void 0 ? "absent" : "present"}`,
-		`metadataKeys=${record.metadata && typeof record.metadata === "object" ? Object.keys(record.metadata).toSorted().join(",") : "none"}`
-	];
-	if (resolveModelPayloadDebugMode() === "full-redacted") parts.push(`payload=${stringifyRedactedPayload(record)}`);
-	return parts.join(" ");
+function readResponsesToolCallItemIdentity(item) {
+	return {
+		itemId: normalizeOptionalString(item.id),
+		callId: normalizeOptionalString(item.call_id)
+	};
 }
-function summarizeOpenAITransportError(error) {
-	if (!error || typeof error !== "object") return `type=${typeof error} message=${safeDebugValue(error)}`;
-	const record = error;
-	const cause = record.cause && typeof record.cause === "object" ? record.cause : void 0;
-	return [
-		`name=${safeDebugValue(record.name)}`,
-		`status=${safeDebugValue(record.status)}`,
-		`code=${safeDebugValue(record.code)}`,
-		`type=${safeDebugValue(record.type)}`,
-		`causeName=${safeDebugValue(cause?.name)}`,
-		`causeCode=${safeDebugValue(cause?.code)}`,
-		`message=${error instanceof Error ? error.message : safeDebugValue(error)}`
-	].join(" ");
+function createResponsesToolCallTracker() {
+	const indexedCalls = /* @__PURE__ */ new Map();
+	const unindexedCalls = /* @__PURE__ */ new Set();
+	const identitiesConflict = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId !== identity.itemId || state.callId && identity.callId && state.callId !== identity.callId);
+	const sharesIdentity = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId === identity.itemId || state.callId && identity.callId && state.callId === identity.callId);
+	const adoptIdentity = (state, identity) => {
+		state.itemId ??= identity.itemId;
+		state.callId ??= identity.callId;
+		return state;
+	};
+	const resolveCompatible = (candidates, identity, allowUnmatchedIdentity) => {
+		const uniqueCandidates = [...new Set(candidates)];
+		if (!identity.itemId && !identity.callId) return allowUnmatchedIdentity && uniqueCandidates.length === 1 ? uniqueCandidates.at(0) : void 0;
+		const compatible = uniqueCandidates.filter((state) => !identitiesConflict(state, identity));
+		const matches = compatible.filter((state) => sharesIdentity(state, identity));
+		const matched = matches.length === 1 ? matches.at(0) : void 0;
+		if (matched) return adoptIdentity(matched, identity);
+		const soleCompatible = allowUnmatchedIdentity && uniqueCandidates.length === 1 && compatible.length === 1 && matches.length === 0 ? compatible.at(0) : void 0;
+		return soleCompatible ? adoptIdentity(soleCompatible, identity) : void 0;
+	};
+	return {
+		register(event, state) {
+			const outputIndex = readOutputIndex(event);
+			if (outputIndex === void 0) {
+				unindexedCalls.add(state);
+				return;
+			}
+			if (indexedCalls.has(outputIndex)) throw new Error(`Responses stream reused active tool-call output index ${outputIndex}`);
+			state.outputIndex = outputIndex;
+			indexedCalls.set(outputIndex, state);
+		},
+		resolve(event, identity = readEventIdentity(event), allowUnmatchedIdentity = true) {
+			const outputIndex = readOutputIndex(event);
+			if (outputIndex !== void 0) {
+				const indexed = indexedCalls.get(outputIndex);
+				if (indexed) {
+					if (indexed.callId && identity.callId && indexed.callId !== identity.callId) return;
+					return adoptIdentity(indexed, identity);
+				}
+				const unindexed = resolveCompatible(unindexedCalls, identity, allowUnmatchedIdentity);
+				if (unindexed) {
+					unindexedCalls.delete(unindexed);
+					unindexed.outputIndex = outputIndex;
+					indexedCalls.set(outputIndex, unindexed);
+				}
+				return unindexed;
+			}
+			return resolveCompatible([...indexedCalls.values(), ...unindexedCalls], identity, allowUnmatchedIdentity);
+		},
+		forget(toolCall) {
+			for (const [outputIndex, tracked] of indexedCalls) if (tracked === toolCall) indexedCalls.delete(outputIndex);
+			unindexedCalls.delete(toolCall);
+		},
+		markArgumentsUnreliable() {
+			for (const toolCall of /* @__PURE__ */ new Set([...indexedCalls.values(), ...unindexedCalls])) toolCall.argumentStreamReliable = false;
+		},
+		hasActive() {
+			return indexedCalls.size > 0 || unindexedCalls.size > 0;
+		},
+		hasExactlyActive(expected) {
+			const active = /* @__PURE__ */ new Set([...indexedCalls.values(), ...unindexedCalls]);
+			return active.size === expected.length && expected.every((state) => active.has(state));
+		}
+	};
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-stream-observer-internal.ts
@@ -1205,8 +1475,12 @@ async function* observeResponsesStream(stream, model, requestStartedAt) {
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-stream-slots-internal.ts
-function createResponsesOutputTracker() {
+function createResponsesOutputTracker(params) {
 	const outputs = /* @__PURE__ */ new Map();
+	let currentEventType = "unknown";
+	let providerToolObserved = false;
+	let visibleTextEmitted = false;
+	let terminalAllowsRetry = false;
 	const identity = (item) => {
 		if ((item.type === "reasoning" || item.type === "message") && item.id) return `${item.type}:${item.id}`;
 		const callId = item.call_id ?? item.id;
@@ -1216,10 +1490,37 @@ function createResponsesOutputTracker() {
 		const key = identity(item);
 		const output = (outputIndex === void 0 ? void 0 : outputs.get(outputIndex)) ?? (key === void 0 ? void 0 : outputs.get(key));
 		if (!output || outputIndex !== void 0 && output.outputIndex !== void 0 && output.outputIndex !== outputIndex) return;
-		if (output.type !== item.type || output.callId && item.call_id && output.callId !== item.call_id) throw new Error("Responses stream changed output item identity");
+		if (output.type !== item.type || output.callId && item.call_id && output.callId !== item.call_id) throw new ResponsesOutputIdentityError({
+			outputIndex,
+			expectedType: output.type,
+			actualType: item.type,
+			completed: output.completed,
+			completedToolCall: [...outputs.values()].some((candidate) => candidate.type === "function_call" && candidate.completed),
+			eventType: currentEventType,
+			retrySafe: params.canRetryIdentityConflict?.() === true && !providerToolObserved && !visibleTextEmitted && terminalAllowsRetry && !params.output.content.some((block) => block.type === "text" && block.text.length > 0)
+		});
 		return output;
 	};
 	return {
+		trackStream(sink) {
+			return { push(event) {
+				visibleTextEmitted ||= event.type === "text_delta" && event.delta.length > 0 || event.type === "text_end" && event.content.length > 0;
+				sink.push(event);
+			} };
+		},
+		observeEvent(event) {
+			currentEventType = event.type;
+			terminalAllowsRetry = false;
+			if (event.type === "response.output_item.added" || event.type === "response.output_item.done") providerToolObserved ||= isResponsesProviderTool(event.item);
+			else if (event.type === "response.completed" || event.type === "response.incomplete") {
+				let terminalHasRefusal = false;
+				for (const item of event.response.output ?? []) {
+					providerToolObserved ||= isResponsesProviderTool(item);
+					terminalHasRefusal ||= item.type === "message" && (item.content ?? []).some((part) => part.type === "refusal");
+				}
+				terminalAllowsRetry = event.type === "response.completed" && event.response.status === "completed" && event.response.error == null && event.response.incomplete_details == null && !terminalHasRefusal;
+			}
+		},
 		get,
 		set(item, contentIndex, outputIndex, completed = false) {
 			const output = get(item, outputIndex) ?? {
@@ -1278,6 +1579,11 @@ function createResponsesOutputSlotTracker() {
 			const outputIndex = readResponsesOutputIndex(event);
 			return outputIndex === void 0 ? unindexed : indexed.get(outputIndex);
 		},
+		resolveOutputItem(event, item) {
+			if (item.type === "reasoning") return this.resolve(event, "thinking");
+			if (item.type === "message") return this.resolve(event, "text");
+			return readResponsesOutputIndex(event) === void 0 ? void 0 : this.get(event);
+		},
 		values() {
 			return [.../* @__PURE__ */ new Set([...indexed.values(), ...unindexed ? [unindexed] : []])];
 		},
@@ -1288,86 +1594,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 +1787,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 +1818,18 @@ 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,
+				stopReason: terminal.stopReason,
+				...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,
@@ -1602,10 +1840,14 @@ function createResponsesTerminalController(params) {
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-stream-internal.ts
-async function processResponsesStream(openaiStream, output, stream, model, options) {
+async function processResponsesStream(openaiStream, output, sink, model, options) {
 	const streamingToolCalls = createResponsesToolCallTracker();
 	const outputSlots = createResponsesOutputSlotTracker();
-	const outputs = createResponsesOutputTracker();
+	const outputs = createResponsesOutputTracker({
+		output,
+		canRetryIdentityConflict: options?.canRetryIdentityConflict
+	});
+	const stream = outputs.trackStream(sink);
 	let terminalResponse;
 	let incompleteToolCall;
 	let lastTextBlock = null;
@@ -1664,11 +1906,6 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 			return slot;
 		}
 	};
-	const resolveOutputItemSlot = (event, item) => {
-		if (item.type === "reasoning") return outputSlots.resolve(event, "thinking");
-		if (item.type === "message") return outputSlots.resolve(event, "text");
-		return readResponsesOutputIndex(event) === void 0 ? void 0 : outputSlots.get(event);
-	};
 	const materializeDeferredTextSlot = (slot) => {
 		if (slot.block || slot.pendingText === null) return;
 		const text = slot.pendingText;
@@ -1784,6 +2021,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 	}), options?.signal);
 	try {
 		for await (const event of guardedStream) {
+			outputs.observeEvent(event);
 			notifyLlmRequestActivity(options?.signal);
 			if (event.type === "response.output_item.done" && event.item.type === "function_call" && event.item.status === "incomplete") incompleteToolCall ??= event.item;
 			if (incompleteToolCall && event.type !== "response.completed" && event.type !== "response.incomplete" && event.type !== "response.failed" && event.type !== "error") continue;
@@ -1807,6 +2045,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 						block: toolCallBlock,
 						contentIndex,
 						argumentStreamReliable: true,
+						argumentsStreamed: false,
 						previewSchedule: createToolArgumentPreviewSchedule(),
 						...readResponsesToolCallItemIdentity(item)
 					};
@@ -1900,6 +2139,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 +2157,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);
@@ -1931,7 +2172,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 			} else if (event.type === "response.output_item.done") {
 				const item = event.item;
 				if (item.type !== "message") lastTextBlock = null;
-				const existingOutputSlot = resolveOutputItemSlot(event, item);
+				const existingOutputSlot = outputSlots.resolveOutputItem(event, item);
 				materializeDeferredTextSlots(existingOutputSlot);
 				const outputSlot = existingOutputSlot ?? createOutputSlot(event, item);
 				compactionTracker.completed(item, blocks.length);
@@ -2012,9 +2253,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 parsedStreamedArguments = streamingToolCall?.argumentStreamReliable && streamingToolCall?.argumentsStreamed && streamedArguments.length > 0 && completedArguments !== void 0 && streamedArguments !== completedArguments ? parseJsonObjectPreservingUnsafeIntegers(streamedArguments) : null;
 					const validated = resolveCompletedResponsesToolCall(item, {
 						name: streamingToolCall?.block.name,
-						arguments: completedArguments || streamingToolCall?.block.partialJson || ""
+						arguments: parsedStreamedArguments ?? (completedArguments || streamedArguments)
 					});
 					finalizeToolCall(item, readResponsesOutputIndex(event), streamingToolCall, validated);
 				}
@@ -2036,8 +2279,15 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				terminalResponse = event.type === "response.completed" ? event.response : null;
 				if (output.stopReason === "stop" && output.content.some((block) => block.type === "toolCall")) output.stopReason = "toolUse";
 				break;
-			} else if (event.type === "error") throw new Error(event.message ? `Error Code ${event.code}: ${event.message}` : "Unknown error");
-			else if (event.type === "response.failed") {
+			} else if (event.type === "error") {
+				const details = isRecord(event) && isRecord(event.error) ? event.error : event;
+				const message = readStringValue(details.message);
+				const code = normalizeStringifiedOptionalString(details.code);
+				throw Object.assign(new Error(message ? code ? `Error Code ${code}: ${message}` : message : "Unknown error"), {
+					code: details.code,
+					error: details
+				});
+			} else if (event.type === "response.failed") {
 				const failure = normalizeResponsesFailedEvent(isRecord(event) ? event : {}, model);
 				terminal.finalizeFailedResponse(event.response, failure.responseId);
 				throw new ResponsesStreamFailure(failure, event.response);
@@ -2052,33 +2302,54 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 	}
 }
 //#endregion
+//#region packages/ai/src/providers/openai-provider-refusal.ts
+/** Responses uses snake_case; the ChatGPT app-server error envelope uses camelCase. */
+function readOpenAIMisalignmentReview(value, continuationSupported) {
+	if (!isRecord(value)) return;
+	return readProviderRefusalReview({
+		explanation: value.detailed_explanation ?? value.detailedExplanation,
+		errorType: value.error_type ?? value.errorType,
+		...continuationSupported ? { continuation: value.steer } : {}
+	});
+}
+//#endregion
 //#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) {
 	if (options?.strict !== void 0) return options.strict;
 	if (options?.model) return getAiTransportHost().resolveOpenAIStrictToolSetting(options.model, {
 		transport: "stream",
-		supportsStrictMode: options.supportsStrictMode
+		supportsStrictMode: options.supportsStrictMode ?? resolveOpenAICompletionsCompat(options.model).supportsStrictMode
 	});
 	return false;
 }
@@ -2099,19 +2370,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 +2379,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 +2416,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 +2428,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,
@@ -2195,17 +2457,33 @@ async function runResponsesStreamLifecycle(params) {
 				onFirstEventTimeout: params.processStreamOptions?.onFirstEventTimeout ?? onFirstEventTimeout,
 				signal: params.processStreamOptions?.signal ?? options?.signal
 			} : void 0,
+			canRetryIdentityConflict: () => hasOnlyResponsesFunctionTools(admittedRequest),
 			reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
 				sessionId: options?.sessionId,
 				authProfileId: options?.authProfileId
 			})
 		});
+		if (terminal && admittedRequest && !options?.signal?.aborted) recordResponsesContextUsage(output, model, options, admittedRequest, terminal.output, "provider");
 		finalizeTransportStream({
 			stream,
 			output,
 			signal: options?.signal
 		});
 	} catch (error) {
+		const response = error instanceof ResponsesStreamFailure ? error.response : error;
+		const rawError = isRecord(response) && isRecord(response.error) ? response.error : response;
+		if (params.model.provider === "openai" && params.model.api === "openai-responses" && isRecord(rawError) && rawError.code === "misalignment_policy_violation") {
+			const review = readOpenAIMisalignmentReview(rawError.misalignment, false);
+			appendAssistantMessageDiagnostic(output, {
+				type: "provider_refusal",
+				timestamp: Date.now(),
+				details: {
+					provider: "openai",
+					category: "misalignment",
+					...review ? { review } : {}
+				}
+			});
+		}
 		failTransportStream({
 			stream,
 			output,
@@ -2218,4 +2496,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 { summarizeOpenAITransportError as A, resolveResponsesContinuationRequest as B, createResponsesStreamWithEncryptedContentRetry as C, ResponsesStreamFailure as D, resolveNextResponsesEncryptedContentAttempt as E, convertResponsesMessages$1 as F, supportsResponsesReasoningUpdate as G, responsesContinuationRequestFingerprint as H, createOpenAIResponsesAssistantOutput as I, captureOpenAIResponsesCompaction as J, CompactionReplayRefreshRequiredError as K, recordResponsesInputReplay as L, recordResponsesContextUsage as M, resolveResponsesContextUsageBoundary as N, logResponsesFailedNoDetails as O, buildResponsesInputMessage as P, resolveReplayableResponsesMessageId as Q, responsesInputFingerprint as R, commitResponsesEncryptedContentAttempt as S, resolveAzureOpenAIApiVersion as T, isConfigurationUpdate as U, responsesContinuationPrefixFingerprint as V, replayResponsesReasoningUpdates as W, resolveNewestOpenAIResponsesCompactionReplay as X, isOpenAIResponsesReplayContext as Y, suppressOpenAIResponsesCompaction as Z, isAzureResponsesTextDeltaEvent as _, runResponsesStreamLifecycle as a, isResponsesTextDeltaEventType as b, readOpenAIMisalignmentReview as c, createResponsesToolCallTracker as d, readResponsesToolCallItemIdentity as f, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as g, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as h, createResponsesAssistantOutput as i, summarizeResponsesPayload as j, safeDebugValue as k, processResponsesStream as l, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as m, applyResponsesServiceTierPricing as n, convertResponsesToolPayload as o, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as p, buildOpenAIResponsesReasoningReplayMetadata as q, convertResponsesMessages as r, prepareResponsesTools as s, applyCommonResponsesParams as t, observeResponsesStream as u, isAzureResponsesTextDeltaEventType as v, isInvalidEncryptedContentError as w, resolveResponsesMessageSnapshotCollapse as x, isResponsesTextContentPartType as y, claimOpenAIResponsesHttpContinuation as z };