@openclaw/ai 2026.9.1-beta.1 → 2026.9.2

package/dist/rolldown-runtime-BhDjJH2R.mjs

@@ -0,0 +1,15 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __require as n, __exportAll as t };

package/dist/{sanitize-unicode-DCkltN94.mjs → sanitize-unicode-D6xUvZaS.mjs}

@@ -1,14 +1,8 @@
-import { a as requiresClaudeMandatoryAdaptiveThinking, l as resolveClaudeNativeThinkingLevelMap } from "./src-Bu3FiFAG.mjs";
+import { l as requiresClaudeMandatoryAdaptiveThinking, p as resolveClaudeNativeThinkingLevelMap, t as calculateUsageCost } from "./src-2qBGKg8O.mjs";
 //#region packages/ai/src/model-utils.ts
 /** Calculates and stores model cost fields from token usage and per-million pricing. */
 function calculateCost(model, usage) {
-	const cacheWrite1h = Math.min(usage.cacheWrite, Math.max(0, usage.cacheWrite1h ?? 0));
-	const cacheWrite5m = usage.cacheWrite - cacheWrite1h;
-	usage.cost.input = model.cost.input / 1e6 * usage.input;
-	usage.cost.output = model.cost.output / 1e6 * usage.output;
-	usage.cost.cacheRead = model.cost.cacheRead / 1e6 * usage.cacheRead;
-	usage.cost.cacheWrite = (model.cost.cacheWrite * cacheWrite5m + model.cost.input * 2 * cacheWrite1h) / 1e6;
-	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	Object.assign(usage.cost, calculateUsageCost(usage, model.cost));
 	return usage.cost;
 }
 /** Replaces the catalog estimate when the provider reports an authoritative billed total. */

package/dist/{simple-options-CFj7x3J4.mjs → simple-options-BjHCCh4v.mjs}

@@ -1,6 +1,6 @@
 import { c as normalizeLowercaseStringOrEmpty } from "./utf16-slice-qz3nsy87.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DCkltN94.mjs";
-import { r as copyProviderAcceptanceObserver } from "./transport-stream-shared-ljShVIZB.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-D6xUvZaS.mjs";
+import { r as copyProviderAcceptanceObserver } from "./transport-stream-shared-CZqMhfIw.mjs";
 //#region packages/ai/src/utils/prompt-cache-stability.ts
 /**
 * Prompt-cache normalization helpers. They keep generated prompt sections
@@ -66,10 +66,45 @@ function prependSystemPromptAdditionAfterCacheBoundary(params) {
 	return `${split.stablePrefix}${SYSTEM_PROMPT_CACHE_BOUNDARY}${systemPromptAddition}\n\n${dynamicSuffix}`;
 }
 //#endregion
+//#region packages/ai/src/provider-options.ts
+const CODE_MODE_TOOL_SURFACE_OBSERVER = Symbol("openaiCodeModeToolSurfaceObserver");
+const CODE_MODE_TOOL_SURFACE_COLLECTOR = Symbol("openaiCodeModeToolSurfaceCollector");
+const STRICT_REASONING_TAG_TEXT = Symbol("openaiStrictReasoningTagText");
+function markStrictReasoningTagText(options) {
+	Reflect.set(options, STRICT_REASONING_TAG_TEXT, true);
+}
+function isStrictReasoningTagText(options) {
+	return options ? Reflect.get(options, STRICT_REASONING_TAG_TEXT) === true : false;
+}
+const codeModeToolSurfaceObserver = {
+	set(options, observer, collector) {
+		Reflect.set(options, CODE_MODE_TOOL_SURFACE_OBSERVER, observer);
+		if (collector) Reflect.set(options, CODE_MODE_TOOL_SURFACE_COLLECTOR, collector);
+	},
+	get(options) {
+		if (!options) return;
+		const observer = Reflect.get(options, CODE_MODE_TOOL_SURFACE_OBSERVER);
+		return typeof observer === "function" ? (observation) => observer(observation) : void 0;
+	},
+	getCollector(options) {
+		if (!options) return;
+		const collector = Reflect.get(options, CODE_MODE_TOOL_SURFACE_COLLECTOR);
+		return typeof collector === "function" ? (observation) => collector(observation) : void 0;
+	}
+};
+/** Internal output policy for callers that must not recover ambiguous reasoning as visible text. */
+const reasoningTagTextPolicy = {
+	markStrict: markStrictReasoningTagText,
+	isStrict: isStrictReasoningTagText,
+	copy(source, target) {
+		if (isStrictReasoningTagText(source)) markStrictReasoningTagText(target);
+	}
+};
+//#endregion
 //#region packages/ai/src/providers/simple-options.ts
 function buildBaseOptions(model, options, apiKey) {
 	const firstEventOptions = options;
-	return copyProviderAcceptanceObserver(options, {
+	const baseOptions = {
 		temperature: options?.temperature,
 		maxTokens: options?.maxTokens,
 		stop: options?.stop,
@@ -85,10 +120,11 @@ function buildBaseOptions(model, options, apiKey) {
 		timeoutMs: options?.timeoutMs,
 		firstEventTimeoutMs: firstEventOptions?.firstEventTimeoutMs,
 		onFirstEventTimeout: firstEventOptions?.onFirstEventTimeout,
-		maxRetries: options?.maxRetries,
 		maxRetryDelayMs: options?.maxRetryDelayMs,
 		metadata: options?.metadata
-	});
+	};
+	reasoningTagTextPolicy.copy(options, baseOptions);
+	return copyProviderAcceptanceObserver(options, baseOptions);
 }
 function clampMaxTokensToModel(model, requestedMaxTokens) {
 	return requestedMaxTokens === void 0 ? void 0 : Math.max(1, Math.min(requestedMaxTokens, model.maxTokens));
@@ -115,4 +151,4 @@ function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLeve
 	};
 }
 //#endregion
-export { SYSTEM_PROMPT_CACHE_BOUNDARY as a, splitSystemPromptCacheBoundary as c, normalizeStructuredPromptSection as d, sortPromptCacheToolsByName as f, clampReasoning as i, stripSystemPromptCacheBoundary as l, buildBaseOptions as n, ensureSystemPromptCacheBoundary as o, clampMaxTokensToModel as r, prependSystemPromptAdditionAfterCacheBoundary as s, adjustMaxTokensForThinking as t, normalizePromptCapabilityIds as u };
+export { codeModeToolSurfaceObserver as a, ensureSystemPromptCacheBoundary as c, stripSystemPromptCacheBoundary as d, normalizePromptCapabilityIds as f, clampReasoning as i, prependSystemPromptAdditionAfterCacheBoundary as l, sortPromptCacheToolsByName as m, buildBaseOptions as n, reasoningTagTextPolicy as o, normalizeStructuredPromptSection as p, clampMaxTokensToModel as r, SYSTEM_PROMPT_CACHE_BOUNDARY as s, adjustMaxTokensForThinking as t, splitSystemPromptCacheBoundary as u };

package/dist/{src-Bu3FiFAG.mjs → src-2qBGKg8O.mjs}

@@ -1,4 +1,4 @@
-import "./validation-B61OhAio.mjs";
+import "./validation-CJZtym2g.mjs";
 //#region packages/llm-core/src/model-contracts/anthropic.ts
 function normalizeClaudeModelId(modelId) {
 	const normalized = modelId?.trim().toLowerCase() ?? "";
@@ -51,6 +51,14 @@ function resolveClaudeMythos5ModelIdentity(ref) {
 	if (!match) return;
 	return normalized.slice((match.index ?? 0) + (match[0].startsWith("-") ? 1 : 0));
 }
+/**
+* Anthropic binds thinking to the conversation prefix starting with Fable 5.1 and
+* plans to enforce it on later models. Extend only with live replay proof for the
+* new model (Mythos 5.1 is unregistered here and unproven).
+*/
+function bindsClaudeThinkingPrefix(ref) {
+	return /^claude-fable-5-1(?=$|[^a-z0-9])/.test(resolveClaudeModelIdentity(ref));
+}
 /** Return whether a Claude model requires adaptive thinking instead of manual budgets. */
 function requiresClaudeMandatoryAdaptiveThinking(ref) {
 	const modelId = resolveClaudeModelIdentity(ref);
@@ -114,4 +122,77 @@ function resolveClaudeNativeThinkingLevelMap(ref) {
 	};
 }
 //#endregion
-export { requiresClaudeMandatoryAdaptiveThinking as a, resolveClaudeMythos5ModelIdentity as c, resolveClaudeSonnet5ModelIdentity as d, supportsClaude1MContext as f, supportsClaudeNativeXhighEffort as g, supportsClaudeNativeMaxEffort as h, requiresClaudeDefaultSampling as i, resolveClaudeNativeThinkingLevelMap as l, supportsClaudeFastMode as m, CLAUDE_OPUS_5_THINKING_PROFILE as n, resolveClaudeFable5ModelIdentity as o, supportsClaudeAdaptiveThinking as p, CLAUDE_SONNET_5_THINKING_PROFILE as r, resolveClaudeModelIdentity as s, CLAUDE_FABLE_5_THINKING_PROFILE as t, resolveClaudeOpus5ModelIdentity as u };
+//#region packages/llm-core/src/usage-cost.ts
+const sortedPricingTiers = /* @__PURE__ */ new WeakMap();
+const finiteOrZero = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+function normalizeTieredPricing(raw) {
+	if (!raw || raw.length === 0) return;
+	const result = [];
+	for (const tier of raw) {
+		const range = tier.range;
+		const start = Array.isArray(range) && typeof range[0] === "number" ? range[0] : NaN;
+		if (!Number.isFinite(start)) continue;
+		const rawEnd = range.length >= 2 ? range[1] : null;
+		const end = typeof rawEnd === "number" && Number.isFinite(rawEnd) && rawEnd > start ? rawEnd : Infinity;
+		if (!Number.isFinite(tier.input) || !Number.isFinite(tier.output) || !Number.isFinite(tier.cacheRead) || !Number.isFinite(tier.cacheWrite)) continue;
+		result.push({
+			input: tier.input,
+			output: tier.output,
+			cacheRead: tier.cacheRead,
+			cacheWrite: tier.cacheWrite,
+			range: [start, end]
+		});
+	}
+	return result.length > 0 ? result.toSorted((a, b) => a.range[0] - b.range[0]) : void 0;
+}
+function normalizeModelCostConfig(cost) {
+	const normalizedTiers = normalizeTieredPricing(cost.tieredPricing);
+	return {
+		input: cost.input,
+		output: cost.output,
+		cacheRead: cost.cacheRead,
+		cacheWrite: cost.cacheWrite,
+		...normalizedTiers ? { tieredPricing: normalizedTiers } : {}
+	};
+}
+function normalizeResolvedPricing(cost) {
+	return normalizeModelCostConfig({
+		input: finiteOrZero(cost.input),
+		output: finiteOrZero(cost.output),
+		cacheRead: finiteOrZero(cost.cacheRead),
+		cacheWrite: finiteOrZero(cost.cacheWrite),
+		...cost.tieredPricing ? { tieredPricing: cost.tieredPricing } : {}
+	});
+}
+function selectPricingRates(cost, promptTokens) {
+	const tiers = cost.tieredPricing;
+	if (!tiers?.length) return cost;
+	let sorted = sortedPricingTiers.get(tiers);
+	if (!sorted) {
+		sorted = normalizeTieredPricing(tiers) ?? [];
+		sortedPricingTiers.set(tiers, sorted);
+	}
+	if (promptTokens <= 0) return sorted[0] ?? cost;
+	return sorted.find((tier) => promptTokens >= tier.range[0] && promptTokens < tier.range[1]) ?? sorted.findLast((tier) => promptTokens >= tier.range[0]) ?? sorted[0] ?? cost;
+}
+/** Price one model call, selecting its tier before billing the separate token buckets. */
+function calculateUsageCost(usage, pricing) {
+	const input = finiteOrZero(usage.input);
+	const output = finiteOrZero(usage.output);
+	const cacheRead = finiteOrZero(usage.cacheRead);
+	const cacheWrite = finiteOrZero(usage.cacheWrite);
+	const rates = selectPricingRates(pricing, input + cacheRead + cacheWrite);
+	const cacheWrite1h = Math.min(cacheWrite, Math.max(0, finiteOrZero(usage.cacheWrite1h)));
+	const cacheWrite5m = cacheWrite - cacheWrite1h;
+	const cost = {
+		input: input * rates.input / 1e6,
+		output: output * rates.output / 1e6,
+		cacheRead: cacheRead * rates.cacheRead / 1e6,
+		cacheWrite: (cacheWrite5m * rates.cacheWrite + cacheWrite1h * rates.input * 2) / 1e6,
+		total: 0
+	};
+	cost.total = cost.input + cost.output + cost.cacheRead + cost.cacheWrite;
+	return cost;
+}
+//#endregion
+export { supportsClaudeAdaptiveThinking as _, CLAUDE_OPUS_5_THINKING_PROFILE as a, supportsClaudeNativeXhighEffort as b, requiresClaudeDefaultSampling as c, resolveClaudeModelIdentity as d, resolveClaudeMythos5ModelIdentity as f, supportsClaude1MContext as g, resolveClaudeSonnet5ModelIdentity as h, CLAUDE_FABLE_5_THINKING_PROFILE as i, requiresClaudeMandatoryAdaptiveThinking as l, resolveClaudeOpus5ModelIdentity as m, normalizeModelCostConfig as n, CLAUDE_SONNET_5_THINKING_PROFILE as o, resolveClaudeNativeThinkingLevelMap as p, normalizeResolvedPricing as r, bindsClaudeThinkingPrefix as s, calculateUsageCost as t, resolveClaudeFable5ModelIdentity as u, supportsClaudeFastMode as v, supportsClaudeNativeMaxEffort as y };

package/dist/{stream-first-event-timeout-MK28puvq.mjs → stream-first-event-timeout-DcNjoFQE.mjs}

@@ -1,4 +1,4 @@
-import { i as clampTimerTimeoutMs } from "./number-coercion-H9qHik3g.mjs";
+import { o as clampTimerTimeoutMs } from "./base64-CEFBpSkN.mjs";
 //#region packages/ai/src/utils/stream-first-event-timeout.ts
 function getFirstStreamEventTimeoutMs(options) {
 	return options?.firstEventTimeoutMs;

package/dist/{tool-schema-json-projection-qvTEs5Am.mjs → tool-schema-json-projection-mJhXDcyz.mjs}

@@ -1,5 +1,5 @@
 import { o as isRecord } from "./utf16-slice-qz3nsy87.mjs";
-import { n as getAiTransportHost } from "./host-D51fmkH6.mjs";
+import { n as getAiTransportHost } from "./host-CEvLw30U.mjs";
 import { types } from "node:util";
 //#region packages/ai/src/transports/host-policy.ts
 function buildGuardedModelFetch(model, timeoutMs, options) {
@@ -37,18 +37,6 @@ function transformTransportMessages(messages, model, normalizeToolCallId, option
 }
 //#endregion
 //#region packages/ai/src/providers/tool-schema-json-projection.ts
-function isJsonValue(value) {
-	if (value === null) return true;
-	switch (typeof value) {
-		case "boolean":
-		case "string": return true;
-		case "number": return Number.isFinite(value);
-		case "object":
-			if (Array.isArray(value)) return value.every(isJsonValue);
-			return Object.values(value).every(isJsonValue);
-		default: return false;
-	}
-}
 function isNonFiniteNumberValue(value) {
 	if (typeof value === "number") return !Number.isFinite(value);
 	if (value === null || typeof value !== "object" || !types.isNumberObject(value)) return false;
@@ -61,11 +49,14 @@ function serializeToolInputSchema(value, path) {
 	let text;
 	try {
 		text = JSON.stringify(value, function(key, entry) {
-			const holderPath = paths.get(this);
-			const entryPath = isRoot ? path : holderPath === void 0 ? `${path}.${key}` : Array.isArray(this) ? `${holderPath}[${key}]` : `${holderPath}.${key}`;
+			const invalidNumber = nonFiniteNumber.path === null && isNonFiniteNumberValue(entry);
+			if (invalidNumber || entry && typeof entry === "object") {
+				const holderPath = paths.get(this);
+				const entryPath = isRoot ? path : holderPath === void 0 ? `${path}.${key}` : Array.isArray(this) ? `${holderPath}[${key}]` : `${holderPath}.${key}`;
+				if (invalidNumber) nonFiniteNumber.path = entryPath;
+				else paths.set(entry, entryPath);
+			}
 			isRoot = false;
-			if (nonFiniteNumber.path === null && isNonFiniteNumberValue(entry)) nonFiniteNumber.path = entryPath;
-			else if (entry && typeof entry === "object") paths.set(entry, entryPath);
 			return entry;
 		});
 	} catch {
@@ -82,13 +73,8 @@ function serializeToolInputSchema(value, path) {
 		schema: {},
 		violations: [`${nonFiniteNumber.path} is not JSON-serializable`]
 	};
-	const parsed = JSON.parse(text);
-	if (!isJsonValue(parsed)) return {
-		schema: {},
-		violations: [`${path} is not a JSON value`]
-	};
 	return {
-		schema: parsed,
+		schema: JSON.parse(text),
 		violations: []
 	};
 }
@@ -100,17 +86,18 @@ const schemaMapKeywords = /* @__PURE__ */ new Set([
 	"patternProperties",
 	"properties"
 ]);
-function findDynamicSchemaKeywordViolations(schema, path) {
-	if (Array.isArray(schema)) return schema.flatMap((entry, index) => findDynamicSchemaKeywordViolations(entry, `${path}[${index}]`));
-	if (!isRecord(schema)) return [];
-	const violations = [];
+function inspectJsonSchema(schema, path, violations) {
+	if (Array.isArray(schema)) return schema.every((entry, index) => inspectJsonSchema(entry, `${path}[${index}]`, violations));
+	if (!isRecord(schema)) return typeof schema !== "number" || Number.isFinite(schema);
 	for (const key of ["$dynamicRef", "$dynamicAnchor"]) if (key in schema) violations.push(`${path}.${key}`);
 	for (const [key, value] of Object.entries(schema)) {
+		if (typeof value === "number" && !Number.isFinite(value)) return false;
 		if (!value || typeof value !== "object") continue;
-		if (schemaMapKeywords.has(key) && isRecord(value)) for (const [schemaName, childSchema] of Object.entries(value)) violations.push(...findDynamicSchemaKeywordViolations(childSchema, `${path}.${key}.${schemaName}`));
-		else violations.push(...findDynamicSchemaKeywordViolations(value, `${path}.${key}`));
+		if (schemaMapKeywords.has(key) && isRecord(value)) {
+			for (const [schemaName, childSchema] of Object.entries(value)) if (!inspectJsonSchema(childSchema, `${path}.${key}.${schemaName}`, violations)) return false;
+		} else if (!inspectJsonSchema(value, `${path}.${key}`, violations)) return false;
 	}
-	return violations;
+	return true;
 }
 /** Projects one runtime tool input schema to JSON and reports runtime incompatibilities. */
 function projectRuntimeToolInputSchema(schema, path = "parameters") {
@@ -118,7 +105,10 @@ function projectRuntimeToolInputSchema(schema, path = "parameters") {
 	const violations = [...projection.violations];
 	if (!isRecord(projection.schema)) violations.push(`${path} must be a JSON object schema`);
 	else if (projection.schema.type !== void 0 && projection.schema.type !== "object") violations.push(`${path}.type must be "object"`);
-	violations.push(...findDynamicSchemaKeywordViolations(projection.schema, path));
+	if (!inspectJsonSchema(projection.schema, path, violations)) return {
+		schema: {},
+		violations: [`${path} is not a JSON value`]
+	};
 	return {
 		schema: projection.schema,
 		violations

package/dist/{transport-stream-shared-ljShVIZB.mjs → transport-stream-shared-CZqMhfIw.mjs}

@@ -1,7 +1,9 @@
-import { r as createAssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-CPeq9F7y.mjs";
+import { r as createAssistantMessageEventStream } from "./event-stream-BgDvQeum.mjs";
 import { a as asOptionalRecord, n as asNonArrayRecord, r as asNullableRecord } from "./utf16-slice-qz3nsy87.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DCkltN94.mjs";
-import { n as projectProviderError } from "./provider-error-DDOs_Bz0.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-D6xUvZaS.mjs";
+import { n as projectProviderError, r as projectDiagnosticValue } from "./provider-error-9TraxGvt.mjs";
+import { n as isTransientNetworkError } from "./diagnostics-DfFyKeX_.mjs";
 //#region packages/ai/src/utils/headers.ts
 /** Converts a Headers object to a plain record for provider request handling. */
 function headersToRecord(headers) {
@@ -134,7 +136,14 @@ function finalizeTerminalToolCallArguments(calls, readArguments, errorMessage) {
 }
 function mergeTransportHeaders(...headerSources) {
 	const merged = {};
-	for (const headers of headerSources) if (headers) Object.assign(merged, headers);
+	const namesByLowercase = /* @__PURE__ */ new Map();
+	for (const headers of headerSources) for (const [name, value] of Object.entries(headers ?? {})) {
+		const lowercaseName = name.toLowerCase();
+		const previousName = namesByLowercase.get(lowercaseName);
+		if (previousName && previousName !== name) delete merged[previousName];
+		merged[name] = value;
+		namesByLowercase.set(lowercaseName, name);
+	}
 	return Object.keys(merged).length > 0 ? merged : void 0;
 }
 function mergeTransportMetadata(payload, metadata) {
@@ -321,16 +330,20 @@ function finalizeTransportStream(params) {
 	});
 	stream.end();
 }
-/** @deprecated Use projectProviderError. v2026.7.2-beta.5 compatibility; remove after 2026.10. */
+/** Assign terminal fields and record silent transport failures before partial-call cleanup. */
 function assignTransportErrorDetails(output, error, signal) {
 	const projection = projectProviderError(error, signal);
 	Object.assign(output, projection);
+	if (projection.stopReason === "error" && output.content.length === 0 && isTransientNetworkError(projectDiagnosticValue(error)) && !output.diagnostics?.some((diagnostic) => diagnostic.type === "provider_transport_failure")) appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("provider_transport_failure", projection.errorMessage, {
+		eventsEmitted: false,
+		phase: "before_message_stream_start"
+	}));
 	return projection;
 }
 function failTransportStream(params) {
 	const { stream, output, signal, error, cleanup } = params;
-	cleanup?.();
 	const projection = assignTransportErrorDetails(output, error, signal);
+	cleanup?.();
 	stream.push({
 		type: "error",
 		reason: projection.stopReason,

package/dist/{transport-stream-shared-rvaCyFYt.d.mts → transport-stream-shared-xnaqxmbP.d.mts}

@@ -1,7 +1,7 @@
-import { D as Model, L as ProviderResponse, U as StreamOptions, a as AssistantMessage, et as Usage } from "./types-DhLoJbFm.mjs";
-import { r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-LiXePESD.mjs";
-import "./index-Qbej8io0.mjs";
-import "./event-stream-BKp4fOt_.mjs";
+import "./index-FnHM2FcI.mjs";
+import { B as ProviderResponse, D as Model, J as StreamOptions, a as AssistantMessage, at as Usage } from "./types-CJ1-Ht7A.mjs";
+import { r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-BhT5T1Ay.mjs";
+import "./event-stream-zctLx0yr.mjs";
 import { t as ProviderErrorProjection } from "./provider-error-CzNw4BWX.mjs";
 //#region packages/ai/src/utils/stream-first-event-timeout.d.ts
 type StreamStage = "responses" | "completions";
@@ -125,7 +125,7 @@ declare function finalizeTransportStream(params: {
   output: AssistantMessage;
   signal?: AbortSignal;
 }): void;
-/** @deprecated Use projectProviderError. v2026.7.2-beta.5 compatibility; remove after 2026.10. */
+/** Assign terminal fields and record silent transport failures before partial-call cleanup. */
 declare function assignTransportErrorDetails(output: AssistantMessage, error: unknown, signal?: AbortSignal): ProviderErrorProjection;
 declare function failTransportStream(params: {
   stream: WritableTransportStream;

package/dist/{transport-utils-LJ1_rbi-.mjs → transport-utils-7il795_9.mjs}

@@ -1,6 +1,6 @@
 import { d as normalizeOptionalString, t as truncateUtf16Safe } from "./utf16-slice-qz3nsy87.mjs";
-import { n as getAiTransportHost } from "./host-D51fmkH6.mjs";
-import { a as parseStrictFiniteNumber, n as asFiniteNumberInRange, o as parseStrictNonNegativeInteger, s as parseStrictPositiveInteger } from "./number-coercion-H9qHik3g.mjs";
+import { n as getAiTransportHost } from "./host-CEvLw30U.mjs";
+import { c as parseStrictNonNegativeInteger, i as asFiniteNumberInRange, l as parseStrictPositiveInteger, s as parseStrictFiniteNumber } from "./base64-CEFBpSkN.mjs";
 import { parseRetryAfterHttpDateMs } from "./internal/retry-after.mjs";
 import { createHash } from "node:crypto";
 //#region packages/ai/src/transports/transport-utils.ts
@@ -25,14 +25,11 @@ function redactIdentifier(value, opts) {
 function redactSensitiveText(text, _options) {
 	return getAiTransportHost().redactToolPayloadText(text);
 }
-function resolveSecretSentinel(value) {
-	return getAiTransportHost().resolveSecretSentinel(value);
-}
 function resolveModelHeaderSentinels(model) {
 	if (!model.headers) return model;
 	let headers;
 	for (const [name, value] of Object.entries(model.headers)) {
-		const resolved = resolveSecretSentinel(value);
+		const resolved = getAiTransportHost().resolveSecretSentinel(value);
 		if (resolved !== value) {
 			headers ??= { ...model.headers };
 			headers[name] = resolved;
@@ -99,7 +96,7 @@ async function readChunkWithIdleTimeout(reader, timeoutMs, onIdleTimeout) {
 	}
 }
 async function readResponseTextSnippet(response, options) {
-	const maxBytes = options?.maxBytes ?? 8 * 1024;
+	const maxBytes = options?.maxBytes ?? 8192;
 	const maxChars = options?.maxChars ?? 200;
 	const reader = response.body?.getReader();
 	if (!reader) return;
@@ -138,4 +135,4 @@ async function readResponseTextSnippet(response, options) {
 	return truncated ? `${collapsed}…` : collapsed;
 }
 //#endregion
-export { isGoogleGemini3FlashModel as a, parseRetryAfterSeconds as c, redactSensitiveText as d, resolveModelHeaderSentinels as f, supportsModelTools as h, isCodeModeModelVisibleToolName as i, readResponseTextSnippet as l, sha256Hex as m, createAbortError as n, isGoogleGemini3ProModel as o, resolveSecretSentinel as p, estimateStringChars as r, parsePositiveInteger as s, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE as t, redactIdentifier as u };
+export { isGoogleGemini3FlashModel as a, parseRetryAfterSeconds as c, redactSensitiveText as d, resolveModelHeaderSentinels as f, isCodeModeModelVisibleToolName as i, readResponseTextSnippet as l, supportsModelTools as m, createAbortError as n, isGoogleGemini3ProModel as o, sha256Hex as p, estimateStringChars as r, parsePositiveInteger as s, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE as t, redactIdentifier as u };