@openclaw/ai 2026.8.1-beta.3 → 2026.8.1

package/dist/{simple-options-oqsXB6U3.mjs → transport-stream-shared-CT5ycdzn.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-DCkltN94.mjs";
+import { n as projectProviderError } from "./provider-error-jZP5NMTZ.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-stream-shared-NjwWNaRY.d.mts

@@ -0,0 +1,138 @@
+import "./index-N3zr6__t.mjs";
+import { D as Model, L as ProviderResponse, U as StreamOptions, a as AssistantMessage, et as Usage } from "./types-h38Azne1.mjs";
+import { r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-UhnxHuqt.mjs";
+import "./event-stream-C988TSLe.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/{transport-utils-Bv0FHkd0.mjs → transport-utils-BHx9z8Cl.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-D51fmkH6.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;
@@ -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 };