@openclaw/ai 2026.10.1 → 2026.10.5-beta.1

package/dist/{openai-responses-shared-TCJRAoMW.mjs → openai-responses-shared-DVGhq5xF.mjs}

@@ -1,91 +1,751 @@
-import "./src-DWJq14pn.mjs";
+import "./src-C_wfIUmV.mjs";
 import { _ as runtimeContextContentToText, f as hasRuntimeContextMarker, p as isRuntimeContextMessage } from "./types-CQc6JNG4.mjs";
 import { o as readProviderRefusalReview, t as appendAssistantMessageDiagnostic } from "./diagnostics-DzrF1h4J.mjs";
-import { r as appendAssistantThinking } from "./event-stream-C5AbCAaZ.mjs";
-import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
-import { a as normalizeOptionalString, c as readStringValue, o as normalizeStringifiedOptionalString } from "./string-coerce-CtgOVOSv.mjs";
-import { N as isImageWithMediaPayload, O as calculateCost, a as resolveAiTransportHeaderSentinels, r as getAiTransportHost } from "./host-JpNulOOs.mjs";
-import { D as supportsOpenAITemperature, a as OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE, c as OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE, f as RESPONSE_FAILED_NO_DETAILS_MESSAGE, g as responsesServiceTierObserver, o as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, p as isPreviousResponseRejection, s as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY } from "./openai-responses-contracts-BKu8O7l4.mjs";
+import { r as appendAssistantThinking } from "./event-stream-X2gmsUWv.mjs";
+import { o as isRecord, r as asOptionalObjectRecord } from "./record-coerce-CNDovvft.mjs";
+import { a as normalizeOptionalString, c as readStringValue, n as normalizeLowercaseStringOrEmpty, o as normalizeStringifiedOptionalString } from "./string-coerce-CtgOVOSv.mjs";
+import { t as asFiniteNumber } from "./number-coercion-C3hztWoY.mjs";
+import { D as applyProviderReportedUsageCost, E as headersToRecord, N as isImageWithMediaPayload, O as calculateCost, a as resolveAiTransportHeaderSentinels, k as clampThinkingLevel, r as getAiTransportHost } from "./host-JWXZWa-c.mjs";
+import { A as MODEL_CATALOG_THINKING_LEVELS, C as normalizeOpenAIReasoningEffort, E as resolveOpenAIReasoningEffortMapping, M as resolveOpenAIThinkingApi, O as supportsOpenAIReasoningEffort, T as resolveOpenAIReasoningEffortForModel, _ as isResponsesServiceTierRejection, a as OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE, c as OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE, f as RESPONSE_FAILED_NO_DETAILS_MESSAGE, g as responsesServiceTierObserver, i as OPENAI_RESPONSES_APIS, k as supportsOpenAITemperature, o as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, p as isPreviousResponseRejection, s as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY, v as nextResponsesServiceTier, w as resolveOpenAIModelReasoningEfforts } from "./openai-responses-contracts-DlKMMTxK.mjs";
 import { n as getSessionResourceOwnerId, r as registerSessionResourceCleanup } from "./session-resources-D1wgDQ8C.mjs";
-import { o as truncateUtf16Safe, s as stableStringify } from "./provider-error-DQBE1bUQ.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-Caj-4RBA.mjs";
-import { o as redactSensitiveText, t as encodeTextSignatureV1 } from "./text-signature-rOn31nxc.mjs";
-import { c as resolveOpenAIResponsesTextFormat, i as resolveOpenAICompletionsCompat } from "./openai-completions-compat-D7hWYB0G.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-C5TAc3U_.mjs";
-import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, d as describeToolResultMediaPlaceholder, m as extractToolResultText, s as prepareModelRequestBody } from "./simple-options-wW3117Fu.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-ildrm49s.mjs";
-import { n as isProviderReplayContext, r as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-ywPKKLjL.mjs";
-import { n as transformProviderMessages } from "./assistant-output-mJ9cL4Qg.mjs";
-import { t as notifyLlmRequestActivity } from "./llm-request-activity-D8f_oxHj.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-D9ZmL_s9.mjs";
-import { a as resolveOpenAIProjectedToolsStrictToolFlag, f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-DYNePiF8.mjs";
-import { n as isOpenAIResponsesCompactionOutput, r as readOpenAIResponsesCompactionWindow } from "./openai-responses-compaction-window-m878aVpU.mjs";
-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) {
-	if (!params.replayResponsesItemIds) return;
-	if (!params.textSignatureId) return params.fallbackOrdinal === 0 ? params.fallbackId : `${params.fallbackId}_${params.fallbackOrdinal}`;
-	return params.previousReplayItemWasReasoning ? params.textSignatureId : void 0;
+import { c as stableStringify, s as truncateUtf16Safe } from "./provider-error-CF9GWCs2.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-Cr2xKVrS.mjs";
+import { _ as resolveResponsesTerminalStopReason, a as resolveModelPayloadDebugMode, d as hasOnlyResponsesFunctionTools, f as isResponsesProviderTool, g as readResponsesReasoningTokens, h as mapResponsesTerminalUsage, o as resolveModelSseDebugMode, r as emitModelTransportDebug, u as ResponsesOutputIdentityError } from "./diagnostics-tQasYct1.mjs";
+import { i as providerReplayContextMatches, l as redactSensitiveText, n as buildProviderReplayContext, r as isProviderReplayContext, s as isCodeModeModelVisibleToolName, t as encodeTextSignatureV1 } from "./text-signature-B_MB6U_9.mjs";
+import { c as resolveOpenAIResponsesTextFormat, i as resolveOpenAICompletionsCompat, o as usesNativeOpenAICodexResponsesBackend } from "./openai-completions-compat-pg1q4uNG.mjs";
+import { r as resolveModelRequestTimeoutMs } from "./host-policy-q4Azym9F.mjs";
+import { A as shortHash, C as parseJsonObjectPreservingUnsafeIntegers, E as createToolArgumentPreviewSchedule, O as parseStreamingJson, S as withProviderResponseHook, b as transportAbortError, c as failTransportStream, d as iterateModelStream, g as parseTerminalToolCallArguments, m as notifyProviderHttpResponse, t as IncompleteToolCallError, u as finalizeTransportStream, v as sanitizeTransportPayloadText } from "./transport-stream-shared-DH08b7Il.mjs";
+import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, d as describeToolResultMediaPlaceholder, m as extractToolResultText, s as prepareModelRequestBody } from "./simple-options-BARFAzk9.mjs";
+import { n as transformProviderMessages } from "./assistant-output-CUEeSotf.mjs";
+import { n as projectRuntimeToolInputSchema, t as prepareRuntimeToolInputSchema } from "./tool-schema-json-projection-B8sG1I9v.mjs";
+import { t as notifyLlmRequestActivity } from "./llm-request-activity-CfMuh5cC.mjs";
+import { n as resolveOpencodeSessionHeaders } from "./session-affinity-DA4WHv1h.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-Dc42hKv6.mjs";
+import { a as resolveOpenAIProjectedToolsStrictToolFlag, f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters, t as findOpenAIStrictToolProjectionDiagnostics } from "./openai-tool-schema-DDPXsvJP.mjs";
+import { a as readOpenAIResponsesCompactionWindow, i as isOpenAIResponsesCompactionOutput, n as supportsNativeOpenAIResponsesEndpoint } from "./openai-responses-endpoint-CinGh4VZ.mjs";
+import { hash, randomUUID } from "node:crypto";
+//#region packages/normalization-core/src/node-crypto.ts
+function sha256Hex(input) {
+	return hash("sha256", input, "hex");
+}
+function sha256HexPrefixCore(input, length) {
+	return sha256Hex(input).slice(0, length);
+}
+/** Redacts an identifier to a stable hash label, or "-" for missing values. */
+function redactIdentifier(value, opts) {
+	const trimmed = normalizeOptionalString(value);
+	if (!trimmed) return "-";
+	const len = opts?.len ?? 12;
+	return `sha256:${sha256HexPrefixCore(trimmed, Number.isFinite(len) ? Math.max(1, Math.floor(len)) : 12)}`;
 }
 //#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 };
+//#region packages/ai/src/transports/openai-transport-shared.ts
+const OPENAI_RESPONSE_MODEL_HEADER_NAMES = /* @__PURE__ */ new Set(["openai-model", "x-openai-model"]);
+const OPENAI_RESPONSE_MODEL_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"response.created",
+	"response.in_progress",
+	"response.completed",
+	"response.done",
+	"response.incomplete",
+	"response.failed"
+]);
+const OPENAI_DATED_MODEL_SUFFIX = /-(?:\d{8}|\d{4}-\d{2}-\d{2})$/;
+const GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP = "skip_thought_signature_validator";
+const log = {
+	debug(message, data) {
+		getAiTransportHost().logDebug("openai-transport", () => ({
+			message,
+			data
+		}));
+	},
+	info(message, data) {
+		getAiTransportHost().logInfo("openai-transport", message, data);
+	},
+	warn(message, data) {
+		getAiTransportHost().logWarn("openai-transport", message, data);
+	}
+};
+function splitOpenAIResponseModelHeader(value) {
+	return value ? value.split(",").map((part) => part.trim()).filter(Boolean) : [];
+}
+function readOpenAIResponseModelHeaders(headers) {
+	return [...OPENAI_RESPONSE_MODEL_HEADER_NAMES].flatMap((name) => splitOpenAIResponseModelHeader(headers.get(name)));
+}
+function readOpenAIResponseModelHeaderRecord(headers) {
+	if (!isRecord(headers)) return [];
+	return Object.entries(headers).filter(([name]) => OPENAI_RESPONSE_MODEL_HEADER_NAMES.has(name.toLowerCase())).flatMap(([, value]) => typeof value === "string" ? splitOpenAIResponseModelHeader(value) : []);
+}
+function readOpenAIResponseModelEvent(event) {
+	if (!isRecord(event)) return [];
+	const response = isRecord(event.response) ? event.response : void 0;
+	return [
+		...OPENAI_RESPONSE_MODEL_EVENT_TYPES.has(String(event.type)) && typeof response?.model === "string" && response.model.trim() ? [response.model.trim()] : [],
+		...readOpenAIResponseModelHeaderRecord(response?.headers),
+		...readOpenAIResponseModelHeaderRecord(event.headers)
+	];
+}
+function reconcileOpenAIResponseModels(current, observed) {
+	if (!current || current === observed) return observed;
+	const currentBase = current.replace(OPENAI_DATED_MODEL_SUFFIX, "");
+	const observedBase = observed.replace(OPENAI_DATED_MODEL_SUFFIX, "");
+	if (currentBase !== observedBase) return;
+	if (currentBase === current && observedBase !== observed) return observed;
+	if (observedBase === observed && currentBase !== current) return current;
+}
+function createResponseModelTracker(enabled = true) {
+	let responseModel;
+	const observe = (models) => {
+		for (const model of models) {
+			const reconciled = reconcileOpenAIResponseModels(responseModel, model);
+			if (!reconciled) throw new Error("Conflicting OpenAI response model attestations");
+			responseModel = reconciled;
+		}
+	};
+	const begin = (headers) => {
+		responseModel = void 0;
+		if (enabled && headers) observe(readOpenAIResponseModelHeaders(headers));
+	};
+	const observeEvent = (event) => {
+		if (enabled) observe(readOpenAIResponseModelEvent(event));
+		return responseModel;
+	};
+	const resolve = () => responseModel;
 	return {
-		callId: id.slice(0, separator),
-		itemId: id.slice(separator + 1)
+		begin,
+		observeEvent,
+		resolve,
+		track(response, stream) {
+			if (!enabled) return stream;
+			return (async function* () {
+				begin(response?.headers);
+				for await (const event of stream) {
+					observeEvent(event);
+					yield event;
+				}
+			})();
+		},
+		terminalOptions: enabled ? { resolveResponseModel: resolve } : {}
 	};
 }
-function shortOpenAIResponsesIdHash(id) {
-	return sha256Hex(id).slice(0, 10);
+function resolveOpenAIClientBaseUrl(model, baseUrl = model.baseUrl) {
+	if (baseUrl?.trim()) return baseUrl;
+	if (model.provider.trim().toLowerCase() === "openai") return;
+	throw new Error(`Provider "${model.provider}" requires an explicit base URL before using an OpenAI-compatible API. Reload provider metadata or configure an endpoint.`);
 }
-function sanitizeOpenAIResponsesIdTail(value) {
-	return value.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
+const EMPTY_OPENAI_COMPLETIONS_REASONING_BATCH = {
+	deltas: [],
+	mirroredThinking: [],
+	hasThinking: false,
+	hasVisibleText: false
+};
+const OPENAI_COMPLETIONS_REASONING_FIELDS = [
+	"reasoning_content",
+	"reasoning",
+	"reasoning_text"
+];
+function appendOpenAICompletionsReasoningDelta(deltas, mirroredThinking, next) {
+	const previous = deltas[deltas.length - 1];
+	if (!previous || previous.kind !== next.kind || next.kind === "thinking" && previous.kind === "thinking" && previous.signature !== next.signature) {
+		deltas.push(next);
+		if (next.kind === "thinking") mirroredThinking.push(next.text);
+		return;
+	}
+	previous.text += next.text;
+	if (next.kind === "thinking") mirroredThinking[mirroredThinking.length - 1] += next.text;
+}
+function readOpenAICompletionsReasoningBatch(delta, visibleReasoningDetailTypes) {
+	let deltas;
+	const mirroredThinking = [];
+	const reasoningDetails = delta.reasoning_details;
+	if (Array.isArray(reasoningDetails)) for (const detail of reasoningDetails) {
+		if (!isRecord(detail)) continue;
+		if (typeof detail.text !== "string" || !detail.text) continue;
+		if (detail.type === "reasoning.text") {
+			deltas ??= [];
+			appendOpenAICompletionsReasoningDelta(deltas, mirroredThinking, {
+				kind: "thinking",
+				signature: "reasoning_details",
+				text: detail.text
+			});
+			continue;
+		}
+		if (typeof detail.type === "string" && visibleReasoningDetailTypes.has(detail.type)) {
+			deltas ??= [];
+			appendOpenAICompletionsReasoningDelta(deltas, mirroredThinking, {
+				kind: "text",
+				text: detail.text,
+				source: "reasoning_detail"
+			});
+		}
+	}
+	if (mirroredThinking.length === 0) for (const field of OPENAI_COMPLETIONS_REASONING_FIELDS) {
+		const value = delta[field];
+		if (typeof value === "string" && value.length > 0) {
+			deltas ??= [];
+			appendOpenAICompletionsReasoningDelta(deltas, mirroredThinking, {
+				kind: "thinking",
+				signature: field,
+				text: value
+			});
+			break;
+		}
+	}
+	if (!deltas) return EMPTY_OPENAI_COMPLETIONS_REASONING_BATCH;
+	return {
+		deltas,
+		mirroredThinking,
+		hasThinking: mirroredThinking.length > 0,
+		hasVisibleText: mirroredThinking.length < deltas.length
+	};
+}
+function parseOpenAICompletionsUsage(rawUsage, model, options) {
+	const cacheRead = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
+	const cacheWrite = rawUsage.prompt_tokens_details?.cache_write_tokens ?? rawUsage.prompt_tokens_details?.cache_creation_input_tokens ?? rawUsage.cache_creation_input_tokens ?? 0;
+	const input = Math.max(0, (rawUsage.prompt_tokens || 0) - cacheRead - cacheWrite);
+	const output = rawUsage.completion_tokens || 0;
+	const reasoningTokens = asFiniteNumber(rawUsage.completion_tokens_details?.reasoning_tokens);
+	const hasCoherentContext = [
+		rawUsage.prompt_tokens,
+		rawUsage.completion_tokens,
+		rawUsage.total_tokens,
+		cacheRead,
+		cacheWrite
+	].every((value) => typeof value === "number" && Number.isFinite(value) && value >= 0) && rawUsage.prompt_tokens >= cacheRead + cacheWrite && rawUsage.total_tokens >= rawUsage.prompt_tokens + rawUsage.completion_tokens;
+	const usage = {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		...options?.includeReasoningTokens !== false && reasoningTokens !== void 0 ? { reasoningTokens } : {},
+		contextUsage: hasCoherentContext ? {
+			state: "available",
+			promptTokens: rawUsage.prompt_tokens,
+			totalTokens: Math.max(input + output + cacheRead + cacheWrite, rawUsage.total_tokens)
+		} : { state: "unavailable" },
+		totalTokens: input + output + cacheRead + cacheWrite,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+	calculateCost(model, usage);
+	applyProviderReportedUsageCost(usage, rawUsage.cost);
+	return usage;
 }
-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}`;
+function createOpenAIResponseHook(onResponse, response, model) {
+	return onResponse ? () => onResponse({
+		status: response.status,
+		headers: headersToRecord(response.headers)
+	}, model) : void 0;
 }
-/** 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)
+function createOpenAIProviderAcceptanceHook(options, response, model) {
+	return () => notifyProviderHttpResponse({
+		options,
+		response,
+		model
 	});
-	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);
+/** Measure one UTF-8 append without double-counting a surrogate pair split across chunks. */
+function measureUtf8AppendBytes(bufferEndsWithHighSurrogate, chunk) {
+	let bytes = Buffer.byteLength(chunk, "utf8");
+	if (!chunk) return {
+		bytes,
+		endsWithHighSurrogate: bufferEndsWithHighSurrogate
+	};
+	const nextCodeUnit = chunk.charCodeAt(0);
+	if (bufferEndsWithHighSurrogate && nextCodeUnit >= 56320 && nextCodeUnit <= 57343) bytes -= 2;
+	const finalCodeUnit = chunk.charCodeAt(chunk.length - 1);
+	return {
+		bytes,
+		endsWithHighSurrogate: finalCodeUnit >= 55296 && finalCodeUnit <= 56319
+	};
+}
+function resolvePromptCacheKey(options, cacheRetention) {
+	if (cacheRetention === "none") return;
+	return clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId);
+}
+function isOpenAICompletionsThinkingEnabled(effort) {
+	const normalized = effort.trim().toLowerCase();
+	return normalized !== "off" && normalized !== "none";
+}
+function readOpenAICompletionsContentDeltas(content, topLevelRefusal, mirroredThinking = []) {
+	let deltas = readOpenAICompletionsContentPartDeltas(content);
+	if (mirroredThinking.length > 0) {
+		const structuredThinking = deltas.filter((delta) => delta.kind === "thinking").map((delta) => delta.text);
+		const mirrorsCombinedThinking = structuredThinking.length > 1 && mirroredThinking.includes(structuredThinking.join(""));
+		deltas = deltas.filter((delta) => delta.kind !== "thinking" || !mirrorsCombinedThinking && !mirroredThinking.includes(delta.text));
+	}
+	if (typeof topLevelRefusal !== "string" || !topLevelRefusal) return deltas;
+	const structuredRefusals = deltas.filter((delta) => delta.kind === "text" && delta.source === "refusal").map((delta) => delta.text);
+	if (structuredRefusals.some((refusal) => refusal === topLevelRefusal) || structuredRefusals.length > 1 && structuredRefusals.join("") === topLevelRefusal) return deltas;
+	return [...deltas, {
+		kind: "text",
+		text: topLevelRefusal,
+		source: "refusal"
+	}];
+}
+function readOpenAICompletionsContentPartDeltas(content) {
+	if (typeof content === "string") return content ? [{
+		kind: "text",
+		text: content
+	}] : [];
+	if (Array.isArray(content)) return content.flatMap(readOpenAICompletionsContentPartDeltas);
+	if (!content || typeof content !== "object") return [];
+	const record = content;
+	const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+	const extractText = (value) => {
+		if (typeof value === "string") return value;
+		if (Array.isArray(value)) return value.map(extractText).join("");
+		if (value && typeof value === "object") {
+			const nested = value;
+			return extractText(nested.text ?? nested.content ?? nested.thinking ?? nested.refusal);
+		}
+		return "";
+	};
+	const text = extractText(record.text ?? record.content ?? record.thinking ?? record.refusal);
+	if (!text) return [];
+	if (type.includes("thinking") || type.includes("reasoning")) return [{
+		kind: "thinking",
+		text
+	}];
+	if (type === "refusal") return [{
+		kind: "text",
+		text,
+		source: "refusal"
+	}];
+	if (["text", "output_text"].includes(type) || type.endsWith(".output_text")) return [{
+		kind: "text",
+		text
+	}];
+	return [];
+}
+//#endregion
+//#region packages/ai/src/providers/openai-tool-projection.ts
+function unreadableToolDiagnostic(toolIndex) {
+	return {
+		toolIndex,
+		violations: [`tool[${toolIndex}] is unreadable`]
+	};
+}
+/** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
+function projectOpenAITools(tools) {
+	return projectOpenAIToolDescriptors(tools);
+}
+/** Package-private facts are consumed before the projection or payload can escape. */
+function prepareOpenAITools(tools) {
+	const schemas = /* @__PURE__ */ new Map();
+	return {
+		projection: projectOpenAIToolDescriptors(tools, schemas),
+		schemas
+	};
+}
+function projectOpenAIToolDescriptors(tools, schemas) {
+	let inputToolCount;
+	try {
+		inputToolCount = tools.length;
+	} catch {
+		return {
+			inputToolCount: 0,
+			tools: [],
+			diagnostics: [unreadableToolDiagnostic(0)]
+		};
+	}
+	const projectedTools = [];
+	const diagnostics = [];
+	for (let toolIndex = 0; toolIndex < inputToolCount; toolIndex += 1) {
+		let tool;
+		let name;
+		let parameters;
+		let readPath = `tool[${toolIndex}]`;
+		try {
+			const candidate = tools[toolIndex];
+			if (!candidate) {
+				diagnostics.push(unreadableToolDiagnostic(toolIndex));
+				continue;
+			}
+			tool = candidate;
+			readPath += ".name";
+			const nameValue = tool.name;
+			if (typeof nameValue !== "string" || !nameValue) {
+				diagnostics.push({
+					toolIndex,
+					violations: [`${readPath} is empty`]
+				});
+				continue;
+			}
+			name = nameValue;
+			readPath = `${name}.parameters`;
+			parameters = tool.parameters;
+		} catch {
+			diagnostics.push({
+				toolIndex,
+				...name ? { toolName: name } : {},
+				violations: [`${readPath} is unreadable`]
+			});
+			continue;
+		}
+		const prepared = schemas ? prepareRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`) : void 0;
+		const schemaProjection = prepared?.projection ?? projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
+		if (!isRecord(schemaProjection.schema) || schemaProjection.violations.length > 0) {
+			diagnostics.push({
+				toolIndex,
+				toolName: name,
+				violations: schemaProjection.violations.length > 0 ? schemaProjection.violations : [`${name}.parameters must be a JSON object schema`]
+			});
+			continue;
+		}
+		if (prepared?.normalization) schemas?.set(schemaProjection.schema, prepared.normalization);
+		let descriptionValue;
+		try {
+			descriptionValue = tool.description;
+		} catch {}
+		const description = typeof descriptionValue === "string" ? descriptionValue : void 0;
+		projectedTools.push({
+			toolIndex,
+			name,
+			...description !== void 0 ? { description } : {},
+			parameters: schemaProjection.schema
+		});
+	}
+	return {
+		inputToolCount,
+		tools: projectedTools,
+		diagnostics
+	};
+}
+function reconcileToolChoice(choice, projection, responses) {
+	const label = responses ? "OpenAI Responses" : "OpenAI Chat Completions";
+	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
+	if (choice === "required") {
+		if (projection.tools.length === 0) throw new Error(`${label} tool_choice requires a tool, but no tools survived schema conversion`);
+		return choice;
+	}
+	if (choice === "none" || !isRecord(choice)) return choice;
+	const choiceType = choice.type;
+	if (!responses && choiceType === "custom") throw new Error("OpenAI Chat Completions custom tool_choice is unsupported because this adapter emits function tools only");
+	if (choiceType === "function") {
+		const functionChoice = responses ? choice : choice.function;
+		const functionName = isRecord(functionChoice) ? functionChoice.name : void 0;
+		if (typeof functionName !== "string") return choice;
+		if (!projection.tools.some((tool) => tool.name === functionName)) throw new Error(`${label} tool_choice requested unavailable tool "${functionName}" after schema conversion`);
+		return responses ? {
+			type: "function",
+			name: functionName
+		} : {
+			type: "function",
+			function: { name: functionName }
+		};
+	}
+	if (choiceType !== "allowed_tools") return choice;
+	const allowedConfig = responses ? choice : choice.allowed_tools;
+	if (!isRecord(allowedConfig)) return choice;
+	const { mode, tools } = allowedConfig;
+	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
+	const responseTools = [];
+	const completionTools = [];
+	for (const tool of tools) {
+		if (!isRecord(tool) || tool.type !== "function") {
+			if (responses) responseTools.push(tool);
+			continue;
+		}
+		const functionChoice = responses ? tool : tool.function;
+		const functionName = isRecord(functionChoice) ? functionChoice.name : void 0;
+		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) {
+			if (responses) responseTools.push({
+				type: "function",
+				name: functionName
+			});
+			else completionTools.push({
+				type: "function",
+				function: { name: functionName }
+			});
+		}
+	}
+	if (responseTools.length === 0 && completionTools.length === 0) {
+		if (mode === "auto") return "none";
+		throw new Error(`${label} tool_choice requires a tool, but no allowed tools survived schema conversion`);
+	}
+	return responses ? {
+		type: "allowed_tools",
+		mode,
+		tools: responseTools
+	} : {
+		type: "allowed_tools",
+		allowed_tools: {
+			mode,
+			tools: completionTools
+		}
+	};
+}
+/** Keeps Responses tool choices aligned with surviving function schemas. */
+function reconcileOpenAIResponsesToolChoice(choice, projection) {
+	return reconcileToolChoice(choice, projection, true);
+}
+/** Keeps Chat Completions tool choices aligned with surviving function schemas. */
+function reconcileOpenAICompletionsToolChoice(choice, projection) {
+	return reconcileToolChoice(choice, projection, false);
+}
+/** Re-expresses an object Chat Completions tool choice in the Responses wire shape. */
+function toOpenAIResponsesToolChoice(choice) {
+	if (choice.type === "function") return {
+		type: "function",
+		name: choice.function.name
+	};
+	return {
+		type: "allowed_tools",
+		mode: choice.allowed_tools.mode,
+		tools: choice.allowed_tools.tools.map((tool) => tool.type === "function" && isRecord(tool.function) && typeof tool.function.name === "string" ? {
+			type: "function",
+			name: tool.function.name
+		} : tool)
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/openai-reasoning-compat.ts
+/** Explicit model reasoning-effort compatibility metadata. */
+function readCompatReasoningEffortMap(compat) {
+	const rawMap = asOptionalObjectRecord(asOptionalObjectRecord(compat)?.reasoningEffortMap);
+	if (!rawMap) return {};
+	return Object.fromEntries(Object.entries(rawMap).filter((entry) => typeof entry[1] === "string"));
+}
+/** Resolves the reasoning effort remap for an OpenAI-compatible model. */
+function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
+	return {
+		...fallbackMap,
+		...readCompatReasoningEffortMap(model.compat)
+	};
+}
+//#endregion
+//#region packages/ai/src/providers/openai-request-reasoning.ts
+/** Preserve explicit off until the selected route maps it to its native value. */
+function resolveOpenAISimpleReasoningEffort(model, reasoning) {
+	return reasoning === void 0 ? void 0 : clampThinkingLevel(model, reasoning);
+}
+function resolveOpenAIRequestReasoning(model, reasoning, offDefault = "none") {
+	const requested = normalizeOpenAIReasoningEffort(reasoning ?? "off");
+	const modelLevel = MODEL_CATALOG_THINKING_LEVELS.find((candidate) => candidate === requested);
+	const modelMapped = modelLevel ? model.thinkingLevelMap?.[modelLevel] : void 0;
+	const mapped = modelMapped === null ? null : resolveOpenAIReasoningEffortMapping(requested, resolveOpenAIReasoningEffortMap(model)) ?? modelMapped;
+	const intent = mapped !== void 0 ? mapped?.trim() : reasoning === void 0 || requested === "off" && offDefault === null ? void 0 : requested;
+	const normalizedIntent = normalizeOpenAIReasoningEffort(intent ?? "off");
+	const supported = resolveOpenAIModelReasoningEfforts(model);
+	const effort = !model.reasoning || supported?.length === 0 || intent === void 0 ? void 0 : supported === void 0 ? mapped !== void 0 ? intent : requested === "off" ? "none" : requested : resolveOpenAIReasoningEffortForModel({
+		model,
+		effort: requested,
+		fallbackMap: { [requested]: intent }
+	});
+	return {
+		effort: effort === "none" && resolveOpenAIThinkingApi(model.api) === "openai-chatgpt-responses" && !supportsOpenAIReasoningEffort(model.id === "gpt-6-sol" || model.id === "gpt-6-luna" ? model : { compat: model.compat }, "none") ? void 0 : effort,
+		thinkingEnabled: intent === void 0 ? void 0 : model.reasoning && normalizedIntent !== "off" && normalizedIntent !== "none"
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/openai-transport-params.ts
+const MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS = 256;
+const loggedOpenAIStrictToolDowngradeDiagnosticKeys = /* @__PURE__ */ new Set();
+const OPENAI_COMPLETIONS_APIS = /* @__PURE__ */ new Set(["openai-completions", "openclaw-openai-completions-transport"]);
+function readToolPayloadField$1(record, field) {
+	try {
+		return Object.hasOwn(record, field) ? record[field] : void 0;
+	} catch {
+		return;
+	}
+}
+function readCodeModePayloadToolName(tool) {
+	if (!isRecord(tool)) return;
+	const name = readToolPayloadField$1(tool, "name");
+	if (typeof name === "string") return name;
+	const fn = readToolPayloadField$1(tool, "function");
+	if (!isRecord(fn)) return;
+	const fnName = readToolPayloadField$1(fn, "name");
+	return typeof fnName === "string" ? fnName : void 0;
+}
+function readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes) {
+	if (!isRecord(tool)) return;
+	const type = readToolPayloadField$1(tool, "type");
+	if (typeof type === "string" && allowedHostedToolTypes?.has(type)) {
+		try {
+			if (Object.hasOwn(tool, "name") || Object.hasOwn(tool, "function") || Object.hasOwn(tool, "functionDeclarations") || Object.hasOwn(tool, "function_declarations")) return false;
+		} catch {
+			return false;
+		}
+		return `hosted:${type}`;
+	}
+	const name = readCodeModePayloadToolName(tool);
+	return typeof name === "string" && isCodeModeModelVisibleToolName(name, visibleToolNames) ? `client:${name}` : void 0;
+}
+function readCodeModePayloadToolIdentities(payload) {
+	if (!isRecord(payload)) return [];
+	const tools = readToolPayloadField$1(payload, "tools");
+	if (!Array.isArray(tools)) return [];
+	return tools.flatMap((tool) => {
+		if (!isRecord(tool)) return [];
+		const identities = [];
+		const name = readCodeModePayloadToolName(tool);
+		if (name) identities.push(`client:${name}`);
+		for (const key of ["functionDeclarations", "function_declarations"]) {
+			const declarations = readToolPayloadField$1(tool, key);
+			if (!Array.isArray(declarations)) continue;
+			for (const declaration of declarations) {
+				const declarationName = readCodeModePayloadToolName(declaration);
+				if (declarationName) identities.push(`client:${declarationName}`);
+			}
+		}
+		const type = readToolPayloadField$1(tool, "type");
+		if (typeof type === "string" && type !== "function") identities.push(`hosted:${type}`);
+		return identities;
+	});
+}
+function filterCodeModePayloadTools(payload, visibleToolNames, allowedHostedToolTypes, observer) {
+	if (!isRecord(payload)) return;
+	const tools = readToolPayloadField$1(payload, "tools");
+	if (!Array.isArray(tools)) return;
+	const beforeToolIdentities = observer ? readCodeModePayloadToolIdentities(payload) : void 0;
+	payload.tools = tools.flatMap((tool) => {
+		const identity = readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes);
+		if (identity) return [tool];
+		if (identity === false) return [];
+		if (!isRecord(tool)) return [];
+		const filteredGroups = {};
+		for (const key of ["functionDeclarations", "function_declarations"]) {
+			const declarations = readToolPayloadField$1(tool, key);
+			if (!Array.isArray(declarations)) continue;
+			const filtered = declarations.filter((declaration) => {
+				const declarationName = readCodeModePayloadToolName(declaration);
+				return typeof declarationName === "string" && isCodeModeModelVisibleToolName(declarationName, visibleToolNames);
+			});
+			if (filtered.length > 0) filteredGroups[key] = filtered;
+		}
+		return Object.keys(filteredGroups).length > 0 ? [filteredGroups] : [];
+	});
+	if (beforeToolIdentities) observer?.({
+		beforeToolIdentities,
+		afterToolIdentities: readCodeModePayloadToolIdentities(payload)
+	});
+}
+function resolveCodeModeResponsesVisibleToolNames(context) {
+	return new Set((context.tools ?? []).map(readCodeModePayloadToolName).filter((name) => typeof name === "string"));
+}
+function enforceCodeModeResponsesToolSurface(payload, visibleToolNames, allowedHostedToolTypes, observer) {
+	if (!isRecord(payload)) return;
+	const tools = readToolPayloadField$1(payload, "tools");
+	if (!Array.isArray(tools)) return;
+	const beforeToolIdentities = observer ? readCodeModePayloadToolIdentities(payload) : void 0;
+	payload.tools = tools.filter((tool) => Boolean(readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes)));
+	if (beforeToolIdentities) observer?.({
+		beforeToolIdentities,
+		afterToolIdentities: readCodeModePayloadToolIdentities(payload)
+	});
+}
+function assertCodeModeResponsesToolSurface(payload, visibleToolNames, allowedHostedToolTypes) {
+	const tools = isRecord(payload) ? readToolPayloadField$1(payload, "tools") : void 0;
+	if (!Array.isArray(tools)) throw new Error("Code mode payload tool surface violation: expected exec,wait; got no tools");
+	const identities = tools.map((tool) => readCodeModePayloadToolIdentity(tool, visibleToolNames, allowedHostedToolTypes));
+	const names = identities.flatMap((identity) => typeof identity === "string" && identity.startsWith("client:") ? [identity.slice(7)] : []).toSorted((left, right) => left.localeCompare(right));
+	if (names.length >= 2 && identities.every((identity) => typeof identity === "string") && new Set(identities).size === identities.length && names.includes("exec") && names.includes("wait")) return;
+	throw new Error(`Code mode payload tool surface violation: expected exec,wait plus direct-only tools; got ${names.length > 0 ? names.join(",") : "none"}`);
+}
+function resolveOpenAIStrictToolFlagWithDiagnostics(projection, strictSetting, context) {
+	const strict = resolveOpenAIProjectedToolsStrictToolFlag(projection, strictSetting);
+	if (strictSetting === true && strict === false) getAiTransportHost().logDebug("openai-transport", () => {
+		const diagnostics = findOpenAIStrictToolProjectionDiagnostics(projection);
+		const key = sha256Hex(JSON.stringify({
+			transport: context.transport,
+			provider: context.model.provider ?? null,
+			model: context.model.id ?? null,
+			diagnostics: diagnostics.map((entry) => ({
+				toolIndex: entry.toolIndex,
+				toolName: entry.toolName ?? null,
+				violations: entry.violations
+			}))
+		}));
+		if (loggedOpenAIStrictToolDowngradeDiagnosticKeys.has(key)) return null;
+		if (loggedOpenAIStrictToolDowngradeDiagnosticKeys.size >= MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS) loggedOpenAIStrictToolDowngradeDiagnosticKeys.clear();
+		loggedOpenAIStrictToolDowngradeDiagnosticKeys.add(key);
+		const sample = diagnostics.slice(0, 5).map((entry) => ({
+			tool: entry.toolName ?? `tool[${entry.toolIndex}]`,
+			violations: entry.violations.slice(0, 8)
+		}));
+		return {
+			message: `OpenAI ${context.transport} tool schema strict mode downgraded to strict=false for ${context.model.provider ?? "unknown"}/${context.model.id ?? "unknown"} because ${diagnostics.length} tool schema(s) are not strict-compatible`,
+			data: {
+				transport: context.transport,
+				provider: context.model.provider,
+				model: context.model.id,
+				incompatibleToolCount: diagnostics.length,
+				sample
+			}
+		};
+	});
+	return strict;
+}
+function buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, sessionId, cacheRetention) {
+	const providerHeaders = { ...model.headers };
+	if (model.provider === "github-copilot") Object.assign(providerHeaders, getAiTransportHost().buildCopilotDynamicHeaders(context.messages));
+	if (OPENAI_COMPLETIONS_APIS.has(model.api) && sessionId && cacheRetention !== "none") {
+		const { sessionAffinity } = resolveOpenAICompletionsCompat(model);
+		if (sessionAffinity !== "none") {
+			const affinityValue = clampOpenAIPromptCacheKey(sessionId) ?? sessionId;
+			const affinityHeaders = sessionAffinity === "openrouter" ? ["x-session-id"] : [
+				"session_id",
+				"x-client-request-id",
+				"x-session-affinity"
+			];
+			const configuredHeaders = new Set(Object.keys(providerHeaders).map((key) => key.toLowerCase()));
+			for (const name of affinityHeaders) if (!configuredHeaders.has(name)) providerHeaders[name] = affinityValue;
+		}
+	}
+	const callerHeaders = {
+		...optionHeaders,
+		...turnHeaders
+	};
+	const resolvedHeaders = getAiTransportHost().resolveProviderRequestHeaders({
+		provider: model.provider,
+		api: model.api,
+		baseUrl: model.baseUrl,
+		providerHeaders,
+		callerHeaders: Object.keys(callerHeaders).length > 0 ? callerHeaders : void 0,
+		precedence: "caller-wins",
+		model
+	}) ?? {};
+	const sendSessionIdHeader = (OPENAI_RESPONSES_APIS.has(model.api) && model.compat && "sendSessionIdHeader" in model.compat ? model.compat?.sendSessionIdHeader : void 0) ?? usesNativeOpenAICodexResponsesBackend(model);
+	if (sessionId && cacheRetention !== "none" && sendSessionIdHeader && !Object.keys(resolvedHeaders).some((key) => normalizeLowercaseStringOrEmpty(key) === "session_id")) resolvedHeaders.session_id = clampOpenAIPromptCacheKey(sessionId) ?? sessionId;
+	return resolveOpencodeSessionHeaders(model, {
+		sessionId,
+		headers: resolvedHeaders
+	}) ?? resolvedHeaders;
+}
+function buildOpenAISdkClientOptions(model) {
+	const timeout = resolveModelRequestTimeoutMs(model);
+	return {
+		...timeout === void 0 ? {} : { timeout },
+		maxRetries: 0
+	};
+}
+function buildOpenAISdkRequestOptions(model, signal, options) {
+	const timeout = resolveModelRequestTimeoutMs(model, options?.timeoutMs);
+	const headers = options?.stream === true && usesNativeOpenAICodexResponsesBackend(model) ? { Accept: "text/event-stream" } : void 0;
+	if (timeout === void 0 && !signal && !headers) return;
+	return {
+		...headers ? { headers } : {},
+		...signal ? { signal } : {},
+		...timeout !== void 0 ? { timeout } : {},
+		maxRetries: 0
+	};
+}
+function getCompat(model) {
+	const resolved = resolveOpenAICompletionsCompat(model);
+	const compat = model.compat ?? {};
+	return {
+		...resolved,
+		reasoningEffortMap: resolveOpenAIReasoningEffortMap(model, {}),
+		openRouterRouting: resolved.openRouterRouting ?? {},
+		requiresStringContent: compat.requiresStringContent ?? false,
+		strictMessageKeys: compat.strictMessageKeys === true
+	};
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-compaction-replay.ts
@@ -94,8 +754,8 @@ const OPENAI_RESPONSES_COMPACTION_SUPPRESSION_DATA = "rejected";
 function isOpenAIResponsesCompactionState(state) {
 	if (typeof state.baseUrlHash !== "string" || state.v !== 1) return false;
 	if (state.type === OPENAI_RESPONSES_COMPACTION_SUPPRESSION_TYPE) return state.data === OPENAI_RESPONSES_COMPACTION_SUPPRESSION_DATA;
-	if (state.type === "openai-responses-retained-compaction") return typeof state.data === "string" && state.data.length > 0 && (state.id === void 0 || typeof state.id === "string") && state.replayIndex === void 0;
-	return state.type === "openai-responses-compaction" && typeof state.data === "string" && state.data.length > 0 && (state.id === void 0 || typeof state.id === "string") && (state.replayIndex === void 0 || typeof state.replayIndex === "number" && Number.isSafeInteger(state.replayIndex) && state.replayIndex >= 0);
+	const retained = state.type === OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE;
+	return (retained || state.type === "openai-responses-compaction") && typeof state.data === "string" && state.data.length > 0 && (state.id === void 0 || typeof state.id === "string") && (state.replayIndex === void 0 || !retained && typeof state.replayIndex === "number" && Number.isSafeInteger(state.replayIndex) && state.replayIndex >= 0);
 }
 function readOpenAIResponsesCompactionReplayState(value) {
 	return isRecord(value) && isProviderReplayContext(value) && isOpenAIResponsesCompactionState(value) ? value : void 0;
@@ -289,6 +949,50 @@ function replayResponsesReasoningUpdates(previous, request, previousOutputLength
 	};
 }
 //#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 normalizeOpenAIResponsesIdPart(value, prefix) {
+	const trimmed = value.trim();
+	if ((prefix === "call_" ? OPENAI_RESPONSES_CALL_ID_RE : OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE).test(trimmed)) return trimmed;
+	const rawTail = trimmed.startsWith(prefix) ? trimmed.slice(prefix.length) : trimmed;
+	const hash = sha256Hex(trimmed || prefix).slice(0, 10);
+	const maxTailLength = 64 - prefix.length;
+	const hashSuffix = `_${hash}`;
+	return `${prefix}${`${rawTail.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "").slice(0, Math.max(1, maxTailLength - hashSuffix.length)) || "id"}${hashSuffix}`.slice(0, maxTailLength)}`;
+}
+/** 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(itemId ? `${callId}|${itemId}` : callId, "call_");
+	if (!itemId) return normalizedCallId;
+	return `${normalizedCallId}|${normalizeOpenAIResponsesIdPart(itemId, "fc_")}`;
+}
+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-continuation.ts
 const HTTP_CONTINUATION_IDLE_TTL_MS = 54e5;
 const MAX_HTTP_CONTINUATION_READY_ENTRIES = 1e3;
@@ -351,13 +1055,9 @@ function pendingResponsesToolCalls(calls, input) {
 	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);
+		if (item.type === "function_call") replayedCallIds.add(item.call_id);
+		const positions = item.type === "function_call" ? lastCallPosition : item.type === "function_call_output" ? lastOutputPosition : void 0;
+		if (positions && owner !== void 0 && owner !== null) positions.set(owner, inputIndex);
 	}
 	return calls.filter((_call, index) => {
 		const callPosition = lastCallPosition.get(index);
@@ -516,7 +1216,7 @@ function resolveResponsesContinuationRequest(continuation, request, steering) {
 	};
 	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));
+	const historyToolRoundUnchanged = [false, true].some((ignoreCachedItemIds) => jsonValuesEqual(replayedToolRound, normalizeAssistantReplayInput(continuation.lastResponseItems, true, ignoreCachedItemIds)));
 	if (!continuationHistoryMatches(previousInput, currentInput.slice(0, previousInput.length)) || !historyToolRoundUnchanged) return {
 		request,
 		continuationStatus: "history_changed"
@@ -540,6 +1240,14 @@ function resolveResponsesContinuationRequest(continuation, request, steering) {
 const httpContinuationEntries = /* @__PURE__ */ new Map();
 const readyHttpContinuationEntries = /* @__PURE__ */ new Map();
 let httpContinuationRetainedBytes = 0;
+function createHttpContinuationTimer(key) {
+	const timer = setTimeout(() => {
+		const entry = httpContinuationEntries.get(key);
+		if (entry?.kind === "ready" && entry.idleTimer === timer) deleteHttpContinuationIfOwned(key, entry);
+	}, HTTP_CONTINUATION_IDLE_TTL_MS);
+	timer.unref?.();
+	return timer;
+}
 function deleteHttpContinuationIfOwned(key, entry) {
 	if (httpContinuationEntries.get(key) !== entry) return;
 	if (entry.kind === "ready") {
@@ -573,7 +1281,7 @@ function claimOpenAIResponsesHttpContinuation(params) {
 	const key = `${getSessionResourceOwnerId(owner)}\0${params.sessionId}\0${connectionIdentity(params)}`;
 	const previous = httpContinuationEntries.get(key);
 	if (previous?.kind === "claimed") return;
-	if (previous?.kind === "ready") deleteHttpContinuationIfOwned(key, previous);
+	if (previous) deleteHttpContinuationIfOwned(key, previous);
 	const claimed = {
 		kind: "claimed",
 		sessionId: params.sessionId,
@@ -581,15 +1289,15 @@ function claimOpenAIResponsesHttpContinuation(params) {
 	};
 	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 request = previous ? params.request : params.restoreRequest?.() ?? params.request;
+		const resolved = resolveResponsesContinuationRequest(previous?.state, request);
 		const fullRequest = resolved.fullRequest ?? request;
 		return {
 			request: params.request.store === false ? fullRequest : resolved.request,
 			fullRequest,
 			commit: (effectiveRequest, response, dispatchedPreviousResponseId) => {
 				if (httpContinuationEntries.get(key) !== claimed) return;
-				const state = recordResponsesContinuationState(previous?.kind === "ready" ? previous.state : void 0, effectiveRequest, response, previous?.kind === "ready" && dispatchedPreviousResponseId === previous.state.lastResponseId);
+				const state = recordResponsesContinuationState(previous?.state, effectiveRequest, response, previous !== void 0 && dispatchedPreviousResponseId === previous.state.lastResponseId);
 				const retainedBytes = Buffer.byteLength(JSON.stringify(state), "utf8");
 				if (httpContinuationEntries.get(key) !== claimed) return;
 				if (retainedBytes > MAX_HTTP_CONTINUATION_RETAINED_BYTES) {
@@ -601,10 +1309,9 @@ function claimOpenAIResponsesHttpContinuation(params) {
 					...claimed,
 					kind: "ready",
 					state,
-					idleTimer: setTimeout(() => deleteHttpContinuationIfOwned(key, ready), HTTP_CONTINUATION_IDLE_TTL_MS),
+					idleTimer: owner.runInDetachedAsyncContext(() => createHttpContinuationTimer(key)),
 					retainedBytes
 				};
-				ready.idleTimer.unref?.();
 				httpContinuationRetainedBytes += retainedBytes;
 				httpContinuationEntries.set(key, ready);
 				readyHttpContinuationEntries.set(key, ready);
@@ -681,36 +1388,32 @@ function createResponsesInputReplay(model) {
 	};
 }
 //#endregion
+//#region packages/ai/src/transports/openai-responses-replay.ts
+/** Resolves the assistant message id that can be replayed to OpenAI Responses. */
+function resolveReplayableResponsesMessageId(params) {
+	if (!params.replayResponsesItemIds) return;
+	if (!params.textSignatureId) return params.fallbackOrdinal === 0 ? params.fallbackId : `${params.fallbackId}_${params.fallbackOrdinal}`;
+	return params.previousReplayItemWasReasoning ? params.textSignatureId : void 0;
+}
+//#endregion
 //#region packages/ai/src/transports/openai-responses-replay-messages-internal.ts
 function resolveResponsesInstructionRole(model) {
 	const supportsDeveloperRole = !isRecord(model.compat) || model.compat.supportsDeveloperRole !== false;
 	return model.reasoning && supportsDeveloperRole ? "developer" : "system";
 }
 function stripEncryptedReasoningContentFields(value) {
-	if (!value || typeof value !== "object") return {
-		value,
-		changed: false
-	};
+	if (!value || typeof value !== "object") return value;
 	if (Array.isArray(value)) {
 		let changed = false;
 		const next = value.map((item) => {
 			const stripped = stripEncryptedReasoningContentFields(item);
-			changed ||= stripped.changed;
-			return stripped.value;
+			changed ||= !Object.is(stripped, item);
+			return stripped;
 		});
-		return changed ? {
-			value: next,
-			changed: true
-		} : {
-			value,
-			changed: false
-		};
+		return changed ? next : value;
 	}
 	const source = value;
-	if (source.type === "compaction") return {
-		value,
-		changed: false
-	};
+	if (source.type === "compaction") return value;
 	let changed = false;
 	const next = {};
 	for (const [key, child] of Object.entries(source)) {
@@ -719,21 +1422,13 @@ function stripEncryptedReasoningContentFields(value) {
 			continue;
 		}
 		const stripped = stripEncryptedReasoningContentFields(child);
-		changed ||= stripped.changed;
-		next[key] = stripped.value;
+		changed ||= !Object.is(stripped, child);
+		next[key] = stripped;
 	}
-	return changed ? {
-		value: next,
-		changed: true
-	} : {
-		value,
-		changed: false
-	};
+	return changed ? next : value;
 }
 function isOpenAIResponsesReasoningReplayMetadata(value) {
-	if (!isProviderReplayContext(value)) return false;
-	const record = value;
-	return record.v === 1 && record.source === "openai-responses";
+	return isProviderReplayContext(value) && value.v === 1 && value.source === "openai-responses";
 }
 function readOpenAIResponsesReasoningReplayBlockMetadata(block) {
 	if (!Object.hasOwn(block, "openclawReasoningReplay")) return;
@@ -741,26 +1436,23 @@ function readOpenAIResponsesReasoningReplayBlockMetadata(block) {
 	return isOpenAIResponsesReasoningReplayMetadata(value) ? value : null;
 }
 function normalizeOpenAIResponsesReasoningReplayItem(item) {
-	const record = item;
-	if (record.type !== "reasoning" || Array.isArray(record.summary)) return item;
-	return {
-		...record,
+	return Array.isArray(item.summary) ? item : {
+		...item,
 		summary: []
 	};
 }
 function prepareOpenAIResponsesReasoningItemForReplay(item, context, blockMetadata, options) {
-	const record = item;
-	const hasRawMetadata = Object.hasOwn(record, OPENAI_RESPONSES_REASONING_REPLAY_META_KEY);
-	const { [OPENAI_RESPONSES_REASONING_REPLAY_META_KEY]: rawMetadata, ...rest } = record;
+	const hasRawMetadata = Object.hasOwn(item, OPENAI_RESPONSES_REASONING_REPLAY_META_KEY);
+	const { [OPENAI_RESPONSES_REASONING_REPLAY_META_KEY]: rawMetadata, ...rest } = item;
 	if (!("encrypted_content" in rest)) return normalizeOpenAIResponsesReasoningReplayItem(rest);
 	const metadata = blockMetadata !== void 0 ? blockMetadata ?? void 0 : isOpenAIResponsesReasoningReplayMetadata(rawMetadata) ? rawMetadata : void 0;
 	if (blockMetadata === void 0 && !hasRawMetadata && options?.preserveUnattributedEncryptedContent === true || metadata && providerReplayContextMatches(metadata, context)) return normalizeOpenAIResponsesReasoningReplayItem(rest);
-	return normalizeOpenAIResponsesReasoningReplayItem(stripEncryptedReasoningContentFields(rest).value);
+	return normalizeOpenAIResponsesReasoningReplayItem(stripEncryptedReasoningContentFields(rest));
 }
-function normalizeResponsesReplayItemId(id, prefix) {
+function normalizeResponsesReplayItemId(id) {
 	if (!id) return;
 	if (id.length <= 64) return id;
-	return `${prefix}_${shortHash(id)}`;
+	return `msg_${shortHash(id)}`;
 }
 function orderResponsesAsyncToolResults(source) {
 	const turnKey = (message) => {
@@ -898,6 +1590,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 	}
 	let msgIndex = 0;
 	const appendAssistant = createResponsesInputReplay(model);
+	const inHistorySystemUpdates = supportsNativeOpenAIResponsesEndpoint(model);
 	for (const msg of replayMessages) {
 		if (!("role" in msg)) {
 			messages.push(msg);
@@ -908,22 +1601,20 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 			text: sanitizeTransportPayloadText(runtimeContextContentToText(msg.content))
 		}]));
 		else if (msg.role === "user") {
-			if (typeof msg.content === "string") messages.push(buildResponsesInputMessage("user", [{
+			const role = msg.operatorMessage && inHistorySystemUpdates && (typeof msg.content === "string" || msg.content.every((block) => block.type === "text")) ? resolveResponsesInstructionRole(model) : "user";
+			const content = typeof msg.content === "string" ? [{
 				type: "input_text",
 				text: sanitizeTransportPayloadText(msg.content)
-			}], msg));
-			else {
-				const content = msg.content.map((item) => item.type === "text" ? {
-					type: "input_text",
-					text: sanitizeTransportPayloadText(item.text)
-				} : {
-					type: "input_image",
-					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, msg));
-				else if (providerStyle) continue;
-			}
+			}] : msg.content.map((item) => item.type === "text" ? {
+				type: "input_text",
+				text: sanitizeTransportPayloadText(item.text)
+			} : {
+				type: "input_image",
+				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(role, content, msg));
+			else if (providerStyle) continue;
 		} else if (msg.role === "assistant") {
 			const output = [];
 			let textFallbackOrdinal = 0;
@@ -954,7 +1645,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 					previousReplayItemWasReasoning
 				});
 				if (!textSignature?.id) textFallbackOrdinal += 1;
-				msgId = normalizeResponsesReplayItemId(msgId, "msg");
+				msgId = normalizeResponsesReplayItemId(msgId);
 				const messageItem = {
 					type: "message",
 					role: "assistant",
@@ -993,8 +1684,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 			if (output.length === 0 && providerStyle) continue;
 		} else if (msg.role === "toolResult") {
 			const textResult = extractToolResultText(msg.content);
-			const sanitizedTextResult = sanitizeTransportPayloadText(textResult);
-			const hasText = sanitizedTextResult.trim().length > 0;
+			const hasText = textResult.trim().length > 0;
 			const mediaPlaceholder = describeToolResultMediaPlaceholder(msg.content);
 			const hasImages = msg.content.some(isImageWithMediaPayload);
 			const separatorIndex = msg.toolCallId.indexOf("|");
@@ -1004,7 +1694,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 				call_id: callId,
 				output: hasImages && model.input.includes("image") ? [...hasText ? [{
 					type: "input_text",
-					text: sanitizedTextResult
+					text: textResult
 				}] : mediaPlaceholder === "(see attached media)" ? [{
 					type: "input_text",
 					text: mediaPlaceholder
@@ -1012,7 +1702,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 					type: "input_image",
 					detail: "auto",
 					image_url: `data:${item.mimeType};base64,${item.data}`
-				}))] : sanitizeNonEmptyTransportPayloadText(textResult, mediaPlaceholder ?? "(no output)")
+				}))] : hasText ? textResult : mediaPlaceholder ?? "(no output)"
 			});
 		}
 		msgIndex += 1;
@@ -1100,10 +1790,10 @@ function isProviderMessage(message) {
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-debug.ts
-function stringifyUnknown(value, fallback = "") {
+function stringifyUnknown(value) {
 	if (typeof value === "string") return value;
 	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	return fallback;
+	return "";
 }
 function safeDebugValue(value) {
 	if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
@@ -1361,6 +2051,19 @@ function summarizeOpenAITransportError(error) {
 function isAsyncIterable(value) {
 	return (typeof value === "object" && value !== null || typeof value === "function") && Symbol.asyncIterator in value;
 }
+function readResponsesRecoveryEvent(event) {
+	const record = isRecord(event) ? event : void 0;
+	const response = isRecord(record?.response) ? record.response : void 0;
+	return {
+		failure: record?.type === "response.failed" ? response?.error : record?.type === "error" ? record.error ?? record : void 0,
+		hasResponseOutput: Array.isArray(response?.output) && response.output.length > 0,
+		isPrelude: record !== void 0 && [
+			"response.created",
+			"response.in_progress",
+			"response.queued"
+		].includes(String(record.type))
+	};
+}
 function isInvalidEncryptedContentError(error) {
 	if (!error || typeof error !== "object") return false;
 	const record = error;
@@ -1379,10 +2082,9 @@ function commitResponsesEncryptedContentAttempt(attempt, commit) {
 }
 function stripResponsesRequestEncryptedReasoning(request) {
 	const stripped = stripEncryptedReasoningContentFields(request.input);
-	if (!stripped.changed) return request;
-	return {
+	return stripped === request.input ? request : {
 		...request,
-		input: stripped.value
+		input: stripped
 	};
 }
 function stripResponsesRequestCompaction(request) {
@@ -1422,16 +2124,44 @@ async function resolveNextResponsesEncryptedContentAttempt(attempt, error, optio
 		rejectedCompaction: readOpenAIResponsesCompactionRejection(attempt.request)
 	};
 }
-async function createResponsesStreamWithEncryptedContentRetry(params) {
+async function createResponsesStreamWithRecovery(params) {
 	const encodeBody = params.encodeBody ?? prepareModelRequestBody(void 0);
+	let tierCeiling;
+	const limitTier = (request) => tierCeiling && (request.service_tier === "ultrafast" || tierCeiling === "default" && request.service_tier === "priority") ? {
+		...request,
+		service_tier: tierCeiling
+	} : request;
+	const recoverServiceTier = (attempt, error) => {
+		if (params.requestOptions?.signal?.aborted || !supportsNativeOpenAIResponsesEndpoint(params.model)) return;
+		const tier = attempt.request.service_tier;
+		const next = nextResponsesServiceTier(tier, error);
+		if (!next || tier !== "ultrafast" && tier !== "priority") return;
+		tierCeiling = next;
+		params.onServiceTierRejected?.(tier);
+		log.info(`[responses] rejected ${tier} tier; retrying with ${next}`);
+		return {
+			...attempt,
+			request: {
+				...attempt.request,
+				service_tier: next
+			}
+		};
+	};
 	const send = async (initialAttempt) => {
 		let attempt = initialAttempt;
 		for (;;) {
+			const cappedRequest = limitTier(attempt.request);
+			if (cappedRequest !== attempt.request) attempt = {
+				kind: attempt.kind,
+				request: cappedRequest,
+				rejectedCompaction: attempt.rejectedCompaction
+			};
 			params.observePrompt?.(attempt.request, {
 				egress: "responses-sdk",
 				payloadVariant: attempt.kind
 			});
 			const bodyOptions = await encodeBody(attempt.request);
+			let responseAccepted = false;
 			try {
 				const { data, response } = await params.client.responses.create(attempt.request, {
 					...params.requestOptions,
@@ -1441,6 +2171,7 @@ async function createResponsesStreamWithEncryptedContentRetry(params) {
 						...params.requestOptions?.headers
 					}
 				}).withResponse();
+				responseAccepted = true;
 				commitResponsesEncryptedContentAttempt(attempt, (checkpoint) => {
 					if (checkpoint) params.onCompactionRejected?.(checkpoint);
 				});
@@ -1451,7 +2182,7 @@ async function createResponsesStreamWithEncryptedContentRetry(params) {
 					attempt
 				};
 			} catch (error) {
-				let nextAttempt = await resolveNextResponsesEncryptedContentAttempt(attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest });
+				let nextAttempt = (!responseAccepted ? recoverServiceTier(attempt, error) : void 0) ?? 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;
@@ -1461,7 +2192,7 @@ async function createResponsesStreamWithEncryptedContentRetry(params) {
 					};
 				}
 				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";
+				const retryDescription = nextAttempt.request.service_tier !== attempt.request.service_tier ? "with a slower service tier" : 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;
 			}
@@ -1474,26 +2205,42 @@ async function createResponsesStreamWithEncryptedContentRetry(params) {
 	});
 	return { stream: { async *[Symbol.asyncIterator]() {
 		let current = result;
+		let outputObserved = false;
 		for (;;) {
 			let rejectedEvent;
+			let sourceError;
+			const source = current.stream;
+			const providerStream = { async *[Symbol.asyncIterator]() {
+				try {
+					yield* source;
+				} catch (error) {
+					sourceError = error;
+					throw error;
+				}
+			} };
 			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
-							});
-						}
+				for await (const event of params.wrapStream?.({
+					...current,
+					stream: providerStream
+				}) ?? providerStream) {
+					const { failure, hasResponseOutput, isPrelude } = readResponsesRecoveryEvent(event);
+					outputObserved ||= hasResponseOutput;
+					if (isRecord(failure) && params.canRetryStream?.() === true && (isInvalidEncryptedContentError(failure) || !outputObserved && isResponsesServiceTierRejection(failure))) {
+						rejectedEvent = event;
+						const message = typeof failure.message === "string" ? failure.message : "";
+						throw Object.assign(new Error(message), {
+							code: failure.code,
+							status: failure.status,
+							type: failure.type,
+							param: failure.param
+						});
 					}
+					outputObserved ||= !isPrelude;
 					yield event;
 				}
 				return;
 			} catch (error) {
-				const nextAttempt = params.canRetryStream?.() === true && !params.requestOptions?.signal?.aborted ? await resolveNextResponsesEncryptedContentAttempt(current.attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest }) : void 0;
+				const nextAttempt = params.canRetryStream?.() === true && !params.requestOptions?.signal?.aborted ? (!outputObserved && (rejectedEvent !== void 0 || sourceError === error) ? recoverServiceTier(current.attempt, error) : void 0) ?? await resolveNextResponsesEncryptedContentAttempt(current.attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest }) : void 0;
 				if (!nextAttempt) {
 					if (rejectedEvent !== void 0) {
 						yield rejectedEvent;
@@ -1501,7 +2248,7 @@ async function createResponsesStreamWithEncryptedContentRetry(params) {
 					}
 					throw error;
 				}
-				log.warn(`[responses] retrying streamed encrypted content provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
+				log.warn(`[responses] retrying explicitly rejected stream provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
 				current = await send(nextAttempt);
 			}
 		}
@@ -1618,31 +2365,24 @@ function readResponsesOutputIndex(event) {
 	return typeof outputIndex === "number" && Number.isInteger(outputIndex) && outputIndex >= 0 ? outputIndex : void 0;
 }
 function createResponsesOutputSlotTracker() {
-	const indexed = /* @__PURE__ */ new Map();
-	let unindexed;
+	const slots = /* @__PURE__ */ new Map();
 	return {
 		register(event, slot) {
 			const outputIndex = readResponsesOutputIndex(event);
-			if (outputIndex === void 0) {
-				if (unindexed) throw new Error("Responses stream added overlapping unindexed output items");
-				unindexed = slot;
-				return;
-			}
-			if (indexed.has(outputIndex)) throw new Error(`Responses stream reused active output index ${outputIndex}`);
-			indexed.set(outputIndex, slot);
+			if (slots.has(outputIndex)) throw new Error(outputIndex === void 0 ? "Responses stream added overlapping unindexed output items" : `Responses stream reused active output index ${outputIndex}`);
+			slots.set(outputIndex, slot);
 		},
 		resolve(event, type) {
 			const outputIndex = readResponsesOutputIndex(event);
-			let slot = outputIndex === void 0 ? unindexed : indexed.get(outputIndex);
+			let slot = slots.get(outputIndex);
 			if (outputIndex === void 0 && !slot) {
-				const matches = [...indexed.values()].filter((candidate) => candidate.type === type);
+				const matches = [...slots.values()].filter((candidate) => candidate.type === type);
 				slot = matches.length === 1 ? matches[0] : void 0;
 			}
 			return slot?.type === type ? slot : void 0;
 		},
 		get(event) {
-			const outputIndex = readResponsesOutputIndex(event);
-			return outputIndex === void 0 ? unindexed : indexed.get(outputIndex);
+			return slots.get(readResponsesOutputIndex(event));
 		},
 		resolveOutputItem(event, item) {
 			if (item.type === "reasoning") return this.resolve(event, "thinking");
@@ -1650,11 +2390,12 @@ function createResponsesOutputSlotTracker() {
 			return readResponsesOutputIndex(event) === void 0 ? void 0 : this.get(event);
 		},
 		values() {
-			return [.../* @__PURE__ */ new Set([...indexed.values(), ...unindexed ? [unindexed] : []])];
+			const indexed = [...slots].filter(([index]) => index !== void 0).map(([, slot]) => slot);
+			const unindexed = slots.get(void 0);
+			return [.../* @__PURE__ */ new Set([...indexed, ...unindexed ? [unindexed] : []])];
 		},
 		forget(slot) {
-			if (unindexed === slot) unindexed = void 0;
-			for (const [outputIndex, candidate] of indexed) if (candidate === slot) indexed.delete(outputIndex);
+			for (const [outputIndex, candidate] of slots) if (candidate === slot) slots.delete(outputIndex);
 		}
 	};
 }
@@ -1783,11 +2524,9 @@ function resolveResponsesToolCallId(item, fallbackId) {
 	const callId = typeof item.call_id === "string" ? item.call_id.trim() : "";
 	const itemId = typeof item.id === "string" ? item.id.trim() : "";
 	const [fallbackCallId, fallbackItemId = ""] = splitToolCallId(fallbackId ?? "");
-	const resolvedCallId = callId || fallbackCallId;
+	const resolvedCallId = callId || fallbackCallId || `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`;
 	const resolvedItemId = itemId || fallbackItemId;
-	if (resolvedCallId) return resolvedItemId ? `${resolvedCallId}|${resolvedItemId}` : resolvedCallId;
-	const generated = `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`;
-	return resolvedItemId ? `${generated}|${resolvedItemId}` : generated;
+	return resolvedItemId ? `${resolvedCallId}|${resolvedItemId}` : resolvedCallId;
 }
 function resolveCompletedResponsesToolCall(item, streamed) {
 	if (item.status && item.status !== "completed") throw new IncompleteToolCallError("Responses stream completed with an incomplete terminal tool call");
@@ -1822,7 +2561,8 @@ function createResponsesTerminalController(params) {
 			if (options?.reasoningReplayMetadata) Object.assign(block, { [OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY]: options.reasoningReplayMetadata });
 		}
 	};
-	const appendText = (item, contentIndex) => {
+	const appendText = (item, initialIndex) => {
+		let contentIndex = initialIndex;
 		const text = (Array.isArray(item.content) ? item.content : []).map((part) => {
 			const content = part;
 			return content.type === "output_text" || content.type === "text" ? content.text ?? "" : content.refusal ?? "";
@@ -1848,58 +2588,47 @@ function createResponsesTerminalController(params) {
 					delta
 				});
 			}
-			stream.push({
-				type: "text_end",
-				contentIndex,
-				content: text,
-				partial: output
-			});
-			return contentIndex;
-		}
-		const previous = params.getLastTextBlock();
-		const collapse = resolveResponsesMessageSnapshotCollapse({
-			prior: previous && {
-				text: previous.block.text,
-				phase: previous.phase
-			},
-			nextText: text,
-			nextPhase: phase
-		});
-		if (collapse.kind === "extend" && previous) {
-			previous.block.text = collapse.text;
-			previous.block.textSignature = encodeTextSignatureV1(item.id, phase);
-			stream.push({
-				type: "text_end",
-				contentIndex: previous.index,
-				content: collapse.text,
-				partial: output
+		} else {
+			const previous = params.getLastTextBlock();
+			const collapse = resolveResponsesMessageSnapshotCollapse({
+				prior: previous && {
+					text: previous.block.text,
+					phase: previous.phase
+				},
+				nextText: text,
+				nextPhase: phase
 			});
-			return previous.index;
+			if (collapse.kind === "extend" && previous) {
+				previous.block.text = collapse.text;
+				previous.block.textSignature = encodeTextSignatureV1(item.id, phase);
+				contentIndex = previous.index;
+			} else {
+				const newBlock = {
+					type: "text",
+					text,
+					textSignature: encodeTextSignatureV1(item.id, phase)
+				};
+				blocks.push(newBlock);
+				contentIndex = blocks.length - 1;
+				params.setLastTextBlock({
+					block: newBlock,
+					index: contentIndex,
+					phase
+				});
+				stream.push({
+					type: "text_start",
+					contentIndex,
+					partial: output
+				});
+			}
 		}
-		const newBlock = {
-			type: "text",
-			text,
-			textSignature: encodeTextSignatureV1(item.id, phase)
-		};
-		blocks.push(newBlock);
-		const index = blocks.length - 1;
-		params.setLastTextBlock({
-			block: newBlock,
-			index,
-			phase
-		});
-		stream.push({
-			type: "text_start",
-			contentIndex: index,
-			partial: output
-		});
 		stream.push({
 			type: "text_end",
-			contentIndex: index,
+			contentIndex,
 			content: text,
 			partial: output
 		});
-		return index;
+		return contentIndex;
 	};
 	const emitToolCallCompletion = (item, outputIndex, started, validated) => {
 		const completed = {
@@ -2043,67 +2772,52 @@ async function processResponsesStream(openaiStream, output, sink, model, options
 	let lastTextBlock = null;
 	const blocks = output.content;
 	const compactionTracker = createCompactionTracker(output, model, options);
+	const createTextBlock = (item, text) => ({
+		type: "text",
+		text,
+		...item.phase ? { textSignature: encodeTextSignatureV1(item.id, item.phase) } : {}
+	});
 	const createOutputSlot = (event, item) => {
-		if (item.type === "reasoning") {
-			const block = {
+		let slot;
+		if (item.type === "reasoning") slot = {
+			type: "thinking",
+			item,
+			block: {
 				type: "thinking",
 				thinking: ""
-			};
-			const slot = {
-				type: "thinking",
-				item,
-				block,
-				contentIndex: blocks.length,
-				outputIndex: readResponsesOutputIndex(event)
-			};
-			blocks.push(block);
-			outputs.set(item, slot.contentIndex, slot.outputIndex);
-			outputSlots.register(event, slot);
-			stream.push({
-				type: "thinking_start",
-				contentIndex: slot.contentIndex,
-				partial: output
-			});
-			return slot;
-		}
-		if (item.type === "message") {
-			const messageItem = item;
+			},
+			contentIndex: blocks.length,
+			outputIndex: readResponsesOutputIndex(event)
+		};
+		else if (item.type === "message") {
 			const collapseCandidate = lastTextBlock;
-			const block = collapseCandidate ? null : {
-				type: "text",
-				text: "",
-				...messageItem.phase ? { textSignature: encodeTextSignatureV1(messageItem.id, messageItem.phase) } : {}
-			};
-			const slot = {
+			const block = collapseCandidate ? null : createTextBlock(item, "");
+			slot = {
 				type: "text",
-				item: messageItem,
+				item,
 				block,
 				contentIndex: block ? blocks.length : void 0,
 				outputIndex: readResponsesOutputIndex(event),
 				pendingText: collapseCandidate ? "" : null,
 				collapseCandidate
 			};
-			if (block) {
-				blocks.push(block);
-				outputs.set(messageItem, slot.contentIndex ?? blocks.length - 1, slot.outputIndex);
-			}
-			outputSlots.register(event, slot);
-			if (slot.contentIndex !== void 0) stream.push({
-				type: "text_start",
-				contentIndex: slot.contentIndex,
-				partial: output
-			});
-			return slot;
+		} else return;
+		if (slot.block) {
+			blocks.push(slot.block);
+			outputs.set(slot.item, slot.contentIndex ?? blocks.length - 1, slot.outputIndex);
 		}
+		outputSlots.register(event, slot);
+		if (slot.contentIndex !== void 0) stream.push({
+			type: slot.type === "thinking" ? "thinking_start" : "text_start",
+			contentIndex: slot.contentIndex,
+			partial: output
+		});
+		return slot;
 	};
 	const materializeDeferredTextSlot = (slot) => {
 		if (slot.block || slot.pendingText === null) return;
 		const text = slot.pendingText;
-		slot.block = {
-			type: "text",
-			text,
-			...slot.item.phase ? { textSignature: encodeTextSignatureV1(slot.item.id, slot.item.phase) } : {}
-		};
+		slot.block = createTextBlock(slot.item, text);
 		blocks.push(slot.block);
 		slot.contentIndex = blocks.length - 1;
 		outputs.set(slot.item, slot.contentIndex, slot.outputIndex);
@@ -2263,19 +2977,17 @@ 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" || event.type === "response.reasoning_summary_part.done") {
+			} else if (event.type === "response.reasoning_summary_text.delta" || event.type === "response.reasoning_summary_part.done" || event.type === "response.reasoning_text.delta") {
 				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;
-				const delta = event.type === "response.reasoning_summary_text.delta" ? event.delta : "\n\n";
-				lastPart.text += delta;
+				const delta = event.type === "response.reasoning_summary_part.done" ? "\n\n" : event.delta;
+				if (event.type !== "response.reasoning_text.delta") {
+					slot.item.summary = slot.item.summary || [];
+					const lastPart = slot.item.summary[slot.item.summary.length - 1];
+					if (!lastPart) continue;
+					lastPart.text += delta;
+				}
 				appendThinkingDelta(slot, delta);
-			} else if (event.type === "response.reasoning_text.delta") {
-				const slot = outputSlots.resolve(event, "thinking");
-				if (!slot) continue;
-				appendThinkingDelta(slot, event.delta);
 			} else if (event.type === "response.content_part.added") {
 				const slot = outputSlots.resolve(event, "text");
 				if (!slot) continue;
@@ -2311,22 +3023,19 @@ async function processResponsesStream(openaiStream, output, sink, model, options
 					lastPart.text += event.delta;
 				}
 				projectTextDelta(slot, event.delta);
-			} else if (event.type === "response.function_call_arguments.delta") {
+			} else if (event.type === "response.function_call_arguments.delta" || event.type === "response.function_call_arguments.done") {
 				const toolCall = streamingToolCalls.resolve(event);
-				if (toolCall) {
+				if (!toolCall) {
+					if (streamingToolCalls.hasActive()) streamingToolCalls.markArgumentsUnreliable();
+					continue;
+				}
+				let delta;
+				if (event.type === "response.function_call_arguments.delta") {
 					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",
-						contentIndex: toolCall.contentIndex,
-						delta: event.delta,
-						partial: output
-					});
-				} else if (streamingToolCalls.hasActive()) streamingToolCalls.markArgumentsUnreliable();
-			} else if (event.type === "response.function_call_arguments.done") {
-				const toolCall = streamingToolCalls.resolve(event);
-				if (toolCall) {
+					delta = event.delta;
+				} else {
 					const previousPartialJson = toolCall.block.partialJson;
 					const doneArguments = typeof event.arguments === "string" ? event.arguments : void 0;
 					if (doneArguments !== void 0 && (doneArguments.length > 0 || previousPartialJson === "")) {
@@ -2335,16 +3044,14 @@ async function processResponsesStream(openaiStream, output, sink, model, options
 						toolCall.argumentStreamReliable = true;
 						toolCall.argumentsStreamed = true;
 					}
-					if (doneArguments?.startsWith(previousPartialJson)) {
-						const delta = doneArguments.slice(previousPartialJson.length);
-						if (delta.length > 0) stream.push({
-							type: "toolcall_delta",
-							contentIndex: toolCall.contentIndex,
-							delta,
-							partial: output
-						});
-					}
-				} else if (streamingToolCalls.hasActive()) streamingToolCalls.markArgumentsUnreliable();
+					if (doneArguments?.startsWith(previousPartialJson)) delta = doneArguments.slice(previousPartialJson.length) || void 0;
+				}
+				if (delta !== void 0) stream.push({
+					type: "toolcall_delta",
+					contentIndex: toolCall.contentIndex,
+					delta,
+					partial: output
+				});
 			} else if (event.type === "response.output_item.done") {
 				const item = event.item;
 				if (item.type !== "message") lastTextBlock = null;
@@ -2392,11 +3099,7 @@ async function processResponsesStream(openaiStream, output, sink, model, options
 						outputs.set(item, outputSlot.collapseCandidate.index, readResponsesOutputIndex(event) ?? outputSlot.outputIndex, true);
 					} else {
 						if (!outputSlot.block) {
-							outputSlot.block = {
-								type: "text",
-								text: "",
-								...phase ? { textSignature: encodeTextSignatureV1(item.id, phase) } : {}
-							};
+							outputSlot.block = createTextBlock(item, "");
 							blocks.push(outputSlot.block);
 							outputSlot.contentIndex = blocks.length - 1;
 							stream.push({
@@ -2588,7 +3291,7 @@ async function runResponsesStreamLifecycle(params) {
 		let started = false;
 		let admittedRequest;
 		let requestedTier;
-		const { stream: hookedOpenAIStream } = await createResponsesStreamWithEncryptedContentRetry({
+		const { stream: hookedOpenAIStream } = await createResponsesStreamWithRecovery({
 			client,
 			request: requestParams,
 			requestOptions: {
@@ -2601,6 +3304,7 @@ async function runResponsesStreamLifecycle(params) {
 			buildFullHistoryRequest: () => buildRequest("full-history"),
 			onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, options, checkpoint),
 			canRetryStream: () => output.content.length === 0,
+			onServiceTierRejected: (tier) => responsesServiceTierObserver.reject(options, tier),
 			wrapStream: ({ stream: openaiStream, response, attempt }) => {
 				requestedTier = attempt.request.service_tier;
 				admittedRequest = attempt.kind === "initial" ? attempt.request : void 0;
@@ -2623,14 +3327,19 @@ async function runResponsesStreamLifecycle(params) {
 		});
 		const firstEventTimeoutMs = getFirstStreamEventTimeoutMs(options);
 		const onFirstEventTimeout = getFirstStreamEventTimeoutHandler(options);
+		const processStreamOptions = params.processStreamOptions || firstEventTimeoutMs !== void 0 || onFirstEventTimeout !== void 0 ? {
+			...params.processStreamOptions,
+			firstEventTimeoutMs: params.processStreamOptions?.firstEventTimeoutMs ?? firstEventTimeoutMs,
+			abortFirstEventStream: params.processStreamOptions?.abortFirstEventStream ?? firstEventAbort.abort,
+			onFirstEventTimeout: params.processStreamOptions?.onFirstEventTimeout ?? onFirstEventTimeout,
+			signal: params.processStreamOptions?.signal ?? options?.signal
+		} : void 0;
 		const terminal = await processResponsesStream(hookedOpenAIStream, output, stream, model, {
-			...params.processStreamOptions || firstEventTimeoutMs !== void 0 || onFirstEventTimeout !== void 0 ? {
-				...params.processStreamOptions,
-				firstEventTimeoutMs: params.processStreamOptions?.firstEventTimeoutMs ?? firstEventTimeoutMs,
-				abortFirstEventStream: params.processStreamOptions?.abortFirstEventStream ?? firstEventAbort.abort,
-				onFirstEventTimeout: params.processStreamOptions?.onFirstEventTimeout ?? onFirstEventTimeout,
-				signal: params.processStreamOptions?.signal ?? options?.signal
-			} : void 0,
+			...processStreamOptions,
+			resolveServiceTier: (responseTier, originalTier) => {
+				const tier = requestedTier === "priority" || requestedTier === "default" ? requestedTier : originalTier;
+				return processStreamOptions?.resolveServiceTier ? processStreamOptions.resolveServiceTier(responseTier, tier) : responseTier ?? tier;
+			},
 			onServiceTier: (responseTier) => responsesServiceTierObserver.observe(options, requestedTier, responseTier),
 			canRetryIdentityConflict: () => hasOnlyResponsesFunctionTools(admittedRequest),
 			reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
@@ -2671,4 +3380,4 @@ async function runResponsesStreamLifecycle(params) {
 	}
 }
 //#endregion
-export { OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE as $, recordResponsesContextUsage as A, recordResponsesContinuationState as B, resolveAzureOpenAIApiVersion as C, safeDebugValue as D, logResponsesFailedNoDetails as E, convertResponsesMessages as F, replayResponsesReasoningUpdates as G, responsesContinuationPrefixFingerprint as H, readResponsesInputReplayState as I, buildOpenAIResponsesReasoningReplayMetadata as J, supportsResponsesReasoningUpdate as K, recordResponsesInputReplay as L, bindResponsesInputMessage as M, buildResponsesInputMessage as N, summarizeOpenAITransportError as O, convertProviderResponsesMessages as P, OPENAI_RESPONSES_CALL_ID_RE as Q, responsesInputFingerprint as R, isInvalidEncryptedContentError as S, ResponsesStreamFailure as T, responsesContinuationRequestFingerprint as U, resolveResponsesContinuationRequest as V, isConfigurationUpdate as W, resolveNewestOpenAIResponsesCompactionReplay as X, captureOpenAIResponsesCompaction 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, CompactionReplayRefreshRequiredError 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, claimOpenAIResponsesHttpContinuation as z };
+export { replayResponsesReasoningUpdates as $, summarizeResponsesPayload as A, measureUtf8AppendBytes as At, responsesInputFingerprint as B, readResponsesRecoveryEvent as C, toOpenAIResponsesToolChoice as Ct, logResponsesFailedNoDetails as D, createResponseModelTracker as Dt, ResponsesStreamFailure as E, createOpenAIResponseHook as Et, convertProviderResponsesMessages as F, resolvePromptCacheKey as Ft, responsesContinuationRequestFingerprint as G, recordResponsesContinuationState as H, convertResponsesMessages as I, redactIdentifier as It, OPENAI_RESPONSES_ID_MAX_LENGTH as J, OPENAI_RESPONSES_CALL_ID_RE as K, resolveReplayableResponsesMessageId as L, sha256Hex as Lt, resolveResponsesContextUsageBoundary as M, readOpenAICompletionsContentDeltas as Mt, bindResponsesInputMessage as N, readOpenAICompletionsReasoningBatch as Nt, safeDebugValue as O, isOpenAICompletionsThinkingEnabled as Ot, buildResponsesInputMessage as P, resolveOpenAIClientBaseUrl as Pt, isConfigurationUpdate as Q, readResponsesInputReplayState as R, isInvalidEncryptedContentError as S, reconcileOpenAIResponsesToolChoice as St, resolveNextResponsesEncryptedContentAttempt as T, createOpenAIProviderAcceptanceHook as Tt, resolveResponsesContinuationRequest as U, claimOpenAIResponsesHttpContinuation as V, responsesContinuationPrefixFingerprint as W, shouldNormalizeOpenAIResponsesToolCallId as X, normalizeOpenAIResponsesFunctionCallId as Y, splitOpenAIFunctionCallPairing as Z, isResponsesTextContentPartType as _, resolveOpenAISimpleReasoningEffort as _t, prepareResponsesTools as a, suppressOpenAIResponsesCompaction as at, commitResponsesEncryptedContentAttempt as b, projectOpenAITools as bt, observeResponsesStream as c, buildOpenAISdkClientOptions as ct, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as d, filterCodeModePayloadTools as dt, supportsResponsesReasoningUpdate as et, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as f, getCompat as ft, isAzureResponsesTextDeltaEventType as g, resolveOpenAIRequestReasoning as gt, isAzureResponsesTextDeltaEvent as h, resolveOpenAIStrictToolFlagWithDiagnostics as ht, convertResponsesToolPayload as i, resolveNewestOpenAIResponsesCompactionReplay as it, recordResponsesContextUsage as j, parseOpenAICompletionsUsage as jt, summarizeOpenAITransportError as k, log as kt, createResponsesToolCallTracker as l, buildOpenAISdkRequestOptions as lt, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as m, resolveCodeModeResponsesVisibleToolNames as mt, applyResponsesServiceTierPricing as n, buildOpenAIResponsesReasoningReplayMetadata as nt, readOpenAIMisalignmentReview as o, assertCodeModeResponsesToolSurface as ot, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as p, readCodeModePayloadToolName as pt, OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE as q, runResponsesStreamLifecycle as r, captureOpenAIResponsesCompaction as rt, processResponsesStream as s, buildOpenAIClientHeaders as st, applyCommonResponsesParams as t, CompactionReplayRefreshRequiredError as tt, readResponsesToolCallItemIdentity as u, enforceCodeModeResponsesToolSurface as ut, isResponsesTextDeltaEventType as v, resolveOpenAIReasoningEffortMap as vt, resolveAzureOpenAIApiVersion as w, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as wt, createResponsesStreamWithRecovery as x, reconcileOpenAICompletionsToolChoice as xt, resolveResponsesMessageSnapshotCollapse as y, prepareOpenAITools as yt, recordResponsesInputReplay as z };