@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/memory/embeddings-gemini.js

@@ -1,20 +1,17 @@
+import { collectProviderApiKeysForExecution, executeWithApiKeyRotation, } from "../agents/api-key-rotation.js";
 import { requireApiKey, resolveApiKeyForProvider } from "../agents/model-auth.js";
-import { isTruthyEnvValue } from "../infra/env.js";
-import { createSubsystemLogger } from "../logging/subsystem.js";
+import { parseGeminiAuth } from "../infra/gemini-auth.js";
+import { debugEmbeddingsLog } from "./embeddings-debug.js";
 const DEFAULT_GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 export const DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
-const debugEmbeddings = isTruthyEnvValue(process.env.POOLBOT_DEBUG_MEMORY_EMBEDDINGS || process.env.CLAWDBOT_DEBUG_MEMORY_EMBEDDINGS);
-const log = createSubsystemLogger("memory/embeddings");
-const debugLog = (message, meta) => {
-    if (!debugEmbeddings)
-        return;
-    const suffix = meta ? ` ${JSON.stringify(meta)}` : "";
-    log.raw(`${message}${suffix}`);
+const GEMINI_MAX_INPUT_TOKENS = {
+    "text-embedding-004": 2048,
 };
 function resolveRemoteApiKey(remoteApiKey) {
     const trimmed = remoteApiKey?.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     if (trimmed === "GOOGLE_API_KEY" || trimmed === "GEMINI_API_KEY") {
         return process.env[trimmed]?.trim();
     }
@@ -22,20 +19,24 @@ function resolveRemoteApiKey(remoteApiKey) {
 }
 function normalizeGeminiModel(model) {
     const trimmed = model.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return DEFAULT_GEMINI_EMBEDDING_MODEL;
+    }
     const withoutPrefix = trimmed.replace(/^models\//, "");
-    if (withoutPrefix.startsWith("gemini/"))
+    if (withoutPrefix.startsWith("gemini/")) {
         return withoutPrefix.slice("gemini/".length);
-    if (withoutPrefix.startsWith("google/"))
+    }
+    if (withoutPrefix.startsWith("google/")) {
         return withoutPrefix.slice("google/".length);
+    }
     return withoutPrefix;
 }
 function normalizeGeminiBaseUrl(raw) {
     const trimmed = raw.replace(/\/+$/, "");
     const openAiIndex = trimmed.indexOf("/openai");
-    if (openAiIndex > -1)
+    if (openAiIndex > -1) {
         return trimmed.slice(0, openAiIndex);
+    }
     return trimmed;
 }
 function buildGeminiModelPath(model) {
@@ -46,42 +47,53 @@ export async function createGeminiEmbeddingProvider(options) {
     const baseUrl = client.baseUrl.replace(/\/$/, "");
     const embedUrl = `${baseUrl}/${client.modelPath}:embedContent`;
     const batchUrl = `${baseUrl}/${client.modelPath}:batchEmbedContents`;
-    const embedQuery = async (text) => {
-        if (!text.trim())
-            return [];
-        const res = await fetch(embedUrl, {
+    const fetchWithGeminiAuth = async (apiKey, endpoint, body) => {
+        const authHeaders = parseGeminiAuth(apiKey);
+        const headers = {
+            ...authHeaders.headers,
+            ...client.headers,
+        };
+        const res = await fetch(endpoint, {
             method: "POST",
-            headers: client.headers,
-            body: JSON.stringify({
-                content: { parts: [{ text }] },
-                taskType: "RETRIEVAL_QUERY",
-            }),
+            headers,
+            body: JSON.stringify(body),
         });
         if (!res.ok) {
             const payload = await res.text();
             throw new Error(`gemini embeddings failed: ${res.status} ${payload}`);
         }
-        const payload = (await res.json());
+        return (await res.json());
+    };
+    const embedQuery = async (text) => {
+        if (!text.trim()) {
+            return [];
+        }
+        const payload = await executeWithApiKeyRotation({
+            provider: "google",
+            apiKeys: client.apiKeys,
+            execute: (apiKey) => fetchWithGeminiAuth(apiKey, embedUrl, {
+                content: { parts: [{ text }] },
+                taskType: "RETRIEVAL_QUERY",
+            }),
+        });
         return payload.embedding?.values ?? [];
     };
     const embedBatch = async (texts) => {
-        if (texts.length === 0)
+        if (texts.length === 0) {
             return [];
+        }
         const requests = texts.map((text) => ({
             model: client.modelPath,
             content: { parts: [{ text }] },
             taskType: "RETRIEVAL_DOCUMENT",
         }));
-        const res = await fetch(batchUrl, {
-            method: "POST",
-            headers: client.headers,
-            body: JSON.stringify({ requests }),
+        const payload = await executeWithApiKeyRotation({
+            provider: "google",
+            apiKeys: client.apiKeys,
+            execute: (apiKey) => fetchWithGeminiAuth(apiKey, batchUrl, {
+                requests,
+            }),
         });
-        if (!res.ok) {
-            const payload = await res.text();
-            throw new Error(`gemini embeddings failed: ${res.status} ${payload}`);
-        }
-        const payload = (await res.json());
         const embeddings = Array.isArray(payload.embeddings) ? payload.embeddings : [];
         return texts.map((_, index) => embeddings[index]?.values ?? []);
     };
@@ -89,6 +101,7 @@ export async function createGeminiEmbeddingProvider(options) {
         provider: {
             id: "gemini",
             model: client.model,
+            maxInputTokens: GEMINI_MAX_INPUT_TOKENS[client.model],
             embedQuery,
             embedBatch,
         },
@@ -111,13 +124,15 @@ export async function resolveGeminiEmbeddingClient(options) {
     const baseUrl = normalizeGeminiBaseUrl(rawBaseUrl);
     const headerOverrides = Object.assign({}, providerConfig?.headers, remote?.headers);
     const headers = {
-        "Content-Type": "application/json",
-        "x-goog-api-key": apiKey,
         ...headerOverrides,
     };
+    const apiKeys = collectProviderApiKeysForExecution({
+        provider: "google",
+        primaryApiKey: apiKey,
+    });
     const model = normalizeGeminiModel(options.model);
     const modelPath = buildGeminiModelPath(model);
-    debugLog("memory embeddings: gemini client", {
+    debugEmbeddingsLog("memory embeddings: gemini client", {
         rawBaseUrl,
         baseUrl,
         model,
@@ -125,5 +140,5 @@ export async function resolveGeminiEmbeddingClient(options) {
         embedEndpoint: `${baseUrl}/${modelPath}:embedContent`,
         batchEndpoint: `${baseUrl}/${modelPath}:batchEmbedContents`,
     });
-    return { baseUrl, headers, model, modelPath };
+    return { baseUrl, headers, model, modelPath, apiKeys };
 }

package/dist/memory/manager-embedding-ops.js

@@ -263,34 +263,32 @@ export class MemoryManagerEmbeddingOps extends MemoryManagerSyncOps {
             debug: (message, data) => log.debug(message, data ? { ...data, source, chunks: chunks.length } : { source, chunks: chunks.length }),
         };
     }
-    async embedChunksWithVoyageBatch(chunks, entry, source) {
-        const voyage = this.voyage;
-        if (!voyage) {
-            return this.embedChunksInBatches(chunks);
+    async embedChunksWithProviderBatch(params) {
+        if (!params.enabled) {
+            return this.embedChunksInBatches(params.chunks);
         }
-        if (chunks.length === 0) {
+        if (params.chunks.length === 0) {
             return [];
         }
-        const { embeddings, missing } = this.collectCachedEmbeddings(chunks);
+        const { embeddings, missing } = this.collectCachedEmbeddings(params.chunks);
         if (missing.length === 0) {
             return embeddings;
         }
         const { requests, mapping } = this.buildBatchRequests({
             missing,
-            entry,
-            source,
-            build: (chunk) => ({
-                body: { input: chunk.text },
-            }),
+            entry: params.entry,
+            source: params.source,
+            build: params.buildRequest,
+        });
+        const runnerOptions = this.buildEmbeddingBatchRunnerOptions({
+            requests,
+            chunks: params.chunks,
+            source: params.source,
         });
-        const runnerOptions = this.buildEmbeddingBatchRunnerOptions({ requests, chunks, source });
         const batchResult = await this.runBatchWithFallback({
-            provider: "voyage",
-            run: async () => await runVoyageEmbeddingBatches({
-                client: voyage,
-                ...runnerOptions,
-            }),
-            fallback: async () => await this.embedChunksInBatches(chunks),
+            provider: params.provider,
+            run: async () => await params.runBatch(runnerOptions),
+            fallback: async () => await this.embedChunksInBatches(params.chunks),
         });
         if (Array.isArray(batchResult)) {
             return batchResult;
@@ -298,81 +296,62 @@ export class MemoryManagerEmbeddingOps extends MemoryManagerSyncOps {
         this.applyBatchEmbeddings({ byCustomId: batchResult, mapping, embeddings });
         return embeddings;
     }
+    async embedChunksWithVoyageBatch(chunks, entry, source) {
+        const voyage = this.voyage;
+        return await this.embedChunksWithProviderBatch({
+            chunks,
+            entry,
+            source,
+            provider: "voyage",
+            enabled: Boolean(voyage),
+            buildRequest: (chunk) => ({
+                body: { input: chunk.text },
+            }),
+            runBatch: async (runnerOptions) => await runVoyageEmbeddingBatches({
+                client: voyage,
+                ...runnerOptions,
+            }),
+        });
+    }
     async embedChunksWithOpenAiBatch(chunks, entry, source) {
         const openAi = this.openAi;
-        if (!openAi) {
-            return this.embedChunksInBatches(chunks);
-        }
-        if (chunks.length === 0) {
-            return [];
-        }
-        const { embeddings, missing } = this.collectCachedEmbeddings(chunks);
-        if (missing.length === 0) {
-            return embeddings;
-        }
-        const { requests, mapping } = this.buildBatchRequests({
-            missing,
+        return await this.embedChunksWithProviderBatch({
+            chunks,
             entry,
             source,
-            build: (chunk) => ({
+            provider: "openai",
+            enabled: Boolean(openAi),
+            buildRequest: (chunk) => ({
                 method: "POST",
                 url: OPENAI_BATCH_ENDPOINT,
                 body: {
-                    model: this.openAi?.model ?? this.provider?.model ?? "text-embedding-3-small",
+                    model: openAi?.model ?? this.provider?.model ?? "text-embedding-3-small",
                     input: chunk.text,
                 },
             }),
-        });
-        const runnerOptions = this.buildEmbeddingBatchRunnerOptions({ requests, chunks, source });
-        const batchResult = await this.runBatchWithFallback({
-            provider: "openai",
-            run: async () => await runOpenAiEmbeddingBatches({
-                openAi,
+            runBatch: async (runnerOptions) => await runOpenAiEmbeddingBatches({
+                openAi: openAi,
                 ...runnerOptions,
             }),
-            fallback: async () => await this.embedChunksInBatches(chunks),
         });
-        if (Array.isArray(batchResult)) {
-            return batchResult;
-        }
-        this.applyBatchEmbeddings({ byCustomId: batchResult, mapping, embeddings });
-        return embeddings;
     }
     async embedChunksWithGeminiBatch(chunks, entry, source) {
         const gemini = this.gemini;
-        if (!gemini) {
-            return this.embedChunksInBatches(chunks);
-        }
-        if (chunks.length === 0) {
-            return [];
-        }
-        const { embeddings, missing } = this.collectCachedEmbeddings(chunks);
-        if (missing.length === 0) {
-            return embeddings;
-        }
-        const { requests, mapping } = this.buildBatchRequests({
-            missing,
+        return await this.embedChunksWithProviderBatch({
+            chunks,
             entry,
             source,
-            build: (chunk) => ({
+            provider: "gemini",
+            enabled: Boolean(gemini),
+            buildRequest: (chunk) => ({
                 content: { parts: [{ text: chunk.text }] },
                 taskType: "RETRIEVAL_DOCUMENT",
             }),
-        });
-        const runnerOptions = this.buildEmbeddingBatchRunnerOptions({ requests, chunks, source });
-        const batchResult = await this.runBatchWithFallback({
-            provider: "gemini",
-            run: async () => await runGeminiEmbeddingBatches({
-                gemini,
+            runBatch: async (runnerOptions) => await runGeminiEmbeddingBatches({
+                gemini: gemini,
                 ...runnerOptions,
             }),
-            fallback: async () => await this.embedChunksInBatches(chunks),
         });
-        if (Array.isArray(batchResult)) {
-            return batchResult;
-        }
-        this.applyBatchEmbeddings({ byCustomId: batchResult, mapping, embeddings });
-        return embeddings;
     }
     async embedBatchWithRetry(texts) {
         if (texts.length === 0) {