agentfootprint 9.12.0 → 9.13.0

package/dist/esm/adapters/llm/createProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"createProvider.js","sourceRoot":"","sources":["../../../../src/adapters/llm/createProvider.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"createProvider.js","sourceRoot":"","sources":["../../../../src/adapters/llm/createProvider.ts"],"names":[],"mappings":"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"}

package/dist/esm/adapters/llm/googleGenAI.d.ts

@@ -0,0 +1,67 @@
+/**
+ * googleGenAI — the one place a `GoogleGenAI` client gets built (9.13.0).
+ *
+ * Two adapters reach for the same SDK client — `gemini()` (the LLM provider)
+ * and `geminiEmbedder()` — and they need the SAME two doors, the SAME refusals
+ * and the SAME `_client` seam. Duplicating that is how the two drift: one grows
+ * a fix, the other keeps the bug, and the difference is invisible until a
+ * consumer hits the door that was not fixed.
+ *
+ * So the connection lives here and the adapters own only their own calls.
+ * Nothing in this file knows what a model, a message or a vector is.
+ *
+ * ─── The two doors ──────────────────────────────────────────────────
+ *
+ *   • **Vertex** — `{ project, location }` → `new GoogleGenAI({ vertexai: true,
+ *     project, location, googleAuthOptions })`. Credentials come from
+ *     Application Default Credentials: `GOOGLE_APPLICATION_CREDENTIALS`, the
+ *     gcloud user credentials, or the metadata server on GCE / Cloud Run. There
+ *     is no API key on this path.
+ *   • **Gemini API (AI Studio)** — `{ apiKey }` → `new GoogleGenAI({ apiKey })`.
+ *     One key, no cloud project.
+ *
+ * ─── The API version, which is not what you would guess ─────────────
+ *
+ * The SDK's DEFAULT API version is `v1beta1` on Vertex and `v1beta` on the
+ * Gemini API — verified against @google/genai 2.16.0 and pinned by
+ * `test/adapters/google/google-surface-pin.test.ts`. It is not `v1`. Callers
+ * who need a specific version pass `apiVersion`; callers who do not at least
+ * find the truth stated instead of assuming a GA path.
+ */
+/** The connection half of a Google adapter's options — the same on both. */
+export interface GoogleGenAIConnectionOptions {
+    /** Google Cloud project id — the VERTEX door. Env fallback (read by the SDK):
+     *  `GOOGLE_CLOUD_PROJECT`. */
+    readonly project?: string;
+    /** Vertex location, e.g. `'us-central1'` or `'global'` (the SDK's default).
+     *  Env fallback: `GOOGLE_CLOUD_LOCATION`. */
+    readonly location?: string;
+    /** API key — the GEMINI API door. Env fallbacks: `GEMINI_API_KEY`, then
+     *  `GOOGLE_API_KEY`. */
+    readonly apiKey?: string;
+    /** Force the door instead of inferring it: `true` = Vertex, `false` = the
+     *  Gemini API. */
+    readonly vertexai?: boolean;
+    /** Pin the API version. Unset means the SDK's default — `v1beta1` on Vertex,
+     *  `v1beta` on the Gemini API. */
+    readonly apiVersion?: string;
+    /** `GoogleAuthOptions` for the Vertex door — a key file, scopes, or an
+     *  `AuthClient` you built (workload identity federation, impersonation). */
+    readonly googleAuthOptions?: Record<string, unknown>;
+}
+/**
+ * Build (or accept) a `GoogleGenAI` client.
+ *
+ * `injected` is the `_client` test seam: a structural double exposing only the
+ * namespace members the calling adapter uses. When it is present the SDK is
+ * never required, no environment is read and no refusal fires — a test drives
+ * the adapter's translation with no Google anywhere near it.
+ *
+ * @param factory  the public name to put in refusals — `'gemini'`,
+ *                 `'geminiEmbedder'`. A message that names the wrong factory
+ *                 sends the reader to the wrong line of their own code.
+ * @throws when neither a project nor an API key is resolvable; when
+ *         `vertexai: true` is asked for without a project; and when
+ *         `@google/genai` is not installed.
+ */
+export declare function resolveGoogleGenAIClient<T>(options: GoogleGenAIConnectionOptions, factory: string, injected?: T): T;

package/dist/esm/adapters/llm/googleGenAI.js

@@ -0,0 +1,105 @@
+/**
+ * googleGenAI — the one place a `GoogleGenAI` client gets built (9.13.0).
+ *
+ * Two adapters reach for the same SDK client — `gemini()` (the LLM provider)
+ * and `geminiEmbedder()` — and they need the SAME two doors, the SAME refusals
+ * and the SAME `_client` seam. Duplicating that is how the two drift: one grows
+ * a fix, the other keeps the bug, and the difference is invisible until a
+ * consumer hits the door that was not fixed.
+ *
+ * So the connection lives here and the adapters own only their own calls.
+ * Nothing in this file knows what a model, a message or a vector is.
+ *
+ * ─── The two doors ──────────────────────────────────────────────────
+ *
+ *   • **Vertex** — `{ project, location }` → `new GoogleGenAI({ vertexai: true,
+ *     project, location, googleAuthOptions })`. Credentials come from
+ *     Application Default Credentials: `GOOGLE_APPLICATION_CREDENTIALS`, the
+ *     gcloud user credentials, or the metadata server on GCE / Cloud Run. There
+ *     is no API key on this path.
+ *   • **Gemini API (AI Studio)** — `{ apiKey }` → `new GoogleGenAI({ apiKey })`.
+ *     One key, no cloud project.
+ *
+ * ─── The API version, which is not what you would guess ─────────────
+ *
+ * The SDK's DEFAULT API version is `v1beta1` on Vertex and `v1beta` on the
+ * Gemini API — verified against @google/genai 2.16.0 and pinned by
+ * `test/adapters/google/google-surface-pin.test.ts`. It is not `v1`. Callers
+ * who need a specific version pass `apiVersion`; callers who do not at least
+ * find the truth stated instead of assuming a GA path.
+ */
+import { lazyRequire } from '../../lib/lazyRequire.js';
+/**
+ * Build (or accept) a `GoogleGenAI` client.
+ *
+ * `injected` is the `_client` test seam: a structural double exposing only the
+ * namespace members the calling adapter uses. When it is present the SDK is
+ * never required, no environment is read and no refusal fires — a test drives
+ * the adapter's translation with no Google anywhere near it.
+ *
+ * @param factory  the public name to put in refusals — `'gemini'`,
+ *                 `'geminiEmbedder'`. A message that names the wrong factory
+ *                 sends the reader to the wrong line of their own code.
+ * @throws when neither a project nor an API key is resolvable; when
+ *         `vertexai: true` is asked for without a project; and when
+ *         `@google/genai` is not installed.
+ */
+export function resolveGoogleGenAIClient(options, factory, injected) {
+    if (injected)
+        return injected;
+    const env = (typeof process !== 'undefined' ? process.env : {});
+    // Read HERE only to decide whether there is enough configuration to build
+    // anything at all. The values are never copied into the constructor, so the
+    // SDK stays the single resolver of its own environment variables — one place
+    // that answers "where did my project come from", not two that can disagree.
+    // An EMPTY variable is not a setting. `GOOGLE_CLOUD_PROJECT=` in a shell or a
+    // CI matrix is how a project comes to be "present" and unusable — the guards
+    // below would pass and the SDK would fail on the first call instead.
+    const set = (value) => value !== undefined && value.trim().length > 0 ? value : undefined;
+    const project = set(options.project) ?? set(env.GOOGLE_CLOUD_PROJECT);
+    const apiKey = set(options.apiKey) ?? set(env.GEMINI_API_KEY) ?? set(env.GOOGLE_API_KEY);
+    const vertexai = options.vertexai ?? (project !== undefined ? true : undefined);
+    if (vertexai !== false && project === undefined && apiKey === undefined) {
+        throw new Error(`${factory}: no Google project and no API key — this factory cannot tell which service ` +
+            'you meant, and the SDK would warn on stderr, construct anyway, and fail on the first ' +
+            'call with something that reads like a network problem.\n' +
+            `  Vertex:      ${factory}({ project: "my-project", location: "us-central1" }) — or set ` +
+            'GOOGLE_CLOUD_PROJECT; credentials come from Application Default Credentials.\n' +
+            `  Gemini API:  ${factory}({ apiKey: process.env.GEMINI_API_KEY }) — or set ` +
+            'GEMINI_API_KEY.\n' +
+            `  Tests:       ${factory}({ _client }) with a { models: { … } } double — no SDK, no ` +
+            'network, no credentials.');
+    }
+    if (vertexai === true && project === undefined) {
+        throw new Error(`${factory}: \`vertexai: true\` selects Vertex, which is addressed by PROJECT and not by ` +
+            'key. Pass `{ project }` (or set GOOGLE_CLOUD_PROJECT), or drop `vertexai` and pass ' +
+            '`{ apiKey }` to use the Gemini API instead.');
+    }
+    let GoogleGenAI;
+    try {
+        const mod = lazyRequire('@google/genai');
+        GoogleGenAI = (mod.GoogleGenAI ?? mod.default?.GoogleGenAI);
+    }
+    catch {
+        throw new Error(`${factory} requires the \`@google/genai\` package.\n` +
+            '  Install:  npm install @google/genai\n' +
+            '  Or pass `_client` for test injection.');
+    }
+    if (!GoogleGenAI) {
+        throw new Error(`${factory}: \`@google/genai\` is installed but exports no \`GoogleGenAI\`. These adapters ` +
+            'are built against @google/genai 2.x — update the package.');
+    }
+    // Only what was ASKED for goes on the wire; everything omitted is left to the
+    // SDK's own environment resolution.
+    return new GoogleGenAI({
+        ...(vertexai !== undefined && { vertexai }),
+        ...(options.project !== undefined && { project: options.project }),
+        ...(options.location !== undefined && { location: options.location }),
+        ...(options.apiKey !== undefined && { apiKey: options.apiKey }),
+        ...(options.apiVersion !== undefined && { apiVersion: options.apiVersion }),
+        ...(options.googleAuthOptions !== undefined && {
+            googleAuthOptions: options.googleAuthOptions,
+        }),
+    });
+}
+//# sourceMappingURL=googleGenAI.js.map

package/dist/esm/adapters/llm/googleGenAI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"googleGenAI.js","sourceRoot":"","sources":["../../../../src/adapters/llm/googleGenAI.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAkCvD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,wBAAwB,CACtC,OAAqC,EACrC,OAAe,EACf,QAAY;IAEZ,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAE9B,MAAM,GAAG,GAAG,CAAC,OAAO,OAAO,KAAK,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAG7D,CAAC;IACF,0EAA0E;IAC1E,4EAA4E;IAC5E,6EAA6E;IAC7E,4EAA4E;IAC5E,8EAA8E;IAC9E,6EAA6E;IAC7E,qEAAqE;IACrE,MAAM,GAAG,GAAG,CAAC,KAAyB,EAAsB,EAAE,CAC5D,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACrE,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,GAAG,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;IACtE,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IACzF,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAEhF,IAAI,QAAQ,KAAK,KAAK,IAAI,OAAO,KAAK,SAAS,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACxE,MAAM,IAAI,KAAK,CACb,GAAG,OAAO,8EAA8E;YACtF,uFAAuF;YACvF,0DAA0D;YAC1D,kBAAkB,OAAO,gEAAgE;YACzF,gFAAgF;YAChF,kBAAkB,OAAO,oDAAoD;YAC7E,mBAAmB;YACnB,kBAAkB,OAAO,6DAA6D;YACtF,0BAA0B,CAC7B,CAAC;IACJ,CAAC;IACD,IAAI,QAAQ,KAAK,IAAI,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC/C,MAAM,IAAI,KAAK,CACb,GAAG,OAAO,gFAAgF;YACxF,qFAAqF;YACrF,6CAA6C,CAChD,CAAC;IACJ,CAAC;IAED,IAAI,WAAkE,CAAC;IACvE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,WAAW,CACrB,eAAe,CAChB,CAAC;QACF,WAAW,GAAG,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,OAAO,EAAE,WAAW,CAE7C,CAAC;IAChB,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,KAAK,CACb,GAAG,OAAO,4CAA4C;YACpD,yCAAyC;YACzC,yCAAyC,CAC5C,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,GAAG,OAAO,kFAAkF;YAC1F,2DAA2D,CAC9D,CAAC;IACJ,CAAC;IAED,8EAA8E;IAC9E,oCAAoC;IACpC,OAAO,IAAI,WAAW,CAAC;QACrB,GAAG,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,QAAQ,EAAE,CAAC;QAC3C,GAAG,CAAC,OAAO,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC;QAClE,GAAG,CAAC,OAAO,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC;QACrE,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;QAC/D,GAAG,CAAC,OAAO,CAAC,UAAU,KAAK,SAAS,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC;QAC3E,GAAG,CAAC,OAAO,CAAC,iBAAiB,KAAK,SAAS,IAAI;YAC7C,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;SAC7C,CAAC;KACH,CAAC,CAAC;AACL,CAAC"}

package/dist/esm/embedders/index.d.ts

@@ -12,12 +12,17 @@
  *                       v3 (the model id picks the body shape); credentials
  *                       come from the AWS chain, so no key option at all.
  *                       peer dep: @aws-sdk/client-bedrock-runtime.
+ *   geminiEmbedder()  — hosted on Google; Vertex (project + Application
+ *                       Default Credentials) or the Gemini API (one key), the
+ *                       same two doors as `gemini()`. Matryoshka sizes, real
+ *                       task types, and it REFUSES a vector the service admits
+ *                       it clipped. peer dep: @google/genai.
  *   localEmbedder()   — on-device sentence-transformer; no key; offline after a
  *                       one-time model fetch. peer dep: @huggingface/transformers.
  *   staticEmbedder()  — pure-JS Model2Vec static vectors; no key, no network
  *                       (weights bundled). peer dep: @yarflam/potion-base-8m.
  *
- * All four satisfy the same `Embedder` shape, so they drop into
+ * All five satisfy the same `Embedder` shape, so they drop into
  * `toolChoiceRecorder({ embedder })` / `semanticPipeline({ embedder })` etc.
  * unchanged. Dimensions differ per model — never mix two in one store.
  *
@@ -43,6 +48,7 @@
  */
 export type { Embedder } from '../memory/embedding/types.js';
 import type { Embedder } from '../memory/embedding/types.js';
+import { type GoogleGenAIConnectionOptions } from '../adapters/llm/googleGenAI.js';
 export interface OpenAIEmbedderOptions {
     /** Default: process.env.OPENAI_API_KEY. */
     readonly apiKey?: string;
@@ -272,6 +278,187 @@ export interface BedrockEmbedderOptions {
  * ```
  */
 export declare function bedrockEmbedder(options?: BedrockEmbedderOptions): Embedder;
+/**
+ * The slice of `@google/genai` {@link geminiEmbedder} uses — one method.
+ *
+ * Structural, so the real `GoogleGenAI`, a client shared with `gemini()`, or a
+ * `{ models: { embedContent } }` double all satisfy it without this package
+ * taking a hard type dependency on the optional peer. The double is what the
+ * Google pin injects.
+ */
+export interface GeminiEmbedClientLike {
+    readonly models: {
+        embedContent(params: GeminiEmbedParams): Promise<GeminiEmbedResponse>;
+    };
+}
+/** `EmbedContentParameters`, narrowed to what this adapter sends. */
+export interface GeminiEmbedParams {
+    readonly model: string;
+    readonly contents: readonly string[];
+    readonly config?: {
+        readonly taskType?: string;
+        readonly outputDimensionality?: number;
+        readonly abortSignal?: AbortSignal;
+    };
+}
+/** `EmbedContentResponse`, narrowed to what this adapter reads. */
+export interface GeminiEmbedResponse {
+    readonly embeddings?: readonly {
+        readonly values?: readonly number[];
+        /**
+         * Present on Vertex. `truncated: true` is the service TELLING us it clipped
+         * the input — the one signal that turns the silent half of
+         * {@link Embedder.maxInputChars} into something an adapter can act on.
+         */
+        readonly statistics?: {
+            readonly truncated?: boolean;
+            readonly tokenCount?: number;
+        };
+    }[];
+}
+/**
+ * Gemini's `task_type` — a real parameter, not a hint.
+ *
+ * `RETRIEVAL_QUERY` and `RETRIEVAL_DOCUMENT` embed a question and a passage
+ * into deliberately different projections that are MEANT to be compared with
+ * each other, so using one value for both halves is a measurable loss of
+ * retrieval quality. The rest are separate objectives; mixing them in one store
+ * is mixing spaces.
+ */
+export type GeminiEmbeddingTaskType = 'RETRIEVAL_QUERY' | 'RETRIEVAL_DOCUMENT' | 'SEMANTIC_SIMILARITY' | 'CLASSIFICATION' | 'CLUSTERING' | 'CODE_RETRIEVAL_QUERY' | 'QUESTION_ANSWERING' | 'FACT_VERIFICATION';
+/** What this adapter does when the service says it clipped the input. */
+export type GeminiTruncationPolicy = 'refuse' | 'allow';
+export interface GeminiEmbedderOptions extends GoogleGenAIConnectionOptions {
+    /**
+     * Embedding model id. Default `'gemini-embedding-001'`.
+     *
+     * Two are known by name (see {@link GEMINI_EMBEDDING_MODELS}); anything else
+     * is a model this library has never met, so pass `dimensions` with it — its
+     * vector length is not something this can know, and a wrong `.dimensions`
+     * corrupts a vector store in silence.
+     */
+    readonly model?: string;
+    /**
+     * Vector length to request (`outputDimensionality`).
+     *
+     * Both known models are Matryoshka models: they emit 3072 numbers and can be
+     * asked for fewer, and the shorter vector is a genuinely usable embedding
+     * rather than a slice of a longer one. The value is SENT to the model AND
+     * reported as `.dimensions`, so the two can never disagree. Google recommends
+     * 768, 1536 or 3072; any length up to the model's native size is accepted.
+     *
+     * Required for a model outside {@link GEMINI_EMBEDDING_MODELS}.
+     *
+     * Note for stores that rank by DOT PRODUCT or euclidean distance: Google's
+     * shortened vectors are not re-normalised, and Google recommends normalising
+     * them yourself. Nothing in this library needs it — `cosineSimilarity`
+     * divides by both magnitudes — so this adapter returns the model's numbers
+     * unchanged rather than quietly rescaling what you store.
+     */
+    readonly dimensions?: number;
+    /**
+     * Pin `task_type` instead of deriving it from the call.
+     *
+     * Unset — the default — `embed()` sends `RETRIEVAL_QUERY` and `embedBatch()`
+     * sends `RETRIEVAL_DOCUMENT`, because that is what this library's own two
+     * call sites are: retrieval embeds ONE question (`loadRelevant`), indexing
+     * embeds MANY passages (`indexDocuments`, `embedMessages`). Pin it when your
+     * own code uses the two calls differently, or when the objective is
+     * classification or clustering rather than search.
+     *
+     * Refused by name on a model that does not take the parameter.
+     */
+    readonly taskType?: GeminiEmbeddingTaskType;
+    /**
+     * What to do when the service reports it CLIPPED the input. Default
+     * `'refuse'`.
+     *
+     * Over-long input is not rejected by Gemini — it is silently truncated, and a
+     * full-looking vector comes back for the opening of the passage. An indexer
+     * then stores the whole chunk as the passage and the clipped vector as its
+     * index, so retrieval cannot find text that is visibly present in the passage
+     * it later serves. Nothing throws, nothing scores zero; the corpus is quietly,
+     * partially indexed.
+     *
+     * `.maxInputChars` exists to stop that BEFORE the call, and it is an
+     * assumption (see {@link CHARS_PER_TOKEN}) — dense text tokenises tighter.
+     * `statistics.truncated` is the service saying it happened anyway, and this
+     * adapter is the only thing that sees it. `'refuse'` turns it into an error
+     * naming the fix; `'allow'` returns the clipped vector, which is what every
+     * library that does not look at the field already does.
+     *
+     * Detection depends on the service RETURNING `statistics` — Vertex does. When
+     * it is absent this adapter cannot tell, and says so here rather than
+     * implying a guarantee.
+     */
+    readonly onTruncation?: GeminiTruncationPolicy;
+    /**
+     * The longest input this model reads whole, in CHARACTERS
+     * ({@link Embedder.maxInputChars}). Declared for every known model from its
+     * documented token window; this option is how a model this library does not
+     * know states its own. An explicit value always wins.
+     */
+    readonly maxInputChars?: number;
+    /** @internal Test injection — skips the SDK require entirely. */
+    readonly _client?: GeminiEmbedClientLike;
+}
+/**
+ * Google's hosted embeddings, through `models.embedContent` — on Vertex or on
+ * the Gemini API.
+ *
+ * The door is chosen exactly as `gemini()` chooses it: `{ project, location }`
+ * is Vertex with Application Default Credentials, `{ apiKey }` is the Gemini
+ * API, and neither is guessed. One `GoogleGenAI` client serves both this and
+ * the LLM provider, so an app that talks to both can build the client once and
+ * pass it as `_client`.
+ *
+ * ── Why the id carries the DIMENSION COUNT ───────────────────────────────
+ * `'gemini:<model>:<dims>'`, for the reason `bedrockEmbedder` gives at length:
+ * `MemoryEntry.embeddingModel` stores the id ALONE and it is the only thing
+ * `SearchOptions.embedderId` filters on. One model id at 768 and the same model
+ * id at 3072 are different embedding spaces, so an id without the size cannot
+ * tell them apart — and neither can the size alone, since both known models are
+ * 3072 natively.
+ *
+ * The `taskType` is deliberately NOT in the id, matching `bedrockEmbedder`'s
+ * treatment of Cohere's `input_type`: the default query/document pair is ONE
+ * space by construction (the two projections exist to be compared with each
+ * other), and a pinned value pins both call sites at once, so the store stays
+ * self-consistent either way.
+ *
+ * ── The input ceiling, and the service telling on itself (9.1.0) ─────────
+ * `.maxInputChars` is per MODEL, from its documented token window at the stated
+ * {@link CHARS_PER_TOKEN} assumption: **8,000** for `gemini-embedding-001`
+ * (2,048 tokens) and **32,000** for `gemini-embedding-2` (8,192). A quarter of
+ * the newer model's window is not a rounding difference — it is the whole
+ * reason the ceiling is per-model. Past the ceiling Gemini CLIPS rather than
+ * refuses, so `onTruncation` decides what happens when the response admits it.
+ *
+ * @throws if `model` is unknown and `dimensions` was not supplied; if
+ *         `dimensions` exceeds what the model can produce; if `taskType` is set
+ *         on a model that takes none; if neither a project nor an API key is
+ *         resolvable; or if `@google/genai` is not installed and no `_client`
+ *         was passed.
+ *
+ * @example
+ * ```ts
+ * import { geminiEmbedder } from 'agentfootprint/providers';
+ * import { sqliteVectorStore } from 'agentfootprint/memory';
+ * import { indexFolder } from 'agentfootprint/rag';
+ *
+ * const embedder = geminiEmbedder({ project: 'my-project', dimensions: 768 });
+ * await indexFolder('./docs', { to: sqliteVectorStore({ file: './corpus.db' }), embedder });
+ * ```
+ *
+ * @example  The Gemini API door, and a store that must never hold a clipped vector
+ * ```ts
+ * const embedder = geminiEmbedder({
+ *   apiKey: process.env.GEMINI_API_KEY,
+ *   onTruncation: 'refuse', // the default — stated here because it is the point
+ * });
+ * ```
+ */
+export declare function geminiEmbedder(options?: GeminiEmbedderOptions): Embedder;
 /**
  * The slice of `@huggingface/transformers` {@link localEmbedder} uses.
  *

package/dist/esm/embedders/index.js

@@ -1,4 +1,5 @@
 import { lazyRequire } from '../lib/lazyRequire.js';
+import { resolveGoogleGenAIClient, } from '../adapters/llm/googleGenAI.js';
 /**
  * Native output size of every OpenAI embedding model, so `.dimensions` reports
  * the truth instead of one hard-coded guess.
@@ -543,6 +544,236 @@ function describeShape(value) {
     }
     return typeof value;
 }
+/**
+ * The Gemini embedding models this library knows by name.
+ *
+ * **`gemini-embedding-001`** — text only, 3072 dimensions, a **2,048-token**
+ * input window, and the full `task_type` vocabulary. It is the default because
+ * this library's two call sites are a query and a passage, and the query /
+ * document task types are exactly that distinction.
+ *
+ * **`gemini-embedding-2`** — natively multimodal, 3072 dimensions, an
+ * **8,192-token** text window, and **no `task_type` parameter at all**: Google
+ * replaced it with task instructions written into the prompt. That difference
+ * is why the field is a per-model fact here rather than a constant — asked for
+ * on the model that does not take it, `task_type` is a request field the
+ * service will reject, and this adapter refuses first with the reason.
+ *
+ * A model outside this table has a length this library cannot know and must
+ * state its own — the same rule `openaiEmbedder` and `bedrockEmbedder` apply,
+ * for the same reason.
+ */
+const GEMINI_EMBEDDING_MODELS = {
+    'gemini-embedding-001': { dimensions: 3072, maxInputTokens: 2048, supportsTaskType: true },
+    'gemini-embedding-2': { dimensions: 3072, maxInputTokens: 8192, supportsTaskType: false },
+};
+/**
+ * How many texts Gemini embeds in ONE `embedContent` call: **one**.
+ *
+ * Not a conservative choice — the documented limit. `gemini-embedding-001`
+ * accepts exactly one input text per request, and libraries that assumed
+ * otherwise (batching 96 or 250 instances the way an OpenAI or Titan client
+ * would) send an oversized request that the service rejects on every batch
+ * bigger than a single text. `embedBatch` is therefore N sequential calls, and
+ * says so rather than looking like a batch that is secretly a loop.
+ */
+const GEMINI_MAX_TEXTS_PER_CALL = 1;
+/**
+ * Google's hosted embeddings, through `models.embedContent` — on Vertex or on
+ * the Gemini API.
+ *
+ * The door is chosen exactly as `gemini()` chooses it: `{ project, location }`
+ * is Vertex with Application Default Credentials, `{ apiKey }` is the Gemini
+ * API, and neither is guessed. One `GoogleGenAI` client serves both this and
+ * the LLM provider, so an app that talks to both can build the client once and
+ * pass it as `_client`.
+ *
+ * ── Why the id carries the DIMENSION COUNT ───────────────────────────────
+ * `'gemini:<model>:<dims>'`, for the reason `bedrockEmbedder` gives at length:
+ * `MemoryEntry.embeddingModel` stores the id ALONE and it is the only thing
+ * `SearchOptions.embedderId` filters on. One model id at 768 and the same model
+ * id at 3072 are different embedding spaces, so an id without the size cannot
+ * tell them apart — and neither can the size alone, since both known models are
+ * 3072 natively.
+ *
+ * The `taskType` is deliberately NOT in the id, matching `bedrockEmbedder`'s
+ * treatment of Cohere's `input_type`: the default query/document pair is ONE
+ * space by construction (the two projections exist to be compared with each
+ * other), and a pinned value pins both call sites at once, so the store stays
+ * self-consistent either way.
+ *
+ * ── The input ceiling, and the service telling on itself (9.1.0) ─────────
+ * `.maxInputChars` is per MODEL, from its documented token window at the stated
+ * {@link CHARS_PER_TOKEN} assumption: **8,000** for `gemini-embedding-001`
+ * (2,048 tokens) and **32,000** for `gemini-embedding-2` (8,192). A quarter of
+ * the newer model's window is not a rounding difference — it is the whole
+ * reason the ceiling is per-model. Past the ceiling Gemini CLIPS rather than
+ * refuses, so `onTruncation` decides what happens when the response admits it.
+ *
+ * @throws if `model` is unknown and `dimensions` was not supplied; if
+ *         `dimensions` exceeds what the model can produce; if `taskType` is set
+ *         on a model that takes none; if neither a project nor an API key is
+ *         resolvable; or if `@google/genai` is not installed and no `_client`
+ *         was passed.
+ *
+ * @example
+ * ```ts
+ * import { geminiEmbedder } from 'agentfootprint/providers';
+ * import { sqliteVectorStore } from 'agentfootprint/memory';
+ * import { indexFolder } from 'agentfootprint/rag';
+ *
+ * const embedder = geminiEmbedder({ project: 'my-project', dimensions: 768 });
+ * await indexFolder('./docs', { to: sqliteVectorStore({ file: './corpus.db' }), embedder });
+ * ```
+ *
+ * @example  The Gemini API door, and a store that must never hold a clipped vector
+ * ```ts
+ * const embedder = geminiEmbedder({
+ *   apiKey: process.env.GEMINI_API_KEY,
+ *   onTruncation: 'refuse', // the default — stated here because it is the point
+ * });
+ * ```
+ */
+export function geminiEmbedder(options = {}) {
+    const model = options.model ?? 'gemini-embedding-001';
+    const facts = GEMINI_EMBEDDING_MODELS[model];
+    const requested = options.dimensions;
+    const dimensions = requested ?? facts?.dimensions;
+    if (dimensions === undefined) {
+        throw new Error(`geminiEmbedder: unknown model '${model}' — its vector length is not something this ` +
+            `library can know, and reporting a wrong .dimensions silently corrupts a vector store. ` +
+            `Pass { dimensions } with the length that model returns.`);
+    }
+    if (requested !== undefined && (!Number.isInteger(requested) || requested < 1)) {
+        throw new Error(`geminiEmbedder: \`dimensions\` must be a positive whole number — received ` +
+            `${String(requested)}.`);
+    }
+    if (requested !== undefined && facts !== undefined && requested > facts.dimensions) {
+        throw new Error(`geminiEmbedder: '${model}' produces at most ${facts.dimensions} dimensions — received ` +
+            `${String(requested)}. Asking for more would be reported as .dimensions and never be ` +
+            `the length that comes back.`);
+    }
+    if (options.taskType !== undefined && facts !== undefined && !facts.supportsTaskType) {
+        throw new Error(`geminiEmbedder: '${model}' takes no \`task_type\` — Google replaced the parameter with ` +
+            `task instructions written into the text itself on this model. Drop \`taskType\` and ` +
+            `prefix your input (for example "task: search result | query: …"), or use ` +
+            `'gemini-embedding-001', which does take it.`);
+    }
+    const sendTaskType = facts?.supportsTaskType ?? true;
+    const maxInputChars = options.maxInputChars ?? charsFor(facts?.maxInputTokens);
+    const onTruncation = options.onTruncation ?? 'refuse';
+    let client;
+    const connect = () => {
+        client ??= resolveGoogleGenAIClient(options, 'geminiEmbedder', options._client);
+        return client;
+    };
+    /**
+     * ONE `embedContent` round-trip, carrying however many texts the model takes
+     * ({@link GEMINI_MAX_TEXTS_PER_CALL}) — one, today. Written as a slice rather
+     * than a single string so that the day Google raises the limit is a
+     * one-number change here and nowhere else.
+     */
+    async function embedChunk(texts, taskType, signal) {
+        const config = {
+            ...(sendTaskType && { taskType: options.taskType ?? taskType }),
+            ...(requested !== undefined && { outputDimensionality: requested }),
+            ...(signal && { abortSignal: signal }),
+        };
+        const response = await connect().models.embedContent({
+            model,
+            contents: [...texts],
+            ...(Object.keys(config).length > 0 && { config }),
+        });
+        return readGeminiEmbeddings(response, model, dimensions, texts, onTruncation);
+    }
+    /** The calls one batch becomes, in order, one chunk at a time. */
+    async function embedAll(texts, taskType, signal) {
+        const out = [];
+        for (let i = 0; i < texts.length; i += GEMINI_MAX_TEXTS_PER_CALL) {
+            signal?.throwIfAborted();
+            out.push(...(await embedChunk(texts.slice(i, i + GEMINI_MAX_TEXTS_PER_CALL), taskType, signal)));
+        }
+        return out;
+    }
+    return {
+        dimensions,
+        // The embedding SPACE, size included — see the note above.
+        id: `gemini:${model}:${dimensions}`,
+        // Spread, so a model this factory does not know declares NO ceiling rather
+        // than one it cannot stand behind.
+        ...(maxInputChars !== undefined && { maxInputChars }),
+        async embed({ text, signal }) {
+            // ONE text is this library's query shape (`loadRelevant` embeds the
+            // question).
+            return (await embedChunk([text], 'RETRIEVAL_QUERY', signal))[0];
+        },
+        async embedBatch({ texts, signal }) {
+            // MANY texts is this library's document shape, and Gemini embeds a
+            // document into a different place from a query on purpose.
+            //
+            // Sequential rather than parallel: callers of this path are usually
+            // indexing a whole corpus, and `indexCorpus` already fans out over
+            // batches with its own bounded parallelism and retry. Racing N more
+            // requests inside one of those branches is how a corpus index meets a
+            // throttling error. The abort is checked between calls as well as passed
+            // into each one.
+            return embedAll(texts, 'RETRIEVAL_DOCUMENT', signal);
+        },
+    };
+}
+/**
+ * Read the vectors out of an `embedContent` response — and refuse everything
+ * else by name.
+ *
+ * Four refusals, each for a failure that would otherwise be silent:
+ *   • a count that disagrees with the texts sent — vectors are paired with
+ *     texts by POSITION, so a short answer does not lose one passage, it
+ *     re-labels every later one;
+ *   • no readable `values` — an embedder that returns `[]` writes a row a store
+ *     will never rank, which is indistinguishable from "the corpus does not
+ *     mention that";
+ *   • a length that disagrees with the declared `.dimensions` — the number a
+ *     vector store fingerprints on;
+ *   • `statistics.truncated` under `onTruncation: 'refuse'` — the service
+ *     saying it indexed the opening of the passage and threw the rest away.
+ */
+function readGeminiEmbeddings(response, model, dimensions, texts, onTruncation) {
+    const rows = response.embeddings;
+    if (!Array.isArray(rows) || rows.length !== texts.length) {
+        throw new Error(`geminiEmbedder: '${model}' was sent ${texts.length} text(s) and answered with ` +
+            `${Array.isArray(rows) ? rows.length : describeShape(response)} — vectors are paired ` +
+            `with texts by POSITION, so a mismatched answer would attach every later vector to the ` +
+            `wrong passage, and the corpus would rank confidently and wrongly forever.`);
+    }
+    return rows.map((row, index) => {
+        const values = row?.values;
+        if (!Array.isArray(values) || !values.every((n) => typeof n === 'number')) {
+            throw new Error(`geminiEmbedder: '${model}' returned no \`embeddings[${index}].values\` array. The ` +
+                `service answered with ${describeShape(response)}, which this adapter cannot read — ` +
+                `check that the model id names an EMBEDDING model.`);
+        }
+        if (values.length !== dimensions) {
+            throw new Error(`geminiEmbedder: '${model}' answered with a ${values.length}-number vector while this ` +
+                `embedder reports .dimensions ${dimensions}. A store fingerprints on the reported ` +
+                `number, so writing this vector would make the store's own record of its shape a lie. ` +
+                `Pass { dimensions: ${values.length} } if that is the size you meant.`);
+        }
+        if (row?.statistics?.truncated === true && onTruncation === 'refuse') {
+            const chars = (texts[index] ?? '').length;
+            throw new Error(`geminiEmbedder: '${model}' CLIPPED this input — it reported ` +
+                `\`statistics.truncated\`, so the vector represents only the opening of the ` +
+                `${chars.toLocaleString('en-US')}-character text it was given. Storing it would ` +
+                `index a passage by a prefix of itself, and retrieval would then fail to find words ` +
+                `the passage visibly contains.\n` +
+                `  Fix 1 — cut smaller: pass \`maxChunkChars\` to the indexer (it wins over this ` +
+                `embedder's declared .maxInputChars, which is a characters-per-token ASSUMPTION and ` +
+                `is optimistic for code, tables and CJK).\n` +
+                `  Fix 2 — \`onTruncation: 'allow'\` if a prefix embedding is genuinely what you ` +
+                `want. The vector is returned unchanged; only this refusal goes away.`);
+        }
+        return [...values];
+    });
+}
 /**
  * The MEASURED cliff of the default model, and the origin of the whole
  * mechanism: `Xenova/all-MiniLM-L6-v2` silently truncates at 512 wordpiece