@vellumai/assistant 0.8.0 → 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-platform-adapter.test.ts

@@ -0,0 +1,229 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mock logger ──────────────────────────────────────────────────────────────
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ── Mock sleep so retry tests don't slow down the suite ──────────────────────
+
+mock.module("../util/retry.js", () => ({
+  sleep: async (_ms: number): Promise<void> => {},
+  isRetryableStatus: (status: number): boolean =>
+    status === 429 || status >= 500,
+  isRetryableNetworkError: (error: unknown): boolean => {
+    if (!(error instanceof Error)) return false;
+    const codes = new Set(["ECONNRESET", "ECONNREFUSED", "ETIMEDOUT", "EPIPE"]);
+    const code = (error as { code?: string }).code;
+    if (code && codes.has(code)) return true;
+    if (error.cause instanceof Error) {
+      const causeCode = (error.cause as { code?: string }).code;
+      if (causeCode && codes.has(causeCode)) return true;
+    }
+    return false;
+  },
+}));
+
+// ── VellumPlatformClient mock state ──────────────────────────────────────────
+
+interface FetchCall {
+  path: string;
+  method: string;
+  body: Record<string, unknown>;
+}
+
+const fetchCalls: FetchCall[] = [];
+const fetchResponses: Array<{ ok: boolean; status: number; body?: string }> = [];
+let clientAvailable = true;
+
+mock.module("../platform/client.js", () => ({
+  VellumPlatformClient: {
+    create: async () => {
+      if (!clientAvailable) return null;
+      return {
+        platformAssistantId: "test-assistant-id",
+        fetch: async (path: string, init?: RequestInit) => {
+          const body = init?.body
+            ? (JSON.parse(init.body as string) as Record<string, unknown>)
+            : {};
+          fetchCalls.push({ path, method: init?.method ?? "GET", body });
+          const response = fetchResponses.shift() ?? {
+            ok: true,
+            status: 200,
+            body: "{}",
+          };
+          return {
+            ok: response.ok,
+            status: response.status,
+            text: async () => response.body ?? "",
+          };
+        },
+      };
+    },
+  },
+}));
+
+import { PlatformPushAdapter } from "../notifications/adapters/platform.js";
+import type {
+  ChannelDeliveryPayload,
+  ChannelDestination,
+} from "../notifications/types.js";
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function makePayload(
+  overrides?: Partial<ChannelDeliveryPayload>,
+): ChannelDeliveryPayload {
+  return {
+    deliveryId: "delivery-uuid-1",
+    sourceEventName: "schedule.notify",
+    copy: { title: "Reminder", body: "Check the oven!" },
+    deepLinkTarget: { type: "conversation", id: "conv-1" },
+    contextPayload: { jobId: "job-1" },
+    ...overrides,
+  };
+}
+
+function makeDestination(
+  overrides?: Partial<ChannelDestination>,
+): ChannelDestination {
+  return {
+    channel: "platform",
+    ...overrides,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("PlatformPushAdapter", () => {
+  beforeEach(() => {
+    fetchCalls.length = 0;
+    fetchResponses.length = 0;
+    clientAvailable = true;
+  });
+
+  test("channel is 'platform'", () => {
+    expect(new PlatformPushAdapter().channel).toBe("platform");
+  });
+
+  test("POSTs to the correct dispatch endpoint with snake_case body", async () => {
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(fetchCalls).toHaveLength(1);
+
+    const call = fetchCalls[0]!;
+    expect(call.path).toBe(
+      "/v1/assistants/test-assistant-id/push/dispatch/",
+    );
+    expect(call.method).toBe("POST");
+    expect(call.body.delivery_id).toBe("delivery-uuid-1");
+    expect(call.body.source_event_name).toBe("schedule.notify");
+    expect(call.body.title).toBe("Reminder");
+    expect(call.body.body).toBe("Check the oven!");
+    expect(call.body.deep_link_metadata).toEqual({
+      type: "conversation",
+      id: "conv-1",
+    });
+    expect(call.body.context_payload).toEqual({ jobId: "job-1" });
+    expect(call.body.target_guardian_principal_id).toBeUndefined();
+  });
+
+  test("sets target_guardian_principal_id for guardian-sensitive events", async () => {
+    const adapter = new PlatformPushAdapter();
+    const payload = makePayload({ sourceEventName: "guardian.question" });
+    const destination = makeDestination({
+      metadata: { guardianPrincipalId: "principal-xyz" },
+    });
+
+    const result = await adapter.send(payload, destination);
+
+    expect(result.success).toBe(true);
+    expect(fetchCalls[0]?.body.target_guardian_principal_id).toBe(
+      "principal-xyz",
+    );
+  });
+
+  test("omits target_guardian_principal_id for non-guardian events even with principalId in metadata", async () => {
+    const adapter = new PlatformPushAdapter();
+    const payload = makePayload({ sourceEventName: "schedule.notify" });
+    const destination = makeDestination({
+      metadata: { guardianPrincipalId: "principal-xyz" },
+    });
+
+    const result = await adapter.send(payload, destination);
+
+    expect(result.success).toBe(true);
+    expect(fetchCalls[0]?.body.target_guardian_principal_id).toBeUndefined();
+  });
+
+  test("returns failure when platform client is unavailable", async () => {
+    clientAvailable = false;
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("platform client unavailable");
+    expect(fetchCalls).toHaveLength(0);
+  });
+
+  test("retries on 5xx responses and succeeds on eventual 200", async () => {
+    fetchResponses.push(
+      { ok: false, status: 503, body: "service unavailable" },
+      { ok: false, status: 500, body: "internal error" },
+      { ok: true, status: 200, body: "{}" },
+    );
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(fetchCalls).toHaveLength(3);
+  });
+
+  test("returns failure after exhausting all retries on persistent 5xx", async () => {
+    fetchResponses.push(
+      { ok: false, status: 500, body: "error" },
+      { ok: false, status: 502, body: "bad gateway" },
+      { ok: false, status: 503, body: "unavailable" },
+      { ok: false, status: 500, body: "still failing" },
+    );
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("500");
+    // 1 initial + 3 retries = 4 attempts
+    expect(fetchCalls).toHaveLength(4);
+  });
+
+  test("does not retry on 4xx responses", async () => {
+    fetchResponses.push({ ok: false, status: 400, body: "bad request" });
+    const adapter = new PlatformPushAdapter();
+    const result = await adapter.send(makePayload(), makeDestination());
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("400");
+    expect(fetchCalls).toHaveLength(1);
+  });
+
+  test("omits optional fields when absent from payload", async () => {
+    const adapter = new PlatformPushAdapter();
+    const payload: ChannelDeliveryPayload = {
+      sourceEventName: "schedule.notify",
+      copy: { title: "Hi", body: "Hello" },
+    };
+
+    const result = await adapter.send(payload, makeDestination());
+
+    expect(result.success).toBe(true);
+    const body = fetchCalls[0]?.body ?? {};
+    expect(body.delivery_id).toBeUndefined();
+    expect(body.deep_link_metadata).toBeUndefined();
+    expect(body.context_payload).toBeUndefined();
+  });
+});