@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/conversation-clear-safety.test.ts

@@ -27,8 +27,8 @@ mock.module("../config/env.js", () => ({
 
 mock.module("../daemon/handlers/conversations.js", () => ({
   cancelGeneration: () => true,
-  clearAllConversations: () => {
-    clearAll();
+  clearAllConversations: async () => {
+    await clearAll();
     return 0;
   },
   switchConversation: async () => null,
@@ -129,26 +129,28 @@ describe("DELETE /v1/conversations — route handler", () => {
     (r) => r.operationId === "clearAllConversations",
   )!;
 
-  test("missing X-Confirm-Destructive header throws BadRequestError", () => {
-    expect(() =>
-      clearRoute.handler({
-        pathParams: {},
-        body: {},
-        headers: {},
-  
-      }),
-    ).toThrow(BadRequestError);
+  test("missing X-Confirm-Destructive header throws BadRequestError", async () => {
+    await expect(
+      Promise.resolve().then(() =>
+        clearRoute.handler({
+          pathParams: {},
+          body: {},
+          headers: {},
+        }),
+      ),
+    ).rejects.toThrow(BadRequestError);
   });
 
-  test("wrong X-Confirm-Destructive header value throws BadRequestError", () => {
-    expect(() =>
-      clearRoute.handler({
-        pathParams: {},
-        body: {},
-        headers: { "x-confirm-destructive": "wrong-value" },
-  
-      }),
-    ).toThrow(BadRequestError);
+  test("wrong X-Confirm-Destructive header value throws BadRequestError", async () => {
+    await expect(
+      Promise.resolve().then(() =>
+        clearRoute.handler({
+          pathParams: {},
+          body: {},
+          headers: { "x-confirm-destructive": "wrong-value" },
+        }),
+      ),
+    ).rejects.toThrow(BadRequestError);
   });
 
   test("correct header clears data", async () => {
@@ -156,23 +158,21 @@ describe("DELETE /v1/conversations — route handler", () => {
     await addMessage(conv.id, "user", "hello from safety test");
     expect(getConversation(conv.id)).not.toBeNull();
 
-    const result = clearRoute.handler({
+    const result = await clearRoute.handler({
       pathParams: {},
       body: {},
       headers: { "x-confirm-destructive": "clear-all-conversations" },
-
     });
     expect(result).toBeUndefined();
 
     expect(getConversation(conv.id)).toBeNull();
   });
 
-  test("lifecycle_events contains conversations_clear_all after successful clear", () => {
-    clearRoute.handler({
+  test("lifecycle_events contains conversations_clear_all after successful clear", async () => {
+    await clearRoute.handler({
       pathParams: {},
       body: {},
       headers: { "x-confirm-destructive": "clear-all-conversations" },
-
     });
 
     const raw = (

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -51,7 +51,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({

package/src/__tests__/conversation-delete-schedule-cleanup.test.ts

@@ -23,7 +23,7 @@ mock.module("../daemon/conversation-store.js", () => ({
 
 mock.module("../daemon/handlers/conversations.js", () => ({
   cancelGeneration: () => true,
-  clearAllConversations: () => 0,
+  clearAllConversations: async () => 0,
   switchConversation: async () => null,
   undoLastMessage: async () => null,
   regenerateResponse: async () => null,

package/src/__tests__/conversation-disk-view-integration.test.ts

@@ -231,7 +231,7 @@ describe("clearAll → disk view", () => {
     resetConversationsDir();
   });
 
-  test("empties the conversations directory", () => {
+  test("empties the conversations directory", async () => {
     // Create two conversations
     createConversation("Conv A");
     createConversation("Conv B");
@@ -241,7 +241,7 @@ describe("clearAll → disk view", () => {
     expect(entries.length).toBe(2);
 
     // Clear all
-    clearAll();
+    await clearAll();
 
     // Conversations directory should exist but be empty
     expect(existsSync(conversationsDir)).toBe(true);

package/src/__tests__/conversation-error.test.ts

@@ -9,6 +9,7 @@ mock.module("../providers/registry.js", () => ({
 
 import type { ErrorContext } from "../daemon/conversation-error.js";
 import {
+  budgetYieldUnrecoveredClassification,
   buildConversationErrorMessage,
   classifyConversationError,
   isUserCancellation,
@@ -947,3 +948,33 @@ describe("buildConversationErrorMessage", () => {
     expect(msg.code).toBe("PROVIDER_WEB_SEARCH");
   });
 });
+
+describe("budgetYieldUnrecoveredClassification", () => {
+  it("returns the BUDGET_YIELD_UNRECOVERED code and retryable=true", () => {
+    const classified = budgetYieldUnrecoveredClassification();
+    expect(classified.code).toBe("BUDGET_YIELD_UNRECOVERED");
+    expect(classified.retryable).toBe(true);
+    expect(classified.errorCategory).toBe("budget_yield_unrecovered");
+  });
+
+  it("returns a user-facing message that explains the situation", () => {
+    const classified = budgetYieldUnrecoveredClassification();
+    // The message must communicate (a) compaction was attempted, (b) send
+    // another message to continue. Avoid asserting exact wording so copy
+    // tweaks don't trip the test, but lock down the two semantic anchors
+    // a downstream client could test against.
+    expect(classified.userMessage).toContain("compact");
+    expect(classified.userMessage).toContain("Send another message");
+  });
+
+  it("survives the buildConversationErrorMessage envelope unchanged", () => {
+    const classified = budgetYieldUnrecoveredClassification();
+    const envelope = buildConversationErrorMessage("conv-1", classified);
+    expect(envelope.type).toBe("conversation_error");
+    expect(envelope.conversationId).toBe("conv-1");
+    expect(envelope.code).toBe("BUDGET_YIELD_UNRECOVERED");
+    expect(envelope.retryable).toBe(true);
+    expect(envelope.errorCategory).toBe("budget_yield_unrecovered");
+    expect(envelope.userMessage).toBe(classified.userMessage);
+  });
+});

package/src/__tests__/conversation-fork-crud.test.ts

@@ -49,6 +49,7 @@ import {
   getRetrospectiveState,
   upsertRetrospectiveState,
 } from "../memory/memory-retrospective-state.js";
+import { rawGet, rawRun } from "../memory/raw-query.js";
 import {
   activationState,
   channelInboundEvents,
@@ -213,6 +214,115 @@ describe("forkConversation", () => {
     ]);
   });
 
+  test("advances fork boundary through consecutive assistant rows after the requested message", async () => {
+    // When the read-path merges consecutive assistant DB rows into a single
+    // display row, the client only addresses the anchor id. Forking through
+    // the anchor must still include the merged tail rows that follow.
+    const source = createConversation("Multi-row turn thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    const anchor = await addMessage(
+      source.id,
+      "assistant",
+      "Assistant text segment",
+      undefined,
+      { skipIndexing: true },
+    );
+    const toolRow = await addMessage(
+      source.id,
+      "assistant",
+      "Tool turn row",
+      undefined,
+      { skipIndexing: true },
+    );
+    const tailRow = await addMessage(
+      source.id,
+      "assistant",
+      "Final assistant segment",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(source.id, "user", "Next user turn", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: anchor.id,
+    });
+
+    // Boundary advances past the entire consecutive-assistant cluster, so the
+    // full turn is preserved in the fork — not just the anchor row.
+    expect(getMessages(fork.id).map((message) => message.content)).toEqual([
+      "Message 1",
+      "Assistant text segment",
+      "Tool turn row",
+      "Final assistant segment",
+    ]);
+    expect(fork.forkParentMessageId).toBe(tailRow.id);
+    expect(toolRow.id).not.toBe(anchor.id);
+  });
+
+  test("advances fork boundary across tool-result-only user rows between assistant rows", async () => {
+    // Read-path collapse folds tool-result-only user rows into the
+    // surrounding assistant turn (`mergeToolResultsIntoAssistantMessages`
+    // suppresses them). The client only sees a single display turn anchored
+    // at the first assistant row, so forking through the anchor must include
+    // both halves of the assistant turn plus the suppressed user row in
+    // between — otherwise the fork loses tool_use ↔ tool_result pairing
+    // and produces an invalid LLM history.
+    const source = createConversation("Tool-result gap thread");
+    await addMessage(source.id, "user", "Find the latest sales numbers", undefined, {
+      skipIndexing: true,
+    });
+    const anchor = await addMessage(
+      source.id,
+      "assistant",
+      JSON.stringify([
+        { type: "text", text: "Looking up the data." },
+        { type: "tool_use", id: "tool_1", name: "lookup", input: {} },
+      ]),
+      undefined,
+      { skipIndexing: true },
+    );
+    const toolResultUserRow = await addMessage(
+      source.id,
+      "user",
+      JSON.stringify([
+        { type: "tool_result", tool_use_id: "tool_1", content: "data" },
+      ]),
+      undefined,
+      { skipIndexing: true },
+    );
+    const tailAssistantRow = await addMessage(
+      source.id,
+      "assistant",
+      "Here are the numbers.",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(source.id, "user", "Thanks", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: anchor.id,
+    });
+
+    // All three DB rows of the assistant display turn — including the
+    // suppressed tool-result user row in the middle — land in the fork.
+    const forkedContent = getMessages(fork.id).map((m) => m.content);
+    expect(forkedContent).toHaveLength(4);
+    expect(forkedContent[0]).toBe("Find the latest sales numbers");
+    expect(forkedContent[1]).toContain("tool_use");
+    expect(forkedContent[2]).toContain("tool_result");
+    expect(forkedContent[3]).toBe("Here are the numbers.");
+    expect(fork.forkParentMessageId).toBe(tailAssistantRow.id);
+    expect(toolResultUserRow.id).not.toBe(anchor.id);
+  });
+
   test("preserves compacted context when forking from the visible window", async () => {
     const source = createConversation("Compacted thread");
     await addMessage(source.id, "user", "Message 1", undefined, {
@@ -296,6 +406,168 @@ describe("forkConversation", () => {
     ]);
   });
 
+  test("inherits historyStrippedAt when forking past the clean event", async () => {
+    const source = createConversation("Clean thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    const preClean = await addMessage(
+      source.id,
+      "assistant",
+      "Message 2",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const historyStrippedAt = preClean.createdAt + 1;
+    getDb()
+      .update(conversations)
+      .set({ historyStrippedAt })
+      .where(eq(conversations.id, source.id))
+      .run();
+
+    const postClean = await addMessage(
+      source.id,
+      "user",
+      "Message 3",
+      undefined,
+      { skipIndexing: true },
+    );
+    expect(postClean.createdAt).toBeGreaterThanOrEqual(historyStrippedAt);
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: postClean.id,
+    });
+
+    expect(fork.historyStrippedAt).toBe(historyStrippedAt);
+  });
+
+  test("does not inherit historyStrippedAt when forking before the clean event", async () => {
+    const source = createConversation("Clean thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    const preClean = await addMessage(
+      source.id,
+      "assistant",
+      "Message 2",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const historyStrippedAt = preClean.createdAt + 1;
+    getDb()
+      .update(conversations)
+      .set({ historyStrippedAt })
+      .where(eq(conversations.id, source.id))
+      .run();
+
+    await addMessage(source.id, "user", "Message 3", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: preClean.id,
+    });
+
+    expect(fork.historyStrippedAt).toBeNull();
+  });
+
+  test("inherits historyStrippedAt on a full-history fork", async () => {
+    const source = createConversation("Clean thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    const last = await addMessage(
+      source.id,
+      "assistant",
+      "Message 2",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const historyStrippedAt = last.createdAt - 1;
+    getDb()
+      .update(conversations)
+      .set({ historyStrippedAt })
+      .where(eq(conversations.id, source.id))
+      .run();
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    expect(fork.historyStrippedAt).toBe(historyStrippedAt);
+  });
+
+  test("leaves historyStrippedAt null when the source has no clean event", async () => {
+    const source = createConversation("Unclean thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "Message 2", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    expect(fork.historyStrippedAt).toBeNull();
+  });
+
+  test("fork from a pre-compaction message preserves historical injection metadata", async () => {
+    const source = createConversation("Compacted thread");
+    const m1 = await addMessage(
+      source.id,
+      "user",
+      "Historical question",
+      {
+        pkbContextBlock: "<knowledge_base>\nstale\n</knowledge_base>",
+        nowScratchpadBlock:
+          "<NOW.md Always keep this up to date>\nstale\n</NOW.md>",
+      },
+      { skipIndexing: true },
+    );
+    await addMessage(source.id, "assistant", "Reply 1", undefined, {
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "user", "Tail turn", undefined, {
+      skipIndexing: true,
+    });
+    const compactedAt = Date.now();
+    getDb()
+      .update(conversations)
+      .set({
+        contextSummary: "summary",
+        contextCompactedMessageCount: 2,
+        contextCompactedAt: compactedAt,
+        historyStrippedAt: compactedAt,
+      })
+      .where(eq(conversations.id, source.id))
+      .run();
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: m1.id,
+    });
+
+    expect(fork.historyStrippedAt).toBeNull();
+    expect(fork.contextSummary).toBeNull();
+    expect(fork.contextCompactedMessageCount).toBe(0);
+
+    const forkedMessages = getMessages(fork.id);
+    expect(forkedMessages).toHaveLength(1);
+    const meta = parseMetadata(forkedMessages[0].metadata) as Record<
+      string,
+      unknown
+    >;
+    expect(meta.pkbContextBlock).toBe(
+      "<knowledge_base>\nstale\n</knowledge_base>",
+    );
+    expect(meta.nowScratchpadBlock).toBe(
+      "<NOW.md Always keep this up to date>\nstale\n</NOW.md>",
+    );
+  });
+
   test("rejects forks when the source conversation has no persisted messages", () => {
     const source = createConversation("Empty thread");
 
@@ -661,6 +933,58 @@ describe("forkConversation", () => {
     expect(loadGraphMemoryState(fork.id)).toBeNull();
   });
 
+  test("defaults conversationType to standard and inherits the parent's group", async () => {
+    const source = createConversation("Default inheritance thread");
+    await addMessage(source.id, "user", "first message", undefined, {
+      skipIndexing: true,
+    });
+    rawRun(
+      "UPDATE conversations SET group_id = ? WHERE id = ?",
+      "system:pinned",
+      source.id,
+    );
+
+    const fork = forkConversation({ conversationId: source.id });
+    const row = getDb()
+      .select()
+      .from(conversations)
+      .where(eq(conversations.id, fork.id))
+      .get();
+    const groupIdRow = rawGet<{ group_id: string | null }>(
+      "SELECT group_id FROM conversations WHERE id = ?",
+      fork.id,
+    );
+
+    expect(row?.conversationType).toBe("standard");
+    expect(groupIdRow?.group_id).toBe("system:pinned");
+  });
+
+  test("honors conversationType and groupId overrides on the fork", async () => {
+    const source = createConversation("Override thread");
+    await addMessage(source.id, "user", "first message", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      conversationType: "background",
+      groupId: "system:background",
+    });
+
+    const row = getDb()
+      .select()
+      .from(conversations)
+      .where(eq(conversations.id, fork.id))
+      .get();
+    const groupIdRow = rawGet<{ group_id: string | null }>(
+      "SELECT group_id FROM conversations WHERE id = ?",
+      fork.id,
+    );
+
+    expect(row?.conversationType).toBe("background");
+    expect(groupIdRow?.group_id).toBe("system:background");
+  });
+
   test("copies memory state when throughMessageId points at the last message", async () => {
     const source = createConversation("Through-last thread");
     const lastMessage = await addMessage(

package/src/__tests__/conversation-lifecycle.test.ts

@@ -8,7 +8,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -379,7 +379,7 @@ describe("loadFromDb metadata injection rehydration", () => {
         metadata: JSON.stringify({
           memoryInjectedBlock: "mem payload",
           memoryV2StaticBlock:
-            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+            "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
           pkbSystemReminderBlock:
             "<system_reminder>\npkb payload\n</system_reminder>",
         }),
@@ -406,7 +406,7 @@ describe("loadFromDb metadata injection rehydration", () => {
       { type: "text", text: "<memory>\nmem payload\n</memory>" },
       {
         type: "text",
-        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+        text: "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
       },
       {
         type: "text",
@@ -416,6 +416,47 @@ describe("loadFromDb metadata injection rehydration", () => {
     ]);
   });
 
+  test("legacy <memory>-wrapped memoryV2StaticBlock rehydrates verbatim", async () => {
+    // `meta.memoryV2StaticBlock` may carry either `<info>…</info>` or
+    // legacy `<memory>…</memory>` wrappers depending on when the row was
+    // persisted. The rehydrate path replays the stored text verbatim,
+    // so both wrappers must round-trip unchanged.
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First turn" }]),
+        metadata: JSON.stringify({
+          memoryV2StaticBlock:
+            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail turn" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages[0].content).toEqual([
+      {
+        type: "text",
+        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+      },
+      { type: "text", text: "First turn" },
+    ]);
+  });
+
   test("tail user row skips memoryV2StaticBlock", async () => {
     mockConversation = defaultConv();
     mockDbMessages = [
@@ -434,7 +475,7 @@ describe("loadFromDb metadata injection rehydration", () => {
         role: "user",
         content: JSON.stringify([{ type: "text", text: "Tail" }]),
         metadata: JSON.stringify({
-          memoryV2StaticBlock: "<memory>\n## Essentials\n\nleak\n</memory>",
+          memoryV2StaticBlock: "<info>\n## Essentials\n\nleak\n</info>",
         }),
       },
     ];
@@ -471,7 +512,7 @@ describe("loadFromDb metadata injection rehydration", () => {
           // survive the row-level filter for non-guardian views.
           provenanceTrustClass: "trusted_contact",
           memoryV2StaticBlock:
-            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+            "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
         }),
       },
       {
@@ -500,7 +541,7 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages[0].content).toEqual([
       {
         type: "text",
-        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+        text: "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
       },
       { type: "text", text: "First" },
     ]);
@@ -510,7 +551,7 @@ describe("loadFromDb metadata injection rehydration", () => {
     // Injection-time layout (per `applyRuntimeInjections` after-memory-
     // prefix splicing in ascending injector order: pkb-context 30,
     // pkb-reminder 35, memory-v2-static 38, now-md 40):
-    //   [<memory __injected>, <memory>v2static</memory>, <NOW.md>,
+    //   [<memory>dynamic</memory>, <info>v2static</info>, <NOW.md>,
     //    <system_reminder>, <knowledge_base>, ...original]
     // Rehydration must reproduce this exactly so Anthropic's prefix cache
     // matches msg[0] across daemon restarts.
@@ -523,7 +564,7 @@ describe("loadFromDb metadata injection rehydration", () => {
         metadata: JSON.stringify({
           memoryInjectedBlock: "mem payload",
           memoryV2StaticBlock:
-            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+            "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
           nowScratchpadBlock: "<NOW.md>\nnow body\n</NOW.md>",
           pkbSystemReminderBlock:
             "<system_reminder>\npkb reminder body\n</system_reminder>",
@@ -551,7 +592,7 @@ describe("loadFromDb metadata injection rehydration", () => {
       { type: "text", text: "<memory>\nmem payload\n</memory>" },
       {
         type: "text",
-        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+        text: "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
       },
       { type: "text", text: "<NOW.md>\nnow body\n</NOW.md>" },
       {
@@ -575,7 +616,7 @@ describe("loadFromDb metadata injection rehydration", () => {
         metadata: JSON.stringify({
           provenanceTrustClass: "trusted_contact",
           memoryV2StaticBlock:
-            "<memory>\n## Essentials\n\nprivate memory\n</memory>",
+            "<info>\n## Essentials\n\nprivate memory\n</info>",
         }),
       },
       {
@@ -621,7 +662,7 @@ describe("loadFromDb metadata injection rehydration", () => {
         metadata: JSON.stringify({
           provenanceTrustClass: "trusted_contact",
           memoryV2StaticBlock:
-            "<memory>\n## Essentials\n\nprivate memory\n</memory>",
+            "<info>\n## Essentials\n\nprivate memory\n</info>",
         }),
       },
       {
@@ -649,7 +690,7 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(conversation.getMessages()[0].content).toEqual([
       {
         type: "text",
-        text: "<memory>\n## Essentials\n\nprivate memory\n</memory>",
+        text: "<info>\n## Essentials\n\nprivate memory\n</info>",
       },
       { type: "text", text: "First" },
     ]);

package/src/__tests__/conversation-load-history-repair.test.ts

@@ -10,7 +10,7 @@ mock.module("../util/logger.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({