@openclaw/ai 2026.10.2 → 2026.10.4

package/dist/{openai-responses-shared-CKNmC3vC.mjs → openai-responses-shared-BMx2NAS-.mjs}

@@ -2,90 +2,761 @@ import "./src-VWy9E7DZ.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-u3o8XiAp.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 { 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 { D as applyProviderReportedUsageCost, E as headersToRecord, N as isImageWithMediaPayload, O as calculateCost, a as resolveAiTransportHeaderSentinels, k as clampThinkingLevel, r as getAiTransportHost } from "./host-u3o8XiAp.mjs";
+import { A as resolveOpenAIThinkingApi, C as resolveOpenAIReasoningEffortForModel, D as supportsOpenAITemperature, E as supportsOpenAIReasoningEffort, O as MODEL_CATALOG_THINKING_LEVELS, S as resolveOpenAIModelReasoningEfforts, 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, o as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, p as isPreviousResponseRejection, s as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY, w as resolveOpenAIReasoningEffortMapping, x as normalizeOpenAIReasoningEffort } from "./openai-responses-contracts-BKu8O7l4.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 { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-BK6E2g4Q.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-D_vRrx-z.mjs";
-import { c as resolveOpenAIResponsesTextFormat, i as resolveOpenAICompletionsCompat } from "./openai-completions-compat-GMN8A0fm.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-CCR7hSW0.mjs";
+import { i as providerReplayContextMatches, l as redactSensitiveText, n as buildProviderReplayContext, r as isProviderReplayContext, s as isCodeModeModelVisibleToolName, t as encodeTextSignatureV1 } from "./text-signature-CbqxIB8B.mjs";
+import { c as resolveOpenAIResponsesTextFormat, i as resolveOpenAICompletionsCompat, o as usesNativeOpenAICodexResponsesBackend } from "./openai-completions-compat-GMN8A0fm.mjs";
+import { r as resolveModelRequestTimeoutMs } from "./host-policy-BwhNNGQR.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, m as notifyProviderHttpResponse, t as IncompleteToolCallError, u as finalizeTransportStream, v as sanitizeTransportPayloadText } from "./transport-stream-shared-CCR7hSW0.mjs";
 import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, d as describeToolResultMediaPlaceholder, m as extractToolResultText, s as prepareModelRequestBody } from "./simple-options-7QuSKriJ.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-D7JMUPjf.mjs";
-import { n as isProviderReplayContext, r as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-CO_Eplnc.mjs";
 import { n as transformProviderMessages } from "./assistant-output-D5762GPH.mjs";
+import { n as projectRuntimeToolInputSchema, t as prepareRuntimeToolInputSchema } from "./tool-schema-json-projection-Ct8SeBeJ.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-D8f_oxHj.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-D9ZmL_s9.mjs";
-import { a as resolveOpenAIProjectedToolsStrictToolFlag, f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-BIrI0mrA.mjs";
+import { a as resolveOpenAIProjectedToolsStrictToolFlag, f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters, t as findOpenAIStrictToolProjectionDiagnostics } from "./openai-tool-schema-BIrI0mrA.mjs";
 import { n as isOpenAIResponsesCompactionOutput, r as readOpenAIResponsesCompactionWindow } from "./openai-responses-compaction-window-tA4QkU0o.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 { 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);
+	}
+};
+const OPENAI_RESPONSE_MODEL_CONFLICT = "Conflicting OpenAI response model attestations";
+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(OPENAI_RESPONSE_MODEL_CONFLICT);
+			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 = createOpenAICompletionsReasoningBatch();
+const OPENAI_COMPLETIONS_REASONING_FIELDS = [
+	"reasoning_content",
+	"reasoning",
+	"reasoning_text"
+];
+function appendOpenAICompletionsReasoningDelta(batch, next) {
+	if (next.kind === "thinking") batch.hasThinking = true;
+	else batch.hasVisibleText = true;
+	const previous = batch.deltas[batch.deltas.length - 1];
+	if (!previous || previous.kind !== next.kind || next.kind === "thinking" && previous.kind === "thinking" && previous.signature !== next.signature) {
+		batch.deltas.push(next);
+		if (next.kind === "thinking") batch.mirroredThinking.push(next.text);
+		return;
+	}
+	previous.text += next.text;
+	if (next.kind === "thinking") batch.mirroredThinking[batch.mirroredThinking.length - 1] += next.text;
 }
-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 createOpenAICompletionsReasoningBatch() {
+	return {
+		deltas: [],
+		mirroredThinking: [],
+		hasThinking: false,
+		hasVisibleText: false
+	};
+}
+function readOpenAICompletionsReasoningBatch(delta, visibleReasoningDetailTypes) {
+	let batch;
+	const reasoningDetails = delta.reasoning_details;
+	let usedReasoningThinkingDetails = false;
+	if (Array.isArray(reasoningDetails)) for (const item of reasoningDetails) {
+		if (!isRecord(item)) continue;
+		const detail = item;
+		if (typeof detail.text !== "string" || !detail.text) continue;
+		if (detail.type === "reasoning.text") {
+			usedReasoningThinkingDetails = true;
+			batch ??= createOpenAICompletionsReasoningBatch();
+			appendOpenAICompletionsReasoningDelta(batch, {
+				kind: "thinking",
+				signature: "reasoning_details",
+				text: detail.text
+			});
+			continue;
+		}
+		if (typeof detail.type === "string" && visibleReasoningDetailTypes.has(detail.type)) {
+			batch ??= createOpenAICompletionsReasoningBatch();
+			appendOpenAICompletionsReasoningDelta(batch, {
+				kind: "text",
+				text: detail.text,
+				source: "reasoning_detail"
+			});
+		}
+	}
+	if (!usedReasoningThinkingDetails) for (const field of OPENAI_COMPLETIONS_REASONING_FIELDS) {
+		const value = delta[field];
+		if (typeof value === "string" && value.length > 0) {
+			batch ??= createOpenAICompletionsReasoningBatch();
+			appendOpenAICompletionsReasoningDelta(batch, {
+				kind: "thinking",
+				signature: field,
+				text: value
+			});
+			break;
+		}
+	}
+	return batch ?? EMPTY_OPENAI_COMPLETIONS_REASONING_BATCH;
+}
+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 = 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 && typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? { 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;
 }
-/** 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 createOpenAIResponseHook(onResponse, response, model) {
+	return onResponse ? () => onResponse({
+		status: response.status,
+		headers: headersToRecord(response.headers)
+	}, model) : void 0;
+}
+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;
+		try {
+			const candidate = tools[toolIndex];
+			if (!candidate) {
+				diagnostics.push(unreadableToolDiagnostic(toolIndex));
+				continue;
+			}
+			tool = candidate;
+		} catch {
+			diagnostics.push(unreadableToolDiagnostic(toolIndex));
+			continue;
+		}
+		let name;
+		try {
+			name = tool.name;
+		} catch {
+			diagnostics.push({
+				toolIndex,
+				violations: [`tool[${toolIndex}].name is unreadable`]
+			});
+			continue;
+		}
+		if (typeof name !== "string" || !name) {
+			diagnostics.push({
+				toolIndex,
+				violations: [`tool[${toolIndex}].name is empty`]
+			});
+			continue;
+		}
+		let parameters;
+		try {
+			parameters = tool.parameters;
+		} catch {
+			diagnostics.push({
+				toolIndex,
+				toolName: name,
+				violations: [`${name}.parameters 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) {
+	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 ? 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 ?? {},
+		vercelGatewayRouting: resolved.vercelGatewayRouting,
+		requiresStringContent: compat.requiresStringContent ?? false,
+		strictMessageKeys: compat.strictMessageKeys === true
+	};
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-compaction-replay.ts
@@ -289,6 +960,65 @@ 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 shortOpenAIResponsesIdHash(id) {
+	return sha256Hex(id).slice(0, 10);
+}
+function sanitizeOpenAIResponsesIdTail(value) {
+	return value.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+|_+$/g, "");
+}
+function normalizeOpenAIResponsesIdPart(params) {
+	const trimmed = params.value.trim();
+	if (params.isValid(trimmed)) return trimmed;
+	const rawTail = trimmed.startsWith(params.prefix) ? trimmed.slice(params.prefix.length) : trimmed;
+	const hash = shortOpenAIResponsesIdHash(trimmed || params.prefix);
+	const maxTailLength = 64 - params.prefix.length;
+	const hashSuffix = `_${hash}`;
+	const tail = `${sanitizeOpenAIResponsesIdTail(rawTail).slice(0, Math.max(1, maxTailLength - hashSuffix.length)) || "id"}${hashSuffix}`.slice(0, maxTailLength);
+	return `${params.prefix}${tail}`;
+}
+/** Same shaping `normalizeOpenAIResponsesToolCallIds` applies to a replayed `call_id`/`call_id|fc_id` pair. */
+function normalizeOpenAIResponsesFunctionCallId(id) {
+	const { callId, itemId } = splitOpenAIFunctionCallPairing(id);
+	const normalizedCallId = normalizeOpenAIResponsesIdPart({
+		value: itemId ? `${callId}|${itemId}` : callId,
+		prefix: "call_",
+		isValid: (value) => OPENAI_RESPONSES_CALL_ID_RE.test(value)
+	});
+	if (!itemId) return normalizedCallId;
+	return `${normalizedCallId}|${normalizeOpenAIResponsesIdPart({
+		value: itemId,
+		prefix: "fc_",
+		isValid: (value) => OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE.test(value)
+	})}`;
+}
+function shouldNormalizeOpenAIResponsesToolCallId(id) {
+	const pairing = splitOpenAIFunctionCallPairing(id);
+	if (!OPENAI_RESPONSES_CALL_ID_RE.test(pairing.callId)) return true;
+	if (pairing.itemId === void 0) return false;
+	return !OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE.test(pairing.itemId);
+}
+//#endregion
 //#region packages/ai/src/transports/openai-responses-continuation.ts
 const HTTP_CONTINUATION_IDLE_TTL_MS = 54e5;
 const MAX_HTTP_CONTINUATION_READY_ENTRIES = 1e3;
@@ -681,6 +1411,14 @@ 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;
@@ -2671,4 +3409,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 { supportsResponsesReasoningUpdate as $, recordResponsesContextUsage as A, parseOpenAICompletionsUsage as At, claimOpenAIResponsesHttpContinuation as B, resolveAzureOpenAIApiVersion as C, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as Ct, safeDebugValue as D, isOpenAICompletionsThinkingEnabled as Dt, logResponsesFailedNoDetails as E, createResponseModelTracker as Et, convertResponsesMessages as F, redactIdentifier as Ft, OPENAI_RESPONSES_CALL_ID_RE as G, resolveResponsesContinuationRequest as H, resolveReplayableResponsesMessageId as I, sha256Hex as It, normalizeOpenAIResponsesFunctionCallId as J, OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE as K, readResponsesInputReplayState as L, bindResponsesInputMessage as M, readOpenAICompletionsReasoningBatch as Mt, buildResponsesInputMessage as N, resolveOpenAIClientBaseUrl as Nt, summarizeOpenAITransportError as O, log as Ot, convertProviderResponsesMessages as P, resolvePromptCacheKey as Pt, replayResponsesReasoningUpdates as Q, recordResponsesInputReplay as R, isInvalidEncryptedContentError as S, toOpenAIResponsesToolChoice as St, ResponsesStreamFailure as T, createOpenAIResponseHook as Tt, responsesContinuationPrefixFingerprint as U, recordResponsesContinuationState as V, responsesContinuationRequestFingerprint as W, splitOpenAIFunctionCallPairing as X, shouldNormalizeOpenAIResponsesToolCallId as Y, isConfigurationUpdate as Z, isResponsesTextContentPartType as _, resolveOpenAIReasoningEffortMap as _t, prepareResponsesTools as a, assertCodeModeResponsesToolSurface as at, commitResponsesEncryptedContentAttempt as b, reconcileOpenAICompletionsToolChoice as bt, observeResponsesStream as c, buildOpenAISdkRequestOptions as ct, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as d, getCompat as dt, CompactionReplayRefreshRequiredError as et, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as f, readCodeModePayloadToolName as ft, isAzureResponsesTextDeltaEventType as g, resolveOpenAISimpleReasoningEffort as gt, isAzureResponsesTextDeltaEvent as h, resolveOpenAIRequestReasoning as ht, convertResponsesToolPayload as i, suppressOpenAIResponsesCompaction as it, resolveResponsesContextUsageBoundary as j, readOpenAICompletionsContentDeltas as jt, summarizeResponsesPayload as k, measureUtf8AppendBytes as kt, createResponsesToolCallTracker as l, enforceCodeModeResponsesToolSurface as lt, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as m, resolveOpenAIStrictToolFlagWithDiagnostics as mt, applyResponsesServiceTierPricing as n, captureOpenAIResponsesCompaction as nt, readOpenAIMisalignmentReview as o, buildOpenAIClientHeaders as ot, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as p, resolveCodeModeResponsesVisibleToolNames as pt, OPENAI_RESPONSES_ID_MAX_LENGTH as q, runResponsesStreamLifecycle as r, resolveNewestOpenAIResponsesCompactionReplay as rt, processResponsesStream as s, buildOpenAISdkClientOptions as st, applyCommonResponsesParams as t, buildOpenAIResponsesReasoningReplayMetadata as tt, readResponsesToolCallItemIdentity as u, filterCodeModePayloadTools as ut, isResponsesTextDeltaEventType as v, prepareOpenAITools as vt, resolveNextResponsesEncryptedContentAttempt as w, createOpenAIProviderAcceptanceHook as wt, createResponsesStreamWithEncryptedContentRetry as x, reconcileOpenAIResponsesToolChoice as xt, resolveResponsesMessageSnapshotCollapse as y, projectOpenAITools as yt, responsesInputFingerprint as z };