zidane 8.2.1 → 8.2.3

package/dist/google-O6pRnddf.js

@@ -0,0 +1,881 @@
+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 { a as imageHttpError, o as repeatRequest, r as imageCount } from "./wire-DH77Z-rr.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/images/google.ts
+const BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+/** Gemini image models on the Gemini API. */
+const GOOGLE_IMAGE_MODELS = [
+	{
+		id: "gemini-3.1-flash-image",
+		name: "Gemini 3.1 Flash Image",
+		input: ["text", "image"]
+	},
+	{
+		id: "gemini-3-pro-image",
+		name: "Gemini 3 Pro Image",
+		input: ["text", "image"]
+	},
+	{
+		id: "gemini-3.1-flash-lite-image",
+		name: "Gemini 3.1 Flash Lite Image",
+		input: ["text", "image"]
+	},
+	{
+		id: "gemini-2.5-flash-image",
+		name: "Gemini 2.5 Flash Image",
+		input: ["text", "image"]
+	}
+];
+/**
+* Gemini image generation as a {@link ProviderImages}. Unavailable while `resolveKey` returns `undefined`.
+*
+* @param options - Key resolver and test overrides.
+* @param options.resolveKey - Returns the Gemini API key, or `undefined` when none is set. Called on every request.
+* @param options.fetch - Fetch override, for tests.
+*/
+function googleImages(options) {
+	const doFetch = options.fetch ?? fetch;
+	return {
+		defaultModel: GOOGLE_IMAGE_MODELS[0].id,
+		models: GOOGLE_IMAGE_MODELS,
+		availability: () => options.resolveKey() ? { available: true } : {
+			available: false,
+			reason: "Gemini image generation needs a Gemini API key (GEMINI_API_KEY)."
+		},
+		async generate(request, signal) {
+			const key = options.resolveKey();
+			if (!key) throw new Error("Gemini image generation needs a Gemini API key. Set GEMINI_API_KEY, or add a key in the Google Gemini provider settings.");
+			const body = {
+				contents: [{
+					role: "user",
+					parts: [{ text: request.prompt }, ...(request.references ?? []).map((ref) => ({ inlineData: {
+						mimeType: ref.mediaType,
+						data: ref.data
+					} }))]
+				}],
+				generationConfig: {
+					responseModalities: ["TEXT", "IMAGE"],
+					...request.aspectRatio ? { imageConfig: { aspectRatio: request.aspectRatio } } : {}
+				}
+			};
+			const once = async () => {
+				const res = await doFetch(`${BASE_URL}/models/${encodeURIComponent(request.model)}:generateContent`, {
+					method: "POST",
+					headers: {
+						"x-goog-api-key": key,
+						"content-type": "application/json"
+					},
+					body: JSON.stringify(body),
+					signal
+				});
+				if (!res.ok) throw await imageHttpError("Gemini", res);
+				const json = await res.json();
+				if (json.promptFeedback?.blockReason) throw new Error(`Gemini refused the prompt (${json.promptFeedback.blockReason}).`);
+				const candidate = json.candidates?.[0];
+				const parts = candidate?.content?.parts ?? [];
+				const images = parts.flatMap((part) => part.inlineData?.data ? [{
+					mediaType: part.inlineData.mimeType ?? "image/png",
+					data: part.inlineData.data
+				}] : []);
+				const text = parts.flatMap((part) => part.text ? [part.text] : []).join("\n").trim();
+				if (images.length === 0) {
+					const reason = candidate?.finishReason && candidate.finishReason !== "STOP" ? ` (${candidate.finishReason})` : "";
+					throw new Error(`Gemini returned no image${reason}${text ? `: ${text}` : "."}`);
+				}
+				return {
+					images,
+					model: request.model,
+					...text ? { text } : {}
+				};
+			};
+			return repeatRequest(imageCount(request.count), once);
+		}
+	};
+}
+//#endregion
+//#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) {
+	const resolveKey = () => params?.apiKey || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+	return {
+		...createGoogleProvider({
+			name: "google",
+			load: loadGeminiApi,
+			isOAuth: false,
+			auth: () => {
+				const apiKey = resolveKey();
+				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),
+		images: googleImages({ resolveKey })
+	};
+}
+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 as a, loadGoogleWireKit as c, toGooglePiMessages as d, GOOGLE_IMAGE_MODELS as f, fromGooglePiAssistantMessage as i, resolveGoogleModel as l, GOOGLE_EXTRA_MODELS as n, googleCompatible as o, classifyGoogleError as r, googleVertex as s, GOOGLE_DEFAULT_MODEL as t, resolveVertexAuth as u };
+
+//# sourceMappingURL=google-O6pRnddf.js.map