@openclaw/ai 2026.7.2-beta.7 → 2026.8.1-beta.2

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

@@ -1,10 +1,8 @@
-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-D81p90xq.mjs";
-import { t as formatProviderError } from "./provider-error-CAEvRjry.mjs";
-import "./transform-messages-C8mBqZxF.mjs";
+import { i as clampThinkingLevel, r as calculateCost, t as sanitizeSurrogates } from "./sanitize-unicode-BYqrYtC_.mjs";
+import { a as describeToolResultMediaPlaceholder, l as isImageWithMediaPayload, s as extractToolResultText } from "./host-DTqNc7ad.mjs";
+import { f as sortPromptCacheToolsByName, l as stripSystemPromptCacheBoundary } from "./simple-options-D58D5Kvw.mjs";
+import { f as transportAbortError, n as assignTransportErrorDetails, r as coerceTransportToolCallArguments, t as transformProviderMessages } from "./provider-transcript-transform-ePx-Bbfr.mjs";
+import { t as googleFlashSupportsMinimalThinking } from "./google-thinking-level-C-V3tecN.mjs";
 import { FinishReason, FunctionCallingConfigMode, ThinkingLevel } from "@google/genai";
 //#region packages/ai/src/providers/google-shared.ts
 /**
@@ -82,7 +80,8 @@ function convertMessages(model, context) {
 		if (!requiresToolCallId(model.id)) return id;
 		return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 	};
-	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+	const transformedMessages = transformProviderMessages(context.messages, model, normalizeToolCallId);
+	const requiresToolCallThoughtSignature = model.provider !== "google-gemini-cli" && (isGemini3ProModel(model) || isGemini3FlashModel(model));
 	const pendingToolResultImageTurns = [];
 	let activeToolResultParts;
 	const flushToolResultRun = () => {
@@ -94,17 +93,17 @@ function convertMessages(model, context) {
 		if (msg.role !== "toolResult") flushToolResultRun();
 		if (msg.role === "user") if (typeof msg.content === "string") contents.push({
 			role: "user",
-			parts: [{ text: sanitizeSurrogates(msg.content) }]
+			parts: [{ text: sanitizeSurrogates(msg.content) || " " }]
 		});
 		else {
 			const parts = msg.content.map((item) => {
-				if (item.type === "text") return { text: sanitizeSurrogates(item.text) };
+				if (item.type === "text") return { text: sanitizeSurrogates(item.text) || " " };
 				return { inlineData: {
 					mimeType: item.mimeType,
 					data: item.data
 				} };
 			});
-			if (parts.length === 0) continue;
+			if (parts.length === 0) parts.push({ text: " " });
 			contents.push({
 				role: "user",
 				parts
@@ -112,30 +111,32 @@ function convertMessages(model, context) {
 		}
 		else if (msg.role === "assistant") {
 			const parts = [];
-			const isSameProviderAndModel = msg.provider === model.provider && msg.model === model.id;
+			let sawFunctionCall = false;
+			const isSameProviderAndModel = msg.provider === model.provider && msg.api === model.api && msg.model === model.id;
 			for (const block of msg.content) if (block.type === "text") {
-				if (!block.text || block.text.trim() === "") continue;
 				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.textSignature);
+				if ((!block.text || block.text.trim() === "") && !thoughtSignature) continue;
 				parts.push({
 					text: sanitizeSurrogates(block.text),
 					...thoughtSignature && { thoughtSignature }
 				});
 			} else if (block.type === "thinking") {
-				if (!block.thinking || block.thinking.trim() === "") continue;
-				if (isSameProviderAndModel) {
-					const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thinkingSignature);
-					parts.push({
-						thought: true,
-						text: sanitizeSurrogates(block.thinking),
-						...thoughtSignature && { thoughtSignature }
-					});
-				} else parts.push({ text: sanitizeSurrogates(block.thinking) });
+				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thinkingSignature);
+				if ((!block.thinking || block.thinking.trim() === "") && !thoughtSignature) continue;
+				if (isSameProviderAndModel) parts.push({
+					thought: true,
+					text: sanitizeSurrogates(block.thinking),
+					...thoughtSignature && { thoughtSignature }
+				});
+				else parts.push({ text: sanitizeSurrogates(block.thinking) });
 			} else if (block.type === "toolCall") {
-				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature);
+				const args = coerceTransportToolCallArguments(block.arguments);
+				const thoughtSignature = resolveThoughtSignature(isSameProviderAndModel, block.thoughtSignature) ?? (!sawFunctionCall && requiresToolCallThoughtSignature ? "skip_thought_signature_validator" : void 0);
+				sawFunctionCall = true;
 				const part = {
 					functionCall: {
 						name: block.name,
-						args: block.arguments ?? {},
+						args,
 						...requiresToolCallId(model.id) ? { id: block.id } : {}
 					},
 					...thoughtSignature && { thoughtSignature }
@@ -181,45 +182,22 @@ function convertMessages(model, context) {
 		}
 	}
 	flushToolResultRun();
+	if (contents.length === 0) contents.push({
+		role: "user",
+		parts: [{ text: " " }]
+	});
 	return contents;
 }
-const JSON_SCHEMA_META_DECLARATIONS = /* @__PURE__ */ new Set([
-	"$schema",
-	"$id",
-	"$anchor",
-	"$dynamicAnchor",
-	"$vocabulary",
-	"$comment",
-	"$defs",
-	"definitions"
-]);
-/**
-* Strip meta-declarations from a schema obj
-*/
-function sanitizeForOpenApi(schema) {
-	if (typeof schema !== "object" || schema === null || Array.isArray(schema)) return schema;
-	const result = {};
-	for (const [key, value] of Object.entries(schema)) {
-		if (JSON_SCHEMA_META_DECLARATIONS.has(key)) continue;
-		result[key] = sanitizeForOpenApi(value);
-	}
-	return result;
-}
 /**
 * Convert tools to Gemini function declarations format.
-*
-* By default uses `parametersJsonSchema` which supports full JSON Schema (including
-* anyOf, oneOf, const, etc.). Set `useParameters` to true to use the legacy `parameters`
-* field instead (OpenAPI 3.03 Schema). This is needed for Cloud Code Assist with Claude
-* models, where the API translates `parameters` into Anthropic's `input_schema`.
 * @internal Directly tested provider implementation detail.
 */
-function convertTools(tools, useParameters = false) {
+function convertTools(tools) {
 	if (tools.length === 0) return;
-	return [{ functionDeclarations: tools.map((tool) => ({
+	return [{ functionDeclarations: sortPromptCacheToolsByName(tools).map((tool) => ({
 		name: tool.name,
 		description: tool.description,
-		...useParameters ? { parameters: sanitizeForOpenApi(tool.parameters) } : { parametersJsonSchema: tool.parameters }
+		parametersJsonSchema: tool.parameters
 	})) }];
 }
 /**
@@ -276,17 +254,16 @@ async function runGoogleGenerateContentLifecycle(params) {
 		});
 	} catch (error) {
 		for (const block of output.content) if ("index" in block) delete block.index;
-		output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-		output.errorMessage = formatProviderError(error);
+		assignTransportErrorDetails(output, options?.signal?.aborted ? transportAbortError(options.signal) : error, options?.signal);
 		stream.push({
 			type: "error",
-			reason: output.stopReason,
+			reason: output.stopReason === "aborted" ? "aborted" : "error",
 			error: output
 		});
 		stream.end();
 	}
 }
-function buildGoogleGenerateContentParams(model, context, options = {}, configHooks) {
+function buildGoogleGenerateContentParams(model, context, options = {}) {
 	const contents = convertMessages(model, context);
 	const generationConfig = {};
 	if (options.temperature !== void 0) generationConfig.temperature = options.temperature;
@@ -304,7 +281,10 @@ function buildGoogleGenerateContentParams(model, context, options = {}, configHo
 		if (options.thinking.level !== void 0) thinkingConfig.thinkingLevel = ThinkingLevel[options.thinking.level];
 		else if (options.thinking.budgetTokens !== void 0) thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
 		config.thinkingConfig = thinkingConfig;
-	} else if (model.reasoning && options.thinking && !options.thinking.enabled) config.thinkingConfig = configHooks?.getDisabledThinkingConfig ? configHooks.getDisabledThinkingConfig(model) : getDisabledGoogleThinkingConfig(model);
+	} else if (model.reasoning && options.thinking && !options.thinking.enabled) {
+		const disabledThinkingConfig = getDisabledGoogleThinkingConfig(model);
+		if (Object.keys(disabledThinkingConfig).length > 0) config.thinkingConfig = disabledThinkingConfig;
+	}
 	if (options.signal) {
 		if (options.signal.aborted) throw new Error("Request aborted");
 		config.abortSignal = options.signal;
@@ -315,8 +295,22 @@ function buildGoogleGenerateContentParams(model, context, options = {}, configHo
 		config
 	};
 }
+function isAdaptiveGoogleReasoningLevel(value) {
+	return value === "adaptive";
+}
 function buildGoogleSimpleThinking(model, options, config) {
 	if (!options?.reasoning || options.reasoning === "off") return { enabled: false };
+	if (isAdaptiveGoogleReasoningLevel(options.reasoning)) {
+		if (!model.reasoning) return { enabled: false };
+		if (isGemma4Model(model)) return {
+			enabled: true,
+			level: ThinkingLevel.HIGH
+		};
+		return isGemini3ProModel(model) || isGemini3FlashModel(model) ? { enabled: true } : {
+			enabled: true,
+			budgetTokens: -1
+		};
+	}
 	const clampedReasoning = clampThinkingLevel(model, options.reasoning);
 	if (clampedReasoning === "off") return { enabled: false };
 	const effort = clampedReasoning === "max" ? "high" : clampedReasoning;
@@ -329,10 +323,10 @@ function buildGoogleSimpleThinking(model, options, config) {
 		budgetTokens: getGoogleBudget(model, effort, options.thinkingBudgets, { useFlashLiteBudgets: config?.useFlashLiteBudgets })
 	};
 }
-function getDisabledGoogleThinkingConfig(model, config) {
+function getDisabledGoogleThinkingConfig(model) {
 	if (isGemini3ProModel(model)) return { thinkingLevel: ThinkingLevel.LOW };
-	if (isGemini3FlashModel(model)) return { thinkingLevel: ThinkingLevel.MINIMAL };
-	if (config?.includeGemma4 && isGemma4Model(model)) return { thinkingLevel: ThinkingLevel.MINIMAL };
+	if (isGemini3FlashModel(model)) return { thinkingLevel: googleFlashSupportsMinimalThinking(model.id) ? ThinkingLevel.MINIMAL : ThinkingLevel.LOW };
+	if (isGemma4Model(model) || model.id.toLowerCase().includes("gemini-2.5-pro")) return {};
 	return { thinkingBudget: 0 };
 }
 /** @internal Directly tested provider implementation detail. */
@@ -340,10 +334,10 @@ function isGemma4Model(model) {
 	return /gemma-?4/.test(model.id.toLowerCase());
 }
 function isGemini3ProModel(model) {
-	return /gemini-3(?:\.\d+)?-pro/.test(model.id.toLowerCase());
+	return /gemini-(?:3(?:\.\d+)?-pro|pro-latest)/.test(model.id.toLowerCase());
 }
 function isGemini3FlashModel(model) {
-	return /gemini-3(?:\.\d+)?-flash/.test(model.id.toLowerCase());
+	return /gemini-(?:3(?:\.\d+)?-flash|flash(?:-lite)?-latest)/.test(model.id.toLowerCase());
 }
 function getGoogleThinkingLevel(effort, model, config) {
 	if (isGemini3ProModel(model)) switch (effort) {
@@ -359,7 +353,7 @@ function getGoogleThinkingLevel(effort, model, config) {
 		case "high": return ThinkingLevel.HIGH;
 	}
 	switch (effort) {
-		case "minimal": return ThinkingLevel.MINIMAL;
+		case "minimal": return isGemini3FlashModel(model) && !googleFlashSupportsMinimalThinking(model.id) ? ThinkingLevel.LOW : ThinkingLevel.MINIMAL;
 		case "low": return ThinkingLevel.LOW;
 		case "medium": return ThinkingLevel.MEDIUM;
 		case "high": return ThinkingLevel.HIGH;
@@ -422,6 +416,15 @@ async function consumeGoogleGenerateContentStream(params) {
 	});
 	let currentBlock = null;
 	const blocks = params.output.content;
+	let sawTerminalReason = false;
+	let terminalGenerationError;
+	const knownUsage = {
+		promptTokenCount: 0,
+		cachedContentTokenCount: 0,
+		toolUsePromptTokenCount: 0,
+		candidatesTokenCount: 0,
+		thoughtsTokenCount: 0
+	};
 	const toolCallIds = /* @__PURE__ */ new Set();
 	for (const block of blocks) if (block.type === "toolCall") toolCallIds.add(block.id);
 	const blockIndex = () => blocks.length - 1;
@@ -443,9 +446,60 @@ async function consumeGoogleGenerateContentStream(params) {
 	};
 	for await (const chunk of params.chunks) {
 		params.output.responseId ||= chunk.responseId;
+		if (chunk.usageMetadata) {
+			for (const field of Object.keys(knownUsage)) {
+				const value = chunk.usageMetadata[field];
+				if (typeof value === "number") knownUsage[field] = value;
+			}
+			const promptTokens = knownUsage.promptTokenCount;
+			const cacheRead = knownUsage.cachedContentTokenCount;
+			const toolUsePromptTokens = knownUsage.toolUsePromptTokenCount;
+			const outputTokens = knownUsage.candidatesTokenCount + knownUsage.thoughtsTokenCount;
+			params.output.usage = {
+				input: Math.max(0, promptTokens - cacheRead) + toolUsePromptTokens,
+				output: outputTokens,
+				cacheRead,
+				cacheWrite: 0,
+				totalTokens: chunk.usageMetadata.totalTokenCount ?? promptTokens + outputTokens + toolUsePromptTokens,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			};
+			calculateCost(params.model, params.output.usage);
+		}
 		const candidate = chunk.candidates?.[0];
-		if (candidate?.content?.parts) for (const part of candidate.content.parts) {
-			if (part.text !== void 0) {
+		const promptFeedback = chunk.promptFeedback;
+		if (!candidate && promptFeedback) {
+			const blockReason = promptFeedback.blockReason ?? "PROMPT_BLOCKED";
+			const blockMessage = promptFeedback.blockReasonMessage?.trim();
+			params.output.errorCode = blockReason;
+			params.output.errorType = "google_prompt_blocked";
+			throw new Error(`Google prompt blocked (${blockReason})${blockMessage ? `: ${blockMessage}` : ""}`);
+		}
+		if (candidate?.content?.parts) for (const [partIndex, part] of candidate.content.parts.entries()) {
+			const text = part.text;
+			const hasText = typeof text === "string";
+			const hasThoughtSignature = typeof part.thoughtSignature === "string" && part.thoughtSignature.length > 0;
+			const signatureOnly = hasThoughtSignature && (!hasText || text.length === 0) && Object.keys(part).every((key) => key === "thought" || key === "thoughtSignature" || key === "text");
+			if (signatureOnly) {
+				if (!hasText && part.thought !== true) {
+					const latestBlock = blocks.at(-1);
+					if (partIndex === 0 && latestBlock?.type === "toolCall" && !latestBlock.thoughtSignature) {
+						latestBlock.thoughtSignature = retainThoughtSignature(latestBlock.thoughtSignature, part.thoughtSignature);
+						continue;
+					}
+				}
+				endCurrentBlock();
+			}
+			if (hasText || signatureOnly) {
+				if (currentBlock && (hasThoughtSignature || partIndex > 0)) {
+					const currentSignature = currentBlock.type === "thinking" ? currentBlock.thinkingSignature : currentBlock.textSignature;
+					if ((currentBlock.type === "thinking" ? currentBlock.thinking : currentBlock.text).length > 0 && (currentSignature !== part.thoughtSignature || partIndex > 0 && (currentSignature || hasThoughtSignature))) endCurrentBlock();
+				}
 				const isThinking = isThinkingPart(part);
 				if (!currentBlock || isThinking && currentBlock.type !== "thinking" || !isThinking && currentBlock.type !== "text") {
 					endCurrentBlock();
@@ -474,25 +528,27 @@ async function consumeGoogleGenerateContentStream(params) {
 						});
 					}
 				}
+				const delta = hasText ? text : "";
 				if (currentBlock.type === "thinking") {
-					currentBlock.thinking += part.text;
+					currentBlock.thinking += delta;
 					currentBlock.thinkingSignature = retainThoughtSignature(currentBlock.thinkingSignature, part.thoughtSignature);
 					params.stream.push({
 						type: "thinking_delta",
 						contentIndex: blockIndex(),
-						delta: part.text,
+						delta,
 						partial: params.output
 					});
 				} else {
-					currentBlock.text += part.text;
+					currentBlock.text += delta;
 					currentBlock.textSignature = retainThoughtSignature(currentBlock.textSignature, part.thoughtSignature);
 					params.stream.push({
 						type: "text_delta",
 						contentIndex: blockIndex(),
-						delta: part.text,
+						delta,
 						partial: params.output
 					});
 				}
+				if (signatureOnly) endCurrentBlock();
 			}
 			if (part.functionCall) {
 				endCurrentBlock();
@@ -526,29 +582,30 @@ async function consumeGoogleGenerateContentStream(params) {
 			}
 		}
 		if (candidate?.finishReason) {
+			sawTerminalReason = true;
 			params.output.stopReason = mapStopReason(candidate.finishReason);
+			if (params.output.stopReason === "error") {
+				const finishMessage = candidate.finishMessage?.trim();
+				terminalGenerationError = Object.assign(/* @__PURE__ */ new Error(`Google generation stopped (${candidate.finishReason})${finishMessage ? `: ${finishMessage}` : ""}`), {
+					code: candidate.finishReason,
+					type: "google_generation_failed"
+				});
+			}
 			if (params.output.stopReason === "stop" && params.output.content.some((block) => block.type === "toolCall")) params.output.stopReason = "toolUse";
 		}
-		if (chunk.usageMetadata) {
-			params.output.usage = {
-				input: (chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
-				output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
-				cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
-				cacheWrite: 0,
-				totalTokens: chunk.usageMetadata.totalTokenCount || 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			};
-			calculateCost(params.model, params.output.usage);
-		}
 	}
 	endCurrentBlock();
 	if (params.signal?.aborted) throw transportAbortError(params.signal);
+	if (terminalGenerationError) {
+		params.output.errorCode = terminalGenerationError.code;
+		params.output.errorType = terminalGenerationError.type;
+		throw terminalGenerationError;
+	}
+	if (!sawTerminalReason) {
+		params.output.errorCode = "STREAM_INCOMPLETE";
+		params.output.errorType = "google_incomplete_stream";
+		throw new Error("Google stream ended before a terminal finish reason");
+	}
 	if (params.output.stopReason === "aborted" || params.output.stopReason === "error") throw new Error("An unknown error occurred");
 	params.stream.push({
 		type: "done",
@@ -558,4 +615,4 @@ async function consumeGoogleGenerateContentStream(params) {
 	params.stream.end();
 }
 //#endregion
-export { runGoogleGenerateContentLifecycle as a, getDisabledGoogleThinkingConfig as i, buildGoogleSimpleThinking as n, createGoogleAssistantOutput as r, buildGoogleGenerateContentParams as t };
+export { runGoogleGenerateContentLifecycle as i, buildGoogleSimpleThinking as n, createGoogleAssistantOutput as r, buildGoogleGenerateContentParams as t };

package/dist/google-thinking-level-C-V3tecN.mjs

@@ -0,0 +1,9 @@
+//#region packages/ai/src/transports/google-thinking-level.ts
+/** Returns whether a Gemini Flash model accepts the MINIMAL thinking level. */
+function googleFlashSupportsMinimalThinking(modelId) {
+	const match = modelId.toLowerCase().match(/(?:^|\/)gemini-3\.(\d+)-flash(?:-|$)/);
+	if (!match) return true;
+	return Number.parseInt(match[1] ?? "0", 10) < 7;
+}
+//#endregion
+export { googleFlashSupportsMinimalThinking as t };

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

@@ -1,7 +1,8 @@
-import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.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 { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { a as normalizeOptionalString } from "./string-coerce-fsri9iCu.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-DTqNc7ad.mjs";
+import { n as buildBaseOptions } from "./simple-options-D58D5Kvw.mjs";
+import { i as runGoogleGenerateContentLifecycle, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-B0Qr9OR7.mjs";
 import { GoogleGenAI, ResourceScope } from "@google/genai";
 //#region packages/ai/src/providers/google-vertex.ts
 const API_VERSION = "v1";
@@ -27,7 +28,10 @@ const streamSimpleGoogleVertex = (model, context, options) => {
 	const base = buildBaseOptions(model, options, void 0);
 	return streamGoogleVertex(model, context, {
 		...base,
-		thinking: buildGoogleSimpleThinking(model, options)
+		thinking: buildGoogleSimpleThinking(model, options, {
+			includeGemma4ThinkingLevel: true,
+			useFlashLiteBudgets: true
+		})
 	});
 };
 function createClient(model, project, location, optionsHeaders) {
@@ -82,12 +86,12 @@ function isPlaceholderApiKey(apiKey) {
 	return /^<[^>]+>$/.test(apiKey);
 }
 function resolveProject(options) {
-	const project = options?.project || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
+	const project = normalizeOptionalString(options?.project) || normalizeOptionalString(process.env.GOOGLE_CLOUD_PROJECT) || normalizeOptionalString(process.env.GCLOUD_PROJECT);
 	if (!project) throw new Error("Vertex AI requires a project ID. Set GOOGLE_CLOUD_PROJECT/GCLOUD_PROJECT or pass project in options.");
 	return project;
 }
 function resolveLocation(options) {
-	const location = options?.location || process.env.GOOGLE_CLOUD_LOCATION;
+	const location = normalizeOptionalString(options?.location) || normalizeOptionalString(process.env.GOOGLE_CLOUD_LOCATION);
 	if (!location) throw new Error("Vertex AI requires a location. Set GOOGLE_CLOUD_LOCATION or pass location in options.");
 	return location;
 }

package/dist/{llm-request-activity-BjtkplhG.mjs → headers-DdOQtGuU.mjs}

@@ -14,4 +14,12 @@ function onLlmRequestActivity(signal, listener) {
 	};
 }
 //#endregion
-export { onLlmRequestActivity as n, notifyLlmRequestActivity as t };
+//#region packages/ai/src/utils/headers.ts
+/** Converts a Headers object to a plain record for provider request handling. */
+function headersToRecord(headers) {
+	const result = {};
+	for (const [key, value] of headers.entries()) result[key] = value;
+	return result;
+}
+//#endregion
+export { notifyLlmRequestActivity as n, onLlmRequestActivity as r, headersToRecord as t };