@openclaw/ai 2026.9.3 → 2026.9.5

package/dist/{simple-options-tcKOqnpF.mjs → simple-options-C6cFWj_f.mjs}

@@ -1,6 +1,6 @@
 import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-Bb-v9meu.mjs";
-import { r as copyProviderAcceptanceObserver } from "./transport-stream-shared-Cu3ZPhNW.mjs";
+import { v as sanitizeSurrogates } from "./host-B4MeUNBc.mjs";
+import { i as copyProviderAcceptanceObserver } from "./transport-stream-shared-D-6FQSHm.mjs";
 //#region packages/ai/src/utils/prompt-cache-stability.ts
 /**
 * Prompt-cache normalization helpers. They keep generated prompt sections
@@ -40,8 +40,23 @@ function normalizePromptCapabilityIds(capabilities) {
 * Keeps stable prompt prefixes separate from dynamic runtime additions for provider prompt caching.
 */
 const SYSTEM_PROMPT_CACHE_BOUNDARY = "\n<!-- OPENCLAW_CACHE_BOUNDARY -->\n";
+/** Producer-delimited Runtime facts; instructions must remain outside this region. */
+const SYSTEM_PROMPT_RELOCATABLE_BOUNDARY = "\n<!-- OPENCLAW-RELOCATABLE-BOUNDARY -->\n";
+const SYSTEM_PROMPT_RELOCATABLE_BOUNDARY_END = "\n<!-- /OPENCLAW-RELOCATABLE-BOUNDARY -->";
 function stripSystemPromptCacheBoundary(text) {
-	return text.replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY, "\n");
+	return stripSystemPromptRelocatableBoundary(text.replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY, "\n").replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY.trim(), ""));
+}
+/** Reject ambiguous markers from workspace or hook text instead of moving instructions. */
+function splitSystemPromptRelocatableBoundary(text) {
+	const opening = SYSTEM_PROMPT_RELOCATABLE_BOUNDARY.trim();
+	const closing = SYSTEM_PROMPT_RELOCATABLE_BOUNDARY_END.trim();
+	const start = text.indexOf(opening);
+	const end = text.indexOf(closing);
+	if (start === -1 || end < start || text.includes(opening, start + 38) || text.includes(closing, end + 39)) return;
+	return {
+		remainingPrompt: [text.slice(0, start).trimEnd(), text.slice(end + 39).trimStart()].filter(Boolean).join("\n"),
+		relocatable: text.slice(start + 38, end).trim()
+	};
 }
 function ensureSystemPromptCacheBoundary(systemPrompt) {
 	if (systemPrompt.trim().length === 0) return systemPrompt;
@@ -55,6 +70,10 @@ function splitSystemPromptCacheBoundary(text) {
 		dynamicSuffix: text.slice(boundaryIndex + 34).trimStart()
 	};
 }
+/** Keep explicit cache breakpoints while removing relocation metadata. */
+function stripSystemPromptRelocatableBoundary(text) {
+	return text.replaceAll(SYSTEM_PROMPT_RELOCATABLE_BOUNDARY, "\n").replaceAll(SYSTEM_PROMPT_RELOCATABLE_BOUNDARY_END, "").replaceAll(SYSTEM_PROMPT_RELOCATABLE_BOUNDARY.trim(), "").replaceAll(SYSTEM_PROMPT_RELOCATABLE_BOUNDARY_END.trim(), "");
+}
 function prependSystemPromptAdditionAfterCacheBoundary(params) {
 	const systemPromptAddition = typeof params.systemPromptAddition === "string" ? normalizeStructuredPromptSection(params.systemPromptAddition) : "";
 	if (!systemPromptAddition) return params.systemPrompt;
@@ -106,7 +125,9 @@ function buildBaseOptions(model, options, apiKey) {
 	const firstEventOptions = options;
 	const baseOptions = {
 		temperature: options?.temperature,
+		...options?.serviceTier ? { serviceTier: options.serviceTier } : {},
 		maxTokens: options?.maxTokens,
+		responseFormat: options?.responseFormat,
 		stop: options?.stop,
 		signal: options?.signal,
 		apiKey: apiKey || options?.apiKey,
@@ -127,7 +148,7 @@ function buildBaseOptions(model, options, apiKey) {
 	return copyProviderAcceptanceObserver(options, baseOptions);
 }
 function clampMaxTokensToModel(model, requestedMaxTokens) {
-	return requestedMaxTokens === void 0 ? void 0 : Math.max(1, Math.min(requestedMaxTokens, model.maxTokens));
+	return requestedMaxTokens === void 0 ? void 0 : Math.max(1, Math.min(requestedMaxTokens, model.maxTokens ?? requestedMaxTokens));
 }
 function clampReasoning(effort) {
 	return effort === "xhigh" ? "high" : effort;
@@ -151,4 +172,4 @@ function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLeve
 	};
 }
 //#endregion
-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 };
+export { normalizeStructuredPromptSection as _, codeModeToolSurfaceObserver as a, SYSTEM_PROMPT_RELOCATABLE_BOUNDARY as c, prependSystemPromptAdditionAfterCacheBoundary as d, splitSystemPromptCacheBoundary as f, normalizePromptCapabilityIds as g, stripSystemPromptRelocatableBoundary as h, clampReasoning as i, SYSTEM_PROMPT_RELOCATABLE_BOUNDARY_END as l, stripSystemPromptCacheBoundary as m, buildBaseOptions as n, reasoningTagTextPolicy as o, splitSystemPromptRelocatableBoundary as p, clampMaxTokensToModel as r, SYSTEM_PROMPT_CACHE_BOUNDARY as s, adjustMaxTokensForThinking as t, ensureSystemPromptCacheBoundary as u, sortPromptCacheToolsByName as v };

package/dist/{src-B2Q_6G8V.mjs → src-DeKjbE8I.mjs}

@@ -1,4 +1,4 @@
-import "./validation-BDzVDnTs.mjs";
+import "./validation-Dw7cb6BV.mjs";
 //#region packages/llm-core/src/model-contracts/anthropic.ts
 function normalizeClaudeModelId(modelId) {
 	const normalized = modelId?.trim().toLowerCase() ?? "";
@@ -6,15 +6,13 @@ function normalizeClaudeModelId(modelId) {
 }
 const CLAUDE_FABLE_5_THINKING_PROFILE = {
 	levels: [
-		{ id: "minimal" },
 		{ id: "low" },
 		{ id: "medium" },
 		{ id: "high" },
 		{ id: "xhigh" },
-		{ id: "adaptive" },
 		{ id: "max" }
 	],
-	defaultLevel: "high",
+	defaultLevel: "medium",
 	preserveWhenCatalogReasoningFalse: true
 };
 const CLAUDE_SONNET_5_THINKING_PROFILE = {
@@ -34,8 +32,7 @@ const CLAUDE_OPUS_5_THINKING_PROFILE = CLAUDE_SONNET_5_THINKING_PROFILE;
 /** Resolve the canonical normalized Claude model id for one runtime model ref. */
 function resolveClaudeModelIdentity(ref) {
 	const normalized = normalizeClaudeModelId((typeof ref.params?.canonicalModelId === "string" ? ref.params.canonicalModelId : void 0) ?? ref.id);
-	const match = /(?:^|[-/])claude-/.exec(normalized);
-	return match ? normalized.slice((match.index ?? 0) + (match[0].startsWith("claude-") ? 0 : 1)) : normalized;
+	return /(?:^|[-/])(claude-[^/]+)$/.exec(normalized)?.[1] ?? normalized;
 }
 /** Resolve Claude Fable 5 through direct ids, cloud ids, or deployment metadata. */
 function resolveClaudeFable5ModelIdentity(ref) {

package/dist/{stream-first-event-timeout-2hfrquuz.mjs → stream-first-event-timeout-C9ZadkJW.mjs}

@@ -1,4 +1,4 @@
-import { a as clampTimerTimeoutMs } from "./base64-D-su8YVo.mjs";
+import { a as clampTimerTimeoutMs } from "./base64-BQOzsvUH.mjs";
 //#region packages/ai/src/utils/stream-first-event-timeout.ts
 function getFirstStreamEventTimeoutMs(options) {
 	return options?.firstEventTimeoutMs;

package/dist/{string-normalization-CmLIasuf.mjs → string-normalization-J9ZiLfGO.mjs}

@@ -12,5 +12,17 @@ function uniqueValues(values) {
 function uniqueStrings(values) {
 	return uniqueValues(values);
 }
+/** Normalizes array-backed string lists and rejects non-array input as empty. */
+function normalizeTrimmedStringList(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((entry) => {
+		const normalized = normalizeOptionalString(entry);
+		return normalized ? [normalized] : [];
+	});
+}
+/** Normalizes an array-backed string list and removes duplicates. */
+function normalizeUniqueTrimmedStringList(value) {
+	return uniqueStrings(normalizeTrimmedStringList(value));
+}
 //#endregion
-export { uniqueStrings as n, uniqueValues as r, normalizeStringEntries as t };
+export { uniqueValues as i, normalizeUniqueTrimmedStringList as n, uniqueStrings as r, normalizeStringEntries as t };

package/dist/tool-schema-json-projection-CD9c_fK8.mjs

@@ -0,0 +1,134 @@
+import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
+import { t as expectDefined } from "./expect-lbe3Hgrh.mjs";
+import { types } from "node:util";
+//#region packages/ai/src/providers/tool-schema-json-projection.ts
+function isNonFiniteNumberValue(value) {
+	if (typeof value === "number") return !Number.isFinite(value);
+	if (value === null || typeof value !== "object" || !types.isNumberObject(value)) return false;
+	return !Number.isFinite(Number.prototype.valueOf.call(value));
+}
+function serializeToolInputSchema(value, path, captureJson) {
+	const nonFiniteNumber = { path: null };
+	const ancestors = [];
+	const pathLengths = [];
+	const segments = [path];
+	let isRoot = true;
+	let text;
+	try {
+		text = JSON.stringify(value, function(key, entry) {
+			const invalidNumber = nonFiniteNumber.path === null && isNonFiniteNumberValue(entry);
+			if (invalidNumber || entry && typeof entry === "object") {
+				while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+					ancestors.pop();
+					segments.length = expectDefined(pathLengths.pop(), "schema ancestor path length");
+				}
+				const prefixLength = segments.length;
+				if (!isRoot) {
+					if (Array.isArray(this)) segments.push("[", key, "]");
+					else segments.push(".", key);
+				}
+				if (invalidNumber) {
+					nonFiniteNumber.path = segments.join("");
+					segments.length = prefixLength;
+				} else {
+					ancestors.push(entry);
+					pathLengths.push(prefixLength);
+				}
+			}
+			isRoot = false;
+			return entry;
+		});
+	} catch {
+		return {
+			schema: {},
+			violations: [`${path} is not JSON-serializable`]
+		};
+	}
+	if (!text) return {
+		schema: {},
+		violations: [`${path} is not JSON-serializable`]
+	};
+	if (nonFiniteNumber.path !== null) return {
+		schema: {},
+		violations: [`${nonFiniteNumber.path} is not JSON-serializable`]
+	};
+	const schema = JSON.parse(text);
+	captureJson?.(text);
+	return {
+		schema,
+		violations: []
+	};
+}
+const schemaMapKeywords = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependencies",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+function inspectJsonSchema(schema, path, violations) {
+	if (Array.isArray(schema)) {
+		let index = 0;
+		for (const entry of schema) {
+			path.push("[", index++, "]");
+			const valid = inspectJsonSchema(entry, path, violations);
+			path.length -= 3;
+			if (!valid) return false;
+		}
+		return true;
+	}
+	if (!isRecord(schema)) return typeof schema !== "number" || Number.isFinite(schema);
+	for (const key of ["$dynamicRef", "$dynamicAnchor"]) if (key in schema) violations.push(`${path.join("")}.${key}`);
+	for (const key of Object.keys(schema)) {
+		const value = schema[key];
+		if (typeof value === "number" && !Number.isFinite(value)) return false;
+		if (!value || typeof value !== "object") continue;
+		path.push(".", key);
+		if (schemaMapKeywords.has(key) && isRecord(value)) for (const schemaName of Object.keys(value)) {
+			const childSchema = value[schemaName];
+			if (childSchema === void 0) return false;
+			path.push(".", schemaName);
+			const valid = inspectJsonSchema(childSchema, path, violations);
+			path.length -= 2;
+			if (!valid) return false;
+		}
+		else if (!inspectJsonSchema(value, path, violations)) return false;
+		path.length -= 2;
+	}
+	return true;
+}
+/** Projects one runtime tool input schema to JSON and reports runtime incompatibilities. */
+function projectRuntimeToolInputSchema(schema, path = "parameters") {
+	return projectToolInputSchema(schema, path);
+}
+/** Package-private preparation; public projections never carry normalization provenance. */
+function prepareRuntimeToolInputSchema(schema, path) {
+	let inputJson;
+	const projection = projectToolInputSchema(schema, path, (text) => {
+		inputJson = text;
+	});
+	return {
+		projection,
+		...schema && typeof schema === "object" && inputJson && projection.violations.length === 0 ? { normalization: {
+			source: schema,
+			inputJson
+		} } : {}
+	};
+}
+function projectToolInputSchema(schema, path, captureJson) {
+	const projection = serializeToolInputSchema(schema, path, captureJson);
+	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"`);
+	if (!inspectJsonSchema(projection.schema, [path], violations)) return {
+		schema: {},
+		violations: [`${path} is not a JSON value`]
+	};
+	return {
+		schema: projection.schema,
+		violations
+	};
+}
+//#endregion
+export { projectRuntimeToolInputSchema as n, prepareRuntimeToolInputSchema as t };

package/dist/{transport-stream-shared-DOxpGJ-H.d.mts → transport-stream-shared-BbUkFaHi.d.mts}

@@ -1,36 +1,8 @@
-import "./index-CQ6LTHw8.mjs";
-import { B as ProviderResponse, D as Model, J as StreamOptions, a as AssistantMessage, at as Usage } from "./types-Dy1q0CSu.mjs";
-import { r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-C1Z2piyk.mjs";
-import "./event-stream-I_GlBsuZ.mjs";
+import "./index-DaF2QbwS.mjs";
+import { O as Model, V as ProviderResponse, Y as StreamOptions, a as AssistantMessage, ot as Usage } from "./types-4_uVs5WH.mjs";
+import { r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-CCoa-qSI.mjs";
+import "./event-stream-DmSCpi1T.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 = {
@@ -52,12 +24,24 @@ type WritableTransportStream = Pick<ReturnType<typeof createAssistantMessageEven
 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>;
+/** Stable terminal fact: presentation must not infer unfinished calls from provider prose. */
+declare class IncompleteToolCallError extends Error {
+  readonly code = "incomplete_tool_call";
+}
+/**
+ * Admit only complete object-shaped terminal tool arguments; partial parsing is preview-only.
+ * `repairStringLiterals` opts a stream whose provider may deliver unvalidated tool input into
+ * string-literal repair before rejection.
+ */
+declare function parseTerminalToolCallArguments(value: unknown, errorMessage?: string, options?: {
+  repairStringLiterals?: boolean;
+}): 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;
+}>(calls: readonly T[], readArguments: (call: T) => unknown, errorMessage?: string, options?: {
+  repairStringLiterals?: boolean;
+}): 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;
@@ -135,4 +119,4 @@ declare function failTransportStream(params: {
   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 };
+export { withProviderResponseHook as S, parseTerminalToolCallArguments as _, coerceTransportToolCallArguments as a, transportAbortError as b, createWritableTransportEventStream as c, finalizeTransportStream as d, mergeTransportHeaders as f, notifyProviderStreamOpened as g, notifyProviderHttpResponse as h, assignTransportErrorDetails as i, failTransportStream as l, notifyProviderHttpMetadata as m, ProviderAcceptance as n, copyProviderAcceptanceObserver as o, mergeTransportMetadata as p, WritableTransportStream as r, createEmptyTransportUsage as s, IncompleteToolCallError as t, finalizeTerminalToolCallArguments as u, sanitizeNonEmptyTransportPayloadText as v, withProviderAcceptanceObserver as x, sanitizeTransportPayloadText as y };

package/dist/{transport-stream-shared-Cu3ZPhNW.mjs → transport-stream-shared-D-6FQSHm.mjs}

@@ -1,9 +1,25 @@
 import { n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-CPeq9F7y.mjs";
 import { i as createAssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-Bb-v9meu.mjs";
 import { i as asOptionalRecord, n as asNullableRecord, t as asNonArrayRecord } from "./record-coerce-DwRYMj3t.mjs";
-import { n as projectProviderError, r as projectDiagnosticValue } from "./provider-error-C6TbKiey.mjs";
-import { c as isTransientNetworkError } from "./diagnostics-dV98PqIy.mjs";
+import { n as getAiTransportHost, v as sanitizeSurrogates } from "./host-B4MeUNBc.mjs";
+import { i as projectDiagnosticValue, n as projectProviderError } from "./provider-error-DDqw9Qda.mjs";
+import { c as isTransientNetworkError } from "./diagnostics-Dm4bisWG.mjs";
+import { parse } from "partial-json";
+//#region packages/ai/src/utils/hash.ts
+/** Fast deterministic hash to shorten long strings */
+function shortHash(str) {
+	let h1 = 3735928559;
+	let h2 = 1103547991;
+	for (let i = 0; i < str.length; i++) {
+		const ch = str.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (h2 >>> 0).toString(36) + (h1 >>> 0).toString(36);
+}
+//#endregion
 //#region packages/ai/src/utils/headers.ts
 /** Converts a Headers object to a plain record for provider request handling. */
 function headersToRecord(headers) {
@@ -12,6 +28,154 @@ function headersToRecord(headers) {
 	return result;
 }
 //#endregion
+//#region packages/ai/src/utils/json-parse.ts
+const VALID_JSON_ESCAPES = /* @__PURE__ */ new Set([
+	"\"",
+	"\\",
+	"/",
+	"b",
+	"f",
+	"n",
+	"r",
+	"t",
+	"u"
+]);
+const JSON_CONTROL_ESCAPES = /* @__PURE__ */ new Set([
+	"b",
+	"f",
+	"n",
+	"r",
+	"t"
+]);
+function isControlCharacter(char) {
+	const codePoint = char.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 0 && codePoint <= 31;
+}
+function escapeControlCharacter(char) {
+	switch (char) {
+		case "\b": return "\\b";
+		case "\f": return "\\f";
+		case "\n": return "\\n";
+		case "\r": return "\\r";
+		case "	": return "\\t";
+		default: return `\\u${char.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000"}`;
+	}
+}
+/**
+* Repairs malformed JSON string literals by:
+* - escaping raw control characters inside strings
+* - doubling backslashes before invalid escape characters
+*
+* By default a valid control escape (`\n`, `\t`, ...) that follows a Windows-path-looking
+* prefix is treated as an unescaped path separator and doubled. Pass
+* `preserveValidControlEscapes` when the text is authoritative (for example a completed
+* tool-call argument buffer) and every valid escape must survive as written.
+*/
+function repairJson(json, options) {
+	if (!/[\\\x00-\x1f]/.test(json)) return json;
+	const preserveValidControlEscapes = options?.preserveValidControlEscapes === true;
+	let repaired = "";
+	let inString = false;
+	let stringValuePrefix = "";
+	for (let index = 0; index < json.length; index++) {
+		const char = json.charAt(index);
+		if (!inString) {
+			repaired += char;
+			if (char === "\"") {
+				inString = true;
+				stringValuePrefix = "";
+			}
+			continue;
+		}
+		if (char === "\"") {
+			repaired += char;
+			inString = false;
+			stringValuePrefix = "";
+			continue;
+		}
+		if (char === "\\") {
+			const nextChar = json.charAt(index + 1);
+			if (!nextChar) {
+				repaired += "\\\\";
+				continue;
+			}
+			if (nextChar === "u") {
+				const unicodeDigits = json.slice(index + 2, index + 6);
+				if (/^[0-9a-fA-F]{4}$/.test(unicodeDigits)) {
+					repaired += `\\u${unicodeDigits}`;
+					stringValuePrefix += `\\u${unicodeDigits}`;
+					index += 5;
+					continue;
+				}
+				repaired += "\\\\";
+				stringValuePrefix += "\\";
+				continue;
+			}
+			if (!preserveValidControlEscapes && JSON_CONTROL_ESCAPES.has(nextChar)) {
+				stringValuePrefix = stringValuePrefix.slice(-160);
+				if (looksLikeWindowsPathPrefix(stringValuePrefix)) {
+					repaired += "\\\\";
+					stringValuePrefix += "\\";
+					continue;
+				}
+			}
+			if (VALID_JSON_ESCAPES.has(nextChar)) {
+				repaired += `\\${nextChar}`;
+				stringValuePrefix += nextChar === "\\" ? "\\" : `\\${nextChar}`;
+				index += 1;
+				continue;
+			}
+			repaired += "\\\\";
+			stringValuePrefix += "\\";
+			continue;
+		}
+		repaired += isControlCharacter(char) ? escapeControlCharacter(char) : char;
+		stringValuePrefix += char;
+	}
+	return repaired;
+}
+function parseJsonWithRepair(json) {
+	return JSON.parse(repairJson(json));
+}
+function looksLikeWindowsPathPrefix(prefix) {
+	return /(?:^|[^A-Za-z0-9])[A-Za-z]:(?:[\\/][^"\\/:*?<>|\r\n]*)*$/.test(prefix);
+}
+/**
+* Attempts to parse potentially incomplete JSON during streaming.
+* Always returns a valid object, even if the JSON is incomplete.
+*
+* @param partialJson The partial JSON string from streaming
+* @returns Parsed object or empty object if parsing fails
+*/
+function parseStreamingJson(partialJson) {
+	if (!partialJson || partialJson.trim() === "") return {};
+	try {
+		return asNonArrayRecord(parseJsonWithRepair(partialJson));
+	} catch {
+		try {
+			return asNonArrayRecord(parse(partialJson));
+		} catch {
+			return {};
+		}
+	}
+}
+const TOOL_ARGUMENT_PREVIEW_FIRST_CHECKPOINT_CHARS = 512;
+/**
+* Streamed tool-call arguments are preview-only; the terminal parse re-reads
+* the full buffer authoritatively at content_block_stop. Reparsing every delta
+* scans an ever-growing buffer and makes assembly quadratic in the argument
+* size, so refresh previews on a geometric length schedule instead — bounded
+* staleness, linear total parse work.
+*/
+function createToolArgumentPreviewSchedule() {
+	let nextCheckpointChars = TOOL_ARGUMENT_PREVIEW_FIRST_CHECKPOINT_CHARS;
+	return (accumulatedChars) => {
+		if (accumulatedChars < nextCheckpointChars) return false;
+		nextCheckpointChars = accumulatedChars * 2;
+		return true;
+	};
+}
+//#endregion
 //#region packages/ai/src/transports/json-unsafe-integers.ts
 /**
 * JSON parsing helpers that preserve integer literals larger than
@@ -56,6 +220,7 @@ function isUnsafeIntegerLiteral(token) {
 }
 /** Quotes integer literals above Number.MAX_SAFE_INTEGER before JSON.parse. */
 function quoteUnsafeIntegerLiterals(input) {
+	if (!/(?:^|\D)\d{16}/.test(input)) return input;
 	let out = "";
 	let inString = false;
 	let escaped = false;
@@ -123,15 +288,59 @@ function coerceTransportToolCallArguments(argumentsValue) {
 	} catch {}
 	return {};
 }
-/** Admit only complete object-shaped terminal tool arguments; partial parsing is preview-only. */
-function parseTerminalToolCallArguments(value, errorMessage = MALFORMED_TOOL_CALL_TERMINAL_ERROR_MESSAGE) {
+/** Stable terminal fact: presentation must not infer unfinished calls from provider prose. */
+var IncompleteToolCallError = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.code = "incomplete_tool_call";
+	}
+};
+const MALFORMED_TOOL_CALL_TERMINAL_ERROR_CODE = "malformed_tool_call_arguments";
+function createMalformedToolCallArgumentsError(value, errorMessage, repairAttempted) {
+	const text = typeof value === "string" ? value : void 0;
+	const diagnostics = {
+		code: MALFORMED_TOOL_CALL_TERMINAL_ERROR_CODE,
+		argumentChars: text?.length ?? 0,
+		argumentHash: text === void 0 ? "" : shortHash(text),
+		repairAttempted
+	};
+	const error = new Error(errorMessage, { cause: diagnostics });
+	Object.assign(error, {
+		errorCode: MALFORMED_TOOL_CALL_TERMINAL_ERROR_CODE,
+		errorBody: JSON.stringify(diagnostics)
+	});
+	return error;
+}
+/**
+* Repair a complete-but-invalid terminal argument buffer. Anthropic fine-grained tool
+* streaming skips server-side JSON validation, so a finished tool_use block can carry raw
+* control characters or invalid escapes inside string values. Only string-literal repairs
+* are applied and every valid escape is preserved as written; truncated or non-object
+* buffers stay rejected so a cut-off write never executes with partial arguments.
+*/
+function repairTerminalToolCallArguments(value) {
+	const repaired = repairJson(value, { preserveValidControlEscapes: true });
+	if (repaired === value) return null;
+	return parseJsonObjectPreservingUnsafeIntegers(repaired);
+}
+/**
+* Admit only complete object-shaped terminal tool arguments; partial parsing is preview-only.
+* `repairStringLiterals` opts a stream whose provider may deliver unvalidated tool input into
+* string-literal repair before rejection.
+*/
+function parseTerminalToolCallArguments(value, errorMessage = MALFORMED_TOOL_CALL_TERMINAL_ERROR_MESSAGE, options) {
 	const parsed = parseJsonObjectPreservingUnsafeIntegers(value);
-	if (!parsed) throw new Error(errorMessage);
-	return parsed;
+	if (parsed) return parsed;
+	const repairStringLiterals = options?.repairStringLiterals === true && typeof value === "string";
+	if (repairStringLiterals) {
+		const repaired = repairTerminalToolCallArguments(value);
+		if (repaired) return repaired;
+	}
+	throw createMalformedToolCallArgumentsError(value, errorMessage, repairStringLiterals);
 }
 /** Validate a complete sibling set before mutating any call into executable state. */
-function finalizeTerminalToolCallArguments(calls, readArguments, errorMessage) {
-	const validated = calls.map((call) => [call, parseTerminalToolCallArguments(readArguments(call), errorMessage)]);
+function finalizeTerminalToolCallArguments(calls, readArguments, errorMessage, options) {
+	const validated = calls.map((call) => [call, parseTerminalToolCallArguments(readArguments(call), errorMessage, options)]);
 	for (const [call, argumentsValue] of validated) call.arguments = argumentsValue;
 }
 function mergeTransportHeaders(...headerSources) {
@@ -229,6 +438,7 @@ async function awaitProviderLifecycleCallback(callback, signal) {
 	if (signal?.aborted) throw transportAbortError(signal);
 	if (!callback) return;
 	const callbackPromise = Promise.resolve().then(callback);
+	getAiTransportHost().observePendingProviderWork?.(callbackPromise);
 	if (!signal) {
 		await callbackPromise;
 		return;
@@ -247,7 +457,9 @@ async function awaitProviderLifecycleCallback(callback, signal) {
 function startProviderStreamCancellation(cancelStream, error) {
 	const reason = error instanceof Error ? error : new Error(String(error));
 	try {
-		Promise.resolve(cancelStream(reason)).catch(() => void 0);
+		const pending = Promise.resolve(cancelStream(reason));
+		pending.catch(() => void 0);
+		getAiTransportHost().observePendingProviderWork?.(pending);
 	} catch {}
 }
 async function awaitProviderLifecycleWithCleanup(params) {
@@ -352,4 +564,4 @@ function failTransportStream(params) {
 	stream.end();
 }
 //#endregion
-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 };
+export { quoteUnsafeIntegerLiterals as C, repairJson as D, parseStreamingJson as E, headersToRecord as O, parseJsonPreservingUnsafeIntegers as S, parseJsonWithRepair as T, sanitizeTransportPayloadText as _, createEmptyTransportUsage as a, withProviderResponseHook as b, finalizeTerminalToolCallArguments as c, mergeTransportMetadata as d, notifyProviderHttpMetadata as f, sanitizeNonEmptyTransportPayloadText as g, parseTerminalToolCallArguments as h, copyProviderAcceptanceObserver as i, shortHash as k, finalizeTransportStream as l, notifyProviderStreamOpened as m, assignTransportErrorDetails as n, createWritableTransportEventStream as o, notifyProviderHttpResponse as p, coerceTransportToolCallArguments as r, failTransportStream as s, IncompleteToolCallError as t, mergeTransportHeaders as u, transportAbortError as v, createToolArgumentPreviewSchedule as w, parseJsonObjectPreservingUnsafeIntegers as x, withProviderAcceptanceObserver as y };

package/dist/{transport-utils-CCooe-cr.mjs → transport-utils-1cyq5Y7x.mjs}

@@ -1,7 +1,8 @@
-import { n as getAiTransportHost } from "./host-CWuF-sS3.mjs";
+import { n as getAiTransportHost } from "./host-B4MeUNBc.mjs";
 import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
-import { o as parseStrictPositiveInteger } from "./base64-D-su8YVo.mjs";
+import "./provider-error-DDqw9Qda.mjs";
 import "./internal/retry-after.mjs";
+import "./positive-integer-DtjCkbue.mjs";
 //#region packages/normalization-core/src/response-bytes.ts
 async function consumeResponseBytes(options) {
 	let size = 0;
@@ -30,10 +31,6 @@ async function consumeResponseBytes(options) {
 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 redactSensitiveText(text, _options) {
 	return getAiTransportHost().redactToolPayloadText(text);
 }
@@ -118,4 +115,4 @@ async function readResponseTextSnippet(response, options) {
 	return truncated ? `${collapsed}…` : collapsed;
 }
 //#endregion
-export { parsePositiveInteger as a, resolveModelHeaderSentinels as c, isCodeModeModelVisibleToolName as i, supportsModelTools as l, createAbortError as n, readResponseTextSnippet as o, estimateStringChars as r, redactSensitiveText as s, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE as t };
+export { readResponseTextSnippet as a, supportsModelTools as c, isCodeModeModelVisibleToolName as i, createAbortError as n, redactSensitiveText as o, estimateStringChars as r, resolveModelHeaderSentinels as s, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE as t };