@openclaw/ai 2026.8.1-beta.2 → 2026.8.1

package/dist/transport-stream-shared-CT5ycdzn.mjs

@@ -0,0 +1,342 @@
+import { r as createAssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { a as asOptionalRecord, n as asNonArrayRecord, r as asNullableRecord } from "./utf16-slice-qz3nsy87.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-DCkltN94.mjs";
+import { n as projectProviderError } from "./provider-error-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
+/**
+* JSON parsing helpers that preserve integer literals larger than
+* Number.MAX_SAFE_INTEGER as strings before JSON.parse can round them.
+*/
+const MAX_SAFE_INTEGER_ABS_STR = String(Number.MAX_SAFE_INTEGER);
+function isAsciiDigit(ch) {
+	return ch !== void 0 && ch >= "0" && ch <= "9";
+}
+function parseJsonNumberToken(input, start) {
+	let idx = start;
+	if (input[idx] === "-") idx += 1;
+	if (idx >= input.length) return null;
+	if (input[idx] === "0") idx += 1;
+	else if (isAsciiDigit(input[idx]) && input[idx] !== "0") while (isAsciiDigit(input[idx])) idx += 1;
+	else return null;
+	let isInteger = true;
+	if (input[idx] === ".") {
+		isInteger = false;
+		idx += 1;
+		if (!isAsciiDigit(input[idx])) return null;
+		while (isAsciiDigit(input[idx])) idx += 1;
+	}
+	if (input[idx] === "e" || input[idx] === "E") {
+		isInteger = false;
+		idx += 1;
+		if (input[idx] === "+" || input[idx] === "-") idx += 1;
+		if (!isAsciiDigit(input[idx])) return null;
+		while (isAsciiDigit(input[idx])) idx += 1;
+	}
+	return {
+		token: input.slice(start, idx),
+		end: idx,
+		isInteger
+	};
+}
+function isUnsafeIntegerLiteral(token) {
+	const digits = token[0] === "-" ? token.slice(1) : token;
+	if (digits.length < MAX_SAFE_INTEGER_ABS_STR.length) return false;
+	if (digits.length > MAX_SAFE_INTEGER_ABS_STR.length) return true;
+	return digits > MAX_SAFE_INTEGER_ABS_STR;
+}
+/** Quotes integer literals above Number.MAX_SAFE_INTEGER before JSON.parse. */
+function quoteUnsafeIntegerLiterals(input) {
+	let out = "";
+	let inString = false;
+	let escaped = false;
+	let idx = 0;
+	while (idx < input.length) {
+		const ch = input[idx] ?? "";
+		if (inString) {
+			out += ch;
+			if (escaped) escaped = false;
+			else if (ch === "\\") escaped = true;
+			else if (ch === "\"") inString = false;
+			idx += 1;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			out += ch;
+			idx += 1;
+			continue;
+		}
+		if (ch === "-" || isAsciiDigit(ch)) {
+			const parsed = parseJsonNumberToken(input, idx);
+			if (parsed) {
+				if (parsed.isInteger && isUnsafeIntegerLiteral(parsed.token)) out += `"${parsed.token}"`;
+				else out += parsed.token;
+				idx = parsed.end;
+				continue;
+			}
+		}
+		out += ch;
+		idx += 1;
+	}
+	return out;
+}
+/** Parses JSON while preserving unsafe integer literals as strings. */
+function parseJsonPreservingUnsafeIntegers(input) {
+	return JSON.parse(quoteUnsafeIntegerLiterals(input));
+}
+/** Parses or accepts an object while preserving unsafe integer literals in string input. */
+function parseJsonObjectPreservingUnsafeIntegers(value) {
+	if (typeof value === "string") try {
+		return asNullableRecord(parseJsonPreservingUnsafeIntegers(value));
+	} catch {
+		return null;
+	}
+	return asNullableRecord(value);
+}
+//#endregion
+//#region packages/ai/src/transports/transport-stream-shared.ts
+const EMPTY_TOOL_RESULT_TEXT = "(no output)";
+const MALFORMED_TOOL_CALL_TERMINAL_ERROR_MESSAGE = "Provider completed tool call with malformed JSON arguments";
+function sanitizeTransportPayloadText(text) {
+	if (typeof text !== "string") return "";
+	return sanitizeSurrogates(text);
+}
+function sanitizeNonEmptyTransportPayloadText(text, fallback = EMPTY_TOOL_RESULT_TEXT) {
+	const sanitized = sanitizeTransportPayloadText(text);
+	return sanitized.trim().length > 0 ? sanitized : fallback;
+}
+function coerceTransportToolCallArguments(argumentsValue) {
+	const argumentsRecord = asOptionalRecord(argumentsValue);
+	if (argumentsRecord) return argumentsRecord;
+	if (typeof argumentsValue === "string") try {
+		return asNonArrayRecord(JSON.parse(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) {
+	const parsed = parseJsonObjectPreservingUnsafeIntegers(value);
+	if (!parsed) throw new Error(errorMessage);
+	return parsed;
+}
+/** 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)]);
+	for (const [call, argumentsValue] of validated) call.arguments = argumentsValue;
+}
+function mergeTransportHeaders(...headerSources) {
+	const merged = {};
+	for (const headers of headerSources) if (headers) Object.assign(merged, headers);
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeTransportMetadata(payload, metadata) {
+	if (!metadata || Object.keys(metadata).length === 0) return payload;
+	const existingMetadata = asOptionalRecord(payload.metadata);
+	return {
+		...payload,
+		metadata: {
+			...existingMetadata,
+			...metadata
+		}
+	};
+}
+function createEmptyTransportUsage() {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+}
+function createWritableTransportEventStream() {
+	const eventStream = createAssistantMessageEventStream();
+	return {
+		eventStream,
+		stream: eventStream
+	};
+}
+/**
+* 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.
+*/
+function transportAbortError(signal) {
+	const reason = signal?.reason;
+	return reason instanceof Error && typeof reason.code === "string" ? reason : /* @__PURE__ */ new Error("Request was aborted");
+}
+const providerAcceptanceObserver = Symbol("openclaw.providerAcceptanceObserver");
+function readProviderAcceptanceObserver(options) {
+	if (options === null || typeof options !== "object") return;
+	const descriptor = Object.getOwnPropertyDescriptor(options, providerAcceptanceObserver);
+	const value = descriptor && "value" in descriptor ? descriptor.value : void 0;
+	return isProviderAcceptanceObserver(value) ? value : void 0;
+}
+function isProviderAcceptanceObserver(value) {
+	return typeof value === "function";
+}
+function writeProviderAcceptanceObserver(options, observer) {
+	Object.defineProperty(options, providerAcceptanceObserver, {
+		configurable: true,
+		enumerable: true,
+		value: observer
+	});
+	return options;
+}
+/** Attach an OpenClaw-internal provider acceptance observer to one model call. */
+function withProviderAcceptanceObserver(options, observer) {
+	const existing = readProviderAcceptanceObserver(options);
+	return writeProviderAcceptanceObserver(options, existing ? (acceptance) => {
+		observer(acceptance);
+		existing(acceptance);
+	} : observer);
+}
+/** Preserve the private provider acceptance observer when a built-in wrapper rebuilds options. */
+function copyProviderAcceptanceObserver(source, target) {
+	const observer = readProviderAcceptanceObserver(source);
+	return observer ? writeProviderAcceptanceObserver(target, observer) : target;
+}
+async function awaitProviderLifecycleCallback(callback, signal) {
+	if (signal?.aborted) throw transportAbortError(signal);
+	if (!callback) return;
+	const callbackPromise = Promise.resolve().then(callback);
+	if (!signal) {
+		await callbackPromise;
+		return;
+	}
+	let onAbort;
+	try {
+		await Promise.race([callbackPromise, new Promise((_resolve, reject) => {
+			onAbort = () => reject(transportAbortError(signal));
+			signal.addEventListener("abort", onAbort, { once: true });
+		})]);
+	} finally {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	}
+	if (signal.aborted) throw transportAbortError(signal);
+}
+function startProviderStreamCancellation(cancelStream, error) {
+	const reason = error instanceof Error ? error : new Error(String(error));
+	try {
+		Promise.resolve(cancelStream(reason)).catch(() => void 0);
+	} catch {}
+}
+async function awaitProviderLifecycleWithCleanup(params) {
+	try {
+		await params.run();
+	} catch (error) {
+		startProviderStreamCancellation(params.cancelStream, error);
+		throw error;
+	}
+}
+/** Report observed HTTP metadata; rejected responses use only onResponse. */
+async function notifyProviderHttpMetadata(params) {
+	const observer = readProviderAcceptanceObserver(params.options);
+	if (!observer && !params.options?.onResponse) return;
+	const { status, headers } = params.response;
+	const signal = params.signal ?? params.options?.signal;
+	const accepted = status >= 200 && status < 300;
+	await awaitProviderLifecycleWithCleanup({
+		cancelStream: params.cancelStream,
+		run: async () => {
+			await awaitProviderLifecycleCallback(accepted && observer ? () => observer({
+				kind: "http_response",
+				status,
+				headers
+			}) : void 0, signal);
+			await awaitProviderLifecycleCallback(params.options?.onResponse ? () => params.options?.onResponse?.({
+				status,
+				headers
+			}, params.model) : void 0, signal);
+		}
+	});
+}
+/** Report a real HTTP response before body consumption. */
+async function notifyProviderHttpResponse(params) {
+	await notifyProviderHttpMetadata({
+		options: params.options,
+		response: {
+			status: params.response.status,
+			headers: headersToRecord(params.response.headers)
+		},
+		model: params.model,
+		signal: params.signal,
+		cancelStream: (reason) => {
+			if (params.cancelStream) startProviderStreamCancellation(params.cancelStream, reason);
+			return params.response.body?.cancel(reason);
+		}
+	});
+}
+/** Report an accepted SDK stream when the SDK does not expose HTTP metadata. */
+async function notifyProviderStreamOpened(params) {
+	const observer = readProviderAcceptanceObserver(params.options);
+	if (!observer) return;
+	await awaitProviderLifecycleWithCleanup({
+		cancelStream: params.cancelStream,
+		run: () => awaitProviderLifecycleCallback(() => observer({ kind: "provider_stream_opened" }), params.signal ?? params.options?.signal)
+	});
+}
+/** Run a provider-response hook before start/body consumption inside the first-event deadline. */
+function withProviderResponseHook(params) {
+	return { async *[Symbol.asyncIterator]() {
+		try {
+			await awaitProviderLifecycleCallback(params.hook, params.signal);
+		} catch (error) {
+			params.abort(error instanceof Error ? error : new Error(String(error)));
+			throw error;
+		}
+		if (params.signal.aborted) throw transportAbortError(params.signal);
+		params.onReady?.();
+		if (params.stream) yield* params.stream;
+	} };
+}
+function finalizeTransportStream(params) {
+	const { stream, output, signal } = params;
+	if (signal?.aborted) throw transportAbortError(signal);
+	if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+	stream.push({
+		type: "done",
+		reason: output.stopReason,
+		message: output
+	});
+	stream.end();
+}
+/** @deprecated Use projectProviderError. v2026.7.2-beta.5 compatibility; remove after 2026.10. */
+function assignTransportErrorDetails(output, error, signal) {
+	const projection = projectProviderError(error, signal);
+	Object.assign(output, projection);
+	return projection;
+}
+function failTransportStream(params) {
+	const { stream, output, signal, error, cleanup } = params;
+	cleanup?.();
+	const projection = assignTransportErrorDetails(output, error, signal);
+	stream.push({
+		type: "error",
+		reason: projection.stopReason,
+		error: output
+	});
+	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 };

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-DJqkxbhC.mjs → transport-utils-BHx9z8Cl.mjs}

@@ -1,13 +1,16 @@
-import { a as normalizeOptionalString } from "./string-coerce-fsri9iCu.mjs";
-import { n as getAiTransportHost } from "./host-DTqNc7ad.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 };