@openclaw/ai 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/provider-error-BUwEnjXq.mjs

@@ -0,0 +1,429 @@
+import { o as normalizeStringifiedOptionalString } from "./string-coerce-fsri9iCu.mjs";
+import { i as asOptionalRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
+import "./number-coercion-H9qHik3g.mjs";
+//#region packages/normalization-core/src/balanced-json.ts
+function isJsonOpeningDelimiter(char, openers) {
+	return (char === "{" || char === "[") && openers.includes(char);
+}
+/** Extracts the first balanced JSON object/array from text. */
+function extractBalancedJsonPrefix(raw, opts = {}) {
+	const openers = opts.openers ?? ["{", "["];
+	let start = 0;
+	while (start < raw.length && !isJsonOpeningDelimiter(raw[start], openers)) start += 1;
+	const stack = [];
+	let inString = false;
+	let escaped = false;
+	for (let index = start; index < raw.length; index += 1) {
+		const char = raw[index];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === "\"") inString = false;
+		} else if (char === "\"") inString = true;
+		else if (isJsonOpeningDelimiter(char, openers)) stack.push(char);
+		else if (stack.length > 0 && char === (stack.at(-1) === "{" ? "}" : "]")) {
+			stack.pop();
+			if (stack.length === 0) return {
+				json: raw.slice(start, index + 1),
+				startIndex: start,
+				endIndex: index
+			};
+		}
+	}
+	return null;
+}
+/** Extracts every balanced JSON object/array fragment from arbitrary text. */
+function extractBalancedJsonFragments(raw, opts = {}) {
+	const fragments = [];
+	for (let offset = 0; offset < raw.length;) {
+		const fragment = extractBalancedJsonPrefix(raw.slice(offset), opts);
+		if (!fragment) break;
+		fragments.push({
+			json: fragment.json,
+			startIndex: offset + fragment.startIndex,
+			endIndex: offset + fragment.endIndex
+		});
+		offset += fragment.endIndex + 1;
+	}
+	return fragments;
+}
+//#endregion
+//#region packages/normalization-core/src/stable-stringify.ts
+const preserveString = (value) => value;
+/** Deterministically stringifies values, optionally normalizing strings before key ordering. */
+function stableStringify(value, normalizeString = preserveString) {
+	return stringifyStableValue(value, /* @__PURE__ */ new WeakSet(), normalizeString);
+}
+function stringifyStableValue(value, stack, normalizeString) {
+	if (value === null || value === void 0) return String(value);
+	if (typeof value === "number" && !Number.isFinite(value)) return JSON.stringify(String(value));
+	if (typeof value === "bigint") return JSON.stringify(value.toString());
+	if (typeof value === "string") return JSON.stringify(normalizeString(value));
+	if (typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (stack.has(value)) return JSON.stringify("[Circular]");
+	stack.add(value);
+	try {
+		return stringifyObjectValue(value, stack, normalizeString);
+	} finally {
+		stack.delete(value);
+	}
+}
+function stringifyObjectValue(value, stack, normalizeString) {
+	if (value instanceof Error) return stringifyStableValue({
+		name: value.name,
+		message: value.message,
+		stack: value.stack
+	}, stack, normalizeString);
+	if (value instanceof Uint8Array) return stringifyStableValue({
+		type: "Uint8Array",
+		data: encodeBase64(value)
+	}, stack, normalizeString);
+	if (Array.isArray(value)) {
+		const serializedEntries = [];
+		for (const entry of value) serializedEntries.push(stringifyStableValue(entry, stack, normalizeString));
+		return `[${serializedEntries.join(",")}]`;
+	}
+	const record = value;
+	const entries = Object.keys(record).map((key) => ({
+		key,
+		normalizedKey: normalizeString(key)
+	})).toSorted((left, right) => {
+		return compareStableStrings(left.normalizedKey, right.normalizedKey) || compareStableStrings(left.key, right.key);
+	});
+	const serializedFields = [];
+	for (const { key, normalizedKey } of entries) serializedFields.push(`${JSON.stringify(normalizedKey)}:${stringifyStableValue(record[key], stack, normalizeString)}`);
+	return `{${serializedFields.join(",")}}`;
+}
+function encodeBase64(value) {
+	let binary = "";
+	for (const byte of value) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+function compareStableStrings(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
+//#region packages/media-core/src/base64.ts
+/** Estimates decoded bytes without allocating a cleaned copy of the base64 payload. */
+function estimateBase64DecodedBytes(base64) {
+	let effectiveLen = 0;
+	for (let i = 0; i < base64.length; i += 1) {
+		if (base64.charCodeAt(i) <= 32) continue;
+		effectiveLen += 1;
+	}
+	if (effectiveLen === 0) return 0;
+	let padding = 0;
+	let end = base64.length - 1;
+	while (end >= 0 && base64.charCodeAt(end) <= 32) end -= 1;
+	if (end >= 0 && base64[end] === "=") {
+		padding = 1;
+		end -= 1;
+		while (end >= 0 && base64.charCodeAt(end) <= 32) end -= 1;
+		if (end >= 0 && base64[end] === "=") padding = 2;
+	}
+	const estimated = Math.floor(effectiveLen * 3 / 4) - padding;
+	return Math.max(0, estimated);
+}
+const CANONICALIZE_BASE64_CHUNK_SIZE = 8192;
+function isBase64DataChar(code) {
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 43 || code === 47;
+}
+function base64DataValue(code) {
+	if (code >= 65 && code <= 90) return code - 65;
+	if (code >= 97 && code <= 122) return code - 97 + 26;
+	if (code >= 48 && code <= 57) return code - 48 + 52;
+	return code === 43 ? 62 : 63;
+}
+/**
+* Normalizes and validates a base64 string, returning canonical no-whitespace
+* base64 only when the input has valid alphabet, padding, and length.
+*/
+function canonicalizeBase64(base64) {
+	const chunks = [];
+	let current = "";
+	let cleanedLength = 0;
+	let padding = 0;
+	let sawPadding = false;
+	let lastDataCode = 0;
+	const append = (char) => {
+		current += char;
+		cleanedLength += 1;
+		if (current.length >= CANONICALIZE_BASE64_CHUNK_SIZE) {
+			chunks.push(current);
+			current = "";
+		}
+	};
+	for (let i = 0; i < base64.length; i += 1) {
+		const code = base64.charCodeAt(i);
+		if (code <= 32) continue;
+		if (code === 61) {
+			padding += 1;
+			if (padding > 2) return;
+			sawPadding = true;
+			append("=");
+			continue;
+		}
+		if (sawPadding || !isBase64DataChar(code)) return;
+		lastDataCode = code;
+		append(base64[i] ?? "");
+	}
+	if (cleanedLength === 0) return;
+	const remainder = cleanedLength % 4;
+	if (remainder !== 0) {
+		if (sawPadding || remainder === 1) return;
+		current += "=".repeat(4 - remainder);
+	}
+	const effectivePadding = remainder === 0 ? padding : 4 - remainder;
+	const padBitMask = effectivePadding === 2 ? 15 : effectivePadding === 1 ? 3 : 0;
+	if (padBitMask !== 0 && (base64DataValue(lastDataCode) & padBitMask) !== 0) return;
+	if (current) chunks.push(current);
+	return chunks.join("");
+}
+//#endregion
+//#region packages/ai/src/utils/credential-redaction.ts
+const NON_CREDENTIAL_FIELD_NAMES = /* @__PURE__ */ new Set([
+	"passwordfile",
+	"tokenbudget",
+	"tokencount",
+	"tokenfield",
+	"tokenlimit",
+	"tokens"
+]);
+const CREDENTIAL_FIELD_SUFFIX_RE = /(?:apikey|cookie|credential|passphrase|passwd|password|privatekey|secret|secret(?:access)?key|signingkey|token)$/u;
+const MEDIA_PAYLOAD_SUFFIXES = "base64|blob|buffer|bytes|data|delta|frames?|output|result|(?:file|media|source)?(?:uri|url)";
+const MEDIA_FIELD_NAME_RE = new RegExp(`^(?:input|output)?(?:audio|image|video)s?(?:${MEDIA_PAYLOAD_SUFFIXES})*$`, "u");
+const MEDIA_PAYLOAD_SUFFIX_RE = new RegExp(`^(?:${MEDIA_PAYLOAD_SUFFIXES})$`, "u");
+const MEDIA_WRAPPER_NAME_RE = /^(?:input_|output_)?(?:audio|image|video)s?(?:_|$)/iu;
+const AUTHORIZATION_VALUE_RE = /\b(Bearer|Basic)\s+[A-Za-z0-9+/._~=-]{8,}/giu;
+const JWT_VALUE_RE = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/gu;
+const COOKIE_HEADER_RE = /\b((?:set-)?cookie\s*:\s*)([^\r\n]+)/giu;
+const QUOTED_CREDENTIAL_HEADER_RE = /(["'])((?:[A-Za-z][A-Za-z0-9_.-]*[_.-])?(?:api[_.-]?key|authorization|passphrase|passwd|password|private[_.-]?key|secret(?:[_.-]?access)?[_.-]?key|signing[_.-]?key|token))\1\s*:\s*([^,}\r\n]+)/giu;
+const CREDENTIAL_HEADER_RE = /\b((?:[A-Za-z][A-Za-z0-9_.-]*[_.-])?(?:api[_.-]?key|authorization|passphrase|passwd|password|private[_.-]?key|secret(?:[_.-]?access)?[_.-]?key|signing[_.-]?key|token))\s*:\s*([^\r\n]+)/giu;
+const LOOSE_QUOTED_CREDENTIAL_PAIR_RE = /\b((?!(?:api|endpoint|method|model|provider|status|type)=)[A-Za-z][A-Za-z0-9_.-]{0,64})=(["'])([A-Za-z0-9+/._~%=-]{16,})\2/giu;
+const LOOSE_CREDENTIAL_PAIR_RE = /\b((?!(?:api|endpoint|method|model|provider|status|type)=)[A-Za-z][A-Za-z0-9_.-]{0,64})=([A-Za-z0-9+/._~%=-]{16,})(?=[;&#'"\s]|$)/giu;
+const MEDIA_DATA_URL_RE = /data:(?:audio|image|video)\/[a-z0-9.+-]+(?:;[^,;\s]+)*;base64,[ \t]*(?:\r?\n[ \t]*)?[a-z0-9+/_=-]+(?:[ \t]*\r?\n[ \t]*[a-z0-9+/_=-]+)*/giu;
+const MAX_DIAGNOSTIC_JSON_LENGTH = 16 * 1024;
+const PLAIN_BRACKET_TAG_RE = /^\[[A-Za-z0-9][A-Za-z0-9 _.-]*\]$/u;
+const JSON_ARRAY_START_RE = /\[\s*(?:[{"\d\]-]|true\b|false\b|null\b)/u;
+const MALFORMED_JSON_RE = /\{|(?:"[^"]+"|\b(?:b64_json|data|(?:input|output)?(?:audio|image|video)[\w-]*))\s*:/iu;
+function looksLikeDiagnosticJson(value) {
+	return JSON_ARRAY_START_RE.test(value) || MALFORMED_JSON_RE.test(value);
+}
+function normalizeDiagnosticFieldName(value) {
+	return value.toLowerCase().replaceAll(/[^a-z0-9]/g, "");
+}
+function isCredentialFieldName(key) {
+	const normalized = normalizeDiagnosticFieldName(key);
+	if (!normalized || NON_CREDENTIAL_FIELD_NAMES.has(normalized)) return false;
+	return normalized === "authorization" || normalized === "proxyauthorization" || CREDENTIAL_FIELD_SUFFIX_RE.test(normalized);
+}
+function redactCredentialText(value) {
+	return value.replace(AUTHORIZATION_VALUE_RE, "$1 <redacted>").replace(JWT_VALUE_RE, "<redacted-jwt>").replace(COOKIE_HEADER_RE, "$1<redacted>").replace(QUOTED_CREDENTIAL_HEADER_RE, "$1$2$1: <redacted>").replace(CREDENTIAL_HEADER_RE, "$1: <redacted>").replace(LOOSE_QUOTED_CREDENTIAL_PAIR_RE, "$1=$2<redacted>$2").replace(LOOSE_CREDENTIAL_PAIR_RE, "$1=<redacted>");
+}
+function diagnosticBytes(value, numericArrays = false) {
+	return value instanceof ArrayBuffer ? new Uint8Array(value) : ArrayBuffer.isView(value) ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : numericArrays && Array.isArray(value) && value.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255) ? Uint8Array.from(value) : void 0;
+}
+function isDiagnosticMediaPayload(descriptors) {
+	const type = descriptors.type?.value;
+	return typeof type === "string" && /^(?:input|output)?(?:audio|image|video)/u.test(normalizeDiagnosticFieldName(type)) || [
+		"mimeType",
+		"mime_type",
+		"mediaType",
+		"media_type",
+		"contentType",
+		"content_type"
+	].some((key) => {
+		const mime = descriptors[key]?.value;
+		return typeof mime === "string" && /^(?:audio|image|video)\//iu.test(mime);
+	});
+}
+function extractDiagnosticMediaField(key, value, parentMedia) {
+	const normalized = normalizeDiagnosticFieldName(key);
+	const privateField = normalized === "b64json";
+	const mediaField = MEDIA_FIELD_NAME_RE.test(normalized) || MEDIA_WRAPPER_NAME_RE.test(key);
+	const contextualPayload = parentMedia && MEDIA_PAYLOAD_SUFFIX_RE.test(normalized);
+	if (!privateField && !mediaField && !contextualPayload) {
+		const nestedMedia = value !== null && (typeof value === "object" || /^(?:0|[1-9]\d*)$/u.test(key));
+		return parentMedia && nestedMedia ? { kind: "context" } : void 0;
+	}
+	if (/(?:uri|url)$/u.test(normalized)) return { kind: "redacted" };
+	const encoded = diagnosticBytes(value, true) ?? (typeof value === "string" ? value : void 0);
+	if (encoded === void 0) return { kind: privateField || Array.isArray(value) ? "redacted" : "context" };
+	return {
+		kind: "redacted",
+		bytes: typeof encoded === "string" ? estimateBase64DecodedBytes(encoded) : encoded.byteLength,
+		source: encoded
+	};
+}
+function projectDiagnosticValue(value, policy = {}, seen = /* @__PURE__ */ new WeakSet(), mediaPayload = false, state = {
+	changed: false,
+	nodesRemaining: 64
+}) {
+	try {
+		if (typeof value === "string") {
+			const projected = redactDiagnosticText(value);
+			state.changed ||= projected !== value;
+			return projected;
+		}
+		if (!value || typeof value !== "object") return value;
+		const binary = diagnosticBytes(value);
+		if (binary) {
+			state.changed = true;
+			return policy.projectBinary?.(binary) ?? {
+				redacted: "<redacted>",
+				bytes: binary.byteLength
+			};
+		}
+		if (seen.has(value)) return "[Circular]";
+		if (state.nodesRemaining-- <= 0) {
+			state.changed = true;
+			return "[Truncated]";
+		}
+		const keys = Reflect.ownKeys(value).slice(0, 65);
+		const descriptors = Object.fromEntries(keys.slice(0, 64).flatMap((key) => {
+			const descriptor = typeof key === "string" && Object.getOwnPropertyDescriptor(value, key);
+			return descriptor ? [[key, descriptor]] : [];
+		}));
+		state.changed ||= keys.length > 64;
+		seen.add(value);
+		const out = Array.isArray(value) ? [] : {};
+		const rawName = typeof descriptors.name?.value === "string" ? descriptors.name.value : descriptors.key?.value;
+		const redactValueField = keys.length > 64 || typeof rawName === "string" && isCredentialFieldName(rawName);
+		const redactMedia = mediaPayload || keys.length > 64 || isDiagnosticMediaPayload(descriptors);
+		for (const [key, descriptor] of Object.entries(descriptors)) {
+			if (!("value" in descriptor) || !descriptor.enumerable && (policy.propertyScope === "enumerable" || ![
+				"cause",
+				"message",
+				"name",
+				"stack"
+			].includes(key)) || key === "length") continue;
+			const child = descriptor.value;
+			if (policy.omitField?.(key) || isCredentialFieldName(key)) {
+				state.changed = true;
+				continue;
+			}
+			if (redactValueField && key === "value") {
+				out[key] = "<redacted>";
+				state.changed = true;
+				continue;
+			}
+			const media = extractDiagnosticMediaField(key, child, redactMedia);
+			if (media?.kind === "redacted") {
+				const redacted = media.bytes === void 0 ? "<redacted>" : {
+					redacted: "<redacted>",
+					bytes: media.bytes
+				};
+				Object.assign(out, policy.projectMedia?.(key, media) ?? { [key]: redacted });
+				state.changed = true;
+				continue;
+			}
+			out[key] = projectDiagnosticValue(child, policy, seen, media?.kind === "context", state);
+		}
+		return out;
+	} catch {
+		state.changed = true;
+		return "[Unserializable]";
+	}
+}
+/** Redacts bounded structured JSON while preserving harmless diagnostic text byte-for-byte. */
+function redactDiagnosticText(value) {
+	const text = redactCredentialText(value).replace(MEDIA_DATA_URL_RE, "<redacted>");
+	if (!looksLikeDiagnosticJson(text)) return text;
+	if (text.length > MAX_DIAGNOSTIC_JSON_LENGTH) return "[Oversized diagnostic JSON redacted]";
+	let cursor = 0;
+	let redacted = "";
+	let unstructured = "";
+	for (const fragment of extractBalancedJsonFragments(text)) {
+		const plainText = text.slice(cursor, fragment.startIndex);
+		unstructured += plainText;
+		redacted += plainText;
+		try {
+			const state = {
+				changed: false,
+				nodesRemaining: 64
+			};
+			const projected = projectDiagnosticValue(JSON.parse(fragment.json), {}, /* @__PURE__ */ new WeakSet(), false, state);
+			redacted += state.changed ? stableStringify(projected) : fragment.json;
+		} catch {
+			if (!PLAIN_BRACKET_TAG_RE.test(fragment.json) || JSON_ARRAY_START_RE.test(fragment.json)) return "[Malformed diagnostic JSON redacted]";
+			redacted += fragment.json;
+		}
+		cursor = fragment.endIndex + 1;
+	}
+	const remainder = text.slice(cursor);
+	return looksLikeDiagnosticJson(unstructured + remainder) ? "[Malformed diagnostic JSON redacted]" : redacted + remainder;
+}
+//#endregion
+//#region packages/ai/src/utils/provider-error.ts
+const MAX_ERROR_BODY_LENGTH = 4e3;
+let providerErrorRedactor;
+function configureProviderErrorRedactor(redactor) {
+	const previous = providerErrorRedactor;
+	providerErrorRedactor = redactor;
+	return previous;
+}
+function readProviderErrorField(record, key) {
+	const value = record?.[key];
+	return typeof value === "string" || typeof value === "number" && Number.isFinite(value) ? normalizeStringifiedOptionalString(value) : void 0;
+}
+function readCauseCode(error) {
+	const seen = /* @__PURE__ */ new Set();
+	for (let cause = asOptionalRecord(error.cause); cause && seen.size < 8 && !seen.has(cause); cause = asOptionalRecord(cause.cause)) {
+		seen.add(cause);
+		const code = readProviderErrorField(cause, "code");
+		if (code) return code;
+	}
+}
+function stringifyField(value, maxLength) {
+	if (value === void 0 || value === null) return;
+	const text = redactDiagnosticText((typeof value === "string" ? value : stableStringify(value)).trim());
+	if (!text) return;
+	return text.length <= maxLength ? text : `${truncateUtf16Safe(text, maxLength)}... [truncated]`;
+}
+function buildProjection(snapshot, signal) {
+	const error = asOptionalRecord(snapshot);
+	const nestedError = asOptionalRecord(error?.error);
+	const response = asOptionalRecord(error?.response);
+	const status = [
+		error?.status,
+		error?.statusCode,
+		response?.status,
+		response?.statusCode
+	].find((value) => typeof value === "number" && Number.isFinite(value));
+	const bodyValue = error?.errorBody ?? error?.body ?? response?.body ?? response?.data ?? nestedError;
+	const body = stringifyField(bodyValue, MAX_ERROR_BODY_LENGTH);
+	const originalMessage = (typeof snapshot === "string" ? snapshot : void 0) ?? readProviderErrorField(error, "message") ?? readProviderErrorField(nestedError, "message");
+	const genericMessage = originalMessage === `${status} status code (no body)`;
+	let errorMessage = status !== void 0 && body && (!originalMessage || genericMessage) ? `${status}: ${body}` : originalMessage ?? body ?? stringifyField(snapshot, MAX_ERROR_BODY_LENGTH) ?? "Unknown provider error";
+	if (status !== void 0 && !body && originalMessage && !originalMessage.startsWith(String(status))) errorMessage = `${status}: ${errorMessage}`;
+	const rawMetadata = stringifyField(asOptionalRecord(nestedError?.metadata)?.raw, MAX_ERROR_BODY_LENGTH);
+	if (rawMetadata && !errorMessage.includes(rawMetadata)) errorMessage += `\n${rawMetadata}`;
+	const errorCode = readProviderErrorField(error, "errorCode") ?? readProviderErrorField(error, "code") ?? readProviderErrorField(nestedError, "code") ?? (error ? readCauseCode(error) : void 0) ?? (status === void 0 ? void 0 : String(status));
+	const errorType = readProviderErrorField(error, "errorType") ?? readProviderErrorField(error, "type") ?? readProviderErrorField(nestedError, "type");
+	return {
+		stopReason: signal?.aborted ? "aborted" : "error",
+		errorMessage: stringifyField(errorMessage, 4096) ?? "Unknown provider error",
+		...errorCode ? { errorCode: truncateUtf16Safe(errorCode, 256) } : {},
+		...errorType ? { errorType: truncateUtf16Safe(errorType, 256) } : {},
+		...body ? { errorBody: stringifyField(bodyValue, 500) } : {}
+	};
+}
+/** Projects one hostile provider throw into final, bounded assistant terminal fields. */
+function projectProviderError(error, signal) {
+	try {
+		const localSnapshot = projectDiagnosticValue(error);
+		let snapshot = localSnapshot;
+		try {
+			snapshot = providerErrorRedactor?.(localSnapshot) ?? localSnapshot;
+		} catch {}
+		return buildProjection(snapshot, signal);
+	} catch {
+		return {
+			stopReason: signal?.aborted ? "aborted" : "error",
+			errorMessage: "Unknown provider error"
+		};
+	}
+}
+//#endregion
+export { estimateBase64DecodedBytes as a, canonicalizeBase64 as i, projectProviderError as n, stableStringify as o, projectDiagnosticValue as r, configureProviderErrorRedactor as t };

package/dist/provider-error-CzNw4BWX.d.mts

@@ -0,0 +1,12 @@
+//#region packages/ai/src/utils/provider-error.d.ts
+type ProviderErrorProjection = {
+  stopReason: "aborted" | "error";
+  errorMessage: string;
+  errorCode?: string;
+  errorType?: string;
+  errorBody?: string;
+};
+type ProviderErrorRedactor = (value: unknown) => unknown;
+declare function configureProviderErrorRedactor(redactor: ProviderErrorRedactor | undefined): ProviderErrorRedactor | undefined;
+//#endregion
+export { ProviderErrorRedactor as n, configureProviderErrorRedactor as r, ProviderErrorProjection as t };

package/dist/{provider-options-D8bB3z9b.d.mts → provider-options-B96RdNpH.d.mts}

@@ -1,4 +1,4 @@
-import { z as StreamOptions } from "./types-bzp5k29J.mjs";
+import { H as StreamOptions } from "./types-BHNrPS1l.mjs";
 import OpenAI from "openai";
 import Anthropic from "@anthropic-ai/sdk";
 import { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
@@ -73,6 +73,10 @@ declare function reconcileOpenAIResponsesToolChoice(choice: OpenAIResponsesToolC
 declare function reconcileOpenAICompletionsToolChoice(choice: OpenAICompletionsSdkToolChoice, projection: OpenAIToolProjection): OpenAICompletionsSdkToolChoice | undefined;
 //#endregion
 //#region packages/ai/src/provider-options.d.ts
+type OpenAIResponsesCompactionRejection = {
+  data: string;
+  id?: string;
+};
 type AnthropicEffort = "low" | "medium" | "high" | "xhigh" | "max";
 type AnthropicThinkingDisplay = "summarized" | "omitted";
 /** Provider options shared by the Anthropic provider and canonical transport. */
@@ -128,8 +132,10 @@ type BaseOpenAIStreamOptions = StreamOptions & {
   topP?: number;
   authProfileId?: string;
   firstEventTimeoutMs?: number;
-  onFirstEventTimeout?: (reason: Error) => void;
+  onFirstEventTimeout?: (reason: Error) => void; /** Internal owner notification after a server rejects a persisted compaction checkpoint. */
+  onCompactionRejected?: (checkpoint: OpenAIResponsesCompactionRejection) => void;
   openclawCodeModeToolSurface?: boolean;
+  openclawCodeModeAllowedHostedToolTypes?: Set<string>;
   frequencyPenalty?: number;
   presencePenalty?: number;
   seed?: number;
@@ -141,4 +147,4 @@ type OpenAICompletionsOptions = BaseOpenAIStreamOptions & {
   reasoningEffort?: OpenAIReasoningEffort;
 };
 //#endregion
-export { resolveOpenAIReasoningEffortForModel as _, OpenAICompletionsOptions as a, supportsOpenAITemperature as b, projectOpenAITools as c, OpenAIApiReasoningEffort as d, OpenAIReasoningEffort as f, normalizeOpenAIReasoningEffort as g, isOpenAIGpt56Model as h, BaseOpenAIStreamOptions as i, reconcileOpenAICompletionsToolChoice as l, isOpenAIGpt55Model as m, AnthropicOptions as n, OpenAICompletionsToolChoice as o, isOpenAIGpt54MiniModel as p, AnthropicThinkingDisplay as r, OpenAIToolProjection as s, AnthropicEffort as t, reconcileOpenAIResponsesToolChoice as u, resolveOpenAISupportedReasoningEfforts as v, supportsOpenAIReasoningEffort as y };
+export { normalizeOpenAIReasoningEffort as _, OpenAICompletionsOptions as a, supportsOpenAIReasoningEffort as b, OpenAIToolProjection as c, reconcileOpenAIResponsesToolChoice as d, OpenAIApiReasoningEffort as f, isOpenAIGpt56Model as g, isOpenAIGpt55Model as h, BaseOpenAIStreamOptions as i, projectOpenAITools as l, isOpenAIGpt54MiniModel as m, AnthropicOptions as n, OpenAIResponsesCompactionRejection as o, OpenAIReasoningEffort as p, AnthropicThinkingDisplay as r, OpenAICompletionsToolChoice as s, AnthropicEffort as t, reconcileOpenAICompletionsToolChoice as u, resolveOpenAIReasoningEffortForModel as v, supportsOpenAITemperature as x, resolveOpenAISupportedReasoningEfforts as y };

package/dist/provider-transcript-transform-ePx-Bbfr.mjs

@@ -0,0 +1,155 @@
+import { r as createAssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-BYqrYtC_.mjs";
+import { i as transformMessages } from "./host-DTqNc7ad.mjs";
+import { i as asOptionalRecord, t as asNonArrayRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { n as projectProviderError } from "./provider-error-BUwEnjXq.mjs";
+//#region packages/ai/src/transports/transport-stream-shared.ts
+const EMPTY_TOOL_RESULT_TEXT = "(no output)";
+function sanitizeTransportPayloadText(text) {
+	if (typeof text !== "string") return "";
+	return sanitizeSurrogates(text);
+}
+function sanitizeNonEmptyTransportPayloadText(text, fallback = EMPTY_TOOL_RESULT_TEXT) {
+	const sanitized = sanitizeTransportPayloadText(text);
+	return sanitized.trim().length > 0 ? sanitized : fallback;
+}
+function coerceTransportToolCallArguments(argumentsValue) {
+	const argumentsRecord = asOptionalRecord(argumentsValue);
+	if (argumentsRecord) return argumentsRecord;
+	if (typeof argumentsValue === "string") try {
+		return asNonArrayRecord(JSON.parse(argumentsValue));
+	} catch {}
+	return {};
+}
+function mergeTransportHeaders(...headerSources) {
+	const merged = {};
+	for (const headers of headerSources) if (headers) Object.assign(merged, headers);
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeTransportMetadata(payload, metadata) {
+	if (!metadata || Object.keys(metadata).length === 0) return payload;
+	const existingMetadata = asOptionalRecord(payload.metadata);
+	return {
+		...payload,
+		metadata: {
+			...existingMetadata,
+			...metadata
+		}
+	};
+}
+function createEmptyTransportUsage() {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+}
+function createWritableTransportEventStream() {
+	const eventStream = createAssistantMessageEventStream();
+	return {
+		eventStream,
+		stream: eventStream
+	};
+}
+/**
+* Abort error to surface for an aborted `signal`.
+*
+* Rethrows the caller's abort reason only when it carries a `code`, so that code
+* survives into `errorCode` on the persisted assistant message and consumers can
+* recognize an abort's origin without matching error text. A default
+* `abort()` reason is an uncoded DOMException that carries nothing the synthetic
+* error does not, so it keeps the "Request was aborted" text every transport
+* already emits rather than churning it.
+*/
+function transportAbortError(signal) {
+	const reason = signal?.reason;
+	return reason instanceof Error && typeof reason.code === "string" ? reason : /* @__PURE__ */ new Error("Request was aborted");
+}
+/** Run a provider-response hook before start/body consumption inside the first-event deadline. */
+function withProviderResponseHook(params) {
+	return { async *[Symbol.asyncIterator]() {
+		let onAbort;
+		try {
+			if (params.signal.aborted) throw transportAbortError(params.signal);
+			if (params.hook) await Promise.race([Promise.resolve().then(params.hook), new Promise((_resolve, reject) => {
+				onAbort = () => reject(transportAbortError(params.signal));
+				params.signal.addEventListener("abort", onAbort, { once: true });
+			})]);
+		} catch (error) {
+			params.abort(error instanceof Error ? error : new Error(String(error)));
+			throw error;
+		} finally {
+			if (onAbort) params.signal.removeEventListener("abort", onAbort);
+		}
+		if (params.signal.aborted) throw transportAbortError(params.signal);
+		params.onReady?.();
+		if (params.stream) yield* params.stream;
+	} };
+}
+function finalizeTransportStream(params) {
+	const { stream, output, signal } = params;
+	if (signal?.aborted) throw transportAbortError(signal);
+	if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+	stream.push({
+		type: "done",
+		reason: output.stopReason,
+		message: output
+	});
+	stream.end();
+}
+/** @deprecated Use projectProviderError. v2026.7.2-beta.5 compatibility; remove after 2026.10. */
+function assignTransportErrorDetails(output, error, signal) {
+	Object.assign(output, projectProviderError(error, signal));
+}
+function failTransportStream(params) {
+	const { stream, output, signal, error, cleanup } = params;
+	cleanup?.();
+	assignTransportErrorDetails(output, error, signal);
+	stream.push({
+		type: "error",
+		reason: output.stopReason,
+		error: output
+	});
+	stream.end();
+}
+//#endregion
+//#region packages/ai/src/provider-transcript-transform.ts
+const IMAGE_OMISSION = "(image omitted: model does not support images)";
+const VIDEO_OMISSION = "(video omitted: provider does not support video input)";
+function projectUserMediaForTransport(content, supportsImages, supportsVideo) {
+	const result = [];
+	for (const block of content) {
+		if (block.type === "text" || block.type === "image" && supportsImages || block.type === "video" && supportsVideo) {
+			result.push(block);
+			continue;
+		}
+		const text = block.type === "video" ? VIDEO_OMISSION : IMAGE_OMISSION;
+		const previous = result.at(-1);
+		if (block.data.trim() && !(previous?.type === "text" && previous.text === text)) result.push({
+			type: "text",
+			text
+		});
+	}
+	return result;
+}
+function transformProviderMessages(messages, model, normalizeToolCallId) {
+	const target = {
+		...model,
+		input: model.input.filter((type) => type !== "video")
+	};
+	return transformMessages(messages.map((message) => {
+		if (message.role !== "user" || !Array.isArray(message.content)) return message;
+		return Object.assign({}, message, { content: projectUserMediaForTransport(message.content, model.input.includes("image"), model.api === "openai-completions" && model.input.includes("video")) });
+	}), target, normalizeToolCallId);
+}
+//#endregion
+export { createWritableTransportEventStream as a, mergeTransportHeaders as c, sanitizeTransportPayloadText as d, transportAbortError as f, createEmptyTransportUsage as i, mergeTransportMetadata as l, assignTransportErrorDetails as n, failTransportStream as o, withProviderResponseHook as p, coerceTransportToolCallArguments as r, finalizeTransportStream as s, transformProviderMessages as t, sanitizeNonEmptyTransportPayloadText as u };

package/dist/provider-types.d.mts

@@ -0,0 +1,31 @@
+import { a as requiresClaudeMandatoryAdaptiveThinking, c as resolveClaudeMythos5ModelIdentity, d as resolveClaudeSonnet5ModelIdentity, f as supportsClaude1MContext, g as supportsClaudeNativeXhighEffort, h as supportsClaudeNativeMaxEffort, i as requiresClaudeDefaultSampling, l as resolveClaudeNativeThinkingLevelMap, m as supportsClaudeFastMode, n as CLAUDE_OPUS_5_THINKING_PROFILE, o as resolveClaudeFable5ModelIdentity, p as supportsClaudeAdaptiveThinking, r as CLAUDE_SONNET_5_THINKING_PROFILE, s as resolveClaudeModelIdentity, t as CLAUDE_FABLE_5_THINKING_PROFILE, u as resolveClaudeOpus5ModelIdentity } from "./anthropic-SrGtwsJu.mjs";
+import { a as extractDiagnosticError, i as createAssistantMessageDiagnostic, n as DiagnosticErrorInfo, o as formatThrownValue, r as appendAssistantMessageDiagnostic, t as AssistantMessageDiagnostic } from "./diagnostics-BaTA9eVl.mjs";
+import { $ as Usage, A as OpenRouterRouting, B as StreamFn, C as KnownImagesProvider, D as ModelThinkingLevel, E as Model, F as ProviderReplayState, G as ThinkingBudgets, H as StreamOptions, I as ProviderResponse, J as ThinkingLevelMap, K as ThinkingContent, M as PROVIDER_POST_DISPATCH_AMBIGUITY_ERROR_CODE, N as Provider, O as OpenAICompletionsCompat, P as ProviderImagesOptions, Q as Transport, R as SimpleStreamOptions, S as KnownImagesApi, U as TextContent, W as TextSignatureV1, X as ToolCall, Y as Tool, Z as ToolResultMessage, _ as ImagesOptions, a as AssistantMessageEvent, b as ImagesStopReason, c as CacheRetention, d as ImageContent, et as UserMessage, f as ImagesApi, g as ImagesModel, h as ImagesInputContent, i as AssistantMessage, j as PROVIDER_FAILURE_WITH_OUTPUT_ERROR_CODE, k as OpenAIResponsesCompat, l as CompleteSimpleFn, m as ImagesFunction, n as Api, nt as VercelGatewayRouting, o as AssistantMessageEventStreamContract, p as ImagesContext, q as ThinkingLevel, r as AssistantImages, s as AssistantMessageEventStreamLike, t as AnthropicMessagesCompat, tt as ValidateToolArgumentsFn, u as Context, v as ImagesOutputContent, w as MaybePromise, x as KnownApi, y as ImagesProvider, z as StopReason } from "./types-BHNrPS1l.mjs";
+import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-BP6AWT8j.mjs";
+import { n as validateToolCall, t as validateToolArguments } from "./validation-DT9SrFn3.mjs";
+//#region packages/ai/src/provider-types.d.ts
+declare const PROVIDER_CONTEXT_HANDOFF: unique symbol;
+type VideoContent = Omit<ImageContent, "type"> & {
+  type: "video";
+};
+type MediaContent = ImageContent | VideoContent;
+type ModelInputContent = TextContent | MediaContent;
+type ProviderUserMessage = Omit<UserMessage, "content"> & {
+  content: string | ModelInputContent[];
+};
+type ProviderMessage = ProviderUserMessage | AssistantMessage | ToolResultMessage;
+type ProviderContext = Omit<Context, "messages"> & {
+  messages: ProviderMessage[];
+};
+type ProviderModel<TApi extends Api = Api> = Omit<Model<TApi>, "input"> & {
+  input: ModelInputContent["type"][];
+};
+type ProviderContextHandoff = () => Promise<ProviderContext>;
+type ProviderStreamOptions = StreamOptions & {
+  [PROVIDER_CONTEXT_HANDOFF]?: ProviderContextHandoff;
+};
+type ProviderStreamFunction<TApi extends Api = Api, TOptions extends StreamOptions = ProviderStreamOptions> = (model: ProviderModel<TApi>, context: ProviderContext, options?: TOptions) => AssistantMessageEventStreamContract;
+/** Resolves provider-only context without widening the canonical call contract. */
+declare function resolveProviderContext(context: Context | ProviderContext, options?: ProviderStreamOptions): Promise<ProviderContext>;
+//#endregion
+export { type AnthropicMessagesCompat, type Api, type AssistantImages, type AssistantMessage, type AssistantMessageDiagnostic, type AssistantMessageEvent, type AssistantMessageEventStream, type AssistantMessageEventStreamContract, type AssistantMessageEventStreamLike, type CLAUDE_FABLE_5_THINKING_PROFILE, type CLAUDE_OPUS_5_THINKING_PROFILE, type CLAUDE_SONNET_5_THINKING_PROFILE, type CacheRetention, type CompleteSimpleFn, type ProviderContext as Context, ProviderContext, type DiagnosticErrorInfo, type EventStream, type ImageContent, type ImagesApi, type ImagesContext, type ImagesFunction, type ImagesInputContent, type ImagesModel, type ImagesOptions, type ImagesOutputContent, type ImagesProvider, type ImagesStopReason, type KnownApi, type KnownImagesApi, type KnownImagesProvider, type MaybePromise, MediaContent, type ProviderMessage as Message, ProviderMessage, type ProviderModel as Model, ProviderModel, ModelInputContent, type ModelThinkingLevel, type OpenAICompletionsCompat, type OpenAIResponsesCompat, type OpenRouterRouting, PROVIDER_CONTEXT_HANDOFF, type PROVIDER_FAILURE_WITH_OUTPUT_ERROR_CODE, type PROVIDER_POST_DISPATCH_AMBIGUITY_ERROR_CODE, type Provider, ProviderContextHandoff, type ProviderImagesOptions, type ProviderReplayState, type ProviderResponse, ProviderStreamFunction, type ProviderStreamFunction as StreamFunction, ProviderStreamOptions, ProviderUserMessage, type SimpleStreamOptions, type StopReason, type StreamFn, type StreamOptions, type TextContent, type TextSignatureV1, type ThinkingBudgets, type ThinkingContent, type ThinkingLevel, type ThinkingLevelMap, type Tool, type ToolCall, type ToolResultMessage, type Transport, type Usage, type UserMessage, type ValidateToolArgumentsFn, type VercelGatewayRouting, VideoContent, type appendAssistantMessageDiagnostic, type createAssistantMessageDiagnostic, type createAssistantMessageEventStream, type extractDiagnosticError, type formatThrownValue, type requiresClaudeDefaultSampling, type requiresClaudeMandatoryAdaptiveThinking, type resolveClaudeFable5ModelIdentity, type resolveClaudeModelIdentity, type resolveClaudeMythos5ModelIdentity, type resolveClaudeNativeThinkingLevelMap, type resolveClaudeOpus5ModelIdentity, type resolveClaudeSonnet5ModelIdentity, resolveProviderContext, type supportsClaude1MContext, type supportsClaudeAdaptiveThinking, type supportsClaudeFastMode, type supportsClaudeNativeMaxEffort, type supportsClaudeNativeXhighEffort, type validateToolArguments, type validateToolCall };