@openclaw/ai 2026.7.2-beta.3 → 2026.7.2-beta.4

package/README.md

@@ -14,15 +14,16 @@ registerBuiltInApiProviders(runtime.registry);
 
 Provider-neutral contracts, validation, diagnostics, and event streams are
 available from the package root and focused subpaths such as
-`@openclaw/ai/event-stream` and `@openclaw/ai/validation`. No second OpenClaw
-runtime package is required.
+`@openclaw/ai/event-stream`, `@openclaw/ai/transports`, and
+`@openclaw/ai/validation`. No second OpenClaw runtime package is required.
 
 Provider ids, credentials, model catalogs, retries, and failover remain
 application concerns. OpenClaw supplies those policies around this package.
 Host policy (request fetch guarding, secret redaction, strict-tool defaults,
-diagnostics logging) can be injected with `configureAiTransportHost`; the
-defaults are inert.
+provider plugin hooks, and diagnostics logging) can be injected with
+`configureAiTransportHost`; the defaults are inert.
 
-`@openclaw/ai/internal/*` subpaths exist for the OpenClaw application itself.
+The explicit `@openclaw/ai/internal/anthropic`, `openai`, `retry-after`,
+`runtime`, and `shared` subpaths exist for the OpenClaw application itself.
 They carry no semver guarantee and can change or disappear in any release; do
 not depend on them outside OpenClaw.

package/dist/{anthropic-D7SyZQ5v.mjs → anthropic-CrUDIBpM.mjs}

@@ -1,17 +1,117 @@
-import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DnhYpc27.mjs";
+import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
 import { c as resolveClaudeNativeThinkingLevelMap, d as supportsClaudeNativeMaxEffort, f as supportsClaudeNativeXhighEffort, l as resolveClaudeSonnet5ModelIdentity, u as supportsClaudeAdaptiveThinking } from "./src-CXno1H5g.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-4t713IeR.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-XYGZcgO8.mjs";
+import { C as isImageWithMediaPayload, D as buildBaseOptions, E as adjustMaxTokensForThinking, O as clampMaxTokensToModel, T as isRecord, a as stripSystemPromptCacheBoundary, b as extractToolResultBlockText, c as transformMessages, d as prepareClaudeSonnet5RequestContext, f as requiresClaudeAdaptiveThinking, h as usesClaudeStreamingRefusalContract, i as splitSystemPromptCacheBoundary, l as applyClaudeRequestContract, m as usesClaudeFable5MessagesContract, x as extractToolResultText, y as describeToolResultMediaPlaceholder } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
 import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-1GiZ2_rr.mjs";
 import { r as createDeferredEventBuffer, t as notifyLlmRequestActivity } from "./llm-request-activity-CehVkZP-.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
 import { n as parseStreamingJson, t as parseJsonWithRepair } from "./json-parse-BvXNt1-7.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { C as splitSystemPromptCacheBoundary, c as adjustMaxTokensForThinking, f as isRecord, g as requiresClaudeAdaptiveThinking, h as prepareClaudeSonnet5RequestContext, i as extractToolResultText, l as buildBaseOptions, n as describeToolResultMediaPlaceholder, o as isImageWithMediaPayload, p as applyClaudeRequestContract, r as extractToolResultBlockText, t as transformMessages, u as clampMaxTokensToModel, v as usesClaudeFable5MessagesContract, w as stripSystemPromptCacheBoundary, y as usesClaudeStreamingRefusalContract } from "./transform-messages-eb6lxDLB.mjs";
 import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BwNu3nDi.mjs";
 import { a as resolveCacheRetention, i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-BsH5cqGj.mjs";
 import Anthropic from "@anthropic-ai/sdk";
 import { Stream } from "@anthropic-ai/sdk/core/streaming.js";
+//#region packages/media-core/src/base64.ts
+/** Estimates decoded bytes without allocating a cleaned copy of the base64 payload. */
+function estimateBase64DecodedBytes(base64) {
+	let effectiveLen = 0;
+	for (let i = 0; i < base64.length; i += 1) {
+		if (base64.charCodeAt(i) <= 32) continue;
+		effectiveLen += 1;
+	}
+	if (effectiveLen === 0) return 0;
+	let padding = 0;
+	let end = base64.length - 1;
+	while (end >= 0 && base64.charCodeAt(end) <= 32) end -= 1;
+	if (end >= 0 && base64[end] === "=") {
+		padding = 1;
+		end -= 1;
+		while (end >= 0 && base64.charCodeAt(end) <= 32) end -= 1;
+		if (end >= 0 && base64[end] === "=") padding = 2;
+	}
+	const estimated = Math.floor(effectiveLen * 3 / 4) - padding;
+	return Math.max(0, estimated);
+}
+const CANONICALIZE_BASE64_CHUNK_SIZE = 8192;
+function isBase64DataChar(code) {
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 43 || code === 47;
+}
+/**
+* Normalizes and validates a base64 string, returning canonical no-whitespace
+* base64 only when the input has valid alphabet, padding, and length.
+*/
+function canonicalizeBase64(base64) {
+	const chunks = [];
+	let current = "";
+	let cleanedLength = 0;
+	let padding = 0;
+	let sawPadding = false;
+	const append = (char) => {
+		current += char;
+		cleanedLength += 1;
+		if (current.length >= CANONICALIZE_BASE64_CHUNK_SIZE) {
+			chunks.push(current);
+			current = "";
+		}
+	};
+	for (let i = 0; i < base64.length; i += 1) {
+		const code = base64.charCodeAt(i);
+		if (code <= 32) continue;
+		if (code === 61) {
+			padding += 1;
+			if (padding > 2) return;
+			sawPadding = true;
+			append("=");
+			continue;
+		}
+		if (sawPadding || !isBase64DataChar(code)) return;
+		append(base64[i] ?? "");
+	}
+	if (cleanedLength === 0) return;
+	const remainder = cleanedLength % 4;
+	if (remainder !== 0) {
+		if (sawPadding || remainder === 1) return;
+		current += "=".repeat(4 - remainder);
+	}
+	if (current) chunks.push(current);
+	return chunks.join("");
+}
+//#endregion
+//#region packages/ai/src/internal/anthropic-inline-images.ts
+const ANTHROPIC_IMAGE_MEDIA_TYPE_SET = /* @__PURE__ */ new Set([
+	"image/jpeg",
+	"image/png",
+	"image/gif",
+	"image/webp"
+]);
+const ANTHROPIC_INLINE_IMAGES_DECODE_SAFETY_BYTES = 64 * 1024 * 1024;
+function createAnthropicInlineImageBudget() {
+	return { totalBytes: 0 };
+}
+function resolveAnthropicImageMediaType(value) {
+	if (ANTHROPIC_IMAGE_MEDIA_TYPE_SET.has(value)) return value;
+	throw new Error(`Unsupported Anthropic image media type after normalization: ${value}`);
+}
+async function normalizeAnthropicInlineContent(content, budget) {
+	if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text");
+	const inputBytes = content.reduce((total, block) => block.type === "image" ? total + estimateBase64DecodedBytes(block.data) : total, 0);
+	if (budget.totalBytes + inputBytes > ANTHROPIC_INLINE_IMAGES_DECODE_SAFETY_BYTES) throw new Error("Anthropic inline images exceed the 64 MB aggregate decoded safety limit.");
+	const normalized = [];
+	for (const block of content) {
+		if (block.type !== "image") {
+			normalized.push(block);
+			continue;
+		}
+		const normalizedBlocks = await getAiTransportHost().normalizeAnthropicInlineContentBlocks([block]);
+		const outputBytes = normalizedBlocks.reduce((total, normalizedBlock) => normalizedBlock.type === "image" ? total + estimateBase64DecodedBytes(normalizedBlock.data) : total, 0);
+		if (budget.totalBytes + outputBytes > ANTHROPIC_INLINE_IMAGES_DECODE_SAFETY_BYTES) throw new Error("Anthropic inline images exceed the 64 MB aggregate decoded safety limit.");
+		budget.totalBytes += outputBytes;
+		normalized.push(...normalizedBlocks);
+	}
+	return normalized;
+}
+//#endregion
 //#region packages/ai/src/providers/anthropic-auth-headers.ts
 function usesFoundryBearerAuth(model) {
 	return model.provider === "microsoft-foundry" && (model.authHeader === true || hasBearerAuthorizationHeader(model.headers));
@@ -381,7 +481,7 @@ const toClaudeCodeName = (name) => ccToolLookup.get(name.toLowerCase()) ?? name;
 /**
 * Convert content blocks to Anthropic API format
 */
-function convertContentBlocks(content, isError) {
+async function convertContentBlocks(content, isError, imageBudget) {
 	const text = extractToolResultText(content);
 	const mediaPlaceholder = describeToolResultMediaPlaceholder(content);
 	if (!content.some(isImageWithMediaPayload)) {
@@ -402,12 +502,18 @@ function convertContentBlocks(content, isError) {
 			hasTextBlock = true;
 		}
 		if (!isImageWithMediaPayload(record)) continue;
+		const [normalizedImage] = await normalizeAnthropicInlineContent([{
+			type: "image",
+			data: typeof record.data === "string" ? record.data : "",
+			mimeType: typeof record.mimeType === "string" ? record.mimeType : "image/jpeg"
+		}], imageBudget);
+		if (normalizedImage?.type !== "image") continue;
 		blocks.push({
 			type: "image",
 			source: {
 				type: "base64",
-				media_type: typeof record.mimeType === "string" ? record.mimeType : "image/jpeg",
-				data: record.data
+				media_type: resolveAnthropicImageMediaType(normalizedImage.mimeType),
+				data: normalizedImage.data
 			}
 		});
 	}
@@ -518,7 +624,7 @@ const streamAnthropic = (model, context, options) => {
 				isOAuth = created.isOAuthToken;
 				serverSideFallback = created.serverSideFallback;
 			}
-			const builtParams = buildParams(model, requestContext, isOAuth, requestOptions, serverSideFallback);
+			const builtParams = await buildParams(model, requestContext, isOAuth, requestOptions, serverSideFallback);
 			let params = builtParams.params;
 			const toolProjection = builtParams.toolProjection;
 			const nextParams = await requestOptions?.onPayload?.(params, model);
@@ -1017,7 +1123,7 @@ function createClient(model, apiKey, thinkingEnabled, interleavedThinking, useFi
 		serverSideFallback
 	};
 }
-function buildParams(model, context, isOAuthTokenResult, options, serverSideFallback = false) {
+async function buildParams(model, context, isOAuthTokenResult, options, serverSideFallback = false) {
 	const mandatoryAdaptiveThinking = requiresClaudeAdaptiveThinking(model);
 	const replayThinkingEnabled = mandatoryAdaptiveThinking || options?.thinkingEnabled === true;
 	const { cacheControl } = getCacheControl(model, options?.cacheRetention);
@@ -1031,7 +1137,7 @@ function buildParams(model, context, isOAuthTokenResult, options, serverSideFall
 	const messageCacheControlLimit = Math.max(0, ANTHROPIC_CACHE_CONTROL_LIMIT - systemCacheControlCount - toolCacheControlCount);
 	const params = {
 		model: model.id,
-		messages: convertMessages(context.messages, model, isOAuthTokenResult, cacheControl, messageCacheControlLimit, replayThinkingEnabled, compat.allowEmptySignature),
+		messages: await convertMessages(context.messages, model, isOAuthTokenResult, cacheControl, messageCacheControlLimit, replayThinkingEnabled, compat.allowEmptySignature),
 		max_tokens: options?.maxTokens ?? model.maxTokens,
 		stream: true
 	};
@@ -1074,8 +1180,9 @@ function buildParams(model, context, isOAuthTokenResult, options, serverSideFall
 function normalizeToolCallId(id) {
 	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-function convertMessages(messages, model, isOAuthTokenValue, cacheControl, messageCacheControlLimit = 4, replayThinkingEnabled = true, allowEmptySignature = false) {
+async function convertMessages(messages, model, isOAuthTokenValue, cacheControl, messageCacheControlLimit = 4, replayThinkingEnabled = true, allowEmptySignature = false) {
 	const params = [];
+	const imageBudget = createAnthropicInlineImageBudget();
 	const cacheBreakpointOptOutParamIndexes = /* @__PURE__ */ new Set();
 	const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
 	const activeToolTurnAssistantIndex = replayThinkingEnabled ? -1 : findActiveAnthropicToolTurnAssistantIndex(transformedMessages);
@@ -1093,7 +1200,7 @@ function convertMessages(messages, model, isOAuthTokenValue, cacheControl, messa
 					});
 				}
 			} else {
-				const filteredBlocks = msg.content.map((item) => {
+				const filteredBlocks = (await normalizeAnthropicInlineContent(msg.content, imageBudget)).map((item) => {
 					if (item.type === "text") return {
 						type: "text",
 						text: sanitizeSurrogates(item.text)
@@ -1102,7 +1209,7 @@ function convertMessages(messages, model, isOAuthTokenValue, cacheControl, messa
 						type: "image",
 						source: {
 							type: "base64",
-							media_type: item.mimeType,
+							media_type: resolveAnthropicImageMediaType(item.mimeType),
 							data: item.data
 						}
 					};
@@ -1174,7 +1281,7 @@ function convertMessages(messages, model, isOAuthTokenValue, cacheControl, messa
 			toolResults.push({
 				type: "tool_result",
 				tool_use_id: msg.toolCallId,
-				content: convertContentBlocks(msg.content, msg.isError),
+				content: await convertContentBlocks(msg.content, msg.isError, imageBudget),
 				is_error: msg.isError
 			});
 			let j = i + 1;
@@ -1184,7 +1291,7 @@ function convertMessages(messages, model, isOAuthTokenValue, cacheControl, messa
 				toolResults.push({
 					type: "tool_result",
 					tool_use_id: nextMsg.toolCallId,
-					content: convertContentBlocks(nextMsg.content, nextMsg.isError),
+					content: await convertContentBlocks(nextMsg.content, nextMsg.isError, imageBudget),
 					is_error: nextMsg.isError
 				});
 				j++;
@@ -1321,4 +1428,4 @@ function mapStopReason(reason) {
 	}
 }
 //#endregion
-export { buildAnthropicServerSideFallbacks as _, readAnthropicPromptUsageSnapshot as a, omitFoundryBearerCredentialHeaders as b, projectAnthropicTools as c, ANTHROPIC_OMITTED_REASONING_TEXT as d, findActiveAnthropicToolTurnAssistantIndex as f, applyAnthropicFallbackBoundary as g, CLAUDE_FABLE_5_FALLBACK_MODEL_COST as h, readAnthropicCacheWriteUsage as i, reconcileAnthropicToolChoice as l, CLAUDE_FABLE_5_FALLBACK_MODEL as m, streamAnthropic as n, readAnthropicUsageTokenCount as o, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA as p, streamSimpleAnthropic as r, readLastAnthropicIterationUsage as s, anthropic_exports as t, resolveOriginalAnthropicToolName as u, readAnthropicFallbackBoundary as v, usesFoundryBearerAuth as x, applyAnthropicRefusal as y };
+export { normalizeAnthropicInlineContent as C, createAnthropicInlineImageBudget as S, canonicalizeBase64 as T, buildAnthropicServerSideFallbacks as _, readAnthropicPromptUsageSnapshot as a, omitFoundryBearerCredentialHeaders as b, projectAnthropicTools as c, ANTHROPIC_OMITTED_REASONING_TEXT as d, findActiveAnthropicToolTurnAssistantIndex as f, applyAnthropicFallbackBoundary as g, CLAUDE_FABLE_5_FALLBACK_MODEL_COST as h, readAnthropicCacheWriteUsage as i, reconcileAnthropicToolChoice as l, CLAUDE_FABLE_5_FALLBACK_MODEL as m, streamAnthropic as n, readAnthropicUsageTokenCount as o, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA as p, streamSimpleAnthropic as r, readLastAnthropicIterationUsage as s, anthropic_exports as t, resolveOriginalAnthropicToolName as u, readAnthropicFallbackBoundary as v, resolveAnthropicImageMediaType as w, usesFoundryBearerAuth as x, applyAnthropicRefusal as y };

package/dist/{api-registry-DXBIXISf.d.mts → api-registry-BMphkFf1.d.mts}

@@ -1,5 +1,4 @@
-import { E as Model, F as SimpleStreamOptions, R as StreamFunction, n as Api, o as AssistantMessageEventStreamContract, u as Context, z as StreamOptions } from "./types-CYORveZ7.mjs";
-
+import { E as Model, F as SimpleStreamOptions, R as StreamFunction, n as Api, o as AssistantMessageEventStreamContract, u as Context, z as StreamOptions } from "./types-AFwwWium.mjs";
 //#region packages/ai/src/api-registry.d.ts
 /** Runtime stream adapter signature stored in the API provider registry. */
 type ApiStreamFunction = (model: Model, context: Context, options?: StreamOptions) => AssistantMessageEventStreamContract;

package/dist/{azure-openai-responses-BkZgyZ3I.mjs → azure-openai-responses-CbrpVeEv.mjs}

@@ -1,10 +1,10 @@
-import { n as getEnvApiKey } from "./env-api-keys-DnhYpc27.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost } from "./host-4t713IeR.mjs";
-import { l as buildBaseOptions } from "./transform-messages-eb6lxDLB.mjs";
-import { a as resolveResponsesReasoningEffort, n as convertResponsesMessages, o as runResponsesStreamLifecycle, r as createResponsesAssistantOutput, t as applyCommonResponsesParams } from "./openai-responses-shared-CwnGU0KW.mjs";
+import { n as getAiTransportHost } from "./host-XYGZcgO8.mjs";
+import { D as buildBaseOptions } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
+import { a as resolveResponsesReasoningEffort, n as convertResponsesMessages, o as runResponsesStreamLifecycle, r as createResponsesAssistantOutput, t as applyCommonResponsesParams } from "./openai-responses-shared-CzCurmY1.mjs";
 import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-C7K7QfUE.mjs";
-import { a as clampOpenAIPromptCacheKey } from "./openai-tool-projection-WHf2nuOI.mjs";
+import { a as clampOpenAIPromptCacheKey } from "./openai-tool-projection-ITOU9bG1.mjs";
 import OpenAI, { AzureOpenAI } from "openai";
 //#region packages/ai/src/providers/azure-openai-responses.ts
 const DEFAULT_AZURE_API_VERSION = "v1";
@@ -94,11 +94,8 @@ function resolveAzureConfig(model, options) {
 	};
 }
 function createClient(model, apiKeyInput, options) {
-	let apiKey = apiKeyInput;
-	if (!apiKey) {
-		if (!process.env.AZURE_OPENAI_API_KEY) throw new Error("Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY environment variable or pass it as an argument.");
-		apiKey = process.env.AZURE_OPENAI_API_KEY;
-	}
+	const apiKey = apiKeyInput.trim();
+	if (!apiKey) throw new Error("Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY environment variable or pass it as an argument.");
 	const headers = { ...model.headers };
 	if (options?.headers) Object.assign(headers, options.headers);
 	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);

package/dist/{env-api-keys-DnhYpc27.mjs → env-api-keys-DrgeBuva.mjs}

@@ -82,7 +82,7 @@ function getProcEnv(key) {
 	return procEnvCache.get(key);
 }
 function getEnvValue(key) {
-	return getProcessEnv()?.[key] || getProcEnv(key);
+	return (getProcessEnv()?.[key] || getProcEnv(key))?.trim() || void 0;
 }
 let cachedVertexAdcCredentialsExists = null;
 function hasVertexAdcCredentials() {

package/dist/{event-stream-BPemFrFW.d.mts → event-stream-Douf9dob.d.mts}

@@ -1,4 +1,4 @@
-import { a as AssistantMessageEvent, i as AssistantMessage, o as AssistantMessageEventStreamContract } from "./types-CYORveZ7.mjs";
+import { a as AssistantMessageEvent, i as AssistantMessage, o as AssistantMessageEventStreamContract } from "./types-AFwwWium.mjs";
 
 //#region packages/llm-core/src/utils/event-stream.d.ts
 /** Generic async-iterable event stream with a separately awaited final result. */

package/dist/event-stream.d.mts

@@ -1,2 +1,2 @@
-import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-BPemFrFW.mjs";
+import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-Douf9dob.mjs";
 export { AssistantMessageEventStream, EventStream, createAssistantMessageEventStream };

package/dist/{google-C_biGbV7.mjs → google-Cs62KA7t.mjs}

@@ -1,8 +1,8 @@
-import { n as getEnvApiKey } from "./env-api-keys-DnhYpc27.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-4t713IeR.mjs";
-import { l as buildBaseOptions } from "./transform-messages-eb6lxDLB.mjs";
-import { a as runGoogleGenerateContentLifecycle, i as getDisabledGoogleThinkingConfig, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-BK-NoHl8.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-XYGZcgO8.mjs";
+import { D as buildBaseOptions } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
+import { a as runGoogleGenerateContentLifecycle, i as getDisabledGoogleThinkingConfig, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-CMLI-tCZ.mjs";
 import { GoogleGenAI } from "@google/genai";
 //#region packages/ai/src/providers/google.ts
 let toolCallCounter = 0;

package/dist/{google-shared-BK-NoHl8.mjs → google-shared-CMLI-tCZ.mjs}

@@ -1,7 +1,7 @@
-import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-1GiZ2_rr.mjs";
+import { C as isImageWithMediaPayload, a as stripSystemPromptCacheBoundary, c as transformMessages, x as extractToolResultText, y as describeToolResultMediaPlaceholder } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
 import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { i as extractToolResultText, n as describeToolResultMediaPlaceholder, o as isImageWithMediaPayload, t as transformMessages, w as stripSystemPromptCacheBoundary } from "./transform-messages-eb6lxDLB.mjs";
-import { t as formatProviderError } from "./provider-error-LMfTEkfO.mjs";
+import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-1GiZ2_rr.mjs";
+import { t as formatProviderError } from "./provider-error-C4VvV_3t.mjs";
 import { FinishReason, FunctionCallingConfigMode, ThinkingLevel } from "@google/genai";
 //#region packages/ai/src/providers/google-shared.ts
 /**

package/dist/{google-vertex-CvdzF1U7.mjs → google-vertex-B4SD3U0f.mjs}

@@ -1,7 +1,7 @@
 import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-4t713IeR.mjs";
-import { l as buildBaseOptions } from "./transform-messages-eb6lxDLB.mjs";
-import { a as runGoogleGenerateContentLifecycle, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-BK-NoHl8.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-XYGZcgO8.mjs";
+import { D as buildBaseOptions } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
+import { a as runGoogleGenerateContentLifecycle, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-CMLI-tCZ.mjs";
 import { GoogleGenAI, ResourceScope } from "@google/genai";
 //#region packages/ai/src/providers/google-vertex.ts
 const API_VERSION = "v1";

package/dist/host-WvWBo4h8.d.mts

@@ -0,0 +1,173 @@
+import { E as Model, L as StreamFn, n as Api, u as Context } from "./types-AFwwWium.mjs";
+import { n as ApiRegistry } from "./api-registry-BMphkFf1.mjs";
+
+//#region packages/ai/src/host.d.ts
+/** Provider capability facts needed by the package-owned transports. */
+interface AiProviderRequestCapabilities {
+  endpointClass: string;
+  knownProviderFamily: string;
+  supportsNativeStreamingUsageCompat: boolean;
+  supportsOpenAICompletionsStreamingUsageCompat: boolean;
+  usesExplicitProxyLikeEndpoint: boolean;
+  allowsAnthropicServiceTier: boolean;
+}
+/** Transport-safe provider policy input kept independent of OpenClaw config types. */
+interface AiProviderRequestPolicyInput {
+  provider?: string;
+  api?: string;
+  baseUrl?: string;
+  capability?: "llm" | "audio" | "image" | "video" | "other";
+  transport?: "stream" | "websocket" | "http" | "media-understanding";
+  modelId?: string | null;
+  compat?: unknown;
+}
+/** Context shared by plugin-owned provider stream hooks. */
+interface AiProviderStreamHookContext {
+  config?: unknown;
+  agentDir?: string;
+  workspaceDir?: string;
+  provider: string;
+  modelId: string;
+  model: Model;
+}
+/** Narrow plugin-runtime port used by package-owned transports. */
+interface AiTransportPluginHost {
+  resolveProviderStream(this: void, params: {
+    provider: string;
+    config?: unknown;
+    workspaceDir?: string;
+    env?: NodeJS.ProcessEnv;
+    allowRuntimePluginLoad?: boolean;
+    context: AiProviderStreamHookContext;
+  }): StreamFn | undefined;
+  resolveTransportTurnState(this: void, params: {
+    provider: string;
+    modelId?: string | null;
+    config?: unknown;
+    workspaceDir?: string;
+    env?: NodeJS.ProcessEnv;
+    allowRuntimePluginLoad?: boolean;
+    context: {
+      provider: string;
+      modelId: string;
+      model?: Model;
+      sessionId?: string;
+      turnId: string;
+      attempt: number;
+      transport: "stream" | "websocket";
+    };
+  }): {
+    headers?: Record<string, string>;
+    metadata?: Record<string, string>;
+  } | undefined;
+  wrapSimpleCompletionStream(this: void, params: {
+    provider: string;
+    config?: unknown;
+    context: AiProviderStreamHookContext & {
+      streamFn: StreamFn;
+    };
+  }): StreamFn | undefined;
+  createAnthropicVertexStream(this: void, model: Pick<Model, "baseUrl">, env?: NodeJS.ProcessEnv): StreamFn;
+}
+/** Host-owned transcript normalization contract used immediately before provider projection. */
+type AiTransformTransportMessages = (messages: Context["messages"], model: Model, normalizeToolCallId?: (id: string, targetModel: Model, source: {
+  provider: string;
+  api: Api;
+  model: string;
+}) => string, options?: {
+  normalizeSameModelToolCallIds?: boolean;
+  preserveCrossModelToolCallThoughtSignature?: boolean;
+}) => Context["messages"];
+/** Strict-tool policy inputs for OpenAI-compatible routes. */
+interface OpenAIStrictToolSettingOptions {
+  transport?: "stream" | "websocket";
+  supportsStrictMode?: boolean;
+}
+type AiInlineTextBlock = {
+  type: "text";
+  text: string;
+};
+type AiInlineImageBlock = {
+  type: "image";
+  data: string;
+  mimeType: string;
+};
+type AiInlineContentBlock = AiInlineTextBlock | AiInlineImageBlock;
+type AnthropicInlineContentNormalizer = (content: readonly AiInlineContentBlock[]) => Promise<AiInlineContentBlock[]>;
+/** Narrow host ports consumed by the built-in provider adapters. */
+interface AiTransportHost {
+  /**
+   * Builds a policy-guarded fetch for one model request.
+   * Returning undefined keeps the provider SDK's default fetch.
+   */
+  buildModelFetch(model: Model, timeoutMs?: number, options?: {
+    sanitizeSse?: boolean;
+  }): typeof fetch | undefined;
+  /** Resolves host-owned process-local secret sentinel substrings immediately before egress. */
+  resolveSecretSentinel(value: string): string;
+  /** Redacts secrets inside structured tool-result payloads. */
+  redactSecrets<T>(value: T): T;
+  /** Redacts secret-bearing text in tool payload strings. */
+  redactToolPayloadText(text: string): string;
+  /** Normalizes Anthropic inline image blocks before provider payload construction. */
+  normalizeAnthropicInlineContentBlocks?: AnthropicInlineContentNormalizer;
+  /**
+   * Resolves the host strict-tool default for OpenAI-compatible routes.
+   * undefined lets the request omit the strict flag entirely.
+   */
+  resolveOpenAIStrictToolSetting(model: Pick<Model, "provider" | "api" | "baseUrl" | "id"> & {
+    compat?: unknown;
+  }, options?: OpenAIStrictToolSettingOptions): boolean | undefined;
+  /** Provider-plugin operations required by the generic package transports. */
+  plugin: AiTransportPluginHost;
+  /** Builds provider-owned Copilot compatibility headers for one message turn. */
+  buildCopilotDynamicHeaders(messages: Context["messages"]): Record<string, string>;
+  /** Resolves endpoint classification without importing core provider registries. */
+  resolveProviderEndpointClass(baseUrl?: string): string;
+  /** Resolves provider capability flags used by payload compatibility policy. */
+  resolveProviderRequestCapabilities(input: AiProviderRequestPolicyInput): AiProviderRequestCapabilities;
+  /** Merges host-owned provider request headers and attribution policy. */
+  resolveProviderRequestHeaders(input: {
+    provider?: string;
+    api?: string;
+    baseUrl?: string;
+    providerHeaders?: Record<string, string>;
+    callerHeaders?: Record<string, string>;
+    precedence?: "caller-wins" | "defaults-win";
+  }): Record<string, string> | undefined;
+  /** Returns the host-configured request timeout attached to a model. */
+  resolveModelRequestTimeoutMs(model: Model): number | undefined;
+  /** Reports whether the model carries host-managed proxy, TLS, or local-service state. */
+  requiresManagedTransport(model: Model): boolean;
+  /** Copies host-owned managed-transport state onto a projected model. */
+  inheritManagedTransport(source: Model, target: Model): Model;
+  /** Applies host-owned transcript replay and pairing rules. */
+  transformTransportMessages: AiTransformTransportMessages;
+  /** Registers a custom transport API with the host's stream error bridge. */
+  registerCustomApi(registry: ApiRegistry, api: Api, streamFn: StreamFn): boolean;
+  /** Prepares the provider-owned Google simple-completion alias when needed. */
+  prepareGoogleSimpleCompletionModel(registry: ApiRegistry, model: Model): Model;
+  /**
+   * Emits one transport diagnostic; build runs only when the host logs it and
+   * may return null to suppress the entry (e.g. de-duplication).
+   */
+  logDebug(subsystem: string, build: () => {
+    message: string;
+    data?: Record<string, unknown>;
+  } | null): void;
+  /** Emits an informational transport diagnostic through the host logger. */
+  logInfo(subsystem: string, message: string, data?: Record<string, unknown>): void;
+  /** Emits a warning through the host logger. */
+  logWarn(subsystem: string, message: string, data?: Record<string, unknown>): void;
+}
+type ActiveAiTransportHost = Omit<AiTransportHost, "normalizeAnthropicInlineContentBlocks"> & {
+  normalizeAnthropicInlineContentBlocks: AnthropicInlineContentNormalizer;
+};
+/** Installs host implementations for the transport policy ports. */
+declare function configureAiTransportHost(host: Partial<AiTransportHost>): void;
+/** Returns the active transport host (inert defaults unless configured). */
+declare function getAiTransportHost(): ActiveAiTransportHost;
+/** Resolves sentinel substrings in custom headers at a no-fetch adapter boundary. */
+declare function resolveAiTransportHeaderSentinels(headers: Record<string, string> | undefined): Record<string, string> | undefined;
+//#endregion
+export { AiProviderRequestPolicyInput as a, AiTransportHost as c, configureAiTransportHost as d, getAiTransportHost as f, AiProviderRequestCapabilities as i, AiTransportPluginHost as l, AiInlineImageBlock as n, AiProviderStreamHookContext as o, resolveAiTransportHeaderSentinels as p, AiInlineTextBlock as r, AiTransformTransportMessages as s, AiInlineContentBlock as t, OpenAIStrictToolSettingOptions as u };

package/dist/host-XYGZcgO8.mjs

@@ -0,0 +1,98 @@
+//#region packages/ai/src/host.ts
+const MAX_PENDING_CUSTOM_API_REGISTRATIONS = 32;
+const pendingCustomApiRegistrations = [];
+function queueCustomApiRegistration(registry, api, streamFn) {
+	const existing = pendingCustomApiRegistrations.find((registration) => registration.registry === registry && registration.api === api);
+	if (existing) {
+		existing.streamFn = streamFn;
+		return false;
+	}
+	if (pendingCustomApiRegistrations.length >= MAX_PENDING_CUSTOM_API_REGISTRATIONS) throw new Error("Too many custom transport APIs were registered before host configuration");
+	pendingCustomApiRegistrations.push({
+		registry,
+		api,
+		streamFn
+	});
+	return false;
+}
+const inertAiTransportHost = {
+	buildModelFetch: () => void 0,
+	resolveSecretSentinel: (value) => value,
+	redactSecrets: (value) => value,
+	redactToolPayloadText: (text) => text,
+	normalizeAnthropicInlineContentBlocks: async (content) => [...content],
+	resolveOpenAIStrictToolSetting: (_model, options) => options?.supportsStrictMode ? false : void 0,
+	plugin: {
+		resolveProviderStream: () => void 0,
+		resolveTransportTurnState: () => void 0,
+		wrapSimpleCompletionStream: () => void 0,
+		createAnthropicVertexStream: () => {
+			throw new Error("Anthropic Vertex transport is not configured by the embedding host");
+		}
+	},
+	buildCopilotDynamicHeaders: () => ({}),
+	resolveProviderEndpointClass: () => "default",
+	resolveProviderRequestCapabilities: () => ({
+		endpointClass: "default",
+		knownProviderFamily: "",
+		supportsNativeStreamingUsageCompat: false,
+		supportsOpenAICompletionsStreamingUsageCompat: false,
+		usesExplicitProxyLikeEndpoint: false,
+		allowsAnthropicServiceTier: false
+	}),
+	resolveProviderRequestHeaders: ({ providerHeaders, callerHeaders, precedence }) => ({
+		...precedence === "caller-wins" ? providerHeaders : callerHeaders,
+		...precedence === "caller-wins" ? callerHeaders : providerHeaders
+	}),
+	resolveModelRequestTimeoutMs: () => void 0,
+	requiresManagedTransport: () => false,
+	inheritManagedTransport: (_source, target) => target,
+	transformTransportMessages: (messages) => messages,
+	registerCustomApi: queueCustomApiRegistration,
+	prepareGoogleSimpleCompletionModel: (_registry, model) => model,
+	logDebug: () => {},
+	logInfo: () => {},
+	logWarn: () => {}
+};
+let activeAiTransportHost = inertAiTransportHost;
+/** Installs host implementations for the transport policy ports. */
+function configureAiTransportHost(host) {
+	activeAiTransportHost = {
+		...inertAiTransportHost,
+		...host,
+		normalizeAnthropicInlineContentBlocks: host.normalizeAnthropicInlineContentBlocks ?? inertAiTransportHost.normalizeAnthropicInlineContentBlocks,
+		plugin: {
+			...inertAiTransportHost.plugin,
+			...host.plugin
+		}
+	};
+	const transportHost = activeAiTransportHost;
+	if (transportHost.registerCustomApi === inertAiTransportHost.registerCustomApi || pendingCustomApiRegistrations.length === 0) return;
+	const pending = pendingCustomApiRegistrations.splice(0);
+	for (const [index, registration] of pending.entries()) try {
+		transportHost.registerCustomApi(registration.registry, registration.api, registration.streamFn);
+	} catch (error) {
+		pendingCustomApiRegistrations.unshift(...pending.slice(index));
+		throw error;
+	}
+}
+/** Returns the active transport host (inert defaults unless configured). */
+function getAiTransportHost() {
+	return activeAiTransportHost;
+}
+/** Resolves sentinel substrings in custom headers at a no-fetch adapter boundary. */
+function resolveAiTransportHeaderSentinels(headers) {
+	if (!headers) return;
+	const host = getAiTransportHost();
+	let resolvedHeaders;
+	for (const [name, value] of Object.entries(headers)) {
+		const resolved = host.resolveSecretSentinel(value);
+		if (resolved !== value) {
+			resolvedHeaders ??= { ...headers };
+			resolvedHeaders[name] = resolved;
+		}
+	}
+	return resolvedHeaders ?? headers;
+}
+//#endregion
+export { getAiTransportHost as n, resolveAiTransportHeaderSentinels as r, configureAiTransportHost as t };

package/dist/index-BVVgDSdq.d.mts

@@ -0,0 +1 @@
+export { };