@warlock.js/ai-google 4.1.1

package/cjs/index.cjs

@@ -0,0 +1,767 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _google_genai = require("@google/genai");
+let _warlock_js_ai = require("@warlock.js/ai");
+let _warlock_js_logger = require("@warlock.js/logger");
+
+//#region ../../@warlock.js/ai-google/src/utils/map-finish-reason.ts
+const finishReasonMap = {
+	STOP: "stop",
+	MAX_TOKENS: "length"
+};
+/**
+* Map Gemini's `FinishReason` enum value to the normalized
+* `FinishReason` union.
+*
+* `STOP` is the natural terminal. `MAX_TOKENS` maps to `length`.
+* Everything else — `SAFETY`, `RECITATION`, `BLOCKLIST`,
+* `PROHIBITED_CONTENT`, `SPII`, `MALFORMED_FUNCTION_CALL`,
+* `UNEXPECTED_TOOL_CALL`, `LANGUAGE`, `OTHER`,
+* `FINISH_REASON_UNSPECIFIED`, `null`, or any future value — falls
+* through to `"error"`.
+*
+* Note: Gemini reports `STOP` even when the turn ended in a function
+* call (it has no `tool_use` reason). `GoogleModel` overrides the
+* mapped reason to `"tool_calls"` when the response carries function
+* calls — this map intentionally stays purely about the raw signal.
+*
+* @example
+* mapFinishReason("STOP");        // "stop"
+* mapFinishReason("MAX_TOKENS");  // "length"
+* mapFinishReason("SAFETY");      // "error"
+* mapFinishReason(undefined);     // "error"
+*/
+function mapFinishReason(raw) {
+	return finishReasonMap[raw ?? ""] ?? "error";
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-google/src/utils/to-google-contents.ts
+/**
+* Convert vendor-neutral `Message[]` into Gemini's request shape.
+*
+* Gemini specifics this function absorbs:
+*
+* 1. **No `system` role.** System messages concatenate into the
+*    separate `systemInstruction` config field.
+* 2. **Role names differ.** Neutral `assistant` → Gemini `"model"`;
+*    `user` stays `"user"`.
+* 3. **Tool results are `user` turns.** A neutral `tool` message
+*    becomes a `"user"` content with a single `functionResponse` part.
+* 4. **Tool calls are `functionCall` parts.** An assistant message
+*    with `toolCalls` becomes a `"model"` content: an optional leading
+*    `text` part followed by one `functionCall` part per call.
+*
+* @example
+* const { systemInstruction, contents } = toGoogleContents([
+*   { role: "system", content: "Be concise." },
+*   { role: "user", content: "Hi" },
+* ]);
+*/
+function toGoogleContents(messages) {
+	const systemParts = [];
+	const contents = [];
+	for (const message of messages) {
+		if (message.role === "system") {
+			systemParts.push(stringifyContent(message.content));
+			continue;
+		}
+		if (message.role === "tool") {
+			contents.push({
+				role: "user",
+				parts: [{ functionResponse: {
+					name: message.toolCallId ?? "",
+					response: toResponseObject(stringifyContent(message.content))
+				} }]
+			});
+			continue;
+		}
+		if (message.role === "assistant" && message.toolCalls && message.toolCalls.length > 0) {
+			const parts = [];
+			const text = stringifyContent(message.content);
+			if (text) parts.push({ text });
+			for (const toolCall of message.toolCalls) {
+				const thoughtSignature = toolCall.providerMetadata?.thoughtSignature;
+				parts.push({
+					...typeof thoughtSignature === "string" ? { thoughtSignature } : {},
+					functionCall: {
+						name: toolCall.name,
+						args: toolCall.input ?? {}
+					}
+				});
+			}
+			contents.push({
+				role: "model",
+				parts
+			});
+			continue;
+		}
+		if (message.role === "user" && Array.isArray(message.content)) {
+			contents.push({
+				role: "user",
+				parts: message.content.map(toGooglePart)
+			});
+			continue;
+		}
+		contents.push({
+			role: message.role === "assistant" ? "model" : "user",
+			parts: [{ text: stringifyContent(message.content) }]
+		});
+	}
+	return {
+		systemInstruction: systemParts.length > 0 ? systemParts.join("\n\n") : void 0,
+		contents
+	};
+}
+/**
+* Multipart content is only meaningful on user messages — for any
+* other role collapse a `ContentPart[]` to concatenated text. Plain
+* strings pass through unchanged.
+*/
+function stringifyContent(content) {
+	if (typeof content === "string") return content;
+	return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+/**
+* Gemini's `functionResponse.response` must be a JSON object. Tool
+* results arrive as a string (usually stringified JSON) — parse it
+* when it is a JSON object, otherwise wrap the raw string under a
+* `result` key so the model always receives a well-formed object.
+*/
+function toResponseObject(raw) {
+	const parsed = (0, _warlock_js_ai.safeJsonParse)(raw, void 0);
+	if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	return { result: raw };
+}
+/**
+* Map a resolved `ContentPart` to a Gemini `Part`. Images are sent as
+* inline base64 (`inlineData`). Gemini's `generateContent` does not
+* fetch arbitrary remote URLs (only Files API / GCS URIs via
+* `fileData`), so a neutral `{ url }` image surfaces a typed
+* `InvalidRequestError` upfront rather than a downstream Gemini fault.
+* The agent resolves attachments before this point, so nothing is
+* read or fetched here.
+*/
+function toGooglePart(part) {
+	if (part.type === "text") return { text: part.text };
+	if ("url" in part.source) throw new _warlock_js_ai.InvalidRequestError("Gemini generateContent does not fetch remote-URL images; supply base64 image bytes instead.");
+	return { inlineData: {
+		mimeType: part.source.mediaType,
+		data: part.source.base64
+	} };
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-google/src/utils/to-google-tools.ts
+/**
+* Convert vendor-neutral `ToolConfig[]` into Gemini's `tools` array —
+* a single `Tool` carrying one `functionDeclarations` entry per tool.
+*
+* The input schema is forwarded via `parametersJsonSchema` (raw JSON
+* Schema, mutually exclusive with Gemini's typed `parameters`).
+* Non-object extractions degrade to a parameterless object so
+* registration never fails.
+*
+* Returns `undefined` when there are no tools so the caller can omit
+* `config.tools` entirely.
+*
+* @example
+* const tools = toGoogleTools([weatherTool]);
+* await ai.models.generateContent({ model, contents, config: { tools } });
+*/
+function toGoogleTools(tools) {
+	if (!tools || tools.length === 0) return;
+	return [{ functionDeclarations: tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		parametersJsonSchema: toJsonSchema(tool.input)
+	})) }];
+}
+/**
+* Resolve a tool's input schema to a JSON-Schema object. Gemini wants
+* an object root for function parameters; anything else (or a failed
+* extraction) degrades to a parameterless object.
+*/
+function toJsonSchema(input) {
+	const schema = (0, _warlock_js_ai.extractJsonSchema)(input);
+	if (schema && schema.type === "object") return schema;
+	return { type: "object" };
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-google/src/utils/wrap-google-error.ts
+/**
+* Wrap any thrown value caught inside the Gemini adapter into the
+* appropriate `@warlock.js/ai` `AIError` subclass.
+*
+* **Dispatch strategy.** Gemini has no machine error `code`; the
+* signals are the HTTP `status` and the canonical status phrase Google
+* embeds in `message` (`PERMISSION_DENIED`, `RESOURCE_EXHAUSTED`,
+* `INVALID_ARGUMENT`, …). Dispatch keys on `status`, using the message
+* phrase as the tie-breaker for the two 400 sub-cases
+* (context-length vs generic) and for status-less auth/quota errors.
+*
+* `AIError` instances pass through unchanged so `catch/throw wrap(e)`
+* pipelines never double-wrap.
+*
+* @example
+* try {
+*   return await this.ai.models.generateContent(...);
+* } catch (thrown) {
+*   throw wrapGoogleError(thrown);
+* }
+*/
+function wrapGoogleError(thrown) {
+	if (thrown instanceof _warlock_js_ai.AIError) return thrown;
+	const shape = toShape(thrown);
+	const context = buildContext(shape);
+	const message = shape.message ?? (thrown instanceof Error ? thrown.message : String(thrown));
+	if (isTimeout(shape)) return new _warlock_js_ai.ProviderTimeoutError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.status === 401 || shape.status === 403 || /permission_denied|api key not valid|unauthenticated/i.test(message)) return new _warlock_js_ai.ProviderAuthError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.status === 429 || /resource_exhausted|quota/i.test(message)) return new _warlock_js_ai.ProviderRateLimitError(message, {
+		cause: thrown,
+		context
+	});
+	if (shape.status === 400) {
+		if (/token count|context length|exceeds the maximum|input is too long/i.test(message)) return new _warlock_js_ai.ContextLengthExceededError(message, {
+			cause: thrown,
+			context
+		});
+		return new _warlock_js_ai.InvalidRequestError(message, {
+			cause: thrown,
+			context
+		});
+	}
+	if (shape.status === 404 || isClientStatus(shape.status)) return new _warlock_js_ai.InvalidRequestError(message, {
+		cause: thrown,
+		context
+	});
+	return new _warlock_js_ai.ProviderError(message, {
+		cause: thrown,
+		context
+	});
+}
+/**
+* Read the raw error shape. The Gemini SDK's `ApiError` carries a
+* numeric `status`; flattened/proxied errors may carry it (or `code`)
+* loosely.
+*/
+function toShape(thrown) {
+	if (thrown instanceof _google_genai.ApiError) return {
+		status: thrown.status,
+		message: thrown.message,
+		name: thrown.name
+	};
+	if (typeof thrown === "object" && thrown !== null) {
+		const raw = thrown;
+		return {
+			status: typeof raw.status === "number" ? raw.status : void 0,
+			message: typeof raw.message === "string" ? raw.message : void 0,
+			name: typeof raw.name === "string" ? raw.name : void 0,
+			code: typeof raw.code === "string" ? raw.code : void 0
+		};
+	}
+	return {};
+}
+/**
+* Decide whether the error is a timeout. Gemini maps gateway timeouts
+* to HTTP 504 (`DEADLINE_EXCEEDED`); transport aborts surface as
+* `AbortError` / `ETIMEDOUT` / `ECONNABORTED`.
+*/
+function isTimeout(shape) {
+	if (shape.status === 504) return true;
+	if (shape.name === "AbortError" || /deadline_exceeded/i.test(shape.message ?? "")) return true;
+	return shape.code === "ETIMEDOUT" || shape.code === "ECONNABORTED";
+}
+/** True for HTTP 4xx — a client-side request problem, not a server fault. */
+function isClientStatus(status) {
+	return typeof status === "number" && status >= 400 && status < 500;
+}
+/** Attach the diagnostic fields to `error.context`. */
+function buildContext(shape) {
+	const context = {};
+	if (shape.status !== void 0) context.status = shape.status;
+	if (shape.name) context.code = shape.name;
+	return context;
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-google/src/embedder.ts
+const LOG_MODULE$1 = "ai.google";
+/**
+* Token usage is not returned by Gemini's `embedContent`, so every
+* embedding result reports a zeroed `EmbeddingUsage` (honest absence,
+* not a fabricated estimate).
+*/
+const NO_USAGE = {
+	promptTokens: 0,
+	totalTokens: 0
+};
+/**
+* Google Gemini-backed implementation of `EmbedderContract`
+* (`gemini-embedding-001`, `text-embedding-004`, …) via
+* `models.embedContent`.
+*
+* **Role.** Converts text into floating-point vectors. Standalone
+* primitive — unrelated to generateContent / tools / the agent loop.
+*
+* **Batch is native.** Gemini's `embedContent` accepts an array of
+* inputs and returns embeddings in the same order, so `embedMany` is
+* a single request (unlike the Bedrock/Titan adapter, which has to
+* loop).
+*
+* **No usage.** Gemini's embed endpoint returns no token counts;
+* `usage` is always `{ promptTokens: 0, totalTokens: 0 }`.
+*
+* **Dimensions.** When no `dimensions` override is given,
+* `this.dimensions` starts at `0` and is populated from the first
+* response's vector length, then cached. Passing `dimensions`
+* forwards Gemini's `outputDimensionality` truncation hint and sets
+* the initial value immediately.
+*
+* @example
+* const embedder = new GoogleEmbedder(ai, { name: "gemini-embedding-001" });
+* const { vector } = await embedder.embed("Hello world");
+* const { vectors } = await embedder.embedMany(["doc 1", "doc 2"]);
+*/
+var GoogleEmbedder = class {
+	constructor(ai, config, provider = "google") {
+		this.logger = _warlock_js_logger.log;
+		this.ai = ai;
+		this.name = config.name;
+		this.provider = provider;
+		this.configuredDimensions = config.dimensions;
+		this.dimensions = config.dimensions ?? 0;
+	}
+	async embed(input) {
+		return {
+			vector: (await this.request([input]))[0],
+			dimensions: this.dimensions,
+			usage: NO_USAGE
+		};
+	}
+	async embedMany(inputs) {
+		return {
+			vectors: await this.request(inputs),
+			dimensions: this.dimensions,
+			usage: NO_USAGE
+		};
+	}
+	/**
+	* Shared transport: one `embedContent` call for the whole batch,
+	* wrap provider errors, cache `dimensions` from the first vector,
+	* and return the raw vectors in input order.
+	*/
+	async request(inputs) {
+		this.logger.debug(LOG_MODULE$1, "embedder.request", "embedContent", {
+			model: this.name,
+			count: inputs.length
+		});
+		let response;
+		try {
+			response = await this.ai.models.embedContent({
+				model: this.name,
+				contents: inputs,
+				...this.configuredDimensions !== void 0 ? { config: { outputDimensionality: this.configuredDimensions } } : {}
+			});
+		} catch (thrown) {
+			const wrapped = wrapGoogleError(thrown);
+			this.logger.error(LOG_MODULE$1, "embedder.error", wrapped.message, {
+				code: wrapped.code,
+				context: wrapped.context
+			});
+			throw wrapped;
+		}
+		const vectors = (response.embeddings ?? []).map((embedding) => embedding.values ?? []);
+		if (this.dimensions === 0 && vectors[0]) this.dimensions = vectors[0].length;
+		this.logger.debug(LOG_MODULE$1, "embedder.response", "embedContent returned", {
+			count: vectors.length,
+			dimensions: this.dimensions
+		});
+		return vectors;
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/ai-google/src/known-vision-models.ts
+/**
+* Substrings identifying Gemini model ids whose family accepts image
+* input (vision).
+*
+* Every Gemini 1.5, 2.x, and 2.5 model is natively multimodal, as is
+* the legacy `gemini-pro-vision`. Only the original text-only
+* `gemini-pro` / `gemini-1.0-pro` is excluded. A substring match
+* tolerates the date/preview suffixes Google appends
+* (`gemini-2.5-flash-preview-05-20`). Override per-model via
+* `google.model({ name, vision: true | false })`.
+*/
+const VISION_CAPABLE_SUBSTRINGS = [
+	"gemini-1.5",
+	"gemini-2",
+	"gemini-exp",
+	"gemini-pro-vision",
+	"gemini-flash"
+];
+/**
+* Infer whether a Gemini model id supports vision based on the known
+* multimodal-family substrings. Unknown ids default to `false` so
+* passing an image attachment to an unsupported model surfaces a
+* clear, agent-side capability error instead of an opaque Gemini 400.
+*
+* @example
+* inferVisionCapability("gemini-2.5-flash");          // → true
+* inferVisionCapability("gemini-1.5-pro-002");        // → true
+* inferVisionCapability("gemini-1.0-pro");            // → false
+* inferVisionCapability("text-embedding-004");        // → false
+*/
+function inferVisionCapability(modelId) {
+	const normalized = modelId.toLowerCase();
+	return VISION_CAPABLE_SUBSTRINGS.some((fragment) => normalized.includes(fragment));
+}
+
+//#endregion
+//#region ../../@warlock.js/ai-google/src/model.ts
+const LOG_MODULE = "ai.google";
+/**
+* Google Gemini-backed implementation of `ModelContract`.
+*
+* **Role.** The provider-facing bridge between the vendor-neutral
+* `@warlock.js/ai` agent runtime and the `@google/genai` SDK
+* (`models.generateContent` / `generateContentStream`).
+*
+* **Responsibility.**
+* - Owns: a long-lived `GoogleGenAI` client + frozen `ModelConfig`
+*   (name, temperature, maxTokens) used as per-call defaults.
+* - Owns: translating vendor-neutral `Message[]` / `ToolConfig[]` into
+*   Gemini shapes (systemInstruction hoisting, `model` role,
+*   `functionCall` / `functionResponse` parts, inline image bytes) on
+*   the way out, and Gemini's candidate/parts response (text, function
+*   calls, finish reason, token usage) back into neutral shapes on the
+*   way in.
+* - Does NOT own: dispatching tools, looping, history, retries — those
+*   are agent concerns. The model is a per-call protocol adapter.
+*
+* Modeled as a class (see §4.2 of code-style.md — "long-lived state
+* across calls"): the `GoogleGenAI` client is reused for the SDK's
+* lifetime.
+*
+* @example
+* import { GoogleGenAI } from "@google/genai";
+* const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+* const model = new GoogleModel(ai, { name: "gemini-2.5-flash" });
+*
+* const myAgent = agent({ model, tools: [searchTool] });
+* const result = await myAgent.execute("Summarize today's news.");
+*/
+var GoogleModel = class {
+	constructor(ai, config, provider = "google") {
+		this.logger = _warlock_js_logger.log;
+		this.ai = ai;
+		this.config = config;
+		this.name = config.name;
+		this.provider = provider;
+		this.pricing = config.pricing;
+		this.capabilities = {
+			structuredOutput: config.structuredOutput ?? true,
+			vision: config.vision ?? inferVisionCapability(config.name)
+		};
+	}
+	/**
+	* Single-shot completion. Sends the full message list to
+	* `generateContent`, waits for the terminal response, and reshapes
+	* it into a vendor-neutral `ModelResponse`. Per-call `options`
+	* override the instance defaults for this call only.
+	*/
+	async complete(messages, options) {
+		this.logger.debug(LOG_MODULE, "request", "Starting generateContent call", {
+			model: this.name,
+			messageCount: messages.length,
+			streaming: false,
+			toolCount: options?.tools?.length ?? 0
+		});
+		const { systemInstruction, contents } = toGoogleContents(messages);
+		let response;
+		try {
+			response = await this.ai.models.generateContent({
+				model: this.name,
+				contents,
+				config: this.buildConfig(systemInstruction, options)
+			});
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		const toolCalls = this.extractToolCalls(response);
+		const finishReason = toolCalls ? "tool_calls" : mapFinishReason(response.candidates?.[0]?.finishReason);
+		const usage = this.extractUsage(response);
+		this.logger.debug(LOG_MODULE, "response", "generateContent call succeeded", {
+			finishReason,
+			usage
+		});
+		return {
+			content: response.text ?? "",
+			finishReason,
+			usage,
+			toolCalls
+		};
+	}
+	/**
+	* Incremental streaming completion via `generateContentStream`.
+	* Yields neutral `ModelStreamChunk`s — `delta` for text, `tool-call`
+	* per function call (Gemini emits a fully-formed call, not partial
+	* JSON), and a terminal `done` with the final finish reason + usage.
+	*/
+	async *stream(messages, options) {
+		this.logger.debug(LOG_MODULE, "request", "Starting generateContentStream call", {
+			model: this.name,
+			messageCount: messages.length,
+			streaming: true,
+			toolCount: options?.tools?.length ?? 0
+		});
+		const { systemInstruction, contents } = toGoogleContents(messages);
+		let iterable;
+		try {
+			iterable = await this.ai.models.generateContentStream({
+				model: this.name,
+				contents,
+				config: this.buildConfig(systemInstruction, options)
+			});
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		let rawFinishReason;
+		let sawToolCall = false;
+		const usage = {
+			input: 0,
+			output: 0,
+			total: 0
+		};
+		try {
+			for await (const chunk of iterable) {
+				const text = chunk.text;
+				if (text) yield {
+					type: "delta",
+					content: text
+				};
+				for (const part of chunk.candidates?.[0]?.content?.parts ?? []) {
+					const toolCall = this.partToToolCall(part);
+					if (!toolCall) continue;
+					sawToolCall = true;
+					yield {
+						type: "tool-call",
+						id: toolCall.id,
+						name: toolCall.name,
+						input: toolCall.input,
+						...toolCall.providerMetadata ? { providerMetadata: toolCall.providerMetadata } : {}
+					};
+				}
+				const candidateFinish = chunk.candidates?.[0]?.finishReason;
+				if (candidateFinish) rawFinishReason = candidateFinish;
+				if (chunk.usageMetadata) this.applyUsage(usage, chunk.usageMetadata);
+			}
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+		const finishReason = sawToolCall ? "tool_calls" : mapFinishReason(rawFinishReason);
+		this.logger.debug(LOG_MODULE, "response", "generateContentStream call succeeded", {
+			finishReason,
+			usage
+		});
+		yield {
+			type: "done",
+			finishReason,
+			usage
+		};
+	}
+	/**
+	* Assemble the `GenerateContentConfig` shared by `complete()` and
+	* `stream()`: inference params, hoisted system instruction,
+	* cancellation signal, and conditional tools + native structured
+	* output.
+	*/
+	buildConfig(systemInstruction, options) {
+		const temperature = options?.temperature ?? this.config.temperature;
+		const maxOutputTokens = options?.maxTokens ?? this.config.maxTokens;
+		return {
+			...systemInstruction ? { systemInstruction } : {},
+			...temperature !== void 0 ? { temperature } : {},
+			...maxOutputTokens !== void 0 ? { maxOutputTokens } : {},
+			...options?.signal ? { abortSignal: options.signal } : {},
+			...this.buildTools(options?.tools),
+			...this.buildStructuredOutput(options?.responseSchema)
+		};
+	}
+	/**
+	* Spread-friendly tools fragment. Empty object when no tools were
+	* supplied so the caller can unconditionally spread it.
+	*/
+	buildTools(tools) {
+		const mapped = toGoogleTools(tools);
+		return mapped ? { tools: mapped } : {};
+	}
+	/**
+	* Translate the neutral `responseSchema` into Gemini's native JSON
+	* structured output (`responseMimeType: "application/json"` +
+	* `responseJsonSchema`, which takes a raw JSON Schema directly).
+	* Emitted only when the model is `structuredOutput`-capable and the
+	* schema is an object root — otherwise the agent's soft prompt hint
+	* + client-side `validate()` carry shape.
+	*/
+	buildStructuredOutput(responseSchema) {
+		if (!responseSchema || !this.capabilities.structuredOutput) return {};
+		if (responseSchema.type !== "object" || typeof responseSchema.properties !== "object") return {};
+		return {
+			responseMimeType: "application/json",
+			responseJsonSchema: responseSchema
+		};
+	}
+	/**
+	* Reshape Gemini's function-call content parts into the neutral
+	* `ModelToolCallRequest[]`. Returns `undefined` when the model
+	* requested no functions so callers can branch on presence.
+	*
+	* Reads `candidates[0].content.parts` directly rather than the
+	* `response.functionCalls` getter: the getter discards the
+	* part-level `thoughtSignature`, and Gemini "thinking" models 400
+	* the follow-up turn if that signature is not echoed back. See
+	* `partToToolCall`.
+	*/
+	extractToolCalls(response) {
+		const toolCalls = (response.candidates?.[0]?.content?.parts ?? []).map((part) => this.partToToolCall(part)).filter((call) => call !== void 0);
+		return toolCalls.length > 0 ? toolCalls : void 0;
+	}
+	/**
+	* Map a single Gemini `Part` to a neutral `ModelToolCallRequest`,
+	* or `undefined` when the part is not a function call. The part's
+	* `thoughtSignature` (opaque, set by thinking models) is carried on
+	* `providerMetadata` so `toGoogleContents` can replay it on the
+	* assistant turn — Gemini rejects the next request without it.
+	*/
+	partToToolCall(part) {
+		if (!part.functionCall) return;
+		const call = part.functionCall;
+		return {
+			id: call.id ?? call.name ?? "",
+			name: call.name ?? "",
+			input: call.args ?? {},
+			...part.thoughtSignature ? { providerMetadata: { thoughtSignature: part.thoughtSignature } } : {}
+		};
+	}
+	/**
+	* Normalize Gemini's `usageMetadata` into the neutral `Usage` shape.
+	* Cache-read tokens are surfaced as `cachedTokens` only when
+	* non-zero. Absent usage collapses to zeros.
+	*/
+	extractUsage(response) {
+		const usage = {
+			input: 0,
+			output: 0,
+			total: 0
+		};
+		if (response.usageMetadata) this.applyUsage(usage, response.usageMetadata);
+		return usage;
+	}
+	/**
+	* Fold a Gemini `usageMetadata` block into the running neutral
+	* `Usage` accumulator. Shared by `complete()` and the streaming
+	* loop (where the final chunk carries cumulative totals).
+	*/
+	applyUsage(usage, raw) {
+		usage.input = raw.promptTokenCount ?? usage.input;
+		usage.output = raw.candidatesTokenCount ?? usage.output;
+		usage.total = raw.totalTokenCount ?? usage.input + usage.output;
+		const cached = raw.cachedContentTokenCount;
+		if (cached && cached > 0) usage.cachedTokens = cached;
+	}
+	/**
+	* Wrap a thrown provider error into the typed `AIError` hierarchy
+	* and emit the standard error log line before it propagates.
+	*/
+	logAndWrap(thrown) {
+		const wrapped = wrapGoogleError(thrown);
+		this.logger.error(LOG_MODULE, "error", wrapped.message, {
+			code: wrapped.code,
+			context: wrapped.context
+		});
+		return wrapped;
+	}
+};
+
+//#endregion
+//#region ../../@warlock.js/ai-google/src/sdk.ts
+/**
+* Google Gemini-backed implementation of `SDKAdapterContract`.
+*
+* **Role.** The package entry point for Gemini models via the
+* `@google/genai` SDK. A single `GoogleSDK` holds one live
+* `GoogleGenAI` client, shared by every `ModelContract` /
+* `EmbedderContract` it produces. Construct one SDK per
+* account/project and reuse it everywhere.
+*
+* **Responsibility.**
+* - Owns: a long-lived `GoogleGenAI` client (auth, Vertex vs Gemini
+*   API) and its lifetime. Factory for `GoogleModel` /
+*   `GoogleEmbedder` instances sharing that client.
+* - Does NOT own: anything per-call — those live in `GoogleModel` /
+*   `GoogleEmbedder` and the agent runtime.
+*
+* Modeled as a class (see §4.2 of code-style.md — "long-lived state
+* across many calls"), fronted by FP usage like the other adapters.
+*
+* @example
+* const google = new GoogleSDK({ apiKey: process.env.GEMINI_API_KEY! });
+* const model = google.model({ name: "gemini-2.5-flash", temperature: 0.7 });
+* const embedder = google.embedder({ name: "gemini-embedding-001" });
+*/
+var GoogleSDK = class {
+	constructor(config) {
+		const { provider, pricing, ...clientOptions } = config;
+		this.ai = new _google_genai.GoogleGenAI(clientOptions);
+		this.provider = provider ?? "google";
+		this.pricing = pricing;
+	}
+	/**
+	* Build a `GoogleModel` bound to this SDK's client. Each call
+	* returns a fresh instance; all instances share the underlying
+	* `GoogleGenAI` client. The SDK's `provider` label is forwarded.
+	*
+	* Pricing resolution: per-model `config.pricing` wins; otherwise the
+	* SDK-level registry entry keyed by `config.name`; otherwise
+	* `undefined` (no cost computed).
+	*/
+	model(config) {
+		const resolvedPricing = config.pricing ?? this.pricing?.[config.name];
+		const resolvedConfig = resolvedPricing === config.pricing ? config : {
+			...config,
+			pricing: resolvedPricing
+		};
+		return new GoogleModel(this.ai, resolvedConfig, this.provider);
+	}
+	/**
+	* Rough token-count estimate. Uses the character-heuristic
+	* (`approximateTokenCount`) from the core package — Gemini's
+	* `countTokens` is a network round-trip; `count()` is intentionally
+	* offline. Good for budgeting/quota guards, not billing.
+	*/
+	async count(text, _model) {
+		return (0, _warlock_js_ai.approximateTokenCount)(text);
+	}
+	/**
+	* Build a `GoogleEmbedder` bound to this SDK's client.
+	*
+	* @example
+	* const embedder = google.embedder({ name: "gemini-embedding-001" });
+	* const { vector } = await embedder.embed("Hello world");
+	*/
+	embedder(config) {
+		return new GoogleEmbedder(this.ai, config, this.provider);
+	}
+};
+
+//#endregion
+exports.GoogleSDK = GoogleSDK;
+//# sourceMappingURL=index.cjs.map