@openclaw/ai 2026.9.2 → 2026.9.4

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

@@ -1,6 +1,6 @@
-import { c as normalizeLowercaseStringOrEmpty } from "./utf16-slice-qz3nsy87.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-D6xUvZaS.mjs";
-import { r as copyProviderAcceptanceObserver } from "./transport-stream-shared-CZqMhfIw.mjs";
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
+import { v as sanitizeSurrogates } from "./host-B8YfDGd4.mjs";
+import { i as copyProviderAcceptanceObserver } from "./transport-stream-shared-zHll9BxO.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;
@@ -151,4 +170,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-DDmEryvj.mjs

@@ -0,0 +1,2 @@
+import "./validation-BDzVDnTs.mjs";
+export {};

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

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

package/dist/string-coerce-fsri9iCu.mjs

@@ -0,0 +1,34 @@
+//#region packages/normalization-core/src/string-coerce.ts
+/** Reads a value only when it is already a string, preserving whitespace. */
+function readStringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/** Trims string input and returns null for non-strings or empty strings. */
+function normalizeNullableString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : null;
+}
+/** Trims string input and returns undefined for non-strings or empty strings. */
+function normalizeOptionalString(value) {
+	return normalizeNullableString(value) ?? void 0;
+}
+/** Stringifies primitive ids/flags before applying optional string normalization. */
+function normalizeStringifiedOptionalString(value) {
+	if (typeof value === "string") return normalizeOptionalString(value);
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return normalizeOptionalString(String(value));
+}
+/** Lowercases a normalized optional string. */
+function normalizeOptionalLowercaseString(value) {
+	return normalizeOptionalString(value)?.toLowerCase();
+}
+/** Lowercases a normalized string or returns an empty string when absent. */
+function normalizeLowercaseStringOrEmpty(value) {
+	return normalizeOptionalLowercaseString(value) ?? "";
+}
+/** Type guard for strings that remain non-empty after trimming. */
+function hasNonEmptyString(value) {
+	return normalizeOptionalString(value) !== void 0;
+}
+//#endregion
+export { normalizeOptionalString as a, normalizeOptionalLowercaseString as i, normalizeLowercaseStringOrEmpty as n, normalizeStringifiedOptionalString as o, normalizeNullableString as r, readStringValue as s, hasNonEmptyString as t };

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

@@ -1,4 +1,4 @@
-import { d as normalizeOptionalString } from "./utf16-slice-qz3nsy87.mjs";
+import { a as normalizeOptionalString } from "./string-coerce-fsri9iCu.mjs";
 //#region packages/normalization-core/src/string-normalization.ts
 /** Coerces entries to strings, trims them, and drops empty results. */
 function normalizeStringEntries(list) {

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

@@ -1,41 +1,5 @@
-import { o as isRecord } from "./utf16-slice-qz3nsy87.mjs";
-import { n as getAiTransportHost } from "./host-CEvLw30U.mjs";
+import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
 import { types } from "node:util";
-//#region packages/ai/src/transports/host-policy.ts
-function buildGuardedModelFetch(model, timeoutMs, options) {
-	const host = getAiTransportHost();
-	if (options !== void 0) return host.buildModelFetch(model, timeoutMs, options) ?? globalThis.fetch;
-	if (timeoutMs !== void 0) return host.buildModelFetch(model, timeoutMs) ?? globalThis.fetch;
-	return host.buildModelFetch(model) ?? globalThis.fetch;
-}
-function resolveProviderEndpoint(model) {
-	return { endpointClass: getAiTransportHost().resolveProviderRequestCapabilities({
-		baseUrl: model.baseUrl,
-		model
-	}).endpointClass };
-}
-function resolveProviderRequestCapabilities(input, model) {
-	return getAiTransportHost().resolveProviderRequestCapabilities({
-		...input,
-		model
-	});
-}
-function resolveProviderRequestPolicyConfig(model, input) {
-	return { headers: getAiTransportHost().resolveProviderRequestHeaders({
-		...input,
-		model
-	}) };
-}
-function resolveModelRequestTimeoutMs(model, timeoutMs) {
-	return timeoutMs ?? getAiTransportHost().resolveModelRequestTimeoutMs(model);
-}
-function resolveOpenAIStrictToolSetting(model, options) {
-	return getAiTransportHost().resolveOpenAIStrictToolSetting(model, options);
-}
-function transformTransportMessages(messages, model, normalizeToolCallId, options) {
-	return getAiTransportHost().transformTransportMessages(messages, model, normalizeToolCallId, options);
-}
-//#endregion
 //#region packages/ai/src/providers/tool-schema-json-projection.ts
 function isNonFiniteNumberValue(value) {
 	if (typeof value === "number") return !Number.isFinite(value);
@@ -115,4 +79,4 @@ function projectRuntimeToolInputSchema(schema, path = "parameters") {
 	};
 }
 //#endregion
-export { resolveProviderEndpoint as a, transformTransportMessages as c, resolveOpenAIStrictToolSetting as i, buildGuardedModelFetch as n, resolveProviderRequestCapabilities as o, resolveModelRequestTimeoutMs as r, resolveProviderRequestPolicyConfig as s, projectRuntimeToolInputSchema as t };
+export { projectRuntimeToolInputSchema as t };

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

@@ -1,36 +1,8 @@
-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 "./index-DdD3qerf.mjs";
+import { O as Model, V as ProviderResponse, Y as StreamOptions, a as AssistantMessage, ot as Usage } from "./types-Ntv5z2g2.mjs";
+import { r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-Bt5Y4Pav.mjs";
+import "./event-stream-C3WGFsum.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-CZqMhfIw.mjs → transport-stream-shared-zHll9BxO.mjs}

@@ -1,9 +1,25 @@
 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-D6xUvZaS.mjs";
-import { n as projectProviderError, r as projectDiagnosticValue } from "./provider-error-9TraxGvt.mjs";
-import { n as isTransientNetworkError } from "./diagnostics-DfFyKeX_.mjs";
+import { i as createAssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
+import { n as getAiTransportHost, v as sanitizeSurrogates } from "./host-B8YfDGd4.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-BA-v_tKd.mjs";
+import { c as isTransientNetworkError } from "./diagnostics-QuErwCIl.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,155 @@ 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) {
+	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) && 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) {
+	const tail = prefix.slice(-160);
+	return /(?:^|[^A-Za-z0-9])[A-Za-z]:(?:[\\/][^"\\/:*?<>|\r\n]*)*$/.test(tail);
+}
+/**
+* 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 {
+			try {
+				return asNonArrayRecord(parse(repairJson(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
@@ -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-zrYjICLZ.mjs

@@ -0,0 +1,118 @@
+import { n as getAiTransportHost } from "./host-B8YfDGd4.mjs";
+import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
+import "./provider-error-BA-v_tKd.mjs";
+import "./internal/retry-after.mjs";
+import "./positive-integer-41zhOdcV.mjs";
+//#region packages/normalization-core/src/response-bytes.ts
+async function consumeResponseBytes(options) {
+	let size = 0;
+	while (true) {
+		const { done, value } = await options.read();
+		if (done) return {
+			size,
+			truncated: false
+		};
+		if (options.skipEmptyChunks !== false && !value?.length) continue;
+		const remaining = options.maxBytes - size;
+		size += value.length;
+		if (size > options.maxBytes || options.stopAtLimit && size === options.maxBytes) {
+			if (remaining > 0) options.onChunk(value.subarray(0, remaining));
+			await options.onLimit(size);
+			return {
+				size,
+				truncated: true
+			};
+		}
+		options.onChunk(value);
+	}
+}
+//#endregion
+//#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 redactSensitiveText(text, _options) {
+	return getAiTransportHost().redactToolPayloadText(text);
+}
+function resolveModelHeaderSentinels(model) {
+	if (!model.headers) return model;
+	let headers;
+	for (const [name, value] of Object.entries(model.headers)) {
+		const resolved = getAiTransportHost().resolveSecretSentinel(value);
+		if (resolved !== value) {
+			headers ??= { ...model.headers };
+			headers[name] = resolved;
+		}
+	}
+	return headers ? {
+		...model,
+		headers
+	} : model;
+}
+function createAbortError(message, options) {
+	const error = new Error(message, options);
+	error.name = "AbortError";
+	return error;
+}
+function estimateStringChars(text) {
+	if (!text) return 0;
+	const nonLatinCount = (text.match(NON_LATIN_RE) ?? []).length;
+	return (nonLatinCount === 0 ? text.length : text.length - (text.match(CJK_SURROGATE_HIGH_RE) ?? []).length) + nonLatinCount * 3;
+}
+function supportsModelTools(model) {
+	return (model.compat && typeof model.compat === "object" ? model.compat : void 0)?.supportsTools !== false;
+}
+function isCodeModeModelVisibleToolName(name, visibleToolNames) {
+	return visibleToolNames.has(name);
+}
+async function readChunkWithIdleTimeout(reader, timeoutMs, onIdleTimeout) {
+	let timer;
+	try {
+		return await Promise.race([reader.read(), new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(onIdleTimeout?.({ chunkTimeoutMs: timeoutMs }) ?? /* @__PURE__ */ new Error("Read timed out")), timeoutMs);
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+async function readResponseTextSnippet(response, options) {
+	const maxBytes = options?.maxBytes ?? 8192;
+	const maxChars = options?.maxChars ?? 200;
+	const reader = response.body?.getReader();
+	if (!reader) return;
+	const chunks = [];
+	let bytes = 0;
+	let truncated = false;
+	try {
+		if (bytes < maxBytes) {
+			const result = await consumeResponseBytes({
+				maxBytes,
+				stopAtLimit: true,
+				read: () => options?.chunkTimeoutMs ? readChunkWithIdleTimeout(reader, options.chunkTimeoutMs, options.onIdleTimeout) : reader.read(),
+				onChunk: (chunk) => chunks.push(chunk),
+				onLimit: async () => {
+					await reader.cancel().catch(() => void 0);
+				}
+			});
+			bytes = Math.min(result.size, maxBytes);
+			truncated = result.truncated;
+		}
+	} catch (error) {
+		await reader.cancel(error).catch(() => void 0);
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+	const merged = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.length;
+	}
+	const collapsed = new TextDecoder().decode(merged).replace(/\s+/g, " ").trim();
+	if (!collapsed) return;
+	if (collapsed.length > maxChars) return `${truncateUtf16Safe(collapsed, maxChars)}…`;
+	return truncated ? `${collapsed}…` : collapsed;
+}
+//#endregion
+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 };