@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/mcp-health-check.test.ts

@@ -18,20 +18,51 @@ mock.module("../mcp/client.js", () => ({
   },
 }));
 
-const { checkServerHealth } = await import("../cli/commands/mcp.js");
+mock.module("../config/loader.js", () => ({
+  loadRawConfig: () => ({
+    mcp: {
+      servers: {
+        test: {
+          transport: {
+            type: "streamable-http",
+            url: "https://example.com/mcp",
+          },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 20,
+        },
+      },
+    },
+  }),
+  saveRawConfig: () => {},
+}));
 
-const serverConfig = (overrides = {}) => ({
-  transport: {
-    type: "streamable-http" as const,
-    url: "https://example.com/mcp",
-  },
-  enabled: true,
-  defaultRiskLevel: "high" as const,
-  maxTools: 20,
-  ...overrides,
-});
+mock.module("../daemon/mcp-reload-service.js", () => ({
+  reloadMcpServers: async () => {},
+}));
+
+mock.module("../mcp/mcp-auth-orchestrator.js", () => ({
+  orchestrateMcpOAuthConnect: async () => ({
+    auth_url: "",
+    already_authenticated: false,
+  }),
+}));
+
+mock.module("../mcp/mcp-auth-state.js", () => ({
+  getMcpAuthState: () => null,
+}));
 
-describe("checkServerHealth", () => {
+mock.module("../mcp/mcp-oauth-provider.js", () => ({
+  deleteMcpOAuthCredentials: async () => {},
+}));
+
+const { ROUTES } = await import("../runtime/routes/mcp-auth-routes.js");
+
+const listHandler = ROUTES.find(
+  (r: { operationId: string }) => r.operationId === "internal_mcp_list",
+)!.handler;
+
+describe("checkServerHealth (via internal_mcp_list route)", () => {
   beforeEach(() => {
     mockConnect.mockReset();
     mockDisconnect.mockReset();
@@ -43,8 +74,10 @@ describe("checkServerHealth", () => {
     mockConnect.mockResolvedValue(undefined);
     mockDisconnect.mockResolvedValue(undefined);
 
-    const result = await checkServerHealth("test", serverConfig());
-    expect(result).toContain("Connected");
+    const result = (await listHandler({})) as {
+      servers: { status: string }[];
+    };
+    expect(result.servers[0].status).toContain("Connected");
     expect(mockDisconnect).toHaveBeenCalled();
   });
 
@@ -52,8 +85,10 @@ describe("checkServerHealth", () => {
     mockConnect.mockResolvedValue(undefined);
     mockIsConnected = false;
 
-    const result = await checkServerHealth("test", serverConfig());
-    expect(result).toContain("Needs authentication");
+    const result = (await listHandler({})) as {
+      servers: { status: string }[];
+    };
+    expect(result.servers[0].status).toContain("Needs authentication");
   });
 
   test("returns Error when connect fails with lastError", async () => {
@@ -62,16 +97,10 @@ describe("checkServerHealth", () => {
     mockLastError = new Error("Connection refused");
     mockDisconnect.mockResolvedValue(undefined);
 
-    const result = await checkServerHealth("test", serverConfig());
-    expect(result).toContain("Error");
-    expect(result).toContain("Connection refused");
-  });
-
-  test("returns Timed out when connect hangs", async () => {
-    mockConnect.mockImplementation(() => new Promise(() => {}));
-    mockDisconnect.mockResolvedValue(undefined);
-
-    const result = await checkServerHealth("test", serverConfig(), 100);
-    expect(result).toContain("Timed out");
+    const result = (await listHandler({})) as {
+      servers: { status: string }[];
+    };
+    expect(result.servers[0].status).toContain("Error");
+    expect(result.servers[0].status).toContain("Connection refused");
   });
 });

package/src/__tests__/memory-jobs-worker-lanes.test.ts

@@ -3,7 +3,7 @@
  *
  * Before this fix, all non-embed jobs ran through a single bounded worker
  * pool, so a long-running `graph_consolidate` LLM call would pin every slot
- * and starve fast-lane jobs (e.g. `embed_concept_page` consolidation pages)
+ * and starve fast-lane jobs (e.g. `memory_v2_activation_recompute`)
  * for the duration of that call.
  *
  * The new scheduler runs slow / fast / embed lanes in parallel pools, each
@@ -87,16 +87,19 @@ mock.module("../memory/graph/consolidation.js", () => ({
 
 // Fast-lane handler: resolves on the next microtask. The test fires this
 // many times in parallel; nothing should block.
-mock.module("../memory/jobs/embed-concept-page.js", () => ({
-  embedConceptPageJob: async (job: {
-    payload: { slug?: string };
-  }): Promise<void> => {
+mock.module("../memory/v2/backfill-jobs.js", () => ({
+  memoryV2ActivationRecomputeJob: async (job: {
+    payload: { scopeId?: string };
+  }): Promise<number> => {
     completions.push({
-      type: "embed_concept_page",
-      conversationId: job.payload.slug ?? "",
+      type: "memory_v2_activation_recompute",
+      conversationId: job.payload.scopeId ?? "",
       completedAt: Date.now(),
     });
+    return 0;
   },
+  memoryV2MigrateJob: async (): Promise<void> => {},
+  memoryV2ReembedJob: async (): Promise<void> => {},
 }));
 
 // Stub remaining heavy boundaries that we never exercise but that get pulled
@@ -128,18 +131,22 @@ describe("memory jobs worker lane scheduling", () => {
 
   test("fast lane completes before slow lane releases its slot", async () => {
     // 5 slow `graph_consolidate` jobs across distinct scopes (so they would
-    // serialize behind a single shared pool) plus 5 fast `embed_concept_page`
-    // jobs across distinct slugs.
+    // serialize behind a single shared pool) plus 5 fast
+    // `memory_v2_activation_recompute` jobs across distinct scopes.
     for (let i = 0; i < 5; i++) {
       enqueueMemoryJob("graph_consolidate", { scopeId: `slow-${i}` });
     }
     for (let i = 0; i < 5; i++) {
-      enqueueMemoryJob("embed_concept_page", { slug: `fast-${i}` });
+      enqueueMemoryJob("memory_v2_activation_recompute", {
+        scopeId: `fast-${i}`,
+      });
     }
 
     await runMemoryJobsOnce();
 
-    const fastDone = completions.filter((c) => c.type === "embed_concept_page");
+    const fastDone = completions.filter(
+      (c) => c.type === "memory_v2_activation_recompute",
+    );
     const slowDone = completions.filter((c) => c.type === "graph_consolidate");
 
     // Slow lane is capped at 1 in this test, so only 1 slow job ran in this

package/src/__tests__/message-complete-display-id.test.ts

@@ -0,0 +1,175 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+interface AddMessageCall {
+  conversationId: string;
+  role: string;
+  content: string;
+  metadata?: Record<string, unknown>;
+}
+
+const addMessageCalls: AddMessageCall[] = [];
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: (
+    conversationId: string,
+    role: string,
+    content: string,
+    metadata?: Record<string, unknown>,
+  ) => {
+    addMessageCalls.push({ conversationId, role, content, metadata });
+    return { id: `mock-msg-${addMessageCalls.length}` };
+  },
+  getConversation: () => null,
+  getMessageById: () => null,
+  provenanceFromTrustContext: () => ({}),
+  updateMessageContent: () => {},
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  backfillMessageIdOnLogs: () => {},
+  recordRequestLog: () => {},
+}));
+
+mock.module("../memory/memory-recall-log-store.js", () => ({
+  backfillMemoryRecallLogMessageId: () => {},
+}));
+
+mock.module("../memory/memory-v2-activation-log-store.js", () => ({
+  backfillMemoryV2ActivationMessageId: () => {},
+}));
+
+mock.module("../memory/conversation-disk-view.js", () => ({
+  syncMessageToDisk: () => {},
+}));
+
+import type { AgentEvent } from "../agent/loop.js";
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  getClientDisplayMessageId,
+  handleMessageComplete,
+} from "../daemon/conversation-agent-loop-handlers.js";
+
+const CONVERSATION_ID = "conv-display-id";
+
+function makeDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: CONVERSATION_ID,
+      currentTurnSurfaces: [],
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      trustContext: {
+        sourceChannel: "vellum",
+        trustClass: "guardian",
+      },
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: () => {},
+    reqId: "req-display-id",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    } as EventHandlerDeps["turnInterfaceContext"],
+  };
+}
+
+function makeMessageCompleteEvent(
+  content: Extract<
+    AgentEvent,
+    { type: "message_complete" }
+  >["message"]["content"],
+): Extract<AgentEvent, { type: "message_complete" }> {
+  return {
+    type: "message_complete",
+    message: { role: "assistant", content },
+  };
+}
+
+describe("message_complete display identity", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    addMessageCalls.length = 0;
+    state = createEventHandlerState();
+    state.turnStartedAt = 1_700_000_000_000;
+  });
+
+  test("tracks the merged display id separately from the final row id", async () => {
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent([
+        {
+          type: "tool_use",
+          id: "toolu_1",
+          name: "bash",
+          input: { command: "true" },
+        },
+      ]),
+    );
+
+    expect(state.firstAssistantMessageId).toBe("mock-msg-1");
+    expect(state.lastAssistantMessageId).toBe("mock-msg-1");
+    expect(getClientDisplayMessageId(state)).toBe("mock-msg-1");
+
+    state.pendingToolResults.set("toolu_1", {
+      content: "ok",
+      isError: false,
+    });
+
+    await handleMessageComplete(
+      state,
+      makeDeps(),
+      makeMessageCompleteEvent([{ type: "text", text: "done" }]),
+    );
+
+    expect(addMessageCalls.map((call) => call.role)).toEqual([
+      "assistant",
+      "user",
+      "assistant",
+    ]);
+    expect(state.firstAssistantMessageId).toBe("mock-msg-1");
+    expect(state.lastAssistantMessageId).toBe("mock-msg-3");
+    expect(getClientDisplayMessageId(state)).toBe("mock-msg-1");
+  });
+});

package/src/__tests__/notification-decision-fallback.test.ts

@@ -95,6 +95,97 @@ describe("notification decision fallback copy", () => {
     );
   });
 
+  test("enforces guardian-facing popup copy for heartbeat alerts", async () => {
+    configuredProvider = { sendMessage: async () => ({}) };
+    extractedToolUse = {
+      input: {
+        shouldNotify: true,
+        selectedChannels: ["vellum"],
+        reasoningSummary: "Heartbeat found a useful follow-up.",
+        renderedCopy: {
+          vellum: {
+            title: "Heartbeat Follow-up",
+            body: "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
+          },
+        },
+        dedupeKey: "heartbeat:test",
+        confidence: 0.9,
+      },
+    };
+
+    const decision = await evaluateSignal(
+      makeSignal({
+        sourceEventName: "heartbeat.alert",
+        sourceChannel: "watcher",
+        contextPayload: {
+          summary:
+            "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
+          conversationTitle: "Running Habit Tracking",
+        },
+        attentionHints: {
+          requiresAction: true,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+      }),
+      ["vellum"] as NotificationChannel[],
+    );
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.title).toBe("Heartbeat Alert");
+    expect(decision.renderedCopy.vellum?.body).toBe(
+      "I found something worth your attention in a heartbeat check. Open the conversation for details.",
+    );
+    expect(decision.renderedCopy.vellum?.body).not.toContain(
+      "reminding the guardian",
+    );
+  });
+
+  test("keeps direct guardian-facing heartbeat copy", async () => {
+    configuredProvider = { sendMessage: async () => ({}) };
+    extractedToolUse = {
+      input: {
+        shouldNotify: true,
+        selectedChannels: ["vellum"],
+        reasoningSummary: "Heartbeat found a useful follow-up.",
+        renderedCopy: {
+          vellum: {
+            title: "Tracker Ready",
+            body: "Your daily tracker is ready. Review it before the next check-in.",
+          },
+        },
+        dedupeKey: "heartbeat:direct-copy-test",
+        confidence: 0.9,
+      },
+    };
+
+    const decision = await evaluateSignal(
+      makeSignal({
+        sourceEventName: "heartbeat.alert",
+        sourceChannel: "watcher",
+        contextPayload: {
+          summary:
+            "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
+          conversationTitle: "Running Habit Tracking",
+        },
+        attentionHints: {
+          requiresAction: true,
+          urgency: "medium",
+          isAsyncBackground: true,
+          visibleInSourceNow: false,
+        },
+      }),
+      ["vellum"] as NotificationChannel[],
+    );
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.vellum?.title).toBe("Tracker Ready");
+    expect(decision.renderedCopy.vellum?.body).toBe(
+      "Your daily tracker is ready. Review it before the next check-in.",
+    );
+  });
+
   test("enforces free-text answer instructions for guardian.question when requestCode exists", async () => {
     const signal = makeSignal({
       contextPayload: {

package/src/__tests__/notification-decision-strategy.test.ts

@@ -373,6 +373,28 @@ describe("notification decision strategy", () => {
         "A guardian question needs your attention",
       );
     });
+
+    test("heartbeat.alert fallback avoids intermediary-instruction popup copy", () => {
+      const signal = makeSignal({
+        sourceEventName: "heartbeat.alert",
+        contextPayload: {
+          summary:
+            "The daily tracker is ready; consider reminding the guardian to review it before the next check-in.",
+          conversationTitle: "Running Habit Tracking",
+        },
+      });
+
+      const copy = composeFallbackCopy(signal, channels);
+      expect(copy.vellum).toBeDefined();
+      expect(copy.vellum!.title).toBe("Heartbeat Alert");
+      expect(copy.vellum!.body).toBe(
+        "I found something worth your attention in a heartbeat check. Open the conversation for details.",
+      );
+      expect(copy.vellum!.conversationSeedMessage).toContain(
+        "consider reminding the guardian",
+      );
+      expect(copy.telegram!.deliveryText).toBe(copy.vellum!.body);
+    });
   });
 
   // -- NotificationChannel type correctness ----------------------------------