@rudderjs/ai 1.5.0 → 1.6.0

package/dist/providers/google.d.ts

@@ -1,4 +1,5 @@
-import type { ProviderFactory, ProviderAdapter, ProviderRequestOptions, ProviderResponse, StreamChunk, EmbeddingAdapter, ImageGenerationAdapter, FileAdapter } from '../types.js';
+import type { ProviderFactory, ProviderAdapter, ProviderRequestOptions, ProviderResponse, StreamChunk, EmbeddingAdapter, ImageGenerationAdapter, FileAdapter, VectorStoreAdapter, VectorStoreInfo, VectorStoreFileInfo } from '../types.js';
+import type { FileSearchFilter } from '../file-search.js';
 import { GoogleCacheRegistry } from './google-cache-registry.js';
 export interface GoogleConfig {
     apiKey: string;
@@ -12,6 +13,7 @@ export declare class GoogleProvider implements ProviderFactory {
     createEmbedding(model: string): EmbeddingAdapter;
     createImage(model: string): ImageGenerationAdapter;
     createFiles(): FileAdapter;
+    createVectorStores(): VectorStoreAdapter;
 }
 export declare class GoogleAdapter implements ProviderAdapter {
     private readonly config;
@@ -30,4 +32,84 @@ export declare class GoogleAdapter implements ProviderAdapter {
     generate(options: ProviderRequestOptions): Promise<ProviderResponse>;
     stream(options: ProviderRequestOptions): AsyncIterable<StreamChunk>;
 }
+/**
+ * Translate a typed `FileSearchFilter` (OpenAI-shaped) into Gemini's
+ * `metadataFilter` string syntax (#B8.5).
+ *
+ * - `{ type: 'eq',  key, value }` → `key = value`
+ * - `{ type: 'ne',  key, value }` → `key != value`
+ * - `{ type: 'gt',  key, value }` → `key > value`
+ * - `{ type: 'gte', key, value }` → `key >= value`
+ * - `{ type: 'lt',  key, value }` → `key < value`
+ * - `{ type: 'lte', key, value }` → `key <= value`
+ * - `{ type: 'and', filters }`    → `(f1) AND (f2) AND ...`
+ * - `{ type: 'or',  filters }`    → `(f1) OR (f2) OR ...`
+ *
+ * String values are wrapped in double quotes with `"` and `\` escaped.
+ * Numbers and booleans render bare.
+ *
+ * Exported for unit testing — see `google-vector-stores.test.ts`.
+ *
+ * @internal
+ */
+export declare function filterToGeminiString(filter: FileSearchFilter): string;
+/**
+ * Map a Gemini `FileSearchStore` resource into the framework's
+ * `VectorStoreInfo` shape. `displayNameOverride` lets `create()` populate
+ * the human-friendly name from the user-supplied value when the API
+ * response omits it (some response variants do).
+ *
+ * @internal
+ */
+export declare function fromGeminiFileSearchStore(raw: unknown, displayNameOverride?: string): VectorStoreInfo;
+/**
+ * Map a Gemini `Document` resource into the framework's
+ * `VectorStoreFileInfo` shape. `DocumentState` enum values flatten to the
+ * shared `'in_progress' | 'completed' | 'failed' | 'cancelled'` union.
+ *
+ * @internal
+ */
+export declare function fromGeminiDocument(raw: unknown, storeId: string): VectorStoreFileInfo;
+/**
+ * Convert the framework's flat attribute map to Gemini's `CustomMetadata`
+ * array shape. Strings → `stringValue`, numbers → `numericValue`,
+ * booleans → `stringValue: 'true' | 'false'` (Gemini has no boolean
+ * variant — string is the safe lossless choice; filter-builders can
+ * still match on `key = "true"`).
+ *
+ * @internal
+ */
+export declare function attributesToCustomMetadata(attrs: Record<string, string | number | boolean>): Array<{
+    key: string;
+    stringValue?: string;
+    numericValue?: number;
+}>;
+/**
+ * Inverse of {@link attributesToCustomMetadata}. Drops `stringListValue`
+ * variants (no flat-attribute representation; apps that need lists
+ * should read the raw Document via the SDK).
+ *
+ * @internal
+ */
+export declare function customMetadataToAttributes(metadata: Array<{
+    key?: string;
+    stringValue?: string;
+    numericValue?: number;
+    stringListValue?: {
+        values?: string[];
+    };
+}>): Record<string, string | number | boolean>;
+/**
+ * Best-effort MIME type from a filename extension. Gemini's
+ * `uploadToFileSearchStore` requires a mimeType on Blob uploads (it
+ * reads `blob.type`, which is empty on untyped `new Blob([data])`).
+ *
+ * Coverage matches Gemini's supported FileSearchStore document formats.
+ * Unknown extensions return `''` — the caller drops the field so the
+ * Gemini SDK's own error fires loudly rather than silently picking a
+ * wrong type.
+ *
+ * @internal
+ */
+export declare function mimeTypeFromFilename(filename: string): string;
 //# sourceMappingURL=google.d.ts.map

package/dist/providers/google.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../src/providers/google.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EAChB,WAAW,EAKX,gBAAgB,EAEhB,sBAAsB,EAGtB,WAAW,EAIZ,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,mBAAmB,EAKpB,MAAM,4BAA4B,CAAA;AAEnC,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAA;CACf;AAED,qBAAa,cAAe,YAAW,eAAe;IACpD,QAAQ,CAAC,IAAI,YAAW;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAqB;gBAExC,MAAM,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,mBAAmB;IAKrE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe;IAItC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB;IAIhD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB;IAIlD,WAAW,IAAI,WAAW;CAG3B;AAID,qBAAa,aAAc,YAAW,eAAe;IAIjD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;IALjC,OAAO,CAAC,MAAM,CAAY;gBAGP,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,aAAa,CAAC,EAAE,mBAAmB,GAAG,SAAS;YAGpD,SAAS;IAQvB;;;;;OAKG;YACW,YAAY;IA0DpB,QAAQ,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmBnE,MAAM,CAAC,OAAO,EAAE,sBAAsB,GAAG,aAAa,CAAC,WAAW,CAAC;CAkD3E"}
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../src/providers/google.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EAChB,WAAW,EAKX,gBAAgB,EAEhB,sBAAsB,EAGtB,WAAW,EAIX,kBAAkB,EAElB,eAAe,EACf,mBAAmB,EAKpB,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACzD,OAAO,EACL,mBAAmB,EAKpB,MAAM,4BAA4B,CAAA;AAEnC,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAA;CACf;AAED,qBAAa,cAAe,YAAW,eAAe;IACpD,QAAQ,CAAC,IAAI,YAAW;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAqB;gBAExC,MAAM,EAAE,YAAY,EAAE,aAAa,CAAC,EAAE,mBAAmB;IAKrE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe;IAItC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB;IAIhD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,sBAAsB;IAIlD,WAAW,IAAI,WAAW;IAI1B,kBAAkB,IAAI,kBAAkB;CAGzC;AAID,qBAAa,aAAc,YAAW,eAAe;IAIjD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;IALjC,OAAO,CAAC,MAAM,CAAY;gBAGP,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,aAAa,CAAC,EAAE,mBAAmB,GAAG,SAAS;YAGpD,SAAS;IAQvB;;;;;OAKG;YACW,YAAY;IA4DpB,QAAQ,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmBnE,MAAM,CAAC,OAAO,EAAE,sBAAsB,GAAG,aAAa,CAAC,WAAW,CAAC;CAkD3E;AAwHD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAsBrE;AA0cD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,EAAE,mBAAmB,CAAC,EAAE,MAAM,GAAG,eAAe,CAuBrG;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,mBAAmB,CAuBrF;AAWD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,GAC/C,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAMrE;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,KAAK,CAAC;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;CAAE,CAAC,GACtH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAc3C;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAoB7D"}

package/dist/providers/google.js

@@ -20,6 +20,9 @@ export class GoogleProvider {
     createFiles() {
         return new GoogleFileAdapter(this.config);
     }
+    createVectorStores() {
+        return new GoogleVectorStoreAdapter(this.config);
+    }
 }
 // ─── Adapter ──────────────────────────────────────────────
 export class GoogleAdapter {
@@ -49,6 +52,8 @@ export class GoogleAdapter {
     async buildPayload(options) {
         const client = await this.getClient();
         const { system, contents } = toGeminiContents(options.messages);
+        // `toGeminiTools` returns the already-wrapped top-level array
+        // ({functionDeclarations: [...]} + any native blocks like google_search).
         const geminiTools = options.tools?.length ? toGeminiTools(options.tools) : undefined;
         const config = {};
         if (options.maxTokens)
@@ -59,8 +64,8 @@ export class GoogleAdapter {
             config['topP'] = options.topP;
         if (options.stop)
             config['stopSequences'] = options.stop;
-        if (geminiTools)
-            config['tools'] = [{ functionDeclarations: geminiTools }];
+        if (geminiTools && geminiTools.length > 0)
+            config['tools'] = geminiTools;
         if (options.toolChoice)
             config['toolConfig'] = toGeminiToolConfig(options.toolChoice);
         // The Gemini SDK reads abortSignal from the config block.
@@ -78,7 +83,7 @@ export class GoogleAdapter {
                     cacheKey,
                     ...(options.cache.instructions && system ? { systemInstruction: { parts: [{ text: system }] } } : {}),
                     ...(cachedSlice.length > 0 ? { contents: cachedSlice } : {}),
-                    ...(options.cache.tools && geminiTools ? { tools: [{ functionDeclarations: geminiTools }] } : {}),
+                    ...(options.cache.tools && geminiTools && geminiTools.length > 0 ? { tools: geminiTools } : {}),
                     ...(options.cache.ttl ? { ttl: durationToGoogleTtl(options.cache.ttl) } : {}),
                 });
             }
@@ -230,12 +235,118 @@ function toGeminiContents(messages) {
     });
     return { system, contents };
 }
+/**
+ * Build Gemini's `tools` array. The Gemini API accepts a mixed array where
+ * function declarations live under one wrapper entry and provider-native
+ * blocks (e.g. `{ google_search: {} }`) sit as separate top-level entries:
+ *
+ *   tools: [
+ *     { functionDeclarations: [...] },
+ *     { google_search: {} },
+ *   ]
+ *
+ * Tools tagged with a recognized `providerHint.type` are emitted as their
+ * native top-level block; everything else collects into one
+ * `functionDeclarations` entry. Tools with unrecognized hints fall through
+ * to the function-declaration shape — the input schema's still there, so
+ * the worst case is the model treats it as a regular function-call tool.
+ */
 function toGeminiTools(tools) {
-    return tools.map(t => ({
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-    }));
+    const fnDecls = [];
+    const blocks = [];
+    for (const t of tools) {
+        if (t.providerHint?.type === 'web-search') {
+            // Gemini's native search tool. The block's `google_search: {}` form is
+            // intentional — Gemini doesn't accept allowed_domains / max_uses on
+            // this block, so the WebSearch.domains() / .maxResults() opts are
+            // ignored on this provider (documented on WebSearch).
+            blocks.push({ google_search: {} });
+            continue;
+        }
+        if (t.providerHint?.type === 'file-search') {
+            // Gemini's native FileSearch tool (#B8.5). The OpenAI-shaped hint
+            // (`vector_store_ids` + typed `filters`) is translated to Gemini's
+            // shape (`fileSearchStoreNames` + `metadataFilter` string). `topK`
+            // mirrors OpenAI's `max_num_results`.
+            const storeNames = t.providerHint['vector_store_ids'] ?? [];
+            const fileSearchConfig = {
+                fileSearchStoreNames: storeNames,
+            };
+            const filters = t.providerHint['filters'];
+            if (filters !== undefined) {
+                fileSearchConfig['metadataFilter'] = filterToGeminiString(filters);
+            }
+            const maxNumResults = t.providerHint['max_num_results'];
+            if (maxNumResults !== undefined) {
+                fileSearchConfig['topK'] = maxNumResults;
+            }
+            blocks.push({ fileSearch: fileSearchConfig });
+            continue;
+        }
+        fnDecls.push({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        });
+    }
+    if (fnDecls.length > 0)
+        blocks.unshift({ functionDeclarations: fnDecls });
+    return blocks;
+}
+/**
+ * Translate a typed `FileSearchFilter` (OpenAI-shaped) into Gemini's
+ * `metadataFilter` string syntax (#B8.5).
+ *
+ * - `{ type: 'eq',  key, value }` → `key = value`
+ * - `{ type: 'ne',  key, value }` → `key != value`
+ * - `{ type: 'gt',  key, value }` → `key > value`
+ * - `{ type: 'gte', key, value }` → `key >= value`
+ * - `{ type: 'lt',  key, value }` → `key < value`
+ * - `{ type: 'lte', key, value }` → `key <= value`
+ * - `{ type: 'and', filters }`    → `(f1) AND (f2) AND ...`
+ * - `{ type: 'or',  filters }`    → `(f1) OR (f2) OR ...`
+ *
+ * String values are wrapped in double quotes with `"` and `\` escaped.
+ * Numbers and booleans render bare.
+ *
+ * Exported for unit testing — see `google-vector-stores.test.ts`.
+ *
+ * @internal
+ */
+export function filterToGeminiString(filter) {
+    switch (filter.type) {
+        case 'eq':
+        case 'ne':
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte': {
+            const op = GEMINI_FILTER_OP[filter.type];
+            return `${filter.key} ${op} ${formatGeminiValue(filter.value)}`;
+        }
+        case 'and':
+        case 'or': {
+            if (filter.filters.length === 0) {
+                throw new Error(`[RudderJS AI] Gemini metadataFilter: ${filter.type.toUpperCase()} requires at least one sub-filter.`);
+            }
+            const joiner = filter.type === 'and' ? ' AND ' : ' OR ';
+            return filter.filters.map(f => `(${filterToGeminiString(f)})`).join(joiner);
+        }
+    }
+}
+const GEMINI_FILTER_OP = {
+    eq: '=',
+    ne: '!=',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<=',
+};
+function formatGeminiValue(value) {
+    if (typeof value === 'string') {
+        return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+    }
+    return String(value);
 }
 function toGeminiToolConfig(choice) {
     if (choice === 'auto')
@@ -402,4 +513,376 @@ class GoogleFileAdapter {
         await client.files.delete({ name: fileId });
     }
 }
+// ─── Vector Stores (Gemini FileSearchStores, #B8.5) ──────
+//
+// Gemini's hosted RAG surface is `ai.fileSearchStores.*` — a direct
+// OpenAI-equivalent that handles ingestion, chunking, embedding, and
+// retrieval server-side. NOT available on Vertex AI; the underlying SDK
+// methods throw for Vertex clients.
+//
+// Mapping decisions:
+// - `VectorStoreInfo.id` is the full Gemini resource name
+//   (`fileSearchStores/foo-bar`). Apps pass it back verbatim to `get` /
+//   `delete` / `addFile`.
+// - `VectorStoreInfo.name` is `displayName`. The OpenAI adapter populates
+//   it from the store's name field; we use the user-supplied display name
+//   to keep `create('Knowledge Base')` round-trip-able.
+// - `createdAt` is parsed from ISO 8601 to Unix seconds for parity with
+//   OpenAI's `created_at`.
+// - `fileCount` sums `activeDocumentsCount + pendingDocumentsCount` (both
+//   string-encoded). `failedDocumentsCount` is dropped — it's surfaced
+//   per-file via `addFile`'s status when polling.
+// - `bytesUsed` is parsed from `sizeBytes` (string-encoded).
+// - Store-level `metadata` and `expiresAfter` are NOT supported by Gemini.
+//   Passing them throws fail-loud so apps don't silently lose data.
+//
+// `addFile` paths:
+// - `{ fileId }` → `importFile` (re-uses an existing Files API file).
+// - `{ filePath | fileBuffer }` → `uploadToFileSearchStore` (single-shot
+//   upload). Both paths return long-running operations; default
+//   `wait: true` polls `client.operations.get` until `done`.
+// - `attributes` (Record<string, primitive>) → Gemini's `customMetadata`
+//   array shape; booleans coerce to `stringValue: 'true' | 'false'`.
+class GoogleVectorStoreAdapter {
+    config;
+    client = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async getClient() {
+        if (this.client)
+            return this.client;
+        const sdk = await import(/* @vite-ignore */ '@google/genai');
+        const GoogleGenAI = sdk.GoogleGenAI ?? sdk.default;
+        this.client = new GoogleGenAI({ apiKey: this.config.apiKey });
+        return this.client;
+    }
+    async create(opts) {
+        if (opts.metadata) {
+            throw new Error('[RudderJS AI] Gemini FileSearchStores does not support store-level metadata. ' +
+                'Attach searchable metadata per-document via addFile({ attributes }).');
+        }
+        if (opts.expiresAfter) {
+            throw new Error('[RudderJS AI] Gemini FileSearchStores does not support expiresAfter. ' +
+                'Stores persist until explicitly deleted via VectorStores.delete().');
+        }
+        const client = await this.getClient();
+        const response = await client.fileSearchStores.create({
+            config: { displayName: opts.name },
+        });
+        return fromGeminiFileSearchStore(response, opts.name);
+    }
+    async list(opts) {
+        const client = await this.getClient();
+        const config = {};
+        if (opts?.limit !== undefined)
+            config['pageSize'] = opts.limit;
+        if (opts?.after !== undefined)
+            config['pageToken'] = opts.after;
+        // Gemini paginates forward via pageToken only — `before` has no
+        // equivalent. Drop it silently (matches OpenAI when `before` is unset).
+        const pager = await client.fileSearchStores.list({ config });
+        const items = Array.isArray(pager?.page) ? pager.page : [];
+        return { stores: items.map(item => fromGeminiFileSearchStore(item)) };
+    }
+    async get(id) {
+        const client = await this.getClient();
+        const response = await client.fileSearchStores.get({ name: id });
+        return fromGeminiFileSearchStore(response);
+    }
+    async delete(id) {
+        const client = await this.getClient();
+        // `force: true` mirrors OpenAI's behavior — deleting a store also
+        // drops attached documents. Without `force`, Gemini returns
+        // FAILED_PRECONDITION when the store has any documents.
+        await client.fileSearchStores.delete({ name: id, config: { force: true } });
+    }
+    async addFile(storeId, opts) {
+        const client = await this.getClient();
+        const customMetadata = opts.attributes ? attributesToCustomMetadata(opts.attributes) : undefined;
+        // Path 1: re-use an existing Files API file.
+        if (opts.fileId) {
+            const importConfig = {};
+            if (customMetadata)
+                importConfig['customMetadata'] = customMetadata;
+            if (opts.chunkingStrategy)
+                importConfig['chunkingConfig'] = opts.chunkingStrategy;
+            const op = await client.fileSearchStores.importFile({
+                fileSearchStoreName: storeId,
+                fileName: opts.fileId,
+                config: importConfig,
+            });
+            return finishVectorStoreOperation(client, op, storeId, opts);
+        }
+        // Path 2: upload a local file directly. Either `filePath` or
+        // `fileBuffer` is required — Gemini's SDK accepts a path string OR a
+        // Blob. For `filePath`, the SDK infers mimeType from the extension;
+        // for `fileBuffer`, it reads `blob.type` which is empty on a
+        // untyped `new Blob([data])`, so we forward an explicit `mimeType`
+        // derived from `filename` to avoid `Can not determine mimeType`.
+        if (opts.filePath || opts.fileBuffer) {
+            const uploadConfig = {};
+            if (customMetadata)
+                uploadConfig['customMetadata'] = customMetadata;
+            if (opts.chunkingStrategy)
+                uploadConfig['chunkingConfig'] = opts.chunkingStrategy;
+            if (opts.fileBuffer?.filename)
+                uploadConfig['displayName'] = opts.fileBuffer.filename;
+            if (opts.fileBuffer?.filename) {
+                const mimeType = mimeTypeFromFilename(opts.fileBuffer.filename);
+                if (mimeType)
+                    uploadConfig['mimeType'] = mimeType;
+            }
+            const file = opts.filePath ?? new Blob([opts.fileBuffer.data]);
+            const op = await client.fileSearchStores.uploadToFileSearchStore({
+                fileSearchStoreName: storeId,
+                file,
+                config: uploadConfig,
+            });
+            return finishVectorStoreOperation(client, op, storeId, opts);
+        }
+        throw new Error('[RudderJS AI] addFile requires fileId, filePath, or fileBuffer. ' +
+            'Pass an existing Gemini Files API id via { fileId } (e.g. `files/abc-123`) or ' +
+            'a local source via { filePath } / { fileBuffer }.');
+    }
+    async removeFile(storeId, fileId) {
+        const client = await this.getClient();
+        // Document resource names are `fileSearchStores/<store>/documents/<doc>`.
+        // Apps that pass the full path use it verbatim; apps that pass only
+        // the document id get the store prefix joined for them.
+        const name = fileId.includes('/documents/') ? fileId : `${storeId}/documents/${fileId}`;
+        await client.fileSearchStores.documents.delete({ name });
+    }
+    async listFiles(storeId, opts) {
+        const client = await this.getClient();
+        const config = {};
+        if (opts?.limit !== undefined)
+            config['pageSize'] = opts.limit;
+        if (opts?.after !== undefined)
+            config['pageToken'] = opts.after;
+        const pager = await client.fileSearchStores.documents.list({ parent: storeId, config });
+        const items = Array.isArray(pager?.page) ? pager.page : [];
+        return { files: items.map(doc => fromGeminiDocument(doc, storeId)) };
+    }
+}
+/**
+ * Wait for a long-running file ingestion operation to finish and map the
+ * result into `VectorStoreFileInfo`. Honors `wait`/`pollInterval`/
+ * `pollTimeout` from `VectorStoreAddOptions` (defaults: wait=true,
+ * interval=1000ms, timeout=120_000ms).
+ *
+ * The terminal state of a Gemini ingestion op is exposed two ways:
+ * - `op.error?: { code, message }` when ingestion failed.
+ * - `op.response?: { documentName: 'fileSearchStores/.../documents/...' }`
+ *   when successful.
+ *
+ * On success we follow up with a single `documents.get` to fetch
+ * `state` / `sizeBytes` / `createTime`. On failure we surface the error
+ * message via `lastError` and the status flips to `'failed'`.
+ */
+async function finishVectorStoreOperation(client, initialOp, storeId, opts) {
+    if (opts.wait === false) {
+        return {
+            id: initialOp?.name ?? `${storeId}/documents/pending-${Date.now()}`,
+            vectorStoreId: storeId,
+            status: 'in_progress',
+            createdAt: Math.floor(Date.now() / 1000),
+            ...(opts.attributes ? { attributes: opts.attributes } : {}),
+        };
+    }
+    const pollInterval = opts.pollInterval ?? 1000;
+    const pollTimeout = opts.pollTimeout ?? 120_000;
+    const deadline = Date.now() + pollTimeout;
+    let current = initialOp;
+    while (!current?.done) {
+        if (Date.now() > deadline) {
+            throw new Error(`[RudderJS AI] Gemini FileSearchStore ingestion timed out after ${pollTimeout}ms ` +
+                `(store=${storeId}). Increase pollTimeout or set wait: false for fire-and-forget.`);
+        }
+        await sleep(pollInterval);
+        current = await client.operations.get({ operation: current });
+    }
+    if (current.error) {
+        const errMessage = current.error.message ?? 'unknown error';
+        return {
+            id: current.name ?? `${storeId}/documents/failed-${Date.now()}`,
+            vectorStoreId: storeId,
+            status: 'failed',
+            createdAt: Math.floor(Date.now() / 1000),
+            lastError: errMessage,
+            ...(opts.attributes ? { attributes: opts.attributes } : {}),
+        };
+    }
+    const documentName = current.response?.documentName;
+    if (!documentName) {
+        // Op done, no error, no documentName — surface as completed without
+        // follow-up details rather than failing.
+        return {
+            id: current.name ?? `${storeId}/documents/unknown-${Date.now()}`,
+            vectorStoreId: storeId,
+            status: 'completed',
+            createdAt: Math.floor(Date.now() / 1000),
+            ...(opts.attributes ? { attributes: opts.attributes } : {}),
+        };
+    }
+    // Follow up with documents.get to surface real createdAt + sizeBytes.
+    // Best-effort: if the get fails (rare race), fall back to the op data.
+    try {
+        const doc = await client.fileSearchStores.documents.get({ name: documentName });
+        const info = fromGeminiDocument(doc, storeId);
+        if (opts.attributes && !info.attributes)
+            info.attributes = opts.attributes;
+        return info;
+    }
+    catch {
+        return {
+            id: documentName,
+            vectorStoreId: storeId,
+            status: 'completed',
+            createdAt: Math.floor(Date.now() / 1000),
+            ...(opts.attributes ? { attributes: opts.attributes } : {}),
+        };
+    }
+}
+/**
+ * Map a Gemini `FileSearchStore` resource into the framework's
+ * `VectorStoreInfo` shape. `displayNameOverride` lets `create()` populate
+ * the human-friendly name from the user-supplied value when the API
+ * response omits it (some response variants do).
+ *
+ * @internal
+ */
+export function fromGeminiFileSearchStore(raw, displayNameOverride) {
+    const r = raw;
+    const id = r.name ?? '';
+    const active = Number(r.activeDocumentsCount ?? 0) || 0;
+    const pending = Number(r.pendingDocumentsCount ?? 0) || 0;
+    const result = {
+        id,
+        name: r.displayName ?? displayNameOverride ?? id,
+        createdAt: r.createTime ? Math.floor(Date.parse(r.createTime) / 1000) : Math.floor(Date.now() / 1000),
+        fileCount: active + pending,
+    };
+    if (r.sizeBytes !== undefined) {
+        const bytes = Number(r.sizeBytes);
+        if (Number.isFinite(bytes))
+            result.bytesUsed = bytes;
+    }
+    return result;
+}
+/**
+ * Map a Gemini `Document` resource into the framework's
+ * `VectorStoreFileInfo` shape. `DocumentState` enum values flatten to the
+ * shared `'in_progress' | 'completed' | 'failed' | 'cancelled'` union.
+ *
+ * @internal
+ */
+export function fromGeminiDocument(raw, storeId) {
+    const r = raw;
+    const status = mapGeminiDocumentState(r.state);
+    const result = {
+        id: r.name ?? `${storeId}/documents/unknown`,
+        vectorStoreId: storeId,
+        status,
+        createdAt: r.createTime ? Math.floor(Date.parse(r.createTime) / 1000) : Math.floor(Date.now() / 1000),
+    };
+    if (r.sizeBytes !== undefined) {
+        const bytes = Number(r.sizeBytes);
+        if (Number.isFinite(bytes))
+            result.bytes = bytes;
+    }
+    if (r.customMetadata && r.customMetadata.length > 0) {
+        result.attributes = customMetadataToAttributes(r.customMetadata);
+    }
+    return result;
+}
+function mapGeminiDocumentState(state) {
+    switch (state) {
+        case 'STATE_ACTIVE': return 'completed';
+        case 'STATE_FAILED': return 'failed';
+        case 'STATE_PENDING': return 'in_progress';
+        default: return 'in_progress';
+    }
+}
+/**
+ * Convert the framework's flat attribute map to Gemini's `CustomMetadata`
+ * array shape. Strings → `stringValue`, numbers → `numericValue`,
+ * booleans → `stringValue: 'true' | 'false'` (Gemini has no boolean
+ * variant — string is the safe lossless choice; filter-builders can
+ * still match on `key = "true"`).
+ *
+ * @internal
+ */
+export function attributesToCustomMetadata(attrs) {
+    return Object.entries(attrs).map(([key, value]) => {
+        if (typeof value === 'number')
+            return { key, numericValue: value };
+        if (typeof value === 'boolean')
+            return { key, stringValue: value ? 'true' : 'false' };
+        return { key, stringValue: value };
+    });
+}
+/**
+ * Inverse of {@link attributesToCustomMetadata}. Drops `stringListValue`
+ * variants (no flat-attribute representation; apps that need lists
+ * should read the raw Document via the SDK).
+ *
+ * @internal
+ */
+export function customMetadataToAttributes(metadata) {
+    const out = {};
+    for (const entry of metadata) {
+        if (!entry.key)
+            continue;
+        if (entry.numericValue !== undefined)
+            out[entry.key] = entry.numericValue;
+        else if (entry.stringValue !== undefined) {
+            // Round-trip booleans encoded by attributesToCustomMetadata.
+            if (entry.stringValue === 'true')
+                out[entry.key] = true;
+            else if (entry.stringValue === 'false')
+                out[entry.key] = false;
+            else
+                out[entry.key] = entry.stringValue;
+        }
+        // stringListValue intentionally dropped.
+    }
+    return out;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Best-effort MIME type from a filename extension. Gemini's
+ * `uploadToFileSearchStore` requires a mimeType on Blob uploads (it
+ * reads `blob.type`, which is empty on untyped `new Blob([data])`).
+ *
+ * Coverage matches Gemini's supported FileSearchStore document formats.
+ * Unknown extensions return `''` — the caller drops the field so the
+ * Gemini SDK's own error fires loudly rather than silently picking a
+ * wrong type.
+ *
+ * @internal
+ */
+export function mimeTypeFromFilename(filename) {
+    const ext = filename.toLowerCase().split('.').pop() ?? '';
+    switch (ext) {
+        case 'txt': return 'text/plain';
+        case 'md': return 'text/markdown';
+        case 'pdf': return 'application/pdf';
+        case 'html':
+        case 'htm': return 'text/html';
+        case 'json': return 'application/json';
+        case 'csv': return 'text/csv';
+        case 'tsv': return 'text/tab-separated-values';
+        case 'xml': return 'application/xml';
+        case 'rtf': return 'application/rtf';
+        case 'doc': return 'application/msword';
+        case 'docx': return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+        case 'js': return 'text/javascript';
+        case 'ts': return 'text/x-typescript';
+        case 'py': return 'text/x-python';
+        default: return '';
+    }
+}
 //# sourceMappingURL=google.js.map