@openclaw/ai 2026.8.1-beta.3 → 2026.8.2

package/dist/{anthropic-BQXQudmA.mjs → src-C8U7lkoa.mjs}

@@ -1,3 +1,4 @@
+import "./validation-CJZtym2g.mjs";
 //#region packages/llm-core/src/model-contracts/anthropic.ts
 function normalizeClaudeModelId(modelId) {
 	const normalized = modelId?.trim().toLowerCase() ?? "";
@@ -113,4 +114,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 { supportsClaudeFastMode as _, CLAUDE_OPUS_5_THINKING_PROFILE as a, requiresClaudeMandatoryAdaptiveThinking as c, resolveClaudeMythos5ModelIdentity as d, resolveClaudeNativeThinkingLevelMap as f, supportsClaudeAdaptiveThinking as g, supportsClaude1MContext as h, CLAUDE_FABLE_5_THINKING_PROFILE as i, resolveClaudeFable5ModelIdentity as l, resolveClaudeSonnet5ModelIdentity as m, normalizeModelCostConfig as n, CLAUDE_SONNET_5_THINKING_PROFILE as o, resolveClaudeOpus5ModelIdentity as p, normalizeResolvedPricing as r, requiresClaudeDefaultSampling as s, calculateUsageCost as t, resolveClaudeModelIdentity as u, supportsClaudeNativeMaxEffort as v, supportsClaudeNativeXhighEffort 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/{streaming-byte-guard-BrbkbwUu.mjs → streaming-byte-guard-CC-HMn_u.mjs}

@@ -5,6 +5,9 @@ function createSseByteGuard(reader, opts) {
 	let total = 0;
 	let overflowedFlag = false;
 	let cancelledFlag = false;
+	const cancelReaderBestEffort = (reason) => {
+		reader.cancel(reason).catch(() => void 0);
+	};
 	return {
 		read: async () => {
 			if (overflowedFlag || cancelledFlag) return {
@@ -22,9 +25,7 @@ function createSseByteGuard(reader, opts) {
 					size: next,
 					maxBytes: opts.maxBytes
 				});
-				try {
-					await reader.cancel(err);
-				} catch {}
+				cancelReaderBestEffort(err);
 				throw err;
 			}
 			total = next;
@@ -33,9 +34,7 @@ function createSseByteGuard(reader, opts) {
 		cancel: async (reason) => {
 			if (overflowedFlag) return;
 			cancelledFlag = true;
-			try {
-				await reader.cancel(reason);
-			} catch {}
+			cancelReaderBestEffort(reason);
 		},
 		totalBytes: () => total,
 		overflowed: () => overflowedFlag,

package/dist/string-normalization--fwJ4S2q.mjs

@@ -0,0 +1,16 @@
+import { d as normalizeOptionalString } from "./utf16-slice-qz3nsy87.mjs";
+//#region packages/normalization-core/src/string-normalization.ts
+/** Coerces entries to strings, trims them, and drops empty results. */
+function normalizeStringEntries(list) {
+	return (list ?? []).map((entry) => normalizeOptionalString(String(entry)) ?? "").filter(Boolean);
+}
+/** Returns first-seen unique values while preserving insertion order. */
+function uniqueValues(values) {
+	return [...new Set(values)];
+}
+/** Returns first-seen unique strings while preserving insertion order. */
+function uniqueStrings(values) {
+	return uniqueValues(values);
+}
+//#endregion
+export { uniqueStrings as n, uniqueValues as r, normalizeStringEntries as t };

package/dist/{tool-schema-json-projection-FEr-jOoZ.mjs → tool-schema-json-projection-BtZiml7r.mjs}

@@ -1,5 +1,5 @@
-import { n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
-import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { o as isRecord } from "./utf16-slice-qz3nsy87.mjs";
+import { n as getAiTransportHost } from "./host-BIaiBURL.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-BbG7PThh.d.mts

@@ -0,0 +1,138 @@
+import "./index-CefaUGSS.mjs";
+import { B as ProviderResponse, D as Model, J as StreamOptions, a as AssistantMessage, at as Usage } from "./types-Beemor2E.mjs";
+import { r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-DcvAPSBe.mjs";
+import "./event-stream-pXT3FI6X.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";
+type FirstStreamEventTimeoutContext = {
+  provider?: string;
+  api?: string;
+  model?: string;
+  timeoutMs: number;
+  stage?: StreamStage;
+  hint?: string;
+  abort?: (reason: Error) => void;
+  onTimeout?: (reason: Error) => void;
+};
+type FirstStreamEventInternalOptions = {
+  firstEventTimeoutMs?: number;
+  abortFirstEventStream?: (reason: Error) => void;
+  onFirstEventTimeout?: (reason: Error) => void;
+};
+type FirstStreamEventAbortController = {
+  signal: AbortSignal;
+  abort: (reason: Error) => void;
+  dispose: () => void;
+};
+declare function getFirstStreamEventTimeoutMs(options: unknown): number | undefined;
+declare function getFirstStreamEventTimeoutHandler(options: unknown): ((reason: Error) => void) | undefined;
+declare function createFirstStreamEventTimeoutError(context: FirstStreamEventTimeoutContext): Error;
+declare function createFirstStreamEventAbortController(parentSignal?: AbortSignal): FirstStreamEventAbortController;
+declare function withFirstStreamEventTimeout<T>(stream: AsyncIterable<T>, context: FirstStreamEventTimeoutContext): AsyncIterable<T>;
+//#endregion
+//#region packages/ai/src/transports/transport-stream-shared.d.ts
+type ContextUsage = NonNullable<Usage["contextUsage"]>;
+type TransportUsage = {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  contextUsage?: ContextUsage;
+  totalTokens: number;
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+  };
+};
+type WritableTransportStream = Pick<ReturnType<typeof createAssistantMessageEventStream>, "push" | "end">;
+declare function sanitizeTransportPayloadText(text: string): string;
+declare function sanitizeNonEmptyTransportPayloadText(text: string, fallback?: string): string;
+declare function coerceTransportToolCallArguments(argumentsValue: unknown): Record<string, unknown>;
+/** Admit only complete object-shaped terminal tool arguments; partial parsing is preview-only. */
+declare function parseTerminalToolCallArguments(value: unknown, errorMessage?: string): Record<string, unknown>;
+/** Validate a complete sibling set before mutating any call into executable state. */
+declare function finalizeTerminalToolCallArguments<T extends {
+  arguments: Record<string, unknown>;
+}>(calls: readonly T[], readArguments: (call: T) => unknown, errorMessage?: string): void;
+declare function mergeTransportHeaders(...headerSources: Array<Record<string, string> | undefined>): Record<string, string> | undefined;
+declare function mergeTransportMetadata<T extends Record<string, unknown>>(payload: T, metadata?: Record<string, string>): T;
+declare function createEmptyTransportUsage(): TransportUsage;
+declare function createWritableTransportEventStream(): {
+  eventStream: AssistantMessageEventStream;
+  stream: AssistantMessageEventStream;
+};
+/**
+ * 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.
+ */
+declare function transportAbortError(signal?: AbortSignal): Error;
+type ProviderAcceptance = {
+  kind: "http_response";
+  status: number;
+  headers: Record<string, string>;
+} | {
+  kind: "provider_stream_opened";
+};
+type ProviderAcceptanceObserver = (acceptance: ProviderAcceptance) => void;
+type ProviderAcceptanceOptions = Pick<StreamOptions, "onResponse" | "signal">;
+type ProviderStreamCancel = (reason: Error) => void | Promise<void>;
+/** Attach an OpenClaw-internal provider acceptance observer to one model call. */
+declare function withProviderAcceptanceObserver<T extends object>(options: T, observer: ProviderAcceptanceObserver): T;
+/** Preserve the private provider acceptance observer when a built-in wrapper rebuilds options. */
+declare function copyProviderAcceptanceObserver<T extends object>(source: unknown, target: T): T;
+/** Report observed HTTP metadata; rejected responses use only onResponse. */
+declare function notifyProviderHttpMetadata(params: {
+  options?: ProviderAcceptanceOptions;
+  response: ProviderResponse;
+  model: Model;
+  cancelStream: ProviderStreamCancel;
+  signal?: AbortSignal;
+}): Promise<void>;
+/** Report a real HTTP response before body consumption. */
+declare function notifyProviderHttpResponse(params: {
+  options?: ProviderAcceptanceOptions;
+  response: Response;
+  model: Model;
+  cancelStream?: ProviderStreamCancel;
+  signal?: AbortSignal;
+}): Promise<void>;
+/** Report an accepted SDK stream when the SDK does not expose HTTP metadata. */
+declare function notifyProviderStreamOpened(params: {
+  options?: Pick<StreamOptions, "signal">;
+  cancelStream: ProviderStreamCancel;
+  signal?: AbortSignal;
+}): Promise<void>;
+/** Run a provider-response hook before start/body consumption inside the first-event deadline. */
+declare function withProviderResponseHook<T = never>(params: {
+  stream?: AsyncIterable<T>;
+  signal: AbortSignal;
+  abort: (reason: Error) => void;
+  hook?: () => void | Promise<void>;
+  onReady?: () => void;
+}): AsyncIterable<T>;
+declare function finalizeTransportStream(params: {
+  stream: WritableTransportStream;
+  output: AssistantMessage;
+  signal?: AbortSignal;
+}): void;
+/** @deprecated Use projectProviderError. v2026.7.2-beta.5 compatibility; remove after 2026.10. */
+declare function assignTransportErrorDetails(output: AssistantMessage, error: unknown, signal?: AbortSignal): ProviderErrorProjection;
+declare function failTransportStream(params: {
+  stream: WritableTransportStream;
+  output: AssistantMessage;
+  signal?: AbortSignal;
+  error: unknown;
+  cleanup?: () => void;
+}): void;
+//#endregion
+export { FirstStreamEventInternalOptions as C, getFirstStreamEventTimeoutHandler as D, createFirstStreamEventTimeoutError as E, getFirstStreamEventTimeoutMs as O, FirstStreamEventAbortController as S, createFirstStreamEventAbortController as T, sanitizeNonEmptyTransportPayloadText as _, copyProviderAcceptanceObserver as a, withProviderAcceptanceObserver as b, failTransportStream as c, mergeTransportHeaders as d, mergeTransportMetadata as f, parseTerminalToolCallArguments as g, notifyProviderStreamOpened as h, coerceTransportToolCallArguments as i, withFirstStreamEventTimeout as k, finalizeTerminalToolCallArguments as l, notifyProviderHttpResponse as m, WritableTransportStream as n, createEmptyTransportUsage as o, notifyProviderHttpMetadata as p, assignTransportErrorDetails as r, createWritableTransportEventStream as s, ProviderAcceptance as t, finalizeTransportStream as u, sanitizeTransportPayloadText as v, FirstStreamEventTimeoutContext as w, withProviderResponseHook as x, transportAbortError as y };

package/dist/{simple-options-oqsXB6U3.mjs → transport-stream-shared-D8nQWCUo.mjs}

@@ -1,72 +1,13 @@
 import { r as createAssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-BP7HLLZn.mjs";
-import { i as asOptionalRecord, n as asNullableRecord, t as asNonArrayRecord } from "./record-coerce-DdXsgUd_.mjs";
-import { n as projectProviderError } from "./provider-error-C8mBRJDl.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-//#region packages/ai/src/utils/prompt-cache-stability.ts
-/**
-* Prompt-cache normalization helpers. They keep generated prompt sections
-* deterministic across platform newlines, trailing whitespace, and input
-* ordering.
-*/
-/** Canonicalizes provider tool order without relying on host locale settings. */
-function sortPromptCacheToolsByName(tools) {
-	const compareText = (left, right) => {
-		const leftText = left ?? "";
-		const rightText = right ?? "";
-		return leftText < rightText ? -1 : leftText > rightText ? 1 : 0;
-	};
-	return tools.toSorted((left, right) => compareText(left.wireName ?? left.name, right.wireName ?? right.name) || compareText(left.description, right.description));
-}
-/** Normalize structured prompt text before hashing or snapshot comparison. */
-function normalizeStructuredPromptSection(text) {
-	return sanitizeSurrogates(text).replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "").trim();
-}
-/** Normalize, de-dupe, and sort capability ids for stable prompt payloads. */
-function normalizePromptCapabilityIds(capabilities) {
-	const seen = /* @__PURE__ */ new Set();
-	const normalized = [];
-	for (const capability of capabilities) {
-		const value = normalizeLowercaseStringOrEmpty(normalizeStructuredPromptSection(capability));
-		if (!value || seen.has(value)) continue;
-		seen.add(value);
-		normalized.push(value);
-	}
-	return normalized.toSorted((left, right) => left.localeCompare(right));
-}
-//#endregion
-//#region packages/ai/src/utils/system-prompt-cache-boundary.ts
-/**
-* System prompt cache-boundary helpers.
-*
-* Keeps stable prompt prefixes separate from dynamic runtime additions for provider prompt caching.
-*/
-const SYSTEM_PROMPT_CACHE_BOUNDARY = "\n<!-- OPENCLAW_CACHE_BOUNDARY -->\n";
-function stripSystemPromptCacheBoundary(text) {
-	return text.replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY, "\n");
-}
-function ensureSystemPromptCacheBoundary(systemPrompt) {
-	if (systemPrompt.trim().length === 0) return systemPrompt;
-	return systemPrompt.includes("\n<!-- OPENCLAW_CACHE_BOUNDARY -->\n") ? systemPrompt : `${systemPrompt}${SYSTEM_PROMPT_CACHE_BOUNDARY}`;
-}
-function splitSystemPromptCacheBoundary(text) {
-	const boundaryIndex = text.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-	if (boundaryIndex === -1) return;
-	return {
-		stablePrefix: text.slice(0, boundaryIndex).trimEnd(),
-		dynamicSuffix: text.slice(boundaryIndex + 34).trimStart()
-	};
-}
-function prependSystemPromptAdditionAfterCacheBoundary(params) {
-	const systemPromptAddition = typeof params.systemPromptAddition === "string" ? normalizeStructuredPromptSection(params.systemPromptAddition) : "";
-	if (!systemPromptAddition) return params.systemPrompt;
-	if (params.systemPrompt.trim().length === 0) return systemPromptAddition;
-	const split = splitSystemPromptCacheBoundary(params.systemPrompt);
-	if (!split) return `${systemPromptAddition}\n\n${params.systemPrompt}`;
-	const dynamicSuffix = split.dynamicSuffix ? normalizeStructuredPromptSection(split.dynamicSuffix) : "";
-	if (!dynamicSuffix) return `${split.stablePrefix}${SYSTEM_PROMPT_CACHE_BOUNDARY}${systemPromptAddition}`;
-	return `${split.stablePrefix}${SYSTEM_PROMPT_CACHE_BOUNDARY}${systemPromptAddition}\n\n${dynamicSuffix}`;
+import { a as asOptionalRecord, n as asNonArrayRecord, r as asNullableRecord } from "./utf16-slice-qz3nsy87.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-S6binQG-.mjs";
+import { n as projectProviderError } from "./provider-error-BI8kIViN.mjs";
+//#region packages/ai/src/utils/headers.ts
+/** Converts a Headers object to a plain record for provider request handling. */
+function headersToRecord(headers) {
+	const result = {};
+	for (const [key, value] of headers.entries()) result[key] = value;
+	return result;
 }
 //#endregion
 //#region packages/ai/src/transports/json-unsafe-integers.ts
@@ -398,53 +339,4 @@ function failTransportStream(params) {
 	stream.end();
 }
 //#endregion
-//#region packages/ai/src/providers/simple-options.ts
-function buildBaseOptions(model, options, apiKey) {
-	const firstEventOptions = options;
-	return copyProviderAcceptanceObserver(options, {
-		temperature: options?.temperature,
-		maxTokens: options?.maxTokens,
-		stop: options?.stop,
-		signal: options?.signal,
-		apiKey: apiKey || options?.apiKey,
-		transport: options?.transport,
-		cacheRetention: options?.cacheRetention,
-		sessionId: options?.sessionId,
-		promptCacheKey: options?.promptCacheKey,
-		headers: options?.headers,
-		onPayload: options?.onPayload,
-		onResponse: options?.onResponse,
-		timeoutMs: options?.timeoutMs,
-		firstEventTimeoutMs: firstEventOptions?.firstEventTimeoutMs,
-		onFirstEventTimeout: firstEventOptions?.onFirstEventTimeout,
-		maxRetries: options?.maxRetries,
-		maxRetryDelayMs: options?.maxRetryDelayMs,
-		metadata: options?.metadata
-	});
-}
-function clampMaxTokensToModel(model, requestedMaxTokens) {
-	return requestedMaxTokens === void 0 ? void 0 : Math.max(1, Math.min(requestedMaxTokens, model.maxTokens));
-}
-function clampReasoning(effort) {
-	return effort === "xhigh" ? "high" : effort;
-}
-function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
-	const budgets = {
-		minimal: 1024,
-		low: 2048,
-		medium: 8192,
-		high: 16384,
-		max: 32768,
-		...customBudgets
-	};
-	const minOutputTokens = 1024;
-	let thinkingBudget = budgets[clampReasoning(reasoningLevel)];
-	const maxTokens = baseMaxTokens === void 0 ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
-	if (maxTokens <= thinkingBudget) thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
-	return {
-		maxTokens,
-		thinkingBudget
-	};
-}
-//#endregion
-export { splitSystemPromptCacheBoundary as A, withProviderResponseHook as C, SYSTEM_PROMPT_CACHE_BOUNDARY as D, quoteUnsafeIntegerLiterals as E, normalizePromptCapabilityIds as M, normalizeStructuredPromptSection as N, ensureSystemPromptCacheBoundary as O, sortPromptCacheToolsByName as P, withProviderAcceptanceObserver as S, parseJsonPreservingUnsafeIntegers as T, notifyProviderStreamOpened as _, assignTransportErrorDetails as a, sanitizeTransportPayloadText as b, createEmptyTransportUsage as c, finalizeTerminalToolCallArguments as d, finalizeTransportStream as f, notifyProviderHttpResponse as g, notifyProviderHttpMetadata as h, clampReasoning as i, stripSystemPromptCacheBoundary as j, prependSystemPromptAdditionAfterCacheBoundary as k, createWritableTransportEventStream as l, mergeTransportMetadata as m, buildBaseOptions as n, coerceTransportToolCallArguments as o, mergeTransportHeaders as p, clampMaxTokensToModel as r, copyProviderAcceptanceObserver as s, adjustMaxTokensForThinking as t, failTransportStream as u, parseTerminalToolCallArguments as v, parseJsonObjectPreservingUnsafeIntegers as w, transportAbortError as x, sanitizeNonEmptyTransportPayloadText as y };
+export { headersToRecord as C, quoteUnsafeIntegerLiterals as S, transportAbortError as _, createWritableTransportEventStream as a, parseJsonObjectPreservingUnsafeIntegers as b, finalizeTransportStream as c, notifyProviderHttpMetadata as d, notifyProviderHttpResponse as f, sanitizeTransportPayloadText as g, sanitizeNonEmptyTransportPayloadText as h, createEmptyTransportUsage as i, mergeTransportHeaders as l, parseTerminalToolCallArguments as m, coerceTransportToolCallArguments as n, failTransportStream as o, notifyProviderStreamOpened as p, copyProviderAcceptanceObserver as r, finalizeTerminalToolCallArguments as s, assignTransportErrorDetails as t, mergeTransportMetadata as u, withProviderAcceptanceObserver as v, parseJsonPreservingUnsafeIntegers as x, withProviderResponseHook as y };

package/dist/{transport-utils-Bv0FHkd0.mjs → transport-utils-CtuS1Upe.mjs}

@@ -1,13 +1,16 @@
-import { a as normalizeOptionalString } from "./string-coerce-fsri9iCu.mjs";
-import { n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
-import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
-import { a as parseStrictFiniteNumber, n as asFiniteNumberInRange, o as parseStrictNonNegativeInteger } from "./number-coercion-H9qHik3g.mjs";
+import { d as normalizeOptionalString, t as truncateUtf16Safe } from "./utf16-slice-qz3nsy87.mjs";
+import { n as getAiTransportHost } from "./host-BIaiBURL.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
 const MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE = "OpenClaw transport error: malformed_streaming_fragment";
 const NON_LATIN_RE = /[\u2E80-\u9FFF\uA000-\uA4FF\uAC00-\uD7AF\uF900-\uFAFF\uFF01-\uFF60\uFFE0-\uFFE6\u{20000}-\u{2FA1F}]/gu;
 const CJK_SURROGATE_HIGH_RE = /[\uD840-\uD87E][\uDC00-\uDFFF]/g;
+function parsePositiveInteger(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
+	return typeof value === "string" ? parseStrictPositiveInteger(value) : void 0;
+}
 function sha256Hex(value) {
 	return createHash("sha256").update(value).digest("hex");
 }
@@ -22,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;
@@ -96,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;
@@ -135,4 +135,4 @@ async function readResponseTextSnippet(response, options) {
 	return truncated ? `${collapsed}…` : collapsed;
 }
 //#endregion
-export { isGoogleGemini3FlashModel as a, readResponseTextSnippet as c, resolveModelHeaderSentinels as d, resolveSecretSentinel as f, isCodeModeModelVisibleToolName as i, redactIdentifier as l, supportsModelTools as m, createAbortError as n, isGoogleGemini3ProModel as o, sha256Hex as p, estimateStringChars as r, parseRetryAfterSeconds as s, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE as t, redactSensitiveText 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 };