mr-memory 3.7.4 → 3.7.5

package/index.js

@@ -8,6 +8,7 @@
  * BYOK — provider API keys never touch MemoryRouter.
  */
 import { readFile, lstat, writeFile, copyFile, mkdir } from "node:fs/promises";
+import { deleteMemories, getMemoryStats, ingestMemory, prepareMemory, searchMemory } from "./memoryrouter-api.js";
 import { join, resolve, relative, isAbsolute, sep, dirname } from "node:path";
 import os from "node:os";
 const DEFAULT_ENDPOINT = "https://api.memoryrouter.ai";
@@ -265,9 +266,6 @@ const WORKSPACE_FILES = [
     "IDENTITY.md", "USER.md", "MEMORY.md", "HEARTBEAT.md",
     "TOOLS.md", "AGENTS.md", "SOUL.md", "BOOTSTRAP.md",
 ];
-// ──────────────────────────────────────────────────────
-// Helpers
-// ──────────────────────────────────────────────────────
 function openClawConfigPath() {
     return process.env.OPENCLAW_CONFIG || join(os.homedir(), ".openclaw", "openclaw.json");
 }
@@ -291,7 +289,8 @@ async function writeOpenClawConfigFile(config) {
         if (err?.code !== "ENOENT")
             throw err;
     }
-    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+    await writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
 }
 async function updateOpenClawPluginEntry(api, patch) {
     const config = await readOpenClawConfigFile();
@@ -545,17 +544,10 @@ If setting up MemoryRouter for another agent:
                             contextPayload.push({ role: "user", content: taskPrompt });
                         }
                     }
-                    const res = await fetch(`${endpoint}/v1/memory/prepare`, {
-                        method: "POST",
-                        headers: {
-                            "Content-Type": "application/json",
-                            Authorization: `Bearer ${activeKey}`,
-                        },
-                        body: JSON.stringify({
-                            messages: contextPayload,
-                            density,
-                            ...(embeddings && { embeddings }),
-                        }),
+                    const res = await prepareMemory(endpoint, activeKey, {
+                        messages: contextPayload,
+                        density,
+                        ...(embeddings && { embeddings }),
                     });
                     if (!res.ok) {
                         const errBody = await res.json().catch(() => null);
@@ -650,17 +642,10 @@ If setting up MemoryRouter for another agent:
                         }
                     }
                     // 4. Call /v1/memory/prepare (no session_id — always search core vault)
-                    const res = await fetch(`${endpoint}/v1/memory/prepare`, {
-                        method: "POST",
-                        headers: {
-                            "Content-Type": "application/json",
-                            Authorization: `Bearer ${activeKey}`,
-                        },
-                        body: JSON.stringify({
-                            messages: contextPayload,
-                            density,
-                            ...(embeddings && { embeddings }),
-                        }),
+                    const res = await prepareMemory(endpoint, activeKey, {
+                        messages: contextPayload,
+                        density,
+                        ...(embeddings && { embeddings }),
                     });
                     if (!res.ok) {
                         const errBody = await res.json().catch(() => null);
@@ -762,17 +747,10 @@ If setting up MemoryRouter for another agent:
                         return;
                     }
                     // Fire and forget — don't block message delivery waiting for ingest
-                    fetch(`${endpoint}/v1/memory/ingest`, {
-                        method: "POST",
-                        headers: {
-                            "Content-Type": "application/json",
-                            Authorization: `Bearer ${activeKey}`,
-                        },
-                        body: JSON.stringify({
-                            messages: toStore,
-                            model: "unknown",
-                            ...(embeddings && { embeddings }),
-                        }),
+                    ingestMemory(endpoint, activeKey, {
+                        messages: toStore,
+                        model: "unknown",
+                        ...(embeddings && { embeddings }),
                     }).then(async (res) => {
                         if (!res.ok) {
                             const details = await res.text().catch(() => "");
@@ -822,15 +800,7 @@ If setting up MemoryRouter for another agent:
                             return jsonToolResult({ results: [], error: "query required" });
                         const limit = typeof params.maxResults === "number" ? params.maxResults : 50;
                         try {
-                            const res = await fetch(`${endpoint}/v1/memory/search`, {
-                                method: "POST",
-                                headers: {
-                                    Authorization: `Bearer ${toolKey}`,
-                                    "Content-Type": "application/json",
-                                    ...(embeddings && { "X-Embedding-Model": embeddings }),
-                                },
-                                body: JSON.stringify({ query, limit }),
-                            });
+                            const res = await searchMemory(endpoint, toolKey, { query, limit, embeddings });
                             if (!res.ok) {
                                 const errBody = await res.text().catch(() => "");
                                 return jsonToolResult({ results: [], error: `Search failed: HTTP ${res.status}`, details: errBody.slice(0, 200) });
@@ -1023,12 +993,7 @@ If setting up MemoryRouter for another agent:
                     return;
                 }
                 try {
-                    const statsUrl = embeddings
-                        ? `${endpoint}/v1/memory/stats?embeddings=${encodeURIComponent(embeddings)}`
-                        : `${endpoint}/v1/memory/stats`;
-                    const res = await fetch(statsUrl, {
-                        headers: { Authorization: `Bearer ${effectiveKey}` },
-                    });
+                    const res = await getMemoryStats(endpoint, effectiveKey, embeddings);
                     const data = (await res.json());
                     if (opts.json) {
                         console.log(JSON.stringify({ enabled: true, key: effectiveKey, density, stats: data }, null, 2));
@@ -1086,15 +1051,7 @@ If setting up MemoryRouter for another agent:
                 }
                 const limit = parseInt(opts.limit, 10) || 50;
                 try {
-                    const res = await fetch(`${endpoint}/v1/memory/search`, {
-                        method: "POST",
-                        headers: {
-                            Authorization: `Bearer ${effectiveKey}`,
-                            "Content-Type": "application/json",
-                            ...(embeddings && { "X-Embedding-Model": embeddings }),
-                        },
-                        body: JSON.stringify({ query, limit }),
-                    });
+                    const res = await searchMemory(endpoint, effectiveKey, { query, limit, embeddings });
                     if (!res.ok) {
                         const err = await res.json();
                         console.error(`Search failed: ${err.error || `HTTP ${res.status}`}`);
@@ -1142,13 +1099,7 @@ If setting up MemoryRouter for another agent:
                     return;
                 }
                 try {
-                    const deleteUrl = embeddings
-                        ? `${endpoint}/v1/memory?embeddings=${encodeURIComponent(embeddings)}`
-                        : `${endpoint}/v1/memory`;
-                    const res = await fetch(deleteUrl, {
-                        method: "DELETE",
-                        headers: { Authorization: `Bearer ${effectiveKey}` },
-                    });
+                    const res = await deleteMemories(endpoint, effectiveKey, embeddings);
                     const data = (await res.json());
                     const modelLabel = embeddings ? ` (${embeddings})` : "";
                     console.log(`✓ ${data.message || `Vault cleared${modelLabel}`}`);

package/index.ts

@@ -9,6 +9,7 @@
  */
 
 import { readFile, readdir, stat, lstat, writeFile, copyFile, mkdir } from "node:fs/promises";
+import { deleteMemories, getMemoryStats, ingestMemory, prepareMemory, searchMemory } from "./memoryrouter-api.js";
 import { join, resolve, relative, isAbsolute, sep, dirname } from "node:path";
 import path from "node:path";
 import os from "node:os";
@@ -570,17 +571,10 @@ If setting up MemoryRouter for another agent:
           }
 
 
-          const res = await fetch(`${endpoint}/v1/memory/prepare`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${activeKey}`,
-            },
-            body: JSON.stringify({
-              messages: contextPayload,
-              density,
-              ...(embeddings && { embeddings }),
-            }),
+          const res = await prepareMemory(endpoint, activeKey, {
+            messages: contextPayload,
+            density,
+            ...(embeddings && { embeddings }),
           });
 
           if (!res.ok) {
@@ -686,17 +680,10 @@ If setting up MemoryRouter for another agent:
 
           // 4. Call /v1/memory/prepare (no session_id — always search core vault)
 
-          const res = await fetch(`${endpoint}/v1/memory/prepare`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${activeKey}`,
-            },
-            body: JSON.stringify({
-              messages: contextPayload,
-              density,
-              ...(embeddings && { embeddings }),
-            }),
+          const res = await prepareMemory(endpoint, activeKey, {
+            messages: contextPayload,
+            density,
+            ...(embeddings && { embeddings }),
           });
 
           if (!res.ok) {
@@ -811,17 +798,10 @@ If setting up MemoryRouter for another agent:
           }
 
           // Fire and forget — don't block message delivery waiting for ingest
-          fetch(`${endpoint}/v1/memory/ingest`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${activeKey}`,
-            },
-            body: JSON.stringify({
-              messages: toStore,
-              model: "unknown",
-              ...(embeddings && { embeddings }),
-            }),
+          ingestMemory(endpoint, activeKey, {
+            messages: toStore,
+            model: "unknown",
+            ...(embeddings && { embeddings }),
           }).then(async (res) => {
             if (!res.ok) {
               const details = await res.text().catch(() => "");
@@ -869,15 +849,7 @@ If setting up MemoryRouter for another agent:
             if (!query) return jsonToolResult({ results: [], error: "query required" });
             const limit = typeof params.maxResults === "number" ? params.maxResults : 50;
             try {
-              const res = await fetch(`${endpoint}/v1/memory/search`, {
-                method: "POST",
-                headers: {
-                  Authorization: `Bearer ${toolKey}`,
-                  "Content-Type": "application/json",
-                  ...(embeddings && { "X-Embedding-Model": embeddings }),
-                },
-                body: JSON.stringify({ query, limit }),
-              });
+              const res = await searchMemory(endpoint, toolKey, { query, limit, embeddings });
               if (!res.ok) {
                 const errBody = await res.text().catch(() => "");
                 return jsonToolResult({ results: [], error: `Search failed: HTTP ${res.status}`, details: errBody.slice(0, 200) });
@@ -1075,12 +1047,7 @@ If setting up MemoryRouter for another agent:
               return;
             }
             try {
-              const statsUrl = embeddings
-                ? `${endpoint}/v1/memory/stats?embeddings=${encodeURIComponent(embeddings)}`
-                : `${endpoint}/v1/memory/stats`;
-              const res = await fetch(statsUrl, {
-                headers: { Authorization: `Bearer ${effectiveKey}` },
-              });
+              const res = await getMemoryStats(endpoint, effectiveKey, embeddings);
               const data = (await res.json()) as { totalVectors?: number; totalTokens?: number };
               if (opts.json) {
                 console.log(JSON.stringify({ enabled: true, key: effectiveKey, density, stats: data }, null, 2));
@@ -1132,15 +1099,7 @@ If setting up MemoryRouter for another agent:
             if (!effectiveKey) { console.error("Not configured. Run: openclaw mr <key> or pass --key <key>"); return; }
             const limit = parseInt(opts.limit, 10) || 50;
             try {
-              const res = await fetch(`${endpoint}/v1/memory/search`, {
-                method: "POST",
-                headers: {
-                  Authorization: `Bearer ${effectiveKey}`,
-                  "Content-Type": "application/json",
-                  ...(embeddings && { "X-Embedding-Model": embeddings }),
-                },
-                body: JSON.stringify({ query, limit }),
-              });
+              const res = await searchMemory(endpoint, effectiveKey, { query, limit, embeddings });
               if (!res.ok) {
                 const err = await res.json() as { error?: string };
                 console.error(`Search failed: ${err.error || `HTTP ${res.status}`}`);
@@ -1205,13 +1164,7 @@ If setting up MemoryRouter for another agent:
             const effectiveKey = opts.key || memoryKey;
             if (!effectiveKey) { console.error("Not configured. Run: openclaw mr <key> or pass --key <key>"); return; }
             try {
-              const deleteUrl = embeddings
-                ? `${endpoint}/v1/memory?embeddings=${encodeURIComponent(embeddings)}`
-                : `${endpoint}/v1/memory`;
-              const res = await fetch(deleteUrl, {
-                method: "DELETE",
-                headers: { Authorization: `Bearer ${effectiveKey}` },
-              });
+              const res = await deleteMemories(endpoint, effectiveKey, embeddings);
               const data = (await res.json()) as { message?: string };
               const modelLabel = embeddings ? ` (${embeddings})` : "";
               console.log(`✓ ${data.message || `Vault cleared${modelLabel}`}`);

package/memoryrouter-api.js

@@ -0,0 +1,49 @@
+const JSON_HEADERS = { "Content-Type": "application/json" };
+export async function prepareMemory(endpoint, key, payload) {
+    return fetch(`${endpoint}/v1/memory/prepare`, {
+        method: "POST",
+        headers: {
+            ...JSON_HEADERS,
+            Authorization: `Bearer ${key}`,
+        },
+        body: JSON.stringify(payload),
+    });
+}
+export function ingestMemory(endpoint, key, payload) {
+    return fetch(`${endpoint}/v1/memory/ingest`, {
+        method: "POST",
+        headers: {
+            ...JSON_HEADERS,
+            Authorization: `Bearer ${key}`,
+        },
+        body: JSON.stringify(payload),
+    });
+}
+export async function searchMemory(endpoint, key, payload) {
+    return fetch(`${endpoint}/v1/memory/search`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${key}`,
+            "Content-Type": "application/json",
+            ...(payload.embeddings && { "X-Embedding-Model": payload.embeddings }),
+        },
+        body: JSON.stringify({ query: payload.query, limit: payload.limit }),
+    });
+}
+export async function getMemoryStats(endpoint, key, embeddings) {
+    const statsUrl = embeddings
+        ? `${endpoint}/v1/memory/stats?embeddings=${encodeURIComponent(embeddings)}`
+        : `${endpoint}/v1/memory/stats`;
+    return fetch(statsUrl, {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+}
+export async function deleteMemories(endpoint, key, embeddings) {
+    const deleteUrl = embeddings
+        ? `${endpoint}/v1/memory?embeddings=${encodeURIComponent(embeddings)}`
+        : `${endpoint}/v1/memory`;
+    return fetch(deleteUrl, {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${key}` },
+    });
+}

package/memoryrouter-api.ts

@@ -0,0 +1,60 @@
+const JSON_HEADERS = { "Content-Type": "application/json" };
+
+type PreparePayload = {
+  messages: Array<{ role: string; content: string }>;
+  density: string;
+  embeddings?: string;
+};
+
+export async function prepareMemory(endpoint: string, key: string, payload: PreparePayload): Promise<Response> {
+  return fetch(`${endpoint}/v1/memory/prepare`, {
+    method: "POST",
+    headers: {
+      ...JSON_HEADERS,
+      Authorization: `Bearer ${key}`,
+    },
+    body: JSON.stringify(payload),
+  });
+}
+
+export function ingestMemory(endpoint: string, key: string, payload: { messages: Array<{ role: string; content: string }>; model: string; embeddings?: string }): Promise<Response> {
+  return fetch(`${endpoint}/v1/memory/ingest`, {
+    method: "POST",
+    headers: {
+      ...JSON_HEADERS,
+      Authorization: `Bearer ${key}`,
+    },
+    body: JSON.stringify(payload),
+  });
+}
+
+export async function searchMemory(endpoint: string, key: string, payload: { query: string; limit: number; embeddings?: string }): Promise<Response> {
+  return fetch(`${endpoint}/v1/memory/search`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${key}`,
+      "Content-Type": "application/json",
+      ...(payload.embeddings && { "X-Embedding-Model": payload.embeddings }),
+    },
+    body: JSON.stringify({ query: payload.query, limit: payload.limit }),
+  });
+}
+
+export async function getMemoryStats(endpoint: string, key: string, embeddings?: string): Promise<Response> {
+  const statsUrl = embeddings
+    ? `${endpoint}/v1/memory/stats?embeddings=${encodeURIComponent(embeddings)}`
+    : `${endpoint}/v1/memory/stats`;
+  return fetch(statsUrl, {
+    headers: { Authorization: `Bearer ${key}` },
+  });
+}
+
+export async function deleteMemories(endpoint: string, key: string, embeddings?: string): Promise<Response> {
+  const deleteUrl = embeddings
+    ? `${endpoint}/v1/memory?embeddings=${encodeURIComponent(embeddings)}`
+    : `${endpoint}/v1/memory`;
+  return fetch(deleteUrl, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${key}` },
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mr-memory",
-  "version": "3.7.4",
+  "version": "3.7.5",
   "description": "mr-memory is the MemoryRouter plugin for OpenClaw — persistent memory across every conversation",
   "type": "module",
   "files": [
@@ -9,6 +9,10 @@
     "upload.js",
     "index.ts",
     "upload.ts",
+    "memoryrouter-api.js",
+    "memoryrouter-api.ts",
+    "upload-api.js",
+    "upload-api.ts",
     "openclaw.plugin.json"
   ],
   "keywords": [

package/upload-api.js

@@ -0,0 +1,40 @@
+const MAX_HTTP_RETRIES = 3;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function checkMemoryRouterHealth(endpoint) {
+    try {
+        const res = await fetch(`${endpoint}/health`, { signal: AbortSignal.timeout(5000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function uploadMemoryBatch(params) {
+    const uploadUrl = `${params.endpoint}/v1/memory/upload`;
+    let lastError = null;
+    for (let attempt = 1; attempt <= MAX_HTTP_RETRIES; attempt++) {
+        try {
+            const res = await fetch(uploadUrl, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${params.memoryKey}`,
+                    "Content-Type": "text/plain",
+                    ...(params.embeddings && { "X-Embedding-Model": params.embeddings }),
+                },
+                body: params.jsonlBody,
+                signal: AbortSignal.timeout(30000),
+            });
+            if (res.ok || res.status < 500)
+                return res;
+            lastError = new Error(`HTTP ${res.status}`);
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+        }
+        if (attempt < MAX_HTTP_RETRIES)
+            await sleep(1000 * attempt);
+    }
+    throw lastError ?? new Error(`${params.label}: failed after ${MAX_HTTP_RETRIES} attempts`);
+}

package/upload-api.ts

@@ -0,0 +1,45 @@
+const MAX_HTTP_RETRIES = 3;
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function checkMemoryRouterHealth(endpoint: string): Promise<boolean> {
+  try {
+    const res = await fetch(`${endpoint}/health`, { signal: AbortSignal.timeout(5000) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function uploadMemoryBatch(params: {
+  endpoint: string;
+  memoryKey: string;
+  jsonlBody: string;
+  embeddings?: string;
+  label: string;
+}): Promise<Response> {
+  const uploadUrl = `${params.endpoint}/v1/memory/upload`;
+  let lastError: Error | null = null;
+  for (let attempt = 1; attempt <= MAX_HTTP_RETRIES; attempt++) {
+    try {
+      const res = await fetch(uploadUrl, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${params.memoryKey}`,
+          "Content-Type": "text/plain",
+          ...(params.embeddings && { "X-Embedding-Model": params.embeddings }),
+        },
+        body: params.jsonlBody,
+        signal: AbortSignal.timeout(30000),
+      });
+      if (res.ok || res.status < 500) return res;
+      lastError = new Error(`HTTP ${res.status}`);
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+    }
+    if (attempt < MAX_HTTP_RETRIES) await sleep(1000 * attempt);
+  }
+  throw lastError ?? new Error(`${params.label}: failed after ${MAX_HTTP_RETRIES} attempts`);
+}

package/upload.js

@@ -3,6 +3,7 @@
  */
 import fs from "node:fs/promises";
 import path from "node:path";
+import { checkMemoryRouterHealth, uploadMemoryBatch } from "./upload-api.js";
 // ── Sanitization utilities (shared with index.ts ingest logic)
 // These MUST stay in sync with the patterns in index.ts
 const MEMORY_TAG_RE = /<mr-memory>[\s\S]*?<\/mr-memory>\s*/g;
@@ -132,7 +133,6 @@ const MAX_BATCH_BYTES = 2_000_000;
 const MAX_BATCH_COUNT_DEFAULT = 100;
 const MAX_BATCH_COUNT_QWEN = 25;
 const BATCH_SLEEP_MS = 150;
-const MAX_HTTP_RETRIES = 3;
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -302,33 +302,10 @@ async function discoverBrainFiles(stateDir) {
     }
     return files;
 }
-async function fetchWithRetry(url, init, label) {
-    let lastError = null;
-    for (let attempt = 1; attempt <= MAX_HTTP_RETRIES; attempt++) {
-        try {
-            const res = await fetch(url, { ...init, signal: AbortSignal.timeout(30000) });
-            if (res.ok || res.status < 500)
-                return res;
-            lastError = new Error(`HTTP ${res.status}`);
-        }
-        catch (err) {
-            lastError = err instanceof Error ? err : new Error(String(err));
-        }
-        if (attempt < MAX_HTTP_RETRIES)
-            await sleep(1000 * attempt);
-    }
-    throw lastError ?? new Error(`${label}: failed after ${MAX_HTTP_RETRIES} attempts`);
-}
 export async function runUpload(params) {
     const { memoryKey, endpoint, targetPath, stateDir, embeddings } = params;
-    const uploadUrl = `${endpoint}/v1/memory/upload`;
     // Validate API reachability
-    try {
-        const res = await fetch(`${endpoint}/health`, { signal: AbortSignal.timeout(5000) });
-        if (!res.ok)
-            throw new Error(`HTTP ${res.status}`);
-    }
-    catch {
+    if (!(await checkMemoryRouterHealth(endpoint))) {
         console.error("Error: Could not reach MemoryRouter API.");
         return;
     }
@@ -427,15 +404,13 @@ export async function runUpload(params) {
             process.stdout.write(`  Batch ${i + 1}/${batches.length} (${batch.length} items)... `);
         }
         try {
-            const response = await fetchWithRetry(uploadUrl, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${memoryKey}`,
-                    "Content-Type": "text/plain",
-                    ...(embeddings && { "X-Embedding-Model": embeddings }),
-                },
-                body: jsonlBody,
-            }, `Batch ${i + 1}`);
+            const response = await uploadMemoryBatch({
+                endpoint,
+                memoryKey,
+                jsonlBody,
+                embeddings,
+                label: `Batch ${i + 1}`,
+            });
             const result = (await response.json());
             const batchStored = result.stats?.stored ?? result.stats?.inputItems ?? batch.length;
             const batchFailed = result.stats?.failed ?? 0;

package/upload.ts

@@ -4,6 +4,7 @@
 
 import fs from "node:fs/promises";
 import path from "node:path";
+import { checkMemoryRouterHealth, uploadMemoryBatch } from "./upload-api.js";
 
 // ── Sanitization utilities (shared with index.ts ingest logic)
 // These MUST stay in sync with the patterns in index.ts
@@ -146,7 +147,6 @@ const MAX_BATCH_BYTES = 2_000_000;
 const MAX_BATCH_COUNT_DEFAULT = 100;
 const MAX_BATCH_COUNT_QWEN = 25;
 const BATCH_SLEEP_MS = 150;
-const MAX_HTTP_RETRIES = 3;
 
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -327,25 +327,6 @@ async function discoverBrainFiles(stateDir: string): Promise<string[]> {
   return files;
 }
 
-async function fetchWithRetry(
-  url: string,
-  init: RequestInit,
-  label: string,
-): Promise<Response> {
-  let lastError: Error | null = null;
-  for (let attempt = 1; attempt <= MAX_HTTP_RETRIES; attempt++) {
-    try {
-      const res = await fetch(url, { ...init, signal: AbortSignal.timeout(30000) });
-      if (res.ok || res.status < 500) return res;
-      lastError = new Error(`HTTP ${res.status}`);
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-    }
-    if (attempt < MAX_HTTP_RETRIES) await sleep(1000 * attempt);
-  }
-  throw lastError ?? new Error(`${label}: failed after ${MAX_HTTP_RETRIES} attempts`);
-}
-
 export async function runUpload(params: {
   memoryKey: string;
   endpoint: string;
@@ -357,13 +338,8 @@ export async function runUpload(params: {
   embeddings?: string;
 }): Promise<void> {
   const { memoryKey, endpoint, targetPath, stateDir, embeddings } = params;
-  const uploadUrl = `${endpoint}/v1/memory/upload`;
-
   // Validate API reachability
-  try {
-    const res = await fetch(`${endpoint}/health`, { signal: AbortSignal.timeout(5000) });
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-  } catch {
+  if (!(await checkMemoryRouterHealth(endpoint))) {
     console.error("Error: Could not reach MemoryRouter API.");
     return;
   }
@@ -467,19 +443,13 @@ export async function runUpload(params: {
     }
 
     try {
-      const response = await fetchWithRetry(
-        uploadUrl,
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${memoryKey}`,
-            "Content-Type": "text/plain",
-            ...(embeddings && { "X-Embedding-Model": embeddings }),
-          },
-          body: jsonlBody,
-        },
-        `Batch ${i + 1}`,
-      );
+      const response = await uploadMemoryBatch({
+        endpoint,
+        memoryKey,
+        jsonlBody,
+        embeddings,
+        label: `Batch ${i + 1}`,
+      });
 
       const result = (await response.json()) as {
         stats?: { stored?: number; failed?: number; inputItems?: number; path?: string; diagnostic?: string };