zidane 8.2.1 → 8.2.3

package/dist/providers/google.js

@@ -1,784 +1 @@
-import { b as providerLimitReason, d as classifyProviderLimit, g as isRetryableHttpStatus, u as classifyErrorPrelude, v as matchesContextExceeded, y as matchesToolPairingError } from "../errors-C3z7pmOx.js";
-import { i as documentBlockMarker, n as assertResolvedMediaBlock } from "../types-CzmghX7C.js";
-import { A as lookupModel, P as systemNotesAsText, T as fillEstimatedCost, g as createToolNameBoundary, h as userMessage, j as mergeCatalogEntry, m as toolResultsMessage, o as assistantMessage, v as sanitizeToolSpecs, z as unsupportedMediaError } from "../openai-compat-5HkREis_.js";
-import { renderSystemForWire } from "../prompt.js";
-import { c as reasoningWireAction } from "../messages-Wd0QtRUJ.js";
-import { t as GOOGLE_VERTEX_OAUTH_ID } from "../google-oauth-g3JmRoJ-.js";
-import { a as pinnedAccountMissingError, l as resolveOAuthApiKey, o as readAccountOAuthCredential, s as readOAuthCredentials } from "../oauth-DRrs-65k.js";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { lstat, readdir, rm } from "node:fs/promises";
-import { normalizeContext } from "@earendil-works/pi-ai";
-import { getBuiltinModel } from "@earendil-works/pi-ai/providers/all";
-//#region src/providers/google.ts
-/** Model used when a request names none. Served on free-tier Gemini API keys. */
-const GOOGLE_DEFAULT_MODEL = "gemini-3.8-flash";
-/**
-* Models pi-ai hasn't bundled yet, served on both routes. A pi-ai release
-* that bundles one supersedes its entry (bundled metadata always wins), so
-* delete the entry then.
-*/
-const GOOGLE_EXTRA_MODELS = [];
-const lookupBuiltin = getBuiltinModel;
-function builtinModel(route, modelId) {
-	try {
-		return lookupBuiltin(route, modelId);
-	} catch {
-		return;
-	}
-}
-/**
-* pi-ai model record for `modelId` on `route`: the bundled entry, else a
-* {@link GOOGLE_EXTRA_MODELS} overlay, else the default model's shape under
-* the requested id. A catalog entry overlays whichever applies.
-*
-* @param route - Backend the request goes to.
-* @param modelId - Requested model id.
-* @param catalog - Per-run catalog override.
-*/
-function resolveGoogleModel(route, modelId, catalog) {
-	const entry = lookupModel(route, modelId, catalog);
-	const bundled = builtinModel(route, modelId);
-	if (bundled) return mergeCatalogEntry(bundled, entry);
-	const extra = GOOGLE_EXTRA_MODELS.find((m) => m.id === modelId);
-	const template = builtinModel(route, extra?.template ?? "gemini-3.8-flash");
-	if (!template) throw new Error(`Google model registry (${route}) is missing ${extra?.template ?? "gemini-3.8-flash"}`);
-	if (extra) return mergeCatalogEntry({
-		...template,
-		id: extra.id,
-		name: extra.name,
-		contextWindow: extra.contextWindow,
-		maxTokens: extra.maxTokens,
-		cost: extra.rates()
-	}, entry);
-	return mergeCatalogEntry({
-		...template,
-		id: modelId,
-		name: modelId
-	}, entry);
-}
-function formatTools(tools) {
-	return sanitizeToolSpecs(tools, { profile: "openai" }).map((t) => ({
-		name: t.name,
-		description: t.description ?? "",
-		parameters: t.inputSchema
-	}));
-}
-function documentMarker(doc) {
-	return documentBlockMarker(doc, "document omitted");
-}
-function emptyUsage() {
-	return {
-		input: 0,
-		output: 0,
-		cacheRead: 0,
-		cacheWrite: 0,
-		totalTokens: 0,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	};
-}
-function piUserMessage(content, provider) {
-	for (const b of content) {
-		if (b.type === "audio") throw unsupportedMediaError("audio", provider);
-		if (b.type === "video") throw unsupportedMediaError("video", provider);
-	}
-	const parts = [];
-	for (const block of content) if (block.type === "text") parts.push({
-		type: "text",
-		text: block.text
-	});
-	else if (block.type === "image") {
-		assertResolvedMediaBlock(block, "Google wire messages");
-		parts.push({
-			type: "image",
-			data: block.data,
-			mimeType: block.mediaType
-		});
-	} else if (block.type === "document") {
-		assertResolvedMediaBlock(block, "Google wire messages");
-		parts.push({
-			type: "text",
-			text: documentMarker(block)
-		});
-	}
-	if (parts.length === 0) return null;
-	if (parts.length === 1 && parts[0].type === "text") return {
-		role: "user",
-		content: parts[0].text,
-		timestamp: Date.now()
-	};
-	return {
-		role: "user",
-		content: parts,
-		timestamp: Date.now()
-	};
-}
-function piToolResultMessage(result, toolName, provider) {
-	const content = typeof result.output === "string" ? [{
-		type: "text",
-		text: result.output
-	}] : result.output.map((block) => {
-		if (block.type === "image") {
-			assertResolvedMediaBlock(block, "Google wire messages");
-			return {
-				type: "image",
-				data: block.data,
-				mimeType: block.mediaType
-			};
-		}
-		if (block.type === "audio") throw unsupportedMediaError("audio", provider);
-		if (block.type === "video") throw unsupportedMediaError("video", provider);
-		if (block.type === "document") {
-			assertResolvedMediaBlock(block, "Google wire messages");
-			return {
-				type: "text",
-				text: documentMarker(block)
-			};
-		}
-		return {
-			type: "text",
-			text: block.text
-		};
-	});
-	return {
-		role: "toolResult",
-		toolCallId: result.callId,
-		toolName,
-		content,
-		isError: result.isError ?? false,
-		timestamp: Date.now()
-	};
-}
-/**
-* One assistant turn for pi-ai. A turn holding this route's signatures is
-* stamped with the TARGET model, so pi-ai treats it as its own and replays
-* the signatures (Google accepts them across its models). Any other turn is
-* stamped foreign: pi-ai then sends its reasoning as plain text and its
-* calls unsigned.
-*/
-function piAssistantMessage(content, model, route) {
-	const native = content.some((block) => (block.type === "text" || block.type === "tool_call" || block.type === "thinking") && block.signature !== void 0 && block.signatureProducer === route);
-	const own = (block) => native && block.signatureProducer === route ? block.signature : void 0;
-	const piContent = [];
-	for (const block of content) if (block.type === "text") {
-		const signature = own(block);
-		piContent.push({
-			type: "text",
-			text: block.text,
-			...signature ? { textSignature: signature } : {}
-		});
-	} else if (block.type === "thinking") {
-		const action = reasoningWireAction(block, route);
-		if (action === "drop") continue;
-		const signature = action === "keep" ? own(block) : void 0;
-		piContent.push({
-			type: "thinking",
-			thinking: block.text,
-			...signature ? { thinkingSignature: signature } : {}
-		});
-	} else if (block.type === "tool_call") {
-		const signature = own(block);
-		piContent.push({
-			type: "toolCall",
-			id: block.id,
-			name: block.name,
-			arguments: block.input,
-			...signature ? { thoughtSignature: signature } : {}
-		});
-	}
-	return {
-		role: "assistant",
-		content: piContent,
-		api: model.api,
-		provider: native ? model.provider : "zidane",
-		model: native ? model.id : "history",
-		usage: emptyUsage(),
-		stopReason: "stop",
-		timestamp: Date.now()
-	};
-}
-/**
-* Converts session messages to pi-ai messages for a Google backend.
-*
-* Unlike the Responses wire, an assistant turn stays whole: Gemini signs only
-* the FIRST function call of a parallel step, so splitting the calls into
-* separate model turns would leave the others unsigned. Its tool results
-* follow in call order (pi-ai folds them into one user turn), with the
-* synthetic placeholder for any the history lost.
-*
-* @param messages - Session messages, tool names already on the wire.
-* @param model - Target model.
-* @param route - Signature scope of the target (the backend's route name by default).
-* @param provider - Provider named in unsupported-media errors. Defaults to `route`.
-*/
-function toGooglePiMessages(messages, model, route, provider = route) {
-	messages = systemNotesAsText(messages);
-	const out = [];
-	for (let i = 0; i < messages.length; i++) {
-		const msg = messages[i];
-		if (msg.role === "assistant") {
-			out.push(piAssistantMessage(msg.content, model, route));
-			const calls = msg.content.filter((b) => b.type === "tool_call");
-			if (calls.length === 0) continue;
-			const next = messages[i + 1];
-			const results = new Map((next?.role === "user" ? next.content : []).filter((b) => b.type === "tool_result").map((r) => [r.callId, r]));
-			for (const call of calls) {
-				const result = results.get(call.id) ?? {
-					type: "tool_result",
-					callId: call.id,
-					output: "[Tool result missing due to internal error]",
-					isError: true
-				};
-				out.push(piToolResultMessage(result, call.name, provider));
-			}
-			if (next?.role === "user") {
-				const rest = piUserMessage(next.content.filter((b) => b.type !== "tool_result"), provider);
-				if (rest) out.push(rest);
-				i++;
-			}
-			continue;
-		}
-		const userMsg = piUserMessage(msg.content.filter((b) => b.type !== "tool_result"), provider);
-		if (userMsg) out.push(userMsg);
-	}
-	return out;
-}
-/**
-* Converts pi-ai's final assistant message to a session message, tagging
-* every thought signature with the route that issued it.
-*
-* @param message - pi-ai assistant message.
-* @param route - Signature scope that produced it.
-*/
-function fromGooglePiAssistantMessage(message, route) {
-	const signed = (signature) => signature ? {
-		signature,
-		signatureProducer: route
-	} : {};
-	const content = [];
-	for (const block of message.content) if (block.type === "text") content.push({
-		type: "text",
-		text: block.text,
-		...signed(block.textSignature)
-	});
-	else if (block.type === "thinking") content.push({
-		type: "thinking",
-		text: block.thinking,
-		...signed(block.thinkingSignature)
-	});
-	else if (block.type === "toolCall") content.push({
-		type: "tool_call",
-		id: block.id,
-		name: block.name,
-		input: block.arguments,
-		...signed(block.thoughtSignature)
-	});
-	return {
-		role: "assistant",
-		content
-	};
-}
-function mapStopReason(stopReason, hasToolCalls) {
-	switch (stopReason) {
-		case "toolUse": return "tool-calls";
-		case "length": return "length";
-		case "error": return "error";
-		case "aborted": return "other";
-		default: return hasToolCalls ? "tool-calls" : "stop";
-	}
-}
-/** Forced tool choice, written into Gemini's `functionCallingConfig`. */
-function applyToolChoice(payload, options, toWire) {
-	const choice = options.toolChoice;
-	if (!choice || choice.type === "auto") return payload;
-	const params = payload;
-	if (!params.config?.toolConfig) return payload;
-	params.config.toolConfig.functionCallingConfig = choice.type === "tool" && choice.name ? {
-		mode: "ANY",
-		allowedFunctionNames: [toWire(choice.name)]
-	} : { mode: "ANY" };
-	return params;
-}
-/**
-* Transient Gemini failures worth a loop-level retry once pi-ai's own retries
-* (408 / 409 / 429 / 5xx before the stream opens) are spent.
-*/
-const TRANSIENT_GOOGLE_MESSAGE_RE = /RESOURCE_EXHAUSTED|UNAVAILABLE|DEADLINE_EXCEEDED|overloaded|high demand|rate.?limit|try again later/i;
-/** Gemini's `RetryInfo` detail in a 429 body: `"retryDelay": "34s"`. */
-const RETRY_DELAY_RE = /"retryDelay"\s*:\s*"(\d+(?:\.\d+)?)s"/;
-/** pi-ai formats HTTP failures as `<status>: <body>`. */
-function leadingStatus(message) {
-	const match = /^(\d{3})\b/.exec(message);
-	return match ? Number(match[1]) : void 0;
-}
-function parseGoogleErrorBody(text) {
-	try {
-		const parsed = JSON.parse(text);
-		return parsed && typeof parsed.error === "object" && parsed.error ? parsed.error : void 0;
-	} catch {
-		return;
-	}
-}
-/**
-* The stream error pi-ai reports, as Google wrote it. `@google/genai` wraps a
-* non-JSON response as `{"error":{"message":"<body>"}}`, so Google's own
-* `{"error":{…}}` can arrive JSON-encoded inside it.
-*
-* @param raw - pi-ai's `errorMessage`: `<status>: <body>` or the SDK's message.
-* @returns The innermost message prefixed with its HTTP and RPC status, the
-* status, and the innermost body (it carries details such as `retryDelay`).
-*/
-function unwrapGoogleError(raw) {
-	let status = leadingStatus(raw);
-	let rpcStatus;
-	let text = status === void 0 ? raw : raw.replace(/^\d{3}:\s*/, "");
-	let message;
-	let body = raw;
-	for (let error = parseGoogleErrorBody(text); error; error = parseGoogleErrorBody(text)) {
-		body = text;
-		if (typeof error.code === "number") status = error.code;
-		if (typeof error.status === "string" && /^[A-Z_]+$/.test(error.status)) rpcStatus = error.status;
-		if (typeof error.message !== "string") break;
-		message = text = error.message.trim();
-	}
-	if (!message) return {
-		message: raw,
-		...status !== void 0 ? { status } : {}
-	};
-	const prefix = [status, rpcStatus].filter((part) => part !== void 0).join(" ");
-	return {
-		message: prefix ? `${prefix}: ${message}` : message,
-		...status !== void 0 ? { status } : {},
-		body
-	};
-}
-/**
-* Classify a Gemini API / Vertex AI error.
-*
-* @param err - Error thrown by pi-ai or the SDK.
-* @param label - Product a limit's message names; routes over other services (Antigravity) pass their own.
-*/
-function classifyGoogleError(err, label = "Gemini") {
-	const prelude = classifyErrorPrelude(err);
-	if (prelude === "not-object") return null;
-	if (prelude === "aborted") return { kind: "aborted" };
-	const anyErr = err;
-	const message = typeof anyErr.message === "string" ? anyErr.message : "";
-	if (matchesContextExceeded(message)) return {
-		kind: "context_exceeded",
-		providerCode: "context_length_exceeded",
-		message
-	};
-	if (matchesToolPairingError(message)) return {
-		kind: "tool_pairing_corruption",
-		message
-	};
-	if (!message) return null;
-	const status = typeof anyErr.status === "number" ? anyErr.status : leadingStatus(message);
-	const retryable = status !== void 0 && isRetryableHttpStatus(status) || TRANSIENT_GOOGLE_MESSAGE_RE.test(message);
-	const reason = providerLimitReason({
-		status,
-		message
-	});
-	if (reason) {
-		const delay = RETRY_DELAY_RE.exec(typeof anyErr.body === "string" ? anyErr.body : message);
-		return classifyProviderLimit({
-			reason,
-			provider: label,
-			...delay ? { retryAfterMs: Number(delay[1]) * 1e3 } : {}
-		}, {
-			...status !== void 0 ? { providerCode: String(status) } : {},
-			retryable
-		});
-	}
-	return {
-		kind: "provider_error",
-		...status !== void 0 ? { providerCode: String(status) } : {},
-		message,
-		...retryable ? { retryable: true } : {}
-	};
-}
-/** Every budget level at `tokens`: pi-ai picks the level, the caller fixed the budget. */
-function budgetsAt(tokens) {
-	return {
-		minimal: tokens,
-		low: tokens,
-		medium: tokens,
-		high: tokens
-	};
-}
-/** Names a {@link googleCompatible} route can't take: built-in providers and signature producers. */
-const RESERVED_ROUTE_NAMES = /* @__PURE__ */ new Set([
-	"google",
-	"google-vertex",
-	"anthropic",
-	"openai",
-	"zidane"
-]);
-function createGoogleProvider(route, params) {
-	const defaultModel = params?.defaultModel || "gemini-3.8-flash";
-	const capabilities = params?.capabilities ?? {
-		vision: true,
-		imageInToolResult: true,
-		audio: false,
-		video: false,
-		documents: false
-	};
-	return {
-		name: route.name,
-		meta: {
-			defaultModel,
-			isOAuth: route.isOAuth,
-			capabilities
-		},
-		formatTools,
-		userMessage,
-		assistantMessage,
-		toolResultsMessage,
-		classifyError: route.classifyError ?? classifyGoogleError,
-		async stream(options, callbacks) {
-			const auth = await route.auth(callbacks);
-			try {
-				return await streamTurn(auth, options, callbacks);
-			} finally {
-				auth.dispose?.();
-			}
-		}
-	};
-	async function streamTurn(auth, options, callbacks) {
-		const modelId = options.model || defaultModel;
-		const model = route.resolveModel ? route.resolveModel(modelId, options.modelCatalog) : resolveGoogleModel(route.name, modelId, options.modelCatalog);
-		const scope = signatureScopeOf(route, model.id);
-		const tools = options.tools;
-		const nameBoundary = createToolNameBoundary(options.messages, tools.map((tool) => tool.name));
-		const context = normalizeContext({
-			systemPrompt: renderSystemForWire(options.system),
-			messages: toGooglePiMessages(nameBoundary.messages, model, scope, route.name),
-			tools: tools.map((tool) => ({
-				...tool,
-				name: nameBoundary.toWire(tool.name)
-			}))
-		});
-		const api = await route.load();
-		const base = {
-			...auth.apiKey ? { apiKey: auth.apiKey } : {},
-			...auth.env ? { env: auth.env } : {},
-			...options.maxTokens !== void 0 ? { maxTokens: options.maxTokens } : {},
-			signal: options.signal,
-			...params?.extraHeaders ? { headers: params.extraHeaders } : {},
-			onPayload: (payload) => applyToolChoice(payload, options, nameBoundary.toWire)
-		};
-		let s;
-		if (options.thinking === "adaptive" && model.reasoning) {
-			const { buildBaseOptions } = await import("@earendil-works/pi-ai/api/simple-options");
-			s = api.stream(model, context, {
-				...buildBaseOptions(model, context, base),
-				thinking: { enabled: true }
-			});
-		} else {
-			const reasoning = options.thinking && options.thinking !== "off" && options.thinking !== "adaptive" ? options.thinking : void 0;
-			s = api.streamSimple(model, context, {
-				...base,
-				...reasoning ? { reasoning } : {},
-				...reasoning && options.thinkingBudget !== void 0 ? { thinkingBudgets: budgetsAt(options.thinkingBudget) } : {}
-			});
-		}
-		let finalMessage;
-		let text = "";
-		let thinking = "";
-		for await (const event of s) if (event.type === "text_delta") {
-			text += event.delta;
-			callbacks.onText(event.delta);
-		} else if (event.type === "thinking_delta") {
-			thinking += event.delta;
-			callbacks.onThinking?.(event.delta);
-		} else if (event.type === "thinking_end") {
-			const delta = event.content.startsWith(thinking) ? event.content.slice(thinking.length) : thinking ? "" : event.content;
-			if (delta) {
-				thinking += delta;
-				callbacks.onThinking?.(delta);
-			}
-		} else if (event.type === "toolcall_start" || event.type === "toolcall_delta") callbacks.onToolCallDelta?.();
-		else if (event.type === "done") finalMessage = event.message;
-		else if (event.type === "error") {
-			const { message, ...details } = unwrapGoogleError(event.error.errorMessage || `Google ${route.name} API error`);
-			throw Object.assign(new Error(message), details);
-		}
-		finalMessage ??= await s.result();
-		const toolCalls = finalMessage.content.filter((block) => block.type === "toolCall").map((block) => ({
-			id: block.id,
-			name: nameBoundary.fromWire(block.name),
-			input: block.arguments
-		}));
-		const assistantTurn = fromGooglePiAssistantMessage(finalMessage, scope);
-		assistantTurn.content = assistantTurn.content.map((block) => block.type === "tool_call" ? {
-			...block,
-			name: nameBoundary.fromWire(block.name)
-		} : block);
-		const finishReason = mapStopReason(finalMessage.stopReason, toolCalls.length > 0);
-		const usage = await fillEstimatedCost({
-			input: finalMessage.usage.input,
-			output: finalMessage.usage.output,
-			cacheRead: finalMessage.usage.cacheRead || void 0,
-			...finalMessage.usage.reasoning ? { thinking: finalMessage.usage.reasoning } : {},
-			cost: finalMessage.usage.cost.total || void 0,
-			finishReason,
-			modelId
-		}, route.name, void 0, options.modelCatalog);
-		return {
-			assistantMessage: assistantTurn,
-			text: text || finalMessage.content.flatMap((block) => block.type === "text" ? [block.text] : []).join(""),
-			toolCalls,
-			done: toolCalls.length === 0,
-			usage
-		};
-	}
-}
-/**
-* The scope a model's thought signatures carry. A custom route's scope can't
-* impersonate a built-in producer, whose signatures it would then replay.
-*/
-function signatureScopeOf(route, modelId) {
-	const scope = route.signatureScope?.(modelId) ?? route.name;
-	if (scope !== route.name && RESERVED_ROUTE_NAMES.has(scope)) throw new Error(`${route.name}: signature scope "${scope}" is reserved for a built-in provider`);
-	return scope;
-}
-/**
-* Creates a provider over another Gemini-wire backend: an extension supplies
-* the transport, auth and model records; message conversion, thought
-* signatures (tagged with the route's scope, never replayed elsewhere), tool
-* names, thinking levels, usage and cost come from the same plumbing as
-* {@link google} and {@link googleVertex}.
-*
-* @param route - The backend: name, transport, auth and models.
-* @param params - Default model, capabilities and extra headers.
-*
-* @example
-* ```ts
-* import { googleCompatible } from 'zidane/providers'
-*
-* const provider = googleCompatible({
-*   name: 'my-gateway',
-*   isOAuth: false,
-*   load: async () => myGeminiTransport,
-*   auth: () => ({ apiKey: process.env.MY_GATEWAY_KEY }),
-*   resolveModel: id => myModels[id],
-* }, { defaultModel: 'gemini-3.8-flash' })
-* ```
-*/
-function googleCompatible(route, params) {
-	if (!route.name || RESERVED_ROUTE_NAMES.has(route.name)) throw new Error(`googleCompatible: route name "${route.name}" is reserved for a built-in provider`);
-	return createGoogleProvider(route, params);
-}
-/**
-* Load the {@link GoogleWireKit} from the HOST's pi-ai. An extension's
-* transport gets it through `zidane/providers` (mapped to the host's module)
-* instead of importing pi-ai itself: one pi-ai copy, the exact wire the
-* host's pi-ai speaks, and it resolves inside compiled binaries too. pi-ai's
-* bare specifiers can't be host-mapped the way `zidane` is: the mapping's
-* loader would re-import the specifier it intercepts. Loaded on first call,
-* since `@google/genai` comes with it.
-*/
-async function loadGoogleWireKit() {
-	const [shared, core] = await Promise.all([import("@earendil-works/pi-ai/api/google-shared"), import("@earendil-works/pi-ai")]);
-	return {
-		convertMessages: shared.convertMessages,
-		convertTools: shared.convertTools,
-		isThinkingPart: shared.isThinkingPart,
-		retainThoughtSignature: shared.retainThoughtSignature,
-		requiresToolCallId: shared.requiresToolCallId,
-		mapStopReasonString: shared.mapStopReasonString,
-		resolveGoogleFunctionCallingMode: shared.resolveGoogleFunctionCallingMode,
-		supportsGoogleStrictToolSampling: shared.supportsGoogleStrictToolSampling,
-		createAssistantMessageEventStream: core.createAssistantMessageEventStream,
-		collapseSystemMessages: core.collapseSystemMessages,
-		getInitialSystemMessage: core.getInitialSystemMessage,
-		getCurrentTools: core.getCurrentTools,
-		getSystemMessageText: core.getSystemMessageText,
-		calculateCost: core.calculateCost,
-		clampThinkingLevel: core.clampThinkingLevel
-	};
-}
-async function loadGeminiApi() {
-	return await import("@earendil-works/pi-ai/api/google-generative-ai");
-}
-async function loadVertexApi() {
-	return await import("@earendil-works/pi-ai/api/google-vertex");
-}
-/**
-* Creates the Google Gemini provider on the Gemini API (Google AI Studio).
-* Authenticates with `apiKey`, else `GEMINI_API_KEY`, else `GOOGLE_API_KEY`.
-*
-* @param params - API key, default model, capabilities and extra headers.
-*
-* @example
-* ```ts
-* import { createAgent } from 'zidane'
-* import { google } from 'zidane/providers/google'
-*
-* const agent = createAgent({
-*   provider: google({ apiKey: process.env.GEMINI_API_KEY }),
-* })
-* await agent.run({ prompt: 'Say hello.' })
-* ```
-*/
-function google(params) {
-	return createGoogleProvider({
-		name: "google",
-		load: loadGeminiApi,
-		isOAuth: false,
-		auth: () => {
-			const apiKey = params?.apiKey || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
-			if (!apiKey) throw new Error("No Gemini API key found. Set GEMINI_API_KEY, or add a key in the Google Gemini provider settings.");
-			return { apiKey };
-		}
-	}, params);
-}
-const VERTEX_DIR_PREFIX = "zidane-vertex-";
-const VERTEX_DIR_RE = /^zidane-vertex-[A-Za-z0-9]{6}$/;
-/** Older than any request: its process crashed or was killed before cleanup. */
-const STALE_VERTEX_DIR_MS = 36e5;
-let nextVertexSweepAt = 0;
-/**
-* Remove this user's credentials dirs that a crashed request left behind;
-* they hold a refresh token. Listing the temp dir can take hundreds of
-* milliseconds, so it runs in the background, at most once an hour.
-*/
-function sweepStaleVertexDirs() {
-	const now = Date.now();
-	if (now < nextVertexSweepAt) return;
-	nextVertexSweepAt = now + STALE_VERTEX_DIR_MS;
-	const root = tmpdir();
-	const uid = process.getuid?.();
-	const sweepOne = async (name) => {
-		const dir = join(root, name);
-		const stat = await lstat(dir);
-		if (stat.isDirectory() && (uid === void 0 || stat.uid === uid) && now - stat.mtimeMs > STALE_VERTEX_DIR_MS) await rm(dir, {
-			recursive: true,
-			force: true
-		});
-	};
-	readdir(root).then((names) => Promise.allSettled(names.filter((name) => VERTEX_DIR_RE.test(name)).map(sweepOne))).catch(() => {});
-}
-/**
-* Request auth from the stored "Sign in with Google" grant (the pinned
-* account's, else the active one), or `undefined` when none is stored.
-*
-* The access token rotates through zidane's OAuth path (cross-process locks,
-* persistence, refresh hooks, a clear "sign in again" for a revoked grant).
-* Vertex itself authenticates from an `authorized_user` credentials file
-* holding the refresh token: pi-ai's Vertex client takes no bare access
-* token. The file lives in a private temp dir for the length of the request.
-*/
-async function signedInAuth(params, callbacks) {
-	const account = params?.account;
-	const read = () => account ? readAccountOAuthCredential(GOOGLE_VERTEX_OAUTH_ID, account) : readOAuthCredentials()[GOOGLE_VERTEX_OAUTH_ID];
-	if (!read()) {
-		if (account) throw new Error(pinnedAccountMissingError("google-vertex"));
-		return;
-	}
-	await resolveOAuthApiKey({
-		provider: "google-vertex",
-		providerId: GOOGLE_VERTEX_OAUTH_ID,
-		...account ? { params: { account } } : {},
-		missingError: "No Google sign-in found for Vertex AI. Sign in with Google again.",
-		refreshError: (reason) => `Google sign-in refresh failed. Sign in with Google again. ${reason}`
-	}, callbacks);
-	const grant = read();
-	if (!grant?.refresh || !grant.clientId || !grant.clientSecret || !grant.projectId) throw new Error("This Google sign-in is missing its OAuth client or project. Sign in with Google again.");
-	const project = params?.project || grant.projectId;
-	sweepStaleVertexDirs();
-	const dir = mkdtempSync(join(tmpdir(), VERTEX_DIR_PREFIX));
-	const file = join(dir, "credentials.json");
-	try {
-		writeFileSync(file, JSON.stringify({
-			type: "authorized_user",
-			client_id: grant.clientId,
-			client_secret: grant.clientSecret,
-			refresh_token: grant.refresh,
-			quota_project_id: project
-		}), { mode: 384 });
-	} catch (err) {
-		rmSync(dir, {
-			recursive: true,
-			force: true
-		});
-		throw err;
-	}
-	return {
-		env: {
-			GOOGLE_CLOUD_PROJECT: project,
-			GOOGLE_CLOUD_LOCATION: params?.location || process.env.GOOGLE_CLOUD_LOCATION || "global",
-			GOOGLE_APPLICATION_CREDENTIALS: file
-		},
-		dispose: () => rmSync(dir, {
-			recursive: true,
-			force: true
-		})
-	};
-}
-/**
-* Credentials and settings for a Vertex AI request, read per turn so a
-* credential configured after the provider was built still applies. In
-* order: a pinned account's sign-in, a Vertex API key, the active "Sign in
-* with Google" grant, then Google Cloud credentials for the project.
-*
-* @param params - Explicit settings; environment variables fill the rest.
-* @param callbacks - Stream callbacks, for the OAuth refresh hook.
-*/
-async function resolveVertexAuth(params, callbacks) {
-	if (params?.account) return await signedInAuth(params, callbacks);
-	const apiKey = params?.apiKey || process.env.GOOGLE_CLOUD_API_KEY;
-	if (apiKey) return { apiKey };
-	const signedIn = await signedInAuth(params, callbacks);
-	if (signedIn) return signedIn;
-	const project = params?.project || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
-	if (!project) throw new Error("Vertex AI needs a Google Cloud project. Set GOOGLE_CLOUD_PROJECT, or configure it in the Google Vertex AI provider settings.");
-	const location = params?.location || process.env.GOOGLE_CLOUD_LOCATION || "global";
-	const credentialsFile = params?.credentialsFile || process.env.GOOGLE_APPLICATION_CREDENTIALS;
-	return { env: {
-		GOOGLE_CLOUD_PROJECT: project,
-		GOOGLE_CLOUD_LOCATION: location,
-		...credentialsFile ? { GOOGLE_APPLICATION_CREDENTIALS: credentialsFile } : {}
-	} };
-}
-/**
-* Creates the Google Vertex AI provider. Authenticates with a pinned
-* `account`'s Google sign-in, else a Vertex API key (`apiKey` or
-* `GOOGLE_CLOUD_API_KEY`), else the active "Sign in with Google" grant, else
-* Google Cloud credentials for `project` in `location`. See
-* {@link resolveVertexAuth}.
-*
-* @param params - Credentials, project, location, default model, capabilities and extra headers.
-*
-* @example
-* ```ts
-* import { createAgent } from 'zidane'
-* import { googleVertex } from 'zidane/providers/google'
-*
-* // After `gcloud auth application-default login`:
-* const agent = createAgent({
-*   provider: googleVertex({ project: 'my-project' }),
-* })
-* await agent.run({ prompt: 'Say hello.' })
-* ```
-*/
-function googleVertex(params) {
-	return createGoogleProvider({
-		name: "google-vertex",
-		load: loadVertexApi,
-		isOAuth: !!params?.account || !(params?.apiKey || process.env.GOOGLE_CLOUD_API_KEY),
-		auth: (callbacks) => resolveVertexAuth(params, callbacks)
-	}, params);
-}
-//#endregion
-export { GOOGLE_DEFAULT_MODEL, GOOGLE_EXTRA_MODELS, classifyGoogleError, fromGooglePiAssistantMessage, google, googleCompatible, googleVertex, loadGoogleWireKit, resolveGoogleModel, resolveVertexAuth, toGooglePiMessages };
-
-//# sourceMappingURL=google.js.map
+export { t as GOOGLE_DEFAULT_MODEL, n as GOOGLE_EXTRA_MODELS, r as classifyGoogleError, i as fromGooglePiAssistantMessage, a as google, o as googleCompatible, s as googleVertex, c as loadGoogleWireKit, l as resolveGoogleModel, u as resolveVertexAuth, d as toGooglePiMessages } from "../google-O6pRnddf.js";