@openclaw/ai 2026.8.1-beta.2 → 2026.8.1

package/dist/openai-responses-compaction-window-DwydGZI8.mjs

@@ -0,0 +1,686 @@
+import "./src-Bu3FiFAG.mjs";
+import { n as PROVIDER_POST_DISPATCH_AMBIGUITY_ERROR_CODE } from "./types-BDdaOVi2.mjs";
+import { c as normalizeLowercaseStringOrEmpty, o as isRecord, p as readStringValue, u as normalizeOptionalLowercaseString } from "./utf16-slice-qz3nsy87.mjs";
+import { t as canonicalizeBase64 } from "./base64-CEFBpSkN.mjs";
+import { n as uniqueStrings, t as normalizeStringEntries } from "./string-normalization--fwJ4S2q.mjs";
+import { s as parsePositiveInteger } from "./transport-utils-BHx9z8Cl.mjs";
+import { t as createSseByteGuard } from "./streaming-byte-guard-CC-HMn_u.mjs";
+//#region packages/ai/src/providers/openai-reasoning-effort.ts
+/**
+* OpenAI-compatible reasoning-effort normalization. Different GPT families
+* expose different accepted effort enums, so callers map requested values here
+* before constructing provider payloads.
+*/
+const GPT_5_REASONING_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high"
+];
+const GPT_51_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high"
+];
+const GPT_52_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_56_REASONING_EFFORTS = [
+	"none",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const GPT_CODEX_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_PRO_REASONING_EFFORTS = [
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_5_PRO_REASONING_EFFORTS = ["high"];
+const GPT_51_CODEX_MAX_REASONING_EFFORTS = [
+	"none",
+	"medium",
+	"high",
+	"xhigh"
+];
+const GPT_51_CODEX_MINI_REASONING_EFFORTS = ["medium"];
+const GENERIC_REASONING_EFFORTS = [
+	"low",
+	"medium",
+	"high"
+];
+const CANONICAL_REASONING_EFFORTS = /* @__PURE__ */ new Set([
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"off"
+]);
+function normalizeModelId(id) {
+	return normalizeLowercaseStringOrEmpty(id ?? "").replace(/-\d{4}-\d{2}-\d{2}$/u, "");
+}
+/** Return whether a model is the GPT-5.4 mini family. */
+function isOpenAIGpt54MiniModel(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return /^gpt-5\.4-mini(?:-|$)/u.test(id);
+}
+/** Return whether a model is the GPT-5.5 family. */
+function isOpenAIGpt55Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
+	return /^gpt-5\.5(?:-|$)/u.test(id) || /^gpt-5\.5(?:\s|\(|-|$)/u.test(name);
+}
+/** Return whether a model is the GPT-5.6 family. */
+function isOpenAIGpt56Model(model) {
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	const name = normalizeModelId(typeof model.name === "string" ? model.name : void 0);
+	return /^gpt-5\.6(?:-|$)/u.test(id) || /^gpt-5\.6(?:\s|\(|-|$)/u.test(name);
+}
+/** Normalize user-facing reasoning effort names to API effort names. */
+function normalizeOpenAIReasoningEffort(effort) {
+	const trimmed = effort.trim();
+	const folded = trimmed.toLowerCase();
+	return CANONICAL_REASONING_EFFORTS.has(folded) ? folded : trimmed;
+}
+function readCompatReasoningEfforts(compat) {
+	if (!compat || typeof compat !== "object") return;
+	if (compat.supportsReasoningEffort === false) return [];
+	const raw = compat.supportedReasoningEfforts;
+	if (!Array.isArray(raw)) return;
+	const supported = uniqueStrings(normalizeStringEntries(raw.filter((value) => typeof value === "string")));
+	return supported.length > 0 ? supported : void 0;
+}
+function isDisabledReasoningEffort(effort) {
+	return effort === "none" || effort === "off";
+}
+/** Resolve the reasoning efforts accepted by a specific OpenAI-compatible model. */
+function resolveOpenAISupportedReasoningEfforts(model) {
+	const compatEfforts = readCompatReasoningEfforts(model.compat);
+	if (compatEfforts) return compatEfforts;
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	if (/^gpt-5\.6(?:-|$)/u.test(id)) return GPT_56_REASONING_EFFORTS;
+	if (id === "gpt-5.1-codex-mini") return GPT_51_CODEX_MINI_REASONING_EFFORTS;
+	if (id === "gpt-5.1-codex-max") return GPT_51_CODEX_MAX_REASONING_EFFORTS;
+	if (/^gpt-5(?:\.\d+)?-codex(?:-|$)/u.test(id)) return GPT_CODEX_REASONING_EFFORTS;
+	if (id === "gpt-5-pro") return GPT_5_PRO_REASONING_EFFORTS;
+	if (/^gpt-5\.[2-9](?:\.\d+)?-pro(?:-|$)/u.test(id)) return GPT_PRO_REASONING_EFFORTS;
+	if (/^gpt-5\.[2-9](?:\.\d+)?(?:-|$)/u.test(id)) return GPT_52_REASONING_EFFORTS;
+	if (/^gpt-5\.1(?:-|$)/u.test(id)) return GPT_51_REASONING_EFFORTS;
+	if (/^gpt-5(?:-|$)/u.test(id)) return GPT_5_REASONING_EFFORTS;
+	return GENERIC_REASONING_EFFORTS;
+}
+/**
+* Return whether a model accepts the temperature parameter. The GPT-5.6
+* family rejects it with a 400; catalog compat can override per model.
+*/
+function supportsOpenAITemperature(model) {
+	const compat = model.compat;
+	if (compat && typeof compat === "object") {
+		const declared = compat.supportsTemperature;
+		if (typeof declared === "boolean") return declared;
+	}
+	const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
+	return !/^gpt-5\.6(?:-|$)/u.test(id);
+}
+/** Return whether a model accepts a requested reasoning effort. */
+function supportsOpenAIReasoningEffort(model, effort) {
+	return resolveOpenAISupportedReasoningEfforts(model).includes(normalizeOpenAIReasoningEffort(effort));
+}
+/** Resolve a requested reasoning effort to the closest value supported by the model. */
+function resolveOpenAIReasoningEffortForModel(params) {
+	const requested = normalizeOpenAIReasoningEffort(params.effort);
+	const mapped = params.fallbackMap?.[requested] ?? (params.fallbackMap && CANONICAL_REASONING_EFFORTS.has(requested) ? Object.entries(params.fallbackMap).find(([effort]) => normalizeOpenAIReasoningEffort(effort) === requested)?.[1] : void 0);
+	const normalized = mapped === void 0 ? requested : mapped.trim();
+	const supported = resolveOpenAISupportedReasoningEfforts(params.model);
+	if (supported.includes(normalized)) return normalized;
+	if (requested === "off" && supported.includes("none")) return "none";
+	if (isDisabledReasoningEffort(requested) || isDisabledReasoningEffort(normalized)) return;
+	if (requested === "minimal" && supported.includes("low")) return "low";
+	if ((requested === "minimal" || requested === "low") && supported.includes("medium")) return "medium";
+	if (requested === "xhigh" && supported.includes("high")) return "high";
+	if (requested === "max" && supported.includes("xhigh")) return "xhigh";
+	return supported.find((effort) => !isDisabledReasoningEffort(normalizeOpenAIReasoningEffort(effort)));
+}
+//#endregion
+//#region packages/model-catalog-core/src/provider-id.ts
+function normalizeProviderId(provider) {
+	return normalizeLowercaseStringOrEmpty(provider);
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-contracts.ts
+const DEFAULT_AZURE_OPENAI_API_VERSION = "preview";
+const OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS = "Follow the user request.";
+const AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS = 3e4;
+const RESPONSE_FAILED_NO_DETAILS_MESSAGE = "Unknown error (no error details in response)";
+const OPENAI_RESPONSES_REASONING_REPLAY_META_KEY = "__openclaw_replay";
+const OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY = "openclawReasoningReplay";
+const OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE = "openai-responses-compaction";
+const OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE = "openai-responses-retained-compaction";
+const OPENAI_RESPONSES_APIS = /* @__PURE__ */ new Set([
+	"openai-responses",
+	"azure-openai-responses",
+	"openai-chatgpt-responses",
+	"openclaw-openai-responses-transport",
+	"openclaw-openai-chatgpt-responses-transport",
+	"openclaw-azure-openai-responses-transport"
+]);
+var OpenAIResponsesWebSocketPreDispatchError = class extends Error {
+	constructor(cause) {
+		super("OpenAI Responses WebSocket failed before request dispatch", { cause });
+		this.name = "OpenAIResponsesWebSocketPreDispatchError";
+	}
+};
+var OpenAIResponsesWebSocketPostDispatchError = class extends Error {
+	constructor(cause) {
+		super("OpenAI Responses WebSocket failed after request dispatch; outcome is unknown", { cause });
+		this.code = PROVIDER_POST_DISPATCH_AMBIGUITY_ERROR_CODE;
+		this.name = "OpenAIResponsesWebSocketPostDispatchError";
+	}
+};
+var OpenAIResponsesWebSocketServerError = class extends Error {
+	constructor(code, status, param, message, cause) {
+		super(message, { cause });
+		this.code = code;
+		this.status = status;
+		this.param = param;
+		this.name = "OpenAIResponsesWebSocketServerError";
+	}
+};
+var OpenAIResponsesWebSocketSafeRetryError = class extends OpenAIResponsesWebSocketServerError {};
+function readWebSocketServerError(value) {
+	if (!isRecord(value) || value.type !== "error") return;
+	const details = isRecord(value.error) ? value.error : value;
+	if (typeof details.code !== "string" || typeof details.message !== "string") return;
+	const rawStatus = value.status ?? value.status_code;
+	return {
+		code: details.code,
+		message: details.message,
+		param: typeof details.param === "string" ? details.param : null,
+		status: typeof rawStatus === "number" ? rawStatus : void 0
+	};
+}
+function parseOpenAIResponsesWebSocketServerError(cause) {
+	if (!isRecord(cause)) return;
+	let details = readWebSocketServerError(cause.error) ?? readWebSocketServerError(cause);
+	if (!details && typeof cause.message === "string") try {
+		details = readWebSocketServerError(JSON.parse(cause.message));
+	} catch {}
+	if (!details) return;
+	return new (details.code === "previous_response_not_found" || details.code === "websocket_connection_limit_reached" || details.code === "invalid_encrypted_content" || details.code === "thinking_signature_invalid" ? OpenAIResponsesWebSocketSafeRetryError : OpenAIResponsesWebSocketServerError)(details.code, details.status, details.param, details.message, cause);
+}
+const PROMPT_OBSERVER = Symbol("openaiResponsesPromptObserver");
+const responsesPromptObserver = {
+	set(options, observer) {
+		Reflect.set(options, PROMPT_OBSERVER, observer);
+	},
+	get(options) {
+		return Reflect.get(options, PROMPT_OBSERVER);
+	},
+	copy(source, target) {
+		const observer = source && responsesPromptObserver.get(source);
+		if (observer) responsesPromptObserver.set(target, observer);
+	}
+};
+//#endregion
+//#region packages/ai/src/transports/openai-responses-payload-policy.ts
+/**
+* OpenAI Responses payload policy.
+* Classifies endpoint capabilities and applies store, prompt-cache,
+* server-compaction, service-tier, and reasoning payload rules.
+*/
+const OPENAI_RESPONSES_PROVIDERS = /* @__PURE__ */ new Set([
+	"openai",
+	"azure-openai",
+	"azure-openai-responses"
+]);
+const LOCAL_ENDPOINT_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1",
+	"[::1]"
+]);
+const MODELSTUDIO_NATIVE_BASE_URLS = /* @__PURE__ */ new Set([
+	"https://coding-intl.dashscope.aliyuncs.com/v1",
+	"https://coding.dashscope.aliyuncs.com/v1",
+	"https://dashscope.aliyuncs.com/compatible-mode/v1",
+	"https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+]);
+const MOONSHOT_NATIVE_BASE_URLS = /* @__PURE__ */ new Set(["https://api.moonshot.ai/v1", "https://api.moonshot.cn/v1"]);
+function normalizeComparableBaseUrl(value) {
+	const trimmed = readStringValue(value)?.trim();
+	if (!trimmed) return;
+	const parsedValue = /^[a-z0-9.[\]-]+(?::\d+)?(?:[/?#].*)?$/i.test(trimmed) ? `https://${trimmed}` : trimmed;
+	try {
+		const url = new URL(parsedValue);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return;
+		url.hash = "";
+		url.search = "";
+		return url.toString().replace(/\/+$/, "").toLowerCase();
+	} catch {
+		return;
+	}
+}
+function resolveUrlHostname(value) {
+	const trimmed = readStringValue(value)?.trim();
+	if (!trimmed) return;
+	try {
+		return new URL(trimmed).hostname.toLowerCase();
+	} catch {
+		try {
+			return new URL(`https://${trimmed}`).hostname.toLowerCase();
+		} catch {
+			return;
+		}
+	}
+}
+function hostMatchesSuffix(host, suffix) {
+	return suffix.startsWith(".") || suffix.startsWith("-") ? host.endsWith(suffix) : host === suffix || host.endsWith(`.${suffix}`);
+}
+function isLocalEndpointHost(host) {
+	return LOCAL_ENDPOINT_HOSTS.has(host) || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal");
+}
+function resolveBundledOpenAIResponsesEndpointClass(baseUrl) {
+	const trimmed = readStringValue(baseUrl)?.trim();
+	if (!trimmed) return "default";
+	const host = resolveUrlHostname(trimmed);
+	if (!host) return "invalid";
+	const comparableBaseUrl = normalizeComparableBaseUrl(trimmed);
+	switch (host) {
+		case "api.anthropic.com": return "anthropic-public";
+		case "api.cerebras.ai": return "cerebras-native";
+		case "llm.chutes.ai": return "chutes-native";
+		case "api.deepseek.com": return "deepseek-native";
+		case "api.groq.com": return "groq-native";
+		case "api.mistral.ai": return "mistral-public";
+		case "api.openai.com": return "openai-public";
+		case "chatgpt.com": return "openai";
+		case "generativelanguage.googleapis.com": return "google-generative-ai";
+		case "aiplatform.googleapis.com": return "google-vertex";
+		case "api.x.ai": return "xai-native";
+		case "api.z.ai": return "zai-native";
+	}
+	if (hostMatchesSuffix(host, ".githubcopilot.com")) return "github-copilot-native";
+	if ([
+		".openai.azure.com",
+		".cognitiveservices.azure.com",
+		".services.ai.azure.com",
+		".api.cognitive.microsoft.com"
+	].some((suffix) => hostMatchesSuffix(host, suffix))) return "azure-openai";
+	if (hostMatchesSuffix(host, "openrouter.ai")) return "openrouter";
+	if (hostMatchesSuffix(host, "opencode.ai")) return "opencode-native";
+	if (hostMatchesSuffix(host, "-aiplatform.googleapis.com")) return "google-vertex";
+	if (comparableBaseUrl && MOONSHOT_NATIVE_BASE_URLS.has(comparableBaseUrl)) return "moonshot-native";
+	if (comparableBaseUrl && MODELSTUDIO_NATIVE_BASE_URLS.has(comparableBaseUrl)) return "modelstudio-native";
+	if (isLocalEndpointHost(host)) return "local";
+	return "custom";
+}
+function isOpenAIResponsesApi(api) {
+	return api !== void 0 && OPENAI_RESPONSES_APIS.has(api);
+}
+function readCompatPayloadBoolean(compat, key) {
+	if (!compat || typeof compat !== "object") return;
+	const value = compat[key];
+	return typeof value === "boolean" ? value : void 0;
+}
+function resolveOpenAIResponsesPayloadCapabilities(model) {
+	const provider = normalizeOptionalLowercaseString(model.provider);
+	const api = normalizeOptionalLowercaseString(model.api);
+	const isOpenAIProvider = provider === "openai";
+	const endpointClass = resolveBundledOpenAIResponsesEndpointClass(model.baseUrl);
+	const isResponsesApi = isOpenAIResponsesApi(api);
+	const usesConfiguredBaseUrl = endpointClass !== "default";
+	const usesKnownNativeOpenAIEndpoint = endpointClass === "openai-public" || endpointClass === "openai" || endpointClass === "azure-openai";
+	const usesKnownNativeOpenAIRoute = endpointClass === "default" ? provider === "openai" : usesKnownNativeOpenAIEndpoint;
+	const usesExplicitProxyLikeEndpoint = usesConfiguredBaseUrl && !usesKnownNativeOpenAIEndpoint;
+	const usesVerifiedInstructionsEndpoint = (endpointClass === "default" ? provider === "openai" : endpointClass === "openai-public" || endpointClass === "openai") || endpointClass === "xai-native";
+	const promptCacheKeySupport = readCompatPayloadBoolean(model.compat, "supportsPromptCacheKey");
+	const shouldStripResponsesPromptCache = promptCacheKeySupport === true ? false : promptCacheKeySupport === false ? isResponsesApi : isResponsesApi && usesExplicitProxyLikeEndpoint;
+	const supportsResponsesStoreField = readCompatPayloadBoolean(model.compat, "supportsStore") !== false && isResponsesApi;
+	return {
+		allowsOpenAIServiceTier: provider === "openai" && (api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai-public" || isOpenAIProvider && (api === "openai-chatgpt-responses" || api === "openclaw-openai-chatgpt-responses-transport" || api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai",
+		allowsResponsesStore: supportsResponsesStoreField && api !== "openai-chatgpt-responses" && api !== "openclaw-openai-chatgpt-responses-transport" && provider !== void 0 && OPENAI_RESPONSES_PROVIDERS.has(provider) && usesKnownNativeOpenAIEndpoint,
+		shouldStripResponsesPromptCache,
+		supportsResponsesStoreField,
+		usesKnownNativeOpenAIRoute,
+		usesVerifiedInstructionsEndpoint
+	};
+}
+function resolveOpenAIResponsesCompactThreshold(model) {
+	const contextTokens = parsePositiveInteger(model.contextTokens);
+	const contextWindow = parsePositiveInteger(model.contextWindow);
+	const effectiveBudget = contextTokens && contextWindow ? Math.min(contextTokens, contextWindow) : contextTokens || contextWindow;
+	if (effectiveBudget) return Math.max(1e3, Math.floor(effectiveBudget * .7));
+	return 8e4;
+}
+/** Resolve the server-compaction gate and effective threshold for a Responses route. */
+function resolveOpenAIResponsesServerCompactionPlan(model, extraParams) {
+	const provider = normalizeOptionalLowercaseString(model.provider);
+	const allowsResponsesStore = resolveOpenAIResponsesPayloadCapabilities(model).allowsResponsesStore;
+	const configured = extraParams?.responsesServerCompaction;
+	const enabled = configured !== false && allowsResponsesStore && (configured === true || provider === "openai");
+	return {
+		enabled,
+		threshold: enabled ? parsePositiveInteger(extraParams?.responsesCompactThreshold) ?? resolveOpenAIResponsesCompactThreshold(model) : void 0
+	};
+}
+/** Resolve the manual Responses compact-endpoint gate for one route. */
+function resolveOpenAIResponsesCompactEndpointPlan(model, extraParams) {
+	const configured = extraParams?.responsesCompactEndpoint;
+	const provider = typeof model.provider === "string" ? normalizeProviderId(model.provider) : "";
+	return { enabled: isOpenAIResponsesApi(normalizeOptionalLowercaseString(model.api)) && (configured === true || configured !== false && (provider === "xai" || provider === "x-ai") && resolveBundledOpenAIResponsesEndpointClass(model.baseUrl) === "xai-native") };
+}
+function stripDisabledOpenAIReasoningPayload(payloadObj) {
+	const reasoning = payloadObj.reasoning;
+	if (reasoning === "none") {
+		delete payloadObj.reasoning;
+		return;
+	}
+	if (!reasoning || typeof reasoning !== "object" || Array.isArray(reasoning)) return;
+	if (reasoning.effort === "none") delete payloadObj.reasoning;
+}
+/** Strip returned-item metadata rejected by strict Responses-compatible endpoints. */
+function stripInputItemStatuses(input) {
+	if (!Array.isArray(input)) return;
+	for (const item of input) if (item && typeof item === "object" && !Array.isArray(item)) delete item.status;
+}
+/** Resolve payload mutation policy for one OpenAI Responses-style model endpoint. */
+function resolveOpenAIResponsesPayloadPolicy(model, options = {}) {
+	const capabilities = resolveOpenAIResponsesPayloadCapabilities(model);
+	const storeMode = options.storeMode ?? "provider-policy";
+	const explicitStore = storeMode === "preserve" ? void 0 : storeMode === "disable" ? capabilities.supportsResponsesStoreField ? false : void 0 : capabilities.allowsResponsesStore ? true : void 0;
+	const isResponsesApi = isOpenAIResponsesApi(normalizeOptionalLowercaseString(model.api));
+	const shouldStripDisabledReasoningPayload = isResponsesApi && (!capabilities.usesKnownNativeOpenAIRoute || !supportsOpenAIReasoningEffort(model, "none"));
+	const shouldStripInputStatus = isResponsesApi && !capabilities.usesKnownNativeOpenAIRoute;
+	const serverCompactionPlan = resolveOpenAIResponsesServerCompactionPlan(model, options.extraParams);
+	const usesInstructionsField = readCompatPayloadBoolean(model.compat, "supportsInstructions") ?? capabilities.usesVerifiedInstructionsEndpoint;
+	return {
+		allowsServiceTier: capabilities.allowsOpenAIServiceTier,
+		compactThreshold: serverCompactionPlan.threshold,
+		explicitStore,
+		shouldStripDisabledReasoningPayload,
+		shouldStripInputStatus,
+		shouldStripPromptCache: options.enablePromptCacheStripping === true && capabilities.shouldStripResponsesPromptCache,
+		shouldStripStore: explicitStore !== true && readCompatPayloadBoolean(model.compat, "supportsStore") === false && isResponsesApi,
+		useServerCompaction: options.enableServerCompaction === true && serverCompactionPlan.enabled,
+		usesInstructionsField
+	};
+}
+/** Mutate a Responses request payload according to the resolved endpoint policy. */
+function applyOpenAIResponsesPayloadPolicy(payloadObj, policy) {
+	if (policy.explicitStore !== void 0) payloadObj.store = policy.explicitStore;
+	if (policy.shouldStripStore) delete payloadObj.store;
+	if (policy.shouldStripPromptCache) {
+		delete payloadObj.prompt_cache_key;
+		delete payloadObj.prompt_cache_retention;
+	}
+	if (policy.useServerCompaction && policy.compactThreshold !== void 0 && payloadObj.context_management === void 0) payloadObj.context_management = [{
+		type: "compaction",
+		compact_threshold: policy.compactThreshold
+	}];
+	if (policy.shouldStripDisabledReasoningPayload) stripDisabledOpenAIReasoningPayload(payloadObj);
+	if (policy.shouldStripInputStatus) stripInputItemStatuses(payloadObj.input);
+}
+//#endregion
+//#region packages/media-core/src/inline-image-data-url.ts
+/** Prefix used to distinguish inline data URLs from remote/local image references. */
+const INLINE_IMAGE_DATA_URL_PREFIX = "data:";
+const IMAGE_SIGNATURES = [
+	{
+		mime: "image/png",
+		matches: (buffer) => buffer.length >= 8 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71 && buffer[4] === 13 && buffer[5] === 10 && buffer[6] === 26 && buffer[7] === 10
+	},
+	{
+		mime: "image/jpeg",
+		matches: (buffer) => buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255
+	},
+	{
+		mime: "image/webp",
+		matches: (buffer) => buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP"
+	},
+	{
+		mime: "image/gif",
+		matches: (buffer) => buffer.length >= 6 && (buffer.subarray(0, 6).toString("ascii") === "GIF87a" || buffer.subarray(0, 6).toString("ascii") === "GIF89a")
+	},
+	{
+		mime: "image/bmp",
+		matches: (buffer) => buffer.length >= 2 && buffer[0] === 66 && buffer[1] === 77
+	}
+];
+const HEIC_BRANDS = /* @__PURE__ */ new Set([
+	"heic",
+	"heix",
+	"hevc",
+	"hevx",
+	"heis",
+	"heim",
+	"hevm",
+	"hevs"
+]);
+const HEIF_BRANDS = /* @__PURE__ */ new Set(["mif1", "msf1"]);
+const IMAGE_SIGNATURE_PREFIX_BASE64_CHARS = 128;
+const INLINE_IMAGE_DATA_URL_MIMES = /* @__PURE__ */ new Set([
+	"image/png",
+	"image/jpeg",
+	"image/webp",
+	"image/gif"
+]);
+function startsWithDataUrl(value) {
+	return value.slice(0, 5).toLowerCase() === INLINE_IMAGE_DATA_URL_PREFIX;
+}
+function sniffIsoBmffImageMime(buffer) {
+	if (buffer.length < 12 || buffer.subarray(4, 8).toString("ascii") !== "ftyp") return;
+	const brands = [buffer.subarray(8, 12).toString("ascii")];
+	for (let offset = 16; offset + 4 <= buffer.length; offset += 4) brands.push(buffer.subarray(offset, offset + 4).toString("ascii"));
+	if (brands.some((brand) => HEIC_BRANDS.has(brand))) return "image/heic";
+	if (brands.some((brand) => HEIF_BRANDS.has(brand))) return "image/heif";
+}
+/** Sniffs supported inline image formats from decoded bytes. */
+function sniffInlineImageMime(buffer) {
+	return IMAGE_SIGNATURES.find((signature) => signature.matches(buffer))?.mime ?? sniffIsoBmffImageMime(buffer);
+}
+function isImageMimeType(value) {
+	return value.trim().toLowerCase().startsWith("image/");
+}
+/** Canonicalizes trusted inline image base64 and rejects malformed or non-image payloads. */
+function sanitizeInlineImageBase64(params) {
+	if (!isImageMimeType(params.mimeType)) return;
+	const canonicalPayload = canonicalizeBase64(params.base64);
+	if (!canonicalPayload) return;
+	const sniffedMimeType = sniffInlineImageMime(Buffer.from(canonicalPayload.slice(0, IMAGE_SIGNATURE_PREFIX_BASE64_CHARS), "base64"));
+	if (!sniffedMimeType) return;
+	return {
+		mimeType: sniffedMimeType,
+		base64: canonicalPayload
+	};
+}
+function parseInlineImageDataUrl(value) {
+	if (!startsWithDataUrl(value)) return {
+		metadata: [],
+		payload: value
+	};
+	const commaIndex = value.indexOf(",");
+	if (commaIndex < 0) return;
+	return {
+		metadata: value.slice(5, commaIndex).split(";").map((part) => part.trim()),
+		payload: value.slice(commaIndex + 1)
+	};
+}
+function metadataAllowsImageBase64(metadata) {
+	const [mimeType, ...options] = metadata;
+	return mimeType !== void 0 && isImageMimeType(mimeType) && options.some((part) => part.toLowerCase() === "base64");
+}
+function sanitizeInlineImageDataUrlWithAllowedMimes(imageUrl, allowedMimes) {
+	const parsed = parseInlineImageDataUrl(imageUrl);
+	if (!parsed) return;
+	if (parsed.metadata.length === 0) return imageUrl;
+	if (!metadataAllowsImageBase64(parsed.metadata)) return;
+	const [mimeType] = parsed.metadata;
+	const sanitized = sanitizeInlineImageBase64({
+		mimeType: mimeType ?? "",
+		base64: parsed.payload
+	});
+	if (!sanitized) return;
+	if (allowedMimes && !allowedMimes.has(sanitized.mimeType)) return;
+	return `data:${sanitized.mimeType};base64,${sanitized.base64}`;
+}
+/** Canonicalizes provider-safe inline image data URLs and rejects unsupported formats. */
+function sanitizeInlineImageDataUrl(imageUrl) {
+	return sanitizeInlineImageDataUrlWithAllowedMimes(imageUrl, INLINE_IMAGE_DATA_URL_MIMES);
+}
+//#endregion
+//#region packages/ai/src/transports/responses-image-payload-sanitizer.ts
+/**
+* Sanitizes OpenAI Responses payloads before transport. Invalid inline images
+* are replaced with text placeholders so the request remains valid and
+* auditable.
+*/
+const IMAGE_OMITTED_TEXT = "omitted image payload: invalid inline image data";
+function invalidSnakeImage() {
+	return {
+		type: "input_text",
+		text: `[${IMAGE_OMITTED_TEXT}]`
+	};
+}
+function sanitizeValue(value) {
+	if (Array.isArray(value)) return value.map(sanitizeValue);
+	if (!isRecord(value)) return value;
+	if (value.type === "input_image" && typeof value.image_url === "string") {
+		const imageUrl = sanitizeInlineImageDataUrl(value.image_url);
+		return imageUrl ? {
+			...value,
+			image_url: imageUrl
+		} : invalidSnakeImage();
+	}
+	const next = {};
+	for (const [key, child] of Object.entries(value)) next[key] = sanitizeValue(child);
+	return next;
+}
+/** Sanitize inline image fields inside a Responses API payload. */
+function sanitizeResponsesImagePayload(params) {
+	if (!Array.isArray(params.input)) return params;
+	return {
+		...params,
+		input: sanitizeValue(params.input)
+	};
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-compaction-window.ts
+const COMPACTION_WINDOW_MAX_BYTES = 16 * 1024 * 1024;
+function isOptionalCompactionString(value) {
+	return value === void 0 || typeof value === "string";
+}
+function isBoundedJson(value, depth = 0) {
+	if (depth > 64) return false;
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	return (Array.isArray(value) || isRecord(value)) && Object.values(value).every((child) => isBoundedJson(child, depth + 1));
+}
+function isInputContent(value) {
+	if (!isRecord(value)) return false;
+	const breakpoint = value.prompt_cache_breakpoint;
+	if (breakpoint !== void 0 && (!isRecord(breakpoint) || breakpoint.mode !== "explicit")) return false;
+	switch (value.type) {
+		case "input_text": return typeof value.text === "string";
+		case "input_image": return typeof value.detail === "string" && [
+			"auto",
+			"low",
+			"high",
+			"original"
+		].includes(value.detail) && (typeof value.image_url === "string" || typeof value.file_id === "string") && (value.image_url === null || isOptionalCompactionString(value.image_url)) && (value.file_id === null || isOptionalCompactionString(value.file_id));
+		case "input_file": return (value.detail === void 0 || typeof value.detail === "string" && [
+			"auto",
+			"low",
+			"high"
+		].includes(value.detail)) && [
+			value.file_data,
+			value.file_id,
+			value.file_url
+		].some((entry) => typeof entry === "string") && isOptionalCompactionString(value.file_data) && (value.file_id === null || isOptionalCompactionString(value.file_id)) && isOptionalCompactionString(value.file_url) && isOptionalCompactionString(value.filename);
+		default: return false;
+	}
+}
+/** Validate without projecting: accepted provider fields must survive replay unchanged. */
+function isOpenAIResponsesCompactionOutput(value, model) {
+	if (!Array.isArray(value) || value.length === 0 || !isBoundedJson(value)) return false;
+	const item = value.at(-1);
+	if (!(isRecord(item) && item.type === "compaction" && typeof item.encrypted_content === "string" && item.encrypted_content.length > 0 && isOptionalCompactionString(item.id) && isOptionalCompactionString(item.created_by) && value.slice(0, -1).every((message) => isRecord(message) && message.type === "message" && typeof message.role === "string" && [
+		"user",
+		"developer",
+		"system"
+	].includes(message.role) && isOptionalCompactionString(message.id) && (message.status === void 0 || typeof message.status === "string" && [
+		"in_progress",
+		"completed",
+		"incomplete"
+	].includes(message.status)) && Array.isArray(message.content) && message.content.every(isInputContent)))) return false;
+	const payload = sanitizeResponsesImagePayload({ input: value });
+	if (model) applyOpenAIResponsesPayloadPolicy(payload, resolveOpenAIResponsesPayloadPolicy(model));
+	return JSON.stringify(payload.input) === JSON.stringify(value);
+}
+/** Read the saved canonical window only when it still matches its opaque checkpoint. */
+function readOpenAIResponsesCompactionWindow(replay, model) {
+	const window = replay.compactedWindow;
+	if (!isRecord(window) || window.state !== "ready" || typeof window.output !== "string") return;
+	if (Buffer.byteLength(window.output, "utf8") + Buffer.byteLength(replay.data, "utf8") > COMPACTION_WINDOW_MAX_BYTES) return;
+	try {
+		if (Buffer.byteLength(JSON.stringify(replay), "utf8") > COMPACTION_WINDOW_MAX_BYTES) return;
+		const output = JSON.parse(window.output);
+		if (!isOpenAIResponsesCompactionOutput(output, model)) return;
+		const item = output.at(-1);
+		return item?.type === "compaction" && item.encrypted_content === replay.data && item.id === replay.id ? output : void 0;
+	} catch {
+		return;
+	}
+}
+/** Bound success bytes while leaving body deadlines, retries, and parsing to the SDK. */
+function createBoundedOpenAIResponsesCompactionFetch(upstreamFetch) {
+	return async (input, init) => {
+		const response = await upstreamFetch(input, init);
+		if (!response.ok || !response.body) return response;
+		const reader = response.body.getReader();
+		const guard = createSseByteGuard(reader, {
+			maxBytes: COMPACTION_WINDOW_MAX_BYTES,
+			onOverflow: () => /* @__PURE__ */ new Error("Responses compact endpoint response exceeds 16 MiB")
+		});
+		const body = new ReadableStream({
+			async pull(controller) {
+				try {
+					const chunk = await guard.read();
+					if (chunk.done) {
+						reader.releaseLock();
+						controller.close();
+					} else controller.enqueue(chunk.value);
+				} catch (error) {
+					reader.releaseLock();
+					controller.error(error);
+				}
+			},
+			cancel(reason) {
+				guard.cancel(reason);
+				reader.releaseLock();
+			}
+		});
+		return new Response(body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		});
+	};
+}
+//#endregion
+export { supportsOpenAITemperature as A, isOpenAIGpt54MiniModel as C, resolveOpenAIReasoningEffortForModel as D, normalizeOpenAIReasoningEffort as E, resolveOpenAISupportedReasoningEfforts as O, responsesPromptObserver as S, isOpenAIGpt56Model as T, OpenAIResponsesWebSocketPostDispatchError as _, applyOpenAIResponsesPayloadPolicy as a, RESPONSE_FAILED_NO_DETAILS_MESSAGE as b, resolveOpenAIResponsesServerCompactionPlan as c, OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS as d, OPENAI_RESPONSES_APIS as f, OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE as g, OPENAI_RESPONSES_REASONING_REPLAY_META_KEY as h, sanitizeResponsesImagePayload as i, supportsOpenAIReasoningEffort as k, AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS as l, OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY as m, isOpenAIResponsesCompactionOutput as n, resolveOpenAIResponsesCompactEndpointPlan as o, OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE as p, readOpenAIResponsesCompactionWindow as r, resolveOpenAIResponsesPayloadPolicy as s, createBoundedOpenAIResponsesCompactionFetch as t, DEFAULT_AZURE_OPENAI_API_VERSION as u, OpenAIResponsesWebSocketPreDispatchError as v, isOpenAIGpt55Model as w, parseOpenAIResponsesWebSocketServerError as x, OpenAIResponsesWebSocketSafeRetryError as y };