@openclaw/ai 2026.8.1-beta.3 → 2026.8.2

package/dist/{openai-responses-shared-Cvt5MgEm.mjs → openai-responses-shared-CxgdGBvm.mjs}

@@ -1,20 +1,19 @@
-import { a as normalizeOptionalString, n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
-import { i as clampThinkingLevel, r as calculateCost } from "./sanitize-unicode-BP7HLLZn.mjs";
-import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
-import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
-import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
-import { n as projectProviderError } from "./provider-error-C8mBRJDl.mjs";
-import { t as asFiniteNumber } from "./number-coercion-H9qHik3g.mjs";
-import { C as normalizeStringEntries, S as supportsOpenAITemperature, T as uniqueValues, a as OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE, c as OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE, f as RESPONSE_FAILED_NO_DETAILS_MESSAGE, o as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, s as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY, x as supportsOpenAIReasoningEffort, y as resolveOpenAIReasoningEffortForModel } from "./openai-responses-contracts-DvILoqBk.mjs";
-import { C as withProviderResponseHook, P as sortPromptCacheToolsByName, b as sanitizeTransportPayloadText, j as stripSystemPromptCacheBoundary, v as parseTerminalToolCallArguments, x as transportAbortError, y as sanitizeNonEmptyTransportPayloadText } from "./simple-options-oqsXB6U3.mjs";
-import { c as transformTransportMessages } from "./tool-schema-json-projection-FEr-jOoZ.mjs";
-import { n as parseStreamingJson } from "./json-parse-CDnesDM_.mjs";
+import { c as normalizeLowercaseStringOrEmpty, d as normalizeOptionalString, o as isRecord, t as truncateUtf16Safe } from "./utf16-slice-qz3nsy87.mjs";
+import { i as clampThinkingLevel, r as calculateCost } from "./sanitize-unicode-S6binQG-.mjs";
+import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, n as getAiTransportHost } from "./host-BIaiBURL.mjs";
+import { n as projectProviderError } from "./provider-error-BI8kIViN.mjs";
+import { r as asFiniteNumber } from "./base64-CEFBpSkN.mjs";
+import { d as stripSystemPromptCacheBoundary, m as sortPromptCacheToolsByName } from "./simple-options-rdOPzr7Z.mjs";
+import { c as transformTransportMessages } from "./tool-schema-json-projection-BtZiml7r.mjs";
+import { d as redactSensitiveText, u as redactIdentifier } from "./transport-utils-CtuS1Upe.mjs";
+import { _ as transportAbortError, g as sanitizeTransportPayloadText, h as sanitizeNonEmptyTransportPayloadText, m as parseTerminalToolCallArguments, y as withProviderResponseHook } from "./transport-stream-shared-D8nQWCUo.mjs";
+import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-BuAJEbdW.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
 import { t as shortHash } from "./hash-CHgqbJmD.mjs";
-import { l as redactIdentifier, u as redactSensitiveText } from "./transport-utils-Bv0FHkd0.mjs";
-import { a as createModelStreamCooperativeScheduler, l as log, o as createOpenAIProviderAcceptanceHook, t as projectOpenAITools } from "./openai-tool-projection-CHGLt03m.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.mjs";
-import { t as transformProviderMessages } from "./provider-transcript-transform--gtf0ZbR.mjs";
+import { C as createOpenAIProviderAcceptanceHook, E as log, S as createModelStreamCooperativeScheduler, a as resolveOpenAIProjectedToolsStrictToolFlag, r as normalizeOpenAIStrictToolParameters, t as findOpenAIStrictToolProjectionDiagnostics, v as projectOpenAITools } from "./openai-tool-schema-CSMh5e9O.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DcNjoFQE.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform-WvJmFUAf.mjs";
+import { A as supportsOpenAITemperature, D as resolveOpenAIReasoningEffortForModel, b as RESPONSE_FAILED_NO_DETAILS_MESSAGE, g as OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE, h as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY, k as supportsOpenAIReasoningEffort, m as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, n as isOpenAIResponsesCompactionOutput, p as OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE, r as readOpenAIResponsesCompactionWindow } from "./openai-responses-compaction-window-DO7yV7az.mjs";
 import { createHash, randomUUID } from "node:crypto";
 //#region packages/ai/src/transports/model-transport-debug.ts
 /**
@@ -57,1270 +56,6 @@ function emitModelTransportDebug(log, message) {
 	log.debug(message);
 }
 //#endregion
-//#region packages/ai/src/providers/clean-for-gemini.ts
-const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
-	"patternProperties",
-	"additionalProperties",
-	"$schema",
-	"$id",
-	"$ref",
-	"$defs",
-	"definitions",
-	"examples",
-	"minLength",
-	"maxLength",
-	"minimum",
-	"maximum",
-	"multipleOf",
-	"pattern",
-	"format",
-	"minItems",
-	"maxItems",
-	"uniqueItems",
-	"minProperties",
-	"maxProperties",
-	"not"
-]);
-const SCHEMA_META_KEYS = [
-	"description",
-	"title",
-	"default"
-];
-function copySchemaMeta$1(from, to) {
-	for (const key of SCHEMA_META_KEYS) if (key in from && from[key] !== void 0) to[key] = from[key];
-}
-function stringifyGeminiEnumValue(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" && Number.isFinite(value)) return String(value);
-	if (typeof value === "boolean") return String(value);
-}
-function cleanGeminiEnumValues(value) {
-	if (!Array.isArray(value)) return;
-	const values = value.flatMap((entry) => {
-		const stringified = stringifyGeminiEnumValue(entry);
-		return stringified === void 0 ? [] : [stringified];
-	});
-	const unique = [...new Set(values)];
-	return unique.length > 0 ? unique : void 0;
-}
-function tryFlattenLiteralAnyOf(variants) {
-	if (variants.length === 0) return null;
-	const allValues = [];
-	let commonType = null;
-	for (const variant of variants) {
-		if (!variant || typeof variant !== "object") return null;
-		const v = variant;
-		let literalValue;
-		if ("const" in v) literalValue = v.const;
-		else if (Array.isArray(v.enum) && v.enum.length === 1) literalValue = v.enum[0];
-		else return null;
-		const variantType = typeof v.type === "string" ? v.type : null;
-		if (!variantType) return null;
-		if (commonType === null) commonType = variantType;
-		else if (commonType !== variantType) return null;
-		allValues.push(literalValue);
-	}
-	if (commonType && allValues.length > 0) return {
-		type: commonType,
-		enum: allValues
-	};
-	return null;
-}
-function isNullSchema(variant) {
-	if (!variant || typeof variant !== "object" || Array.isArray(variant)) return false;
-	const record = variant;
-	if ("const" in record && record.const === null) return true;
-	if (Array.isArray(record.enum) && record.enum.length === 1) return record.enum[0] === null;
-	const typeValue = record.type;
-	if (typeValue === "null") return true;
-	if (Array.isArray(typeValue) && typeValue.length === 1 && typeValue[0] === "null") return true;
-	return false;
-}
-function stripNullVariants(variants) {
-	if (variants.length === 0) return {
-		variants,
-		stripped: false
-	};
-	const nonNull = variants.filter((variant) => !isNullSchema(variant));
-	return {
-		variants: nonNull,
-		stripped: nonNull.length !== variants.length
-	};
-}
-function extendSchemaDefs$1(defs, schema) {
-	const defsEntry = schema.$defs && typeof schema.$defs === "object" && !Array.isArray(schema.$defs) ? schema.$defs : void 0;
-	const legacyDefsEntry = schema.definitions && typeof schema.definitions === "object" && !Array.isArray(schema.definitions) ? schema.definitions : void 0;
-	if (!defsEntry && !legacyDefsEntry) return defs;
-	const next = defs ? new Map(defs) : /* @__PURE__ */ new Map();
-	if (defsEntry) for (const [key, value] of Object.entries(defsEntry)) next.set(key, value);
-	if (legacyDefsEntry) for (const [key, value] of Object.entries(legacyDefsEntry)) next.set(key, value);
-	return next;
-}
-function decodeJsonPointerSegment$1(segment) {
-	return segment.replaceAll("~1", "/").replaceAll("~0", "~");
-}
-function tryResolveLocalRef$1(ref, defs) {
-	if (!defs) return;
-	const match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
-	if (!match) return;
-	const name = decodeJsonPointerSegment$1(match[1] ?? "");
-	if (!name) return;
-	return defs.get(name);
-}
-function simplifyUnionVariants(params) {
-	const { obj, variants } = params;
-	const { variants: nonNullVariants, stripped } = stripNullVariants(variants);
-	const flattened = tryFlattenLiteralAnyOf(nonNullVariants);
-	if (flattened) {
-		const result = {
-			type: flattened.type,
-			enum: flattened.enum
-		};
-		copySchemaMeta$1(obj, result);
-		return {
-			kind: "simplified",
-			value: result
-		};
-	}
-	if (stripped && nonNullVariants.length === 1) {
-		const lone = nonNullVariants[0];
-		if (lone && typeof lone === "object" && !Array.isArray(lone)) {
-			const result = { ...lone };
-			copySchemaMeta$1(obj, result);
-			return {
-				kind: "simplified",
-				value: result
-			};
-		}
-		return {
-			kind: "simplified",
-			value: lone
-		};
-	}
-	return {
-		kind: "variants",
-		value: stripped ? nonNullVariants : variants
-	};
-}
-function sanitizeRequiredFields(schema) {
-	if (!Array.isArray(schema.required)) return schema;
-	if (!schema.properties || typeof schema.properties !== "object" || Array.isArray(schema.properties)) {
-		if (schema.type === "object") delete schema.required;
-		return schema;
-	}
-	const properties = schema.properties;
-	const required = schema.required.filter((key) => typeof key === "string" && Object.hasOwn(properties, key));
-	if (required.length > 0) schema.required = required;
-	else delete schema.required;
-	return schema;
-}
-function cleanSchemaForGeminiWithDefs(schema, defs, refStack) {
-	if (!schema || typeof schema !== "object") return schema;
-	if (Array.isArray(schema)) return schema.map((item) => cleanSchemaForGeminiWithDefs(item, defs, refStack));
-	const obj = schema;
-	const nextDefs = extendSchemaDefs$1(defs, obj);
-	const refValue = typeof obj.$ref === "string" ? obj.$ref : void 0;
-	if (refValue) {
-		if (refStack?.has(refValue)) return {};
-		const resolved = tryResolveLocalRef$1(refValue, nextDefs);
-		if (resolved) {
-			const nextRefStack = refStack ? new Set(refStack) : /* @__PURE__ */ new Set();
-			nextRefStack.add(refValue);
-			const cleaned = cleanSchemaForGeminiWithDefs(resolved, nextDefs, nextRefStack);
-			if (!cleaned || typeof cleaned !== "object" || Array.isArray(cleaned)) return cleaned;
-			const result = { ...cleaned };
-			copySchemaMeta$1(obj, result);
-			return result;
-		}
-		const result = {};
-		copySchemaMeta$1(obj, result);
-		return result;
-	}
-	const hasAnyOf = "anyOf" in obj && Array.isArray(obj.anyOf);
-	const hasOneOf = "oneOf" in obj && Array.isArray(obj.oneOf);
-	let cleanedAnyOf = hasAnyOf ? obj.anyOf.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack)) : void 0;
-	let cleanedOneOf = hasOneOf ? obj.oneOf.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack)) : void 0;
-	if (hasAnyOf) {
-		const simplified = simplifyUnionVariants({
-			obj,
-			variants: cleanedAnyOf ?? []
-		});
-		if (simplified.kind === "simplified") return simplified.value;
-		cleanedAnyOf = simplified.value;
-	}
-	if (hasOneOf) {
-		const simplified = simplifyUnionVariants({
-			obj,
-			variants: cleanedOneOf ?? []
-		});
-		if (simplified.kind === "simplified") return simplified.value;
-		cleanedOneOf = simplified.value;
-	}
-	const cleaned = {};
-	for (const [key, value] of Object.entries(obj)) {
-		if (GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS.has(key)) continue;
-		if (key === "const") {
-			const enumValues = cleanGeminiEnumValues([value]);
-			if (enumValues) cleaned.enum = enumValues;
-			continue;
-		}
-		if (key === "enum") {
-			const enumValues = cleanGeminiEnumValues(value);
-			if (enumValues) cleaned.enum = enumValues;
-			continue;
-		}
-		if (key === "required" && Array.isArray(value) && value.length === 0) continue;
-		if (key === "type" && (hasAnyOf || hasOneOf)) continue;
-		if (key === "type" && Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
-			const types = value.filter((entry) => entry !== "null");
-			cleaned.type = types.length === 1 ? types[0] : types;
-			continue;
-		}
-		if (key === "properties") if (value && typeof value === "object" && !Array.isArray(value)) cleaned[key] = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, cleanSchemaForGeminiWithDefs(v, nextDefs, refStack)]));
-		else cleaned[key] = {};
-		else if (key === "items" && value) if (Array.isArray(value)) cleaned[key] = value.map((entry) => cleanSchemaForGeminiWithDefs(entry, nextDefs, refStack));
-		else if (typeof value === "object") cleaned[key] = cleanSchemaForGeminiWithDefs(value, nextDefs, refStack);
-		else cleaned[key] = value;
-		else if (key === "anyOf" && Array.isArray(value)) cleaned[key] = cleanedAnyOf ?? value.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack));
-		else if (key === "oneOf" && Array.isArray(value)) cleaned[key] = cleanedOneOf ?? value.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack));
-		else if (key === "allOf" && Array.isArray(value)) cleaned[key] = value.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack));
-		else cleaned[key] = value;
-	}
-	if (cleaned.anyOf && Array.isArray(cleaned.anyOf)) {
-		const flattened = flattenUnionFallback(cleaned, cleaned.anyOf);
-		if (flattened) return sanitizeRequiredFields(flattened);
-	}
-	if (cleaned.oneOf && Array.isArray(cleaned.oneOf)) {
-		const flattened = flattenUnionFallback(cleaned, cleaned.oneOf);
-		if (flattened) return sanitizeRequiredFields(flattened);
-	}
-	return sanitizeRequiredFields(cleaned);
-}
-/**
-* Last-resort flattening for anyOf/oneOf arrays that could not be simplified
-* by `simplifyUnionVariants`. Picks a representative type so the schema is
-* accepted by Google's restricted JSON Schema validation.
-*/
-function flattenUnionFallback(obj, variants) {
-	const objects = variants.filter((v) => Boolean(v) && typeof v === "object");
-	if (objects.length === 0) return;
-	const types = new Set(objects.map((v) => v.type).filter(Boolean));
-	if (objects.length === 1) {
-		const merged = { ...objects[0] };
-		copySchemaMeta$1(obj, merged);
-		return merged;
-	}
-	if (types.size === 1) {
-		const merged = { type: Array.from(types)[0] };
-		copySchemaMeta$1(obj, merged);
-		return merged;
-	}
-	const first = objects[0];
-	if (first?.type) {
-		const merged = { type: first.type };
-		copySchemaMeta$1(obj, merged);
-		return merged;
-	}
-	const merged = {};
-	copySchemaMeta$1(obj, merged);
-	return merged;
-}
-function cleanSchemaForGemini(schema) {
-	if (!schema || typeof schema !== "object") return schema;
-	if (Array.isArray(schema)) return schema.map(cleanSchemaForGemini);
-	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 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 (!isRecord(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) && isRecord(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 (!isRecord(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) && isRecord(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;
-	if (Array.isArray(schema)) return schema.map((entry) => stripUnsupportedSchemaKeywords(entry, unsupportedKeywords));
-	const obj = schema;
-	const cleaned = {};
-	for (const [key, value] of Object.entries(obj)) {
-		if (unsupportedKeywords.has(key)) continue;
-		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 (SCHEMA_ARRAY_KEYS$1.has(key) && Array.isArray(value)) {
-			cleaned[key] = value.map((entry) => stripUnsupportedSchemaKeywords(entry, unsupportedKeywords));
-			continue;
-		}
-		if (SCHEMA_OBJECT_KEYS$1.has(key) && value && typeof value === "object") {
-			cleaned[key] = stripUnsupportedSchemaKeywords(value, unsupportedKeywords);
-			continue;
-		}
-		cleaned[key] = value;
-	}
-	return cleaned;
-}
-//#endregion
-//#region packages/ai/src/providers/agent-tools-parameter-schema.ts
-/**
-* Normalizes model-facing tool parameter schemas across provider quirks.
-* Handles local JSON Schema refs, OpenAPI nullable syntax, top-level unions,
-* and provider-specific unsupported keyword stripping.
-*/
-/** Extracts the compat record whether callers pass a model (`{ compat }`) or the compat itself. */
-function extractToolSchemaModelCompat(modelOrCompat) {
-	if (!modelOrCompat || typeof modelOrCompat !== "object") return;
-	if ("compat" in modelOrCompat) {
-		const compat = modelOrCompat.compat;
-		return compat && typeof compat === "object" ? compat : void 0;
-	}
-	return modelOrCompat;
-}
-/** JSON Schema keywords this model/provider rejects in tool schemas. */
-function resolveUnsupportedToolSchemaKeywords(modelOrCompat) {
-	const keywords = extractToolSchemaModelCompat(modelOrCompat)?.unsupportedToolSchemaKeywords ?? [];
-	return new Set(normalizeStringEntries(keywords.filter((keyword) => typeof keyword === "string")));
-}
-/** Whether empty `items: {}` on array schemas must be omitted for this model/provider. */
-function shouldOmitEmptyArrayItems(modelOrCompat) {
-	return extractToolSchemaModelCompat(modelOrCompat)?.omitEmptyArrayItems === true;
-}
-const MAX_TOOL_PARAMETER_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
-const toolParameterSchemaCache = /* @__PURE__ */ new WeakMap();
-function resolveToolParameterSchemaCacheKey(options) {
-	const normalizedProvider = normalizeLowercaseStringOrEmpty(options?.modelProvider);
-	const normalizedModelId = normalizeLowercaseStringOrEmpty(options?.modelId);
-	const toolSchemaProfile = normalizeLowercaseStringOrEmpty(options?.modelCompat?.toolSchemaProfile);
-	const unsupportedKeywords = Array.from(resolveUnsupportedToolSchemaKeywords(options?.modelCompat)).toSorted();
-	const omitEmptyArrayItems = shouldOmitEmptyArrayItems(options?.modelCompat);
-	return JSON.stringify([
-		normalizedProvider,
-		normalizedModelId,
-		toolSchemaProfile,
-		unsupportedKeywords,
-		omitEmptyArrayItems
-	]);
-}
-function getCachedToolParameterSchema(schema, key) {
-	return toolParameterSchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
-}
-function rememberCachedToolParameterSchema(schema, key, value) {
-	const entries = toolParameterSchemaCache.get(schema) ?? [];
-	toolParameterSchemaCache.set(schema, [{
-		key,
-		value
-	}, ...entries.filter((entry) => entry.key !== key)].slice(0, MAX_TOOL_PARAMETER_SCHEMA_CACHE_ENTRIES_PER_SCHEMA));
-	return value;
-}
-function isGeminiModelId(modelId) {
-	return /(?:^|[/:])gemini(?:$|[-/:.])/.test(modelId);
-}
-function extractEnumValues(schema) {
-	if (!schema || typeof schema !== "object") return;
-	const record = schema;
-	if (Array.isArray(record.enum)) return record.enum;
-	if ("const" in record) return [record.const];
-	const variants = Array.isArray(record.anyOf) ? record.anyOf : Array.isArray(record.oneOf) ? record.oneOf : null;
-	if (variants) {
-		const values = variants.flatMap((variant) => {
-			return extractEnumValues(variant) ?? [];
-		});
-		return values.length > 0 ? values : void 0;
-	}
-}
-function mergePropertySchemas(existing, incoming) {
-	if (!existing) return incoming;
-	if (!incoming) return existing;
-	const existingEnum = extractEnumValues(existing);
-	const incomingEnum = extractEnumValues(incoming);
-	if (existingEnum || incomingEnum) {
-		const values = uniqueValues([...existingEnum ?? [], ...incomingEnum ?? []]);
-		const merged = {};
-		for (const source of [existing, incoming]) {
-			if (!source || typeof source !== "object") continue;
-			const record = source;
-			for (const key of [
-				"title",
-				"description",
-				"default"
-			]) if (!(key in merged) && key in record) merged[key] = record[key];
-		}
-		const types = new Set(values.map((value) => typeof value));
-		if (types.size === 1) merged.type = Array.from(types)[0];
-		merged.enum = values;
-		return merged;
-	}
-	return existing;
-}
-function setOwnSchemaProperty(target, key, value) {
-	Object.defineProperty(target, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-}
-function hasTopLevelArrayKeyword(schemaRecord, key) {
-	return Array.isArray(schemaRecord[key]);
-}
-function getFlattenableVariantKey(schemaRecord) {
-	if (hasTopLevelArrayKeyword(schemaRecord, "anyOf")) return "anyOf";
-	if (hasTopLevelArrayKeyword(schemaRecord, "oneOf")) return "oneOf";
-	return null;
-}
-function getTopLevelConditionalKey(schemaRecord) {
-	return getFlattenableVariantKey(schemaRecord) ?? (hasTopLevelArrayKeyword(schemaRecord, "allOf") ? "allOf" : null);
-}
-function hasTopLevelObjectSchema(schemaRecord, conditionalKey) {
-	return schemaRecord.type === "object" && isRecord(schemaRecord.properties) && conditionalKey === null;
-}
-function isObjectLikeSchemaMissingType(schemaRecord, conditionalKey) {
-	return !("type" in schemaRecord) && (isRecord(schemaRecord.properties) || Array.isArray(schemaRecord.required)) && conditionalKey === null;
-}
-function isTypedObjectSchemaMissingValidProperties(schemaRecord, conditionalKey) {
-	return schemaRecord.type === "object" && !isRecord(schemaRecord.properties) && conditionalKey === null;
-}
-function isTrulyEmptySchema(schemaRecord) {
-	return Object.keys(schemaRecord).length === 0;
-}
-function normalizeArraySchemasMissingItems(schema) {
-	if (!isRecord(schema)) return schema;
-	let changed = false;
-	const nextSchema = { ...schema };
-	if (nextSchema.type === "array" && nextSchema.items === void 0) {
-		nextSchema.items = {};
-		changed = true;
-	}
-	const normalizeSchemaValue = (key) => {
-		if (!(key in nextSchema)) return;
-		const value = nextSchema[key];
-		if (Array.isArray(value)) {
-			const normalized = value.map(normalizeArraySchemasMissingItems);
-			if (normalized.some((entry, index) => entry !== value[index])) {
-				nextSchema[key] = normalized;
-				changed = true;
-			}
-			return;
-		}
-		const normalized = normalizeArraySchemasMissingItems(value);
-		if (normalized !== value) {
-			nextSchema[key] = normalized;
-			changed = true;
-		}
-	};
-	for (const key of [
-		"items",
-		"contains",
-		"additionalProperties",
-		"propertyNames",
-		"not",
-		"if",
-		"then",
-		"else"
-	]) normalizeSchemaValue(key);
-	for (const key of [
-		"anyOf",
-		"oneOf",
-		"allOf",
-		"prefixItems"
-	]) normalizeSchemaValue(key);
-	for (const key of [
-		"properties",
-		"patternProperties",
-		"dependentSchemas",
-		"$defs",
-		"definitions"
-	]) {
-		const value = nextSchema[key];
-		if (!isRecord(value)) continue;
-		let entriesChanged = false;
-		const normalizedEntries = Object.entries(value).map(([entryKey, entryValue]) => {
-			const normalizedEntryValue = normalizeArraySchemasMissingItems(entryValue);
-			if (normalizedEntryValue !== entryValue) entriesChanged = true;
-			return [entryKey, normalizedEntryValue];
-		});
-		if (entriesChanged) {
-			nextSchema[key] = Object.fromEntries(normalizedEntries);
-			changed = true;
-		}
-	}
-	return changed ? nextSchema : schema;
-}
-function schemaAllowsArrayType(schema) {
-	const type = schema.type;
-	return type === "array" || Array.isArray(type) && type.includes("array");
-}
-const ARRAY_ITEMS_SCHEMA_OBJECT_KEYS = /* @__PURE__ */ new Set([
-	"additionalProperties",
-	"contains",
-	"else",
-	"if",
-	"items",
-	"not",
-	"propertyNames",
-	"then"
-]);
-const ARRAY_ITEMS_SCHEMA_ARRAY_KEYS = /* @__PURE__ */ new Set([
-	"allOf",
-	"anyOf",
-	"oneOf",
-	"prefixItems"
-]);
-const ARRAY_ITEMS_SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
-	"$defs",
-	"definitions",
-	"dependentSchemas",
-	"patternProperties",
-	"properties"
-]);
-function stripEmptyArrayItemsFromArraySchemas(schema) {
-	if (Array.isArray(schema)) {
-		let changed = false;
-		const entries = schema.map((entry) => {
-			const next = stripEmptyArrayItemsFromArraySchemas(entry);
-			changed ||= next !== entry;
-			return next;
-		});
-		return changed ? entries : schema;
-	}
-	if (!isRecord(schema)) return schema;
-	let changed = false;
-	const entries = Object.entries(schema).flatMap(([key, value]) => {
-		if (key === "items" && schemaAllowsArrayType(schema) && isRecord(value) && isTrulyEmptySchema(value)) {
-			changed = true;
-			return [];
-		}
-		if (ARRAY_ITEMS_SCHEMA_OBJECT_KEYS.has(key)) {
-			const next = stripEmptyArrayItemsFromArraySchemas(value);
-			changed ||= next !== value;
-			return [[key, next]];
-		}
-		if (ARRAY_ITEMS_SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
-			const next = stripEmptyArrayItemsFromArraySchemas(value);
-			changed ||= next !== value;
-			return [[key, next]];
-		}
-		if (ARRAY_ITEMS_SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
-			let mapChanged = false;
-			const next = Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => {
-				const entryNext = stripEmptyArrayItemsFromArraySchemas(entryValue);
-				mapChanged ||= entryNext !== entryValue;
-				return [entryKey, entryNext];
-			}));
-			changed ||= mapChanged;
-			return [[key, mapChanged ? next : value]];
-		}
-		return [[key, value]];
-	});
-	return changed ? Object.fromEntries(entries) : schema;
-}
-function copySchemaMeta(from, to) {
-	for (const key of [
-		"title",
-		"description",
-		"default"
-	]) if (key in from && from[key] !== void 0) to[key] = from[key];
-}
-function extendSchemaDefs(defs, schema) {
-	const defsEntry = schema.$defs && typeof schema.$defs === "object" && !Array.isArray(schema.$defs) ? schema.$defs : void 0;
-	const legacyDefsEntry = schema.definitions && typeof schema.definitions === "object" && !Array.isArray(schema.definitions) ? schema.definitions : void 0;
-	if (!defsEntry && !legacyDefsEntry) return defs;
-	const next = defs ? {
-		$defs: new Map(defs.$defs),
-		definitions: new Map(defs.definitions)
-	} : {
-		$defs: /* @__PURE__ */ new Map(),
-		definitions: /* @__PURE__ */ new Map()
-	};
-	if (defsEntry) for (const [key, value] of Object.entries(defsEntry)) next.$defs.set(key, value);
-	if (legacyDefsEntry) for (const [key, value] of Object.entries(legacyDefsEntry)) next.definitions.set(key, value);
-	return next;
-}
-function decodeJsonPointerSegment(segment) {
-	return segment.replaceAll("~1", "/").replaceAll("~0", "~");
-}
-function resolveJsonPointerPath(value, segments) {
-	let current = value;
-	for (const segment of segments) {
-		if (!current || typeof current !== "object") return;
-		const key = decodeJsonPointerSegment(segment);
-		if (Array.isArray(current)) {
-			const index = /^(?:0|[1-9]\d*)$/.test(key) ? Number(key) : -1;
-			if (index < 0 || index >= current.length) return;
-			current = current[index];
-			continue;
-		}
-		const record = current;
-		if (!Object.hasOwn(record, key)) return;
-		current = record[key];
-	}
-	return current;
-}
-function resolveLocalJsonPointer(rootDocument, ref) {
-	if (!ref.startsWith("#/")) return;
-	return resolveJsonPointerPath(rootDocument, ref.slice(2).split("/"));
-}
-const SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
-	"$defs",
-	"definitions",
-	"dependentSchemas",
-	"patternProperties",
-	"properties"
-]);
-const SCHEMA_OBJECT_KEYS = /* @__PURE__ */ new Set([
-	"additionalProperties",
-	"contains",
-	"else",
-	"if",
-	"items",
-	"not",
-	"propertyNames",
-	"then"
-]);
-const SCHEMA_ARRAY_KEYS = /* @__PURE__ */ new Set([
-	"allOf",
-	"anyOf",
-	"items",
-	"oneOf",
-	"prefixItems"
-]);
-const SCHEMA_LITERAL_KEYS = /* @__PURE__ */ new Set([
-	"const",
-	"default",
-	"enum",
-	"examples"
-]);
-function tryResolveLocalRef(ref, defs, rootDocument) {
-	const match = ref.match(/^#\/(\$defs|definitions)\/([^/]+)(?:\/(.*))?$/);
-	if (match && defs) {
-		const namespace = match[1] === "$defs" ? defs.$defs : defs.definitions;
-		const name = decodeJsonPointerSegment(match[2] ?? "");
-		const resolved = name ? namespace.get(name) : void 0;
-		if (resolved !== void 0) return resolveJsonPointerPath(resolved, match[3] ? match[3].split("/") : []);
-	}
-	return resolveLocalJsonPointer(rootDocument, ref);
-}
-function inlineLocalSchemaRefsWithDefs(schema, defs, refStack, state, rootDocument) {
-	if (!schema || typeof schema !== "object") return schema;
-	if (Array.isArray(schema)) return schema.map((entry) => inlineLocalSchemaRefsWithDefs(entry, defs, refStack, state, rootDocument));
-	const obj = schema;
-	const nextDefs = extendSchemaDefs(defs, obj);
-	const refValue = typeof obj.$ref === "string" ? obj.$ref : void 0;
-	if (refValue) {
-		if (refStack?.has(refValue)) return {};
-		const resolved = tryResolveLocalRef(refValue, nextDefs, rootDocument);
-		if (resolved === void 0) {
-			if (refValue.startsWith("#/")) state.unresolvedLocalRefs = true;
-			return { ...obj };
-		}
-		const nextRefStack = refStack ? new Set(refStack) : /* @__PURE__ */ new Set();
-		nextRefStack.add(refValue);
-		const inlined = inlineLocalSchemaRefsWithDefs(resolved, nextDefs, nextRefStack, state, rootDocument);
-		if (!inlined || typeof inlined !== "object" || Array.isArray(inlined)) return inlined;
-		const result = { ...inlined };
-		copySchemaMeta(obj, result);
-		if (obj.nullable === true) result.nullable = true;
-		return result;
-	}
-	const result = {};
-	for (const [key, value] of Object.entries(obj)) {
-		if (key === "$defs" || key === "definitions" || key === "components") continue;
-		if (SCHEMA_LITERAL_KEYS.has(key)) {
-			setOwnSchemaProperty(result, key, value);
-			continue;
-		}
-		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
-			setOwnSchemaProperty(result, key, Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, inlineLocalSchemaRefsWithDefs(entryValue, nextDefs, refStack, state, rootDocument)])));
-			continue;
-		}
-		if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) {
-			setOwnSchemaProperty(result, key, inlineLocalSchemaRefsWithDefs(value, nextDefs, refStack, state, rootDocument));
-			continue;
-		}
-		if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
-			setOwnSchemaProperty(result, key, value.map((entry) => inlineLocalSchemaRefsWithDefs(entry, nextDefs, refStack, state, rootDocument)));
-			continue;
-		}
-		setOwnSchemaProperty(result, key, value);
-	}
-	if (state.unresolvedLocalRefs) {
-		if ("$defs" in obj) result.$defs = obj.$defs;
-		if ("definitions" in obj) result.definitions = obj.definitions;
-		if ("components" in obj) result.components = obj.components;
-	}
-	return result;
-}
-/** Inline local $ref pointers so providers receive self-contained tool schemas. */
-function inlineLocalToolSchemaRefs(schema) {
-	if (!schema || typeof schema !== "object") return schema;
-	return inlineLocalSchemaRefsWithDefs(schema, extendSchemaDefs(void 0, schema), void 0, { unresolvedLocalRefs: false }, schema);
-}
-const OPENAPI_SCHEMA_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
-	"discriminator",
-	"externalDocs",
-	"readOnly",
-	"writeOnly",
-	"xml",
-	"example"
-]);
-function appendNullSchemaType(type) {
-	if (type === "null") return type;
-	if (typeof type === "string") return [type, "null"];
-	if (Array.isArray(type)) return type.includes("null") ? type : [...type, "null"];
-	return type;
-}
-function isNullSchemaLike(schema) {
-	if (!isRecord(schema)) return false;
-	if (schema.type === "null") return true;
-	if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
-	if ("const" in schema && schema.const === null) return true;
-	return Array.isArray(schema.enum) && schema.enum.includes(null);
-}
-function hasOpenApiComposition(schema) {
-	return [
-		"allOf",
-		"anyOf",
-		"oneOf"
-	].some((key) => Array.isArray(schema[key]));
-}
-function schemaCompositionAlreadyAllowsNull(schema) {
-	return Array.isArray(schema.anyOf) && schema.anyOf.some(isNullSchemaLike) || Array.isArray(schema.oneOf) && schema.oneOf.some(isNullSchemaLike);
-}
-function wrapNullableComposedSchema(schema) {
-	if (schemaCompositionAlreadyAllowsNull(schema)) return schema;
-	const wrapped = { anyOf: [schema, { type: "null" }] };
-	copySchemaMeta(schema, wrapped);
-	return wrapped;
-}
-function normalizeOpenApiSchemaKeywords(schema) {
-	if (Array.isArray(schema)) {
-		let changed = false;
-		const normalized = schema.map((entry) => {
-			const next = normalizeOpenApiSchemaKeywords(entry);
-			changed ||= next !== entry;
-			return next;
-		});
-		return changed ? normalized : schema;
-	}
-	if (!isRecord(schema)) return schema;
-	let changed = false;
-	const nullable = schema.nullable === true;
-	const normalized = {};
-	for (const [key, value] of Object.entries(schema)) {
-		if (key === "nullable" || OPENAPI_SCHEMA_ANNOTATION_KEYS.has(key)) {
-			changed = true;
-			continue;
-		}
-		if (SCHEMA_LITERAL_KEYS.has(key)) {
-			normalized[key] = value;
-			continue;
-		}
-		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
-			let mapChanged = false;
-			const next = Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => {
-				const nextEntry = normalizeOpenApiSchemaKeywords(entryValue);
-				mapChanged ||= nextEntry !== entryValue;
-				return [entryKey, nextEntry];
-			}));
-			normalized[key] = mapChanged ? next : value;
-			changed ||= mapChanged;
-			continue;
-		}
-		if (key === "components") {
-			normalized[key] = value;
-			continue;
-		}
-		if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) {
-			const next = normalizeOpenApiSchemaKeywords(value);
-			normalized[key] = next;
-			changed ||= next !== value;
-			continue;
-		}
-		if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
-			const next = value.map(normalizeOpenApiSchemaKeywords);
-			normalized[key] = next;
-			changed ||= next.some((entry, index) => entry !== value[index]);
-			continue;
-		}
-		normalized[key] = value;
-	}
-	if (nullable) {
-		if (hasOpenApiComposition(normalized)) return wrapNullableComposedSchema(normalized);
-		if ("type" in normalized) {
-			const nextType = appendNullSchemaType(normalized.type);
-			if (nextType !== normalized.type) normalized.type = nextType;
-		}
-		if (Array.isArray(normalized.enum) && !normalized.enum.includes(null)) normalized.enum = [...normalized.enum, null];
-	}
-	return changed || nullable ? normalized : schema;
-}
-function normalizeToolParameterSchemaUncached(schema, options) {
-	const inlinedSchema = normalizeOpenApiSchemaKeywords(inlineLocalToolSchemaRefs(schema));
-	const schemaRecord = inlinedSchema && typeof inlinedSchema === "object" ? inlinedSchema : void 0;
-	if (!schemaRecord) return inlinedSchema;
-	const normalizedProvider = normalizeLowercaseStringOrEmpty(options?.modelProvider);
-	const normalizedModelId = normalizeLowercaseStringOrEmpty(options?.modelId);
-	const normalizedToolSchemaProfile = normalizeLowercaseStringOrEmpty(options?.modelCompat?.toolSchemaProfile);
-	const isGeminiProvider = normalizedProvider.includes("google") || normalizedProvider.includes("gemini") || isGeminiModelId(normalizedModelId) || normalizedToolSchemaProfile === "gemini";
-	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);
-		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;
-		}
-		if (unsupportedToolSchemaKeywords.size > 0) return stripUnsupportedSchemaKeywords(arrayItemsCompatibleSchema, unsupportedToolSchemaKeywords);
-		return arrayItemsCompatibleSchema;
-	}
-	const conditionalKey = getTopLevelConditionalKey(schemaRecord);
-	const flattenableVariantKey = getFlattenableVariantKey(schemaRecord);
-	if (hasTopLevelObjectSchema(schemaRecord, conditionalKey)) return applyProviderCleaning(schemaRecord);
-	if (isObjectLikeSchemaMissingType(schemaRecord, conditionalKey)) return applyProviderCleaning({
-		...schemaRecord,
-		type: "object",
-		properties: isRecord(schemaRecord.properties) ? schemaRecord.properties : {}
-	});
-	if (isTypedObjectSchemaMissingValidProperties(schemaRecord, conditionalKey)) return applyProviderCleaning({
-		...schemaRecord,
-		properties: {}
-	});
-	if (!flattenableVariantKey) {
-		if (isTrulyEmptySchema(schemaRecord)) return applyProviderCleaning({
-			type: "object",
-			properties: {}
-		});
-		if (conditionalKey === "allOf") return applyProviderCleaning(inlinedSchema);
-		return applyProviderCleaning(inlinedSchema);
-	}
-	const variants = schemaRecord[flattenableVariantKey];
-	const mergedProperties = {};
-	const requiredCounts = /* @__PURE__ */ new Map();
-	let objectVariants = 0;
-	for (const entry of variants) {
-		if (!entry || typeof entry !== "object") continue;
-		const props = entry.properties;
-		if (!props || typeof props !== "object") continue;
-		objectVariants += 1;
-		for (const [key, value] of Object.entries(props)) {
-			if (!(key in mergedProperties)) {
-				mergedProperties[key] = value;
-				continue;
-			}
-			mergedProperties[key] = mergePropertySchemas(mergedProperties[key], value);
-		}
-		const required = Array.isArray(entry.required) ? entry.required : [];
-		for (const key of required) {
-			if (typeof key !== "string") continue;
-			requiredCounts.set(key, (requiredCounts.get(key) ?? 0) + 1);
-		}
-	}
-	const baseRequired = Array.isArray(schemaRecord.required) ? schemaRecord.required.filter((key) => typeof key === "string") : void 0;
-	const mergedRequired = baseRequired && baseRequired.length > 0 ? baseRequired : objectVariants > 0 ? Array.from(requiredCounts.entries()).filter(([, count]) => count === objectVariants).map(([key]) => key) : void 0;
-	const nextSchema = { ...schemaRecord };
-	return applyProviderCleaning({
-		type: "object",
-		...typeof nextSchema.title === "string" ? { title: nextSchema.title } : {},
-		...typeof nextSchema.description === "string" ? { description: nextSchema.description } : {},
-		properties: Object.keys(mergedProperties).length > 0 ? mergedProperties : schemaRecord.properties ?? {},
-		...mergedRequired && mergedRequired.length > 0 ? { required: mergedRequired } : {},
-		additionalProperties: "additionalProperties" in schemaRecord ? schemaRecord.additionalProperties : true
-	});
-}
-/** Return a provider-compatible JSON schema for a model-facing tool. */
-function normalizeToolParameterSchema(schema, options) {
-	if (!schema || typeof schema !== "object") return normalizeToolParameterSchemaUncached(schema, options);
-	const cacheKey = resolveToolParameterSchemaCacheKey(options);
-	const cached = getCachedToolParameterSchema(schema, cacheKey);
-	if (cached) return cached;
-	return rememberCachedToolParameterSchema(schema, cacheKey, normalizeToolParameterSchemaUncached(schema, options));
-}
-//#endregion
-//#region packages/ai/src/providers/openai-tool-schema-compat.ts
-const OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
-	"$defs",
-	"definitions",
-	"dependentSchemas",
-	"dependencies",
-	"patternProperties",
-	"properties"
-]);
-const OPENAI_NULLABLE_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
-	"default",
-	"description",
-	"examples",
-	"format",
-	"title"
-]);
-const OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS = /* @__PURE__ */ new Set([
-	"additionalItems",
-	"additionalProperties",
-	"allOf",
-	"anyOf",
-	"contains",
-	"contentSchema",
-	"else",
-	"if",
-	"items",
-	"not",
-	"oneOf",
-	"prefixItems",
-	"propertyNames",
-	"then",
-	"unevaluatedItems",
-	"unevaluatedProperties"
-]);
-function normalizeOpenAIStrictCompatSchemaMap(schema) {
-	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
-	let changed = false;
-	const normalized = {};
-	for (const [key, value] of Object.entries(schema)) {
-		const next = normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false });
-		normalized[key] = next;
-		changed ||= next !== value;
-	}
-	return changed ? normalized : schema;
-}
-function normalizeOpenAIStrictCompatSchemaRecursive(schema, options) {
-	if (Array.isArray(schema)) {
-		let changed = false;
-		const normalized = schema.map((entry) => {
-			const next = normalizeOpenAIStrictCompatSchemaRecursive(entry, { promoteEmptyObject: false });
-			changed ||= next !== entry;
-			return next;
-		});
-		return changed ? normalized : schema;
-	}
-	if (!schema || typeof schema !== "object") return schema;
-	const record = schema;
-	let changed = false;
-	let hadNullType = false;
-	const normalized = {};
-	for (const [key, value] of Object.entries(record)) {
-		if (value === null && OPENAI_NULLABLE_ANNOTATION_KEYS.has(key)) {
-			changed = true;
-			continue;
-		}
-		if (value === null && key === "type") {
-			hadNullType = true;
-			changed = true;
-			continue;
-		}
-		const next = OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaMap(value) : OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false }) : value;
-		normalized[key] = next;
-		changed ||= next !== value;
-	}
-	if (Object.keys(normalized).length === 0) {
-		if (!options.promoteEmptyObject) return schema;
-		return {
-			type: "object",
-			properties: {},
-			required: [],
-			additionalProperties: false
-		};
-	}
-	const hasObjectShapeHints = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) || Array.isArray(normalized.required);
-	const hasArrayShapeHints = "items" in normalized;
-	if (!("type" in normalized) && hasObjectShapeHints !== hasArrayShapeHints) {
-		normalized.type = hasObjectShapeHints ? "object" : "array";
-		changed = true;
-	} else if (hadNullType && !("type" in normalized)) normalized.type = null;
-	if (normalized.type === "object" && !("properties" in normalized)) {
-		normalized.properties = {};
-		changed = true;
-	}
-	const hasEmptyProperties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) && Object.keys(normalized.properties).length === 0;
-	if (normalized.type === "object" && !Array.isArray(normalized.required) && hasEmptyProperties) {
-		normalized.required = [];
-		changed = true;
-	}
-	if (normalized.type === "object" && hasEmptyProperties && !("additionalProperties" in normalized)) {
-		normalized.additionalProperties = false;
-		changed = true;
-	}
-	return changed ? normalized : schema;
-}
-/** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
-function normalizeOpenAIStrictCompatSchema(schema) {
-	return normalizeOpenAIStrictCompatSchemaRecursive(schema, { promoteEmptyObject: true });
-}
-/** Finds schema paths that violate OpenAI strict tool-schema requirements. */
-function findOpenAIStrictSchemaViolations(schema, path, options) {
-	if (Array.isArray(schema)) {
-		if (options?.requireObjectRoot) return [`${path}.type`];
-		return schema.flatMap((item, index) => findOpenAIStrictSchemaViolations(item, `${path}[${index}]`));
-	}
-	if (!schema || typeof schema !== "object") return options?.requireObjectRoot ? [`${path}.type`] : [];
-	const record = schema;
-	const violations = [];
-	for (const key of [
-		"anyOf",
-		"oneOf",
-		"allOf"
-	]) if (key in record) violations.push(`${path}.${key}`);
-	if (Array.isArray(record.type)) violations.push(`${path}.type`);
-	const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : void 0;
-	if (record.type === "object") {
-		if (record.additionalProperties !== false) violations.push(`${path}.additionalProperties`);
-		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
-		if (!required) violations.push(`${path}.required`);
-		else if (properties) {
-			const requiredSet = new Set(required);
-			for (const key of Object.keys(properties)) if (!requiredSet.has(key)) violations.push(`${path}.required.${key}`);
-		}
-	}
-	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS) {
-		const schemaMap = record[key];
-		if (!schemaMap || typeof schemaMap !== "object" || Array.isArray(schemaMap)) continue;
-		for (const [entryKey, value] of Object.entries(schemaMap)) violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}.${entryKey}`));
-	}
-	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS) {
-		const value = record[key];
-		if (value && typeof value === "object") violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}`));
-	}
-	return violations;
-}
-//#endregion
-//#region packages/ai/src/providers/openai-tool-schema.ts
-/**
-* OpenAI strict JSON-schema normalization for tool inventories and request payloads.
-*
-* Caches normalized object inputs by provider compatibility so repeated inventory builds preserve identity.
-*/
-const MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
-const strictOpenAISchemaCache = /* @__PURE__ */ new WeakMap();
-function resolveToolSchemaModelCompat(compat) {
-	if (!compat) return;
-	const unsupportedToolSchemaKeywords = Array.isArray(compat.unsupportedToolSchemaKeywords) ? compat.unsupportedToolSchemaKeywords.filter((keyword) => typeof keyword === "string") : [];
-	if (unsupportedToolSchemaKeywords.length === 0 && compat.omitEmptyArrayItems !== true) return;
-	return {
-		...unsupportedToolSchemaKeywords.length > 0 ? { unsupportedToolSchemaKeywords } : {},
-		...compat.omitEmptyArrayItems === true ? { omitEmptyArrayItems: true } : {}
-	};
-}
-function resolveStrictOpenAISchemaCacheKey(modelCompat) {
-	const compat = resolveToolSchemaModelCompat(modelCompat);
-	return JSON.stringify([[...compat?.unsupportedToolSchemaKeywords ?? []].toSorted(), shouldOmitEmptyArrayItems(compat)]);
-}
-function readCachedStrictOpenAISchema(schema, key) {
-	return strictOpenAISchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
-}
-function rememberStrictOpenAISchema(schema, key, value) {
-	const entries = strictOpenAISchemaCache.get(schema) ?? [];
-	strictOpenAISchemaCache.set(schema, [{
-		key,
-		value
-	}, ...entries.filter((entry) => entry.key !== key)].slice(0, MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA));
-	return value;
-}
-/** 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
-		}] : [];
-	})];
-}
-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);
-	});
-}
-/** 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));
-}
-//#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) {
@@ -1362,7 +97,7 @@ function readOpenAIResponsesCompactionReplayState(value) {
 function openAIResponsesReplayContextMatches(state, context) {
 	return state.provider === context.provider && state.api === context.api && state.model === context.model && state.baseUrlHash === context.baseUrlHash && state.sessionHash === context.sessionHash && state.authProfileHash === context.authProfileHash;
 }
-function captureOpenAIResponsesCompaction(output, item, boundary, model, captureMetadata) {
+function captureOpenAIResponsesCompaction(output, item, boundary, model, captureMetadata, compactedOutput) {
 	const metadata = captureMetadata ?? buildOpenAIResponsesReasoningReplayMetadata(model);
 	if (!item.encrypted_content) return;
 	if (!metadata?.baseUrlHash) {
@@ -1371,19 +106,28 @@ function captureOpenAIResponsesCompaction(output, item, boundary, model, capture
 	}
 	const currentReplay = readOpenAIResponsesCompactionReplayState(output.providerReplay);
 	if (typeof boundary === "number" && currentReplay?.type === "openai-responses-compaction" && (currentReplay.replayIndex ?? -1) > boundary) return;
-	output.providerReplay = {
+	if (compactedOutput && !isOpenAIResponsesCompactionOutput(compactedOutput, model)) throw new Error("Responses compact endpoint checkpoint is invalid");
+	const replay = {
 		v: 1,
-		type: boundary === "retained-users" ? OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE : OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE,
+		...boundary === "retained-users" ? { type: OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE } : {
+			type: OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE,
+			replayIndex: boundary
+		},
 		...item.id ? { id: item.id } : {},
 		data: item.encrypted_content,
-		...typeof boundary === "number" ? { replayIndex: boundary } : {},
 		provider: metadata.provider,
 		api: metadata.api,
 		model: metadata.model,
 		baseUrlHash: metadata.baseUrlHash,
 		...metadata.sessionHash ? { sessionHash: metadata.sessionHash } : {},
-		...metadata.authProfileHash ? { authProfileHash: metadata.authProfileHash } : {}
+		...metadata.authProfileHash ? { authProfileHash: metadata.authProfileHash } : {},
+		...compactedOutput ? { compactedWindow: {
+			state: "ready",
+			output: JSON.stringify(compactedOutput)
+		} } : {}
 	};
+	if (compactedOutput && !readOpenAIResponsesCompactionWindow(replay, model)) throw new Error("Responses compact endpoint checkpoint is invalid or exceeds 16 MiB");
+	output.providerReplay = replay;
 }
 function suppressOpenAIResponsesCompaction(output, model, options, rejectedCheckpoint) {
 	const context = buildOpenAIResponsesReplayContext(model, options);
@@ -1432,6 +176,21 @@ function resolveNewestOpenAIResponsesCompactionReplay(messages, model, options)
 			continue;
 		}
 		if (!openAIResponsesReplayContextMatches(replay, context)) return;
+		if (replay.compactedWindow !== void 0 || replay.type === "openai-responses-retained-compaction") {
+			const output = readOpenAIResponsesCompactionWindow(replay, model);
+			const item = output?.at(-1);
+			if (!output || item?.type !== "compaction") return {
+				owner: message,
+				mode: "refresh-required"
+			};
+			return {
+				owner: message,
+				mode: "complete-window",
+				output,
+				item,
+				replayIndex: replay.type === "openai-responses-retained-compaction" ? message.content.length : replay.replayIndex ?? 0
+			};
+		}
 		return {
 			owner: message,
 			item: {
@@ -1439,13 +198,17 @@ function resolveNewestOpenAIResponsesCompactionReplay(messages, model, options)
 				...isSafeResponsesReplayItemId(replay.id) ? { id: replay.id } : {},
 				encrypted_content: replay.data
 			},
-			...replay.type === "openai-responses-retained-compaction" ? { mode: "retained-users" } : {
-				mode: "compacted-prefix",
-				replayIndex: replay.replayIndex ?? 0
-			}
+			mode: "compacted-prefix",
+			replayIndex: replay.replayIndex ?? 0
 		};
 	}
 }
+var CompactionReplayRefreshRequiredError = class extends Error {
+	constructor() {
+		super("Provider compaction checkpoint needs rebuilding. Run /compact to rebuild from saved conversation history.");
+		this.name = "CompactionReplayRefreshRequiredError";
+	}
+};
 function buildOpenAIResponsesCompactionReplayPlan(messages, model, options) {
 	if (options?.mode === "full-history") return {
 		messages,
@@ -1456,22 +219,14 @@ function buildOpenAIResponsesCompactionReplayPlan(messages, model, options) {
 		messages,
 		preserveUnframedToolResults: false
 	};
+	if (compaction.mode === "refresh-required") throw new CompactionReplayRefreshRequiredError();
 	const ownerIndex = messages.indexOf(compaction.owner);
-	const collectRetainedUserMessages = (prefix) => {
-		const previous = resolveNewestOpenAIResponsesCompactionReplay(prefix, model, options);
-		if (!previous) return prefix.filter((message) => message.role === "user");
-		const previousOwnerIndex = prefix.indexOf(previous.owner);
-		const laterUsers = prefix.slice(previousOwnerIndex + 1).filter((message) => message.role === "user");
-		return previous.mode === "retained-users" ? [...collectRetainedUserMessages(prefix.slice(0, previousOwnerIndex)), ...laterUsers] : laterUsers;
-	};
-	const retainedMessages = compaction.mode === "retained-users" ? collectRetainedUserMessages(messages.slice(0, ownerIndex)) : void 0;
 	return {
 		messages: [{
 			...compaction.owner,
-			content: compaction.mode === "retained-users" ? [] : compaction.owner.content.slice(compaction.replayIndex)
+			content: compaction.owner.content.slice(compaction.replayIndex)
 		}, ...messages.slice(ownerIndex + 1)],
-		...retainedMessages?.length ? { retainedMessages } : {},
-		compaction: compaction.item,
+		...compaction.mode === "complete-window" ? { compactedWindow: compaction.output } : { compaction: compaction.item },
 		preserveUnframedToolResults: true
 	};
 }
@@ -1663,39 +418,47 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 		preserveUnframedToolResults: replayPlan.preserveUnframedToolResults
 	});
 	const transformedMessages = transformMessages(replayPlan.messages);
-	const transformedRetainedMessages = replayPlan.retainedMessages ? transformMessages(replayPlan.retainedMessages) : [];
-	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) messages.push(buildResponsesInputMessage(model.reasoning && (providerStyle ? model.compat?.supportsDeveloperRole !== false : options?.supportsDeveloperRole !== false) ? "developer" : "system", [{
+	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) messages.push(buildResponsesInputMessage(model.reasoning && model.compat?.supportsDeveloperRole !== false ? "developer" : "system", [{
 		type: "input_text",
 		text: sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt))
 	}]));
-	const replayMessages = replayPlan.compaction ? [
-		...transformedRetainedMessages,
-		replayPlan.compaction,
-		...transformedMessages
-	] : transformedMessages;
+	if (replayPlan.compactedWindow) messages.push(...replayPlan.compactedWindow);
+	let replayMessages = replayPlan.compaction ? [replayPlan.compaction, ...transformedMessages] : transformedMessages;
+	const isCarrier = (message) => "role" in message && message.role === "user" && message.runtimeContextCarrier === true;
+	const carriers = replayMessages.filter(isCarrier);
+	if (carriers.length > 0) {
+		const stableMessages = replayMessages.filter((message) => !isCarrier(message));
+		const insertionIndex = stableMessages.findLastIndex((message) => "role" in message ? message.role === "user" : message.type === "compaction") + 1;
+		if (insertionIndex > 0 || replayPlan.compactedWindow) replayMessages = [
+			...stableMessages.slice(0, insertionIndex),
+			...carriers,
+			...stableMessages.slice(insertionIndex)
+		];
+	}
 	let msgIndex = 0;
 	for (const msg of replayMessages) {
 		if (!("role" in msg)) {
 			messages.push(msg);
 			continue;
 		}
-		if (msg.role === "user") if (typeof msg.content === "string") messages.push(buildResponsesInputMessage("user", [{
-			type: "input_text",
-			text: sanitizeTransportPayloadText(msg.content)
-		}]));
-		else {
-			const content = msg.content.map((item) => item.type === "text" ? {
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") messages.push(buildResponsesInputMessage("user", [{
 				type: "input_text",
-				text: sanitizeTransportPayloadText(item.text)
-			} : {
-				type: "input_image",
-				detail: "auto",
-				image_url: `data:${item.mimeType};base64,${item.data}`
-			}).filter((item) => providerStyle || model.input.includes("image") || item.type !== "input_image");
-			if (content.length > 0) messages.push(buildResponsesInputMessage("user", content));
-			else if (providerStyle) continue;
-		}
-		else if (msg.role === "assistant") {
+				text: sanitizeTransportPayloadText(msg.content)
+			}]));
+			else {
+				const content = msg.content.map((item) => item.type === "text" ? {
+					type: "input_text",
+					text: sanitizeTransportPayloadText(item.text)
+				} : {
+					type: "input_image",
+					detail: "auto",
+					image_url: `data:${item.mimeType};base64,${item.data}`
+				}).filter((item) => providerStyle || model.input.includes("image") || item.type !== "input_image");
+				if (content.length > 0) messages.push(buildResponsesInputMessage("user", content));
+				else if (providerStyle) continue;
+			}
+		} else if (msg.role === "assistant") {
 			const output = [];
 			let textFallbackOrdinal = 0;
 			let previousReplayItemWasReasoning = false;
@@ -1799,8 +562,8 @@ function isInvalidEncryptedContentError(error) {
 	if (!error || typeof error !== "object") return false;
 	const record = error;
 	if (record.code === "invalid_encrypted_content" || record.code === "thinking_signature_invalid") return true;
-	const message = typeof record.message === "string" ? record.message : "";
-	return message.includes("invalid_encrypted_content") || message.includes("thinking_signature_invalid") || record.status === 400 && message.toLowerCase().includes("could not decrypt the provided encrypted_content");
+	const message = typeof record.message === "string" ? record.message.toLowerCase() : "";
+	return message.includes("invalid_encrypted_content") || message.includes("thinking_signature_invalid") || (record.status === 400 || record.status == null && /(?:^|[\s(])400(?:[\s):]|$)/.test(message)) && (message.includes("could not decrypt the provided encrypted_content") || message.includes("encrypted content") && (message.includes("could not be verified") || message.includes("could not be decrypted or parsed")));
 }
 function isOrphanedFunctionCallOutputError(error) {
 	if (!error || typeof error !== "object") return false;
@@ -1880,7 +643,45 @@ async function createResponsesStreamWithEncryptedContentRetry(params) {
 			payloadVariant: attempt.kind
 		});
 		try {
-			return await sendAttempt(attempt);
+			const result = await sendAttempt(attempt);
+			return {
+				...result,
+				stream: { async *[Symbol.asyncIterator]() {
+					let rejectedEvent;
+					try {
+						for await (const event of params.wrapStream?.(result) ?? result.stream) {
+							if (isRecord(event)) {
+								const failure = event.type === "response.failed" && isRecord(event.response) ? event.response.error : event.type === "error" ? event.error ?? event : void 0;
+								if (isRecord(failure) && params.canRetryStream?.() === true && isInvalidEncryptedContentError(failure)) {
+									rejectedEvent = event;
+									const message = typeof failure.message === "string" ? failure.message : "";
+									throw Object.assign(new Error(message), {
+										code: failure.code,
+										status: failure.status
+									});
+								}
+							}
+							yield event;
+						}
+					} catch (error) {
+						const nextAttempt = params.canRetryStream?.() === true && !params.requestOptions?.signal?.aborted ? await resolveNextResponsesEncryptedContentAttempt(result.attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest }) : void 0;
+						if (!nextAttempt) {
+							if (rejectedEvent !== void 0) {
+								yield rejectedEvent;
+								return;
+							}
+							throw error;
+						}
+						log.warn(`[responses] retrying streamed encrypted content provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
+						yield* (await createResponsesStreamWithEncryptedContentRetry({
+							...params,
+							request: nextAttempt.request,
+							initialAttemptKind: nextAttempt.kind,
+							initialRejectedCompaction: nextAttempt.rejectedCompaction
+						})).stream;
+					}
+				} }
+			};
 		} catch (error) {
 			let nextAttempt = await resolveNextResponsesEncryptedContentAttempt(attempt, error, { buildFullHistoryRequest: params.buildFullHistoryRequest });
 			if (!nextAttempt && attempt.request.previous_response_id && error && typeof error === "object" && typeof error.status === "number" && error.code === "previous_response_not_found") {
@@ -1952,14 +753,14 @@ function createResponsesToolCallTracker() {
 		state.callId ??= identity.callId;
 		return state;
 	};
-	const resolveCompatible = (candidates, identity) => {
+	const resolveCompatible = (candidates, identity, allowUnmatchedIdentity) => {
 		const uniqueCandidates = [...new Set(candidates)];
-		if (!identity.itemId && !identity.callId) return uniqueCandidates.length === 1 ? uniqueCandidates.at(0) : void 0;
+		if (!identity.itemId && !identity.callId) return allowUnmatchedIdentity && 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;
+		const soleCompatible = allowUnmatchedIdentity && uniqueCandidates.length === 1 && compatible.length === 1 && matches.length === 0 ? compatible.at(0) : void 0;
 		return soleCompatible ? adoptIdentity(soleCompatible, identity) : void 0;
 	};
 	return {
@@ -1970,9 +771,10 @@ function createResponsesToolCallTracker() {
 				return;
 			}
 			if (indexedCalls.has(outputIndex)) throw new Error(`Responses stream reused active tool-call output index ${outputIndex}`);
+			state.outputIndex = outputIndex;
 			indexedCalls.set(outputIndex, state);
 		},
-		resolve(event, identity = readEventIdentity(event)) {
+		resolve(event, identity = readEventIdentity(event), allowUnmatchedIdentity = true) {
 			const outputIndex = readOutputIndex(event);
 			if (outputIndex !== void 0) {
 				const indexed = indexedCalls.get(outputIndex);
@@ -1980,14 +782,15 @@ function createResponsesToolCallTracker() {
 					if (indexed.callId && identity.callId && indexed.callId !== identity.callId) return;
 					return adoptIdentity(indexed, identity);
 				}
-				const unindexed = resolveCompatible(unindexedCalls, identity);
+				const unindexed = resolveCompatible(unindexedCalls, identity, allowUnmatchedIdentity);
 				if (unindexed) {
 					unindexedCalls.delete(unindexed);
+					unindexed.outputIndex = outputIndex;
 					indexedCalls.set(outputIndex, unindexed);
 				}
 				return unindexed;
 			}
-			return resolveCompatible([...indexedCalls.values(), ...unindexedCalls], identity);
+			return resolveCompatible([...indexedCalls.values(), ...unindexedCalls], identity, allowUnmatchedIdentity);
 		},
 		forget(toolCall) {
 			for (const [outputIndex, tracked] of indexedCalls) if (tracked === toolCall) indexedCalls.delete(outputIndex);
@@ -1998,6 +801,10 @@ function createResponsesToolCallTracker() {
 		},
 		hasActive() {
 			return indexedCalls.size > 0 || unindexedCalls.size > 0;
+		},
+		hasExactlyActive(expected) {
+			const active = /* @__PURE__ */ new Set([...indexedCalls.values(), ...unindexedCalls]);
+			return active.size === expected.length && expected.every((state) => active.has(state));
 		}
 	};
 }
@@ -2123,9 +930,10 @@ const RESPONSE_FAILED_FAILURE_FIELD_KEYS = [
 function readResponseFailedString(record, key) {
 	return stringifyUnknown(record?.[key]);
 }
-function buildResponsesFailedEventSummary(message, responseId, observation) {
+function buildResponsesFailedEventSummary(message, responseId, code, observation) {
 	const summary = { message };
 	if (responseId) summary.responseId = responseId;
+	if (code) summary.code = code;
 	if (observation) summary.observation = observation;
 	return summary;
 }
@@ -2244,11 +1052,11 @@ function normalizeResponsesFailedEvent(event, model) {
 	if (error) {
 		const code = readResponseFailedString(error, "code").trim();
 		const message = readResponseFailedString(error, "message").trim();
-		if (code || message) return buildResponsesFailedEventSummary(`${code || "unknown"}: ${message || "no message"}`, responseId);
+		if (code || message) return buildResponsesFailedEventSummary(`${code || "unknown"}: ${message || "no message"}`, responseId, code || void 0);
 	}
 	const incompleteReason = readResponseFailedString(isRecord(response?.incomplete_details) ? response.incomplete_details : void 0, "reason");
 	if (incompleteReason) return buildResponsesFailedEventSummary(`incomplete: ${incompleteReason}`, responseId);
-	return buildResponsesFailedEventSummary(RESPONSE_FAILED_NO_DETAILS_MESSAGE, responseId, buildResponsesFailedNoDetailsObservation(event, model, response));
+	return buildResponsesFailedEventSummary(RESPONSE_FAILED_NO_DETAILS_MESSAGE, responseId, void 0, buildResponsesFailedNoDetailsObservation(event, model, response));
 }
 var ResponsesStreamFailure = class extends Error {
 	constructor(failure, response) {
@@ -2256,6 +1064,7 @@ var ResponsesStreamFailure = class extends Error {
 		this.name = "ResponsesStreamFailure";
 		this.responseId = failure.responseId;
 		this.response = response;
+		this.code = failure.code;
 		this.observation = failure.observation;
 	}
 };
@@ -2346,20 +1155,39 @@ async function* observeResponsesStream(stream, model, requestStartedAt) {
 }
 //#endregion
 //#region packages/ai/src/transports/openai-responses-stream-slots-internal.ts
-function createResponsesOutputContentIndex() {
-	const indexes = /* @__PURE__ */ new Map();
+function createResponsesOutputTracker() {
+	const outputs = /* @__PURE__ */ new Map();
 	const identity = (item) => {
 		if ((item.type === "reasoning" || item.type === "message") && item.id) return `${item.type}:${item.id}`;
-		return item.type === "function_call" ? `function_call:${item.call_id ?? item.id ?? ""}` : void 0;
+		const callId = item.call_id ?? item.id;
+		return item.type === "function_call" && callId ? `function_call:${callId}` : void 0;
+	};
+	const get = (item, outputIndex) => {
+		const key = identity(item);
+		const output = (outputIndex === void 0 ? void 0 : outputs.get(outputIndex)) ?? (key === void 0 ? void 0 : outputs.get(key));
+		if (!output || outputIndex !== void 0 && output.outputIndex !== void 0 && output.outputIndex !== outputIndex) return;
+		if (output.type !== item.type || output.callId && item.call_id && output.callId !== item.call_id) throw new Error("Responses stream changed output item identity");
+		return output;
 	};
 	return {
-		get(item) {
-			const key = identity(item);
-			return key === void 0 ? void 0 : indexes.get(key);
-		},
-		set(item, contentIndex) {
+		get,
+		set(item, contentIndex, outputIndex, completed = false) {
+			const output = get(item, outputIndex) ?? {
+				type: item.type,
+				contentIndex,
+				completed
+			};
+			Object.assign(output, {
+				contentIndex,
+				completed
+			});
+			if (item.call_id) output.callId = item.call_id;
+			if (outputIndex !== void 0) {
+				output.outputIndex = outputIndex;
+				outputs.set(outputIndex, output);
+			}
 			const key = identity(item);
-			if (key !== void 0) indexes.set(key, contentIndex);
+			if (key !== void 0) outputs.set(key, output);
 		}
 	};
 }
@@ -2419,8 +1247,11 @@ function createResponsesOutputSlotTracker() {
 * package and managed transports from drifting on token buckets, service-tier pricing, or future
 * terminal-event semantics.
 */
+function readReportedCount(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
 function readCount(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+	return readReportedCount(value) ?? 0;
 }
 /**
 * Split a terminal usage payload into the priced buckets.
@@ -2438,12 +1269,21 @@ function mapResponsesTerminalUsage(usage) {
 	const input = Math.max(0, readCount(usage.input_tokens) - cacheRead - cacheWrite);
 	const output = readCount(usage.output_tokens);
 	const bucketTotal = input + output + cacheRead + cacheWrite;
+	const totalTokens = Math.max(bucketTotal, readCount(usage.total_tokens));
+	const reportedInput = readReportedCount(usage.input_tokens);
+	const reportedOutput = readReportedCount(usage.output_tokens);
+	const reportedTotal = readReportedCount(usage.total_tokens);
 	return {
 		input,
 		output,
 		cacheRead,
 		cacheWrite,
-		totalTokens: Math.max(bucketTotal, readCount(usage.total_tokens))
+		contextUsage: reportedInput !== void 0 && (reportedOutput !== void 0 || reportedTotal !== void 0 && reportedTotal >= reportedInput) && cacheRead + cacheWrite <= reportedInput ? {
+			state: "available",
+			promptTokens: reportedInput,
+			totalTokens: Math.max(totalTokens, reportedInput + (reportedOutput ?? 0))
+		} : { state: "unavailable" },
+		totalTokens
 	};
 }
 /** Reasoning tokens are reported by the agent path only; the package path does not track them. */
@@ -2509,51 +1349,52 @@ function createResponsesTerminalController(params) {
 	const { output, stream, model, options } = params;
 	const blocks = output.content;
 	const backfillReasoning = (items) => {
-		for (const item of items) {
+		for (const [outputIndex, item] of items.entries()) {
 			if (item.type !== "reasoning" || !item.encrypted_content) continue;
-			const block = params.reasoningBlocksById.get(item.id);
-			if (!block?.thinkingSignature) continue;
+			const tracked = params.outputs.get(item, outputIndex);
+			const block = tracked && blocks[tracked.contentIndex];
+			if (block?.type !== "thinking" || !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;
+			if (options?.reasoningReplayMetadata) Object.assign(block, { [OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY]: options.reasoningReplayMetadata });
 		}
 	};
-	const appendText = (item) => {
+	const appendText = (item, contentIndex) => {
 		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("");
-		const started = params.startedTextBlocksByItemId.get(item.id);
+		const block = contentIndex === void 0 ? void 0 : blocks[contentIndex];
+		const started = block?.type === "text" ? block : void 0;
 		if (!text && !started) return;
 		const phase = item.phase ?? void 0;
-		if (started) {
-			const previousText = started.block.text;
-			started.block.text = text;
-			started.block.textSignature = encodeTextSignatureV1(item.id, phase);
+		if (started && contentIndex !== void 0) {
+			const previousText = started.text;
+			started.text = text;
+			started.textSignature = encodeTextSignatureV1(item.id, phase);
 			params.setLastTextBlock({
-				block: started.block,
-				index: started.index,
+				block: started,
+				index: contentIndex,
 				phase
 			});
-			params.startedTextBlocksByItemId.delete(item.id);
 			if (text.startsWith(previousText)) {
 				const delta = text.slice(previousText.length);
 				if (delta) stream.push({
 					type: "text_delta",
-					contentIndex: started.index,
+					contentIndex,
 					delta
 				});
 			}
 			stream.push({
 				type: "text_end",
-				contentIndex: started.index,
+				contentIndex,
 				content: text,
 				partial: output
 			});
-			return started.index;
+			return contentIndex;
 		}
 		const previous = params.getLastTextBlock();
 		const collapse = resolveResponsesMessageSnapshotCollapse({
@@ -2575,15 +1416,15 @@ function createResponsesTerminalController(params) {
 			});
 			return previous.index;
 		}
-		const block = {
+		const newBlock = {
 			type: "text",
 			text,
 			textSignature: encodeTextSignatureV1(item.id, phase)
 		};
-		blocks.push(block);
+		blocks.push(newBlock);
 		const index = blocks.length - 1;
 		params.setLastTextBlock({
-			block,
+			block: newBlock,
 			index,
 			phase
 		});
@@ -2600,65 +1441,71 @@ function createResponsesTerminalController(params) {
 		});
 		return index;
 	};
-	const appendToolCall = (item) => {
-		const validated = resolveCompletedResponsesToolCall(item);
-		const toolCall = {
+	const emitToolCallCompletion = (item, outputIndex, started, validated) => {
+		const completed = {
+			id: resolveResponsesToolCallId(item, started?.block.id),
+			...validated
+		};
+		const toolCall = started ? Object.assign(started.block, completed) : {
 			type: "toolCall",
-			id: resolveResponsesToolCallId(item),
-			name: validated.name,
-			arguments: validated.arguments
+			...completed
 		};
-		blocks.push(toolCall);
-		const contentIndex = blocks.length - 1;
-		stream.push({
-			type: "toolcall_start",
-			contentIndex,
-			partial: output
-		});
+		delete toolCall.partialJson;
+		const contentIndex = started?.contentIndex ?? blocks.length;
+		if (!started) {
+			blocks.push(toolCall);
+			stream.push({
+				type: "toolcall_start",
+				contentIndex,
+				partial: output
+			});
+		}
+		params.outputs.set(item, contentIndex, outputIndex, true);
 		stream.push({
 			type: "toolcall_end",
 			contentIndex,
 			toolCall,
 			partial: output
 		});
-		return contentIndex;
 	};
-	const recoverTerminalOutput = (items, includeToolCalls) => {
+	const recoverTerminalOutput = (items, completeToolCall) => {
 		let hasCompletedLaterOutput = false;
-		for (const item of items.toReversed()) {
+		for (const [outputIndex, item] of [...items.entries()].toReversed()) {
+			const tracked = params.outputs.get(item, outputIndex);
 			if (item.type === "reasoning") {
-				hasCompletedLaterOutput ||= params.outputItemContentIndexes.get(item) !== void 0;
+				hasCompletedLaterOutput ||= tracked !== void 0;
 				continue;
 			}
 			if (item.type !== "message" && item.type !== "function_call") continue;
-			if (params.outputItemContentIndexes.get(item) !== void 0 || item.type === "message" && params.startedTextBlocksByItemId.has(item.id)) {
+			if (tracked) {
 				hasCompletedLaterOutput = true;
 				continue;
 			}
-			if (item.type === "function_call" && !includeToolCalls) continue;
+			if (item.type === "function_call" && !completeToolCall) continue;
 			if (hasCompletedLaterOutput) throw new Error("Responses stream omitted an output item before completed output");
-			if (item.type === "function_call") resolveCompletedResponsesToolCall(item);
 		}
 		for (const [terminalIndex, item] of items.entries()) if (item.type === "message") {
-			if (params.outputItemContentIndexes.get(item) !== void 0 && !params.startedTextBlocksByItemId.has(item.id)) continue;
-			const appendedIndex = appendText(item);
-			if (appendedIndex !== void 0) params.outputItemContentIndexes.set(item, appendedIndex);
+			const tracked = params.outputs.get(item, terminalIndex);
+			if (tracked?.completed) continue;
+			const appendedIndex = appendText(item, tracked?.contentIndex);
+			if (appendedIndex !== void 0) params.outputs.set(item, appendedIndex, terminalIndex, true);
 		} else {
 			params.setLastTextBlock(null);
 			const alreadyCapturedCompaction = item.type === "compaction" && output.providerReplay?.type === "openai-responses-compaction" && output.providerReplay.id === item.id && output.providerReplay.data === item.encrypted_content;
 			if (item.type === "compaction" && !alreadyCapturedCompaction) {
 				let replayIndex = blocks.length;
-				for (const laterItem of items.slice(terminalIndex + 1)) {
-					const laterContentIndex = params.outputItemContentIndexes.get(laterItem);
+				for (const [laterIndex, laterItem] of items.entries()) {
+					if (laterIndex <= terminalIndex) continue;
+					const laterContentIndex = params.outputs.get(laterItem, laterIndex)?.contentIndex;
 					if (laterContentIndex !== void 0) {
 						replayIndex = laterContentIndex;
 						break;
 					}
 				}
 				captureOpenAIResponsesCompaction(output, item, replayIndex, model, options?.reasoningReplayMetadata);
-			} else if (includeToolCalls && item.type === "function_call") {
-				if (params.outputItemContentIndexes.get(item) !== void 0) continue;
-				params.outputItemContentIndexes.set(item, appendToolCall(item));
+			} else if (completeToolCall && item.type === "function_call") {
+				if (params.outputs.get(item, terminalIndex)?.completed) continue;
+				completeToolCall(terminalIndex);
 			}
 		}
 	};
@@ -2685,7 +1532,6 @@ function createResponsesTerminalController(params) {
 		}
 	};
 	const finalizeResponse = (response, terminalEventType) => {
-		params.markFinalized();
 		backfillReasoning(response.output ?? []);
 		finalizeTerminalFacts(response);
 		const terminal = resolveResponsesTerminalStopReason({
@@ -2700,7 +1546,8 @@ function createResponsesTerminalController(params) {
 	return {
 		finalizeResponse,
 		finalizeFailedResponse: finalizeTerminalFacts,
-		recoverTerminalOutput
+		recoverTerminalOutput,
+		emitToolCallCompletion
 	};
 }
 //#endregion
@@ -2708,9 +1555,7 @@ function createResponsesTerminalController(params) {
 async function processResponsesStream(openaiStream, output, stream, model, options) {
 	const streamingToolCalls = createResponsesToolCallTracker();
 	const outputSlots = createResponsesOutputSlotTracker();
-	const reasoningBlocksById = /* @__PURE__ */ new Map();
-	const outputItemContentIndexes = createResponsesOutputContentIndex();
-	const startedTextBlocksByItemId = /* @__PURE__ */ new Map();
+	const outputs = createResponsesOutputTracker();
 	let terminalResponse;
 	let lastTextBlock = null;
 	const blocks = output.content;
@@ -2725,11 +1570,11 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				type: "thinking",
 				item,
 				block,
-				contentIndex: blocks.length
+				contentIndex: blocks.length,
+				outputIndex: readResponsesOutputIndex(event)
 			};
 			blocks.push(block);
-			reasoningBlocksById.set(item.id, block);
-			outputItemContentIndexes.set(item, slot.contentIndex);
+			outputs.set(item, slot.contentIndex, slot.outputIndex);
 			outputSlots.register(event, slot);
 			stream.push({
 				type: "thinking_start",
@@ -2751,17 +1596,13 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				item: messageItem,
 				block,
 				contentIndex: block ? blocks.length : void 0,
+				outputIndex: readResponsesOutputIndex(event),
 				pendingText: collapseCandidate ? "" : null,
 				collapseCandidate
 			};
 			if (block) {
 				blocks.push(block);
-				outputItemContentIndexes.set(messageItem, slot.contentIndex ?? blocks.length - 1);
-				startedTextBlocksByItemId.set(messageItem.id, {
-					block,
-					index: slot.contentIndex ?? blocks.length - 1,
-					phase: messageItem.phase ?? void 0
-				});
+				outputs.set(messageItem, slot.contentIndex ?? blocks.length - 1, slot.outputIndex);
 			}
 			outputSlots.register(event, slot);
 			if (slot.contentIndex !== void 0) stream.push({
@@ -2777,9 +1618,6 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 		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;
@@ -2790,12 +1628,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 		};
 		blocks.push(slot.block);
 		slot.contentIndex = blocks.length - 1;
-		outputItemContentIndexes.set(slot.item, slot.contentIndex);
-		startedTextBlocksByItemId.set(slot.item.id, {
-			block: slot.block,
-			index: slot.contentIndex,
-			phase: slot.item.phase ?? void 0
-		});
+		outputs.set(slot.item, slot.contentIndex, slot.outputIndex);
 		stream.push({
 			type: "text_start",
 			contentIndex: slot.contentIndex,
@@ -2813,20 +1646,58 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 	const materializeDeferredTextSlots = (except) => {
 		for (const slot of outputSlots.values()) if (slot !== except && slot.type === "text") materializeDeferredTextSlot(slot);
 	};
-	const { finalizeResponse, finalizeFailedResponse, recoverTerminalOutput } = createResponsesTerminalController({
+	const terminal = createResponsesTerminalController({
 		output,
 		stream,
 		model,
 		options,
-		reasoningBlocksById,
-		startedTextBlocksByItemId,
-		outputItemContentIndexes,
+		outputs,
 		getLastTextBlock: () => lastTextBlock,
 		setLastTextBlock: (block) => {
 			lastTextBlock = block;
-		},
-		markFinalized: () => void 0
+		}
 	});
+	const finalizeToolCall = (item, outputIndex, streamingToolCall, validated) => {
+		const identity = {
+			type: item.type,
+			id: item.id || streamingToolCall?.itemId,
+			call_id: item.call_id || streamingToolCall?.callId
+		};
+		const finalOutputIndex = outputIndex ?? streamingToolCall?.outputIndex;
+		if (finalOutputIndex === void 0 && !identity.id && !identity.call_id) {
+			if (!streamingToolCall) throw new Error("Responses stream completed tool call without an output identity");
+			return;
+		}
+		if (streamingToolCall) {
+			streamingToolCalls.forget(streamingToolCall);
+			for (const slot of outputSlots.values()) if (slot.type === "toolCall" && slot.toolCall === streamingToolCall) outputSlots.forget(slot);
+		}
+		terminal.emitToolCallCompletion(identity, finalOutputIndex, streamingToolCall, validated);
+	};
+	const prepareTerminalToolCalls = (items) => {
+		const prepared = /* @__PURE__ */ new Map();
+		const recovered = [];
+		const callIds = /* @__PURE__ */ new Set();
+		const allowUnmatchedIdentity = items.filter((item, index) => item.type === "function_call" && !outputs.get(item, index)?.completed).length === 1;
+		for (const [outputIndex, item] of items.entries()) {
+			const tracked = outputs.get(item, outputIndex);
+			if (item.type !== "function_call") continue;
+			if (item.call_id && callIds.has(item.call_id)) throw new Error("Responses stream repeated a terminal tool-call identity");
+			if (item.call_id) callIds.add(item.call_id);
+			if (tracked?.completed) continue;
+			const state = streamingToolCalls.resolve({ output_index: outputIndex }, readResponsesToolCallItemIdentity(item), allowUnmatchedIdentity);
+			if (tracked && !state) throw new Error("Responses stream completed with unresolved tool calls");
+			const validated = resolveCompletedResponsesToolCall(item, { name: state?.block.name });
+			if (state) recovered.push(state);
+			prepared.set(outputIndex, () => finalizeToolCall(item, outputIndex, state, validated));
+		}
+		if (!streamingToolCalls.hasExactlyActive(recovered)) throw new Error("Responses stream completed with unresolved tool calls");
+		return (outputIndex) => {
+			const complete = prepared.get(outputIndex);
+			if (!complete) throw new Error("Responses stream completed with unresolved tool calls");
+			complete();
+		};
+	};
 	const guardedStream = adaptResponsesStream(withFirstStreamEventTimeout(openaiStream, {
 		provider: model.provider,
 		api: model.api,
@@ -2860,6 +1731,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 						block: toolCallBlock,
 						contentIndex,
 						argumentStreamReliable: true,
+						previewSchedule: createToolArgumentPreviewSchedule(),
 						...readResponsesToolCallItemIdentity(item)
 					};
 					streamingToolCalls.register(event, toolCallState);
@@ -2868,7 +1740,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 						toolCall: toolCallState
 					});
 					output.content.push(toolCallBlock);
-					outputItemContentIndexes.set(item, contentIndex);
+					outputs.set(item, contentIndex, readResponsesOutputIndex(event));
 					stream.push({
 						type: "toolcall_start",
 						contentIndex,
@@ -2994,7 +1866,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				const toolCall = streamingToolCalls.resolve(event);
 				if (toolCall) {
 					toolCall.block.partialJson += event.delta;
-					toolCall.block.arguments = parseStreamingJson(toolCall.block.partialJson);
+					if (toolCall.previewSchedule(toolCall.block.partialJson.length)) toolCall.block.arguments = parseStreamingJson(toolCall.block.partialJson);
 					stream.push({
 						type: "toolcall_delta",
 						contentIndex: toolCall.contentIndex,
@@ -3027,13 +1899,14 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 				if (item.type !== "message") lastTextBlock = null;
 				const existingOutputSlot = resolveOutputItemSlot(event, item);
 				materializeDeferredTextSlots(existingOutputSlot);
-				const outputSlot = existingOutputSlot ?? getOrCreateOutputSlot(event, item);
+				const outputSlot = existingOutputSlot ?? createOutputSlot(event, item);
 				compactionTracker.completed(item, blocks.length);
 				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);
+					outputs.set(item, outputSlot.contentIndex, readResponsesOutputIndex(event) ?? outputSlot.outputIndex, true);
 					if (item.encrypted_content && options?.reasoningReplayMetadata) outputSlot.block[OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY] = options.reasoningReplayMetadata;
 					stream.push({
 						type: "thinking_end",
@@ -3065,7 +1938,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 							partial: output
 						});
 						lastTextBlock = outputSlot.collapseCandidate;
-						outputItemContentIndexes.set(item, outputSlot.collapseCandidate.index);
+						outputs.set(item, outputSlot.collapseCandidate.index, readResponsesOutputIndex(event) ?? outputSlot.outputIndex, true);
 					} else {
 						if (!outputSlot.block) {
 							outputSlot.block = {
@@ -3090,7 +1963,7 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 							index: contentIndex,
 							phase
 						};
-						outputItemContentIndexes.set(item, contentIndex);
+						outputs.set(item, contentIndex, readResponsesOutputIndex(event) ?? outputSlot.outputIndex, true);
 						stream.push({
 							type: "text_end",
 							contentIndex,
@@ -3099,66 +1972,33 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 						});
 					}
 					outputSlots.forget(outputSlot);
-					startedTextBlocksByItemId.delete(item.id);
 				} else if (item.type === "function_call") {
+					if (outputs.get(item, readResponsesOutputIndex(event))?.completed) continue;
 					const streamingToolCall = streamingToolCalls.resolve(event, readResponsesToolCallItemIdentity(item));
 					if (!streamingToolCall && streamingToolCalls.hasActive()) continue;
-					const streamedArguments = streamingToolCall?.block.partialJson ?? "";
 					const completedArguments = typeof item.arguments === "string" ? item.arguments : void 0;
 					if (streamingToolCall && !streamingToolCall.argumentStreamReliable && !completedArguments) continue;
-					const finalArguments = completedArguments !== void 0 && (completedArguments.length > 0 || !streamedArguments) ? completedArguments : streamedArguments;
 					const validated = resolveCompletedResponsesToolCall(item, {
 						name: streamingToolCall?.block.name,
-						arguments: finalArguments
+						arguments: completedArguments || streamingToolCall?.block.partialJson || ""
 					});
-					let toolCall;
-					let contentIndex;
-					if (streamingToolCall) {
-						const block = streamingToolCall.block;
-						block.id = resolveResponsesToolCallId(item, block.id);
-						block.name = validated.name;
-						block.arguments = validated.arguments;
-						delete block.partialJson;
-						toolCall = block;
-						contentIndex = streamingToolCall.contentIndex;
-					} else {
-						toolCall = {
-							type: "toolCall",
-							id: resolveResponsesToolCallId(item),
-							name: validated.name,
-							arguments: validated.arguments
-						};
-						blocks.push(toolCall);
-						contentIndex = blocks.length - 1;
-						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
-					});
-					outputItemContentIndexes.set(item, contentIndex);
+					finalizeToolCall(item, readResponsesOutputIndex(event), streamingToolCall, validated);
 				}
 			} 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 (event.type === "response.incomplete" && streamingToolCalls.hasActive()) throw new Error("Responses stream completed with unresolved tool calls");
+				terminal.finalizeResponse(event.response, event.type);
+				if (event.type === "response.completed" || output.stopReason === "length") {
+					const items = event.response.output ?? [];
+					const completeToolCall = event.type === "response.completed" ? prepareTerminalToolCalls(items) : void 0;
+					terminal.recoverTerminalOutput(items, completeToolCall);
+				}
 				terminalResponse = event.type === "response.completed" ? event.response : null;
 				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(isRecord(event) ? event : {}, model);
-				finalizeFailedResponse(event.response, failure.responseId);
+				terminal.finalizeFailedResponse(event.response, failure.responseId);
 				throw new ResponsesStreamFailure(failure, event.response);
 			}
 		}
@@ -3312,26 +2152,34 @@ async function runResponsesStreamLifecycle(params) {
 			return request;
 		};
 		const requestParams = await buildRequest("checkpoint");
-		firstEventAbort = createFirstStreamEventAbortController(options?.signal);
-		const { stream: openaiStream, response } = await createResponsesStreamWithEncryptedContentRetry({
+		const firstEvent = createFirstStreamEventAbortController(options?.signal);
+		firstEventAbort = firstEvent;
+		let started = false;
+		const { stream: hookedOpenAIStream } = await createResponsesStreamWithEncryptedContentRetry({
 			client,
 			request: requestParams,
 			requestOptions: {
 				...buildResponsesRequestOptions(options),
-				signal: firstEventAbort.signal
+				signal: firstEvent.signal
 			},
 			model,
 			buildFullHistoryRequest: () => buildRequest("full-history"),
-			onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, options, checkpoint)
-		});
-		const hookedOpenAIStream = withProviderResponseHook({
-			stream: openaiStream,
-			signal: firstEventAbort.signal,
-			abort: firstEventAbort.abort,
-			hook: createOpenAIProviderAcceptanceHook(options, response, model),
-			onReady: () => stream.push({
-				type: "start",
-				partial: output
+			onCompactionRejected: (checkpoint) => suppressOpenAIResponsesCompaction(output, model, options, checkpoint),
+			canRetryStream: () => output.content.length === 0,
+			wrapStream: ({ stream: openaiStream, response }) => withProviderResponseHook({
+				stream: openaiStream,
+				signal: firstEvent.signal,
+				abort: firstEvent.abort,
+				hook: createOpenAIProviderAcceptanceHook(options, response, model),
+				onReady: () => {
+					if (!started) {
+						started = true;
+						stream.push({
+							type: "start",
+							partial: output
+						});
+					}
+				}
 			})
 		});
 		const firstEventTimeoutMs = getFirstStreamEventTimeoutMs(options);
@@ -3372,4 +2220,4 @@ async function runResponsesStreamLifecycle(params) {
 	}
 }
 //#endregion
-export { normalizeOpenAIStrictCompatSchema as $, isAzureResponsesTextDeltaEvent as A, buildResponsesInputMessage as B, summarizeResponsesTools as C, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as D, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as E, commitResponsesEncryptedContentAttempt as F, suppressOpenAIResponsesCompaction as G, createOpenAIResponsesAssistantOutput as H, createResponsesStreamWithEncryptedContentRetry as I, isStrictOpenAIJsonSchemaCompatible as J, resolveReplayableResponsesMessageId as K, isInvalidEncryptedContentError as L, isResponsesTextContentPartType as M, isResponsesTextDeltaEventType as N, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as O, resolveResponsesMessageSnapshotCollapse as P, findOpenAIStrictSchemaViolations as Q, resolveAzureOpenAIApiVersion as R, summarizeResponsesPayload as S, readResponsesToolCallItemIdentity as T, buildOpenAIResponsesReasoningReplayMetadata as U, convertResponsesMessages$1 as V, captureOpenAIResponsesCompaction as W, normalizeStrictOpenAIJsonSchema as X, normalizeOpenAIStrictToolParameters as Y, resolveOpenAIProjectedToolsStrictToolFlag as Z, safeDebugValue as _, resolveResponsesReasoningEffort as a, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD as at, summarizeOpenAITransportError as b, processResponsesStream as c, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as ct, resolveResponsesTerminalStopReason as d, resolveModelPayloadDebugMode as dt, extractToolSchemaModelCompat as et, observeResponsesStream as f, resolveModelSseDebugMode as ft, normalizeResponsesFailedEvent as g, logResponsesFailedNoDetails as h, createResponsesAssistantOutput as i, stripUnsupportedSchemaKeywords as it, isAzureResponsesTextDeltaEventType as j, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as k, mapResponsesTerminalUsage as l, cleanSchemaForGemini as lt, buildResponsesFailedNoDetailsObservation as m, applyResponsesServiceTierPricing as n, resolveUnsupportedToolSchemaKeywords as nt, runResponsesStreamLifecycle as o, cleanSchemaForLlamacppGbnf as ot, ResponsesStreamFailure as p, findOpenAIStrictToolProjectionDiagnostics as q, convertResponsesMessages as r, shouldOmitEmptyArrayItems as rt, convertResponsesToolPayload as s, findLlamacppGbnfSchemaViolations as st, applyCommonResponsesParams as t, normalizeToolParameterSchema as tt, readResponsesReasoningTokens as u, emitModelTransportDebug as ut, stringifyRedactedEvent as v, createResponsesToolCallTracker as w, summarizeResponsesFailedNoDetailsObservation as x, stringifyRedactedPayload as y, resolveNextResponsesEncryptedContentAttempt as z };
+export { isAzureResponsesTextDeltaEvent as A, buildResponsesInputMessage as B, summarizeResponsesTools as C, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as D, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as E, commitResponsesEncryptedContentAttempt as F, captureOpenAIResponsesCompaction as G, createOpenAIResponsesAssistantOutput as H, createResponsesStreamWithEncryptedContentRetry as I, resolveReplayableResponsesMessageId as J, resolveNewestOpenAIResponsesCompactionReplay as K, isInvalidEncryptedContentError as L, isResponsesTextContentPartType as M, isResponsesTextDeltaEventType as N, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as O, resolveResponsesMessageSnapshotCollapse as P, resolveAzureOpenAIApiVersion as R, summarizeResponsesPayload as S, readResponsesToolCallItemIdentity as T, CompactionReplayRefreshRequiredError as U, convertResponsesMessages$1 as V, buildOpenAIResponsesReasoningReplayMetadata as W, resolveModelPayloadDebugMode as X, emitModelTransportDebug as Y, resolveModelSseDebugMode as Z, safeDebugValue as _, resolveResponsesReasoningEffort as a, summarizeOpenAITransportError as b, processResponsesStream as c, resolveResponsesTerminalStopReason as d, observeResponsesStream as f, normalizeResponsesFailedEvent as g, logResponsesFailedNoDetails as h, createResponsesAssistantOutput as i, isAzureResponsesTextDeltaEventType as j, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as k, mapResponsesTerminalUsage as l, buildResponsesFailedNoDetailsObservation as m, applyResponsesServiceTierPricing as n, runResponsesStreamLifecycle as o, ResponsesStreamFailure as p, suppressOpenAIResponsesCompaction as q, convertResponsesMessages as r, convertResponsesToolPayload as s, applyCommonResponsesParams as t, readResponsesReasoningTokens as u, stringifyRedactedEvent as v, createResponsesToolCallTracker as w, summarizeResponsesFailedNoDetailsObservation as x, stringifyRedactedPayload as y, resolveNextResponsesEncryptedContentAttempt as z };