@openclaw/ai 2026.9.4 → 2026.9.6

package/dist/{openai-transport-params-9aPuV5YY.mjs → openai-transport-params-DZKOTSfH.mjs}

@@ -1,18 +1,20 @@
 import { a as normalizeOptionalString, n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
-import { A as applyProviderReportedUsageCost, j as calculateCost, n as getAiTransportHost } from "./host-B8YfDGd4.mjs";
 import { o as isRecord, r as asOptionalObjectRecord } from "./record-coerce-DwRYMj3t.mjs";
-import { l as usesNativeOpenAICodexResponsesBackend, n as clampOpenAIPromptCacheKey, s as resolveOpenAICompletionsCompat } from "./openai-prompt-cache-Bds-n_9Q.mjs";
-import { i as isCodeModeModelVisibleToolName } from "./transport-utils-zrYjICLZ.mjs";
-import { n as resolveModelRequestTimeoutMs, o as resolveProviderRequestPolicyConfig } from "./host-policy-Zcg_cNz8.mjs";
-import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-ClptDdAO.mjs";
-import { O as headersToRecord, p as notifyProviderHttpResponse, v as transportAbortError } from "./transport-stream-shared-zHll9BxO.mjs";
+import { a as normalizeOpenAIReasoningEffort, c as resolveOpenAIReasoningEffortMapping, f as MODEL_CATALOG_THINKING_LEVELS, m as resolveOpenAIThinkingApi, o as resolveOpenAIModelReasoningEfforts, s as resolveOpenAIReasoningEffortForModel, u as supportsOpenAIReasoningEffort } from "./openai-reasoning-effort-ash8dPrd.mjs";
+import { A as headersToRecord, M as calculateCost, N as clampThinkingLevel, j as applyProviderReportedUsageCost, n as getAiTransportHost } from "./host-yTvBrYM2.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-CjV_2IRI.mjs";
+import { i as isCodeModeModelVisibleToolName } from "./transport-utils-03Qi0CN2.mjs";
+import { i as resolveOpenAICompletionsCompat, o as usesNativeOpenAICodexResponsesBackend } from "./openai-completions-compat-CUollwl6.mjs";
+import { n as resolveModelRequestTimeoutMs, o as resolveProviderRequestPolicyConfig } from "./host-policy-DZO3oPPk.mjs";
+import { n as projectRuntimeToolInputSchema, t as prepareRuntimeToolInputSchema } from "./tool-schema-json-projection-CD9c_fK8.mjs";
+import { p as notifyProviderHttpResponse, v as transportAbortError } from "./transport-stream-shared-B5RioB_Q.mjs";
 import { n as resolveOpencodeSessionHeaders } from "./session-affinity-Bcunsn4I.mjs";
-import { i as OPENAI_RESPONSES_APIS } from "./openai-responses-contracts-DDOHA62Y.mjs";
-import { a as resolveOpenAIProjectedToolsStrictToolFlag, t as findOpenAIStrictToolProjectionDiagnostics } from "./openai-tool-schema-CzjyYXun.mjs";
-import { createHash } from "node:crypto";
+import { a as resolveOpenAIProjectedToolsStrictToolFlag, t as findOpenAIStrictToolProjectionDiagnostics } from "./openai-tool-schema-D4BMcj2D.mjs";
+import { i as OPENAI_RESPONSES_APIS } from "./openai-responses-contracts-DWrfMODE.mjs";
+import { hash } from "node:crypto";
 //#region packages/normalization-core/src/node-crypto.ts
 function sha256Hex(input) {
-	return createHash("sha256").update(input).digest("hex");
+	return hash("sha256", input, "hex");
 }
 function sha256HexPrefixCore(input, length) {
 	return sha256Hex(input).slice(0, length);
@@ -29,6 +31,16 @@ function redactIdentifier(value, opts) {
 /** Shared options, usage shape, cache identity, ordering, and stream scheduling for OpenAI APIs. */
 const MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS = 12;
 const MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS = 64;
+const OPENAI_RESPONSE_MODEL_HEADER_NAMES = /* @__PURE__ */ new Set(["openai-model", "x-openai-model"]);
+const OPENAI_RESPONSE_MODEL_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"response.created",
+	"response.in_progress",
+	"response.completed",
+	"response.done",
+	"response.incomplete",
+	"response.failed"
+]);
+const OPENAI_DATED_MODEL_SUFFIX = /-(?:\d{8}|\d{4}-\d{2}-\d{2})$/;
 const GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP = "skip_thought_signature_validator";
 const log = {
 	debug(message, data) {
@@ -44,6 +56,69 @@ const log = {
 		getAiTransportHost().logWarn("openai-transport", message, data);
 	}
 };
+const OPENAI_RESPONSE_MODEL_CONFLICT = "Conflicting OpenAI response model attestations";
+function splitOpenAIResponseModelHeader(value) {
+	return value ? value.split(",").map((part) => part.trim()).filter(Boolean) : [];
+}
+function readOpenAIResponseModelHeaders(headers) {
+	return [...OPENAI_RESPONSE_MODEL_HEADER_NAMES].flatMap((name) => splitOpenAIResponseModelHeader(headers.get(name)));
+}
+function readOpenAIResponseModelHeaderRecord(headers) {
+	if (!isRecord(headers)) return [];
+	return Object.entries(headers).filter(([name]) => OPENAI_RESPONSE_MODEL_HEADER_NAMES.has(name.toLowerCase())).flatMap(([, value]) => typeof value === "string" ? splitOpenAIResponseModelHeader(value) : []);
+}
+function readOpenAIResponseModelEvent(event) {
+	if (!isRecord(event)) return [];
+	const response = isRecord(event.response) ? event.response : void 0;
+	return [
+		...OPENAI_RESPONSE_MODEL_EVENT_TYPES.has(String(event.type)) && typeof response?.model === "string" && response.model.trim() ? [response.model.trim()] : [],
+		...readOpenAIResponseModelHeaderRecord(response?.headers),
+		...readOpenAIResponseModelHeaderRecord(event.headers)
+	];
+}
+function reconcileOpenAIResponseModels(current, observed) {
+	if (!current || current === observed) return observed;
+	const currentBase = current.replace(OPENAI_DATED_MODEL_SUFFIX, "");
+	const observedBase = observed.replace(OPENAI_DATED_MODEL_SUFFIX, "");
+	if (currentBase !== observedBase) return;
+	if (currentBase === current && observedBase !== observed) return observed;
+	if (observedBase === observed && currentBase !== current) return current;
+}
+function createResponseModelTracker(enabled = true) {
+	let responseModel;
+	const observe = (models) => {
+		for (const model of models) {
+			const reconciled = reconcileOpenAIResponseModels(responseModel, model);
+			if (!reconciled) throw new Error(OPENAI_RESPONSE_MODEL_CONFLICT);
+			responseModel = reconciled;
+		}
+	};
+	const begin = (headers) => {
+		responseModel = void 0;
+		if (enabled && headers) observe(readOpenAIResponseModelHeaders(headers));
+	};
+	const observeEvent = (event) => {
+		if (enabled) observe(readOpenAIResponseModelEvent(event));
+		return responseModel;
+	};
+	const resolve = () => responseModel;
+	return {
+		begin,
+		observeEvent,
+		resolve,
+		track(response, stream) {
+			if (!enabled) return stream;
+			return (async function* () {
+				begin(response?.headers);
+				for await (const event of stream) {
+					observeEvent(event);
+					yield event;
+				}
+			})();
+		},
+		terminalOptions: enabled ? { resolveResponseModel: resolve } : {}
+	};
+}
 function resolveOpenAIClientBaseUrl(model, baseUrl = model.baseUrl) {
 	if (baseUrl?.trim()) return baseUrl;
 	if (model.provider.trim().toLowerCase() === "openai") return;
@@ -192,14 +267,13 @@ function createModelStreamCooperativeScheduler(signal) {
 	return { async afterEvent() {
 		throwIfModelStreamAborted(signal);
 		eventsSinceYield += 1;
-		const now = Date.now();
-		if (eventsSinceYield < MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS && now - lastYieldedAt < MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS) return;
+		if (eventsSinceYield < MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS && Date.now() - lastYieldedAt < MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS) return;
 		eventsSinceYield = 0;
-		lastYieldedAt = now;
 		await new Promise((resolve) => {
 			setTimeout(resolve, 0);
 		});
 		throwIfModelStreamAborted(signal);
+		lastYieldedAt = Date.now();
 	} };
 }
 function resolvePromptCacheKey(options, cacheRetention) {
@@ -262,6 +336,45 @@ function readOpenAICompletionsContentPartDeltas(content) {
 	return [];
 }
 //#endregion
+//#region packages/ai/src/transports/openai-reasoning-compat.ts
+/** Explicit model reasoning-effort compatibility metadata. */
+function readCompatReasoningEffortMap(compat) {
+	const rawMap = asOptionalObjectRecord(asOptionalObjectRecord(compat)?.reasoningEffortMap);
+	if (!rawMap) return {};
+	return Object.fromEntries(Object.entries(rawMap).filter((entry) => typeof entry[1] === "string"));
+}
+/** Resolves the reasoning effort remap for an OpenAI-compatible model. */
+function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
+	return {
+		...fallbackMap,
+		...readCompatReasoningEffortMap(model.compat)
+	};
+}
+//#endregion
+//#region packages/ai/src/providers/openai-request-reasoning.ts
+/** Preserve explicit off until the selected route maps it to its native value. */
+function resolveOpenAISimpleReasoningEffort(model, reasoning) {
+	return reasoning === void 0 ? void 0 : clampThinkingLevel(model, reasoning);
+}
+function resolveOpenAIRequestReasoning(model, reasoning) {
+	const requested = normalizeOpenAIReasoningEffort(reasoning ?? "off");
+	const modelLevel = MODEL_CATALOG_THINKING_LEVELS.find((candidate) => candidate === requested);
+	const modelMapped = modelLevel ? model.thinkingLevelMap?.[modelLevel] : void 0;
+	const mapped = modelMapped === null ? null : resolveOpenAIReasoningEffortMapping(requested, resolveOpenAIReasoningEffortMap(model)) ?? modelMapped;
+	const intent = mapped !== void 0 ? mapped?.trim() : reasoning === void 0 ? void 0 : requested;
+	const normalizedIntent = normalizeOpenAIReasoningEffort(intent ?? "off");
+	const supported = resolveOpenAIModelReasoningEfforts(model);
+	const effort = !model.reasoning || supported?.length === 0 || intent === void 0 ? void 0 : supported === void 0 ? mapped !== void 0 ? intent : requested === "off" ? "none" : requested : resolveOpenAIReasoningEffortForModel({
+		model,
+		effort: requested,
+		fallbackMap: { [requested]: intent }
+	});
+	return {
+		effort: effort === "none" && resolveOpenAIThinkingApi(model.api) === "openai-chatgpt-responses" && !supportsOpenAIReasoningEffort(model.id === "gpt-6-sol" || model.id === "gpt-6-luna" ? model : { compat: model.compat }, "none") ? void 0 : effort,
+		thinkingEnabled: intent === void 0 ? void 0 : model.reasoning && normalizedIntent !== "off" && normalizedIntent !== "none"
+	};
+}
+//#endregion
 //#region packages/ai/src/providers/openai-tool-projection.ts
 function unreadableToolDiagnostic(toolIndex) {
 	return {
@@ -271,6 +384,17 @@ function unreadableToolDiagnostic(toolIndex) {
 }
 /** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
 function projectOpenAITools(tools) {
+	return projectOpenAIToolDescriptors(tools);
+}
+/** Package-private facts are consumed before the projection or payload can escape. */
+function prepareOpenAITools(tools) {
+	const schemas = /* @__PURE__ */ new Map();
+	return {
+		projection: projectOpenAIToolDescriptors(tools, schemas),
+		schemas
+	};
+}
+function projectOpenAIToolDescriptors(tools, schemas) {
 	let inputToolCount;
 	try {
 		inputToolCount = tools.length;
@@ -324,7 +448,8 @@ function projectOpenAITools(tools) {
 			});
 			continue;
 		}
-		const schemaProjection = projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
+		const prepared = schemas ? prepareRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`) : void 0;
+		const schemaProjection = prepared?.projection ?? projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
 		if (!isRecord(schemaProjection.schema) || schemaProjection.violations.length > 0) {
 			diagnostics.push({
 				toolIndex,
@@ -333,6 +458,7 @@ function projectOpenAITools(tools) {
 			});
 			continue;
 		}
+		if (prepared?.normalization) schemas?.set(schemaProjection.schema, prepared.normalization);
 		let descriptionValue;
 		try {
 			descriptionValue = tool.description;
@@ -448,36 +574,10 @@ function reconcileOpenAICompletionsToolChoice(choice, projection) {
 	};
 }
 //#endregion
-//#region packages/ai/src/transports/openai-reasoning-compat.ts
-/**
-* OpenAI reasoning-effort compatibility helpers.
-*
-* Keeps provider metadata and built-in model exceptions on one path before request payloads are built.
-*/
-const OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS = /* @__PURE__ */ new Set(["gpt-5.1-codex-mini"]);
-function readCompatReasoningEffortMap(compat) {
-	const rawMap = asOptionalObjectRecord(asOptionalObjectRecord(compat)?.reasoningEffortMap);
-	if (!rawMap) return {};
-	return Object.fromEntries(Object.entries(rawMap).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string"));
-}
-/** Resolves the reasoning effort remap for an OpenAI-compatible model. */
-function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
-	const provider = normalizeLowercaseStringOrEmpty(model.provider ?? "");
-	const id = normalizeLowercaseStringOrEmpty(model.id ?? "");
-	const builtinMap = provider === "openai" && OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS.has(id) ? {
-		minimal: "medium",
-		low: "medium"
-	} : {};
-	return {
-		...fallbackMap,
-		...builtinMap,
-		...readCompatReasoningEffortMap(model.compat)
-	};
-}
-//#endregion
 //#region packages/ai/src/transports/openai-transport-params.ts
 const MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS = 256;
 const loggedOpenAIStrictToolDowngradeDiagnosticKeys = /* @__PURE__ */ new Set();
+const OPENAI_COMPLETIONS_APIS = /* @__PURE__ */ new Set(["openai-completions", "openclaw-openai-completions-transport"]);
 function readToolPayloadField(record, field) {
 	try {
 		return Object.hasOwn(record, field) ? record[field] : void 0;
@@ -616,6 +716,19 @@ function resolveOpenAIStrictToolFlagWithDiagnostics(projection, strictSetting, c
 function buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, sessionId, cacheRetention) {
 	const providerHeaders = { ...model.headers };
 	if (model.provider === "github-copilot") Object.assign(providerHeaders, getAiTransportHost().buildCopilotDynamicHeaders(context.messages));
+	if (OPENAI_COMPLETIONS_APIS.has(model.api) && sessionId && cacheRetention !== "none") {
+		const { sessionAffinity } = resolveOpenAICompletionsCompat(model);
+		if (sessionAffinity !== "none") {
+			const affinityValue = clampOpenAIPromptCacheKey(sessionId) ?? sessionId;
+			const affinityHeaders = sessionAffinity === "openrouter" ? ["x-session-id"] : [
+				"session_id",
+				"x-client-request-id",
+				"x-session-affinity"
+			];
+			const configuredHeaders = new Set(Object.keys(providerHeaders).map((key) => key.toLowerCase()));
+			for (const name of affinityHeaders) if (!configuredHeaders.has(name)) providerHeaders[name] = affinityValue;
+		}
+	}
 	const callerHeaders = {
 		...optionHeaders,
 		...turnHeaders
@@ -637,18 +750,15 @@ function buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, se
 		headers: resolvedHeaders
 	}) ?? resolvedHeaders;
 }
-function resolveOpenAISdkTimeoutMs(model, timeoutMs) {
-	return resolveModelRequestTimeoutMs(model, timeoutMs);
-}
 function buildOpenAISdkClientOptions(model) {
-	const timeout = resolveOpenAISdkTimeoutMs(model);
+	const timeout = resolveModelRequestTimeoutMs(model);
 	return {
 		...timeout === void 0 ? {} : { timeout },
 		maxRetries: 0
 	};
 }
 function buildOpenAISdkRequestOptions(model, signal, options) {
-	const timeout = resolveOpenAISdkTimeoutMs(model, options?.timeoutMs);
+	const timeout = resolveModelRequestTimeoutMs(model, options?.timeoutMs);
 	const headers = options?.stream === true && usesNativeOpenAICodexResponsesBackend(model) ? { Accept: "text/event-stream" } : void 0;
 	if (timeout === void 0 && !signal && !headers) return;
 	return {
@@ -672,4 +782,4 @@ function getCompat(model) {
 	};
 }
 //#endregion
-export { readOpenAICompletionsContentDeltas as C, throwIfModelStreamAborted as D, resolvePromptCacheKey as E, redactIdentifier as O, parseOpenAICompletionsUsage as S, resolveOpenAIClientBaseUrl as T, createOpenAIProviderAcceptanceHook as _, enforceCodeModeResponsesToolSurface as a, log as b, readCodeModePayloadToolName as c, resolveOpenAIReasoningEffortMap as d, projectOpenAITools as f, createModelStreamCooperativeScheduler as g, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as h, buildOpenAISdkRequestOptions as i, sha256Hex as k, resolveCodeModeResponsesVisibleToolNames as l, reconcileOpenAIResponsesToolChoice as m, buildOpenAIClientHeaders as n, filterCodeModePayloadTools as o, reconcileOpenAICompletionsToolChoice as p, buildOpenAISdkClientOptions as r, getCompat as s, assertCodeModeResponsesToolSurface as t, resolveOpenAIStrictToolFlagWithDiagnostics as u, createOpenAIResponseHook as v, readOpenAICompletionsReasoningBatch as w, measureUtf8AppendBytes as x, isOpenAICompletionsThinkingEnabled as y };
+export { resolvePromptCacheKey as A, isOpenAICompletionsThinkingEnabled as C, readOpenAICompletionsContentDeltas as D, parseOpenAICompletionsUsage as E, redactIdentifier as M, sha256Hex as N, readOpenAICompletionsReasoningBatch as O, createResponseModelTracker as S, measureUtf8AppendBytes as T, resolveOpenAIReasoningEffortMap as _, enforceCodeModeResponsesToolSurface as a, createOpenAIProviderAcceptanceHook as b, readCodeModePayloadToolName as c, prepareOpenAITools as d, projectOpenAITools as f, resolveOpenAISimpleReasoningEffort as g, resolveOpenAIRequestReasoning as h, buildOpenAISdkRequestOptions as i, throwIfModelStreamAborted as j, resolveOpenAIClientBaseUrl as k, resolveCodeModeResponsesVisibleToolNames as l, reconcileOpenAIResponsesToolChoice as m, buildOpenAIClientHeaders as n, filterCodeModePayloadTools as o, reconcileOpenAICompletionsToolChoice as p, buildOpenAISdkClientOptions as r, getCompat as s, assertCodeModeResponsesToolSurface as t, resolveOpenAIStrictToolFlagWithDiagnostics as u, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as v, log as w, createOpenAIResponseHook as x, createModelStreamCooperativeScheduler as y };

package/dist/{positive-integer-41zhOdcV.mjs → positive-integer-BiUxrd71.mjs}

@@ -1,4 +1,4 @@
-import { o as parseStrictPositiveInteger } from "./base64-D-su8YVo.mjs";
+import { o as parseStrictPositiveInteger } from "./base64-CPmadnUf.mjs";
 //#region packages/ai/src/transports/positive-integer.ts
 function parsePositiveInteger(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);

package/dist/{provider-error-BA-v_tKd.mjs → provider-error-CRhW7lkJ.mjs}

@@ -1,7 +1,8 @@
 import { o as normalizeStringifiedOptionalString } from "./string-coerce-fsri9iCu.mjs";
 import { i as asOptionalRecord } from "./record-coerce-DwRYMj3t.mjs";
 import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
-import { n as estimateBase64DecodedBytes } from "./base64-D-su8YVo.mjs";
+import { t as expectDefined } from "./expect-lbe3Hgrh.mjs";
+import { n as estimateBase64DecodedBytes } from "./base64-CPmadnUf.mjs";
 import { parseRetryAfterErrorSeconds, parseRetryAfterHeadersSeconds } from "./internal/retry-after.mjs";
 //#region packages/normalization-core/src/balanced-json.ts
 function isJsonOpeningDelimiter(char, openers) {
@@ -47,12 +48,54 @@ function extractBalancedJsonFragments(raw, opts = {}) {
 	return fragments;
 }
 //#endregion
-//#region packages/normalization-core/src/expect.ts
-/** Returns the value or throws with the named context; use for genuine invariants only. */
-function expectDefined(value, context) {
-	if (value === null || value === void 0) throw new Error("expected " + context + " to be defined");
-	return value;
-}
+//#region packages/normalization-core/src/cjk-chars.ts
+const WEIGHTED_CJK_RANGES = [
+	[
+		[183, 183],
+		[12288, 12703],
+		[19968, 40869],
+		[44032, 55215],
+		[65281, 65376]
+	],
+	[
+		[4352, 4607],
+		[11904, 12287],
+		[12704, 19967],
+		[40870, 40959],
+		[40960, 42239],
+		[42752, 42759],
+		[43360, 43391],
+		[55216, 55295],
+		[63744, 64255]
+	],
+	[
+		[711, 711],
+		[713, 715],
+		[729, 729],
+		[746, 747],
+		[773, 773],
+		[803, 803],
+		[65040, 65103],
+		[65377, 65500],
+		[65504, 65510]
+	],
+	[[119648, 119665]],
+	[
+		[94176, 94207],
+		[110576, 110591],
+		[110592, 110959],
+		[127488, 127743],
+		[131072, 195103],
+		[196608, 210047]
+	]
+];
+new RegExp(`[${WEIGHTED_CJK_RANGES.flatMap((ranges) => ranges.map(([start, end]) => `\\u{${start.toString(16)}}-\\u{${end.toString(16)}}`)).join("")}]`, "u");
+(() => {
+	const maxCodePoint = Math.max(...WEIGHTED_CJK_RANGES.flatMap((ranges) => ranges.map(([, end]) => end)));
+	const categories = new Uint8Array(maxCodePoint + 1);
+	for (const [bucket, ranges] of WEIGHTED_CJK_RANGES.entries()) for (const [start, end] of ranges) categories.fill(bucket + 1, start, end + 1);
+	return categories;
+})();
 //#endregion
 //#region packages/normalization-core/src/stable-stringify.ts
 const preserveString = (value) => value;
@@ -60,7 +103,7 @@ const preserveString = (value) => value;
 function stableStringify(value, normalizeString = preserveString) {
 	return stringifyStableValue(value, /* @__PURE__ */ new WeakSet(), normalizeString);
 }
-function stringifyStableValue(value, stack, normalizeString) {
+function stringifyStableValue(value, stack, normalizeString, write) {
 	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());
@@ -69,39 +112,73 @@ function stringifyStableValue(value, stack, normalizeString) {
 	if (stack.has(value)) return JSON.stringify("[Circular]");
 	stack.add(value);
 	try {
-		return stringifyObjectValue(value, stack, normalizeString);
+		return stringifyObjectValue(value, stack, normalizeString, write);
 	} finally {
 		stack.delete(value);
 	}
 }
-function stringifyObjectValue(value, stack, normalizeString) {
+function stringifyObjectValue(value, stack, normalizeString, write) {
 	if (value instanceof Error) return stringifyStableValue({
 		name: value.name,
 		message: value.message,
 		stack: value.stack
-	}, stack, normalizeString);
+	}, stack, normalizeString, write);
 	if (value instanceof Uint8Array) return stringifyStableValue({
 		type: "Uint8Array",
 		data: encodeBase64(value)
-	}, stack, normalizeString);
+	}, stack, normalizeString, write);
 	if (Array.isArray(value)) {
+		if (write) {
+			write("[");
+			let separator = "";
+			for (const entry of value) {
+				write(separator);
+				write(stringifyStableValue(entry, stack, normalizeString, write));
+				separator = ",";
+			}
+			write("]");
+			return "";
+		}
 		const serializedEntries = [];
 		for (const entry of value) serializedEntries.push(stringifyStableValue(entry, stack, normalizeString));
 		return `[${serializedEntries.join(",")}]`;
 	}
 	const record = value;
 	if (normalizeString === preserveString) {
-		const fields = [];
-		for (const key of Object.keys(record).toSorted()) fields.push(`${JSON.stringify(key)}:${stringifyStableValue(record[key], stack, normalizeString)}`);
+		const fields = Object.keys(record).sort();
+		if (write) {
+			write("{");
+			let separator = "";
+			for (const key of fields) {
+				write(`${separator}${JSON.stringify(key)}:`);
+				write(stringifyStableValue(record[key], stack, normalizeString, write));
+				separator = ",";
+			}
+			write("}");
+			return "";
+		}
+		let fieldIndex = 0;
+		for (const key of fields) fields[fieldIndex++] = `${JSON.stringify(key)}:${stringifyStableValue(record[key], stack, normalizeString)}`;
 		return `{${fields.join(",")}}`;
 	}
 	const entries = Object.keys(record).map((key) => ({
 		key,
 		normalizedKey: normalizeString(key)
-	})).toSorted((left, right) => {
+	})).sort((left, right) => {
 		return compareStableStrings(left.normalizedKey, right.normalizedKey) || compareStableStrings(left.key, right.key);
 	});
 	const serializedFields = [];
+	if (write) {
+		write("{");
+		let separator = "";
+		for (const { key, normalizedKey } of entries) {
+			write(`${separator}${JSON.stringify(normalizedKey)}:`);
+			write(stringifyStableValue(record[key], stack, normalizeString, write));
+			separator = ",";
+		}
+		write("}");
+		return "";
+	}
 	for (const { key, normalizedKey } of entries) serializedFields.push(`${JSON.stringify(normalizedKey)}:${stringifyStableValue(record[key], stack, normalizeString)}`);
 	return `{${serializedFields.join(",")}}`;
 }
@@ -128,6 +205,19 @@ const MEDIA_PAYLOAD_SUFFIXES = "base64|blob|buffer|bytes|data|delta|frames?|outp
 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 DIAGNOSTIC_FIELD_SEPARATOR_RE = /[^a-z0-9]/g;
+const MEDIA_TYPE_RE = /^(?:input|output)?(?:audio|image|video)/u;
+const MEDIA_MIME_RE = /^(?:audio|image|video)\//iu;
+const MEDIA_ARRAY_INDEX_RE = /^(?:0|[1-9]\d*)$/u;
+const MEDIA_URL_SUFFIX_RE = /(?:uri|url)$/u;
+const MEDIA_MIME_FIELDS = [
+	"mimeType",
+	"mime_type",
+	"mediaType",
+	"media_type",
+	"contentType",
+	"content_type"
+];
 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;
@@ -170,7 +260,7 @@ function hasSensitiveProseContent(value) {
 	return false;
 }
 function normalizeDiagnosticFieldName(value) {
-	return value.toLowerCase().replaceAll(/[^a-z0-9]/g, "");
+	return value.toLowerCase().replaceAll(DIAGNOSTIC_FIELD_SEPARATOR_RE, "");
 }
 function isCredentialFieldName(normalized) {
 	if (!normalized || NON_CREDENTIAL_FIELD_NAMES.has(normalized)) return false;
@@ -184,27 +274,19 @@ function diagnosticBytes(value, numericArrays = false) {
 }
 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) => {
+	if (typeof type === "string" && MEDIA_TYPE_RE.test(normalizeDiagnosticFieldName(type))) return true;
+	for (const key of MEDIA_MIME_FIELDS) {
 		const mime = descriptors[key]?.value;
-		return typeof mime === "string" && /^(?:audio|image|video)\//iu.test(mime);
-	});
+		if (typeof mime === "string" && MEDIA_MIME_RE.test(mime)) return true;
+	}
+	return false;
 }
 function extractDiagnosticMediaField(key, normalized, value, parentMedia) {
 	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" };
+	if (!privateField && !mediaField && !contextualPayload) return parentMedia && value !== null && (typeof value === "object" || MEDIA_ARRAY_INDEX_RE.test(key)) ? { kind: "context" } : void 0;
+	if (MEDIA_URL_SUFFIX_RE.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 {
@@ -213,6 +295,13 @@ function extractDiagnosticMediaField(key, normalized, value, parentMedia) {
 		source: encoded
 	};
 }
+const diagnosticRecords = /* @__PURE__ */ new WeakSet();
+/** Fresh records need no native-object probe while their prototype stays ordinary. */
+function createDiagnosticRecord() {
+	const record = {};
+	diagnosticRecords.add(record);
+	return record;
+}
 function projectDiagnosticValue(value, policy = {}, seen = /* @__PURE__ */ new WeakSet(), mediaPayload = false, state = {
 	changed: false,
 	nodesRemaining: 64
@@ -237,24 +326,28 @@ function projectDiagnosticValue(value, policy = {}, seen = /* @__PURE__ */ new W
 			state.changed = true;
 			return "[Truncated]";
 		}
-		try {
+		if (!diagnosticRecords.has(value) || Object.getPrototypeOf(value) !== Object.prototype) try {
 			Headers.prototype.has.call(value, "retry-after");
 			const seconds = parseRetryAfterHeadersSeconds(value);
 			state.changed = true;
 			return seconds === void 0 ? {} : { "retry-after-ms": seconds * 1e3 };
 		} catch {}
-		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]] : [];
-		}));
+		const keys = Reflect.ownKeys(value);
+		const descriptors = Object.create(null);
+		for (let index = 0; index < Math.min(keys.length, 64); index += 1) {
+			const key = keys[index];
+			if (typeof key !== "string") continue;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (descriptor) descriptors[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(normalizeDiagnosticFieldName(rawName));
 		const redactMedia = mediaPayload || keys.length > 64 || isDiagnosticMediaPayload(descriptors);
-		for (const [key, descriptor] of Object.entries(descriptors)) {
+		for (const key in descriptors) {
+			const descriptor = expectDefined(descriptors[key], "diagnostic descriptor");
 			if (!("value" in descriptor) || !descriptor.enumerable && (policy.propertyScope === "enumerable" || ![
 				"cause",
 				"errors",
@@ -349,11 +442,14 @@ function readCauseCode(error) {
 		if (code) return code;
 	}
 }
+function truncateField(text, maxLength) {
+	return text.length <= maxLength ? text : `${truncateUtf16Safe(text, maxLength)}... [truncated]`;
+}
 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]`;
+	return maxLength === void 0 ? text : truncateField(text, maxLength);
 }
 function buildProjection(snapshot, signal) {
 	const error = asOptionalRecord(snapshot);
@@ -365,12 +461,11 @@ function buildProjection(snapshot, signal) {
 		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 body = stringifyField(error?.errorBody ?? error?.body ?? response?.body ?? response?.data ?? nestedError);
 	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}`;
+	if (status !== void 0 && 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));
@@ -380,7 +475,7 @@ function buildProjection(snapshot, signal) {
 		errorMessage: stringifyField(errorMessage, 4096) ?? "Unknown provider error",
 		...errorCode ? { errorCode: truncateUtf16Safe(errorCode, 256) } : {},
 		...errorType ? { errorType: truncateUtf16Safe(errorType, 256) } : {},
-		...body ? { errorBody: stringifyField(bodyValue, 500) } : {}
+		...body ? { errorBody: truncateField(body, 500) } : {}
 	};
 }
 /** Projects one hostile provider throw into final, bounded assistant terminal fields. */
@@ -406,4 +501,4 @@ function projectProviderError(error, signal) {
 	}
 }
 //#endregion
-export { expectDefined as a, stableStringify as i, projectProviderError as n, projectDiagnosticValue as r, configureProviderErrorRedactor as t };
+export { redactDiagnosticText as a, projectDiagnosticValue as i, projectProviderError as n, stableStringify as o, createDiagnosticRecord as r, configureProviderErrorRedactor as t };

package/dist/{provider-error-CzNw4BWX.d.mts → provider-error-xumb1V3F.d.mts}

@@ -8,5 +8,7 @@ type ProviderErrorProjection = {
 };
 type ProviderErrorRedactor = (value: unknown) => unknown;
 declare function configureProviderErrorRedactor(redactor: ProviderErrorRedactor | undefined): ProviderErrorRedactor | undefined;
+/** Projects one hostile provider throw into final, bounded assistant terminal fields. */
+declare function projectProviderError(error: unknown, signal?: AbortSignal): ProviderErrorProjection;
 //#endregion
-export { ProviderErrorRedactor as n, configureProviderErrorRedactor as r, ProviderErrorProjection as t };
+export { projectProviderError as i, ProviderErrorRedactor as n, configureProviderErrorRedactor as r, ProviderErrorProjection as t };