test: pre-register memory embedding adapters

extensions/memory-core/src/memory/embedding-manager.test-harness.ts

@@ -7,6 +7,8 @@ import type { MemoryIndexManager } from "./index.js";
 
 type EmbeddingTestMocksModule = typeof import("./embedding.test-mocks.js");
 type MemoryIndexModule = typeof import("./index.js");
+type MemoryEmbeddingProvidersModule =
+  typeof import("../../../../src/plugins/memory-embedding-providers.js");
 type MemorySearchManagerHandle = Awaited<
   ReturnType<MemoryIndexModule["getMemorySearchManager"]>
 >["manager"];
@@ -32,6 +34,13 @@ export function installEmbeddingManagerFixture(opts: {
   let embedBatch: Mock<(texts: string[]) => Promise<number[][]>> | undefined;
   let getMemorySearchManager: MemoryIndexModule["getMemorySearchManager"];
   let resetEmbeddingMocks: EmbeddingTestMocksModule["resetEmbeddingMocks"];
+  let clearRegistry: MemoryEmbeddingProvidersModule["clearMemoryEmbeddingProviders"];
+  let registerAdapter: MemoryEmbeddingProvidersModule["registerMemoryEmbeddingProvider"];
+  let restoreRegistry: MemoryEmbeddingProvidersModule["restoreRegisteredMemoryEmbeddingProviders"];
+  let listRegistry: MemoryEmbeddingProvidersModule["listRegisteredMemoryEmbeddingProviders"];
+  let originalRegistry:
+    | ReturnType<MemoryEmbeddingProvidersModule["listRegisteredMemoryEmbeddingProviders"]>
+    | undefined;
 
   const resetManager = (manager: MemoryIndexManager) => {
     (manager as unknown as { resetIndex: () => void }).resetIndex();
@@ -65,6 +74,21 @@ export function installEmbeddingManagerFixture(opts: {
     embedBatch = embeddingMocks.getEmbedBatchMock();
     resetEmbeddingMocks = embeddingMocks.resetEmbeddingMocks;
     ({ getMemorySearchManager } = await import("./index.js"));
+    ({
+      clearMemoryEmbeddingProviders: clearRegistry,
+      registerMemoryEmbeddingProvider: registerAdapter,
+      restoreRegisteredMemoryEmbeddingProviders: restoreRegistry,
+      listRegisteredMemoryEmbeddingProviders: listRegistry,
+    } = await import("../../../../src/plugins/memory-embedding-providers.js"));
+    const savedRegistry = listRegistry();
+    clearRegistry();
+    registerAdapter({
+      id: "openai",
+      defaultModel: "mock-embed",
+      transport: "remote",
+      create: async () => ({ provider: null }),
+    });
+    originalRegistry = savedRegistry;
     fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), opts.fixturePrefix));
     workspaceDir = path.join(fixtureRoot, "workspace");
     memoryDir = path.join(workspaceDir, "memory");
@@ -109,6 +133,12 @@ export function installEmbeddingManagerFixture(opts: {
       await fs.rm(fixtureRoot, { recursive: true, force: true });
       fixtureRoot = undefined;
     }
+    if (originalRegistry) {
+      restoreRegistry(originalRegistry);
+      originalRegistry = undefined;
+    } else {
+      clearRegistry();
+    }
   });
 
   beforeEach(async () => {

extensions/memory-core/src/memory/manager.atomic-reindex.test.ts

@@ -10,6 +10,8 @@ let shouldFail = false;
 type EmbeddingTestMocksModule = typeof import("./embedding.test-mocks.js");
 type TestManagerHelpersModule = typeof import("./test-manager-helpers.js");
 type MemoryIndexModule = typeof import("./index.js");
+type MemoryEmbeddingProvidersModule =
+  typeof import("../../../../src/plugins/memory-embedding-providers.js");
 
 describe("memory manager atomic reindex", () => {
   let fixtureRoot = "";
@@ -21,6 +23,8 @@ describe("memory manager atomic reindex", () => {
   let resetEmbeddingMocks: EmbeddingTestMocksModule["resetEmbeddingMocks"];
   let getRequiredMemoryIndexManager: TestManagerHelpersModule["getRequiredMemoryIndexManager"];
   let closeAllMemorySearchManagers: MemoryIndexModule["closeAllMemorySearchManagers"];
+  let clearRegistry: MemoryEmbeddingProvidersModule["clearMemoryEmbeddingProviders"];
+  let registerAdapter: MemoryEmbeddingProvidersModule["registerMemoryEmbeddingProvider"];
 
   beforeAll(async () => {
     vi.resetModules();
@@ -29,11 +33,22 @@ describe("memory manager atomic reindex", () => {
     resetEmbeddingMocks = embeddingMocks.resetEmbeddingMocks;
     ({ getRequiredMemoryIndexManager } = await import("./test-manager-helpers.js"));
     ({ closeAllMemorySearchManagers } = await import("./index.js"));
+    ({
+      clearMemoryEmbeddingProviders: clearRegistry,
+      registerMemoryEmbeddingProvider: registerAdapter,
+    } = await import("../../../../src/plugins/memory-embedding-providers.js"));
     fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-mem-atomic-"));
   });
 
   beforeEach(async () => {
     vi.stubEnv("OPENCLAW_TEST_MEMORY_UNSAFE_REINDEX", "0");
+    clearRegistry();
+    registerAdapter({
+      id: "openai",
+      defaultModel: "mock-embed",
+      transport: "remote",
+      create: async () => ({ provider: null }),
+    });
     resetEmbeddingMocks();
     shouldFail = false;
     embedBatch.mockImplementation(async (texts: string[]) => {
@@ -55,6 +70,7 @@ describe("memory manager atomic reindex", () => {
       manager = null;
     }
     await closeAllMemorySearchManagers();
+    clearRegistry();
     vi.unstubAllEnvs();
   });
 
@@ -75,7 +91,7 @@ describe("memory manager atomic reindex", () => {
           memorySearch: {
             provider: "openai",
             model: "mock-embed",
-            store: { path: indexPath },
+            store: { path: indexPath, vector: { enabled: false } },
             cache: { enabled: false },
             // Perf: keep test indexes to a single chunk to reduce sqlite work.
             chunking: { tokens: 4000, overlap: 0 },

extensions/memory-core/src/memory/manager.mistral-provider.test.ts

@@ -3,26 +3,43 @@ import os from "node:os";
 import path from "node:path";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/memory-core-host-engine-foundation";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { DEFAULT_OLLAMA_EMBEDDING_MODEL } from "./embeddings.js";
-import type {
-  EmbeddingProvider,
-  EmbeddingProviderRuntime,
-  EmbeddingProviderResult,
-} from "./embeddings.js";
 import type { MemoryIndexManager } from "./index.js";
 type MemoryIndexModule = typeof import("./index.js");
+type MemoryEmbeddingProvidersModule =
+  typeof import("../../../../src/plugins/memory-embedding-providers.js");
+
+const DEFAULT_OLLAMA_EMBEDDING_MODEL = "nomic-embed-text";
+
+type EmbeddingProvider = {
+  id: string;
+  model: string;
+  embedQuery: (text: string) => Promise<number[]>;
+  embedBatch: (texts: string[]) => Promise<number[][]>;
+};
+
+type EmbeddingProviderRuntime = {
+  id: string;
+  cacheKeyData: { provider: string; model: string };
+};
+
+type EmbeddingProviderResult = {
+  requestedProvider: string;
+  provider: EmbeddingProvider | null;
+  fallbackFrom?: string;
+  fallbackReason?: string;
+  providerUnavailableReason?: string;
+  runtime?: EmbeddingProviderRuntime;
+};
 
 const { createEmbeddingProviderMock } = vi.hoisted(() => ({
   createEmbeddingProviderMock: vi.fn(),
 }));
 
-vi.mock("./embeddings.js", async () => {
-  const actual = await vi.importActual<typeof import("./embeddings.js")>("./embeddings.js");
-  return {
-    ...actual,
-    createEmbeddingProvider: createEmbeddingProviderMock,
-  };
-});
+vi.mock("./embeddings.js", () => ({
+  createEmbeddingProvider: createEmbeddingProviderMock,
+  resolveEmbeddingProviderFallbackModel: (providerId: string, fallbackSourceModel: string) =>
+    providerId === "ollama" ? DEFAULT_OLLAMA_EMBEDDING_MODEL : fallbackSourceModel,
+}));
 
 vi.mock("./sqlite-vec.js", () => ({
   loadSqliteVecExtension: async () => ({ ok: false, error: "sqlite-vec disabled in tests" }),
@@ -76,15 +93,40 @@ describe("memory manager mistral provider wiring", () => {
   let workspaceDir = "";
   let indexPath = "";
   let manager: MemoryIndexManager | null = null;
+  let clearRegistry: MemoryEmbeddingProvidersModule["clearMemoryEmbeddingProviders"];
+  let registerAdapter: MemoryEmbeddingProvidersModule["registerMemoryEmbeddingProvider"];
 
   beforeAll(async () => {
     vi.resetModules();
     ({ getMemorySearchManager, closeAllMemorySearchManagers } = await import("./index.js"));
+    ({
+      clearMemoryEmbeddingProviders: clearRegistry,
+      registerMemoryEmbeddingProvider: registerAdapter,
+    } = await import("../../../../src/plugins/memory-embedding-providers.js"));
   });
 
   beforeEach(async () => {
     vi.clearAllMocks();
     createEmbeddingProviderMock.mockReset();
+    clearRegistry();
+    registerAdapter({
+      id: "openai",
+      defaultModel: "text-embedding-3-small",
+      transport: "remote",
+      create: async () => ({ provider: null }),
+    });
+    registerAdapter({
+      id: "mistral",
+      defaultModel: "mistral-embed",
+      transport: "remote",
+      create: async () => ({ provider: null }),
+    });
+    registerAdapter({
+      id: "ollama",
+      defaultModel: DEFAULT_OLLAMA_EMBEDDING_MODEL,
+      transport: "remote",
+      create: async () => ({ provider: null }),
+    });
     workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-memory-mistral-"));
     indexPath = path.join(workspaceDir, "index.sqlite");
     await fs.mkdir(path.join(workspaceDir, "memory"), { recursive: true });
@@ -97,6 +139,7 @@ describe("memory manager mistral provider wiring", () => {
       manager = null;
     }
     await closeAllMemorySearchManagers();
+    clearRegistry();
     if (workspaceDir) {
       await fs.rm(workspaceDir, { recursive: true, force: true });
       workspaceDir = "";

extensions/memory-core/src/memory/manager.vector-dedupe.test.ts

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/memory-core-host-engine-foundation";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import type { MemoryIndexManager } from "./index.js";
 
 vi.mock("./embeddings.js", () => {
@@ -22,10 +22,14 @@ vi.mock("./embeddings.js", () => {
 type MemoryStorageModule = typeof import("openclaw/plugin-sdk/memory-core-host-engine-storage");
 type TestManagerModule = typeof import("./test-manager.js");
 type MemoryIndexModule = typeof import("./index.js");
+type MemoryEmbeddingProvidersModule =
+  typeof import("../../../../src/plugins/memory-embedding-providers.js");
 
 let buildFileEntry: MemoryStorageModule["buildFileEntry"];
 let createMemoryManagerOrThrow: TestManagerModule["createMemoryManagerOrThrow"];
 let closeAllMemorySearchManagers: MemoryIndexModule["closeAllMemorySearchManagers"];
+let clearRegistry: MemoryEmbeddingProvidersModule["clearMemoryEmbeddingProviders"];
+let registerAdapter: MemoryEmbeddingProvidersModule["registerMemoryEmbeddingProvider"];
 
 async function ensureProviderInitialized(manager: MemoryIndexManager): Promise<void> {
   await (
@@ -53,11 +57,25 @@ describe("memory vector dedupe", () => {
     manager = null;
   }
 
-  beforeEach(async () => {
+  beforeAll(async () => {
     vi.resetModules();
     ({ buildFileEntry } = await import("openclaw/plugin-sdk/memory-core-host-engine-storage"));
     ({ createMemoryManagerOrThrow } = await import("./test-manager.js"));
     ({ closeAllMemorySearchManagers } = await import("./index.js"));
+    ({
+      clearMemoryEmbeddingProviders: clearRegistry,
+      registerMemoryEmbeddingProvider: registerAdapter,
+    } = await import("../../../../src/plugins/memory-embedding-providers.js"));
+  });
+
+  beforeEach(async () => {
+    clearRegistry();
+    registerAdapter({
+      id: "openai",
+      defaultModel: "mock-embed",
+      transport: "remote",
+      create: async () => ({ provider: null }),
+    });
     workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-mem-"));
     indexPath = path.join(workspaceDir, "index.sqlite");
     await seedMemoryWorkspace(workspaceDir);
@@ -66,9 +84,14 @@ describe("memory vector dedupe", () => {
   afterEach(async () => {
     await closeManagerIfOpen();
     await closeAllMemorySearchManagers();
+    clearRegistry();
     await fs.rm(workspaceDir, { recursive: true, force: true });
   });
 
+  afterAll(() => {
+    vi.resetModules();
+  });
+
   it("deletes existing vector rows before inserting replacements", async () => {
     const cfg = {
       agents: {