@smyslenny/agent-memory 4.2.0 → 4.3.1

package/dist/index.d.ts

@@ -550,7 +550,7 @@ declare function exportMemories(db: Database.Database, dirPath: string, opts?: {
     agent_id?: string;
 }): ExportResult;
 
-type EmbeddingProviderKind = "openai-compatible" | "local-http";
+type EmbeddingProviderKind = "openai-compatible" | "local-http" | "gemini";
 interface EmbeddingProviderConfig {
     provider: EmbeddingProviderKind;
     baseUrl: string;

package/dist/index.js

@@ -676,6 +676,47 @@ function createLocalHttpEmbeddingProvider(opts) {
     }
   };
 }
+var GEMINI_DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com";
+function createGeminiEmbeddingProvider(opts) {
+  const baseUrl = trimTrailingSlashes(opts.baseUrl || GEMINI_DEFAULT_BASE_URL);
+  const descriptorInput = `${baseUrl}|${opts.model}|${opts.dimension}`;
+  const id = stableProviderId(`gemini:${opts.model}`, descriptorInput);
+  return {
+    id,
+    model: opts.model,
+    dimension: opts.dimension,
+    async embed(texts) {
+      if (texts.length === 0) return [];
+      const fetchFn = getFetch(opts.fetchImpl);
+      const url = `${baseUrl}/v1beta/models/${opts.model}:batchEmbedContents?key=${opts.apiKey}`;
+      const requests = texts.map((text) => ({
+        model: `models/${opts.model}`,
+        content: { parts: [{ text }] },
+        outputDimensionality: opts.dimension
+      }));
+      const response = await fetchFn(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ requests })
+      });
+      if (!response.ok) {
+        const detail = await response.text().catch(() => "");
+        throw new Error(`Gemini embedding request failed: ${response.status} ${response.statusText}${detail ? ` \u2014 ${detail}` : ""}`);
+      }
+      const json2 = await response.json();
+      const embeddings = json2?.embeddings;
+      if (!Array.isArray(embeddings)) {
+        throw new Error("Gemini embedding response missing embeddings array");
+      }
+      return embeddings.map(
+        (entry, index) => assertEmbeddingVector(entry?.values, opts.dimension, `Gemini embedding item ${index}`)
+      );
+    },
+    async healthcheck() {
+      await this.embed(["healthcheck"]);
+    }
+  };
+}
 function normalizeEmbeddingBaseUrl(baseUrl) {
   return trimTrailingSlashes(baseUrl);
 }
@@ -688,7 +729,7 @@ function parseDimension(raw) {
 }
 function parseProvider(raw) {
   if (!raw) return null;
-  if (raw === "openai-compatible" || raw === "local-http") {
+  if (raw === "openai-compatible" || raw === "local-http" || raw === "gemini") {
     return raw;
   }
   throw new Error(`Unsupported embedding provider: ${raw}`);
@@ -699,8 +740,8 @@ function getEmbeddingProviderConfigFromEnv(env = process.env) {
   const baseUrl = env.AGENT_MEMORY_EMBEDDING_BASE_URL;
   const model = env.AGENT_MEMORY_EMBEDDING_MODEL;
   const dimension = parseDimension(env.AGENT_MEMORY_EMBEDDING_DIMENSION);
-  if (!baseUrl) {
-    throw new Error("AGENT_MEMORY_EMBEDDING_BASE_URL is required when embeddings are enabled");
+  if (!baseUrl && provider !== "gemini") {
+    throw new Error("AGENT_MEMORY_EMBEDDING_BASE_URL is required when embeddings are enabled (not needed for gemini provider)");
   }
   if (!model) {
     throw new Error("AGENT_MEMORY_EMBEDDING_MODEL is required when embeddings are enabled");
@@ -711,9 +752,12 @@ function getEmbeddingProviderConfigFromEnv(env = process.env) {
   if (provider === "openai-compatible" && !env.AGENT_MEMORY_EMBEDDING_API_KEY) {
     throw new Error("AGENT_MEMORY_EMBEDDING_API_KEY is required for openai-compatible providers");
   }
+  if (provider === "gemini" && !env.AGENT_MEMORY_EMBEDDING_API_KEY) {
+    throw new Error("AGENT_MEMORY_EMBEDDING_API_KEY is required for gemini provider (Google AI API key)");
+  }
   return {
     provider,
-    baseUrl,
+    baseUrl: baseUrl ?? "",
     model,
     dimension,
     apiKey: env.AGENT_MEMORY_EMBEDDING_API_KEY
@@ -722,8 +766,17 @@ function getEmbeddingProviderConfigFromEnv(env = process.env) {
 function createEmbeddingProvider(input, opts) {
   const normalized = {
     ...input,
-    baseUrl: normalizeEmbeddingBaseUrl(input.baseUrl)
+    baseUrl: input.baseUrl ? normalizeEmbeddingBaseUrl(input.baseUrl) : ""
   };
+  if (normalized.provider === "gemini") {
+    return createGeminiEmbeddingProvider({
+      model: normalized.model,
+      dimension: normalized.dimension,
+      apiKey: normalized.apiKey,
+      baseUrl: normalized.baseUrl || void 0,
+      fetchImpl: opts?.fetchImpl
+    });
+  }
   if (normalized.provider === "openai-compatible") {
     return createOpenAICompatibleEmbeddingProvider({
       baseUrl: normalized.baseUrl,
@@ -750,13 +803,16 @@ function resolveEmbeddingProviderConfig(opts) {
   const model = opts?.config?.model ?? envConfig?.model;
   const dimension = opts?.config?.dimension ?? envConfig?.dimension;
   const apiKey = opts?.config?.apiKey ?? envConfig?.apiKey;
-  if (!provider || !baseUrl || !model || !dimension) {
+  if (!provider || !model || !dimension) {
     throw new Error("Incomplete embedding provider configuration");
   }
-  if (provider === "openai-compatible" && !apiKey) {
-    throw new Error("OpenAI-compatible embedding providers require an API key");
+  if (provider !== "gemini" && !baseUrl) {
+    throw new Error("baseUrl is required for non-gemini embedding providers");
+  }
+  if ((provider === "openai-compatible" || provider === "gemini") && !apiKey) {
+    throw new Error(`${provider} embedding provider requires an API key`);
   }
-  return { provider, baseUrl, model, dimension, apiKey };
+  return { provider, baseUrl: baseUrl ?? "", model, dimension, apiKey };
 }
 function getEmbeddingProvider(opts) {
   const config = resolveEmbeddingProviderConfig({ config: opts?.config, env: opts?.env });