@openclaw/ai 2026.9.1 → 2026.9.3

package/dist/{sanitize-unicode-S6binQG-.mjs → sanitize-unicode-Bb-v9meu.mjs}

@@ -1,4 +1,4 @@
-import { c as requiresClaudeMandatoryAdaptiveThinking, f as resolveClaudeNativeThinkingLevelMap, t as calculateUsageCost } from "./src-C8U7lkoa.mjs";
+import { l as requiresClaudeMandatoryAdaptiveThinking, p as resolveClaudeNativeThinkingLevelMap, t as calculateUsageCost } from "./src-B2Q_6G8V.mjs";
 //#region packages/ai/src/model-utils.ts
 /** Calculates and stores model cost fields from token usage and per-million pricing. */
 function calculateCost(model, usage) {

package/dist/session-affinity-CCH7eYdB.mjs

@@ -0,0 +1,20 @@
+//#region packages/ai/src/transports/session-affinity.ts
+function isOpencodeEndpoint(baseUrl) {
+	try {
+		const url = new URL(baseUrl);
+		return url.protocol === "https:" && url.hostname.replace(/\.$/, "") === "opencode.ai";
+	} catch {
+		return false;
+	}
+}
+/** Required conversation identity is independent of optional prompt caching. */
+function resolveOpencodeSessionHeaders(model, options) {
+	if (!options?.sessionId || !isOpencodeEndpoint(model.baseUrl)) return options?.headers;
+	if ([model.headers, options.headers].some((headers) => Object.keys(headers ?? {}).some((name) => name.toLowerCase() === "x-opencode-session"))) return options.headers;
+	return {
+		...options.headers,
+		"x-opencode-session": options.sessionId
+	};
+}
+//#endregion
+export { resolveOpencodeSessionHeaders as t };

package/dist/{simple-options-0PLDyJ-d.mjs → simple-options-tcKOqnpF.mjs}

@@ -1,6 +1,6 @@
-import { c as normalizeLowercaseStringOrEmpty } from "./utf16-slice-qz3nsy87.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-S6binQG-.mjs";
-import { r as copyProviderAcceptanceObserver } from "./transport-stream-shared-CytPVLIg.mjs";
+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";
 //#region packages/ai/src/utils/prompt-cache-stability.ts
 /**
 * Prompt-cache normalization helpers. They keep generated prompt sections

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

@@ -1,4 +1,4 @@
-import "./validation-CJZtym2g.mjs";
+import "./validation-BDzVDnTs.mjs";
 //#region packages/llm-core/src/model-contracts/anthropic.ts
 function normalizeClaudeModelId(modelId) {
 	const normalized = modelId?.trim().toLowerCase() ?? "";
@@ -51,6 +51,14 @@ function resolveClaudeMythos5ModelIdentity(ref) {
 	if (!match) return;
 	return normalized.slice((match.index ?? 0) + (match[0].startsWith("-") ? 1 : 0));
 }
+/**
+* Anthropic binds thinking to the conversation prefix starting with Fable 5.1 and
+* plans to enforce it on later models. Extend only with live replay proof for the
+* new model (Mythos 5.1 is unregistered here and unproven).
+*/
+function bindsClaudeThinkingPrefix(ref) {
+	return /^claude-fable-5-1(?=$|[^a-z0-9])/.test(resolveClaudeModelIdentity(ref));
+}
 /** Return whether a Claude model requires adaptive thinking instead of manual budgets. */
 function requiresClaudeMandatoryAdaptiveThinking(ref) {
 	const modelId = resolveClaudeModelIdentity(ref);
@@ -187,4 +195,4 @@ function calculateUsageCost(usage, pricing) {
 	return cost;
 }
 //#endregion
-export { supportsClaudeFastMode as _, CLAUDE_OPUS_5_THINKING_PROFILE as a, requiresClaudeMandatoryAdaptiveThinking as c, resolveClaudeMythos5ModelIdentity as d, resolveClaudeNativeThinkingLevelMap as f, supportsClaudeAdaptiveThinking as g, supportsClaude1MContext as h, CLAUDE_FABLE_5_THINKING_PROFILE as i, resolveClaudeFable5ModelIdentity as l, resolveClaudeSonnet5ModelIdentity as m, normalizeModelCostConfig as n, CLAUDE_SONNET_5_THINKING_PROFILE as o, resolveClaudeOpus5ModelIdentity as p, normalizeResolvedPricing as r, requiresClaudeDefaultSampling as s, calculateUsageCost as t, resolveClaudeModelIdentity as u, supportsClaudeNativeMaxEffort as v, supportsClaudeNativeXhighEffort as y };
+export { supportsClaudeAdaptiveThinking as _, CLAUDE_OPUS_5_THINKING_PROFILE as a, supportsClaudeNativeXhighEffort as b, requiresClaudeDefaultSampling as c, resolveClaudeModelIdentity as d, resolveClaudeMythos5ModelIdentity as f, supportsClaude1MContext as g, resolveClaudeSonnet5ModelIdentity as h, CLAUDE_FABLE_5_THINKING_PROFILE as i, requiresClaudeMandatoryAdaptiveThinking as l, resolveClaudeOpus5ModelIdentity as m, normalizeModelCostConfig as n, CLAUDE_SONNET_5_THINKING_PROFILE as o, resolveClaudeNativeThinkingLevelMap as p, normalizeResolvedPricing as r, bindsClaudeThinkingPrefix as s, calculateUsageCost as t, resolveClaudeFable5ModelIdentity as u, supportsClaudeFastMode as v, supportsClaudeNativeMaxEffort as y };

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-BtZiml7r.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-BIaiBURL.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-CytPVLIg.mjs → transport-stream-shared-Cu3ZPhNW.mjs}

@@ -1,9 +1,9 @@
 import { n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-CPeq9F7y.mjs";
-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-S6binQG-.mjs";
-import { n as projectProviderError, r as projectDiagnosticValue } from "./provider-error-B6EGq6gg.mjs";
-import { n as isTransientNetworkError } from "./diagnostics-KhXK-QJI.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";
 //#region packages/ai/src/utils/headers.ts
 /** Converts a Headers object to a plain record for provider request handling. */
 function headersToRecord(headers) {

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

@@ -1,7 +1,7 @@
-import "./index-AfaxKT8w.mjs";
-import { B as ProviderResponse, D as Model, J as StreamOptions, a as AssistantMessage, at as Usage } from "./types-DbrhszyQ.mjs";
-import { r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-vK_7r3bj.mjs";
-import "./event-stream-DeDhbCc5.mjs";
+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 { t as ProviderErrorProjection } from "./provider-error-CzNw4BWX.mjs";
 //#region packages/ai/src/utils/stream-first-event-timeout.d.ts
 type StreamStage = "responses" | "completions";

package/dist/transport-utils-CCooe-cr.mjs

@@ -0,0 +1,121 @@
+import { n as getAiTransportHost } from "./host-CWuF-sS3.mjs";
+import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
+import { o as parseStrictPositiveInteger } from "./base64-D-su8YVo.mjs";
+import "./internal/retry-after.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 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);
+}
+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 { 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 };

package/dist/transports.d.mts

@@ -1,15 +1,20 @@
-import "./index-AfaxKT8w.mjs";
-import { D as Model, K as StreamFn, Q as ThinkingContent, Y as TextContent, a as AssistantMessage, at as Usage, d as Context, j as OpenAICompletionsCompat, n as Api, nt as ToolCall, o as AssistantMessageEvent, z as ProviderReplayState } from "./types-DbrhszyQ.mjs";
-import { n as ApiRegistry } from "./api-registry-Cs6HGNqY.mjs";
-import { a as CodeModeToolSurfaceObservation, d as OpenAIToolProjection, i as BaseOpenAIStreamOptions, o as OpenAICompletionsOptions, s as OpenAIResponsesCompactionRejection } from "./provider-options-CxFPtvh7.mjs";
-import "./types-B5EFUmXs.mjs";
-import { a as resolveAnthropicPayloadPolicy, i as resolveAnthropicEphemeralCacheControl, n as applyAnthropicEphemeralCacheControlMarkers, o as resolveAnthropicServerCompactionPlan, r as applyAnthropicPayloadPolicyToParams, t as applyAnthropicCacheControlToMessages } from "./anthropic-payload-policy-DBT1itQ-.mjs";
-import { a as ReplayableResponseCompactionItem, c as OpenAIResponsesCompactionOutput, i as OpenAIResponsesRequestParams, n as OpenAIResponsesOptions, o as ResponsesPromptObservation, r as OpenAIResponsesReasoningReplayMetadata } from "./openai-responses-contracts-bPzSN_Ba.mjs";
+import "./index-CQ6LTHw8.mjs";
+import { D as Model, G as StopReason, K as StreamFn, Q as ThinkingContent, Y as TextContent, a as AssistantMessage, at as Usage, d as Context, j as OpenAICompletionsCompat, lt as ModelDataThinkingFormat, n as Api, nt as ToolCall, o as AssistantMessageEvent, tt as Tool, z as ProviderReplayState } from "./types-Dy1q0CSu.mjs";
+import { n as ApiRegistry } from "./api-registry-CB1-1oQ2.mjs";
+import { a as BaseOpenAIStreamOptions, c as OpenAIResponsesCompactionRejection, o as CodeModeToolSurfaceObservation, s as OpenAICompletionsOptions } from "./provider-options-BXr9Ec83.mjs";
+import { n as OpenAIToolProjection } from "./openai-tool-projection-793cE3QX.mjs";
+import "./types-BADKjDBI.mjs";
+import { a as buildAnthropicSystemBlocks, c as logAnthropicContextEdits, d as resolveAnthropicEphemeralCacheControl, f as resolveAnthropicPayloadPolicy, i as applyAnthropicRequestCacheControl, l as resolveAnthropicCacheOptions, n as applyAnthropicEphemeralCacheControlMarkers, o as isAnthropicServerToolClearingEnabled, p as resolveAnthropicServerCompactionPlan, r as applyAnthropicPayloadPolicyToParams, s as isDirectAnthropicModel, t as applyAnthropicContextManagementToRequest, u as resolveAnthropicContextManagementBetaHeader } from "./anthropic-payload-policy-wuRCb6MH.mjs";
+import { a as ReplayableResponseCompactionItem, c as OpenAIResponsesCompactionOutput, i as OpenAIResponsesRequestParams, n as OpenAIResponsesOptions, o as ResponsesPromptObservation, r as OpenAIResponsesReasoningReplayMetadata } from "./openai-responses-contracts-B55afwRo.mjs";
 import { i as resolveOpenAIResponsesServerCompactionPlan, n as resolveOpenAIResponsesCompactEndpointPlan, r as resolveOpenAIResponsesPayloadPolicy, t as applyOpenAIResponsesPayloadPolicy } from "./openai-responses-payload-policy-rLRPsSmB.mjs";
-import { n as detectOpenAICompletionsCompat, r as resolveOpenAICompletionsCompat, t as ResolvedOpenAICompletionsCompat } from "./openai-completions-compat-4IjSBpr6.mjs";
-import { C as FirstStreamEventInternalOptions, _ as sanitizeNonEmptyTransportPayloadText, a as copyProviderAcceptanceObserver, b as withProviderAcceptanceObserver, c as failTransportStream, d as mergeTransportHeaders, f as mergeTransportMetadata, g as parseTerminalToolCallArguments, h as notifyProviderStreamOpened, i as coerceTransportToolCallArguments, l as finalizeTerminalToolCallArguments, m as notifyProviderHttpResponse, n as WritableTransportStream, o as createEmptyTransportUsage, p as notifyProviderHttpMetadata, r as assignTransportErrorDetails, s as createWritableTransportEventStream, t as ProviderAcceptance, u as finalizeTransportStream, v as sanitizeTransportPayloadText, x as withProviderResponseHook, y as transportAbortError } from "./transport-stream-shared-BrvFTkoO.mjs";
+import { a as resolveOpenAICompletionsCompat, i as isOpenAICodexResponsesModel, n as detectOpenAICompletionsCompat, o as resolveOpenAIPromptCacheKeySupport, r as isNativeOpenAIEndpoint, s as usesNativeOpenAICodexResponsesBackend, t as ResolvedOpenAICompletionsCompat } from "./openai-completions-compat-CXn3T1we.mjs";
+import { C as FirstStreamEventInternalOptions, _ as sanitizeNonEmptyTransportPayloadText, a as copyProviderAcceptanceObserver, b as withProviderAcceptanceObserver, c as failTransportStream, d as mergeTransportHeaders, f as mergeTransportMetadata, g as parseTerminalToolCallArguments, h as notifyProviderStreamOpened, i as coerceTransportToolCallArguments, l as finalizeTerminalToolCallArguments, m as notifyProviderHttpResponse, n as WritableTransportStream, o as createEmptyTransportUsage, p as notifyProviderHttpMetadata, r as assignTransportErrorDetails, s as createWritableTransportEventStream, t as ProviderAcceptance, u as finalizeTransportStream, v as sanitizeTransportPayloadText, x as withProviderResponseHook, y as transportAbortError } from "./transport-stream-shared-DOxpGJ-H.mjs";
 import { r as sortPromptCacheToolsByName } from "./prompt-cache-stability-Cwcjv_fx.mjs";
+import { r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-ynZBgqW-.mjs";
+import { d as VideoContent, i as ProviderContext, s as ProviderModel } from "./provider-types-CAV0Og3m.mjs";
+import { a as resolveModelSseDebugMode, i as resolveModelPayloadDebugMode, n as formatModelTransportDebugUrl, r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl } from "./model-transport-url-DKocrEsb.mjs";
 import OpenAI from "openai";
+import { Part } from "@google/genai";
 import { ResponseCreateParamsStreaming, ResponseInput, ResponseInputItem as ResponseInputItem$1 } from "openai/resources/responses/responses.js";
 import { ChatCompletionChunk } from "openai/resources/chat/completions.js";
 //#region packages/ai/src/transports/anthropic-transport-stream.d.ts
@@ -52,37 +57,18 @@ export declare function canonicalizeMaxTokensParam(params: {
   sources: Array<Record<string, unknown> | undefined>;
 }): void;
 //#endregion
-//#region packages/ai/src/transports/model-transport-debug.d.ts
-type SubsystemLogger = {
-  info(message: string): void;
-  debug(message: string): void;
-};
-type ModelTransportDebugEnv = NodeJS.ProcessEnv;
-/** Payload debug detail levels accepted by `OPENCLAW_DEBUG_MODEL_PAYLOAD`. */
-type ModelPayloadDebugMode = "off" | "summary" | "tools" | "full-redacted";
-/** SSE debug detail levels accepted by `OPENCLAW_DEBUG_SSE`. */
-type ModelSseDebugMode = "off" | "events" | "peek";
-/** Resolves model payload debug verbosity from `OPENCLAW_DEBUG_MODEL_PAYLOAD`. */
-export declare function resolveModelPayloadDebugMode(env?: ModelTransportDebugEnv): ModelPayloadDebugMode;
-/** Resolves SSE stream debug verbosity from `OPENCLAW_DEBUG_SSE`. */
-export declare function resolveModelSseDebugMode(env?: ModelTransportDebugEnv): ModelSseDebugMode;
-/** Emits model-fetch metadata at info level by default; other diagnostics require debug env. */
-export declare function emitModelTransportDebug(log: SubsystemLogger, message: string): void;
-//#endregion
-//#region packages/ai/src/transports/model-transport-url.d.ts
-/**
- * Debug formatting helpers for model transport endpoints.
- * Keeps logs useful without exposing credentials, request params, or fragments.
- */
-/** Return a sanitized URL suitable for logs and diagnostics. */
-export declare function formatModelTransportDebugUrl(rawUrl: string): string;
-/** Format a configured base URL for debug output, or the implicit default. */
-export declare function formatModelTransportDebugBaseUrl(rawUrl: string | undefined): string;
-//#endregion
 //#region packages/ai/src/transports/openai-compatible-conversation-turn.d.ts
 /** Returns whether an OpenAI-compatible messages payload contains a usable turn. */
 export declare function hasOpenAICompatibleConversationTurn(messages: unknown): boolean;
 //#endregion
+//#region packages/ai/src/transports/openai-completions-cache-control.d.ts
+type CacheControl = {
+  type: "ephemeral";
+  ttl?: "1h" | "5m";
+};
+/** Shared Chat Completions policy; repeated wrapper application preserves existing checkpoints. */
+export declare function applyCompletionsAnthropicCacheControl(payload: Record<string, unknown>, cacheControl?: CacheControl | null, cacheOptOutIndexes?: ReadonlySet<number>, markTools?: boolean, markMessages?: boolean): void;
+//#endregion
 //#region packages/ai/src/transports/openai-completions-string-content.d.ts
 /** Flatten string-only text block content arrays into newline-joined strings. */
 export declare function flattenCompletionMessagesToStringContent(messages: unknown[]): unknown[];
@@ -160,7 +146,25 @@ export declare function isOpenAICompletionsThinkingEnabled(effort: string): bool
 export declare function readOpenAICompletionsContentDeltas(content: unknown, topLevelRefusal?: unknown, mirroredThinking?: readonly string[]): OpenAICompletionsContentDelta[];
 //#endregion
 //#region packages/ai/src/transports/openai-completions-params.d.ts
-export declare function buildOpenAICompletionsParams(model: OpenAIModeModel, context: Context, options: OpenAICompletionsOptions | undefined): Record<string, unknown>;
+declare function convertTools(tools: NonNullable<Context["tools"]>, compat: ResolvedOpenAICompletionsCompat, model: OpenAIModeModel, mode: "direct" | "managed"): {
+  projection: OpenAIToolProjection;
+  tools: {
+    type: "function";
+    function: {
+      name: string;
+      description: string | undefined;
+      parameters: ReturnType<typeof normalizeOpenAIStrictToolParameters>;
+      strict?: boolean;
+    };
+  }[];
+};
+export declare function buildOpenAICompletionsParams(model: OpenAIModeModel, context: Context, options: OpenAICompletionsOptions | undefined): CompletionsRequest;
+type CompletionsRequest = Record<string, unknown> & {
+  model: string;
+  messages: unknown[];
+  stream: true;
+  tools?: ReturnType<typeof convertTools>["tools"];
+};
 //#endregion
 //#region packages/ai/src/transports/openai-completions-transport.d.ts
 export declare function createOpenAICompletionsTransportStreamFn(): StreamFn;
@@ -285,6 +289,7 @@ type ResponsesEventSink = {
 //#endregion
 //#region packages/ai/src/transports/openai-responses-stream-types-internal.d.ts
 type ResponsesStreamOptions = FirstStreamEventInternalOptions & {
+  asyncToolExecution?: boolean;
   serviceTier?: ResponseCreateParamsStreaming["service_tier"];
   resolveServiceTier?: (responseServiceTier: ResponseCreateParamsStreaming["service_tier"] | undefined, requestServiceTier: ResponseCreateParamsStreaming["service_tier"] | undefined) => ResponseCreateParamsStreaming["service_tier"] | undefined;
   applyServiceTierPricing?: (usage: Usage, serviceTier: ResponseCreateParamsStreaming["service_tier"] | undefined) => void;
@@ -305,8 +310,6 @@ export declare function resolveOpenAIStrictToolFlagWithDiagnostics(projection: O
   transport: "responses" | "completions";
   model: OpenAIModeModel;
 }): boolean | undefined;
-export declare function isOpenAICodexResponsesModel(model: Model): boolean;
-export declare function usesNativeOpenAICodexResponsesBackend(model: Model): boolean;
 export declare function buildOpenAIClientHeaders(model: Model, context: Context, optionHeaders?: Record<string, string>, turnHeaders?: Record<string, string>, sessionId?: string): Record<string, string>;
 export declare function buildOpenAISdkClientOptions(model: Model): {
   timeout?: number;
@@ -337,7 +340,7 @@ export declare function getCompat(model: OpenAIModeModel): {
   requiresAssistantAfterToolResult: boolean;
   requiresThinkingAsText: boolean;
   requiresReasoningContentOnAssistantMessages: boolean;
-  thinkingFormat: "openai" | "openrouter" | "deepseek" | "together" | "zai" | "qwen" | "qwen-chat-template";
+  thinkingFormat: ModelDataThinkingFormat;
   zaiToolStream: boolean;
   supportsStrictMode: boolean;
   supportsJsonSchemaResponseFormat: boolean;
@@ -346,6 +349,7 @@ export declare function getCompat(model: OpenAIModeModel): {
   sessionAffinity: "openai" | "openrouter" | "none";
   visibleReasoningDetailTypes: string[];
   requiresNonEmptyUserOrAssistantMessage: boolean;
+  configuredSupportsLongCacheRetention?: boolean;
 };
 //#endregion
 //#region packages/ai/src/transports/openai-responses-compact-request.d.ts
@@ -469,4 +473,73 @@ export declare function prepareModelForSimpleCompletion<TApi extends Api>(params
 export declare const MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE = "OpenClaw transport error: malformed_streaming_fragment";
 export declare function isCodeModeModelVisibleToolName(name: string, visibleToolNames: ReadonlySet<string>): boolean;
 //#endregion
-export { type OpenAICompletionsOptions, type OpenAIResponsesCompactionRejection, ProviderAcceptance, ResolvedOpenAICompletionsCompat, WritableTransportStream, applyAnthropicCacheControlToMessages, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyOpenAIResponsesPayloadPolicy, assignTransportErrorDetails, coerceTransportToolCallArguments, copyProviderAcceptanceObserver, createEmptyTransportUsage, createWritableTransportEventStream, detectOpenAICompletionsCompat, failTransportStream, finalizeTerminalToolCallArguments, finalizeTransportStream, mergeTransportHeaders, mergeTransportMetadata, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseTerminalToolCallArguments, resolveAnthropicEphemeralCacheControl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveOpenAICompletionsCompat, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, sanitizeNonEmptyTransportPayloadText, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, transportAbortError, withProviderAcceptanceObserver, withProviderResponseHook };
+//#region packages/ai/src/providers/google-stream.d.ts
+type GoogleStreamChunk = {
+  responseId?: string;
+  modelVersion?: string;
+  promptFeedback?: {
+    blockReason?: string;
+    blockReasonMessage?: string;
+  };
+  candidates?: Array<{
+    content?: {
+      parts?: Array<{
+        text?: string;
+        thought?: boolean;
+        thoughtSignature?: string;
+        functionCall?: {
+          id?: string;
+          name?: string;
+          args?: Record<string, unknown>;
+        };
+      }>;
+    };
+    finishReason?: string;
+    finishMessage?: string;
+  }>;
+  usageMetadata?: {
+    promptTokenCount?: number;
+    cachedContentTokenCount?: number;
+    candidatesTokenCount?: number;
+    thoughtsTokenCount?: number;
+    toolUsePromptTokenCount?: number;
+    totalTokenCount?: number;
+  };
+};
+/** @internal Directly tested provider implementation detail. */
+export declare function consumeGoogleGenerateContentStream(params: {
+  chunks: AsyncIterable<GoogleStreamChunk>;
+  model: Model;
+  output: AssistantMessage;
+  stream: WritableTransportStream;
+  signal?: AbortSignal;
+  nextToolCallId: (name: string | undefined) => string;
+  profile?: "sdk" | "managed";
+  normalizeModelId?: (id: string) => string;
+  resolveStopReason?: (reason: string) => StopReason;
+}): Promise<void>;
+//#endregion
+//#region packages/ai/src/providers/google-messages.d.ts
+type GoogleContentPart = Part & Record<string, unknown>;
+type GoogleContent = {
+  role: string;
+  parts: GoogleContentPart[];
+};
+export declare function requiresGoogleToolCallId(modelId: string): boolean;
+/** Project a prepared transcript; route repair and trusted video admission remain caller-owned. */
+export declare function projectGoogleMessages(params: {
+  model: Pick<ProviderModel, "id" | "api" | "provider" | "input">;
+  messages: ProviderContext["messages"];
+  replay: "signed-parts" | "managed";
+  requiresToolCallSignature: boolean;
+  videoPart?: (video: VideoContent) => GoogleContentPart;
+}): GoogleContent[];
+/**
+ * Convert tools to Gemini function declarations format.
+ * @internal Directly tested provider implementation detail.
+ */
+export declare function convertGoogleTools(tools: Tool[]): {
+  functionDeclarations: Record<string, unknown>[];
+}[] | undefined;
+//#endregion
+export { type GoogleStreamChunk, type OpenAICompletionsOptions, type OpenAIResponsesCompactionRejection, ProviderAcceptance, ResolvedOpenAICompletionsCompat, WritableTransportStream, applyAnthropicContextManagementToRequest, applyAnthropicEphemeralCacheControlMarkers, applyAnthropicPayloadPolicyToParams, applyAnthropicRequestCacheControl, applyOpenAIResponsesPayloadPolicy, assignTransportErrorDetails, buildAnthropicSystemBlocks, coerceTransportToolCallArguments, copyProviderAcceptanceObserver, createEmptyTransportUsage, createWritableTransportEventStream, detectOpenAICompletionsCompat, emitModelTransportDebug, failTransportStream, finalizeTerminalToolCallArguments, finalizeTransportStream, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, isAnthropicServerToolClearingEnabled, isDirectAnthropicModel, isNativeOpenAIEndpoint, isOpenAICodexResponsesModel, logAnthropicContextEdits, mergeTransportHeaders, mergeTransportMetadata, notifyProviderHttpMetadata, notifyProviderHttpResponse, notifyProviderStreamOpened, parseTerminalToolCallArguments, resolveAnthropicCacheOptions, resolveAnthropicContextManagementBetaHeader, resolveAnthropicEphemeralCacheControl, resolveAnthropicPayloadPolicy, resolveAnthropicServerCompactionPlan, resolveModelPayloadDebugMode, resolveModelSseDebugMode, resolveOpenAICompletionsCompat, resolveOpenAIPromptCacheKeySupport, resolveOpenAIResponsesCompactEndpointPlan, resolveOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesServerCompactionPlan, sanitizeNonEmptyTransportPayloadText, sanitizeTransportPayloadText, sortPromptCacheToolsByName as sortTransportToolsByName, transportAbortError, usesNativeOpenAICodexResponsesBackend, withProviderAcceptanceObserver, withProviderResponseHook };