@vellumai/assistant 0.7.2 → 0.8.0

package/src/__tests__/mcp-abort-signal.test.ts

@@ -122,6 +122,136 @@ describe("MCP AbortSignal threading", () => {
   });
 
   describe("createMcpTool execute", () => {
+    test("keeps safe MCP tool names unchanged", () => {
+      const fakeManager = { callTool: jest.fn() } as any;
+
+      const tool = createMcpTool(
+        {
+          name: "my-tool",
+          description: "A test tool",
+          inputSchema: { type: "object", properties: {} },
+        },
+        "test-server",
+        {
+          transport: { type: "stdio", command: "echo", args: [] },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 100,
+        },
+        fakeManager,
+      );
+
+      expect(tool.name).toBe("mcp__test-server__my-tool");
+      expect(tool.getDefinition().name).toBe("mcp__test-server__my-tool");
+    });
+
+    test("keeps MCP tool names with trailing whitespace distinct", () => {
+      const fakeManager = { callTool: jest.fn() } as any;
+
+      const plain = createMcpTool(
+        {
+          name: "deploy",
+          description: "Deploy",
+          inputSchema: { type: "object", properties: {} },
+        },
+        "test-server",
+        {
+          transport: { type: "stdio", command: "echo", args: [] },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 100,
+        },
+        fakeManager,
+      );
+      const padded = createMcpTool(
+        {
+          name: "deploy ",
+          description: "Deploy padded",
+          inputSchema: { type: "object", properties: {} },
+        },
+        "test-server",
+        {
+          transport: { type: "stdio", command: "echo", args: [] },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 100,
+        },
+        fakeManager,
+      );
+
+      expect(plain.name).toBe("mcp__test-server__deploy");
+      expect(padded.name).toMatch(/^mcp__test-server__deploy__[a-f0-9]{12}$/);
+      expect(padded.name).not.toBe(plain.name);
+    });
+
+    test("exposes provider-safe MCP names while preserving raw execution names", async () => {
+      const callToolSpy = jest.fn().mockResolvedValue({
+        content: "tool result",
+        isError: false,
+      });
+      const fakeManager = { callTool: callToolSpy } as any;
+
+      const tool = createMcpTool(
+        {
+          name: "create link",
+          description: "Create a Stripe Link CLI resource",
+          inputSchema: { type: "object", properties: {} },
+        },
+        "stripe.link-cli",
+        {
+          transport: { type: "stdio", command: "echo", args: [] },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 100,
+        },
+        fakeManager,
+      );
+
+      expect(tool.name).toMatch(/^[a-zA-Z0-9_-]{1,64}$/);
+      expect(tool.name.startsWith("mcp__stripe_link-cli__create_link__")).toBe(
+        true,
+      );
+      expect(tool.getDefinition().name).toBe(tool.name);
+
+      await tool.execute(
+        { someArg: "value" },
+        {
+          workingDir: "/tmp",
+          conversationId: "conv-1",
+          trustClass: "guardian",
+        },
+      );
+
+      expect(callToolSpy).toHaveBeenCalledWith(
+        "stripe.link-cli",
+        "create link",
+        { someArg: "value" },
+        undefined,
+      );
+    });
+
+    test("caps long MCP names at the provider limit", () => {
+      const fakeManager = { callTool: jest.fn() } as any;
+      const tool = createMcpTool(
+        {
+          name: "x".repeat(180),
+          description: "A test tool",
+          inputSchema: { type: "object", properties: {} },
+        },
+        "server",
+        {
+          transport: { type: "stdio", command: "echo", args: [] },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 100,
+        },
+        fakeManager,
+      );
+
+      expect(tool.name).toHaveLength(64);
+      expect(tool.name).toMatch(/^[a-zA-Z0-9_-]{1,64}$/);
+    });
+
     test("threads context.signal through manager.callTool", async () => {
       const callToolSpy = jest.fn().mockResolvedValue({
         content: "tool result",

package/src/__tests__/memory-admin-recall.test.ts

@@ -15,7 +15,6 @@ interface CapturedSearch {
 
 const capturedSearches: CapturedSearch[] = [];
 const getConfiguredProviderCalls: string[] = [];
-const scopeByConversation = new Map<string, string | undefined>();
 const testConfig = {} as AssistantConfig;
 
 mock.module("../config/loader.js", () => ({
@@ -56,13 +55,11 @@ mock.module("../memory/embedding-backend.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   addMessage: () => ({ id: "msg-1" }),
-  createConversation: () => ({ id: "conv-1", memoryScopeId: "default" }),
+  createConversation: () => ({ id: "conv-1" }),
   deleteConversation: () => true,
   getAssistantMessageIdsInTurn: () => [],
   getConversation: () => null,
   getConversationHostAccess: () => false,
-  getConversationMemoryScopeId: (conversationId: string) =>
-    scopeByConversation.get(conversationId),
   getConversationOverrideProfile: () => undefined,
   getConversationSource: () => null,
   getMessageById: () => null,
@@ -165,12 +162,9 @@ describe("memory admin recall", () => {
   beforeEach(() => {
     capturedSearches.length = 0;
     getConfiguredProviderCalls.length = 0;
-    scopeByConversation.clear();
   });
 
-  test("uses the conversation memory scope and safe admin sources", async () => {
-    scopeByConversation.set("conv-admin", "scope-admin");
-
+  test("uses safe admin sources", async () => {
     const result = await queryMemory("launch notes", "conv-admin");
 
     expect(capturedSearches).toHaveLength(1);
@@ -180,7 +174,6 @@ describe("memory admin recall", () => {
     });
     expect(capturedSearches[0].context).toMatchObject({
       workingDir: getWorkspaceDir(),
-      memoryScopeId: "scope-admin",
       conversationId: "conv-admin",
       config: testConfig,
     });
@@ -202,13 +195,12 @@ describe("memory admin recall", () => {
     });
   });
 
-  test("falls back to default scope without invoking a provider", async () => {
+  test("does not invoke a provider for deterministic recall", async () => {
     await queryMemory("offline recall", "missing-conversation");
 
     expect(capturedSearches).toHaveLength(1);
     expect(capturedSearches[0].context).toMatchObject({
       workingDir: getWorkspaceDir(),
-      memoryScopeId: "default",
       conversationId: "missing-conversation",
     });
     expect(capturedSearches[0].input.sources).toEqual([

package/src/__tests__/memory-retrieval-pipeline.test.ts

@@ -158,6 +158,27 @@ describe("runDefaultMemoryRetrieval", () => {
     expect(result.nowContent).toBe("now-default");
   });
 
+  test("propagates errors from prepareMemory rather than swallowing them", async () => {
+    // Memory is critical — failures must surface to the caller (the agent
+    // loop) rather than silently degrading to an empty memory block.
+    const failingPrepare = mock(
+      (
+        _msgs: Message[],
+        _cfg: AssistantConfig,
+        _signal: AbortSignal,
+        _onEvent: (msg: ServerMessage) => void,
+      ) => Promise.reject(new Error("retrieval failed")),
+    );
+    const graphMemory = {
+      prepareMemory: failingPrepare,
+    } as unknown as ConversationGraphMemory;
+    const deps = makeDeps({ graphMemory, isTrustedActor: true });
+
+    await expect(
+      runDefaultMemoryRetrieval(makeMemoryArgs(), deps),
+    ).rejects.toThrow("retrieval failed");
+  });
+
   test("passes through null PKB and NOW when the files are absent", async () => {
     readPkbContextMock.mockImplementation(() => null);
     readNowContextMock.mockImplementation(() => null);
@@ -314,7 +335,7 @@ describe("memoryRetrieval pipeline — default vs custom plugin", () => {
         (innerArgs: MemoryArgs) => runDefaultMemoryRetrieval(innerArgs, deps),
         args,
         makeTurnCtx(),
-        30, // tiny budget — real production path uses 5_000ms
+        30, // tiny pipeline budget to keep the test fast
       );
     } catch (err) {
       caught = err;

package/src/__tests__/normalize-onboarding.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  normalizeOnboardingContext,
+  normalizeTasks,
+  normalizeTools,
+  TASK_DISPLAY_LABELS,
+  TOOL_DISPLAY_NAMES,
+} from "../prompts/normalize-onboarding.js";
+import type { OnboardingContext } from "../types/onboarding-context.js";
+
+describe("normalizeTools", () => {
+  test("known tool IDs produce display labels", () => {
+    expect(normalizeTools(["github"])).toEqual(["GitHub"]);
+    expect(normalizeTools(["google-calendar"])).toEqual(["Google Calendar"]);
+    expect(normalizeTools(["slack"])).toEqual(["Slack"]);
+    expect(normalizeTools(["notion"])).toEqual(["Notion"]);
+    expect(normalizeTools(["linear"])).toEqual(["Linear"]);
+    expect(normalizeTools(["gmail"])).toEqual(["Gmail"]);
+    expect(normalizeTools(["google-drive"])).toEqual(["Google Drive"]);
+    expect(normalizeTools(["figma"])).toEqual(["Figma"]);
+    expect(normalizeTools(["jira"])).toEqual(["Jira"]);
+    expect(normalizeTools(["outlook"])).toEqual(["Outlook"]);
+    expect(normalizeTools(["excel"])).toEqual(["Excel"]);
+    expect(normalizeTools(["apple-notes"])).toEqual(["Apple Notes"]);
+  });
+
+  test("all known tool IDs from the client onboarding UI are mapped", () => {
+    const clientToolIds = [
+      "gmail",
+      "outlook",
+      "google-calendar",
+      "slack",
+      "notion",
+      "linear",
+      "jira",
+      "github",
+      "figma",
+      "google-drive",
+      "excel",
+      "apple-notes",
+    ];
+    expect(Object.keys(TOOL_DISPLAY_NAMES)).toEqual(
+      expect.arrayContaining(clientToolIds),
+    );
+    expect(Object.keys(TOOL_DISPLAY_NAMES)).toHaveLength(clientToolIds.length);
+  });
+
+  test("unknown/custom tool IDs pass through with first-letter capitalization", () => {
+    expect(normalizeTools(["trello"])).toEqual(["Trello"]);
+    expect(normalizeTools(["asana"])).toEqual(["Asana"]);
+  });
+
+  test("mixed known and unknown IDs normalize correctly", () => {
+    expect(normalizeTools(["github", "trello", "slack"])).toEqual([
+      "GitHub",
+      "Trello",
+      "Slack",
+    ]);
+  });
+
+  test("empty array produces empty array", () => {
+    expect(normalizeTools([])).toEqual([]);
+  });
+});
+
+describe("normalizeTasks", () => {
+  test("known task IDs produce plain-language labels", () => {
+    expect(normalizeTasks(["code-building"])).toEqual([
+      "builds code, apps, or tools",
+    ]);
+    expect(normalizeTasks(["writing"])).toEqual([
+      "writes docs, emails, or content",
+    ]);
+    expect(normalizeTasks(["research"])).toEqual([
+      "does research and analysis",
+    ]);
+    expect(normalizeTasks(["project-management"])).toEqual([
+      "plans and coordinates work",
+    ]);
+    expect(normalizeTasks(["scheduling"])).toEqual([
+      "handles meetings, calendar, and logistics",
+    ]);
+    expect(normalizeTasks(["personal"])).toEqual(["handles life admin"]);
+  });
+
+  test("all six known task IDs are mapped", () => {
+    const knownIds = [
+      "code-building",
+      "writing",
+      "research",
+      "project-management",
+      "scheduling",
+      "personal",
+    ];
+    expect(Object.keys(TASK_DISPLAY_LABELS)).toEqual(
+      expect.arrayContaining(knownIds),
+    );
+    expect(Object.keys(TASK_DISPLAY_LABELS)).toHaveLength(knownIds.length);
+  });
+
+  test("unknown/custom task IDs pass through unchanged", () => {
+    expect(normalizeTasks(["data-entry"])).toEqual(["data-entry"]);
+    expect(normalizeTasks(["custom-workflow"])).toEqual(["custom-workflow"]);
+  });
+
+  test("mixed known and unknown IDs normalize correctly", () => {
+    expect(normalizeTasks(["writing", "data-entry", "research"])).toEqual([
+      "writes docs, emails, or content",
+      "data-entry",
+      "does research and analysis",
+    ]);
+  });
+
+  test("empty array produces empty array", () => {
+    expect(normalizeTasks([])).toEqual([]);
+  });
+});
+
+describe("normalizeOnboardingContext", () => {
+  test("maps userName to preferredName", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "friendly",
+      userName: "Alice",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.preferredName).toBe("Alice");
+  });
+
+  test("absent userName yields undefined preferredName", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "professional",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.preferredName).toBeUndefined();
+  });
+
+  test("tone passes through", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "casual",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.tone).toBe("casual");
+  });
+
+  test("assistantName passes through", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "friendly",
+      assistantName: "Jarvis",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.assistantName).toBe("Jarvis");
+  });
+
+  test("normalizes tools and tasks together", () => {
+    const ctx: OnboardingContext = {
+      tools: ["github", "trello"],
+      tasks: ["code-building", "data-entry"],
+      tone: "professional",
+      userName: "Bob",
+      assistantName: "Friday",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result).toEqual({
+      preferredName: "Bob",
+      commonWork: ["builds code, apps, or tools", "data-entry"],
+      dailyTools: ["GitHub", "Trello"],
+      tone: "professional",
+      assistantName: "Friday",
+    });
+  });
+});

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 ----------------------------------

package/src/__tests__/oauth-cli.test.ts

@@ -62,6 +62,13 @@ let mockUpsertAppImpl:
 let mockOrchestrateOAuthConnect: (
   opts: Record<string, unknown>,
 ) => Promise<Record<string, unknown>>;
+let mockCliIpcCall: (
+  operationId: string,
+  params?: Record<string, unknown>,
+) => Promise<Record<string, unknown>> = async () => ({
+  ok: false,
+  error: "Could not connect to assistant daemon (test default)",
+});
 let mockGetAppByProviderAndClientId: (
   provider: string,
   clientId: string,
@@ -335,6 +342,15 @@ mock.module("../oauth/connect-orchestrator.js", () => ({
     mockOrchestrateOAuthConnect(opts),
 }));
 
+// ---------------------------------------------------------------------------
+// Mock cli-client (IPC) — used by `oauth connect` for daemon-orchestrated flow
+// ---------------------------------------------------------------------------
+
+mock.module("../ipc/cli-client.js", () => ({
+  cliIpcCall: (operationId: string, params?: Record<string, unknown>) =>
+    mockCliIpcCall(operationId, params),
+}));
+
 mock.module("../oauth/seed-providers.js", () => ({
   SEEDED_PROVIDER_KEYS: new Set([
     "google",
@@ -1220,6 +1236,111 @@ describe("assistant oauth connect managed mode — platform 401/403 errors", ()
   });
 });
 
+// ---------------------------------------------------------------------------
+// `assistant oauth connect <provider>` BYO mode — daemon-unreachable behavior.
+//
+// We deleted the in-process `orchestrateOAuthConnect` fallback (the same
+// pattern as the MCP CLI consolidation in #29484). When the daemon is
+// unreachable, the CLI must surface a clear error and exit 1 — never
+// silently fall back to in-process flow.
+// ---------------------------------------------------------------------------
+
+describe("assistant oauth connect <provider> — daemon unreachable (BYO mode)", () => {
+  beforeEach(() => {
+    // BYO provider with a registered app and no managed-mode wiring.
+    mockGetProvider = () => ({
+      provider: "github",
+      authorizeUrl: "https://github.com/login/oauth/authorize",
+      tokenExchangeUrl: "https://github.com/login/oauth/access_token",
+      defaultScopes: "[]",
+      availableScopes: null,
+      authorizeParams: null,
+      managedServiceConfigKey: null,
+      requiresClientSecret: false,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+    mockGetMostRecentAppByProvider = () => ({
+      provider: "github",
+      clientId: "test-client-id",
+      clientSecretCredentialPath: "oauth_app/github/test/client_secret",
+    });
+    mockGetSecureKey = () => "test-secret";
+    mockGetConfig = () => ({ services: {} });
+  });
+
+  test("daemon connect-refused → exit 1 with 'Is the assistant running?'", async () => {
+    mockCliIpcCall = async () => ({
+      ok: false,
+      error: "Could not connect to assistant daemon: ECONNREFUSED",
+    });
+
+    const { exitCode, stdout } = await runCli([
+      "connect",
+      "github",
+      "--no-browser",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("Could not reach the assistant");
+    expect(parsed.error).toContain("Is the assistant running?");
+  });
+
+  test("daemon route missing (Unknown method) → exit 1, never falls through to in-process", async () => {
+    let orchestratorCalls = 0;
+    mockOrchestrateOAuthConnect = async () => {
+      orchestratorCalls++;
+      return { success: true, deferred: false, grantedScopes: [] };
+    };
+    mockCliIpcCall = async () => ({
+      ok: false,
+      error: "Unknown method: internal_oauth_connect_start",
+    });
+
+    const { exitCode } = await runCli([
+      "connect",
+      "github",
+      "--no-browser",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    // Critical regression guard: the in-process `orchestrateOAuthConnect`
+    // must NOT be invoked from the CLI. The daemon-orchestrated path is
+    // the sole code path; this is the same invariant #29484 established
+    // for the MCP CLI.
+    expect(orchestratorCalls).toBe(0);
+  });
+
+  test("daemon HTTP error (statusCode set) → surfaces error verbatim, no fallback", async () => {
+    let orchestratorCalls = 0;
+    mockOrchestrateOAuthConnect = async () => {
+      orchestratorCalls++;
+      return { success: true, deferred: false, grantedScopes: [] };
+    };
+    mockCliIpcCall = async () => ({
+      ok: false,
+      statusCode: 400,
+      error: "service must be registered before connecting",
+    });
+
+    const { exitCode, stdout } = await runCli([
+      "connect",
+      "github",
+      "--no-browser",
+      "--json",
+    ]);
+
+    expect(exitCode).toBe(1);
+    const parsed = JSON.parse(stdout);
+    expect(parsed.error).toContain("service must be registered");
+    expect(orchestratorCalls).toBe(0);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // requirePlatformClient — improved error messages
 // ---------------------------------------------------------------------------