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

package/dist/{openai-D3PD6PE-.mjs → openai-responses-stream-internal-Cw5txaGW.mjs}

@@ -1,19 +1,13 @@
-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 { g as isRecord, m as normalizeOptionalString, n as getAiTransportHost, p as normalizeLowercaseStringOrEmpty } from "./host-Dog2WQiR.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 { 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 { a as isImageWithMediaPayload, d as stripSystemPromptCacheBoundary, o as truncateUtf16Safe, r as extractToolResultText, t as describeToolResultMediaPlaceholder } from "./tool-result-text-CTpIRbYd.mjs";
+import { u as transformTransportMessages } from "./openai-tool-projection-OhX64DoP.mjs";
+import { c as calculateCost } from "./number-coercion-DvG7SNMg.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 { b as redactIdentifier, d as transportAbortError, l as sanitizeNonEmptyTransportPayloadText, u as sanitizeTransportPayloadText, x as redactSensitiveText } from "./transport-stream-shared-D81p90xq.mjs";
+import { a as withFirstStreamEventTimeout } from "./stream-first-event-timeout-BBys9hSb.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-C3OgBjIk.mjs";
-import { createHash, randomUUID } from "node:crypto";
-import OpenAI from "openai";
+import { randomUUID } from "node:crypto";
 //#region packages/ai/src/transports/model-transport-debug.ts
 function normalizeEnv(value) {
 	return typeof value === "string" ? value.trim().toLowerCase() : "";
@@ -66,6 +60,159 @@ function uniqueStrings(values) {
 	return uniqueValues(values);
 }
 //#endregion
+//#region packages/ai/src/providers/openai-reasoning-effort.ts
+/**
+* OpenAI-compatible reasoning-effort normalization. Different GPT families
+* expose different accepted effort enums, so callers map requested values here
+* before constructing provider payloads.
+*/
+const GPT_5_REASONING_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high"
+];
+const GPT_51_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high"
+];
+const GPT_52_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_56_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const GPT_CODEX_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_PRO_REASONING_EFFORTS = [
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_5_PRO_REASONING_EFFORTS = ["high"];
+const GPT_51_CODEX_MAX_REASONING_EFFORTS = [
+	"none",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_51_CODEX_MINI_REASONING_EFFORTS = ["medium"];
+const GENERIC_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high"
+];
+const CANONICAL_REASONING_EFFORTS = /* @__PURE__ */ new Set([
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"off"
+]);
+function normalizeModelId(id) {
+	return normalizeLowercaseStringOrEmpty(id ?? "").replace(/-\d{4}-\d{2}-\d{2}$/u, "");
+}
+/** Return whether a model is the GPT-5.4 mini family. */
+function isOpenAIGpt54MiniModel(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return /^gpt-5\.4-mini(?:-|$)/u.test(id);
+}
+/** Return whether a model is the GPT-5.5 family. */
+function isOpenAIGpt55Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
+	return /^gpt-5\.5(?:-|$)/u.test(id) || /^gpt-5\.5(?:\s|\(|-|$)/u.test(name);
+}
+/** Return whether a model is the GPT-5.6 family. */
+function isOpenAIGpt56Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
+	return /^gpt-5\.6(?:-|$)/u.test(id) || /^gpt-5\.6(?:\s|\(|-|$)/u.test(name);
+}
+/** Normalize user-facing reasoning effort names to API effort names. */
+function normalizeOpenAIReasoningEffort(effort) {
+	const trimmed = effort.trim();
+	const folded = trimmed.toLowerCase();
+	return CANONICAL_REASONING_EFFORTS.has(folded) ? folded : trimmed;
+}
+function readCompatReasoningEfforts(compat) {
+	if (!compat || typeof compat !== "object") return;
+	if (compat.supportsReasoningEffort === false) return [];
+	const raw = compat.supportedReasoningEfforts;
+	if (!Array.isArray(raw)) return;
+	const supported = uniqueStrings(normalizeStringEntries(raw.filter((value) => typeof value === "string")));
+	return supported.length > 0 ? supported : void 0;
+}
+function isDisabledReasoningEffort(effort) {
+	return effort === "none" || effort === "off";
+}
+/** Resolve the reasoning efforts accepted by a specific OpenAI-compatible model. */
+function resolveOpenAISupportedReasoningEfforts(model) {
+	const compatEfforts = readCompatReasoningEfforts(model.compat);
+	if (compatEfforts) return compatEfforts;
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	if (/^gpt-5\.6(?:-|$)/u.test(id)) return GPT_56_REASONING_EFFORTS;
+	if (id === "gpt-5.1-codex-mini") return GPT_51_CODEX_MINI_REASONING_EFFORTS;
+	if (id === "gpt-5.1-codex-max") return GPT_51_CODEX_MAX_REASONING_EFFORTS;
+	if (/^gpt-5(?:\.\d+)?-codex(?:-|$)/u.test(id)) return GPT_CODEX_REASONING_EFFORTS;
+	if (id === "gpt-5-pro") return GPT_5_PRO_REASONING_EFFORTS;
+	if (/^gpt-5\.[2-9](?:\.\d+)?-pro(?:-|$)/u.test(id)) return GPT_PRO_REASONING_EFFORTS;
+	if (/^gpt-5\.[2-9](?:\.\d+)?(?:-|$)/u.test(id)) return GPT_52_REASONING_EFFORTS;
+	if (/^gpt-5\.1(?:-|$)/u.test(id)) return GPT_51_REASONING_EFFORTS;
+	if (/^gpt-5(?:-|$)/u.test(id)) return GPT_5_REASONING_EFFORTS;
+	return GENERIC_REASONING_EFFORTS;
+}
+/**
+* Return whether a model accepts the temperature parameter. The GPT-5.6
+* family rejects it with a 400; catalog compat can override per model.
+*/
+function supportsOpenAITemperature(model) {
+	const compat = model.compat;
+	if (compat && typeof compat === "object") {
+		const declared = compat.supportsTemperature;
+		if (typeof declared === "boolean") return declared;
+	}
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return !/^gpt-5\.6(?:-|$)/u.test(id);
+}
+/** Return whether a model accepts a requested reasoning effort. */
+function supportsOpenAIReasoningEffort(model, effort) {
+	return resolveOpenAISupportedReasoningEfforts(model).includes(normalizeOpenAIReasoningEffort(effort));
+}
+/** Resolve a requested reasoning effort to the closest value supported by the model. */
+function resolveOpenAIReasoningEffortForModel(params) {
+	const requested = normalizeOpenAIReasoningEffort(params.effort);
+	const mapped = params.fallbackMap?.[requested] ?? (params.fallbackMap && CANONICAL_REASONING_EFFORTS.has(requested) ? Object.entries(params.fallbackMap).find(([effort]) => normalizeOpenAIReasoningEffort(effort) === requested)?.[1] : void 0);
+	const normalized = mapped === void 0 ? requested : mapped.trim();
+	const supported = resolveOpenAISupportedReasoningEfforts(params.model);
+	if (supported.includes(normalized)) return normalized;
+	if (requested === "off" && supported.includes("none")) return "none";
+	if (isDisabledReasoningEffort(requested) || isDisabledReasoningEffort(normalized)) return;
+	if (requested === "minimal" && supported.includes("low")) return "low";
+	if ((requested === "minimal" || requested === "low") && supported.includes("medium")) return "medium";
+	if (requested === "xhigh" && supported.includes("high")) return "high";
+	if (requested === "max" && supported.includes("xhigh")) return "xhigh";
+	return supported.find((effort) => !isDisabledReasoningEffort(normalizeOpenAIReasoningEffort(effort)));
+}
+//#endregion
 //#region packages/ai/src/providers/clean-for-gemini.ts
 const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
 	"patternProperties",
@@ -337,7 +484,127 @@ function cleanSchemaForGemini(schema) {
 	return cleanSchemaForGeminiWithDefs(schema, extendSchemaDefs$1(void 0, schema), void 0);
 }
 //#endregion
+//#region packages/ai/src/providers/clean-for-llamacpp-gbnf.ts
+/** llama.cpp rejects grammar repetitions whose expanded rule count reaches 2000. */
+const LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD = 2e3;
+const SCHEMA_MAP_KEYS$2 = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+const SCHEMA_CHILD_KEYS = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"not",
+	"oneOf",
+	"prefixItems",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+function isSchemaRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function cleanSchemaNode(node) {
+	if (Array.isArray(node)) {
+		let changed = false;
+		const entries = node.map((entry) => {
+			const next = cleanSchemaNode(entry);
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? entries : node;
+	}
+	if (!isSchemaRecord(node)) return node;
+	let changed = false;
+	const cleaned = {};
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "pattern") {
+			changed = true;
+			continue;
+		}
+		if (key === "maxLength" && typeof value === "number" && value >= 2e3) {
+			changed = true;
+			continue;
+		}
+		let next = value;
+		if (SCHEMA_MAP_KEYS$2.has(key) && isSchemaRecord(value)) {
+			let mapChanged = false;
+			next = Object.fromEntries(Object.entries(value).map(([childKey, childValue]) => {
+				const cleanedChild = cleanSchemaNode(childValue);
+				mapChanged ||= cleanedChild !== childValue;
+				return [childKey, cleanedChild];
+			}));
+			if (!mapChanged) next = value;
+		} else if (SCHEMA_CHILD_KEYS.has(key)) next = cleanSchemaNode(value);
+		cleaned[key] = next;
+		changed ||= next !== value;
+	}
+	return changed ? cleaned : node;
+}
+function collectSchemaViolations(node, path, violations) {
+	if (Array.isArray(node)) {
+		node.forEach((entry, index) => collectSchemaViolations(entry, `${path}[${index}]`, violations));
+		return;
+	}
+	if (!isSchemaRecord(node)) return;
+	if ("pattern" in node) violations.push(`${path}.pattern`);
+	if (typeof node.maxLength === "number" && node.maxLength >= 2e3) violations.push(`${path}.maxLength`);
+	for (const [key, value] of Object.entries(node)) if (SCHEMA_MAP_KEYS$2.has(key) && isSchemaRecord(value)) for (const [childKey, childValue] of Object.entries(value)) collectSchemaViolations(childValue, `${path}.${key}.${childKey}`, violations);
+	else if (SCHEMA_CHILD_KEYS.has(key)) collectSchemaViolations(value, `${path}.${key}`, violations);
+}
+/** Removes JSON Schema constraints that llama.cpp cannot compile into GBNF. */
+function cleanSchemaForLlamacppGbnf(schema) {
+	return cleanSchemaNode(schema);
+}
+/** Reports schema paths that llama.cpp cannot compile into GBNF. */
+function findLlamacppGbnfSchemaViolations(schema, path) {
+	const violations = [];
+	collectSchemaViolations(schema, path, violations);
+	return violations;
+}
+//#endregion
 //#region packages/ai/src/providers/schema-keyword-strip.ts
+const SCHEMA_MAP_KEYS$1 = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"dependencies",
+	"patternProperties",
+	"properties"
+]);
+/** Containers whose value is a single nested schema. */
+const SCHEMA_OBJECT_KEYS$1 = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+/** Containers whose value is a list of nested schemas. */
+const SCHEMA_ARRAY_KEYS$1 = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"items",
+	"oneOf",
+	"prefixItems"
+]);
 /** Recursively remove schema keywords unsupported by a target provider/tool surface. */
 function stripUnsupportedSchemaKeywords(schema, unsupportedKeywords) {
 	if (!schema || typeof schema !== "object") return schema;
@@ -346,16 +613,16 @@ function stripUnsupportedSchemaKeywords(schema, unsupportedKeywords) {
 	const cleaned = {};
 	for (const [key, value] of Object.entries(obj)) {
 		if (unsupportedKeywords.has(key)) continue;
-		if (key === "properties" && value && typeof value === "object" && !Array.isArray(value)) {
+		if (SCHEMA_MAP_KEYS$1.has(key) && value && typeof value === "object" && !Array.isArray(value)) {
 			cleaned[key] = Object.fromEntries(Object.entries(value).map(([childKey, childValue]) => [childKey, stripUnsupportedSchemaKeywords(childValue, unsupportedKeywords)]));
 			continue;
 		}
-		if (key === "items" && value && typeof value === "object") {
-			cleaned[key] = Array.isArray(value) ? value.map((entry) => stripUnsupportedSchemaKeywords(entry, unsupportedKeywords)) : stripUnsupportedSchemaKeywords(value, unsupportedKeywords);
+		if (SCHEMA_ARRAY_KEYS$1.has(key) && Array.isArray(value)) {
+			cleaned[key] = value.map((entry) => stripUnsupportedSchemaKeywords(entry, unsupportedKeywords));
 			continue;
 		}
-		if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
-			cleaned[key] = value.map((entry) => stripUnsupportedSchemaKeywords(entry, unsupportedKeywords));
+		if (SCHEMA_OBJECT_KEYS$1.has(key) && value && typeof value === "object") {
+			cleaned[key] = stripUnsupportedSchemaKeywords(value, unsupportedKeywords);
 			continue;
 		}
 		cleaned[key] = value;
@@ -867,9 +1134,11 @@ function normalizeToolParameterSchemaUncached(schema, options) {
 	const isAnthropicProvider = normalizedProvider.includes("anthropic");
 	const unsupportedToolSchemaKeywords = resolveUnsupportedToolSchemaKeywords(options?.modelCompat);
 	const omitEmptyArrayItems = shouldOmitEmptyArrayItems(options?.modelCompat);
+	const isLlamacppGbnfProfile = normalizedToolSchemaProfile === "llamacpp";
 	function applyProviderCleaning(s) {
 		const normalizedSchema = normalizeArraySchemasMissingItems(s);
-		const arrayItemsCompatibleSchema = omitEmptyArrayItems ? stripEmptyArrayItemsFromArraySchemas(normalizedSchema) : normalizedSchema;
+		let arrayItemsCompatibleSchema = omitEmptyArrayItems ? stripEmptyArrayItemsFromArraySchemas(normalizedSchema) : normalizedSchema;
+		if (isLlamacppGbnfProfile) arrayItemsCompatibleSchema = cleanSchemaForLlamacppGbnf(arrayItemsCompatibleSchema);
 		if (isGeminiProvider && !isAnthropicProvider) {
 			const geminiCompatibleSchema = cleanSchemaForGemini(arrayItemsCompatibleSchema);
 			return unsupportedToolSchemaKeywords.size > 0 ? stripUnsupportedSchemaKeywords(geminiCompatibleSchema, unsupportedToolSchemaKeywords) : geminiCompatibleSchema;
@@ -940,327 +1209,276 @@ 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
-* expose different accepted effort enums, so callers map requested values here
-* before constructing provider payloads.
-*/
-const GPT_5_REASONING_EFFORTS = [
-	"minimal",
-	"low",
-	"medium",
-	"high"
-];
-const GPT_51_REASONING_EFFORTS = [
-	"none",
-	"low",
-	"medium",
-	"high"
-];
-const GPT_52_REASONING_EFFORTS = [
-	"none",
-	"low",
-	"medium",
-	"high",
-	"xhigh"
-];
-const GPT_56_REASONING_EFFORTS = [
-	"none",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max"
-];
-const GPT_CODEX_REASONING_EFFORTS = [
-	"low",
-	"medium",
-	"high",
-	"xhigh"
-];
-const GPT_PRO_REASONING_EFFORTS = [
-	"medium",
-	"high",
-	"xhigh"
-];
-const GPT_5_PRO_REASONING_EFFORTS = ["high"];
-const GPT_51_CODEX_MAX_REASONING_EFFORTS = [
-	"none",
-	"medium",
-	"high",
-	"xhigh"
-];
-const GPT_51_CODEX_MINI_REASONING_EFFORTS = ["medium"];
-const GENERIC_REASONING_EFFORTS = [
-	"low",
-	"medium",
-	"high"
-];
-const CANONICAL_REASONING_EFFORTS = /* @__PURE__ */ new Set([
-	"none",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-	"max",
-	"off"
+//#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"
 ]);
-function normalizeModelId(id) {
-	return normalizeLowercaseStringOrEmpty(id ?? "").replace(/-\d{4}-\d{2}-\d{2}$/u, "");
+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;
 }
-/** Return whether a model is the GPT-5.4 mini family. */
-function isOpenAIGpt54MiniModel(model) {
-	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
-	return /^gpt-5\.4-mini(?:-|$)/u.test(id);
+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;
 }
-/** Return whether a model is the GPT-5.5 family. */
-function isOpenAIGpt55Model(model) {
-	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
-	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
-	return /^gpt-5\.5(?:-|$)/u.test(id) || /^gpt-5\.5(?:\s|\(|-|$)/u.test(name);
+/** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
+function normalizeOpenAIStrictCompatSchema(schema) {
+	return normalizeOpenAIStrictCompatSchemaRecursive(schema, { promoteEmptyObject: true });
 }
-/** Return whether a model is the GPT-5.6 family. */
-function isOpenAIGpt56Model(model) {
-	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
-	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
-	return /^gpt-5\.6(?:-|$)/u.test(id) || /^gpt-5\.6(?:\s|\(|-|$)/u.test(name);
+/** 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;
 }
-/** Normalize user-facing reasoning effort names to API effort names. */
-function normalizeOpenAIReasoningEffort(effort) {
-	const trimmed = effort.trim();
-	const folded = trimmed.toLowerCase();
-	return CANONICAL_REASONING_EFFORTS.has(folded) ? folded : trimmed;
+//#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 readCompatReasoningEfforts(compat) {
-	if (!compat || typeof compat !== "object") return;
-	if (compat.supportsReasoningEffort === false) return [];
-	const raw = compat.supportedReasoningEfforts;
-	if (!Array.isArray(raw)) return;
-	const supported = uniqueStrings(normalizeStringEntries(raw.filter((value) => typeof value === "string")));
-	return supported.length > 0 ? supported : void 0;
+function resolveStrictOpenAISchemaCacheKey(modelCompat) {
+	const compat = resolveToolSchemaModelCompat(modelCompat);
+	return JSON.stringify([[...compat?.unsupportedToolSchemaKeywords ?? []].toSorted(), shouldOmitEmptyArrayItems(compat)]);
 }
-function isDisabledReasoningEffort(effort) {
-	return effort === "none" || effort === "off";
+function readCachedStrictOpenAISchema(schema, key) {
+	return strictOpenAISchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
 }
-/** Resolve the reasoning efforts accepted by a specific OpenAI-compatible model. */
-function resolveOpenAISupportedReasoningEfforts(model) {
-	const compatEfforts = readCompatReasoningEfforts(model.compat);
-	if (compatEfforts) return compatEfforts;
-	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
-	if (/^gpt-5\.6(?:-|$)/u.test(id)) return GPT_56_REASONING_EFFORTS;
-	if (id === "gpt-5.1-codex-mini") return GPT_51_CODEX_MINI_REASONING_EFFORTS;
-	if (id === "gpt-5.1-codex-max") return GPT_51_CODEX_MAX_REASONING_EFFORTS;
-	if (/^gpt-5(?:\.\d+)?-codex(?:-|$)/u.test(id)) return GPT_CODEX_REASONING_EFFORTS;
-	if (id === "gpt-5-pro") return GPT_5_PRO_REASONING_EFFORTS;
-	if (/^gpt-5\.[2-9](?:\.\d+)?-pro(?:-|$)/u.test(id)) return GPT_PRO_REASONING_EFFORTS;
-	if (/^gpt-5\.[2-9](?:\.\d+)?(?:-|$)/u.test(id)) return GPT_52_REASONING_EFFORTS;
-	if (/^gpt-5\.1(?:-|$)/u.test(id)) return GPT_51_REASONING_EFFORTS;
-	if (/^gpt-5(?:-|$)/u.test(id)) return GPT_5_REASONING_EFFORTS;
-	return GENERIC_REASONING_EFFORTS;
-}
-/**
-* Return whether a model accepts the temperature parameter. The GPT-5.6
-* family rejects it with a 400; catalog compat can override per model.
-*/
-function supportsOpenAITemperature(model) {
-	const compat = model.compat;
-	if (compat && typeof compat === "object") {
-		const declared = compat.supportsTemperature;
-		if (typeof declared === "boolean") return declared;
-	}
-	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
-	return !/^gpt-5\.6(?:-|$)/u.test(id);
-}
-/** Return whether a model accepts a requested reasoning effort. */
-function supportsOpenAIReasoningEffort(model, effort) {
-	return resolveOpenAISupportedReasoningEfforts(model).includes(normalizeOpenAIReasoningEffort(effort));
-}
-/** Resolve a requested reasoning effort to the closest value supported by the model. */
-function resolveOpenAIReasoningEffortForModel(params) {
-	const requested = normalizeOpenAIReasoningEffort(params.effort);
-	const mapped = params.fallbackMap?.[requested] ?? (params.fallbackMap && CANONICAL_REASONING_EFFORTS.has(requested) ? Object.entries(params.fallbackMap).find(([effort]) => normalizeOpenAIReasoningEffort(effort) === requested)?.[1] : void 0);
-	const normalized = mapped === void 0 ? requested : mapped.trim();
-	const supported = resolveOpenAISupportedReasoningEfforts(params.model);
-	if (supported.includes(normalized)) return normalized;
-	if (requested === "off" && supported.includes("none")) return "none";
-	if (isDisabledReasoningEffort(requested) || isDisabledReasoningEffort(normalized)) return;
-	if (requested === "minimal" && supported.includes("low")) return "low";
-	if ((requested === "minimal" || requested === "low") && supported.includes("medium")) return "medium";
-	if (requested === "xhigh" && supported.includes("high")) return "high";
-	if (requested === "max" && supported.includes("xhigh")) return "xhigh";
-	return supported.find((effort) => !isDisabledReasoningEffort(normalizeOpenAIReasoningEffort(effort)));
-}
-//#endregion
-//#region packages/ai/src/providers/openai-responses-stream-compat.ts
-const OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE = "output_text";
-const AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE = "text";
-const OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE = "response.output_text.delta";
-const AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE = "response.text.delta";
-function isResponsesTextContentPartType(type) {
-	return type === "output_text" || type === "text";
-}
-function isResponsesTextDeltaEventType(type) {
-	return type === "response.output_text.delta" || type === "response.text.delta";
+function rememberStrictOpenAISchema(schema, key, value) {
+	const entries = strictOpenAISchemaCache.get(schema) ?? [];
+	strictOpenAISchemaCache.set(schema, [{
+		key,
+		value
+	}, ...entries.filter((entry) => entry.key !== key)].slice(0, MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA));
+	return value;
 }
-function isAzureResponsesTextDeltaEventType(type) {
-	return type === AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
+function clearOpenAIToolSchemaCacheForTest() {
+	strictOpenAISchemaCache = /* @__PURE__ */ new WeakMap();
 }
-function isAzureResponsesTextDeltaEvent(event) {
-	return isAzureResponsesTextDeltaEventType(event.type) && typeof event.delta === "string";
+/** Normalizes a tool parameter schema into the OpenAI strict JSON-schema subset. */
+function normalizeStrictOpenAIJsonSchema(schema, modelCompat) {
+	const schemaInput = schema ?? {};
+	if (!schemaInput || typeof schemaInput !== "object") return normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0);
+	const cacheKey = resolveStrictOpenAISchemaCacheKey(modelCompat);
+	const cached = readCachedStrictOpenAISchema(schemaInput, cacheKey);
+	if (cached !== void 0) return cached;
+	return rememberStrictOpenAISchema(schemaInput, cacheKey, normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0));
 }
-function resolveResponsesMessageSnapshotCollapse(params) {
-	const { prior, nextText } = params;
-	if (!prior?.text || !nextText || prior.phase !== params.nextPhase) return { kind: "keep" };
-	if (nextText.length > prior.text.length && nextText.startsWith(prior.text)) return {
-		kind: "extend",
-		text: nextText
-	};
-	return { kind: "keep" };
+function normalizeStrictOpenAIJsonSchemaRecursive(schema, depth) {
+	if (Array.isArray(schema)) {
+		let changed = false;
+		const normalized = schema.map((entry) => {
+			const next = normalizeStrictOpenAIJsonSchemaRecursive(entry, depth);
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? normalized : schema;
+	}
+	if (!schema || typeof schema !== "object") return schema;
+	const record = schema;
+	let changed = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(record)) {
+		const next = normalizeStrictOpenAIJsonSchemaRecursive(value, key === "properties" ? depth : depth + 1);
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	if (normalized.type === "object") {
+		const properties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) ? normalized.properties : void 0;
+		if (properties && Object.keys(properties).length === 0 && !Array.isArray(normalized.required)) {
+			normalized.required = [];
+			changed = true;
+		}
+		if (depth === 0 && !("additionalProperties" in normalized)) {
+			normalized.additionalProperties = false;
+			changed = true;
+		}
+	}
+	return changed ? normalized : schema;
 }
-//#endregion
-//#region packages/ai/src/providers/openai-responses-tool-call-tracker.ts
-function readIdentityValue(value) {
-	return (typeof value === "string" ? value.trim() : "") || void 0;
+/** Normalizes tool parameters using strict OpenAI rules only when strict mode is active. */
+function normalizeOpenAIStrictToolParameters(schema, strict, modelCompat) {
+	const toolSchemaCompat = resolveToolSchemaModelCompat(modelCompat);
+	if (!strict) return normalizeToolParameterSchema(schema ?? {}, { modelCompat: toolSchemaCompat });
+	return normalizeStrictOpenAIJsonSchema(schema, toolSchemaCompat);
 }
-function readOutputIndex(event) {
-	return typeof event.output_index === "number" && Number.isInteger(event.output_index) && event.output_index >= 0 ? event.output_index : void 0;
+/** Returns whether a schema already satisfies OpenAI strict tool-schema constraints. */
+function isStrictOpenAIJsonSchemaCompatible(schema) {
+	return isStrictOpenAIJsonSchemaCompatibleRecursive(normalizeStrictOpenAIJsonSchema(schema));
 }
-function readEventIdentity(event) {
-	return { itemId: readIdentityValue(event.item_id) };
+/** Returns strict-schema diagnostics for an already materialized OpenAI tool projection. */
+function findOpenAIStrictToolProjectionDiagnostics(projection) {
+	return [...projection.diagnostics.map((diagnostic) => ({
+		toolIndex: diagnostic.toolIndex,
+		...diagnostic.toolName ? { toolName: diagnostic.toolName } : {},
+		violations: [...diagnostic.violations]
+	})), ...projection.tools.flatMap((tool) => {
+		const violations = findOpenAIStrictSchemaViolations(normalizeStrictOpenAIJsonSchema(tool.parameters), `${tool.name}.parameters`);
+		return violations.length > 0 ? [{
+			toolIndex: tool.toolIndex,
+			toolName: tool.name,
+			violations
+		}] : [];
+	})];
 }
-function readResponsesToolCallItemIdentity(item) {
-	return {
-		itemId: readIdentityValue(item.id),
-		callId: readIdentityValue(item.call_id)
-	};
+function isStrictOpenAIJsonSchemaCompatibleRecursive(schema) {
+	if (Array.isArray(schema)) return schema.every((entry) => isStrictOpenAIJsonSchemaCompatibleRecursive(entry));
+	if (!schema || typeof schema !== "object") return true;
+	const record = schema;
+	if ("anyOf" in record || "oneOf" in record || "allOf" in record) return false;
+	if (Array.isArray(record.type)) return false;
+	if (record.type === "object" && record.additionalProperties !== false) return false;
+	if (record.type === "object") {
+		const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : {};
+		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
+		if (!required) return false;
+		const requiredSet = new Set(required);
+		if (Object.keys(properties).some((key) => !requiredSet.has(key))) return false;
+	}
+	return Object.entries(record).every(([key, entry]) => {
+		if (key === "properties" && entry && typeof entry === "object" && !Array.isArray(entry)) return Object.values(entry).every((value) => isStrictOpenAIJsonSchemaCompatibleRecursive(value));
+		return isStrictOpenAIJsonSchemaCompatibleRecursive(entry);
+	});
 }
-function createResponsesToolCallTracker() {
-	const indexedCalls = /* @__PURE__ */ new Map();
-	const unindexedCalls = /* @__PURE__ */ new Set();
-	const identitiesConflict = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId !== identity.itemId || state.callId && identity.callId && state.callId !== identity.callId);
-	const sharesIdentity = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId === identity.itemId || state.callId && identity.callId && state.callId === identity.callId);
-	const adoptIdentity = (state, identity) => {
-		state.itemId ??= identity.itemId;
-		state.callId ??= identity.callId;
-		return state;
-	};
-	const resolveCompatible = (candidates, identity) => {
-		const uniqueCandidates = [...new Set(candidates)];
-		if (!identity.itemId && !identity.callId) return uniqueCandidates.length === 1 ? uniqueCandidates.at(0) : void 0;
-		const compatible = uniqueCandidates.filter((state) => !identitiesConflict(state, identity));
-		const matches = compatible.filter((state) => sharesIdentity(state, identity));
-		const matched = matches.length === 1 ? matches.at(0) : void 0;
-		if (matched) return adoptIdentity(matched, identity);
-		const soleCompatible = uniqueCandidates.length === 1 && compatible.length === 1 && matches.length === 0 ? compatible.at(0) : void 0;
-		return soleCompatible ? adoptIdentity(soleCompatible, identity) : void 0;
-	};
-	return {
-		register(event, state) {
-			const outputIndex = readOutputIndex(event);
-			if (outputIndex === void 0) {
-				unindexedCalls.add(state);
-				return;
-			}
-			if (indexedCalls.has(outputIndex)) throw new Error(`Responses stream reused active tool-call output index ${outputIndex}`);
-			indexedCalls.set(outputIndex, state);
-		},
-		resolve(event, identity = readEventIdentity(event)) {
-			const outputIndex = readOutputIndex(event);
-			if (outputIndex !== void 0) {
-				const indexed = indexedCalls.get(outputIndex);
-				if (indexed) {
-					if (indexed.callId && identity.callId && indexed.callId !== identity.callId) return;
-					return adoptIdentity(indexed, identity);
-				}
-				const unindexed = resolveCompatible(unindexedCalls, identity);
-				if (unindexed) {
-					unindexedCalls.delete(unindexed);
-					indexedCalls.set(outputIndex, unindexed);
-				}
-				return unindexed;
-			}
-			return resolveCompatible([...indexedCalls.values(), ...unindexedCalls], identity);
-		},
-		forget(toolCall) {
-			for (const [outputIndex, tracked] of indexedCalls) if (tracked === toolCall) indexedCalls.delete(outputIndex);
-			unindexedCalls.delete(toolCall);
-		},
-		markArgumentsUnreliable() {
-			for (const toolCall of /* @__PURE__ */ new Set([...indexedCalls.values(), ...unindexedCalls])) toolCall.argumentStreamReliable = false;
-		},
-		hasActive() {
-			return indexedCalls.size > 0 || unindexedCalls.size > 0;
-		}
-	};
+/** Resolves strict mode for the projected tools that will be emitted in the request payload. */
+function resolveOpenAIProjectedToolsStrictToolFlag(projection, strict) {
+	if (strict !== true) return strict === false ? false : void 0;
+	return projection.tools.every((tool) => isStrictOpenAIJsonSchemaCompatible(tool.parameters));
 }
-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/transports/openai-transport-shared.ts
 /** Shared options, usage shape, cache identity, ordering, and stream scheduling for OpenAI APIs. */
@@ -1300,31 +1518,39 @@ function createModelStreamCooperativeScheduler(signal) {
 		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-replay.ts
+/** Resolves the assistant message id that can be replayed to OpenAI Responses. */
+function resolveReplayableResponsesMessageId(params) {
+	if (!params.replayResponsesItemIds) return;
+	if (!params.textSignatureId) return params.fallbackOrdinal === 0 ? params.fallbackId : `${params.fallbackId}_${params.fallbackOrdinal}`;
+	return params.previousReplayItemWasReasoning ? params.textSignatureId : void 0;
+}
+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/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) {
+function getServiceTierCostMultiplier(serviceTier) {
 	switch (serviceTier) {
 		case "flex": return .5;
 		case "priority": return 2;
 		default: return 1;
 	}
 }
-function applyServiceTierPricing$1(usage, serviceTier) {
-	const multiplier = getServiceTierCostMultiplier$1(serviceTier);
+function applyServiceTierPricing(usage, serviceTier) {
+	const multiplier = getServiceTierCostMultiplier(serviceTier);
 	if (multiplier === 1) return;
 	usage.cost.input *= multiplier;
 	usage.cost.output *= multiplier;
@@ -1584,14 +1810,6 @@ function summarizeOpenAITransportError(error) {
 	].join(" ");
 }
 //#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;
@@ -1730,7 +1948,7 @@ function encodeTextSignatureV1(id, phase) {
 		...phase ? { phase } : {}
 	});
 }
-function parseTextSignature$1(signature) {
+function parseTextSignature(signature) {
 	if (!signature) return;
 	if (signature.startsWith("{")) try {
 		const parsed = JSON.parse(signature);
@@ -1753,7 +1971,7 @@ function buildResponsesInputMessage(role, content) {
 		content
 	};
 }
-function convertResponsesMessages$1(model, context, allowedToolCallProviders, options) {
+function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
 	const messages = [];
 	const shouldReplayReasoningItems = options?.replayReasoningItems ?? true;
 	const shouldReplayResponsesItemIds = options?.replayResponsesItemIds ?? true;
@@ -1823,8 +2041,8 @@ function convertResponsesMessages$1(model, context, allowedToolCallProviders, op
 					previousReplayItemWasReasoning = true;
 				}
 			} else if (block.type === "text") {
-				const textSignature = parseTextSignature$1(block.textSignature);
-				let msgId = resolveReplayableResponsesMessageId$1({
+				const textSignature = parseTextSignature(block.textSignature);
+				let msgId = resolveReplayableResponsesMessageId({
 					replayResponsesItemIds: shouldReplayResponsesItemIds,
 					textSignatureId: textSignature?.id,
 					fallbackId: `msg_${msgIndex}`,
@@ -1842,1577 +2060,905 @@ function convertResponsesMessages$1(model, context, allowedToolCallProviders, op
 						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
+					...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;
 			}
-		} 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 (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)")
+			});
 		}
-		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;
+		msgIndex += 1;
 	}
+	return messages;
 }
 //#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;
+//#region packages/ai/src/providers/openai-responses-stream-compat.ts
+const OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE = "output_text";
+const AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE = "text";
+const OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE = "response.output_text.delta";
+const AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE = "response.text.delta";
+function isResponsesTextContentPartType(type) {
+	return type === "output_text" || type === "text";
 }
-function 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;
+function isResponsesTextDeltaEventType(type) {
+	return type === "response.output_text.delta" || type === "response.text.delta";
+}
+function isAzureResponsesTextDeltaEventType(type) {
+	return type === AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE;
+}
+function isAzureResponsesTextDeltaEvent(event) {
+	return isAzureResponsesTextDeltaEventType(event.type) && typeof event.delta === "string";
+}
+function resolveResponsesMessageSnapshotCollapse(params) {
+	const { prior, nextText } = params;
+	if (!prior?.text || !nextText || prior.phase !== params.nextPhase) return { kind: "keep" };
+	if (nextText.length > prior.text.length && nextText.startsWith(prior.text)) return {
+		kind: "extend",
+		text: nextText
+	};
+	return { kind: "keep" };
+}
+//#endregion
+//#region packages/ai/src/providers/openai-responses-tool-call-tracker.ts
+function readIdentityValue(value) {
+	return (typeof value === "string" ? value.trim() : "") || void 0;
+}
+function readOutputIndex(event) {
+	return typeof event.output_index === "number" && Number.isInteger(event.output_index) && event.output_index >= 0 ? event.output_index : void 0;
+}
+function readEventIdentity(event) {
+	return { itemId: readIdentityValue(event.item_id) };
+}
+function readResponsesToolCallItemIdentity(item) {
+	return {
+		itemId: readIdentityValue(item.id),
+		callId: readIdentityValue(item.call_id)
+	};
+}
+function createResponsesToolCallTracker() {
+	const indexedCalls = /* @__PURE__ */ new Map();
+	const unindexedCalls = /* @__PURE__ */ new Set();
+	const identitiesConflict = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId !== identity.itemId || state.callId && identity.callId && state.callId !== identity.callId);
+	const sharesIdentity = (state, identity) => Boolean(state.itemId && identity.itemId && state.itemId === identity.itemId || state.callId && identity.callId && state.callId === identity.callId);
+	const adoptIdentity = (state, identity) => {
+		state.itemId ??= identity.itemId;
+		state.callId ??= identity.callId;
+		return state;
+	};
+	const resolveCompatible = (candidates, identity) => {
+		const uniqueCandidates = [...new Set(candidates)];
+		if (!identity.itemId && !identity.callId) return uniqueCandidates.length === 1 ? uniqueCandidates.at(0) : void 0;
+		const compatible = uniqueCandidates.filter((state) => !identitiesConflict(state, identity));
+		const matches = compatible.filter((state) => sharesIdentity(state, identity));
+		const matched = matches.length === 1 ? matches.at(0) : void 0;
+		if (matched) return adoptIdentity(matched, identity);
+		const soleCompatible = uniqueCandidates.length === 1 && compatible.length === 1 && matches.length === 0 ? compatible.at(0) : void 0;
+		return soleCompatible ? adoptIdentity(soleCompatible, identity) : void 0;
+	};
+	return {
+		register(event, state) {
+			const outputIndex = readOutputIndex(event);
+			if (outputIndex === void 0) {
+				unindexedCalls.add(state);
+				return;
+			}
+			if (indexedCalls.has(outputIndex)) throw new Error(`Responses stream reused active tool-call output index ${outputIndex}`);
+			indexedCalls.set(outputIndex, state);
+		},
+		resolve(event, identity = readEventIdentity(event)) {
+			const outputIndex = readOutputIndex(event);
+			if (outputIndex !== void 0) {
+				const indexed = indexedCalls.get(outputIndex);
+				if (indexed) {
+					if (indexed.callId && identity.callId && indexed.callId !== identity.callId) return;
+					return adoptIdentity(indexed, identity);
+				}
+				const unindexed = resolveCompatible(unindexedCalls, identity);
+				if (unindexed) {
+					unindexedCalls.delete(unindexed);
+					indexedCalls.set(outputIndex, unindexed);
+				}
+				return unindexed;
+			}
+			return resolveCompatible([...indexedCalls.values(), ...unindexedCalls], identity);
+		},
+		forget(toolCall) {
+			for (const [outputIndex, tracked] of indexedCalls) if (tracked === toolCall) indexedCalls.delete(outputIndex);
+			unindexedCalls.delete(toolCall);
+		},
+		markArgumentsUnreliable() {
+			for (const toolCall of /* @__PURE__ */ new Set([...indexedCalls.values(), ...unindexedCalls])) toolCall.argumentStreamReliable = false;
+		},
+		hasActive() {
+			return indexedCalls.size > 0 || unindexedCalls.size > 0;
 		}
-		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;
+	};
+}
+//#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();
 	}
-	if (normalized.type === "object" && hasEmptyProperties && !("additionalProperties" in normalized)) {
-		normalized.additionalProperties = false;
-		changed = true;
+}
+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}`);
 	}
-	return changed ? normalized : schema;
 }
-/** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
-function normalizeOpenAIStrictCompatSchema(schema) {
-	return normalizeOpenAIStrictCompatSchemaRecursive(schema, { promoteEmptyObject: true });
+//#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;
 }
-/** 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 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);
 		}
-	}
-	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
+//#region packages/ai/src/providers/openai-responses-terminal-usage.ts
+function readCount(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
 /**
-* OpenAI strict JSON-schema normalization for tool inventories and request payloads.
+* Split a terminal usage payload into the priced buckets.
 *
-* Caches normalized object inputs by provider compatibility so repeated inventory builds preserve identity.
+* 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.
 */
-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;
+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 {
-		...unsupportedToolSchemaKeywords.length > 0 ? { unsupportedToolSchemaKeywords } : {},
-		...compat.omitEmptyArrayItems === true ? { omitEmptyArrayItems: true } : {}
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: Math.max(bucketTotal, readCount(usage.total_tokens))
 	};
 }
-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) ?? [];
-	strictOpenAISchemaCache.set(schema, [{
-		key,
-		value
-	}, ...entries.filter((entry) => entry.key !== key)].slice(0, MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA));
-	return value;
-}
-function clearOpenAIToolSchemaCacheForTest() {
-	strictOpenAISchemaCache = /* @__PURE__ */ new WeakMap();
-}
-/** Normalizes a tool parameter schema into the OpenAI strict JSON-schema subset. */
-function normalizeStrictOpenAIJsonSchema(schema, modelCompat) {
-	const schemaInput = schema ?? {};
-	if (!schemaInput || typeof schemaInput !== "object") return normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0);
-	const cacheKey = resolveStrictOpenAISchemaCacheKey(modelCompat);
-	const cached = readCachedStrictOpenAISchema(schemaInput, cacheKey);
-	if (cached !== void 0) return cached;
-	return rememberStrictOpenAISchema(schemaInput, cacheKey, normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0));
-}
-function normalizeStrictOpenAIJsonSchemaRecursive(schema, depth) {
-	if (Array.isArray(schema)) {
-		let changed = false;
-		const normalized = schema.map((entry) => {
-			const next = normalizeStrictOpenAIJsonSchemaRecursive(entry, depth);
-			changed ||= next !== entry;
-			return next;
-		});
-		return changed ? normalized : schema;
-	}
-	if (!schema || typeof schema !== "object") return schema;
-	const record = schema;
-	let changed = false;
-	const normalized = {};
-	for (const [key, value] of Object.entries(record)) {
-		const next = normalizeStrictOpenAIJsonSchemaRecursive(value, key === "properties" ? depth : depth + 1);
-		normalized[key] = next;
-		changed ||= next !== value;
-	}
-	if (normalized.type === "object") {
-		const properties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) ? normalized.properties : void 0;
-		if (properties && Object.keys(properties).length === 0 && !Array.isArray(normalized.required)) {
-			normalized.required = [];
-			changed = true;
-		}
-		if (depth === 0 && !("additionalProperties" in normalized)) {
-			normalized.additionalProperties = false;
-			changed = true;
-		}
-	}
-	return changed ? normalized : schema;
-}
-/** Normalizes tool parameters using strict OpenAI rules only when strict mode is active. */
-function normalizeOpenAIStrictToolParameters(schema, strict, modelCompat) {
-	const toolSchemaCompat = resolveToolSchemaModelCompat(modelCompat);
-	if (!strict) return normalizeToolParameterSchema(schema ?? {}, { modelCompat: toolSchemaCompat });
-	return normalizeStrictOpenAIJsonSchema(schema, toolSchemaCompat);
-}
-/** Returns whether a schema already satisfies OpenAI strict tool-schema constraints. */
-function isStrictOpenAIJsonSchemaCompatible(schema) {
-	return isStrictOpenAIJsonSchemaCompatibleRecursive(normalizeStrictOpenAIJsonSchema(schema));
-}
-/** Returns strict-schema diagnostics for an already materialized OpenAI tool projection. */
-function findOpenAIStrictToolProjectionDiagnostics(projection) {
-	return [...projection.diagnostics.map((diagnostic) => ({
-		toolIndex: diagnostic.toolIndex,
-		...diagnostic.toolName ? { toolName: diagnostic.toolName } : {},
-		violations: [...diagnostic.violations]
-	})), ...projection.tools.flatMap((tool) => {
-		const violations = findOpenAIStrictSchemaViolations(normalizeStrictOpenAIJsonSchema(tool.parameters), `${tool.name}.parameters`);
-		return violations.length > 0 ? [{
-			toolIndex: tool.toolIndex,
-			toolName: tool.name,
-			violations
-		}] : [];
-	})];
+/** 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 isStrictOpenAIJsonSchemaCompatibleRecursive(schema) {
-	if (Array.isArray(schema)) return schema.every((entry) => isStrictOpenAIJsonSchemaCompatibleRecursive(entry));
-	if (!schema || typeof schema !== "object") return true;
-	const record = schema;
-	if ("anyOf" in record || "oneOf" in record || "allOf" in record) return false;
-	if (Array.isArray(record.type)) return false;
-	if (record.type === "object" && record.additionalProperties !== false) return false;
-	if (record.type === "object") {
-		const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : {};
-		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
-		if (!required) return false;
-		const requiredSet = new Set(required);
-		if (Object.keys(properties).some((key) => !requiredSet.has(key))) return false;
+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)}`);
 	}
-	return Object.entries(record).every(([key, entry]) => {
-		if (key === "properties" && entry && typeof entry === "object" && !Array.isArray(entry)) return Object.values(entry).every((value) => isStrictOpenAIJsonSchemaCompatibleRecursive(value));
-		return isStrictOpenAIJsonSchemaCompatibleRecursive(entry);
-	});
 }
-/** Resolves strict mode for the projected tools that will be emitted in the request payload. */
-function resolveOpenAIProjectedToolsStrictToolFlag(projection, strict) {
-	if (strict !== true) return strict === false ? false : void 0;
-	return projection.tools.every((tool) => isStrictOpenAIJsonSchemaCompatible(tool.parameters));
+/**
+* Resolve the terminal stop reason, including the two overrides every Responses path shares: a
+* content-filtered turn is a provider error rather than a truncated answer, and a turn that
+* produced tool calls reports `toolUse` instead of a plain stop.
+*/
+function resolveResponsesTerminalStopReason(params) {
+	const status = params.status ?? (params.terminalEventType === "response.incomplete" ? "incomplete" : void 0);
+	if (status === "incomplete" && params.incompleteReason === "content_filter") return {
+		stopReason: "error",
+		errorMessage: "Provider incomplete_reason: content_filter"
+	};
+	const stopReason = mapResponsesTerminalStopReason(status);
+	if (stopReason === "stop" && params.hasToolCall) return { stopReason: "toolUse" };
+	return { stopReason };
 }
 //#endregion
-//#region packages/ai/src/providers/openai-responses-tools.ts
-const LOG_SUBSYSTEM = "llm/openai-responses";
-const MAX_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS = 64;
-const loggedStrictToolDowngradeDiagnosticKeys = /* @__PURE__ */ new Set();
-/** Converts and returns the projection used to reconcile tool choices. */
-function convertResponsesToolPayload(tools, options) {
-	const projection = projectOpenAITools(tools);
-	const strict = resolveResponsesStrictToolFlag(projection, resolveResponsesStrictToolSetting(options), options?.model);
-	return {
-		projection,
-		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => {
-			const result = {
-				type: "function",
-				name: tool.name,
-				description: tool.description,
-				parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, options?.model?.compat)
-			};
-			if (strict !== void 0) result.strict = strict;
-			return result;
-		})
-	};
+//#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 resolveResponsesStrictToolSetting(options) {
-	if (options?.strict !== void 0) return options.strict;
-	if (options?.model) return getAiTransportHost().resolveOpenAIStrictToolSetting(options.model, {
-		transport: "stream",
-		supportsStrictMode: options.supportsStrictMode
-	});
-	return false;
+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 resolveResponsesStrictToolFlag(projection, strictSetting, model) {
-	const strict = resolveOpenAIProjectedToolsStrictToolFlag(projection, strictSetting);
-	if (strictSetting === true && strict === false && model) getAiTransportHost().logDebug(LOG_SUBSYSTEM, () => {
-		const diagnostics = findOpenAIStrictToolProjectionDiagnostics(projection);
-		if (!shouldLogStrictToolDowngradeDiagnostic(diagnostics, model)) return null;
-		const sample = diagnostics.slice(0, 5).map((entry) => ({
-			tool: entry.toolName ?? `tool[${entry.toolIndex}]`,
-			violations: entry.violations.slice(0, 8)
-		}));
-		return {
-			message: `OpenAI responses tool schema strict mode downgraded to strict=false for ${model.provider ?? "unknown"}/${model.id ?? "unknown"} because ${diagnostics.length} tool schema(s) are not strict-compatible`,
-			data: {
-				provider: model.provider,
-				model: model.id,
-				incompatibleToolCount: diagnostics.length,
-				sample
+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.some((block) => block.type !== "thinking")) 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, terminalEventType) => {
+		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
 			}
 		};
-	});
-	return strict;
-}
-function shouldLogStrictToolDowngradeDiagnostic(diagnostics, model) {
-	const key = createHash("sha256").update(JSON.stringify({
-		provider: model.provider,
-		model: model.id,
-		diagnostics: diagnostics.map((entry) => ({
-			toolIndex: entry.toolIndex,
-			toolName: entry.toolName ?? null,
-			violations: entry.violations
-		}))
-	})).digest("hex");
-	if (loggedStrictToolDowngradeDiagnosticKeys.has(key)) return false;
-	if (loggedStrictToolDowngradeDiagnosticKeys.size >= MAX_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS) loggedStrictToolDowngradeDiagnosticKeys.clear();
-	loggedStrictToolDowngradeDiagnosticKeys.add(key);
-	return true;
+		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,
+			terminalEventType,
+			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/providers/openai-responses-shared.ts
-const EMPTY_TOOL_RESULT_TEXT = "(no output)";
-function splitResponsesToolCallId(id) {
-	const separatorIndex = id.indexOf("|");
-	return separatorIndex === -1 ? [id, void 0] : [id.slice(0, separatorIndex), id.slice(separatorIndex + 1)];
-}
-function sanitizeToolResultText(text, fallback) {
-	const sanitized = sanitizeSurrogates(text);
-	return sanitized.trim().length > 0 ? sanitized : fallback;
-}
-function normalizeResponsesReasoningReplayItem(params) {
-	const next = { ...params.item };
-	if (!Array.isArray(next.summary)) next.summary = [];
-	if (!params.replayResponsesItemIds) delete next.id;
-	return next;
-}
-function parseTextSignature(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
+//#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: ""
 			};
-			return;
+			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;
 		}
-	} catch {}
-	return { id: signature };
-}
-function resolveReplayableResponsesMessageId(params) {
-	if (!params.textSignatureId) return params.fallbackOrdinal === 0 ? params.fallbackId : `${params.fallbackId}_${params.fallbackOrdinal}`;
-	return params.previousReplayItemWasReasoning ? params.textSignatureId : void 0;
-}
-function isResponsesReasoningEffort(effort) {
-	return effort === "minimal" || effort === "low" || effort === "medium" || effort === "high" || effort === "xhigh" || effort === "max";
-}
-function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
-	const messages = [];
-	const shouldReplayResponsesItemIds = options?.replayResponsesItemIds ?? true;
-	const normalizeIdPart = (part) => {
-		const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
-		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 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 normalizeToolCallId = (id, targetModel, source) => {
-		if (!allowedToolCallProviders.has(model.provider)) return normalizeIdPart(id);
-		if (!id.includes("|")) return normalizeIdPart(id);
-		const [callId, itemId = ""] = splitResponsesToolCallId(id);
-		const normalizedCallId = normalizeIdPart(callId);
-		let normalizedItemId = source.provider !== model.provider || source.api !== model.api ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
-		if (!normalizedItemId.startsWith("fc_")) normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
-		return `${normalizedCallId}|${normalizedItemId}`;
+	const getOrCreateOutputSlot = (event, item) => {
+		return resolveOutputItemSlot(event, item) ?? createOutputSlot(event, item);
 	};
-	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
-	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) {
-		const compat = model.compat;
-		const role = model.reasoning && compat?.supportsDeveloperRole !== false ? "developer" : "system";
-		messages.push({
-			type: "message",
-			role,
-			content: [{
-				type: "input_text",
-				text: sanitizeSurrogates(stripSystemPromptCacheBoundary(context.systemPrompt))
-			}]
+	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
 		});
-	}
-	let msgIndex = 0;
-	for (const msg of transformedMessages) {
-		if (msg.role === "user") if (typeof msg.content === "string") messages.push({
-			type: "message",
-			role: "user",
-			content: [{
-				type: "input_text",
-				text: sanitizeSurrogates(msg.content)
-			}]
+		if (text) stream.push({
+			type: "text_delta",
+			contentIndex: slot.contentIndex,
+			delta: text
 		});
-		else {
-			const content = msg.content.map((item) => {
-				if (item.type === "text") return {
-					type: "input_text",
-					text: sanitizeSurrogates(item.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 || ""
 				};
-				return {
-					type: "input_image",
-					detail: "auto",
-					image_url: `data:${item.mimeType};base64,${item.data}`
+				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
 			});
-			if (content.length === 0) continue;
-			messages.push({
-				type: "message",
-				role: "user",
-				content
+		} 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 (msg.role === "assistant") {
-			const output = [];
-			let textFallbackOrdinal = 0;
-			const assistantMsg = msg;
-			let previousReplayItemWasReasoning = false;
-			const isDifferentModel = assistantMsg.model !== model.id && assistantMsg.provider === model.provider && assistantMsg.api === model.api;
-			for (const block of msg.content) if (block.type === "thinking") {
-				if (block.thinkingSignature) {
-					const reasoningItem = normalizeResponsesReasoningReplayItem({
-						item: JSON.parse(block.thinkingSignature),
-						replayResponsesItemIds: shouldReplayResponsesItemIds
-					});
-					output.push(reasoningItem);
-					previousReplayItemWasReasoning = true;
-				}
-			} else if (block.type === "text") {
-				const textBlock = block;
-				const parsedSignature = parseTextSignature(textBlock.textSignature);
-				let msgId = shouldReplayResponsesItemIds ? resolveReplayableResponsesMessageId({
-					textSignatureId: parsedSignature?.id,
-					fallbackId: `msg_${msgIndex}`,
-					fallbackOrdinal: textFallbackOrdinal,
-					previousReplayItemWasReasoning
-				}) : void 0;
-				if (!parsedSignature?.id) textFallbackOrdinal += 1;
-				if (msgId && msgId.length > 64) msgId = `msg_${shortHash(msgId)}`;
-				const messageItem = {
-					type: "message",
-					role: "assistant",
-					content: [{
-						type: "output_text",
-						text: sanitizeSurrogates(textBlock.text),
-						annotations: []
-					}],
-					status: "completed",
-					...msgId ? { id: msgId } : {},
-					phase: parsedSignature?.phase
+		} 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: []
 				};
-				output.push(messageItem);
-				previousReplayItemWasReasoning = false;
-			} else if (block.type === "toolCall") {
-				const toolCall = block;
-				const [callId, itemIdRaw] = splitResponsesToolCallId(toolCall.id);
-				let itemId = shouldReplayResponsesItemIds ? itemIdRaw : void 0;
-				if (shouldReplayResponsesItemIds && isDifferentModel && itemId?.startsWith("fc_")) itemId = void 0;
-				output.push({
-					type: "function_call",
-					...itemId ? { id: itemId } : {},
-					call_id: callId,
-					name: toolCall.name,
-					arguments: JSON.stringify(toolCall.arguments)
+				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
 				});
-				previousReplayItemWasReasoning = false;
 			}
-			if (output.length === 0) continue;
-			messages.push(...output);
-		} else if (msg.role === "toolResult") {
-			const textResult = extractToolResultText(msg.content);
-			const sanitizedTextResult = sanitizeSurrogates(textResult);
-			const hasImages = msg.content.some(isImageWithMediaPayload);
-			const mediaPlaceholder = describeToolResultMediaPlaceholder(msg.content);
-			const hasText = sanitizedTextResult.trim().length > 0;
-			const [callId] = splitResponsesToolCallId(msg.toolCallId);
-			let output;
-			if (hasImages && model.input.includes("image")) {
-				const contentParts = [];
-				if (hasText) contentParts.push({
-					type: "input_text",
-					text: sanitizedTextResult
+		} 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 (mediaPlaceholder === "(see attached media)") contentParts.push({
-					type: "input_text",
-					text: mediaPlaceholder
+			} 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
 				});
-				for (const block of msg.content) if (isImageWithMediaPayload(block)) contentParts.push({
-					type: "input_image",
-					detail: "auto",
-					image_url: `data:${block.mimeType};base64,${block.data}`
+				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
 				});
-				output = contentParts;
-			} else output = sanitizeToolResultText(textResult, mediaPlaceholder ?? EMPTY_TOOL_RESULT_TEXT);
-			messages.push({
-				type: "function_call_output",
-				call_id: callId,
-				output
-			});
-		}
-		msgIndex++;
-	}
-	return messages;
-}
-function createResponsesAssistantOutput(model, api = model.api) {
-	return {
-		role: "assistant",
-		content: [],
-		api,
-		provider: model.provider,
-		model: model.id,
-		usage: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 0,
-			cost: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				total: 0
 			}
-		},
-		stopReason: "stop",
-		timestamp: Date.now()
-	};
-}
-function resolveResponsesReasoningEffort(model, reasoning) {
-	const clampedReasoning = reasoning ? clampThinkingLevel(model, reasoning) : void 0;
-	if (!clampedReasoning || clampedReasoning === "off") return;
-	if (clampedReasoning === "max") return supportsOpenAIReasoningEffort(model, "max") ? "max" : "xhigh";
-	if (clampedReasoning === "minimal" && model.provider === "openai" && supportsOpenAIReasoningEffort(model, "max")) {
-		const effort = resolveOpenAIReasoningEffortForModel({
-			model,
-			effort: "minimal"
-		});
-		return isResponsesReasoningEffort(effort) ? effort : void 0;
-	}
-	return clampedReasoning;
-}
-function applyCommonResponsesParams(params, model, context, options, config) {
-	if (options?.maxTokens) params.max_output_tokens = Math.max(options.maxTokens, 16);
-	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
-	if (context.tools) {
-		const converted = convertResponsesToolPayload(context.tools, { model });
-		if (converted.tools.length > 0) params.tools = converted.tools;
-	}
-	if (!model.reasoning) return;
-	if (options?.reasoningEffort || options?.reasoningSummary) {
-		params.reasoning = {
-			effort: options?.reasoningEffort ? model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort : "medium",
-			summary: options?.reasoningSummary || "auto"
-		};
-		params.include = ["reasoning.encrypted_content"];
-	} else if ((config?.setDefaultReasoningOff ?? true) && model.thinkingLevelMap?.off !== null) params.reasoning = { effort: model.thinkingLevelMap?.off ?? "none" };
-}
-function buildResponsesRequestOptions(options) {
-	return {
-		...options?.signal ? { signal: options.signal } : {},
-		...options?.timeoutMs !== void 0 ? { timeout: options.timeoutMs } : {},
-		maxRetries: options?.maxRetries ?? 0
-	};
-}
-function cleanStreamingScratchBuffers(output) {
-	for (const block of output.content) {
-		delete block.index;
-		delete block.partialJson;
-	}
-}
-async function runResponsesStreamLifecycle(params) {
-	const { stream, model, output, options } = params;
-	let firstEventAbort;
-	try {
-		const client = params.createClient();
-		let requestParams = params.buildParams();
-		const nextParams = await options?.onPayload?.(requestParams, model);
-		if (nextParams !== void 0) requestParams = nextParams;
-		firstEventAbort = createFirstStreamEventAbortController(options?.signal);
-		const { data: openaiStream, response } = await client.responses.create(requestParams, {
-			...buildResponsesRequestOptions(options),
-			signal: firstEventAbort.signal
-		}).withResponse();
-		await options?.onResponse?.({
-			status: response.status,
-			headers: headersToRecord(response.headers)
-		}, model);
-		stream.push({
-			type: "start",
-			partial: output
-		});
-		const firstEventTimeoutMs = getFirstStreamEventTimeoutMs(options);
-		const onFirstEventTimeout = getFirstStreamEventTimeoutHandler(options);
-		await processResponsesStream(openaiStream, output, stream, model, params.processStreamOptions || firstEventTimeoutMs !== void 0 || onFirstEventTimeout !== void 0 ? {
-			...params.processStreamOptions,
-			firstEventTimeoutMs: params.processStreamOptions?.firstEventTimeoutMs ?? firstEventTimeoutMs,
-			abortFirstEventStream: params.processStreamOptions?.abortFirstEventStream ?? firstEventAbort.abort,
-			onFirstEventTimeout: params.processStreamOptions?.onFirstEventTimeout ?? onFirstEventTimeout,
-			signal: params.processStreamOptions?.signal ?? options?.signal
-		} : void 0);
-		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",
-			reason: output.stopReason,
-			message: output
-		});
-		stream.end();
-	} catch (error) {
-		cleanStreamingScratchBuffers(output);
-		output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-		output.errorMessage = params.formatError(error);
-		stream.push({
-			type: "error",
-			reason: output.stopReason,
-			error: output
-		});
-		stream.end();
+		} 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, event.type);
+			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 {
-		firstEventAbort?.dispose();
-	}
-}
-//#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
-	};
-}
-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
-	});
-	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
-		});
-		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;
+		for (const block of output.content) delete block.partialJson;
 	}
 }
-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 { 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 };
+export { normalizeOpenAIStrictCompatSchema as $, normalizeResponsesFailedEvent as A, resolveReplayableResponsesMessageId as B, prepareOpenAIResponsesReasoningItemForReplay as C, applyServiceTierPricing as D, tagOpenAIResponsesReasoningReplayItem as E, summarizeResponsesFailedNoDetailsObservation as F, throwIfModelStreamAborted as G, createModelStreamCooperativeScheduler as H, summarizeResponsesPayload as I, isStrictOpenAIJsonSchemaCompatible as J, clearOpenAIToolSchemaCacheForTest as K, summarizeResponsesTools as L, stringifyRedactedEvent as M, stringifyRedactedPayload as N, buildResponsesFailedNoDetailsObservation as O, summarizeOpenAITransportError as P, findOpenAIStrictSchemaViolations as Q, AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS as R, isInvalidEncryptedContentError as S, stripResponsesRequestEncryptedContent as T, log as U, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as V, resolvePromptCacheKey as W, normalizeStrictOpenAIJsonSchema as X, normalizeOpenAIStrictToolParameters as Y, resolveOpenAIProjectedToolsStrictToolFlag as Z, resolveResponsesMessageSnapshotCollapse as _, supportsOpenAITemperature as _t, resolveResponsesTerminalStopReason as a, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD as at, convertResponsesMessages as b, resolveModelPayloadDebugMode as bt, readResponsesToolCallItemIdentity as c, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as ct, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as d, isOpenAIGpt55Model as dt, extractToolSchemaModelCompat as et, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as f, isOpenAIGpt56Model as ft, isResponsesTextDeltaEventType as g, supportsOpenAIReasoningEffort as gt, isResponsesTextContentPartType as h, resolveOpenAISupportedReasoningEfforts as ht, readResponsesReasoningTokens as i, stripUnsupportedSchemaKeywords as it, safeDebugValue as j, logResponsesFailedNoDetails as k, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as l, cleanSchemaForGemini as lt, isAzureResponsesTextDeltaEventType as m, resolveOpenAIReasoningEffortForModel as mt, processResponsesStream as n, resolveUnsupportedToolSchemaKeywords as nt, observeResponsesStream as o, cleanSchemaForLlamacppGbnf as ot, isAzureResponsesTextDeltaEvent as p, normalizeOpenAIReasoningEffort as pt, findOpenAIStrictToolProjectionDiagnostics as q, mapResponsesTerminalUsage as r, shouldOmitEmptyArrayItems as rt, createResponsesToolCallTracker as s, findLlamacppGbnfSchemaViolations as st, ResponsesStreamFailure as t, normalizeToolParameterSchema as tt, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as u, isOpenAIGpt54MiniModel as ut, buildOpenAIResponsesReasoningReplayMetadata as v, uniqueStrings as vt, resolveAzureOpenAIApiVersion as w, createResponsesStreamWithEncryptedContentRetry as x, resolveModelSseDebugMode as xt, buildResponsesInputMessage as y, emitModelTransportDebug as yt, OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS as z };