@openclaw/ai 2026.7.2-beta.4 → 2026.7.2-beta.5

package/dist/{openai-responses-shared-CzCurmY1.mjs → openai-D3PD6PE-.mjs}

@@ -1,13 +1,57 @@
+import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
 import { n as getAiTransportHost } from "./host-XYGZcgO8.mjs";
-import { C as isImageWithMediaPayload, T as isRecord, _ as normalizeOptionalString, a as stripSystemPromptCacheBoundary, c as transformMessages, g as normalizeLowercaseStringOrEmpty, x as extractToolResultText, y as describeToolResultMediaPlaceholder } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
+import { A as buildBaseOptions, D as truncateUtf16Safe, E as isImageWithMediaPayload, O as isRecord, S as describeToolResultMediaPlaceholder, b as normalizeOptionalString, l as sortPromptCacheToolsByName, o as stripSystemPromptCacheBoundary, u as transformMessages, w as extractToolResultText, y as normalizeLowercaseStringOrEmpty } from "./shared-CdjNZd35.mjs";
 import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-1GiZ2_rr.mjs";
+import { C as transformTransportMessages, a as projectOpenAITools } from "./openai-completions-CiSutyu0.mjs";
+import { c as calculateCost, l as clampThinkingLevel } from "./number-coercion-DvG7SNMg.mjs";
+import { b as redactIdentifier, d as transportAbortError, l as sanitizeNonEmptyTransportPayloadText, u as sanitizeTransportPayloadText, x as redactSensitiveText } from "./transport-stream-shared-BbMELSI4.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
 import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
+import { a as resolveCacheRetention$1, i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-BCoBNmL7.mjs";
 import { t as shortHash } from "./hash-CHgqbJmD.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DP4xEyBY.mjs";
-import { t as projectOpenAITools } from "./openai-tool-projection-ITOU9bG1.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-C3OgBjIk.mjs";
 import { createHash, randomUUID } from "node:crypto";
+import OpenAI from "openai";
+//#region packages/ai/src/transports/model-transport-debug.ts
+function normalizeEnv(value) {
+	return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function isTruthyEnv(value) {
+	const normalized = normalizeEnv(value);
+	return normalized.length > 0 && normalized !== "0" && normalized !== "false" && normalized !== "off" && normalized !== "no";
+}
+/** Resolves model payload debug verbosity from `OPENCLAW_DEBUG_MODEL_PAYLOAD`. */
+function resolveModelPayloadDebugMode(env = process.env) {
+	const normalized = normalizeEnv(env.OPENCLAW_DEBUG_MODEL_PAYLOAD);
+	if (normalized === "tools" || normalized === "full-redacted") return normalized;
+	if (normalized === "summary") return "summary";
+	return "off";
+}
+/** Resolves SSE stream debug verbosity from `OPENCLAW_DEBUG_SSE`. */
+function resolveModelSseDebugMode(env = process.env) {
+	const normalized = normalizeEnv(env.OPENCLAW_DEBUG_SSE);
+	if (normalized === "peek") return "peek";
+	if (normalized === "events" || isTruthyEnv(normalized)) return "events";
+	return "off";
+}
+/** Returns whether any model transport debug channel is enabled. */
+function isModelTransportDebugEnabled(env = process.env) {
+	return isTruthyEnv(env.OPENCLAW_DEBUG_MODEL_TRANSPORT) || resolveModelPayloadDebugMode(env) !== "off" || resolveModelSseDebugMode(env) !== "off" || isTruthyEnv(env.OPENCLAW_DEBUG_CODE_MODE);
+}
+function isModelFetchMetadataMessage(message) {
+	return message.startsWith("[model-fetch]");
+}
+/** Emits model-fetch metadata at info level by default; other diagnostics require debug env. */
+function emitModelTransportDebug(log, message) {
+	if (isModelFetchMetadataMessage(message) || isModelTransportDebugEnabled()) {
+		log.info(message);
+		return;
+	}
+	log.debug(message);
+}
+//#endregion
 //#region packages/normalization-core/src/string-normalization.ts
 /** Coerces entries to strings, trims them, and drops empty results. */
 function normalizeStringEntries(list) {
@@ -896,6 +940,67 @@ function normalizeToolParameterSchema(schema, options) {
 	return rememberCachedToolParameterSchema(schema, cacheKey, normalizeToolParameterSchemaUncached(schema, options));
 }
 //#endregion
+//#region packages/ai/src/providers/azure-deployment-map.ts
+/** Parses AZURE_OPENAI_DEPLOYMENT_MAP-style model=deployment entries. */
+function parseAzureDeploymentNameMap(value) {
+	const map = /* @__PURE__ */ new Map();
+	if (!value) return map;
+	for (const entry of value.split(",")) {
+		const trimmed = entry.trim();
+		if (!trimmed) continue;
+		const separator = trimmed.indexOf("=");
+		if (separator <= 0) continue;
+		const modelId = trimmed.slice(0, separator).trim();
+		const deploymentName = trimmed.slice(separator + 1).trim();
+		if (!modelId || !deploymentName) continue;
+		map.set(modelId, deploymentName);
+	}
+	return map;
+}
+let cachedDeploymentLookup;
+function getDeploymentLookup(source) {
+	const cached = cachedDeploymentLookup;
+	if (cached && cached.source === source) return cached;
+	const exact = parseAzureDeploymentNameMap(source);
+	const folded = /* @__PURE__ */ new Map();
+	for (const [modelId, deploymentName] of exact) folded.set(modelId.toLowerCase(), deploymentName);
+	cachedDeploymentLookup = {
+		source,
+		exact,
+		folded
+	};
+	return cachedDeploymentLookup;
+}
+/**
+* Resolves the Azure deployment name for a model id, falling back to the model id.
+*
+* An exact-case match always wins, so configs that intentionally distinguish keys by
+* case keep their exact mappings; a case-insensitive match is only used as a fallback
+* (e.g. `GPT-4o` against a `gpt-4o=...` map) to avoid 404s from casing differences.
+*/
+function resolveAzureDeploymentNameFromMap(params) {
+	const { exact, folded } = getDeploymentLookup(params.deploymentMap);
+	return exact.get(params.modelId) ?? folded.get(params.modelId.toLowerCase()) ?? params.modelId;
+}
+//#endregion
+//#region packages/ai/src/providers/azure-openai-responses-client-compat.ts
+function isTraditionalAzureOpenAIHost(hostname) {
+	return hostname.endsWith(".openai.azure.com") || hostname.endsWith(".cognitiveservices.azure.com");
+}
+function isOpenAICompatibleAzureResponsesBaseUrl(baseUrl) {
+	let url;
+	try {
+		url = new URL(baseUrl);
+	} catch {
+		return false;
+	}
+	if (isTraditionalAzureOpenAIHost(url.hostname)) return false;
+	const hostname = url.hostname.toLowerCase();
+	if (!(hostname.endsWith(".services.ai.azure.com") || hostname.endsWith(".api.cognitive.microsoft.com"))) return false;
+	const normalizedPath = url.pathname.replace(/\/+$/, "");
+	return normalizedPath === "/openai/v1" || normalizedPath.endsWith("/openai/v1");
+}
+//#endregion
 //#region packages/ai/src/providers/openai-reasoning-effort.ts
 /**
 * OpenAI-compatible reasoning-effort normalization. Different GPT families
@@ -1076,66 +1181,6 @@ function resolveResponsesMessageSnapshotCollapse(params) {
 	return { kind: "keep" };
 }
 //#endregion
-//#region packages/ai/src/providers/openai-responses-terminal-usage.ts
-function readCount(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-/**
-* Split a terminal usage payload into the priced buckets.
-*
-* OpenAI includes cache reads and writes in `input_tokens`, so both are subtracted out of the
-* billable input bucket. `total_tokens` comes from the payload, but never below the sum of the
-* split buckets: proxies routinely omit it (reporting 0 would understate the turn), and a payload
-* whose `cached_tokens` exceeds `input_tokens` clamps the input bucket, leaving the reported total
-* short of what the buckets actually price.
-*/
-function mapResponsesTerminalUsage(usage) {
-	if (!usage) return;
-	const cacheRead = readCount(usage.input_tokens_details?.cached_tokens);
-	const cacheWrite = readCount(usage.input_tokens_details?.cache_write_tokens);
-	const input = Math.max(0, readCount(usage.input_tokens) - cacheRead - cacheWrite);
-	const output = readCount(usage.output_tokens);
-	const bucketTotal = input + output + cacheRead + cacheWrite;
-	return {
-		input,
-		output,
-		cacheRead,
-		cacheWrite,
-		totalTokens: Math.max(bucketTotal, readCount(usage.total_tokens))
-	};
-}
-/** Reasoning tokens are reported by the agent path only; the package path does not track them. */
-function readResponsesReasoningTokens(usage) {
-	const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens;
-	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? reasoningTokens : void 0;
-}
-function mapResponsesTerminalStopReason(status) {
-	if (!status) return "stop";
-	switch (status) {
-		case "completed": return "stop";
-		case "incomplete": return "length";
-		case "failed":
-		case "cancelled": return "error";
-		case "in_progress":
-		case "queued": return "stop";
-		default: throw new Error(`Unhandled stop reason: ${String(status)}`);
-	}
-}
-/**
-* Resolve the terminal stop reason, including the two overrides every Responses path shares: a
-* content-filtered turn is a provider error rather than a truncated answer, and a turn that
-* produced tool calls reports `toolUse` instead of a plain stop.
-*/
-function resolveResponsesTerminalStopReason(params) {
-	if (params.status === "incomplete" && params.incompleteReason === "content_filter") return {
-		stopReason: "error",
-		errorMessage: "Provider incomplete_reason: content_filter"
-	};
-	const stopReason = mapResponsesTerminalStopReason(params.status);
-	if (stopReason === "stop" && params.hasToolCall) return { stopReason: "toolUse" };
-	return { stopReason };
-}
-//#endregion
 //#region packages/ai/src/providers/openai-responses-tool-call-tracker.ts
 function readIdentityValue(value) {
 	return (typeof value === "string" ? value.trim() : "") || void 0;
@@ -1211,175 +1256,1556 @@ function createResponsesToolCallTracker() {
 		}
 	};
 }
+const OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS = "Follow the user request.";
+const AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS = 3e4;
+const RESPONSE_FAILED_NO_DETAILS_MESSAGE = "Unknown error (no error details in response)";
+const OPENAI_RESPONSES_REASONING_REPLAY_META_KEY = "__openclaw_replay";
+const OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY = "openclawReasoningReplay";
 //#endregion
-//#region packages/ai/src/providers/openai-tool-schema-compat.ts
-const OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
-	"$defs",
-	"definitions",
-	"dependentSchemas",
-	"dependencies",
-	"patternProperties",
-	"properties"
-]);
-const OPENAI_NULLABLE_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
-	"default",
-	"description",
-	"examples",
-	"format",
-	"title"
-]);
-const OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS = /* @__PURE__ */ new Set([
-	"additionalItems",
-	"additionalProperties",
-	"allOf",
-	"anyOf",
-	"contains",
-	"contentSchema",
-	"else",
-	"if",
-	"items",
-	"not",
-	"oneOf",
-	"prefixItems",
-	"propertyNames",
-	"then",
-	"unevaluatedItems",
-	"unevaluatedProperties"
-]);
-function normalizeOpenAIStrictCompatSchemaMap(schema) {
-	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
-	let changed = false;
-	const normalized = {};
-	for (const [key, value] of Object.entries(schema)) {
-		const next = normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false });
-		normalized[key] = next;
-		changed ||= next !== value;
+//#region packages/ai/src/transports/openai-transport-shared.ts
+/** Shared options, usage shape, cache identity, ordering, and stream scheduling for OpenAI APIs. */
+const MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS = 12;
+const MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS = 64;
+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);
 	}
-	return changed ? normalized : schema;
-}
-function normalizeOpenAIStrictCompatSchemaRecursive(schema, options) {
-	if (Array.isArray(schema)) {
-		let changed = false;
-		const normalized = schema.map((entry) => {
-			const next = normalizeOpenAIStrictCompatSchemaRecursive(entry, { promoteEmptyObject: false });
-			changed ||= next !== entry;
-			return next;
+};
+function throwIfModelStreamAborted(signal) {
+	if (signal?.aborted) throw transportAbortError(signal);
+}
+function createModelStreamCooperativeScheduler(signal) {
+	let lastYieldedAt = Date.now();
+	let eventsSinceYield = 0;
+	return { async afterEvent() {
+		throwIfModelStreamAborted(signal);
+		eventsSinceYield += 1;
+		const now = Date.now();
+		if (eventsSinceYield < MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS && now - lastYieldedAt < MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS) return;
+		eventsSinceYield = 0;
+		lastYieldedAt = now;
+		await new Promise((resolve) => {
+			setTimeout(resolve, 0);
 		});
-		return changed ? normalized : schema;
-	}
-	if (!schema || typeof schema !== "object") return schema;
-	const record = schema;
-	let changed = false;
-	let hadNullType = false;
-	const normalized = {};
-	for (const [key, value] of Object.entries(record)) {
-		if (value === null && OPENAI_NULLABLE_ANNOTATION_KEYS.has(key)) {
-			changed = true;
-			continue;
-		}
-		if (value === null && key === "type") {
-			hadNullType = true;
-			changed = true;
-			continue;
-		}
-		const next = OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaMap(value) : OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false }) : value;
-		normalized[key] = next;
-		changed ||= next !== value;
+		throwIfModelStreamAborted(signal);
+	} };
+}
+function resolveCacheRetention(cacheRetention) {
+	if (cacheRetention === "short" || cacheRetention === "long" || cacheRetention === "none") return cacheRetention;
+	if (typeof process !== "undefined" && process.env.OPENCLAW_CACHE_RETENTION === "long") return "long";
+	return "short";
+}
+function resolvePromptCacheKey(options, cacheRetention) {
+	if (cacheRetention === "none") return;
+	return clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId);
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-debug.ts
+function stringifyUnknown(value, fallback = "") {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return fallback;
+}
+function getServiceTierCostMultiplier$1(serviceTier) {
+	switch (serviceTier) {
+		case "flex": return .5;
+		case "priority": return 2;
+		default: return 1;
 	}
-	if (Object.keys(normalized).length === 0) {
-		if (!options.promoteEmptyObject) return schema;
-		return {
-			type: "object",
-			properties: {},
-			required: [],
-			additionalProperties: false
-		};
+}
+function applyServiceTierPricing$1(usage, serviceTier) {
+	const multiplier = getServiceTierCostMultiplier$1(serviceTier);
+	if (multiplier === 1) return;
+	usage.cost.input *= multiplier;
+	usage.cost.output *= multiplier;
+	usage.cost.cacheRead *= multiplier;
+	usage.cost.cacheWrite *= multiplier;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+function safeDebugValue(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	return Array.isArray(value) ? "array" : typeof value;
+}
+function responseInputTextChars(input) {
+	if (typeof input === "string") return input.length;
+	if (Array.isArray(input)) return input.reduce((total, item) => total + responseInputTextChars(item), 0);
+	if (!input || typeof input !== "object") return 0;
+	const record = input;
+	let total = 0;
+	if (typeof record.text === "string") total += record.text.length;
+	if (typeof record.content === "string") total += record.content.length;
+	else if (Array.isArray(record.content)) total += responseInputTextChars(record.content);
+	return total;
+}
+function responseInputRoles(input) {
+	if (!Array.isArray(input)) return "";
+	const roles = /* @__PURE__ */ new Set();
+	for (const item of input) if (item && typeof item === "object") {
+		const role = item.role;
+		if (typeof role === "string" && role.trim()) roles.add(role.trim());
 	}
-	const hasObjectShapeHints = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) || Array.isArray(normalized.required);
-	const hasArrayShapeHints = "items" in normalized;
-	if (!("type" in normalized) && hasObjectShapeHints !== hasArrayShapeHints) {
-		normalized.type = hasObjectShapeHints ? "object" : "array";
-		changed = true;
-	} else if (hadNullType && !("type" in normalized)) normalized.type = null;
-	if (normalized.type === "object" && !("properties" in normalized)) {
-		normalized.properties = {};
-		changed = true;
+	return [...roles].toSorted().join(",");
+}
+function readToolPayloadField(record, field) {
+	try {
+		return record[field];
+	} catch {
+		return;
 	}
-	const hasEmptyProperties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) && Object.keys(normalized.properties).length === 0;
-	if (normalized.type === "object" && !Array.isArray(normalized.required) && hasEmptyProperties) {
-		normalized.required = [];
-		changed = true;
+}
+function readResponsesToolDisplayName(tool) {
+	if (!tool || typeof tool !== "object") return "";
+	const record = tool;
+	const name = readToolPayloadField(record, "name");
+	if (typeof name === "string") return name;
+	const fn = readToolPayloadField(record, "function");
+	if (fn && typeof fn === "object") {
+		const fnName = readToolPayloadField(fn, "name");
+		if (typeof fnName === "string") return fnName;
 	}
-	if (normalized.type === "object" && hasEmptyProperties && !("additionalProperties" in normalized)) {
-		normalized.additionalProperties = false;
-		changed = true;
+	const type = readToolPayloadField(record, "type");
+	return typeof type === "string" && type !== "function" ? type : "";
+}
+function summarizeResponsesTools(tools) {
+	if (!Array.isArray(tools)) return "count=0";
+	const names = tools.map(readResponsesToolDisplayName).filter(Boolean);
+	const mode = resolveModelPayloadDebugMode();
+	const maxNames = mode === "tools" || mode === "full-redacted" ? names.length : 12;
+	const label = maxNames >= names.length ? "names" : "sample";
+	const shown = names.slice(0, maxNames).join(",");
+	return `count=${tools.length}${shown ? ` ${label}=${shown}` : ""}`;
+}
+function stringifyRedactedPayload(value) {
+	try {
+		const encoded = JSON.stringify(value);
+		if (!encoded) return "<empty>";
+		const redacted = redactSensitiveText(encoded, { mode: "tools" });
+		return redacted.length > 8e3 ? `${truncateUtf16Safe(redacted, 8e3)}…<truncated>` : redacted;
+	} catch {
+		return "<unserializable>";
 	}
-	return changed ? normalized : schema;
-}
-/** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
-function normalizeOpenAIStrictCompatSchema(schema) {
-	return normalizeOpenAIStrictCompatSchemaRecursive(schema, { promoteEmptyObject: true });
 }
-/** Finds schema paths that violate OpenAI strict tool-schema requirements. */
-function findOpenAIStrictSchemaViolations(schema, path, options) {
-	if (Array.isArray(schema)) {
-		if (options?.requireObjectRoot) return [`${path}.type`];
-		return schema.flatMap((item, index) => findOpenAIStrictSchemaViolations(item, `${path}[${index}]`));
-	}
-	if (!schema || typeof schema !== "object") return options?.requireObjectRoot ? [`${path}.type`] : [];
-	const record = schema;
-	const violations = [];
-	for (const key of [
-		"anyOf",
-		"oneOf",
-		"allOf"
-	]) if (key in record) violations.push(`${path}.${key}`);
-	if (Array.isArray(record.type)) violations.push(`${path}.type`);
-	const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : void 0;
-	if (record.type === "object") {
-		if (record.additionalProperties !== false) violations.push(`${path}.additionalProperties`);
-		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
-		if (!required) violations.push(`${path}.required`);
-		else if (properties) {
-			const requiredSet = new Set(required);
-			for (const key of Object.keys(properties)) if (!requiredSet.has(key)) violations.push(`${path}.required.${key}`);
+function stringifyRedactedEvent(value) {
+	const redacted = stringifyRedactedPayload(value);
+	return redacted.length > 2e3 ? `${truncateUtf16Safe(redacted, 2e3)}…<truncated>` : redacted;
+}
+const RESPONSE_FAILED_FAILURE_FIELD_KEYS = [
+	"error",
+	"incomplete_details",
+	"status_details",
+	"failure_reason",
+	"last_error",
+	"provider_error",
+	"error_details"
+];
+function readResponseFailedString(record, key) {
+	return stringifyUnknown(record?.[key]);
+}
+function buildResponsesFailedEventSummary(message, responseId, observation) {
+	const summary = { message };
+	if (responseId) summary.responseId = responseId;
+	if (observation) summary.observation = observation;
+	return summary;
+}
+function isResponseFailedIdentifierKey(key) {
+	const normalized = key.replace(/[-_\s]/g, "").toLowerCase();
+	return normalized === "requestid" || normalized === "xrequestid" || normalized === "providerrequestid" || normalized === "providerresponseid" || normalized === "litellmrequestid" || normalized.includes("request") && normalized.endsWith("id") || normalized.includes("provider") && normalized.endsWith("id");
+}
+function collectResponseFailedIdentifierHashes(value, opts = {}) {
+	const path = opts.path ?? "";
+	const depth = opts.depth ?? 0;
+	const identifierKey = opts.identifierKey ?? "";
+	const out = opts.out ?? [];
+	const seen = opts.seen ?? /* @__PURE__ */ new WeakSet();
+	if (out.length >= 12 || depth > 4 || !value || typeof value !== "object") return out;
+	if (seen.has(value)) return out;
+	seen.add(value);
+	if (Array.isArray(value)) {
+		for (const [index, item] of value.entries()) {
+			if (index >= 8 || out.length >= 12) break;
+			const itemString = typeof item === "string" || typeof item === "number" ? String(item).trim() : "";
+			if (identifierKey && isResponseFailedIdentifierKey(identifierKey) && itemString) {
+				out.push(`${path}[${index}]=${redactIdentifier(itemString, { len: 12 })}`);
+				continue;
+			}
+			collectResponseFailedIdentifierHashes(item, {
+				path: `${path}[${index}]`,
+				depth: depth + 1,
+				identifierKey,
+				out,
+				seen
+			});
 		}
+		return out;
 	}
-	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS) {
-		const schemaMap = record[key];
-		if (!schemaMap || typeof schemaMap !== "object" || Array.isArray(schemaMap)) continue;
-		for (const [entryKey, value] of Object.entries(schemaMap)) violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}.${entryKey}`));
-	}
-	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS) {
-		const value = record[key];
-		if (value && typeof value === "object") violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}`));
+	for (const [key, child] of Object.entries(value)) {
+		if (out.length >= 12) break;
+		const childPath = path ? `${path}.${key}` : key;
+		const childString = typeof child === "string" || typeof child === "number" ? String(child).trim() : "";
+		if (isResponseFailedIdentifierKey(key) && childString) {
+			out.push(`${childPath}=${redactIdentifier(childString, { len: 12 })}`);
+			continue;
+		}
+		collectResponseFailedIdentifierHashes(child, {
+			path: childPath,
+			depth: depth + 1,
+			identifierKey: isResponseFailedIdentifierKey(key) ? key : void 0,
+			out,
+			seen
+		});
 	}
-	return violations;
-}
-//#endregion
-//#region packages/ai/src/providers/openai-tool-schema.ts
-/**
-* OpenAI strict JSON-schema normalization for tool inventories and request payloads.
-*
-* Caches normalized object inputs by provider compatibility so repeated inventory builds preserve identity.
-*/
-const MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
-let strictOpenAISchemaCache = /* @__PURE__ */ new WeakMap();
-function resolveToolSchemaModelCompat(compat) {
-	if (!compat) return;
-	const unsupportedToolSchemaKeywords = Array.isArray(compat.unsupportedToolSchemaKeywords) ? compat.unsupportedToolSchemaKeywords.filter((keyword) => typeof keyword === "string") : [];
-	if (unsupportedToolSchemaKeywords.length === 0 && compat.omitEmptyArrayItems !== true) return;
+	return out;
+}
+function redactResponseFailedDiagnosticValue(value, opts = {}) {
+	const key = opts.key ?? "";
+	const depth = opts.depth ?? 0;
+	if (typeof value === "string" || typeof value === "number") return key && isResponseFailedIdentifierKey(key) ? redactIdentifier(String(value), { len: 12 }) : value;
+	if (depth > 6 || !value || typeof value !== "object") return value;
+	const seen = opts.seen ?? /* @__PURE__ */ new WeakSet();
+	if (seen.has(value)) return "<circular>";
+	seen.add(value);
+	if (Array.isArray(value)) return value.slice(0, 16).map((item) => redactResponseFailedDiagnosticValue(item, {
+		key,
+		depth: depth + 1,
+		seen
+	}));
+	const out = {};
+	for (const [childKey, child] of Object.entries(value)) out[childKey] = redactResponseFailedDiagnosticValue(child, {
+		key: childKey,
+		depth: depth + 1,
+		seen
+	});
+	return out;
+}
+function buildResponsesFailedFailureFields(response) {
+	if (!response) return {};
+	const fields = {};
+	for (const key of RESPONSE_FAILED_FAILURE_FIELD_KEYS) if (response[key] !== void 0 && response[key] !== null) fields[key] = response[key];
+	return fields;
+}
+function buildResponsesFailedNoDetailsObservation(event, model, response = isRecord(event.response) ? event.response : void 0) {
+	const failureFields = redactResponseFailedDiagnosticValue(buildResponsesFailedFailureFields(response));
+	const metadataKeys = isRecord(response?.metadata) ? Object.keys(response.metadata).toSorted() : [];
+	const responsePreview = {
+		id: readResponseFailedString(response, "id"),
+		status: readResponseFailedString(response, "status"),
+		model: readResponseFailedString(response, "model"),
+		object: readResponseFailedString(response, "object"),
+		failureFields,
+		metadataKeys
+	};
 	return {
-		...unsupportedToolSchemaKeywords.length > 0 ? { unsupportedToolSchemaKeywords } : {},
-		...compat.omitEmptyArrayItems === true ? { omitEmptyArrayItems: true } : {}
+		event: "openai_responses_response_failed_without_details",
+		provider: model.provider,
+		api: model.api,
+		transportModel: model.id,
+		providerRuntimeFailureKind: "no_error_details",
+		responseId: responsePreview.id,
+		responseStatus: responsePreview.status,
+		responseModel: responsePreview.model,
+		responseObject: responsePreview.object,
+		metadataKeys,
+		requestIdHashes: collectResponseFailedIdentifierHashes(event),
+		failureFieldsPreview: stringifyRedactedEvent(failureFields),
+		responsePreview: stringifyRedactedEvent(responsePreview)
 	};
 }
-function resolveStrictOpenAISchemaCacheKey(modelCompat) {
-	const compat = resolveToolSchemaModelCompat(modelCompat);
-	return JSON.stringify([[...compat?.unsupportedToolSchemaKeywords ?? []].toSorted(), shouldOmitEmptyArrayItems(compat)]);
+function summarizeResponsesFailedNoDetailsObservation(observation) {
+	const requestIds = observation.requestIdHashes.join(",");
+	const metadataKeys = observation.metadataKeys.join(",");
+	return `responseId=${safeDebugValue(observation.responseId || void 0)} responseStatus=${safeDebugValue(observation.responseStatus || void 0)} responseModel=${safeDebugValue(observation.responseModel || void 0)} requestIds=${requestIds || "none"} metadataKeys=${metadataKeys || "none"} failureFields=${observation.failureFieldsPreview}`;
+}
+function normalizeResponsesFailedEvent(event, model) {
+	const response = isRecord(event.response) ? event.response : void 0;
+	const responseId = readResponseFailedString(response, "id") || void 0;
+	const error = isRecord(response?.error) ? response.error : void 0;
+	if (error) {
+		const code = readResponseFailedString(error, "code").trim();
+		const message = readResponseFailedString(error, "message").trim();
+		if (code || message) return buildResponsesFailedEventSummary(`${code || "unknown"}: ${message || "no message"}`, responseId);
+	}
+	const incompleteReason = readResponseFailedString(isRecord(response?.incomplete_details) ? response.incomplete_details : void 0, "reason");
+	if (incompleteReason) return buildResponsesFailedEventSummary(`incomplete: ${incompleteReason}`, responseId);
+	return buildResponsesFailedEventSummary(RESPONSE_FAILED_NO_DETAILS_MESSAGE, responseId, buildResponsesFailedNoDetailsObservation(event, model, response));
+}
+function logResponsesFailedNoDetails(observation) {
+	log.warn(`[responses] response.failed missing error details provider=${observation.provider} api=${observation.api} model=${observation.transportModel} ` + summarizeResponsesFailedNoDetailsObservation(observation), observation);
+}
+function summarizeResponsesPayload(params) {
+	if (!params || typeof params !== "object") return "payload=non-object";
+	const record = params;
+	const input = record.input;
+	const reasoning = record.reasoning && typeof record.reasoning === "object" ? record.reasoning : void 0;
+	const text = record.text && typeof record.text === "object" ? record.text : void 0;
+	const parts = [
+		`fields=${Object.keys(record).toSorted().join(",")}`,
+		`model=${safeDebugValue(record.model)}`,
+		`stream=${safeDebugValue(record.stream)}`,
+		`inputItems=${Array.isArray(input) ? input.length : typeof input}`,
+		`inputRoles=${responseInputRoles(input) || "none"}`,
+		`inputTextChars=${responseInputTextChars(input)}`,
+		`tools=${summarizeResponsesTools(record.tools)}`,
+		`reasoningEffort=${safeDebugValue(reasoning?.effort)}`,
+		`reasoningSummary=${safeDebugValue(reasoning?.summary)}`,
+		`textVerbosity=${safeDebugValue(text?.verbosity)}`,
+		`serviceTier=${safeDebugValue(record.service_tier)}`,
+		`store=${safeDebugValue(record.store)}`,
+		`promptCacheKey=${record.prompt_cache_key === void 0 ? "absent" : "present"}`,
+		`metadataKeys=${record.metadata && typeof record.metadata === "object" ? Object.keys(record.metadata).toSorted().join(",") : "none"}`
+	];
+	if (resolveModelPayloadDebugMode() === "full-redacted") parts.push(`payload=${stringifyRedactedPayload(record)}`);
+	return parts.join(" ");
+}
+function summarizeOpenAITransportError(error) {
+	if (!error || typeof error !== "object") return `type=${typeof error} message=${safeDebugValue(error)}`;
+	const record = error;
+	const cause = record.cause && typeof record.cause === "object" ? record.cause : void 0;
+	return [
+		`name=${safeDebugValue(record.name)}`,
+		`status=${safeDebugValue(record.status)}`,
+		`code=${safeDebugValue(record.code)}`,
+		`type=${safeDebugValue(record.type)}`,
+		`causeName=${safeDebugValue(cause?.name)}`,
+		`causeCode=${safeDebugValue(cause?.code)}`,
+		`message=${error instanceof Error ? error.message : safeDebugValue(error)}`
+	].join(" ");
 }
-function readCachedStrictOpenAISchema(schema, key) {
-	return strictOpenAISchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
+//#endregion
+//#region packages/ai/src/transports/openai-responses-replay.ts
+/** Resolves the assistant message id that can be replayed to OpenAI Responses. */
+function resolveReplayableResponsesMessageId$1(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-internal.ts
+function isInvalidEncryptedContentError(error) {
+	if (!error || typeof error !== "object") return false;
+	const record = error;
+	if (record.code === "invalid_encrypted_content" || record.code === "thinking_signature_invalid") return true;
+	const message = typeof record.message === "string" ? record.message : "";
+	return message.includes("invalid_encrypted_content") || message.includes("thinking_signature_invalid") || record.status === 400 && message.toLowerCase().includes("could not decrypt the provided encrypted_content");
+}
+function stripEncryptedContentFields(value) {
+	if (!value || typeof value !== "object") return {
+		value,
+		changed: false
+	};
+	if (Array.isArray(value)) {
+		let changed = false;
+		const next = value.map((item) => {
+			const stripped = stripEncryptedContentFields(item);
+			changed ||= stripped.changed;
+			return stripped.value;
+		});
+		return changed ? {
+			value: next,
+			changed: true
+		} : {
+			value,
+			changed: false
+		};
+	}
+	let changed = false;
+	const next = {};
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "encrypted_content") {
+			changed = true;
+			continue;
+		}
+		const stripped = stripEncryptedContentFields(child);
+		changed ||= stripped.changed;
+		next[key] = stripped.value;
+	}
+	return changed ? {
+		value: next,
+		changed: true
+	} : {
+		value,
+		changed: false
+	};
+}
+function stripResponsesRequestEncryptedContent(params) {
+	const stripped = stripEncryptedContentFields(params.input);
+	if (!stripped.changed) return params;
+	return {
+		...params,
+		input: stripped.value
+	};
+}
+function hashOptionalReplayContextValue(value) {
+	const normalized = value?.trim();
+	return normalized ? shortHash(normalized) : void 0;
+}
+function buildOpenAIResponsesReplayContext(model, options) {
+	return {
+		provider: model.provider,
+		api: model.api,
+		model: model.id,
+		baseUrlHash: hashOptionalReplayContextValue(model.baseUrl),
+		sessionHash: hashOptionalReplayContextValue(options?.sessionId),
+		authProfileHash: hashOptionalReplayContextValue(options?.authProfileId)
+	};
+}
+function buildOpenAIResponsesReasoningReplayMetadata(model, options) {
+	return {
+		v: 1,
+		source: "openai-responses",
+		...buildOpenAIResponsesReplayContext(model, options)
+	};
+}
+function tagOpenAIResponsesReasoningReplayItem(item, model, options) {
+	if (!("encrypted_content" in item)) return item;
+	return {
+		...item,
+		[OPENAI_RESPONSES_REASONING_REPLAY_META_KEY]: buildOpenAIResponsesReasoningReplayMetadata(model, options)
+	};
+}
+function isOpenAIResponsesReasoningReplayMetadata(value) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return record.v === 1 && record.source === "openai-responses" && typeof record.provider === "string" && typeof record.api === "string" && typeof record.model === "string" && (record.baseUrlHash === void 0 || typeof record.baseUrlHash === "string") && (record.sessionHash === void 0 || typeof record.sessionHash === "string") && (record.authProfileHash === void 0 || typeof record.authProfileHash === "string");
+}
+function encryptedReasoningReplayMetadataMatches(metadata, context) {
+	if (!metadata) return false;
+	return metadata.provider === context.provider && metadata.api === context.api && metadata.model === context.model && metadata.baseUrlHash === context.baseUrlHash && metadata.sessionHash === context.sessionHash && metadata.authProfileHash === context.authProfileHash;
+}
+function readOpenAIResponsesReasoningReplayBlockMetadata(block) {
+	const value = block[OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY];
+	return isOpenAIResponsesReasoningReplayMetadata(value) ? value : void 0;
+}
+function normalizeOpenAIResponsesReasoningReplayItem(item) {
+	const record = item;
+	if (record.type !== "reasoning" || Array.isArray(record.summary)) return item;
+	return {
+		...record,
+		summary: []
+	};
+}
+function prepareOpenAIResponsesReasoningItemForReplay(item, context, blockMetadata) {
+	const { [OPENAI_RESPONSES_REASONING_REPLAY_META_KEY]: rawMetadata, ...rest } = item;
+	if (!("encrypted_content" in rest)) return normalizeOpenAIResponsesReasoningReplayItem(rest);
+	if (encryptedReasoningReplayMetadataMatches(blockMetadata ?? (isOpenAIResponsesReasoningReplayMetadata(rawMetadata) ? rawMetadata : void 0), context)) return normalizeOpenAIResponsesReasoningReplayItem(rest);
+	return normalizeOpenAIResponsesReasoningReplayItem(stripEncryptedContentFields(rest).value);
+}
+async function createResponsesStreamWithEncryptedContentRetry(params) {
+	try {
+		return await params.client.responses.create(params.request, params.requestOptions);
+	} catch (error) {
+		const retryRequest = stripResponsesRequestEncryptedContent(params.request);
+		if (!isInvalidEncryptedContentError(error) || retryRequest === params.request) throw error;
+		log.warn(`[responses] retrying without encrypted reasoning content provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
+		return await params.client.responses.create(retryRequest, params.requestOptions);
+	}
+}
+function resolveAzureOpenAIApiVersion(env = process.env) {
+	return env.AZURE_OPENAI_API_VERSION?.trim() || "preview";
+}
+function normalizeResponsesReplayItemId(id, prefix) {
+	if (!id) return;
+	if (id.length <= 64) return id;
+	return `${prefix}_${shortHash(id)}`;
+}
+function isSafeResponsesReplayItemId(id) {
+	return typeof id === "string" && id.length > 0 && id.length <= 64;
+}
+function encodeTextSignatureV1(id, phase) {
+	return JSON.stringify({
+		v: 1,
+		id,
+		...phase ? { phase } : {}
+	});
+}
+function parseTextSignature$1(signature) {
+	if (!signature) return;
+	if (signature.startsWith("{")) try {
+		const parsed = JSON.parse(signature);
+		if (parsed.v === 1) {
+			const id = typeof parsed.id === "string" ? parsed.id : void 0;
+			const phase = parsed.phase === "commentary" || parsed.phase === "final_answer" ? parsed.phase : void 0;
+			if (id !== void 0 || phase !== void 0) return {
+				id,
+				phase
+			};
+			return;
+		}
+	} catch {}
+	return { id: signature };
+}
+function buildResponsesInputMessage(role, content) {
+	return {
+		type: "message",
+		role,
+		content
+	};
+}
+function convertResponsesMessages$1(model, context, allowedToolCallProviders, options) {
+	const messages = [];
+	const shouldReplayReasoningItems = options?.replayReasoningItems ?? true;
+	const shouldReplayResponsesItemIds = options?.replayResponsesItemIds ?? true;
+	const replayContext = buildOpenAIResponsesReplayContext(model, {
+		sessionId: options?.sessionId,
+		authProfileId: options?.authProfileId
+	});
+	const shouldNormalizeSameModelToolCallIds = model.provider === "github-copilot";
+	const sanitizeIdPart = (part) => part.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+$/, "");
+	const normalizeIdPart = (part) => {
+		const sanitized = sanitizeIdPart(part);
+		return (sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized).replace(/_+$/, "");
+	};
+	const buildForeignResponsesItemId = (itemId) => {
+		const normalized = `fc_${shortHash(itemId)}`;
+		return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
+	};
+	const buildSameProviderCopilotResponsesItemId = (itemId) => {
+		const sanitized = sanitizeIdPart(itemId);
+		const candidate = sanitized.startsWith("fc_") ? sanitized : `fc_${sanitized}`;
+		return candidate.length > 64 ? buildForeignResponsesItemId(itemId) : candidate;
+	};
+	const normalizeToolCallId = (id, _targetModel, source) => {
+		if (!allowedToolCallProviders.has(model.provider)) return normalizeIdPart(id);
+		if (!id.includes("|")) return normalizeIdPart(id);
+		const separatorIndex = id.indexOf("|");
+		const callId = id.slice(0, separatorIndex);
+		const itemId = id.slice(separatorIndex + 1);
+		const normalizedCallId = normalizeIdPart(callId);
+		let normalizedItemId = source.provider !== model.provider || source.api !== model.api ? buildForeignResponsesItemId(itemId) : model.provider === "github-copilot" ? buildSameProviderCopilotResponsesItemId(itemId) : normalizeIdPart(itemId);
+		if (!normalizedItemId.startsWith("fc_")) normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
+		return `${normalizedCallId}|${normalizedItemId}`;
+	};
+	const transformedMessages = transformTransportMessages(context.messages, model, normalizeToolCallId, { normalizeSameModelToolCallIds: shouldNormalizeSameModelToolCallIds });
+	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) messages.push(buildResponsesInputMessage(model.reasoning && options?.supportsDeveloperRole !== false ? "developer" : "system", [{
+		type: "input_text",
+		text: sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt))
+	}]));
+	let msgIndex = 0;
+	for (const msg of transformedMessages) {
+		if (msg.role === "user") if (typeof msg.content === "string") messages.push(buildResponsesInputMessage("user", [{
+			type: "input_text",
+			text: sanitizeTransportPayloadText(msg.content)
+		}]));
+		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) => model.input.includes("image") || item.type !== "input_image");
+			if (content.length > 0) messages.push(buildResponsesInputMessage("user", content));
+		}
+		else if (msg.role === "assistant") {
+			const output = [];
+			let textFallbackOrdinal = 0;
+			let previousReplayItemWasReasoning = false;
+			const isDifferentModel = msg.model !== model.id && msg.provider === model.provider && msg.api === model.api;
+			for (const block of msg.content) if (block.type === "thinking") {
+				if (shouldReplayReasoningItems && block.thinkingSignature && block.thinkingSignature.startsWith("{")) {
+					const replayableReasoningItem = prepareOpenAIResponsesReasoningItemForReplay(JSON.parse(block.thinkingSignature), replayContext, readOpenAIResponsesReasoningReplayBlockMetadata(block));
+					if (!shouldReplayResponsesItemIds) delete replayableReasoningItem.id;
+					if (shouldReplayResponsesItemIds && model.provider === "github-copilot" && !isSafeResponsesReplayItemId(replayableReasoningItem.id)) continue;
+					output.push(replayableReasoningItem);
+					previousReplayItemWasReasoning = true;
+				}
+			} else if (block.type === "text") {
+				const textSignature = parseTextSignature$1(block.textSignature);
+				let msgId = resolveReplayableResponsesMessageId$1({
+					replayResponsesItemIds: shouldReplayResponsesItemIds,
+					textSignatureId: textSignature?.id,
+					fallbackId: `msg_${msgIndex}`,
+					fallbackOrdinal: textFallbackOrdinal,
+					previousReplayItemWasReasoning
+				});
+				if (!textSignature?.id) textFallbackOrdinal += 1;
+				msgId = normalizeResponsesReplayItemId(msgId, "msg");
+				const messageItem = {
+					type: "message",
+					role: "assistant",
+					content: [{
+						type: "output_text",
+						text: sanitizeTransportPayloadText(block.text),
+						annotations: []
+					}],
+					status: "completed",
+					...msgId ? { id: msgId } : {},
+					phase: textSignature?.phase
+				};
+				output.push(messageItem);
+				previousReplayItemWasReasoning = false;
+			} else if (block.type === "toolCall") {
+				const separatorIndex = block.id.indexOf("|");
+				const callId = separatorIndex === -1 ? block.id : block.id.slice(0, separatorIndex);
+				const itemIdRaw = separatorIndex === -1 ? void 0 : block.id.slice(separatorIndex + 1);
+				const itemId = shouldReplayResponsesItemIds && !(isDifferentModel && itemIdRaw?.startsWith("fc_")) ? itemIdRaw : void 0;
+				output.push({
+					type: "function_call",
+					...itemId ? { id: itemId } : {},
+					call_id: callId,
+					name: block.name,
+					arguments: typeof block.arguments === "string" ? block.arguments : JSON.stringify(block.arguments ?? {})
+				});
+				previousReplayItemWasReasoning = false;
+			}
+			if (output.length > 0) messages.push(...output);
+		} else if (msg.role === "toolResult") {
+			const textResult = extractToolResultText(msg.content);
+			const sanitizedTextResult = sanitizeTransportPayloadText(textResult);
+			const hasText = sanitizedTextResult.trim().length > 0;
+			const mediaPlaceholder = describeToolResultMediaPlaceholder(msg.content);
+			const hasImages = msg.content.some(isImageWithMediaPayload);
+			const separatorIndex = msg.toolCallId.indexOf("|");
+			const callId = separatorIndex === -1 ? msg.toolCallId : msg.toolCallId.slice(0, separatorIndex);
+			messages.push({
+				type: "function_call_output",
+				call_id: callId,
+				output: hasImages && model.input.includes("image") ? [...hasText ? [{
+					type: "input_text",
+					text: sanitizedTextResult
+				}] : mediaPlaceholder === "(see attached media)" ? [{
+					type: "input_text",
+					text: mediaPlaceholder
+				}] : [], ...msg.content.filter(isImageWithMediaPayload).map((item) => ({
+					type: "input_image",
+					detail: "auto",
+					image_url: `data:${item.mimeType};base64,${item.data}`
+				}))] : sanitizeNonEmptyTransportPayloadText(textResult, mediaPlaceholder ?? "(no output)")
+			});
+		}
+		msgIndex += 1;
+	}
+	return messages;
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-stream-observer-internal.ts
+const STRING_DELTA_EVENTS = /* @__PURE__ */ new Set([
+	"response.function_call_arguments.delta",
+	"response.output_text.delta",
+	"response.reasoning_summary_text.delta",
+	"response.reasoning_text.delta",
+	"response.refusal.delta",
+	"response.text.delta"
+]);
+async function* adaptResponsesStream(stream, signal) {
+	const scheduler = createModelStreamCooperativeScheduler(signal);
+	for await (const event of stream) {
+		if (signal?.aborted) throw transportAbortError(signal);
+		if (!isRecord(event) || typeof event.type !== "string") throw new Error("Responses stream delivered a malformed event without a string type");
+		if (STRING_DELTA_EVENTS.has(event.type) && typeof event.delta !== "string") throw new Error(`Responses stream delivered malformed ${event.type} delta`);
+		if ((event.type === "response.output_item.added" || event.type === "response.output_item.done") && !isRecord(event.item)) throw new Error(`Responses stream delivered malformed ${event.type} item`);
+		if ((event.type === "response.created" || event.type === "response.completed" || event.type === "response.incomplete" || event.type === "response.failed") && !isRecord(event.response)) throw new Error(`Responses stream delivered malformed ${event.type} response`);
+		yield event;
+		await scheduler.afterEvent();
+	}
+}
+async function* observeResponsesStream(stream, model) {
+	const startedAt = Date.now();
+	const eventTypes = /* @__PURE__ */ new Map();
+	const debugMode = resolveModelSseDebugMode();
+	let eventCount = 0;
+	try {
+		for await (const event of stream) {
+			const type = isRecord(event) && typeof event.type === "string" ? event.type : "unknown";
+			eventCount += 1;
+			eventTypes.set(type, (eventTypes.get(type) ?? 0) + 1);
+			if (eventCount === 1) emitModelTransportDebug(log, `[responses] first_event provider=${model.provider} api=${model.api} model=${model.id} elapsedMs=${Date.now() - startedAt} type=${type}`);
+			if (debugMode === "peek" && eventCount <= 5) emitModelTransportDebug(log, `[responses] event_peek provider=${model.provider} api=${model.api} model=${model.id} index=${eventCount} type=${type} event=${stringifyRedactedEvent(event)}`);
+			yield event;
+		}
+	} finally {
+		const types = [...eventTypes].map(([type, count]) => `${type}:${count}`).join(",");
+		emitModelTransportDebug(log, `[responses] stream_done provider=${model.provider} api=${model.api} model=${model.id} elapsedMs=${Date.now() - startedAt} events=${eventCount} types=${types}`);
+	}
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-stream-slots-internal.ts
+function readResponsesOutputIndex(event) {
+	const outputIndex = event.output_index;
+	return typeof outputIndex === "number" && Number.isInteger(outputIndex) && outputIndex >= 0 ? outputIndex : void 0;
+}
+function createResponsesOutputSlotTracker() {
+	const indexed = /* @__PURE__ */ new Map();
+	let unindexed;
+	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);
+		},
+		resolve(event, type) {
+			const outputIndex = readResponsesOutputIndex(event);
+			let slot = outputIndex === void 0 ? unindexed : indexed.get(outputIndex);
+			if (outputIndex === void 0 && !slot) {
+				const matches = [...indexed.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);
+		},
+		values() {
+			return [.../* @__PURE__ */ new Set([...indexed.values(), ...unindexed ? [unindexed] : []])];
+		},
+		forget(slot) {
+			if (unindexed === slot) unindexed = void 0;
+			for (const [outputIndex, candidate] of indexed) if (candidate === slot) indexed.delete(outputIndex);
+		}
+	};
+}
+//#endregion
+//#region packages/ai/src/providers/openai-responses-terminal-usage.ts
+function readCount(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+/**
+* Split a terminal usage payload into the priced buckets.
+*
+* OpenAI includes cache reads and writes in `input_tokens`, so both are subtracted out of the
+* billable input bucket. `total_tokens` comes from the payload, but never below the sum of the
+* split buckets: proxies routinely omit it (reporting 0 would understate the turn), and a payload
+* whose `cached_tokens` exceeds `input_tokens` clamps the input bucket, leaving the reported total
+* short of what the buckets actually price.
+*/
+function mapResponsesTerminalUsage(usage) {
+	if (!usage) return;
+	const cacheRead = readCount(usage.input_tokens_details?.cached_tokens);
+	const cacheWrite = readCount(usage.input_tokens_details?.cache_write_tokens);
+	const input = Math.max(0, readCount(usage.input_tokens) - cacheRead - cacheWrite);
+	const output = readCount(usage.output_tokens);
+	const bucketTotal = input + output + cacheRead + cacheWrite;
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: Math.max(bucketTotal, readCount(usage.total_tokens))
+	};
+}
+/** Reasoning tokens are reported by the agent path only; the package path does not track them. */
+function readResponsesReasoningTokens(usage) {
+	const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens;
+	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? reasoningTokens : void 0;
+}
+function mapResponsesTerminalStopReason(status) {
+	if (!status) return "stop";
+	switch (status) {
+		case "completed": return "stop";
+		case "incomplete": return "length";
+		case "failed":
+		case "cancelled": return "error";
+		case "in_progress":
+		case "queued": return "stop";
+		default: throw new Error(`Unhandled stop reason: ${String(status)}`);
+	}
+}
+/**
+* Resolve the terminal stop reason, including the two overrides every Responses path shares: a
+* content-filtered turn is a provider error rather than a truncated answer, and a turn that
+* produced tool calls reports `toolUse` instead of a plain stop.
+*/
+function resolveResponsesTerminalStopReason(params) {
+	if (params.status === "incomplete" && params.incompleteReason === "content_filter") return {
+		stopReason: "error",
+		errorMessage: "Provider incomplete_reason: content_filter"
+	};
+	const stopReason = mapResponsesTerminalStopReason(params.status);
+	if (stopReason === "stop" && params.hasToolCall) return { stopReason: "toolUse" };
+	return { stopReason };
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-stream-terminal-internal.ts
+function splitToolCallId(id) {
+	const separator = id.indexOf("|");
+	return separator === -1 ? [id, void 0] : [id.slice(0, separator), id.slice(separator + 1)];
+}
+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 resolvedItemId = itemId || fallbackItemId;
+	if (resolvedCallId) return resolvedItemId ? `${resolvedCallId}|${resolvedItemId}` : resolvedCallId;
+	const generated = `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`;
+	return resolvedItemId ? `${generated}|${resolvedItemId}` : generated;
+}
+function resolveCompletedToolCallName(toolCall, value) {
+	const streamedName = toolCall?.block.name.trim() || void 0;
+	const completedName = typeof value === "string" ? value.trim() || void 0 : void 0;
+	if (streamedName && completedName && streamedName !== completedName) throw new Error(`Responses stream changed tool-call function name from ${streamedName} to ${completedName}`);
+	const name = completedName ?? streamedName;
+	if (!name) throw new Error("Responses stream completed tool call without a function name");
+	return name;
+}
+function createResponsesTerminalController(params) {
+	const { output, stream, model, options } = params;
+	const blocks = output.content;
+	const backfillReasoning = (items) => {
+		for (const item of items) {
+			if (item.type !== "reasoning" || !item.encrypted_content) continue;
+			const block = params.reasoningBlocksById.get(item.id);
+			if (!block?.thinkingSignature) continue;
+			const stored = JSON.parse(block.thinkingSignature);
+			if (!stored.encrypted_content) block.thinkingSignature = JSON.stringify({
+				...stored,
+				encrypted_content: item.encrypted_content
+			});
+			if (options?.reasoningReplayMetadata) block[OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY] = options.reasoningReplayMetadata;
+		}
+	};
+	const appendText = (item) => {
+		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 ?? "";
+		}).join("");
+		if (!text) return;
+		const phase = item.phase ?? void 0;
+		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
+			});
+			return;
+		}
+		const block = {
+			type: "text",
+			text,
+			textSignature: encodeTextSignatureV1(item.id, phase)
+		};
+		blocks.push(block);
+		const index = blocks.length - 1;
+		params.setLastTextBlock({
+			block,
+			index,
+			phase
+		});
+		stream.push({
+			type: "text_start",
+			contentIndex: index,
+			partial: output
+		});
+		stream.push({
+			type: "text_end",
+			contentIndex: index,
+			content: text,
+			partial: output
+		});
+	};
+	const appendToolCall = (item) => {
+		const toolCall = {
+			type: "toolCall",
+			id: resolveResponsesToolCallId(item),
+			name: resolveCompletedToolCallName(void 0, item.name),
+			arguments: parseStreamingJson(item.arguments || "{}")
+		};
+		blocks.push(toolCall);
+		const contentIndex = blocks.length - 1;
+		stream.push({
+			type: "toolcall_start",
+			contentIndex,
+			partial: output
+		});
+		stream.push({
+			type: "toolcall_end",
+			contentIndex,
+			toolCall,
+			partial: output
+		});
+	};
+	const recoverTerminalOutput = (items, includeToolCalls) => {
+		if (blocks.length > 0) return;
+		for (const item of items) if (item.type === "message") appendText(item);
+		else {
+			params.setLastTextBlock(null);
+			if (includeToolCalls && item.type === "function_call") appendToolCall(item);
+		}
+	};
+	const finalizeResponse = (response) => {
+		params.markFinalized();
+		backfillReasoning(response.output ?? []);
+		output.responseId = response.id || output.responseId;
+		const usage = mapResponsesTerminalUsage(response.usage);
+		const reasoningTokens = readResponsesReasoningTokens(response.usage);
+		if (usage) output.usage = {
+			...usage,
+			...reasoningTokens === void 0 ? {} : { reasoningTokens },
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		};
+		calculateCost(model, output.usage);
+		if (options?.applyServiceTierPricing) {
+			const tier = options.resolveServiceTier ? options.resolveServiceTier(response.service_tier, options.serviceTier) : response.service_tier ?? options.serviceTier;
+			options.applyServiceTierPricing(output.usage, tier);
+		}
+		const terminal = resolveResponsesTerminalStopReason({
+			status: response.status,
+			incompleteReason: response.incomplete_details?.reason,
+			hasToolCall: blocks.some((block) => block.type === "toolCall")
+		});
+		output.stopReason = terminal.stopReason;
+		output.errorMessage = terminal.errorMessage;
+	};
+	return {
+		finalizeResponse,
+		recoverTerminalOutput
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-stream-internal.ts
+var ResponsesStreamFailure = class extends Error {
+	constructor(failure, response) {
+		super(failure.message);
+		this.name = "ResponsesStreamFailure";
+		this.responseId = failure.responseId;
+		this.response = response;
+		this.observation = failure.observation;
+	}
+};
+async function processResponsesStream(openaiStream, output, stream, model, options) {
+	const streamingToolCalls = createResponsesToolCallTracker();
+	const outputSlots = createResponsesOutputSlotTracker();
+	const reasoningBlocksById = /* @__PURE__ */ new Map();
+	let terminalResponseEvent;
+	let lastTextBlock = null;
+	const blocks = output.content;
+	const blockIndex = () => blocks.length - 1;
+	const createOutputSlot = (event, item) => {
+		if (item.type === "reasoning") {
+			const block = {
+				type: "thinking",
+				thinking: ""
+			};
+			const slot = {
+				type: "thinking",
+				item,
+				block,
+				contentIndex: blocks.length
+			};
+			blocks.push(block);
+			outputSlots.register(event, slot);
+			stream.push({
+				type: "thinking_start",
+				contentIndex: slot.contentIndex,
+				partial: output
+			});
+			return slot;
+		}
+		if (item.type === "message") {
+			const messageItem = item;
+			const collapseCandidate = lastTextBlock;
+			const block = collapseCandidate ? null : {
+				type: "text",
+				text: "",
+				...messageItem.phase ? { textSignature: encodeTextSignatureV1(messageItem.id, messageItem.phase) } : {}
+			};
+			const slot = {
+				type: "text",
+				item: messageItem,
+				block,
+				contentIndex: block ? blocks.length : void 0,
+				pendingText: collapseCandidate ? "" : null,
+				collapseCandidate
+			};
+			if (block) blocks.push(block);
+			outputSlots.register(event, slot);
+			if (slot.contentIndex !== void 0) stream.push({
+				type: "text_start",
+				contentIndex: slot.contentIndex,
+				partial: output
+			});
+			return slot;
+		}
+	};
+	const resolveOutputItemSlot = (event, item) => {
+		if (item.type === "reasoning") return outputSlots.resolve(event, "thinking");
+		if (item.type === "message") return outputSlots.resolve(event, "text");
+		return readResponsesOutputIndex(event) === void 0 ? void 0 : outputSlots.get(event);
+	};
+	const getOrCreateOutputSlot = (event, item) => {
+		return resolveOutputItemSlot(event, item) ?? createOutputSlot(event, item);
+	};
+	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) } : {}
+		};
+		blocks.push(slot.block);
+		slot.contentIndex = blockIndex();
+		stream.push({
+			type: "text_start",
+			contentIndex: slot.contentIndex,
+			partial: output
+		});
+		if (text) stream.push({
+			type: "text_delta",
+			contentIndex: slot.contentIndex,
+			delta: text
+		});
+		if (lastTextBlock === slot.collapseCandidate) lastTextBlock = null;
+		slot.pendingText = null;
+		slot.collapseCandidate = null;
+	};
+	const materializeDeferredTextSlots = (except) => {
+		for (const slot of outputSlots.values()) if (slot !== except && slot.type === "text") materializeDeferredTextSlot(slot);
+	};
+	const appendPendingMessageDelta = (slot, delta) => {
+		slot.pendingText = `${slot.pendingText ?? ""}${delta}`;
+		const priorText = slot.collapseCandidate?.block.text ?? "";
+		if (priorText.startsWith(slot.pendingText) || slot.pendingText.startsWith(priorText)) return;
+		materializeDeferredTextSlot(slot);
+	};
+	const { finalizeResponse, recoverTerminalOutput } = createResponsesTerminalController({
+		output,
+		stream,
+		model,
+		options,
+		reasoningBlocksById,
+		getLastTextBlock: () => lastTextBlock,
+		setLastTextBlock: (block) => {
+			lastTextBlock = block;
+		},
+		markFinalized: () => {
+			terminalResponseEvent = "finalized";
+		}
+	});
+	const guardedStream = adaptResponsesStream(withFirstStreamEventTimeout(openaiStream, {
+		provider: model.provider,
+		api: model.api,
+		model: model.id,
+		timeoutMs: options?.firstEventTimeoutMs ?? 0,
+		stage: "responses",
+		abort: options?.abortFirstEventStream,
+		onTimeout: options?.onFirstEventTimeout,
+		hint: "The provider may be stalled while parsing the tool payload; retry with a smaller tool surface or enable OPENCLAW_DEBUG_MODEL_PAYLOAD=tools to inspect exposed tools."
+	}), options?.signal);
+	try {
+		for await (const event of guardedStream) if (event.type === "response.created") output.responseId = event.response.id;
+		else if (event.type === "response.output_item.added") {
+			materializeDeferredTextSlots();
+			const item = event.item;
+			if (item.type !== "message") lastTextBlock = null;
+			if (item.type === "reasoning" || item.type === "message") createOutputSlot(event, item);
+			else if (item.type === "function_call") {
+				const toolCallBlock = {
+					type: "toolCall",
+					id: resolveResponsesToolCallId(item),
+					name: typeof item.name === "string" ? item.name.trim() : "",
+					arguments: {},
+					partialJson: item.arguments || ""
+				};
+				const contentIndex = output.content.length;
+				const toolCallState = {
+					block: toolCallBlock,
+					contentIndex,
+					argumentStreamReliable: true,
+					...readResponsesToolCallItemIdentity(item)
+				};
+				streamingToolCalls.register(event, toolCallState);
+				if (readResponsesOutputIndex(event) !== void 0) outputSlots.register(event, {
+					type: "toolCall",
+					toolCall: toolCallState
+				});
+				output.content.push(toolCallBlock);
+				stream.push({
+					type: "toolcall_start",
+					contentIndex,
+					partial: output
+				});
+			}
+		} else if (event.type === "response.reasoning_summary_part.added") {
+			const slot = outputSlots.resolve(event, "thinking");
+			if (!slot) continue;
+			slot.item.summary = slot.item.summary || [];
+			slot.item.summary.push(event.part);
+		} else if (event.type === "response.reasoning_summary_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;
+			slot.block.thinking += event.delta;
+			lastPart.text += event.delta;
+			stream.push({
+				type: "thinking_delta",
+				contentIndex: slot.contentIndex,
+				delta: event.delta,
+				partial: output
+			});
+		} else if (event.type === "response.reasoning_summary_part.done") {
+			const slot = outputSlots.resolve(event, "thinking");
+			if (!slot) continue;
+			slot.item.summary = slot.item.summary || [];
+			const lastPart = slot.item.summary[slot.item.summary.length - 1];
+			if (!lastPart) continue;
+			slot.block.thinking += "\n\n";
+			lastPart.text += "\n\n";
+			stream.push({
+				type: "thinking_delta",
+				contentIndex: slot.contentIndex,
+				delta: "\n\n",
+				partial: output
+			});
+		} else if (event.type === "response.reasoning_text.delta") {
+			const slot = outputSlots.resolve(event, "thinking");
+			if (!slot) continue;
+			slot.block.thinking += event.delta;
+			stream.push({
+				type: "thinking_delta",
+				contentIndex: slot.contentIndex,
+				delta: event.delta,
+				partial: output
+			});
+		} else if (event.type === "response.content_part.added") {
+			const slot = outputSlots.resolve(event, "text");
+			if (!slot) continue;
+			slot.item.content = slot.item.content || [];
+			if (event.part.type === "output_text" || event.part.type === "text" || event.part.type === "refusal") slot.item.content.push(event.part);
+		} else if (event.type === "response.output_text.delta") {
+			const slot = outputSlots.resolve(event, "text");
+			if (!slot) continue;
+			slot.item.content ||= [];
+			let lastPart = slot.item.content[slot.item.content.length - 1];
+			if (!isResponsesTextContentPartType(lastPart?.type)) {
+				lastPart = {
+					type: "output_text",
+					text: "",
+					annotations: []
+				};
+				slot.item.content.push(lastPart);
+			}
+			lastPart.text += event.delta;
+			if (slot.pendingText !== null) appendPendingMessageDelta(slot, event.delta);
+			else if (slot.block && slot.contentIndex !== void 0) {
+				slot.block.text += event.delta;
+				stream.push({
+					type: "text_delta",
+					contentIndex: slot.contentIndex,
+					delta: event.delta
+				});
+			}
+		} else if (isAzureResponsesTextDeltaEvent(event)) {
+			const slot = outputSlots.resolve(event, "text");
+			if (!slot) continue;
+			slot.item.content = slot.item.content || [];
+			let lastPart = slot.item.content[slot.item.content.length - 1];
+			if (lastPart?.type !== "text") {
+				lastPart = {
+					type: "text",
+					text: ""
+				};
+				slot.item.content.push(lastPart);
+			}
+			lastPart.text += event.delta;
+			if (slot.pendingText !== null) appendPendingMessageDelta(slot, event.delta);
+			else if (slot.block && slot.contentIndex !== void 0) {
+				slot.block.text += event.delta;
+				stream.push({
+					type: "text_delta",
+					contentIndex: slot.contentIndex,
+					delta: event.delta
+				});
+			}
+		} else if (event.type === "response.refusal.delta") {
+			const slot = outputSlots.resolve(event, "text");
+			if (!slot) continue;
+			slot.item.content ||= [];
+			let lastPart = slot.item.content[slot.item.content.length - 1];
+			if (lastPart?.type !== "refusal") {
+				lastPart = {
+					type: "refusal",
+					refusal: ""
+				};
+				slot.item.content.push(lastPart);
+			}
+			lastPart.refusal += event.delta;
+			if (slot.pendingText !== null) appendPendingMessageDelta(slot, event.delta);
+			else if (slot.block && slot.contentIndex !== void 0) {
+				slot.block.text += event.delta;
+				stream.push({
+					type: "text_delta",
+					contentIndex: slot.contentIndex,
+					delta: event.delta
+				});
+			}
+		} else if (event.type === "response.function_call_arguments.delta") {
+			const toolCall = streamingToolCalls.resolve(event);
+			if (toolCall) {
+				toolCall.block.partialJson += event.delta;
+				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) {
+				const previousPartialJson = toolCall.block.partialJson;
+				const doneArguments = typeof event.arguments === "string" ? event.arguments : void 0;
+				if (doneArguments !== void 0 && (doneArguments.length > 0 || previousPartialJson === "")) {
+					toolCall.block.partialJson = doneArguments;
+					toolCall.block.arguments = parseStreamingJson(toolCall.block.partialJson);
+					toolCall.argumentStreamReliable = 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();
+		} else if (event.type === "response.output_item.done") {
+			const item = event.item;
+			if (item.type !== "message") lastTextBlock = null;
+			const existingOutputSlot = resolveOutputItemSlot(event, item);
+			materializeDeferredTextSlots(existingOutputSlot);
+			const outputSlot = existingOutputSlot ?? getOrCreateOutputSlot(event, item);
+			if (item.type === "reasoning" && outputSlot?.type === "thinking") {
+				const summaryText = item.summary?.map((s) => s.text).join("\n\n") || "";
+				const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
+				outputSlot.block.thinking = summaryText || contentText || outputSlot.block.thinking;
+				outputSlot.block.thinkingSignature = JSON.stringify(item);
+				if (item.encrypted_content && options?.reasoningReplayMetadata) outputSlot.block[OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY] = options.reasoningReplayMetadata;
+				if (typeof item.id === "string") reasoningBlocksById.set(item.id, outputSlot.block);
+				stream.push({
+					type: "thinking_end",
+					contentIndex: outputSlot.contentIndex,
+					content: outputSlot.block.thinking,
+					partial: output
+				});
+				outputSlots.forget(outputSlot);
+			} else if (item.type === "message" && outputSlot?.type === "text" && (outputSlot.block || outputSlot.pendingText !== null)) {
+				const streamedText = outputSlot.pendingText ?? outputSlot.block?.text ?? "";
+				const finalText = item.content == null ? streamedText : item.content.map((c) => c.type === "output_text" || c.type === "text" ? c.text : c.refusal).join("");
+				const phase = item.phase ?? void 0;
+				const collapse = outputSlot.pendingText !== null ? resolveResponsesMessageSnapshotCollapse({
+					prior: outputSlot.collapseCandidate && {
+						text: outputSlot.collapseCandidate.block.text,
+						phase: outputSlot.collapseCandidate.phase
+					},
+					nextText: finalText,
+					nextPhase: phase
+				}) : { kind: "keep" };
+				outputSlot.pendingText = null;
+				if (collapse.kind === "extend" && outputSlot.collapseCandidate) {
+					outputSlot.collapseCandidate.block.text = collapse.text;
+					outputSlot.collapseCandidate.block.textSignature = encodeTextSignatureV1(item.id, phase);
+					stream.push({
+						type: "text_end",
+						contentIndex: outputSlot.collapseCandidate.index,
+						content: collapse.text,
+						partial: output
+					});
+					lastTextBlock = outputSlot.collapseCandidate;
+				} else {
+					if (!outputSlot.block) {
+						outputSlot.block = {
+							type: "text",
+							text: "",
+							...phase ? { textSignature: encodeTextSignatureV1(item.id, phase) } : {}
+						};
+						blocks.push(outputSlot.block);
+						outputSlot.contentIndex = blockIndex();
+						stream.push({
+							type: "text_start",
+							contentIndex: outputSlot.contentIndex,
+							partial: output
+						});
+					}
+					outputSlot.block.text = finalText;
+					outputSlot.block.textSignature = encodeTextSignatureV1(item.id, phase);
+					const contentIndex = outputSlot.contentIndex;
+					if (contentIndex === void 0) throw new Error("Responses stream finalized text without a content index");
+					lastTextBlock = {
+						block: outputSlot.block,
+						index: contentIndex,
+						phase
+					};
+					stream.push({
+						type: "text_end",
+						contentIndex,
+						content: outputSlot.block.text,
+						partial: output
+					});
+				}
+				outputSlots.forget(outputSlot);
+			} else if (item.type === "function_call") {
+				const streamingToolCall = streamingToolCalls.resolve(event, readResponsesToolCallItemIdentity(item));
+				if (!streamingToolCall && streamingToolCalls.hasActive()) continue;
+				const completedName = resolveCompletedToolCallName(streamingToolCall, item.name);
+				const streamedArguments = streamingToolCall?.block.partialJson ?? "";
+				const completedArguments = typeof item.arguments === "string" ? item.arguments : void 0;
+				if (streamingToolCall && !streamingToolCall.argumentStreamReliable && !completedArguments) continue;
+				const args = parseStreamingJson(completedArguments !== void 0 && (completedArguments.length > 0 || !streamedArguments) ? completedArguments : streamedArguments || "{}");
+				let toolCall;
+				let contentIndex;
+				if (streamingToolCall) {
+					const block = streamingToolCall.block;
+					block.id = resolveResponsesToolCallId(item, block.id);
+					block.name = completedName;
+					block.arguments = args;
+					delete block.partialJson;
+					toolCall = block;
+					contentIndex = streamingToolCall.contentIndex;
+				} else {
+					toolCall = {
+						type: "toolCall",
+						id: resolveResponsesToolCallId(item),
+						name: completedName,
+						arguments: args
+					};
+					blocks.push(toolCall);
+					contentIndex = blockIndex();
+					stream.push({
+						type: "toolcall_start",
+						contentIndex,
+						partial: output
+					});
+				}
+				if (streamingToolCall) {
+					streamingToolCalls.forget(streamingToolCall);
+					for (const slot of outputSlots.values()) if (slot.type === "toolCall" && slot.toolCall === streamingToolCall) outputSlots.forget(slot);
+				}
+				stream.push({
+					type: "toolcall_end",
+					contentIndex,
+					toolCall,
+					partial: output
+				});
+			}
+		} else if (event.type === "response.completed" || event.type === "response.incomplete") {
+			if (streamingToolCalls.hasActive()) throw new Error("Responses stream completed with unresolved tool calls");
+			finalizeResponse(event.response);
+			if (event.type === "response.completed" || output.stopReason === "length") recoverTerminalOutput(event.response.output ?? [], event.type === "response.completed");
+			if (output.stopReason === "stop" && output.content.some((block) => block.type === "toolCall")) output.stopReason = "toolUse";
+			break;
+		} else if (event.type === "error") throw new Error(event.message ? `Error Code ${event.code}: ${event.message}` : "Unknown error");
+		else if (event.type === "response.failed") {
+			const failure = normalizeResponsesFailedEvent(event, model);
+			if (failure.responseId) output.responseId = failure.responseId;
+			throw new ResponsesStreamFailure(failure, event.response);
+		}
+		if (streamingToolCalls.hasActive()) throw new Error("Responses stream ended with unresolved tool calls");
+		if (!terminalResponseEvent) throw new Error("OpenAI Responses stream ended before a terminal response event");
+	} finally {
+		for (const block of output.content) delete block.partialJson;
+	}
+}
+//#endregion
+//#region packages/ai/src/providers/openai-tool-schema-compat.ts
+const OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"dependencies",
+	"patternProperties",
+	"properties"
+]);
+const OPENAI_NULLABLE_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
+	"default",
+	"description",
+	"examples",
+	"format",
+	"title"
+]);
+const OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"oneOf",
+	"prefixItems",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+function normalizeOpenAIStrictCompatSchemaMap(schema) {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
+	let changed = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(schema)) {
+		const next = normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false });
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	return changed ? normalized : schema;
+}
+function normalizeOpenAIStrictCompatSchemaRecursive(schema, options) {
+	if (Array.isArray(schema)) {
+		let changed = false;
+		const normalized = schema.map((entry) => {
+			const next = normalizeOpenAIStrictCompatSchemaRecursive(entry, { promoteEmptyObject: false });
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? normalized : schema;
+	}
+	if (!schema || typeof schema !== "object") return schema;
+	const record = schema;
+	let changed = false;
+	let hadNullType = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(record)) {
+		if (value === null && OPENAI_NULLABLE_ANNOTATION_KEYS.has(key)) {
+			changed = true;
+			continue;
+		}
+		if (value === null && key === "type") {
+			hadNullType = true;
+			changed = true;
+			continue;
+		}
+		const next = OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaMap(value) : OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false }) : value;
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	if (Object.keys(normalized).length === 0) {
+		if (!options.promoteEmptyObject) return schema;
+		return {
+			type: "object",
+			properties: {},
+			required: [],
+			additionalProperties: false
+		};
+	}
+	const hasObjectShapeHints = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) || Array.isArray(normalized.required);
+	const hasArrayShapeHints = "items" in normalized;
+	if (!("type" in normalized) && hasObjectShapeHints !== hasArrayShapeHints) {
+		normalized.type = hasObjectShapeHints ? "object" : "array";
+		changed = true;
+	} else if (hadNullType && !("type" in normalized)) normalized.type = null;
+	if (normalized.type === "object" && !("properties" in normalized)) {
+		normalized.properties = {};
+		changed = true;
+	}
+	const hasEmptyProperties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) && Object.keys(normalized.properties).length === 0;
+	if (normalized.type === "object" && !Array.isArray(normalized.required) && hasEmptyProperties) {
+		normalized.required = [];
+		changed = true;
+	}
+	if (normalized.type === "object" && hasEmptyProperties && !("additionalProperties" in normalized)) {
+		normalized.additionalProperties = false;
+		changed = true;
+	}
+	return changed ? normalized : schema;
+}
+/** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
+function normalizeOpenAIStrictCompatSchema(schema) {
+	return normalizeOpenAIStrictCompatSchemaRecursive(schema, { promoteEmptyObject: true });
+}
+/** Finds schema paths that violate OpenAI strict tool-schema requirements. */
+function findOpenAIStrictSchemaViolations(schema, path, options) {
+	if (Array.isArray(schema)) {
+		if (options?.requireObjectRoot) return [`${path}.type`];
+		return schema.flatMap((item, index) => findOpenAIStrictSchemaViolations(item, `${path}[${index}]`));
+	}
+	if (!schema || typeof schema !== "object") return options?.requireObjectRoot ? [`${path}.type`] : [];
+	const record = schema;
+	const violations = [];
+	for (const key of [
+		"anyOf",
+		"oneOf",
+		"allOf"
+	]) if (key in record) violations.push(`${path}.${key}`);
+	if (Array.isArray(record.type)) violations.push(`${path}.type`);
+	const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : void 0;
+	if (record.type === "object") {
+		if (record.additionalProperties !== false) violations.push(`${path}.additionalProperties`);
+		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
+		if (!required) violations.push(`${path}.required`);
+		else if (properties) {
+			const requiredSet = new Set(required);
+			for (const key of Object.keys(properties)) if (!requiredSet.has(key)) violations.push(`${path}.required.${key}`);
+		}
+	}
+	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS) {
+		const schemaMap = record[key];
+		if (!schemaMap || typeof schemaMap !== "object" || Array.isArray(schemaMap)) continue;
+		for (const [entryKey, value] of Object.entries(schemaMap)) violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}.${entryKey}`));
+	}
+	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS) {
+		const value = record[key];
+		if (value && typeof value === "object") violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}`));
+	}
+	return violations;
+}
+//#endregion
+//#region packages/ai/src/providers/openai-tool-schema.ts
+/**
+* OpenAI strict JSON-schema normalization for tool inventories and request payloads.
+*
+* Caches normalized object inputs by provider compatibility so repeated inventory builds preserve identity.
+*/
+const MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
+let strictOpenAISchemaCache = /* @__PURE__ */ new WeakMap();
+function resolveToolSchemaModelCompat(compat) {
+	if (!compat) return;
+	const unsupportedToolSchemaKeywords = Array.isArray(compat.unsupportedToolSchemaKeywords) ? compat.unsupportedToolSchemaKeywords.filter((keyword) => typeof keyword === "string") : [];
+	if (unsupportedToolSchemaKeywords.length === 0 && compat.omitEmptyArrayItems !== true) return;
+	return {
+		...unsupportedToolSchemaKeywords.length > 0 ? { unsupportedToolSchemaKeywords } : {},
+		...compat.omitEmptyArrayItems === true ? { omitEmptyArrayItems: true } : {}
+	};
+}
+function resolveStrictOpenAISchemaCacheKey(modelCompat) {
+	const compat = resolveToolSchemaModelCompat(modelCompat);
+	return JSON.stringify([[...compat?.unsupportedToolSchemaKeywords ?? []].toSorted(), shouldOmitEmptyArrayItems(compat)]);
+}
+function readCachedStrictOpenAISchema(schema, key) {
+	return strictOpenAISchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
 }
 function rememberStrictOpenAISchema(schema, key, value) {
 	const entries = strictOpenAISchemaCache.get(schema) ?? [];
@@ -1493,7 +2919,7 @@ function convertResponsesToolPayload(tools, options) {
 	const strict = resolveResponsesStrictToolFlag(projection, resolveResponsesStrictToolSetting(options), options?.model);
 	return {
 		projection,
-		tools: sortResponsesToolsByName(projection.tools).map((tool) => {
+		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
 			const result = {
 				type: "function",
 				name: tool.name,
@@ -1549,16 +2975,6 @@ function shouldLogStrictToolDowngradeDiagnostic(diagnostics, model) {
 	loggedStrictToolDowngradeDiagnosticKeys.add(key);
 	return true;
 }
-function compareToolText(left, right) {
-	const leftText = left ?? "";
-	const rightText = right ?? "";
-	if (leftText < rightText) return -1;
-	if (leftText > rightText) return 1;
-	return 0;
-}
-function sortResponsesToolsByName(tools) {
-	return tools.toSorted((left, right) => compareToolText(left.name, right.name) || compareToolText(left.description, right.description));
-}
 //#endregion
 //#region packages/ai/src/providers/openai-responses-shared.ts
 const EMPTY_TOOL_RESULT_TEXT = "(no output)";
@@ -1566,16 +2982,6 @@ function splitResponsesToolCallId(id) {
 	const separatorIndex = id.indexOf("|");
 	return separatorIndex === -1 ? [id, void 0] : [id.slice(0, separatorIndex), id.slice(separatorIndex + 1)];
 }
-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 = ""] = splitResponsesToolCallId(fallbackId ?? "");
-	const resolvedCallId = callId || fallbackCallId;
-	const resolvedItemId = itemId || fallbackItemId;
-	if (resolvedCallId) return resolvedItemId ? `${resolvedCallId}|${resolvedItemId}` : resolvedCallId;
-	const generatedCallId = `call_${randomUUID().replaceAll("-", "").slice(0, 24)}`;
-	return resolvedItemId ? `${generatedCallId}|${resolvedItemId}` : generatedCallId;
-}
 function sanitizeToolResultText(text, fallback) {
 	const sanitized = sanitizeSurrogates(text);
 	return sanitized.trim().length > 0 ? sanitized : fallback;
@@ -1586,14 +2992,6 @@ function normalizeResponsesReasoningReplayItem(params) {
 	if (!params.replayResponsesItemIds) delete next.id;
 	return next;
 }
-function encodeTextSignatureV1(id, phase) {
-	const payload = {
-		v: 1,
-		id
-	};
-	if (phase) payload.phase = phase;
-	return JSON.stringify(payload);
-}
 function parseTextSignature(signature) {
 	if (!signature) return;
 	if (signature.startsWith("{")) try {
@@ -1864,9 +3262,10 @@ async function runResponsesStreamLifecycle(params) {
 			...params.processStreamOptions,
 			firstEventTimeoutMs: params.processStreamOptions?.firstEventTimeoutMs ?? firstEventTimeoutMs,
 			abortFirstEventStream: params.processStreamOptions?.abortFirstEventStream ?? firstEventAbort.abort,
-			onFirstEventTimeout: params.processStreamOptions?.onFirstEventTimeout ?? onFirstEventTimeout
+			onFirstEventTimeout: params.processStreamOptions?.onFirstEventTimeout ?? onFirstEventTimeout,
+			signal: params.processStreamOptions?.signal ?? options?.signal
 		} : void 0);
-		if (options?.signal?.aborted) throw new Error("Request was aborted");
+		if (options?.signal?.aborted) throw transportAbortError(options.signal);
 		if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
 		stream.push({
 			type: "done",
@@ -1888,505 +3287,132 @@ async function runResponsesStreamLifecycle(params) {
 		firstEventAbort?.dispose();
 	}
 }
-async function processResponsesStream(openaiStream, output, stream, model, options) {
-	const streamingToolCalls = createResponsesToolCallTracker();
-	const outputSlots = /* @__PURE__ */ new Map();
-	const reasoningBlocksById = /* @__PURE__ */ new Map();
-	let unindexedOutputSlot;
-	let terminalResponseEvent;
-	let lastTextBlock = null;
-	const blocks = output.content;
-	const blockIndex = () => blocks.length - 1;
-	const readOutputIndex = (event) => {
-		const outputIndex = event.output_index;
-		return typeof outputIndex === "number" && Number.isInteger(outputIndex) && outputIndex >= 0 ? outputIndex : void 0;
-	};
-	const registerOutputSlot = (event, slot) => {
-		const outputIndex = readOutputIndex(event);
-		if (outputIndex === void 0) {
-			if (unindexedOutputSlot) throw new Error("Responses stream added overlapping unindexed output items");
-			unindexedOutputSlot = slot;
-			return;
-		}
-		if (outputSlots.has(outputIndex)) throw new Error(`Responses stream reused active output index ${outputIndex}`);
-		outputSlots.set(outputIndex, slot);
-	};
-	const resolveOutputSlot = (event, type) => {
-		const outputIndex = readOutputIndex(event);
-		let slot = outputIndex === void 0 ? unindexedOutputSlot : outputSlots.get(outputIndex);
-		if (outputIndex === void 0 && !slot) {
-			const matchingSlots = [...outputSlots.values()].filter((candidate) => candidate.type === type);
-			slot = matchingSlots.length === 1 ? matchingSlots[0] : void 0;
-		}
-		return slot?.type === type ? slot : void 0;
-	};
-	const forgetOutputSlot = (event, slot) => {
-		const outputIndex = readOutputIndex(event);
-		if (outputIndex === void 0) {
-			if (unindexedOutputSlot === slot) unindexedOutputSlot = void 0;
-			else for (const [indexedOutput, indexedSlot] of outputSlots) if (indexedSlot === slot) outputSlots.delete(indexedOutput);
-			return;
-		}
-		if (outputSlots.get(outputIndex) === slot) outputSlots.delete(outputIndex);
-	};
-	const forgetToolCallOutputSlot = (toolCall) => {
-		for (const [outputIndex, slot] of outputSlots) if (slot.type === "toolCall" && slot.toolCall === toolCall) outputSlots.delete(outputIndex);
-	};
-	const readIdentityValue = (value) => {
-		return (typeof value === "string" ? value.trim() : "") || void 0;
-	};
-	const resolveCompletedToolCallName = (toolCall, value) => {
-		const streamedName = readIdentityValue(toolCall?.block.name);
-		const completedName = readIdentityValue(value);
-		if (streamedName && completedName && streamedName !== completedName) throw new Error(`Responses stream changed tool-call function name from ${streamedName} to ${completedName}`);
-		const name = completedName ?? streamedName;
-		if (!name) throw new Error("Responses stream completed tool call without a function name");
-		return name;
-	};
-	const createOutputSlot = (event, item) => {
-		if (item.type === "reasoning") {
-			const block = {
-				type: "thinking",
-				thinking: ""
-			};
-			const slot = {
-				type: "thinking",
-				item,
-				block,
-				contentIndex: blocks.length
-			};
-			blocks.push(block);
-			registerOutputSlot(event, slot);
-			stream.push({
-				type: "thinking_start",
-				contentIndex: slot.contentIndex,
-				partial: output
-			});
-			return slot;
-		}
-		if (item.type === "message") {
-			const messageItem = item;
-			const collapseCandidate = lastTextBlock;
-			const block = collapseCandidate ? null : {
-				type: "text",
-				text: "",
-				...messageItem.phase ? { textSignature: encodeTextSignatureV1(messageItem.id, messageItem.phase) } : {}
-			};
-			const slot = {
-				type: "text",
-				item: messageItem,
-				block,
-				contentIndex: block ? blocks.length : void 0,
-				pendingText: collapseCandidate ? "" : null,
-				collapseCandidate
-			};
-			if (block) blocks.push(block);
-			registerOutputSlot(event, slot);
-			if (slot.contentIndex !== void 0) stream.push({
-				type: "text_start",
-				contentIndex: slot.contentIndex,
-				partial: output
-			});
-			return slot;
-		}
-	};
-	const resolveOutputItemSlot = (event, item) => {
-		if (item.type === "reasoning") return resolveOutputSlot(event, "thinking");
-		if (item.type === "message") return resolveOutputSlot(event, "text");
-		const outputIndex = readOutputIndex(event);
-		return outputIndex === void 0 ? void 0 : outputSlots.get(outputIndex);
-	};
-	const getOrCreateOutputSlot = (event, item) => {
-		return resolveOutputItemSlot(event, item) ?? createOutputSlot(event, item);
-	};
-	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) } : {}
-		};
-		blocks.push(slot.block);
-		slot.contentIndex = blockIndex();
-		stream.push({
-			type: "text_start",
-			contentIndex: slot.contentIndex,
-			partial: output
-		});
-		if (text) stream.push({
-			type: "text_delta",
-			contentIndex: slot.contentIndex,
-			delta: text,
-			partial: output
-		});
-		if (lastTextBlock === slot.collapseCandidate) lastTextBlock = null;
-		slot.pendingText = null;
-		slot.collapseCandidate = null;
-	};
-	const materializeDeferredTextSlots = (except) => {
-		for (const slot of outputSlots.values()) if (slot !== except && slot.type === "text") materializeDeferredTextSlot(slot);
-		if (unindexedOutputSlot !== except && unindexedOutputSlot?.type === "text") materializeDeferredTextSlot(unindexedOutputSlot);
-	};
-	const appendPendingMessageDelta = (slot, delta) => {
-		slot.pendingText = `${slot.pendingText ?? ""}${delta}`;
-		const priorText = slot.collapseCandidate?.block.text ?? "";
-		if (priorText.startsWith(slot.pendingText) || slot.pendingText.startsWith(priorText)) return;
-		materializeDeferredTextSlot(slot);
-	};
-	const backfillReasoningSignatures = (responseOutput) => {
-		for (const item of responseOutput) {
-			if (item.type !== "reasoning" || !item.encrypted_content) continue;
-			const block = reasoningBlocksById.get(item.id);
-			if (!block?.thinkingSignature) continue;
-			const storedItem = JSON.parse(block.thinkingSignature);
-			if (storedItem.encrypted_content) continue;
-			block.thinkingSignature = JSON.stringify({
-				...storedItem,
-				encrypted_content: item.encrypted_content
-			});
-		}
-	};
-	const finalizeResponse = (response) => {
-		terminalResponseEvent = "finalized";
-		backfillReasoningSignatures(response.output ?? []);
-		if (response.id) output.responseId = response.id;
-		const mappedUsage = mapResponsesTerminalUsage(response.usage);
-		if (mappedUsage) output.usage = {
-			...mappedUsage,
-			cost: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				total: 0
-			}
-		};
-		calculateCost(model, output.usage);
-		if (options?.applyServiceTierPricing) {
-			const serviceTier = options.resolveServiceTier ? options.resolveServiceTier(response.service_tier, options.serviceTier) : response.service_tier ?? options.serviceTier;
-			options.applyServiceTierPricing(output.usage, serviceTier);
-		}
-		const terminal = resolveResponsesTerminalStopReason({
-			status: response.status,
-			incompleteReason: response.incomplete_details?.reason,
-			hasToolCall: output.content.some((block) => block.type === "toolCall")
-		});
-		output.stopReason = terminal.stopReason;
-		if (terminal.errorMessage) output.errorMessage = terminal.errorMessage;
+//#endregion
+//#region packages/ai/src/providers/openai-responses.ts
+var openai_responses_exports = /* @__PURE__ */ __exportAll({
+	streamOpenAIResponses: () => streamOpenAIResponses,
+	streamSimpleOpenAIResponses: () => streamSimpleOpenAIResponses
+});
+const OPENAI_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set(["openai", "opencode"]);
+function getCompat(model) {
+	return {
+		sendSessionIdHeader: model.compat?.sendSessionIdHeader ?? true,
+		supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true
 	};
-	const guardedStream = withFirstStreamEventTimeout(openaiStream, {
-		provider: model.provider,
-		api: model.api,
-		model: model.id,
-		timeoutMs: options?.firstEventTimeoutMs ?? 0,
-		stage: "responses",
-		abort: options?.abortFirstEventStream,
-		onTimeout: options?.onFirstEventTimeout,
-		hint: "The provider may be stalled while parsing the tool payload; retry with a smaller tool surface or enable OPENCLAW_DEBUG_MODEL_PAYLOAD=tools to inspect exposed tools."
+}
+function getPromptCacheRetention(compat, cacheRetention) {
+	return cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : void 0;
+}
+function formatOpenAIResponsesError(error) {
+	if (error instanceof Error) {
+		const status = error.status;
+		const statusCode = typeof status === "number" ? status : void 0;
+		if (statusCode !== void 0) return `OpenAI API error (${statusCode}): ${error.message}`;
+		return error.message;
+	}
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
+/**
+* Generate function for OpenAI Responses API
+*/
+const streamOpenAIResponses = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	runResponsesStreamLifecycle({
+		stream,
+		model,
+		output: createResponsesAssistantOutput(model),
+		options,
+		createClient: () => {
+			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+			const cacheSessionId = resolveCacheRetention$1(options?.cacheRetention) === "none" ? void 0 : options?.sessionId;
+			return createClient(model, context, apiKey, options?.headers, cacheSessionId);
+		},
+		buildParams: () => buildParams(model, context, options),
+		processStreamOptions: {
+			serviceTier: options?.serviceTier,
+			applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
+		},
+		formatError: formatOpenAIResponsesError
 	});
-	for await (const event of guardedStream) if (event.type === "response.created") output.responseId = event.response.id;
-	else if (event.type === "response.output_item.added") {
-		materializeDeferredTextSlots();
-		const item = event.item;
-		if (item.type !== "message") lastTextBlock = null;
-		if (item.type === "reasoning" || item.type === "message") createOutputSlot(event, item);
-		else if (item.type === "function_call") {
-			const toolCallBlock = {
-				type: "toolCall",
-				id: resolveResponsesToolCallId(item),
-				name: readIdentityValue(item.name) ?? "",
-				arguments: {},
-				partialJson: item.arguments || ""
-			};
-			const contentIndex = output.content.length;
-			const toolCallState = {
-				block: toolCallBlock,
-				contentIndex,
-				argumentStreamReliable: true,
-				...readResponsesToolCallItemIdentity(item)
-			};
-			streamingToolCalls.register(event, toolCallState);
-			if (readOutputIndex(event) !== void 0) registerOutputSlot(event, {
-				type: "toolCall",
-				toolCall: toolCallState
-			});
-			output.content.push(toolCallBlock);
-			stream.push({
-				type: "toolcall_start",
-				contentIndex,
-				partial: output
-			});
-		}
-	} else if (event.type === "response.reasoning_summary_part.added") {
-		const slot = resolveOutputSlot(event, "thinking");
-		if (!slot) continue;
-		slot.item.summary = slot.item.summary || [];
-		slot.item.summary.push(event.part);
-	} else if (event.type === "response.reasoning_summary_text.delta") {
-		const slot = resolveOutputSlot(event, "thinking");
-		if (!slot) continue;
-		slot.item.summary = slot.item.summary || [];
-		const lastPart = slot.item.summary[slot.item.summary.length - 1];
-		if (!lastPart) continue;
-		slot.block.thinking += event.delta;
-		lastPart.text += event.delta;
-		stream.push({
-			type: "thinking_delta",
-			contentIndex: slot.contentIndex,
-			delta: event.delta,
-			partial: output
-		});
-	} else if (event.type === "response.reasoning_summary_part.done") {
-		const slot = resolveOutputSlot(event, "thinking");
-		if (!slot) continue;
-		slot.item.summary = slot.item.summary || [];
-		const lastPart = slot.item.summary[slot.item.summary.length - 1];
-		if (!lastPart) continue;
-		slot.block.thinking += "\n\n";
-		lastPart.text += "\n\n";
-		stream.push({
-			type: "thinking_delta",
-			contentIndex: slot.contentIndex,
-			delta: "\n\n",
-			partial: output
-		});
-	} else if (event.type === "response.reasoning_text.delta") {
-		const slot = resolveOutputSlot(event, "thinking");
-		if (!slot) continue;
-		slot.block.thinking += event.delta;
-		stream.push({
-			type: "thinking_delta",
-			contentIndex: slot.contentIndex,
-			delta: event.delta,
-			partial: output
+	return stream;
+};
+const streamSimpleOpenAIResponses = (model, context, options) => {
+	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+	const base = buildBaseOptions(model, options, apiKey);
+	return streamOpenAIResponses(model, context, {
+		...base,
+		reasoningEffort: resolveResponsesReasoningEffort(model, options?.reasoning),
+		replayResponsesItemIds: options?.replayResponsesItemIds
+	});
+};
+function createClient(model, context, apiKey, optionsHeaders, sessionId) {
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+	const compat = getCompat(model);
+	const headers = { ...model.headers };
+	if (model.provider === "github-copilot") {
+		const hasImages = hasCopilotVisionInput(context.messages);
+		const copilotHeaders = buildCopilotDynamicHeaders({
+			messages: context.messages,
+			hasImages
 		});
-	} else if (event.type === "response.content_part.added") {
-		const slot = resolveOutputSlot(event, "text");
-		if (!slot) continue;
-		slot.item.content = slot.item.content || [];
-		if (event.part.type === "output_text" || event.part.type === "text" || event.part.type === "refusal") slot.item.content.push(event.part);
-	} else if (event.type === "response.output_text.delta") {
-		const slot = resolveOutputSlot(event, "text");
-		if (!slot?.item.content || slot.item.content.length === 0) continue;
-		const lastPart = slot.item.content[slot.item.content.length - 1];
-		if (!isResponsesTextContentPartType(lastPart?.type)) continue;
-		lastPart.text += event.delta;
-		if (slot.pendingText !== null) appendPendingMessageDelta(slot, event.delta);
-		else if (slot.block && slot.contentIndex !== void 0) {
-			slot.block.text += event.delta;
-			stream.push({
-				type: "text_delta",
-				contentIndex: slot.contentIndex,
-				delta: event.delta,
-				partial: output
-			});
-		}
-	} else if (isAzureResponsesTextDeltaEvent(event)) {
-		const slot = resolveOutputSlot(event, "text");
-		if (!slot) continue;
-		slot.item.content = slot.item.content || [];
-		let lastPart = slot.item.content[slot.item.content.length - 1];
-		if (lastPart?.type !== "text") {
-			lastPart = {
-				type: "text",
-				text: ""
-			};
-			slot.item.content.push(lastPart);
-		}
-		lastPart.text += event.delta;
-		if (slot.pendingText !== null) appendPendingMessageDelta(slot, event.delta);
-		else if (slot.block && slot.contentIndex !== void 0) {
-			slot.block.text += event.delta;
-			stream.push({
-				type: "text_delta",
-				contentIndex: slot.contentIndex,
-				delta: event.delta,
-				partial: output
-			});
-		}
-	} else if (event.type === "response.refusal.delta") {
-		const slot = resolveOutputSlot(event, "text");
-		if (!slot?.item.content || slot.item.content.length === 0) continue;
-		const lastPart = slot.item.content[slot.item.content.length - 1];
-		if (lastPart?.type !== "refusal") continue;
-		lastPart.refusal += event.delta;
-		if (slot.pendingText !== null) appendPendingMessageDelta(slot, event.delta);
-		else if (slot.block && slot.contentIndex !== void 0) {
-			slot.block.text += event.delta;
-			stream.push({
-				type: "text_delta",
-				contentIndex: slot.contentIndex,
-				delta: event.delta,
-				partial: output
-			});
-		}
-	} else if (event.type === "response.function_call_arguments.delta") {
-		const toolCall = streamingToolCalls.resolve(event);
-		if (toolCall) {
-			toolCall.block.partialJson += event.delta;
-			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) {
-			const previousPartialJson = toolCall.block.partialJson;
-			const doneArguments = typeof event.arguments === "string" ? event.arguments : void 0;
-			if (doneArguments !== void 0 && (doneArguments.length > 0 || previousPartialJson === "")) {
-				toolCall.block.partialJson = doneArguments;
-				toolCall.block.arguments = parseStreamingJson(toolCall.block.partialJson);
-				toolCall.argumentStreamReliable = 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();
-	} else if (event.type === "response.output_item.done") {
-		const item = event.item;
-		if (item.type !== "message") lastTextBlock = null;
-		const existingOutputSlot = resolveOutputItemSlot(event, item);
-		materializeDeferredTextSlots(existingOutputSlot);
-		const outputSlot = existingOutputSlot ?? getOrCreateOutputSlot(event, item);
-		if (item.type === "reasoning" && outputSlot?.type === "thinking") {
-			const summaryText = item.summary?.map((s) => s.text).join("\n\n") || "";
-			const contentText = item.content?.map((c) => c.text).join("\n\n") || "";
-			outputSlot.block.thinking = summaryText || contentText || outputSlot.block.thinking;
-			outputSlot.block.thinkingSignature = JSON.stringify(item);
-			if (typeof item.id === "string") reasoningBlocksById.set(item.id, outputSlot.block);
-			stream.push({
-				type: "thinking_end",
-				contentIndex: outputSlot.contentIndex,
-				content: outputSlot.block.thinking,
-				partial: output
-			});
-			forgetOutputSlot(event, outputSlot);
-		} else if (item.type === "message" && outputSlot?.type === "text" && (outputSlot.block || outputSlot.pendingText !== null)) {
-			const streamedText = outputSlot.pendingText ?? outputSlot.block?.text ?? "";
-			const finalText = item.content == null ? streamedText : item.content.map((c) => c.type === "output_text" || c.type === "text" ? c.text : c.refusal).join("");
-			const phase = item.phase ?? void 0;
-			const collapse = outputSlot.pendingText !== null ? resolveResponsesMessageSnapshotCollapse({
-				prior: outputSlot.collapseCandidate && {
-					text: outputSlot.collapseCandidate.block.text,
-					phase: outputSlot.collapseCandidate.phase
-				},
-				nextText: finalText,
-				nextPhase: phase
-			}) : { kind: "keep" };
-			outputSlot.pendingText = null;
-			if (collapse.kind === "extend" && outputSlot.collapseCandidate) {
-				outputSlot.collapseCandidate.block.text = collapse.text;
-				outputSlot.collapseCandidate.block.textSignature = encodeTextSignatureV1(item.id, phase);
-				stream.push({
-					type: "text_end",
-					contentIndex: outputSlot.collapseCandidate.index,
-					content: collapse.text,
-					partial: output
-				});
-				lastTextBlock = outputSlot.collapseCandidate;
-			} else {
-				if (!outputSlot.block) {
-					outputSlot.block = {
-						type: "text",
-						text: "",
-						...phase ? { textSignature: encodeTextSignatureV1(item.id, phase) } : {}
-					};
-					blocks.push(outputSlot.block);
-					outputSlot.contentIndex = blockIndex();
-					stream.push({
-						type: "text_start",
-						contentIndex: outputSlot.contentIndex,
-						partial: output
-					});
-				}
-				outputSlot.block.text = finalText;
-				outputSlot.block.textSignature = encodeTextSignatureV1(item.id, phase);
-				const contentIndex = outputSlot.contentIndex;
-				if (contentIndex === void 0) throw new Error("Responses stream finalized text without a content index");
-				lastTextBlock = {
-					block: outputSlot.block,
-					index: contentIndex,
-					phase
-				};
-				stream.push({
-					type: "text_end",
-					contentIndex,
-					content: outputSlot.block.text,
-					partial: output
-				});
-			}
-			forgetOutputSlot(event, outputSlot);
-		} else if (item.type === "function_call") {
-			const streamingToolCall = streamingToolCalls.resolve(event, readResponsesToolCallItemIdentity(item));
-			if (!streamingToolCall && streamingToolCalls.hasActive()) continue;
-			const completedName = resolveCompletedToolCallName(streamingToolCall, item.name);
-			const streamedArguments = streamingToolCall?.block.partialJson ?? "";
-			const completedArguments = typeof item.arguments === "string" ? item.arguments : void 0;
-			if (streamingToolCall && !streamingToolCall.argumentStreamReliable && !completedArguments) continue;
-			const args = parseStreamingJson(completedArguments !== void 0 && (completedArguments.length > 0 || !streamedArguments) ? completedArguments : streamedArguments || "{}");
-			let toolCall;
-			let contentIndex;
-			if (streamingToolCall) {
-				const block = streamingToolCall.block;
-				block.id = resolveResponsesToolCallId(item, block.id);
-				block.name = completedName;
-				block.arguments = args;
-				delete block.partialJson;
-				toolCall = block;
-				contentIndex = streamingToolCall.contentIndex;
-			} else {
-				toolCall = {
-					type: "toolCall",
-					id: resolveResponsesToolCallId(item),
-					name: completedName,
-					arguments: args
-				};
-				blocks.push(toolCall);
-				contentIndex = blockIndex();
-				stream.push({
-					type: "toolcall_start",
-					contentIndex,
-					partial: output
-				});
-			}
-			if (streamingToolCall) {
-				streamingToolCalls.forget(streamingToolCall);
-				forgetToolCallOutputSlot(streamingToolCall);
-			}
-			stream.push({
-				type: "toolcall_end",
-				contentIndex,
-				toolCall,
-				partial: output
-			});
-		}
-	} else if (event.type === "response.completed" || event.type === "response.incomplete") {
-		if (streamingToolCalls.hasActive()) throw new Error("Responses stream completed with unresolved tool calls");
-		finalizeResponse(event.response);
-	} else if (event.type === "error") throw new Error(event.message ? `Error Code ${event.code}: ${event.message}` : "Unknown error");
-	else if (event.type === "response.failed") {
-		const error = event.response?.error;
-		const details = event.response?.incomplete_details;
-		output.responseId = event.response.id;
-		output.stopReason = "error";
-		output.errorMessage = error ? `${error.code || "unknown"}: ${error.message || "no message"}` : details?.reason ? `incomplete: ${details.reason}` : "Unknown error (no error details in response)";
-		terminalResponseEvent = "failed";
-		break;
-	}
-	if (terminalResponseEvent === "failed") return;
-	if (streamingToolCalls.hasActive()) throw new Error("Responses stream ended with unresolved tool calls");
-	if (!terminalResponseEvent) throw new Error("OpenAI Responses stream ended before a terminal response event");
+		Object.assign(headers, copilotHeaders);
+	}
+	if (sessionId) {
+		if (compat.sendSessionIdHeader) headers.session_id = sessionId;
+		headers["x-client-request-id"] = sessionId;
+	}
+	if (optionsHeaders) Object.assign(headers, optionsHeaders);
+	const defaultHeaders = model.provider === "cloudflare-ai-gateway" ? {
+		...headers,
+		Authorization: headers.Authorization ?? null,
+		"cf-aig-authorization": `Bearer ${apiKey}`
+	} : headers;
+	return new OpenAI({
+		apiKey,
+		baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders,
+		fetch: getAiTransportHost().buildModelFetch(model)
+	});
+}
+function buildParams(model, context, options) {
+	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, { replayResponsesItemIds: options?.replayResponsesItemIds ?? false });
+	const cacheRetention = resolveCacheRetention$1(options?.cacheRetention);
+	const compat = getCompat(model);
+	const params = {
+		model: model.id,
+		input: messages,
+		stream: true,
+		prompt_cache_key: cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId),
+		prompt_cache_retention: getPromptCacheRetention(compat, cacheRetention),
+		store: false
+	};
+	if (options?.maxTokens) params.max_output_tokens = options?.maxTokens;
+	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options?.temperature;
+	if (options?.serviceTier !== void 0) params.service_tier = options.serviceTier;
+	applyCommonResponsesParams(params, model, context, options, { setDefaultReasoningOff: model.provider !== "github-copilot" });
+	return params;
+}
+function getServiceTierCostMultiplier(model, serviceTier) {
+	switch (serviceTier) {
+		case "flex": return .5;
+		case "priority": return model.id === "gpt-5.5" ? 2.5 : 2;
+		default: return 1;
+	}
+}
+function applyServiceTierPricing(usage, serviceTier, model) {
+	const multiplier = getServiceTierCostMultiplier(model, serviceTier);
+	if (multiplier === 1) return;
+	usage.cost.input *= multiplier;
+	usage.cost.output *= multiplier;
+	usage.cost.cacheRead *= multiplier;
+	usage.cost.cacheWrite *= multiplier;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
 }
 //#endregion
-export { isOpenAIGpt54MiniModel as A, resolveUnsupportedToolSchemaKeywords as B, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as C, isResponsesTextContentPartType as D, isAzureResponsesTextDeltaEventType as E, resolveOpenAISupportedReasoningEfforts as F, uniqueStrings as G, stripUnsupportedSchemaKeywords as H, supportsOpenAIReasoningEffort as I, supportsOpenAITemperature as L, isOpenAIGpt56Model as M, normalizeOpenAIReasoningEffort as N, isResponsesTextDeltaEventType as O, resolveOpenAIReasoningEffortForModel as P, extractToolSchemaModelCompat as R, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as S, isAzureResponsesTextDeltaEvent as T, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as U, shouldOmitEmptyArrayItems as V, cleanSchemaForGemini as W, readResponsesToolCallItemIdentity as _, resolveResponsesReasoningEffort as a, resolveResponsesTerminalStopReason as b, clearOpenAIToolSchemaCacheForTest as c, normalizeOpenAIStrictToolParameters as d, normalizeStrictOpenAIJsonSchema as f, createResponsesToolCallTracker as g, normalizeOpenAIStrictCompatSchema as h, processResponsesStream as i, isOpenAIGpt55Model as j, resolveResponsesMessageSnapshotCollapse as k, findOpenAIStrictToolProjectionDiagnostics as l, findOpenAIStrictSchemaViolations as m, convertResponsesMessages as n, runResponsesStreamLifecycle as o, resolveOpenAIProjectedToolsStrictToolFlag as p, createResponsesAssistantOutput as r, convertResponsesToolPayload as s, applyCommonResponsesParams as t, isStrictOpenAIJsonSchemaCompatible as u, mapResponsesTerminalUsage as v, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as w, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as x, readResponsesReasoningTokens as y, normalizeToolParameterSchema as z };
+export { createResponsesToolCallTracker as $, resolveAzureOpenAIApiVersion as A, emitModelTransportDebug as At, stringifyRedactedPayload as B, observeResponsesStream as C, normalizeToolParameterSchema as Ct, createResponsesStreamWithEncryptedContentRetry as D, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as Dt, convertResponsesMessages$1 as E, stripUnsupportedSchemaKeywords as Et, buildResponsesFailedNoDetailsObservation as F, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as G, summarizeResponsesFailedNoDetailsObservation as H, logResponsesFailedNoDetails as I, resolveCacheRetention as J, createModelStreamCooperativeScheduler as K, normalizeResponsesFailedEvent as L, tagOpenAIResponsesReasoningReplayItem as M, resolveModelSseDebugMode as Mt, resolveReplayableResponsesMessageId$1 as N, isInvalidEncryptedContentError as O, cleanSchemaForGemini as Ot, applyServiceTierPricing$1 as P, OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS as Q, safeDebugValue as R, resolveResponsesTerminalStopReason as S, extractToolSchemaModelCompat as St, buildResponsesInputMessage as T, shouldOmitEmptyArrayItems as Tt, summarizeResponsesPayload as U, summarizeOpenAITransportError as V, summarizeResponsesTools as W, throwIfModelStreamAborted as X, resolvePromptCacheKey as Y, AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS as Z, normalizeOpenAIStrictCompatSchema as _, supportsOpenAITemperature as _t, convertResponsesMessages as a, isAzureResponsesTextDeltaEvent as at, mapResponsesTerminalUsage as b, parseAzureDeploymentNameMap as bt, runResponsesStreamLifecycle as c, isResponsesTextDeltaEventType as ct, findOpenAIStrictToolProjectionDiagnostics as d, isOpenAIGpt55Model as dt, readResponsesToolCallItemIdentity as et, isStrictOpenAIJsonSchemaCompatible as f, isOpenAIGpt56Model as ft, findOpenAIStrictSchemaViolations as g, supportsOpenAIReasoningEffort as gt, resolveOpenAIProjectedToolsStrictToolFlag as h, resolveOpenAISupportedReasoningEfforts as ht, applyCommonResponsesParams as i, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as it, stripResponsesRequestEncryptedContent as j, resolveModelPayloadDebugMode as jt, prepareOpenAIResponsesReasoningItemForReplay as k, uniqueStrings as kt, convertResponsesToolPayload as l, resolveResponsesMessageSnapshotCollapse as lt, normalizeStrictOpenAIJsonSchema as m, resolveOpenAIReasoningEffortForModel as mt, streamOpenAIResponses as n, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as nt, createResponsesAssistantOutput as o, isAzureResponsesTextDeltaEventType as ot, normalizeOpenAIStrictToolParameters as p, normalizeOpenAIReasoningEffort as pt, log as q, streamSimpleOpenAIResponses as r, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as rt, resolveResponsesReasoningEffort as s, isResponsesTextContentPartType as st, openai_responses_exports as t, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as tt, clearOpenAIToolSchemaCacheForTest as u, isOpenAIGpt54MiniModel as ut, ResponsesStreamFailure as v, isOpenAICompatibleAzureResponsesBaseUrl as vt, buildOpenAIResponsesReasoningReplayMetadata as w, resolveUnsupportedToolSchemaKeywords as wt, readResponsesReasoningTokens as x, resolveAzureDeploymentNameFromMap as xt, processResponsesStream as y, isTraditionalAzureOpenAIHost as yt, stringifyRedactedEvent as z };