@openclaw/ai 2026.7.2-beta.5 → 2026.7.2-beta.7

package/dist/anthropic-usage-DWU-x8MI.mjs

@@ -0,0 +1,459 @@
+import { o as resolveClaudeFable5ModelIdentity, s as resolveClaudeModelIdentity, u as resolveClaudeOpus5ModelIdentity } from "./src-QkygScBs.mjs";
+import { g as isRecord, n as getAiTransportHost } from "./host-Dog2WQiR.mjs";
+import { m as sortPromptCacheToolsByName } from "./tool-result-text-CTpIRbYd.mjs";
+import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BwNu3nDi.mjs";
+//#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;
+}
+function base64DataValue(code) {
+	if (code >= 65 && code <= 90) return code - 65;
+	if (code >= 97 && code <= 122) return code - 97 + 26;
+	if (code >= 48 && code <= 57) return code - 48 + 52;
+	return code === 43 ? 62 : 63;
+}
+/**
+* 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;
+	let lastDataCode = 0;
+	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;
+		lastDataCode = code;
+		append(base64[i] ?? "");
+	}
+	if (cleanedLength === 0) return;
+	const remainder = cleanedLength % 4;
+	if (remainder !== 0) {
+		if (sawPadding || remainder === 1) return;
+		current += "=".repeat(4 - remainder);
+	}
+	const effectivePadding = remainder === 0 ? padding : 4 - remainder;
+	const padBitMask = effectivePadding === 2 ? 15 : effectivePadding === 1 ? 3 : 0;
+	if (padBitMask !== 0 && (base64DataValue(lastDataCode) & padBitMask) !== 0) return;
+	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));
+}
+function hasBearerAuthorizationHeader(headers) {
+	if (!headers) return false;
+	return Object.entries(headers).some(([key, value]) => key.toLowerCase() === "authorization" && /^bearer\s+\S+/i.test(value.trim()));
+}
+function omitFoundryBearerCredentialHeaders(headers) {
+	if (!headers) return;
+	const next = {};
+	for (const [key, value] of Object.entries(headers)) {
+		const lower = key.toLowerCase();
+		if (lower === "authorization" || lower === "x-api-key" || lower === "api-key") continue;
+		next[key] = value;
+	}
+	return Object.keys(next).length > 0 ? next : void 0;
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-refusal.ts
+function readNullableString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function readAnthropicRefusalDetails(value) {
+	if (!value || typeof value !== "object") return {
+		category: null,
+		explanation: null
+	};
+	const details = value;
+	return {
+		category: readNullableString(details.category),
+		explanation: readNullableString(details.explanation)
+	};
+}
+function formatAnthropicRefusalMessage(details) {
+	return `Anthropic refusal${details.category ? ` (category: ${details.category})` : ""}${details.explanation ? `: ${details.explanation}` : "."}`;
+}
+function applyAnthropicRefusal(output, stopDetails, provider) {
+	const details = readAnthropicRefusalDetails(stopDetails);
+	output.stopReason = "error";
+	output.errorMessage = formatAnthropicRefusalMessage(details);
+	output.diagnostics = [...output.diagnostics ?? [], {
+		type: "provider_refusal",
+		timestamp: Date.now(),
+		details: {
+			provider,
+			category: details.category,
+			explanation: details.explanation
+		}
+	}];
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-server-fallback.ts
+/** Anthropic beta that re-serves safety refusals on an allowed fallback model. */
+const ANTHROPIC_SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
+/** Let Anthropic select the recommended model for each refusal category. */
+const ANTHROPIC_SERVER_SIDE_FALLBACKS = "default";
+const CLAUDE_OPUS_FALLBACK_MODEL_COST = {
+	input: 5,
+	output: 25,
+	cacheRead: .5,
+	cacheWrite: 6.25
+};
+function resolveFallbackModelIdentity(modelId) {
+	if (!modelId?.trim()) return null;
+	const ref = { id: modelId };
+	const normalized = resolveClaudeModelIdentity(ref);
+	if (normalized === "opus" || normalized === "opus-5" || resolveClaudeOpus5ModelIdentity(ref)) return "claude-opus-5";
+	if (resolveClaudeFable5ModelIdentity(ref)) return "claude-fable-5";
+	if (/^claude-opus-4-8(?=$|[^a-z0-9])/.test(normalized)) return "claude-opus-4-8";
+	return normalized || null;
+}
+function isClaudeOpusFallbackModel(modelId) {
+	return modelId === "claude-opus-5" || modelId === "claude-opus-4-8";
+}
+/** Resolve billed rates from the serving model reported by Anthropic's fallback stream. */
+function resolveAnthropicFallbackServingModelCost(params) {
+	const requestedModelId = resolveFallbackModelIdentity(params.requestedModelId);
+	const servingModelId = resolveFallbackModelIdentity(params.servingModelId);
+	if (!servingModelId || servingModelId === requestedModelId || !isClaudeOpusFallbackModel(servingModelId)) return params.requestedCost;
+	if (requestedModelId && isClaudeOpusFallbackModel(requestedModelId)) return params.requestedCost;
+	return CLAUDE_OPUS_FALLBACK_MODEL_COST;
+}
+function readBoundaryModel(value) {
+	if (!value || typeof value !== "object") return null;
+	const model = value.model;
+	return typeof model === "string" && model.trim() ? model : null;
+}
+/** Reads a `fallback` content block marking where one model's output gives way to the next. */
+function readAnthropicFallbackBoundary(block) {
+	if (!block || typeof block !== "object") return null;
+	const record = block;
+	if (record.type !== "fallback") return null;
+	return {
+		fromModel: readBoundaryModel(record.from),
+		toModel: readBoundaryModel(record.to)
+	};
+}
+/**
+* Drops pre-fallback thinking/tool calls while preserving the text prefix that
+* the serving model continued. Dropped tool calls must never execute or replay.
+*/
+function applyAnthropicFallbackBoundary(params) {
+	const { output, boundary } = params;
+	const survivors = output.content.filter((block) => block.type === "text");
+	for (const survivor of survivors) delete survivor.textSignature;
+	output.content.splice(0, output.content.length, ...survivors);
+	if (boundary.toModel) output.responseModel = boundary.toModel;
+	output.diagnostics = [...output.diagnostics ?? [], {
+		type: "provider_fallback",
+		timestamp: Date.now(),
+		details: {
+			provider: params.provider,
+			fromModel: boundary.fromModel,
+			toModel: boundary.toModel
+		}
+	}];
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-thinking-replay.ts
+const ANTHROPIC_OMITTED_REASONING_TEXT = "[assistant reasoning omitted]";
+function asReplayMessage(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+/**
+* Anthropic tool results continue the preceding assistant turn. Preserve that
+* turn's signed thinking even when the next request disables new thinking.
+*/
+function findActiveAnthropicToolTurnAssistantIndex(messages) {
+	const toolResultIds = /* @__PURE__ */ new Set();
+	let index = messages.length - 1;
+	while (index >= 0) {
+		const message = asReplayMessage(messages[index]);
+		if (message?.role !== "toolResult") break;
+		if (typeof message.toolCallId === "string") toolResultIds.add(message.toolCallId);
+		index -= 1;
+	}
+	if (toolResultIds.size === 0) return -1;
+	const assistant = asReplayMessage(messages[index]);
+	if (assistant?.role !== "assistant" || !Array.isArray(assistant.content)) return -1;
+	const toolCallIds = /* @__PURE__ */ new Set();
+	for (const block of assistant.content) {
+		if (!block || typeof block !== "object") continue;
+		const record = block;
+		if ((record.type === "toolCall" || record.type === "tool_use" || record.type === "function_call") && typeof record.id === "string") toolCallIds.add(record.id);
+	}
+	return [...toolResultIds].every((toolCallId) => toolCallIds.has(toolCallId)) ? index : -1;
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-tool-projection.ts
+function isProviderSupportedViolation(violation) {
+	return violation.endsWith(".$dynamicRef") || violation.endsWith(".$dynamicAnchor");
+}
+const schemaValueKeywords = /* @__PURE__ */ new Set([
+	"additionalProperties",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+const schemaArrayKeywords = /* @__PURE__ */ new Set([
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+]);
+const schemaMapKeywords = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependencies",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+]);
+function normalizeAnthropicJsonSchema(schema) {
+	if (!isRecord(schema)) return schema;
+	let changed = false;
+	const normalized = { ...schema };
+	for (const [key, value] of Object.entries(schema)) {
+		if (schemaValueKeywords.has(key) && !Array.isArray(value)) {
+			const next = normalizeAnthropicJsonSchema(value);
+			normalized[key] = next;
+			changed ||= next !== value;
+			continue;
+		}
+		if (schemaArrayKeywords.has(key) && Array.isArray(value)) {
+			const next = value.map(normalizeAnthropicJsonSchema);
+			normalized[key] = next;
+			changed ||= next.some((entry, index) => entry !== value[index]);
+			continue;
+		}
+		if (schemaMapKeywords.has(key) && isRecord(value)) {
+			const next = Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, normalizeAnthropicJsonSchema(entryValue)]));
+			normalized[key] = next;
+			changed ||= Object.entries(value).some(([entryKey, entryValue]) => next[entryKey] !== entryValue);
+		}
+	}
+	if (Array.isArray(schema.items)) {
+		normalized.prefixItems = schema.items.map(normalizeAnthropicJsonSchema);
+		const additionalItems = schema.additionalItems;
+		if (typeof additionalItems === "boolean" || isRecord(additionalItems)) normalized.items = normalizeAnthropicJsonSchema(additionalItems);
+		else delete normalized.items;
+		delete normalized.additionalItems;
+		changed = true;
+	}
+	return changed ? normalized : schema;
+}
+/** Snapshots direct/custom tool descriptors before Anthropic payload construction. */
+function projectAnthropicTools(tools, toWireName) {
+	const projectedTools = [];
+	const unavailableOriginalNames = /* @__PURE__ */ new Set();
+	for (const tool of tools) {
+		let projectedTool;
+		let originalName;
+		try {
+			const name = tool.name;
+			originalName = name;
+			if (!name) continue;
+			const schemaProjection = projectRuntimeToolInputSchema(tool.parameters, `${name}.parameters`);
+			if (!isRecord(schemaProjection.schema) || schemaProjection.violations.some((violation) => !isProviderSupportedViolation(violation))) {
+				unavailableOriginalNames.add(name);
+				continue;
+			}
+			const anthropicSchema = normalizeAnthropicJsonSchema(schemaProjection.schema);
+			if (!isRecord(anthropicSchema)) {
+				unavailableOriginalNames.add(name);
+				continue;
+			}
+			const properties = anthropicSchema.properties;
+			const required = anthropicSchema.required;
+			if (properties !== void 0 && properties !== null && !isRecord(properties) || required !== void 0 && required !== null && (!Array.isArray(required) || required.some((entry) => typeof entry !== "string"))) {
+				unavailableOriginalNames.add(name);
+				continue;
+			}
+			let description;
+			try {
+				description = typeof tool.description === "string" ? tool.description : void 0;
+			} catch {}
+			projectedTool = {
+				originalName: name,
+				wireName: toWireName(name),
+				...description ? { description } : {},
+				inputSchema: {
+					type: "object",
+					properties: properties ?? {},
+					required: required ?? []
+				}
+			};
+		} catch {
+			if (originalName) unavailableOriginalNames.add(originalName);
+			continue;
+		}
+		const conflictingTool = projectedTools.find((entry) => entry.wireName === projectedTool.wireName);
+		if (conflictingTool && conflictingTool.originalName !== projectedTool.originalName) throw new Error(`Anthropic tool names "${conflictingTool.originalName}" and "${projectedTool.originalName}" both map to "${projectedTool.wireName}"`);
+		projectedTools.push(projectedTool);
+	}
+	return {
+		inputToolCount: tools.length,
+		unavailableOriginalNames,
+		tools: sortPromptCacheToolsByName(projectedTools)
+	};
+}
+/** Keeps forced Anthropic tool choices aligned with the projected wire names. */
+function reconcileAnthropicToolChoice(choice, projection) {
+	if (projection.inputToolCount === 0) return choice;
+	if (choice.type === "tool") {
+		const requestedName = choice.name;
+		const originalMatch = projection.tools.find((tool) => tool.originalName === requestedName);
+		if (originalMatch) return {
+			...choice,
+			name: originalMatch.wireName
+		};
+		if (projection.unavailableOriginalNames.has(requestedName)) throw new Error(`Anthropic tool_choice requested unavailable tool "${requestedName}" after schema conversion`);
+		const matchedTool = projection.tools.find((tool) => tool.wireName === requestedName);
+		if (!matchedTool) throw new Error(`Anthropic tool_choice requested unavailable tool "${requestedName}" after schema conversion`);
+		return {
+			...choice,
+			name: matchedTool.wireName
+		};
+	}
+	if (projection.tools.length === 0) {
+		if (choice.type === "auto") return;
+		if (choice.type === "any") throw new Error("Anthropic tool_choice requires a tool, but no tools survived schema conversion");
+	}
+	return choice;
+}
+/** Maps Claude Code wire names without trusting every direct/custom descriptor. */
+function resolveOriginalAnthropicToolName(name, projection) {
+	return projection?.tools.find((tool) => tool.wireName === name)?.originalName ?? name;
+}
+//#endregion
+//#region packages/ai/src/providers/anthropic-usage.ts
+function readAnthropicUsageTokenCount(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function readAnthropicCacheWriteUsage(usage) {
+	if (!usage.cache_creation || typeof usage.cache_creation !== "object") return {};
+	const cacheCreation = usage.cache_creation;
+	const cacheWrite5m = readAnthropicUsageTokenCount(cacheCreation.ephemeral_5m_input_tokens);
+	const cacheWrite1h = readAnthropicUsageTokenCount(cacheCreation.ephemeral_1h_input_tokens);
+	return {
+		...cacheWrite5m !== void 0 ? { cacheWrite5m } : {},
+		...cacheWrite1h !== void 0 ? { cacheWrite1h } : {}
+	};
+}
+function readAnthropicPromptUsageSnapshot(usage) {
+	const input = readAnthropicUsageTokenCount(usage.input_tokens);
+	const cacheRead = usage.cache_read_input_tokens == null ? 0 : readAnthropicUsageTokenCount(usage.cache_read_input_tokens);
+	const cacheWrite = usage.cache_creation_input_tokens == null ? 0 : readAnthropicUsageTokenCount(usage.cache_creation_input_tokens);
+	if (input === void 0 || cacheRead === void 0 || cacheWrite === void 0) return;
+	return {
+		input,
+		cacheRead,
+		cacheWrite
+	};
+}
+function readLastAnthropicIterationUsage(usage) {
+	if (usage.iterations == null) return { state: "absent" };
+	if (!Array.isArray(usage.iterations) || usage.iterations.length === 0) return { state: "invalid" };
+	const iteration = usage.iterations.at(-1);
+	if (!iteration || typeof iteration !== "object" || Array.isArray(iteration)) return { state: "invalid" };
+	const record = iteration;
+	const input = readAnthropicUsageTokenCount(record.input_tokens);
+	const cacheRead = readAnthropicUsageTokenCount(record.cache_read_input_tokens);
+	const cacheWrite = readAnthropicUsageTokenCount(record.cache_creation_input_tokens);
+	const outputTokens = readAnthropicUsageTokenCount(record.output_tokens);
+	if (input === void 0 || cacheRead === void 0 || cacheWrite === void 0 || outputTokens === void 0) return { state: "invalid" };
+	const contextPromptTokens = input + cacheRead + cacheWrite;
+	return {
+		state: "valid",
+		usage: {
+			contextPromptTokens,
+			totalTokens: contextPromptTokens + outputTokens
+		}
+	};
+}
+//#endregion
+export { canonicalizeBase64 as S, omitFoundryBearerCredentialHeaders as _, projectAnthropicTools as a, normalizeAnthropicInlineContent as b, ANTHROPIC_OMITTED_REASONING_TEXT as c, ANTHROPIC_SERVER_SIDE_FALLBACK_BETA as d, CLAUDE_OPUS_FALLBACK_MODEL_COST as f, applyAnthropicRefusal as g, resolveAnthropicFallbackServingModelCost as h, readLastAnthropicIterationUsage as i, findActiveAnthropicToolTurnAssistantIndex as l, readAnthropicFallbackBoundary as m, readAnthropicPromptUsageSnapshot as n, reconcileAnthropicToolChoice as o, applyAnthropicFallbackBoundary as p, readAnthropicUsageTokenCount as r, resolveOriginalAnthropicToolName as s, readAnthropicCacheWriteUsage as t, ANTHROPIC_SERVER_SIDE_FALLBACKS as u, usesFoundryBearerAuth as v, resolveAnthropicImageMediaType as x, createAnthropicInlineImageBudget as y };

package/dist/{azure-openai-responses-DIYgsqFM.mjs → azure-openai-responses-CImcwB83.mjs}

@@ -1,9 +1,10 @@
 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-XYGZcgO8.mjs";
+import { n as getAiTransportHost } from "./host-Dog2WQiR.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { A as buildBaseOptions } from "./shared-CdjNZd35.mjs";
-import { a as convertResponsesMessages, c as runResponsesStreamLifecycle, i as applyCommonResponsesParams, o as createResponsesAssistantOutput, s as resolveResponsesReasoningEffort, vt as isOpenAICompatibleAzureResponsesBaseUrl, xt as resolveAzureDeploymentNameFromMap } from "./openai-D3PD6PE-.mjs";
+import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-C7K7QfUE.mjs";
+import { n as buildBaseOptions } from "./simple-options-9lhRrN73.mjs";
+import { a as runResponsesStreamLifecycle, i as resolveResponsesReasoningEffort, n as convertResponsesMessages, r as createResponsesAssistantOutput, t as applyCommonResponsesParams } from "./openai-responses-shared-pXl6Wd8S.mjs";
 import OpenAI, { AzureOpenAI } from "openai";
 //#region packages/ai/src/providers/azure-openai-responses.ts
 const DEFAULT_AZURE_API_VERSION = "v1";

package/dist/azure-openai-responses-client-compat-C7K7QfUE.mjs

@@ -0,0 +1,62 @@
+//#region packages/ai/src/providers/azure-deployment-map.ts
+/** Parses AZURE_OPENAI_DEPLOYMENT_MAP-style model=deployment entries. */
+function parseAzureDeploymentNameMap(value) {
+	const map = /* @__PURE__ */ new Map();
+	if (!value) return map;
+	for (const entry of value.split(",")) {
+		const trimmed = entry.trim();
+		if (!trimmed) continue;
+		const separator = trimmed.indexOf("=");
+		if (separator <= 0) continue;
+		const modelId = trimmed.slice(0, separator).trim();
+		const deploymentName = trimmed.slice(separator + 1).trim();
+		if (!modelId || !deploymentName) continue;
+		map.set(modelId, deploymentName);
+	}
+	return map;
+}
+let cachedDeploymentLookup;
+function getDeploymentLookup(source) {
+	const cached = cachedDeploymentLookup;
+	if (cached && cached.source === source) return cached;
+	const exact = parseAzureDeploymentNameMap(source);
+	const folded = /* @__PURE__ */ new Map();
+	for (const [modelId, deploymentName] of exact) folded.set(modelId.toLowerCase(), deploymentName);
+	cachedDeploymentLookup = {
+		source,
+		exact,
+		folded
+	};
+	return cachedDeploymentLookup;
+}
+/**
+* Resolves the Azure deployment name for a model id, falling back to the model id.
+*
+* An exact-case match always wins, so configs that intentionally distinguish keys by
+* case keep their exact mappings; a case-insensitive match is only used as a fallback
+* (e.g. `GPT-4o` against a `gpt-4o=...` map) to avoid 404s from casing differences.
+*/
+function resolveAzureDeploymentNameFromMap(params) {
+	const { exact, folded } = getDeploymentLookup(params.deploymentMap);
+	return exact.get(params.modelId) ?? folded.get(params.modelId.toLowerCase()) ?? params.modelId;
+}
+//#endregion
+//#region packages/ai/src/providers/azure-openai-responses-client-compat.ts
+function isTraditionalAzureOpenAIHost(hostname) {
+	return hostname.endsWith(".openai.azure.com") || hostname.endsWith(".cognitiveservices.azure.com");
+}
+function isOpenAICompatibleAzureResponsesBaseUrl(baseUrl) {
+	let url;
+	try {
+		url = new URL(baseUrl);
+	} catch {
+		return false;
+	}
+	if (isTraditionalAzureOpenAIHost(url.hostname)) return false;
+	const hostname = url.hostname.toLowerCase();
+	if (!(hostname.endsWith(".services.ai.azure.com") || hostname.endsWith(".api.cognitive.microsoft.com"))) return false;
+	const normalizedPath = url.pathname.replace(/\/+$/, "");
+	return normalizedPath === "/openai/v1" || normalizedPath.endsWith("/openai/v1");
+}
+//#endregion
+export { resolveAzureDeploymentNameFromMap as i, isTraditionalAzureOpenAIHost as n, parseAzureDeploymentNameMap as r, isOpenAICompatibleAzureResponsesBaseUrl as t };

package/dist/cache-retention-0x979a5V.mjs

@@ -0,0 +1,12 @@
+//#region packages/ai/src/providers/cache-retention.ts
+/**
+* Resolve cache retention preference.
+* Defaults to "short" and uses OPENCLAW_CACHE_RETENTION for backward compatibility.
+*/
+function resolveCacheRetention(cacheRetention) {
+	if (cacheRetention === "short" || cacheRetention === "long" || cacheRetention === "none") return cacheRetention;
+	if (typeof process !== "undefined" && process.env.OPENCLAW_CACHE_RETENTION === "long") return "long";
+	return "short";
+}
+//#endregion
+export { resolveCacheRetention as t };

package/dist/deferred-event-buffer-DAvyP7qA.mjs

@@ -0,0 +1,19 @@
+//#region packages/ai/src/utils/deferred-event-buffer.ts
+function createDeferredEventBuffer(sink, onBufferedEvent) {
+	let events = [];
+	return {
+		push(event) {
+			events.push(event);
+			onBufferedEvent?.();
+		},
+		flush() {
+			for (const event of events) sink.push(event);
+			events = [];
+		},
+		discard() {
+			events = [];
+		}
+	};
+}
+//#endregion
+export { createDeferredEventBuffer as t };

package/dist/github-copilot-headers-NCJtz9i0.mjs

@@ -0,0 +1,37 @@
+//#region packages/ai/src/providers/cloudflare.ts
+function isCloudflareProvider(provider) {
+	return provider === "cloudflare-workers-ai" || provider === "cloudflare-ai-gateway";
+}
+/** Substitute `{VAR}` placeholders in a Cloudflare baseUrl from process.env. */
+function resolveCloudflareBaseUrl(model) {
+	const url = model.baseUrl;
+	if (!url.includes("{")) return url;
+	return url.replace(/\{([A-Z_][A-Z0-9_]*)\}/g, (_match, name) => {
+		const value = process.env[name];
+		if (!value) throw new Error(`${name} is required for provider ${model.provider} but is not set.`);
+		return value;
+	});
+}
+//#endregion
+//#region packages/ai/src/providers/github-copilot-headers.ts
+function inferCopilotInitiator(messages) {
+	const last = messages[messages.length - 1];
+	return last && last.role !== "user" ? "agent" : "user";
+}
+function hasCopilotVisionInput(messages) {
+	return messages.some((msg) => {
+		if (msg.role === "user" && Array.isArray(msg.content)) return msg.content.some((c) => c.type === "image");
+		if (msg.role === "toolResult" && Array.isArray(msg.content)) return msg.content.some((c) => c.type === "image");
+		return false;
+	});
+}
+function buildCopilotDynamicHeaders(params) {
+	const headers = {
+		"X-Initiator": inferCopilotInitiator(params.messages),
+		"Openai-Intent": "conversation-edits"
+	};
+	if (params.hasImages) headers["Copilot-Vision-Request"] = "true";
+	return headers;
+}
+//#endregion
+export { resolveCloudflareBaseUrl as i, hasCopilotVisionInput as n, isCloudflareProvider as r, buildCopilotDynamicHeaders as t };

package/dist/{google-f-A8xrae.mjs → google-CtSg0iTS.mjs}

@@ -1,8 +1,8 @@
 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-XYGZcgO8.mjs";
-import { A as buildBaseOptions } from "./shared-CdjNZd35.mjs";
-import { a as runGoogleGenerateContentLifecycle, i as getDisabledGoogleThinkingConfig, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-J6qvYINH.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-Dog2WQiR.mjs";
+import { n as buildBaseOptions } from "./simple-options-9lhRrN73.mjs";
+import { a as runGoogleGenerateContentLifecycle, i as getDisabledGoogleThinkingConfig, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-DNBz5rcD.mjs";
 import { GoogleGenAI } from "@google/genai";
 //#region packages/ai/src/providers/google.ts
 let toolCallCounter = 0;

package/dist/{google-shared-J6qvYINH.mjs → google-shared-DNBz5rcD.mjs}

@@ -1,8 +1,10 @@
-import { E as isImageWithMediaPayload, S as describeToolResultMediaPlaceholder, o as stripSystemPromptCacheBoundary, u as transformMessages, w as extractToolResultText } from "./shared-CdjNZd35.mjs";
+import { i as transformMessages } from "./host-Dog2WQiR.mjs";
 import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
+import { a as isImageWithMediaPayload, d as stripSystemPromptCacheBoundary, r as extractToolResultText, t as describeToolResultMediaPlaceholder } from "./tool-result-text-CTpIRbYd.mjs";
 import { c as calculateCost, l as clampThinkingLevel } from "./number-coercion-DvG7SNMg.mjs";
-import { d as transportAbortError } from "./transport-stream-shared-BbMELSI4.mjs";
-import { t as formatProviderError } from "./provider-error-apVOZI6G.mjs";
+import { d as transportAbortError } from "./transport-stream-shared-D81p90xq.mjs";
+import { t as formatProviderError } from "./provider-error-CAEvRjry.mjs";
+import "./transform-messages-C8mBqZxF.mjs";
 import { FinishReason, FunctionCallingConfigMode, ThinkingLevel } from "@google/genai";
 //#region packages/ai/src/providers/google-shared.ts
 /**

package/dist/{google-vertex-D3yMVXIY.mjs → google-vertex-31f1uS9L.mjs}

@@ -1,7 +1,7 @@
 import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-XYGZcgO8.mjs";
-import { A as buildBaseOptions } from "./shared-CdjNZd35.mjs";
-import { a as runGoogleGenerateContentLifecycle, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-J6qvYINH.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-Dog2WQiR.mjs";
+import { n as buildBaseOptions } from "./simple-options-9lhRrN73.mjs";
+import { a as runGoogleGenerateContentLifecycle, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-DNBz5rcD.mjs";
 import { GoogleGenAI, ResourceScope } from "@google/genai";
 //#region packages/ai/src/providers/google-vertex.ts
 const API_VERSION = "v1";