@smyslenny/agent-memory 4.2.0 → 4.3.1

package/README.md

@@ -22,7 +22,7 @@ AgentMemory is a SQLite-first memory layer for AI agents. It lets an agent:
 - **maintain** them over time with `reflect`, `reindex`, and feedback signals
 - **integrate** through **CLI**, **MCP stdio**, or **HTTP/SSE**
 
-Current release: **`4.0.0-alpha.1`**.
+Current release: **`4.3.0`**.
 
 Without an embedding provider, AgentMemory still works in **BM25-only mode**.
 With one configured, it adds **hybrid recall** and **semantic dedup**.

package/dist/bin/agent-memory.js

@@ -691,12 +691,54 @@ function createLocalHttpEmbeddingProvider(opts) {
     }
   };
 }
+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);
 }
+var GEMINI_DEFAULT_BASE_URL;
 var init_embedding = __esm({
   "src/search/embedding.ts"() {
     "use strict";
+    GEMINI_DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com";
   }
 });
 
@@ -708,7 +750,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}`);
@@ -719,8 +761,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");
@@ -731,9 +773,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
@@ -742,8 +787,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,
@@ -770,13 +824,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 });