@openclaw/ai 2026.9.6 → 2026.9.8

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

@@ -1,27 +1,25 @@
 import { o as readProviderRefusalReview, t as appendAssistantMessageDiagnostic } from "./diagnostics-DzrF1h4J.mjs";
-import { r as appendAssistantThinking } from "./event-stream-D8PARQfL.mjs";
+import { r as appendAssistantThinking } from "./event-stream-vd9UnCAU.mjs";
+import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
+import { k as isImageWithMediaPayload, n as getAiTransportHost, r as resolveAiTransportHeaderSentinels, w as calculateCost } from "./host-DwBmNMCC.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 { 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 { d as supportsOpenAITemperature } from "./openai-reasoning-effort-C_0p3psG.mjs";
+import { o as truncateUtf16Safe, s as stableStringify } from "./provider-error-CwT_j2v0.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-CJaB6g8J.mjs";
+import { o as redactSensitiveText } from "./transport-utils-CqXzku3R.mjs";
+import { i as resolveOpenAICompletionsCompat } from "./openai-completions-compat-BJf57ZxN.mjs";
+import { A as shortHash, C as parseJsonObjectPreservingUnsafeIntegers, E as createToolArgumentPreviewSchedule, O as parseStreamingJson, S as withProviderResponseHook, _ as sanitizeNonEmptyTransportPayloadText, b as transportAbortError, c as failTransportStream, d as iterateModelStream, g as parseTerminalToolCallArguments, t as IncompleteToolCallError, u as finalizeTransportStream, v as sanitizeTransportPayloadText } from "./transport-stream-shared-BU5pwY6W.mjs";
+import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, d as describeToolResultMediaPlaceholder, m as extractToolResultText, s as prepareModelRequestBody } from "./simple-options-BkDPMuxw.mjs";
+import { A as redactIdentifier, C as log, d as prepareOpenAITools, h as resolveOpenAIRequestReasoning, j as sha256Hex, u as resolveOpenAIStrictToolFlagWithDiagnostics, y as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-DyFJ4cgR.mjs";
+import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-Bs5aWE1d.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-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 { t as transformProviderMessages } from "./provider-transcript-transform-DjA5Fk2P.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-B9o0S4SZ.mjs";
+import { a as resolveOpenAIProjectedToolsStrictToolFlag, f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-vsl-cE-n.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-CLxnqS9p.mjs";
+import { n as isOpenAIResponsesCompactionOutput, r as readOpenAIResponsesCompactionWindow } from "./openai-responses-compaction-window-CYGCjAQz.mjs";
 import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
-import { createHash, randomUUID } from "node:crypto";
+import { 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. */
 function resolveReplayableResponsesMessageId(params) {
@@ -30,12 +28,68 @@ function resolveReplayableResponsesMessageId(params) {
 	return params.previousReplayItemWasReasoning ? params.textSignatureId : void 0;
 }
 //#endregion
+//#region packages/ai/src/transports/openai-responses-tool-call-id-shape.ts
+/**
+* Pure OpenAI Responses `call_*`/`fc_*` tool-call-id shape helpers.
+*
+* Moved out of embedded-agent-helpers/openai.ts (the AgentMessage[]-walking
+* caller lives in src/agents and imports from packages/ai, so the reverse
+* import direction is not available) so the continuation transport can
+* recognize its own cached raw ids after this same reshaping and restore
+* them on a replayed wire request -- see openai-responses-continuation.ts.
+*/
+const OPENAI_RESPONSES_ID_MAX_LENGTH = 64;
+const OPENAI_RESPONSES_CALL_ID_RE = /^call_[A-Za-z0-9_-]{1,59}$/;
+const OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE = /^fc_[A-Za-z0-9_-]{1,61}$/;
+function splitOpenAIFunctionCallPairing(id) {
+	const separator = id.indexOf("|");
+	if (separator <= 0 || separator >= id.length - 1) return { callId: id };
+	return {
+		callId: id.slice(0, separator),
+		itemId: id.slice(separator + 1)
+	};
+}
+function shortOpenAIResponsesIdHash(id) {
+	return sha256Hex(id).slice(0, 10);
+}
+function sanitizeOpenAIResponsesIdTail(value) {
+	return value.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
+}
+function normalizeOpenAIResponsesIdPart(params) {
+	const trimmed = params.value.trim();
+	if (params.isValid(trimmed)) return trimmed;
+	const rawTail = trimmed.startsWith(params.prefix) ? trimmed.slice(params.prefix.length) : trimmed;
+	const hash = shortOpenAIResponsesIdHash(trimmed || params.prefix);
+	const maxTailLength = 64 - params.prefix.length;
+	const hashSuffix = `_${hash}`;
+	const tail = `${sanitizeOpenAIResponsesIdTail(rawTail).slice(0, Math.max(1, maxTailLength - hashSuffix.length)) || "id"}${hashSuffix}`.slice(0, maxTailLength);
+	return `${params.prefix}${tail}`;
+}
+/** Same shaping `normalizeOpenAIResponsesToolCallIds` applies to a replayed `call_id`/`call_id|fc_id` pair. */
+function normalizeOpenAIResponsesFunctionCallId(id) {
+	const { callId, itemId } = splitOpenAIFunctionCallPairing(id);
+	const normalizedCallId = normalizeOpenAIResponsesIdPart({
+		value: itemId ? `${callId}|${itemId}` : callId,
+		prefix: "call_",
+		isValid: (value) => OPENAI_RESPONSES_CALL_ID_RE.test(value)
+	});
+	if (!itemId) return normalizedCallId;
+	return `${normalizedCallId}|${normalizeOpenAIResponsesIdPart({
+		value: itemId,
+		prefix: "fc_",
+		isValid: (value) => OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE.test(value)
+	})}`;
+}
+function shouldNormalizeOpenAIResponsesToolCallId(id) {
+	const pairing = splitOpenAIFunctionCallPairing(id);
+	if (!OPENAI_RESPONSES_CALL_ID_RE.test(pairing.callId)) return true;
+	if (pairing.itemId === void 0) return false;
+	return !OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE.test(pairing.itemId);
+}
+//#endregion
 //#region packages/ai/src/transports/openai-responses-compaction-replay.ts
 const OPENAI_RESPONSES_COMPACTION_SUPPRESSION_TYPE = "openai-responses-compaction-suppression";
 const OPENAI_RESPONSES_COMPACTION_SUPPRESSION_DATA = "rejected";
-function buildOpenAIResponsesReplayContext(model, options) {
-	return buildProviderReplayContext(model, options);
-}
 function isOpenAIResponsesReplayContext(value) {
 	if (!isRecord(value)) return false;
 	return typeof value.provider === "string" && typeof value.api === "string" && typeof value.model === "string" && (value.baseUrlHash === void 0 || typeof value.baseUrlHash === "string") && (value.sessionHash === void 0 || typeof value.sessionHash === "string") && (value.authProfileHash === void 0 || typeof value.authProfileHash === "string");
@@ -82,7 +136,7 @@ function captureOpenAIResponsesCompaction(output, item, boundary, model, capture
 	output.providerReplay = replay;
 }
 function suppressOpenAIResponsesCompaction(output, model, options, rejectedCheckpoint) {
-	const context = buildOpenAIResponsesReplayContext(model, options);
+	const context = buildProviderReplayContext(model, options);
 	if (!context.baseUrlHash) return;
 	output.providerReplay = {
 		v: 1,
@@ -114,7 +168,7 @@ function isSafeResponsesReplayItemId(id) {
 	return typeof id === "string" && id.length > 0 && id.length <= 64;
 }
 function resolveNewestOpenAIResponsesCompactionReplay(messages, model, options) {
-	const context = buildOpenAIResponsesReplayContext(model, options);
+	const context = buildProviderReplayContext(model, options);
 	for (let index = messages.length - 1; index >= 0; index -= 1) {
 		const message = messages[index];
 		if (message?.role !== "assistant") continue;
@@ -186,7 +240,7 @@ function buildOpenAIResponsesReasoningReplayMetadata(model, options) {
 	return {
 		v: 1,
 		source: "openai-responses",
-		...buildOpenAIResponsesReplayContext(model, options)
+		...buildProviderReplayContext(model, options)
 	};
 }
 //#endregion
@@ -260,12 +314,87 @@ function requestWithoutInput(request) {
 		metadata
 	};
 }
-function normalizeAssistantReplayInput(input, fromResponse = false) {
+function canonicalizeToolCallId(callId, itemId) {
+	if (typeof callId !== "string") return callId;
+	const paired = typeof itemId === "string" && itemId ? `${callId}|${itemId}` : callId;
+	if (!shouldNormalizeOpenAIResponsesToolCallId(paired)) return callId;
+	return splitOpenAIFunctionCallPairing(normalizeOpenAIResponsesFunctionCallId(paired)).callId;
+}
+function responseToolCalls(items) {
+	return items.flatMap((item) => {
+		if (!isRecord(item) || item.type !== "function_call" || typeof item.call_id !== "string") return [];
+		return [{
+			callId: item.call_id,
+			...typeof item.id === "string" ? { itemId: item.id } : {}
+		}];
+	});
+}
+function toolCallReplayShapes(call) {
+	return new Set([
+		call.callId,
+		canonicalizeToolCallId(call.callId, call.itemId),
+		canonicalizeToolCallId(call.callId, void 0)
+	].filter((shape) => typeof shape === "string"));
+}
+function toolCallOwnerByReplayShape(calls) {
+	const ownerByReplayShape = /* @__PURE__ */ new Map();
+	for (const [index, call] of calls.entries()) for (const replayShape of toolCallReplayShapes(call)) {
+		const owner = ownerByReplayShape.get(replayShape);
+		ownerByReplayShape.set(replayShape, owner === void 0 || owner === index ? index : null);
+	}
+	return ownerByReplayShape;
+}
+function pendingResponsesToolCalls(calls, input) {
+	const ownerByReplayShape = toolCallOwnerByReplayShape(calls);
+	const replayedCallIds = /* @__PURE__ */ new Set();
+	const lastCallPosition = /* @__PURE__ */ new Map();
+	const lastOutputPosition = /* @__PURE__ */ new Map();
+	for (const [inputIndex, item] of input.entries()) {
+		if (!isRecord(item) || typeof item.call_id !== "string") continue;
+		const owner = ownerByReplayShape.get(item.call_id);
+		if (item.type === "function_call") {
+			replayedCallIds.add(item.call_id);
+			if (owner !== void 0 && owner !== null) lastCallPosition.set(owner, inputIndex);
+			continue;
+		}
+		if (item.type !== "function_call_output") continue;
+		if (owner !== void 0 && owner !== null) lastOutputPosition.set(owner, inputIndex);
+	}
+	return calls.filter((_call, index) => {
+		const callPosition = lastCallPosition.get(index);
+		return [...toolCallReplayShapes(_call)].some((shape) => replayedCallIds.has(shape)) && (callPosition === void 0 || (lastOutputPosition.get(index) ?? -1) < callPosition);
+	});
+}
+function recordResponsesContinuationState(previous, lastRequest, response, continued = false) {
+	const calls = previous && continued ? [...previous.pendingToolCalls ?? [], ...responseToolCalls(previous.lastResponseItems)] : responseToolCalls(lastRequest.input ?? []);
+	const seenCalls = /* @__PURE__ */ new Set();
+	const pendingToolCalls = pendingResponsesToolCalls(calls.filter((call) => {
+		const key = JSON.stringify([call.callId, call.itemId]);
+		if (seenCalls.has(key)) return false;
+		seenCalls.add(key);
+		return true;
+	}), lastRequest.input ?? []);
+	return {
+		lastRequest,
+		lastResponseId: response.id,
+		lastResponseItems: response.output,
+		pendingToolCalls
+	};
+}
+function normalizeAssistantReplayInput(input, fromResponse = false, ignoreCachedItemIds = 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 (item.type !== "function_call" && item.type !== "function_call_output" && !(item.type === "message" && item.role === "assistant")) return item;
+		const { id: rawId, status: _status, ...stableItem } = item;
+		if (item.type === "function_call_output") {
+			if ("id" in item) stableItem.id = item.id;
+			if ("status" in item) stableItem.status = item.status;
+		}
+		if ("call_id" in stableItem) {
+			const itemId = item.type === "function_call" && !(fromResponse && ignoreCachedItemIds) ? rawId : void 0;
+			stableItem.call_id = canonicalizeToolCallId(stableItem.call_id, itemId);
+		}
 		if (fromResponse && item.type === "function_call") {
 			const args = parseJsonObjectPreservingUnsafeIntegers(stableItem.arguments);
 			stableItem.arguments = args ? JSON.stringify(args) : stableItem.arguments;
@@ -278,6 +407,53 @@ function normalizeAssistantReplayInput(input, fromResponse = false) {
 		return stableItem;
 	});
 }
+function normalizeContinuationHistory(input) {
+	const normalized = normalizeAssistantReplayInput(input);
+	const ownerByReplayShape = toolCallOwnerByReplayShape(responseToolCalls(input));
+	let callIndex = 0;
+	for (const [index, item] of input.entries()) {
+		const normalizedItem = normalized[index];
+		if (!isRecord(item) || !isRecord(normalizedItem)) continue;
+		if (item.type === "function_call") {
+			if (typeof normalizedItem.call_id !== "string") return;
+			const callOwner = ownerByReplayShape.get(normalizedItem.call_id);
+			if (callOwner !== callIndex) return;
+			normalizedItem.call_id = { callOwner };
+			callIndex += 1;
+			continue;
+		}
+		if (item.type !== "function_call_output" || typeof item.call_id !== "string") continue;
+		const owner = ownerByReplayShape.get(item.call_id);
+		if (owner === null) return;
+		normalizedItem.call_id = owner === void 0 ? { unknownCallId: canonicalizeToolCallId(item.call_id, void 0) } : { callOwner: owner };
+	}
+	return normalized;
+}
+function continuationHistoryMatches(previousInput, currentInput) {
+	for (const [index, previousItem] of previousInput.entries()) {
+		const currentItem = currentInput[index];
+		if (!isRecord(previousItem) || !isRecord(currentItem)) continue;
+		if (previousItem.type === "function_call" && currentItem.type === "function_call") {
+			if (typeof previousItem.call_id === "string" && typeof currentItem.call_id === "string" && !toolCallReplayShapes({
+				callId: previousItem.call_id,
+				...typeof previousItem.id === "string" ? { itemId: previousItem.id } : {}
+			}).has(currentItem.call_id)) return false;
+		}
+		if (previousItem.type === "function_call_output" && currentItem.type === "function_call_output" && typeof previousItem.call_id === "string" && typeof currentItem.call_id === "string" && currentItem.call_id !== previousItem.call_id && currentItem.call_id !== canonicalizeToolCallId(previousItem.call_id, void 0)) return false;
+	}
+	const previousCalls = responseToolCalls(previousInput);
+	const currentCalls = responseToolCalls(currentInput);
+	if (previousCalls.length !== currentCalls.length) return false;
+	for (const [index, previousCall] of previousCalls.entries()) {
+		const currentCall = currentCalls[index];
+		if (!currentCall) return false;
+		const previousShapes = toolCallReplayShapes(previousCall);
+		if (![...toolCallReplayShapes(currentCall)].some((shape) => previousShapes.has(shape))) return false;
+	}
+	const normalizedPrevious = normalizeContinuationHistory(previousInput);
+	const normalizedCurrent = normalizeContinuationHistory(currentInput);
+	return normalizedPrevious !== void 0 && normalizedCurrent !== void 0 && jsonValuesEqual(normalizedCurrent, normalizedPrevious);
+}
 function responsesContinuationRequestFingerprint(request) {
 	const serialized = JSON.stringify(requestWithoutInput(request));
 	return sha256Hex(stableStringify(JSON.parse(serialized)));
@@ -286,6 +462,34 @@ function responsesContinuationPrefixFingerprint(input, output = []) {
 	const serialized = JSON.stringify([...normalizeAssistantReplayInput(input), ...normalizeAssistantReplayInput(output, true)]);
 	return sha256Hex(stableStringify(JSON.parse(serialized)));
 }
+function restoreRawCallIdsInDelta(delta, cachedResponseItems, replayedToolRound, pendingToolCalls) {
+	const currentResponseCalls = responseToolCalls(cachedResponseItems);
+	const replayedCalls = replayedToolRound.filter((item) => isRecord(item) && item.type === "function_call");
+	if (currentResponseCalls.length !== replayedCalls.length) return;
+	const cachedCalls = [...pendingToolCalls, ...currentResponseCalls];
+	const currentCallOffset = pendingToolCalls.length;
+	const ownerByReplayShape = toolCallOwnerByReplayShape(cachedCalls);
+	for (const index of currentResponseCalls.keys()) {
+		const replayedCallId = replayedCalls[index]?.call_id;
+		if (typeof replayedCallId !== "string" || ownerByReplayShape.get(replayedCallId) !== currentCallOffset + index) return;
+	}
+	const restoredDelta = [];
+	for (const item of delta) {
+		if (!isRecord(item) || item.type !== "function_call_output" || typeof item.call_id !== "string") {
+			restoredDelta.push(item);
+			continue;
+		}
+		const owner = ownerByReplayShape.get(item.call_id);
+		if (owner === void 0 || owner === null) return;
+		const rawCallId = cachedCalls[owner]?.callId;
+		if (!rawCallId) return;
+		restoredDelta.push(rawCallId === item.call_id ? item : {
+			...item,
+			call_id: rawCallId
+		});
+	}
+	return restoredDelta;
+}
 function resolveResponsesContinuationRequest(continuation, request, steering) {
 	if (!continuation) return {
 		request,
@@ -311,15 +515,24 @@ function resolveResponsesContinuationRequest(continuation, request, steering) {
 		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 {
+	const replayedToolRoundInput = currentInput.slice(previousInput.length, baselineLength);
+	const replayedToolRound = normalizeAssistantReplayInput(replayedToolRoundInput);
+	const historyToolRoundUnchanged = jsonValuesEqual(replayedToolRound, normalizeAssistantReplayInput(continuation.lastResponseItems, true)) || jsonValuesEqual(replayedToolRound, normalizeAssistantReplayInput(continuation.lastResponseItems, true, true));
+	if (!continuationHistoryMatches(previousInput, currentInput.slice(0, previousInput.length)) || !historyToolRoundUnchanged) return {
 		request,
 		continuationStatus: "history_changed"
 	};
+	const restoredInput = restoreRawCallIdsInDelta(currentInput.slice(baselineLength), continuation.lastResponseItems, replayedToolRoundInput, continuation.pendingToolCalls ?? []);
+	if (!restoredInput) return {
+		request,
+		continuationStatus: "history_changed"
+	};
+	const restoredResponseInput = restoredInput;
 	return {
 		request: {
 			...prepared,
 			previous_response_id: continuation.lastResponseId,
-			input: currentInput.slice(baselineLength)
+			input: restoredResponseInput
 		},
 		...prepared !== request ? { fullRequest: prepared } : {},
 		continuationStatus: "continued"
@@ -354,16 +567,12 @@ function claimOpenAIResponsesHttpContinuation(params) {
 		return {
 			request: params.request.store === false ? fullRequest : resolved.request,
 			fullRequest,
-			commit: (effectiveRequest, response) => {
+			commit: (effectiveRequest, response, dispatchedPreviousResponseId) => {
 				if (httpContinuationEntries.get(key) !== claimed) return;
 				const ready = {
 					...claimed,
 					kind: "ready",
-					state: {
-						lastRequest: effectiveRequest,
-						lastResponseId: response.id,
-						lastResponseItems: response.output
-					},
+					state: recordResponsesContinuationState(previous?.kind === "ready" ? previous.state : void 0, effectiveRequest, response, previous?.kind === "ready" && dispatchedPreviousResponseId === previous.state.lastResponseId),
 					idleTimer: setTimeout(() => deleteHttpContinuationIfOwned(key, ready), HTTP_CONTINUATION_IDLE_TTL_MS)
 				};
 				ready.idleTimer.unref?.();
@@ -575,36 +784,23 @@ function parseOpenAIResponsesTextSignature(signature) {
 	} catch {}
 	return { id: signature };
 }
-function buildResponsesInputMessage(role, content) {
+const responsesInputSource = Symbol("openclaw.responsesInputSource");
+/** Source identity survives payload spreads but never enters serialized provider input. */
+function bindResponsesInputMessage(source) {
+	const identity = {};
+	Object.defineProperty(source, responsesInputSource, {
+		value: identity,
+		enumerable: true
+	});
+	return (input) => typeof input === "object" && input !== null && Reflect.get(input, responsesInputSource) === identity;
+}
+function buildResponsesInputMessage(role, content, source) {
+	const identity = source && Reflect.get(source, responsesInputSource);
 	return {
 		type: "message",
 		role,
-		content
-	};
-}
-function createOpenAIResponsesAssistantOutput(model, api = model.api) {
-	return {
-		role: "assistant",
-		content: [],
-		api,
-		provider: model.provider,
-		model: model.id,
-		usage: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 0,
-			cost: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				total: 0
-			}
-		},
-		stopReason: "stop",
-		timestamp: Date.now()
+		content,
+		...identity ? { [responsesInputSource]: identity } : {}
 	};
 }
 function convertResponsesMessagesWithStyle(model, context, allowedToolCallProviders, options, conversionStyle) {
@@ -612,7 +808,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 	const providerStyle = conversionStyle === "provider";
 	const shouldReplayReasoningItems = options?.replayReasoningItems ?? true;
 	const shouldReplayResponsesItemIds = options?.replayResponsesItemIds ?? true;
-	const replayContext = buildOpenAIResponsesReplayContext(model, {
+	const replayContext = buildProviderReplayContext(model, {
 		sessionId: options?.sessionId,
 		authProfileId: options?.authProfileId
 	});
@@ -650,7 +846,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 		authProfileId: options?.authProfileId,
 		mode: options?.replayMode
 	});
-	const transformMessages = (source) => providerStyle ? transformProviderMessages(source, model, normalizeToolCallId) : transformTransportMessages(source, model, normalizeToolCallId, {
+	const transformMessages = (source) => providerStyle ? transformProviderMessages(source, model, normalizeToolCallId) : getAiTransportHost().transformTransportMessages(source, model, normalizeToolCallId, {
 		normalizeSameModelToolCallIds: shouldNormalizeSameModelToolCallIds,
 		preserveUnframedToolResults: replayPlan.preserveUnframedToolResults
 	});
@@ -686,7 +882,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 			if (typeof msg.content === "string") messages.push(buildResponsesInputMessage("user", [{
 				type: "input_text",
 				text: sanitizeTransportPayloadText(msg.content)
-			}]));
+			}], msg));
 			else {
 				const content = msg.content.map((item) => item.type === "text" ? {
 					type: "input_text",
@@ -696,7 +892,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 					detail: "auto",
 					image_url: `data:${item.mimeType};base64,${item.data}`
 				}).filter((item) => providerStyle || model.input.includes("image") || item.type !== "input_image");
-				if (content.length > 0) messages.push(buildResponsesInputMessage("user", content));
+				if (content.length > 0) messages.push(buildResponsesInputMessage("user", content, msg));
 				else if (providerStyle) continue;
 			}
 		} else if (msg.role === "assistant") {
@@ -794,7 +990,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 	}
 	return messages;
 }
-function convertResponsesMessages$1(model, context, allowedToolCallProviders, options) {
+function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
 	return convertResponsesMessagesWithStyle(model, context, allowedToolCallProviders, options, "transport");
 }
 function convertProviderResponsesMessages(model, context, allowedToolCallProviders, options) {
@@ -827,7 +1023,7 @@ function contextFingerprint(input, output = []) {
 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, {
+	const replayOutput = (projection === "transport" ? convertResponsesMessages : convertProviderResponsesMessages)(model, { messages: [message] }, TOOL_CALL_PROVIDERS, {
 		...identity,
 		includeSystemPrompt: false
 	}).filter((item) => item.type !== "function_call_output");
@@ -856,7 +1052,7 @@ function resolveResponsesContextUsageBoundary(messages, model, identity, systemP
 		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, {
+		const input = (projection === "transport" ? convertResponsesMessages : convertProviderResponsesMessages)(model, {
 			messages: messages.filter(isProviderMessage),
 			systemPrompt
 		}, TOOL_CALL_PROVIDERS, {
@@ -919,9 +1115,6 @@ function responseInputItemShape(input) {
 		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",
@@ -932,9 +1125,9 @@ function summarizeResponsesCompactionItems(input) {
 	const compactions = input.flatMap((item, inputIndex) => {
 		if (!isRecord(item) || item.type !== "compaction") return [];
 		return [{
-			idHash: typeof item.id === "string" ? hashOpaqueResponsesValue(item.id) : void 0,
+			idHash: typeof item.id === "string" ? sha256Hex(item.id) : void 0,
 			inputIndex,
-			payloadHash: typeof item.encrypted_content === "string" ? hashOpaqueResponsesValue(item.encrypted_content) : void 0
+			payloadHash: typeof item.encrypted_content === "string" ? sha256Hex(item.encrypted_content) : void 0
 		}];
 	});
 	return [
@@ -1248,6 +1441,7 @@ async function resolveNextResponsesEncryptedContentAttempt(attempt, error, optio
 	};
 }
 async function createResponsesStreamWithEncryptedContentRetry(params) {
+	const encodeBody = params.encodeBody ?? prepareModelRequestBody(void 0);
 	const send = async (initialAttempt) => {
 		let attempt = initialAttempt;
 		for (;;) {
@@ -1255,8 +1449,16 @@ async function createResponsesStreamWithEncryptedContentRetry(params) {
 				egress: "responses-sdk",
 				payloadVariant: attempt.kind
 			});
+			const bodyOptions = await encodeBody(attempt.request);
 			try {
-				const { data, response } = await params.client.responses.create(attempt.request, params.requestOptions).withResponse();
+				const { data, response } = await params.client.responses.create(attempt.request, {
+					...params.requestOptions,
+					...bodyOptions,
+					headers: {
+						...bodyOptions.headers,
+						...params.requestOptions?.headers
+					}
+				}).withResponse();
 				commitResponsesEncryptedContentAttempt(attempt, (checkpoint) => {
 					if (checkpoint) params.onCompactionRejected?.(checkpoint);
 				});
@@ -1443,15 +1645,12 @@ const STRING_DELTA_EVENTS = /* @__PURE__ */ new Set([
 	"response.text.delta"
 ]);
 async function* adaptResponsesStream(stream, signal) {
-	const scheduler = createModelStreamCooperativeScheduler(signal);
-	for await (const event of stream) {
-		if (signal?.aborted) throw transportAbortError(signal);
+	for await (const event of iterateModelStream(stream, signal)) {
 		if (!isRecord(event) || typeof event.type !== "string") throw new Error("Responses stream delivered a malformed event without a string type");
 		if (STRING_DELTA_EVENTS.has(event.type) && typeof event.delta !== "string") throw new Error(`Responses stream delivered malformed ${event.type} delta`);
 		if ((event.type === "response.output_item.added" || event.type === "response.output_item.done") && !isRecord(event.item)) throw new Error(`Responses stream delivered malformed ${event.type} item`);
 		if ((event.type === "response.created" || event.type === "response.completed" || event.type === "response.incomplete" || event.type === "response.failed") && !isRecord(event.response)) throw new Error(`Responses stream delivered malformed ${event.type} response`);
 		yield event;
-		await scheduler.afterEvent();
 	}
 }
 async function* observeResponsesStream(stream, model, requestStartedAt) {
@@ -1543,9 +1742,10 @@ function createResponsesOutputTracker(params) {
 	};
 }
 function appendResponsesPendingTextDelta(slot, delta, materialize) {
+	const offset = slot.pendingText?.length ?? 0;
 	slot.pendingText = `${slot.pendingText ?? ""}${delta}`;
 	const priorText = slot.collapseCandidate?.block.text ?? "";
-	if (priorText.startsWith(slot.pendingText) || slot.pendingText.startsWith(priorText)) return;
+	if (offset >= priorText.length || priorText.startsWith(delta.slice(0, priorText.length - offset), offset)) return;
 	materialize(slot);
 }
 function readResponsesOutputIndex(event) {
@@ -1849,7 +2049,7 @@ async function processResponsesStream(openaiStream, output, sink, model, options
 	});
 	const stream = outputs.trackStream(sink);
 	let terminalResponse;
-	let incompleteToolCall;
+	let rejectedToolCall;
 	let lastTextBlock = null;
 	const blocks = output.content;
 	const compactionTracker = createCompactionTracker(output, model, options);
@@ -2023,8 +2223,12 @@ async function processResponsesStream(openaiStream, output, sink, model, options
 		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;
+			if (event.type === "response.output_item.done" && event.item.type === "function_call" && event.item.status && event.item.status !== "completed" && !rejectedToolCall) try {
+				resolveCompletedResponsesToolCall(event.item);
+			} catch (error) {
+				rejectedToolCall = { error };
+			}
+			if (rejectedToolCall && event.type !== "response.completed" && event.type !== "response.incomplete" && event.type !== "response.failed" && event.type !== "error") continue;
 			if (event.type === "response.created") output.responseId = event.response.id;
 			else if (event.type === "response.output_item.added") {
 				materializeDeferredTextSlots();
@@ -2067,22 +2271,15 @@ async function processResponsesStream(openaiStream, output, sink, model, options
 				if (!slot) continue;
 				slot.item.summary = slot.item.summary || [];
 				slot.item.summary.push(event.part);
-			} else if (event.type === "response.reasoning_summary_text.delta") {
+			} else if (event.type === "response.reasoning_summary_text.delta" || event.type === "response.reasoning_summary_part.done") {
 				const slot = outputSlots.resolve(event, "thinking");
 				if (!slot) continue;
 				slot.item.summary = slot.item.summary || [];
 				const lastPart = slot.item.summary[slot.item.summary.length - 1];
 				if (!lastPart) continue;
-				lastPart.text += event.delta;
-				appendThinkingDelta(slot, event.delta);
-			} else if (event.type === "response.reasoning_summary_part.done") {
-				const slot = outputSlots.resolve(event, "thinking");
-				if (!slot) continue;
-				slot.item.summary = slot.item.summary || [];
-				const lastPart = slot.item.summary[slot.item.summary.length - 1];
-				if (!lastPart) continue;
-				lastPart.text += "\n\n";
-				appendThinkingDelta(slot, "\n\n");
+				const delta = event.type === "response.reasoning_summary_text.delta" ? event.delta : "\n\n";
+				lastPart.text += delta;
+				appendThinkingDelta(slot, delta);
 			} else if (event.type === "response.reasoning_text.delta") {
 				const slot = outputSlots.resolve(event, "thinking");
 				if (!slot) continue;
@@ -2255,22 +2452,22 @@ async function processResponsesStream(openaiStream, output, sink, model, options
 					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: parsedStreamedArguments ?? (completedArguments || streamedArguments)
-					});
+					let validated;
+					try {
+						validated = resolveCompletedResponsesToolCall(item, {
+							name: streamingToolCall?.block.name,
+							arguments: parsedStreamedArguments ?? (completedArguments || streamedArguments)
+						});
+					} catch (error) {
+						rejectedToolCall = { error };
+						continue;
+					}
 					finalizeToolCall(item, readResponsesOutputIndex(event), streamingToolCall, validated);
 				}
 			} else if (event.type === "response.completed" || event.type === "response.incomplete") {
 				terminal.finalizeResponse(event.response, event.type);
-				if (incompleteToolCall) {
-					if (output.errorMessage) throw new Error(output.errorMessage);
-					resolveCompletedResponsesToolCall(incompleteToolCall);
-				}
-				if (event.type === "response.incomplete" && streamingToolCalls.hasActive()) {
-					if (output.errorMessage) throw new Error(output.errorMessage);
-					throw new IncompleteToolCallError("Responses stream completed with unresolved tool calls");
-				}
+				if (rejectedToolCall) throw output.errorMessage ? new Error(output.errorMessage) : rejectedToolCall.error;
+				if (event.type === "response.incomplete" && streamingToolCalls.hasActive()) throw output.errorMessage ? new Error(output.errorMessage) : new IncompleteToolCallError("Responses stream completed with unresolved tool calls");
 				if (event.type === "response.completed" || output.stopReason === "length") {
 					const items = event.response.output ?? [];
 					const completeToolCall = event.type === "response.completed" ? prepareTerminalToolCalls(items) : void 0;
@@ -2294,6 +2491,7 @@ async function processResponsesStream(openaiStream, output, sink, model, options
 			}
 		}
 		if (options?.signal?.aborted) throw transportAbortError(options.signal);
+		if (rejectedToolCall) throw rejectedToolCall.error;
 		if (streamingToolCalls.hasActive()) throw new Error("Responses stream ended with unresolved tool calls");
 		if (terminalResponse === void 0) throw new Error("OpenAI Responses stream ended before a terminal response event");
 		return terminalResponse ?? void 0;
@@ -2355,10 +2553,6 @@ function resolveResponsesStrictToolSetting(options) {
 }
 //#endregion
 //#region packages/ai/src/providers/openai-responses-shared.ts
-function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
-	return convertProviderResponsesMessages(model, context, allowedToolCallProviders, options);
-}
-const createResponsesAssistantOutput = createOpenAIResponsesAssistantOutput;
 function applyResponsesServiceTierPricing(usage, serviceTier, model) {
 	let multiplier = 1;
 	if (serviceTier === "flex") multiplier = .5;
@@ -2387,13 +2581,6 @@ function applyCommonResponsesParams(params, model, context, options, config) {
 		params.include = ["reasoning.encrypted_content"];
 	}
 }
-function buildResponsesRequestOptions(options) {
-	return {
-		...options?.signal ? { signal: options.signal } : {},
-		...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
-		maxRetries: 0
-	};
-}
 function cleanStreamingScratchBuffers(output) {
 	for (const block of output.content) {
 		delete block.index;
@@ -2406,6 +2593,7 @@ async function runResponsesStreamLifecycle(params) {
 	try {
 		const model = params.resolveRequestModel?.(params.model) ?? params.model;
 		const client = params.createClient(model);
+		const encodeBody = prepareModelRequestBody(options);
 		const buildRequest = async (replayMode) => {
 			let request = params.buildParams(model, replayMode);
 			const nextRequest = await options?.onPayload?.(request, model);
@@ -2421,10 +2609,12 @@ async function runResponsesStreamLifecycle(params) {
 			client,
 			request: requestParams,
 			requestOptions: {
-				...buildResponsesRequestOptions(options),
-				signal: firstEvent.signal
+				signal: firstEvent.signal,
+				...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
+				maxRetries: 0
 			},
 			model,
+			encodeBody,
 			buildFullHistoryRequest: () => buildRequest("full-history"),
 			onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, options, checkpoint),
 			canRetryStream: () => output.content.length === 0,
@@ -2496,4 +2686,4 @@ async function runResponsesStreamLifecycle(params) {
 	}
 }
 //#endregion
-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 };
+export { OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE as $, recordResponsesContextUsage as A, resolveResponsesContinuationRequest as B, resolveAzureOpenAIApiVersion as C, safeDebugValue as D, logResponsesFailedNoDetails as E, convertResponsesMessages as F, supportsResponsesReasoningUpdate as G, responsesContinuationRequestFingerprint as H, recordResponsesInputReplay as I, captureOpenAIResponsesCompaction as J, CompactionReplayRefreshRequiredError as K, responsesInputFingerprint as L, bindResponsesInputMessage as M, buildResponsesInputMessage as N, summarizeOpenAITransportError as O, convertProviderResponsesMessages as P, OPENAI_RESPONSES_CALL_ID_RE as Q, claimOpenAIResponsesHttpContinuation as R, isInvalidEncryptedContentError as S, ResponsesStreamFailure as T, isConfigurationUpdate as U, responsesContinuationPrefixFingerprint as V, replayResponsesReasoningUpdates as W, resolveNewestOpenAIResponsesCompactionReplay as X, isOpenAIResponsesReplayContext as Y, suppressOpenAIResponsesCompaction as Z, isResponsesTextContentPartType as _, prepareResponsesTools as a, commitResponsesEncryptedContentAttempt as b, observeResponsesStream as c, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as d, OPENAI_RESPONSES_ID_MAX_LENGTH as et, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as f, isAzureResponsesTextDeltaEventType as g, isAzureResponsesTextDeltaEvent as h, convertResponsesToolPayload as i, resolveReplayableResponsesMessageId as it, resolveResponsesContextUsageBoundary as j, summarizeResponsesPayload as k, createResponsesToolCallTracker as l, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as m, applyResponsesServiceTierPricing as n, shouldNormalizeOpenAIResponsesToolCallId as nt, readOpenAIMisalignmentReview as o, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as p, buildOpenAIResponsesReasoningReplayMetadata as q, runResponsesStreamLifecycle as r, splitOpenAIFunctionCallPairing as rt, processResponsesStream as s, applyCommonResponsesParams as t, normalizeOpenAIResponsesFunctionCallId as tt, readResponsesToolCallItemIdentity as u, isResponsesTextDeltaEventType as v, resolveNextResponsesEncryptedContentAttempt as w, createResponsesStreamWithEncryptedContentRetry as x, resolveResponsesMessageSnapshotCollapse as y, recordResponsesContinuationState as z };