@prom.codes/memory-mcp 0.9.1 → 0.10.1

package/dist/bin.js

@@ -871,11 +871,192 @@ var VoyageRerankProvider = class {
   }
 };
 
-// ../rerank-openai-compat/dist/index.js
-var DEFAULT_MODEL2 = "bge-reranker-base";
+// ../rerank-prometheus/dist/index.js
+var DEFAULT_BASE2 = "https://api.prom.codes";
+var DEFAULT_NAME = "prometheus";
+var DEFAULT_MODEL2 = "prometheus";
 var DEFAULT_BATCH4 = 100;
-var DEFAULT_RETRIES4 = 6;
-var DEFAULT_BACKOFF4 = 2e3;
+var DEFAULT_BATCH_CHARS2 = 4e5;
+var DEFAULT_RETRIES4 = 4;
+var DEFAULT_BACKOFF4 = 250;
+function sleep4(ms, signal) {
+  return new Promise((resolve3, reject) => {
+    if (signal?.aborted === true) {
+      reject(new Error("aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve3();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function nonRetryable4(message) {
+  const err = new Error(message);
+  err.nonRetryable = true;
+  return err;
+}
+var PrometheusRerankProvider = class {
+  name;
+  model;
+  region;
+  #apiKey;
+  #url;
+  #batchSize;
+  #maxBatchChars;
+  #maxRetries;
+  #retryBaseMs;
+  #fetch;
+  #creditsUsed = 0;
+  constructor(opts) {
+    if (typeof opts.apiKey !== "string" || opts.apiKey === "") {
+      throw new Error("PrometheusRerankProvider: apiKey is required");
+    }
+    if (opts.batchSize !== void 0 && (!Number.isInteger(opts.batchSize) || opts.batchSize <= 0 || opts.batchSize > 1e3)) {
+      throw new Error(`PrometheusRerankProvider: batchSize must be an integer in 1..1000, got ${opts.batchSize}`);
+    }
+    this.name = opts.name ?? DEFAULT_NAME;
+    this.model = opts.model ?? DEFAULT_MODEL2;
+    this.region = opts.region ?? "eu";
+    this.#apiKey = opts.apiKey;
+    this.#url = `${(opts.baseUrl ?? DEFAULT_BASE2).replace(/\/+$/, "")}/rerank`;
+    this.#batchSize = opts.batchSize ?? DEFAULT_BATCH4;
+    this.#maxBatchChars = opts.maxBatchChars ?? DEFAULT_BATCH_CHARS2;
+    this.#maxRetries = opts.maxRetries ?? DEFAULT_RETRIES4;
+    this.#retryBaseMs = opts.retryBaseMs ?? DEFAULT_BACKOFF4;
+    this.#fetch = opts.fetch ?? fetch;
+  }
+  /** Cumulative credits charged across all rerank calls of this instance. */
+  get creditsUsed() {
+    return this.#creditsUsed;
+  }
+  async rerank(query, candidates, opts) {
+    if (candidates.length === 0)
+      return [];
+    const all = new Array(candidates.length);
+    let cursor = 0;
+    let start = 0;
+    while (start < candidates.length) {
+      const end = this.#batchEnd(query, candidates, start);
+      const slice = candidates.slice(start, end);
+      const scored = await this.#rerankBatch(query, slice, opts?.signal);
+      for (const hit of scored) {
+        const globalIndex = start + hit.localIndex;
+        const cand = candidates[globalIndex];
+        all[cursor++] = { id: cand.id, index: globalIndex, score: hit.score };
+      }
+      start = end;
+    }
+    all.length = cursor;
+    all.sort((a, b) => b.score - a.score);
+    if (opts?.topK !== void 0 && opts.topK >= 0 && opts.topK < all.length) {
+      return all.slice(0, opts.topK);
+    }
+    return all;
+  }
+  /**
+   * Greedy batch cut honouring both the document-count cap and the
+   * char budget (query + documents must stay under the proxy limit).
+   * Always advances by at least one candidate, even if a single
+   * document alone exceeds the budget (the proxy applies upstream
+   * truncation; refusing to send it would strand the rest).
+   */
+  #batchEnd(query, candidates, start) {
+    let chars = query.length;
+    let end = start;
+    while (end < candidates.length && end - start < this.#batchSize) {
+      const len = candidates[end].text.length;
+      if (end > start && chars + len > this.#maxBatchChars)
+        break;
+      chars += len;
+      end += 1;
+    }
+    return end;
+  }
+  async #rerankBatch(query, batch, signal) {
+    const init = {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.#apiKey}`
+      },
+      body: JSON.stringify({ query, documents: batch.map((c) => c.text) })
+    };
+    if (signal !== void 0)
+      init.signal = signal;
+    const payload = await this.#requestJson(init, signal);
+    if (payload?.ok !== true || !Array.isArray(payload.results)) {
+      throw nonRetryable4("prometheus-rerank: malformed rerank response");
+    }
+    if (payload.results.length !== batch.length) {
+      throw nonRetryable4(`prometheus-rerank: expected ${batch.length} rerank rows, got ${payload.results.length}`);
+    }
+    const credits = payload.usage?.credits;
+    if (typeof credits === "number" && Number.isFinite(credits)) {
+      this.#creditsUsed += credits;
+    }
+    return payload.results.map((row) => {
+      if (!Number.isInteger(row.index) || row.index < 0 || row.index >= batch.length) {
+        throw nonRetryable4(`prometheus-rerank: invalid index ${row.index} in rerank response`);
+      }
+      if (typeof row.relevanceScore !== "number" || !Number.isFinite(row.relevanceScore)) {
+        throw nonRetryable4(`prometheus-rerank: invalid relevanceScore ${row.relevanceScore} at index ${row.index}`);
+      }
+      return { localIndex: row.index, score: row.relevanceScore };
+    });
+  }
+  /**
+   * Fetch with retry. 5xx and network errors back off exponentially;
+   * everything else (401 invalid key, 413 oversized input, 429 monthly
+   * quota exhausted) fails fast with the proxy's error code in the
+   * message.
+   */
+  async #requestJson(init, signal) {
+    let attempt = 0;
+    let lastError = null;
+    while (attempt <= this.#maxRetries) {
+      try {
+        const res = await this.#fetch(this.#url, init);
+        if (res.status >= 500 && res.status < 600) {
+          lastError = new Error(`prometheus-rerank: HTTP ${res.status}`);
+          attempt += 1;
+          if (attempt > this.#maxRetries)
+            break;
+          await sleep4(this.#retryBaseMs * 2 ** (attempt - 1), signal);
+          continue;
+        }
+        if (!res.ok) {
+          const body = await res.json().catch(() => null);
+          const detail = typeof body?.code === "string" ? `${body.code}${typeof body.error === "string" ? ` \u2014 ${body.error}` : ""}` : res.statusText;
+          throw nonRetryable4(`prometheus-rerank: HTTP ${res.status} ${detail}`);
+        }
+        return await res.json();
+      } catch (err) {
+        if (err?.name === "AbortError")
+          throw err;
+        if (err?.nonRetryable === true)
+          throw err;
+        if (attempt >= this.#maxRetries)
+          throw err;
+        lastError = err;
+        attempt += 1;
+        await sleep4(this.#retryBaseMs * 2 ** (attempt - 1), signal);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(`prometheus-rerank: exhausted ${this.#maxRetries} retries`);
+  }
+};
+
+// ../rerank-openai-compat/dist/index.js
+var DEFAULT_MODEL3 = "bge-reranker-base";
+var DEFAULT_BATCH5 = 100;
+var DEFAULT_RETRIES5 = 6;
+var DEFAULT_BACKOFF5 = 2e3;
 var DEFAULT_RETRY_MAX3 = 6e4;
 var DEFAULT_TIMEOUT = 18e4;
 function parseRetryAfterMs3(value, now = Date.now()) {
@@ -898,7 +1079,7 @@ function parseRetryAfterMs3(value, now = Date.now()) {
   const delta = ts - now;
   return delta > 0 ? delta : 0;
 }
-function sleep4(ms, signal) {
+function sleep5(ms, signal) {
   return new Promise((resolve3, reject) => {
     if (signal?.aborted === true) {
       reject(new Error("aborted"));
@@ -915,7 +1096,7 @@ function sleep4(ms, signal) {
     signal?.addEventListener("abort", onAbort, { once: true });
   });
 }
-function nonRetryable4(message) {
+function nonRetryable5(message) {
   const err = new Error(message);
   err.nonRetryable = true;
   return err;
@@ -942,14 +1123,14 @@ var OpenAICompatRerankProvider = class {
     if (opts.timeoutMs !== void 0 && (!Number.isInteger(opts.timeoutMs) || opts.timeoutMs < 0)) {
       throw new Error(`OpenAICompatRerankProvider: timeoutMs must be a non-negative integer (0 disables), got ${opts.timeoutMs}`);
     }
-    this.model = opts.model ?? DEFAULT_MODEL2;
+    this.model = opts.model ?? DEFAULT_MODEL3;
     this.name = opts.name ?? `openai-compat:${this.model}`;
     this.region = opts.region ?? "self-hosted";
     this.#baseUrl = opts.baseUrl.replace(/\/+$/, "");
     this.#apiKey = opts.apiKey === void 0 || opts.apiKey === "" ? void 0 : opts.apiKey;
-    this.#batchSize = opts.batchSize ?? DEFAULT_BATCH4;
-    this.#maxRetries = opts.maxRetries ?? DEFAULT_RETRIES4;
-    this.#retryBaseMs = opts.retryBaseMs ?? DEFAULT_BACKOFF4;
+    this.#batchSize = opts.batchSize ?? DEFAULT_BATCH5;
+    this.#maxRetries = opts.maxRetries ?? DEFAULT_RETRIES5;
+    this.#retryBaseMs = opts.retryBaseMs ?? DEFAULT_BACKOFF5;
     this.#retryMaxMs = opts.retryMaxMs ?? DEFAULT_RETRY_MAX3;
     this.#timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT;
     this.#fetch = opts.fetch ?? fetch;
@@ -1018,12 +1199,12 @@ var OpenAICompatRerankProvider = class {
           if (attempt > this.#maxRetries)
             break;
           const backoff = this.#computeBackoff(attempt, res.headers.get("retry-after"));
-          await sleep4(backoff, signal);
+          await sleep5(backoff, signal);
           continue;
         }
         if (!res.ok) {
           const text = await res.text().catch(() => "");
-          throw nonRetryable4(`${this.name}: HTTP ${res.status} ${res.statusText}${text === "" ? "" : ` \u2014 ${text}`}`);
+          throw nonRetryable5(`${this.name}: HTTP ${res.status} ${res.statusText}${text === "" ? "" : ` \u2014 ${text}`}`);
         }
         const payload = await res.json();
         return this.#decode(payload, batch.length);
@@ -1038,7 +1219,7 @@ var OpenAICompatRerankProvider = class {
           throw normalized;
         lastError = normalized;
         attempt += 1;
-        await sleep4(this.#computeBackoff(attempt, null), signal);
+        await sleep5(this.#computeBackoff(attempt, null), signal);
       } finally {
         if (timer !== void 0)
           clearTimeout(timer);
@@ -1056,14 +1237,14 @@ var OpenAICompatRerankProvider = class {
   }
   #decode(payload, expected) {
     if (!Array.isArray(payload.results) || payload.results.length !== expected) {
-      throw nonRetryable4(`${this.name}: expected ${expected} rerank rows, got ${payload.results?.length ?? 0}`);
+      throw nonRetryable5(`${this.name}: expected ${expected} rerank rows, got ${payload.results?.length ?? 0}`);
     }
     return payload.results.map((row) => {
       if (!Number.isInteger(row.index) || row.index < 0 || row.index >= expected) {
-        throw nonRetryable4(`${this.name}: invalid index ${row.index} in rerank response`);
+        throw nonRetryable5(`${this.name}: invalid index ${row.index} in rerank response`);
       }
       if (typeof row.relevance_score !== "number" || !Number.isFinite(row.relevance_score)) {
-        throw nonRetryable4(`${this.name}: invalid relevance_score ${row.relevance_score} at index ${row.index}`);
+        throw nonRetryable5(`${this.name}: invalid relevance_score ${row.relevance_score} at index ${row.index}`);
       }
       return { localIndex: row.index, score: row.relevance_score };
     });
@@ -2107,9 +2288,25 @@ function discoverMemoryEmbedder(env) {
   return { id: "none", embedder: void 0 };
 }
 function discoverMemoryReranker(env) {
-  const forced = (env.PROMETHEUS_MEMORY_RERANK_PROVIDER ?? "none").toLowerCase();
-  if (forced === "" || forced === "none")
+  const explicit = env.PROMETHEUS_MEMORY_RERANK_PROVIDER?.toLowerCase();
+  const hasKey = (env[API_KEY_ENV] ?? "").trim() !== "";
+  const forced = explicit === void 0 || explicit === "" ? hasKey ? "prometheus" : "none" : explicit;
+  if (forced === "none")
     return { id: "none", provider: null };
+  if (forced === "prometheus") {
+    const apiKey = requireApiKey(env);
+    const baseUrl = env.PROMETHEUS_API_URL;
+    const provider = new PrometheusRerankProvider({
+      name: "prometheus-rerank",
+      apiKey,
+      region: "eu",
+      ...baseUrl !== void 0 && baseUrl !== "" ? { baseUrl } : {},
+      maxRetries: intEnv(env, "PROMETHEUS_MEMORY_RERANK_MAX_RETRIES", 4),
+      retryBaseMs: intEnv(env, "PROMETHEUS_MEMORY_RERANK_RETRY_BASE_MS", 250),
+      batchSize: intEnv(env, "PROMETHEUS_MEMORY_RERANK_BATCH", 100)
+    });
+    return { id: "prometheus", provider };
+  }
   if (forced === "voyage") {
     const apiKey = env.VOYAGE_API_KEY;
     if (apiKey === void 0 || apiKey === "") {
@@ -2146,7 +2343,7 @@ function discoverMemoryReranker(env) {
     });
     return { id: "bge", provider };
   }
-  throw new Error(`unknown PROMETHEUS_MEMORY_RERANK_PROVIDER="${forced}" (expected "none", "voyage", or "bge")`);
+  throw new Error(`unknown PROMETHEUS_MEMORY_RERANK_PROVIDER="${forced}" (expected "none", "prometheus", "voyage", or "bge")`);
 }
 function discoverMemoryExtractor(env) {
   const forced = (env.PROMETHEUS_MEMORY_EXTRACT_PROVIDER ?? "none").toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prom.codes/memory-mcp",
-  "version": "0.9.1",
+  "version": "0.10.1",
   "description": "prom.codes Memory — persistent, local-first agent memory as an MCP server.",
   "type": "module",
   "bin": {