@vellumai/assistant 0.6.4 → 0.6.6

package/src/__tests__/filing-service.test.ts

@@ -0,0 +1,255 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+
+const testWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR!;
+
+// Mock config loader. Filing's `runOnce()` reads `getConfig().filing`, and
+// `executeRun()` no longer reads `config.speed` (PR 8) — the call site is
+// hardcoded to 'filingAgent' and the resolver picks up `llm.callSites.filingAgent`
+// inside the daemon's processMessage path.
+let mockConfig = {
+  filing: {
+    enabled: true,
+    intervalMs: 60_000,
+    speed: "standard" as "standard" | "fast",
+    activeHoursStart: null as number | null,
+    activeHoursEnd: null as number | null,
+  },
+};
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => mockConfig,
+  loadConfig: () => mockConfig,
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+// Mock conversation store
+const createdConversations: Array<{ title: string; conversationType: string }> =
+  [];
+let conversationIdCounter = 0;
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversationType: () => "default",
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  updateConversationTitle: () => {},
+  updateConversationUsage: () => {},
+  addMessage: () => ({ id: "mock-msg-id" }),
+  getMessages: () => [],
+  getConversation: () => ({
+    id: "conv-1",
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+    title: null,
+  }),
+  getMessageById: () => null,
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  createConversation: (opts: { title: string; conversationType: string }) => {
+    createdConversations.push(opts);
+    return { id: `conv-${++conversationIdCounter}`, ...opts };
+  },
+}));
+
+// Mock logger
+mock.module("../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+}));
+
+// Mock conversation title service
+mock.module("../memory/conversation-title-service.js", () => ({
+  GENERATING_TITLE: "Generating title...",
+  queueGenerateConversationTitle: () => {},
+}));
+
+// Import after mocks are set up
+const { FilingService } = await import("../filing/filing-service.js");
+
+describe("FilingService", () => {
+  let processMessageCalls: Array<{
+    conversationId: string;
+    content: string;
+    options?: { speed?: string; callSite?: string };
+  }>;
+
+  afterEach(() => {
+    // Clean up workspace files between tests so buffer-existence tests don't leak
+    const bufferPath = join(testWorkspaceDir, "pkb", "buffer.md");
+    try {
+      writeFileSync(bufferPath, "");
+    } catch {
+      // best-effort
+    }
+  });
+
+  beforeEach(() => {
+    processMessageCalls = [];
+    createdConversations.length = 0;
+    conversationIdCounter = 0;
+
+    mockConfig = {
+      filing: {
+        enabled: true,
+        intervalMs: 60_000,
+        speed: "standard",
+        activeHoursStart: null,
+        activeHoursEnd: null,
+      },
+    };
+
+    // Seed buffer.md with content so runOnce doesn't skip
+    const pkbDir = join(testWorkspaceDir, "pkb");
+    try {
+      mkdirSync(pkbDir, { recursive: true });
+    } catch {
+      // best-effort
+    }
+    writeFileSync(join(pkbDir, "buffer.md"), "- some buffered fact\n");
+  });
+
+  function createService(overrides?: {
+    processMessage?: (
+      id: string,
+      content: string,
+      options?: { speed?: string; callSite?: string },
+    ) => Promise<{ messageId: string }>;
+  }) {
+    return new FilingService({
+      processMessage:
+        overrides?.processMessage ??
+        (async (
+          conversationId: string,
+          content: string,
+          options?: { speed?: string; callSite?: string },
+        ) => {
+          processMessageCalls.push({ conversationId, content, options });
+          return { messageId: "msg-1" };
+        }),
+    });
+  }
+
+  test("runOnce() passes callSite: 'filingAgent' to processMessage", async () => {
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].options).toEqual({ callSite: "filingAgent" });
+    expect(processMessageCalls[0].options?.callSite).toBe("filingAgent");
+  });
+
+  test("runOnce() does not pass legacy 'speed' kwarg even when filing.speed is set", async () => {
+    // Filing's schema still carries `speed` (PR 19 will remove it), but PR 8
+    // stopped reading it. Ensure the new wiring no longer leaks the legacy
+    // kwarg through to processMessage.
+    mockConfig.filing.speed = "fast";
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].options?.speed).toBeUndefined();
+    expect(processMessageCalls[0].options?.callSite).toBe("filingAgent");
+  });
+
+  test("runOnce() invokes processMessage with the filing prompt template", async () => {
+    const service = createService();
+    await service.runOnce();
+
+    expect(processMessageCalls).toHaveLength(1);
+    expect(processMessageCalls[0].conversationId).toBe("conv-1");
+    expect(processMessageCalls[0].content).toContain(
+      "periodic knowledge base filing job",
+    );
+  });
+
+  test("creates background conversation with generating title placeholder", async () => {
+    const service = createService();
+    await service.runOnce();
+
+    expect(createdConversations).toHaveLength(1);
+    expect(createdConversations[0].title).toBe("Generating title...");
+    expect(createdConversations[0].conversationType).toBe("background");
+  });
+
+  describe("llm.callSites.filingAgent resolution", () => {
+    // These tests verify that the call-site name used by FilingService
+    // ('filingAgent') resolves through the unified `llm` config the way
+    // downstream consumers expect.
+
+    test("resolves to llm.default when no filingAgent override exists", () => {
+      const llm = LLMSchema.parse({
+        default: {
+          provider: "anthropic",
+          model: "claude-opus-4-7",
+          maxTokens: 64000,
+          effort: "max",
+          speed: "standard",
+        },
+      });
+      const resolved = resolveCallSiteConfig("filingAgent", llm);
+      expect(resolved.model).toBe("claude-opus-4-7");
+      expect(resolved.speed).toBe("standard");
+    });
+
+    test("call-site override on filingAgent wins over llm.default", () => {
+      const llm = LLMSchema.parse({
+        default: {
+          provider: "anthropic",
+          model: "claude-opus-4-7",
+          maxTokens: 64000,
+          effort: "max",
+          speed: "standard",
+        },
+        callSites: {
+          filingAgent: { speed: "fast", model: "claude-haiku-4-7" },
+        },
+      });
+      const resolved = resolveCallSiteConfig("filingAgent", llm);
+      expect(resolved.model).toBe("claude-haiku-4-7");
+      expect(resolved.speed).toBe("fast");
+      // Sibling defaults remain untouched.
+      expect(resolved.provider).toBe("anthropic");
+      expect(resolved.maxTokens).toBe(64000);
+    });
+
+    test("filingAgent profile reference resolves through profile fragment", () => {
+      const llm = LLMSchema.parse({
+        default: {
+          provider: "anthropic",
+          model: "claude-opus-4-7",
+          maxTokens: 64000,
+          effort: "max",
+          speed: "standard",
+        },
+        profiles: {
+          background: { speed: "fast", effort: "low" },
+        },
+        callSites: {
+          filingAgent: { profile: "background" },
+        },
+      });
+      const resolved = resolveCallSiteConfig("filingAgent", llm);
+      expect(resolved.speed).toBe("fast");
+      expect(resolved.effort).toBe("low");
+      expect(resolved.model).toBe("claude-opus-4-7");
+    });
+  });
+});

package/src/__tests__/first-greeting.test.ts

@@ -6,6 +6,7 @@ const tempDir = process.env.VELLUM_WORKSPACE_DIR!;
 
 const { isWakeUpGreeting, getCannedFirstGreeting, CANNED_FIRST_GREETING } =
   await import("../daemon/first-greeting.js");
+import type { OnboardingGreetingContext } from "../daemon/first-greeting.js";
 
 describe("first-greeting", () => {
   describe("isWakeUpGreeting", () => {
@@ -48,12 +49,253 @@ describe("first-greeting", () => {
     });
   });
 
-  describe("getCannedFirstGreeting", () => {
-    it("returns the expected greeting string", () => {
-      const greeting = getCannedFirstGreeting();
+  describe("no-onboarding branch", () => {
+    it("returns no-onboarding greeting when context is undefined", () => {
+      expect(getCannedFirstGreeting(undefined)).toBe(CANNED_FIRST_GREETING);
+    });
+
+    it("returns no-onboarding greeting when everything is empty", () => {
+      const greeting = getCannedFirstGreeting({
+        tools: [],
+        tasks: [],
+        tone: "",
+      });
       expect(greeting).toBe(CANNED_FIRST_GREETING);
-      expect(greeting).toContain("brand new");
-      expect(greeting).toContain("No name, no memories");
+    });
+
+    it("no-onboarding greeting uses two-paragraph structure", () => {
+      expect(CANNED_FIRST_GREETING).toContain("\n\n");
+      expect(CANNED_FIRST_GREETING).toContain("I can ask");
+    });
+  });
+
+  describe("personalized greeting", () => {
+    const base: OnboardingGreetingContext = {
+      tools: [],
+      tasks: [],
+      tone: "balanced",
+    };
+
+    it("full dev stack: GitHub + Linear, Building + PM", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tools: ["github", "linear"],
+        tasks: ["code-building", "project-management"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("Hey Bob, I'm Pip.");
+      expect(greeting).toContain("You mentioned using GitHub and Linear");
+      expect(greeting).toContain(
+        "shipping code or figuring out what to ship next",
+      );
+      expect(greeting).toContain("\n\n");
+    });
+
+    it("PM + comms: Linear + Notion, PM + Writing", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tools: ["linear", "notion"],
+        tasks: ["project-management", "writing"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("You mentioned using Notion and Linear");
+      expect(greeting).toContain("writing a spec or pushing something forward");
+    });
+
+    it("writer: Notion + Google Drive, Writing only", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tools: ["notion", "google-drive"],
+        tasks: ["writing"],
+        userName: "Bob",
+        assistantName: "Luna",
+      });
+      expect(greeting).toContain("You mentioned using Notion and Google Drive");
+      expect(greeting).toContain("drafting something or cleaning up docs");
+    });
+
+    it("single task no tools: Building only", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tasks: ["code-building"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("Probably shipping something or debugging");
+      expect(greeting).not.toContain("You mentioned using");
+    });
+
+    it("single tool single task: GitHub + Building", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tools: ["github"],
+        tasks: ["code-building"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("You mentioned using GitHub");
+    });
+
+    it("many hats: 4 selections", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tasks: ["code-building", "writing", "research", "project-management"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("wear a lot of hats");
+      expect(greeting).toContain("Where should we start?");
+    });
+
+    it("many hats: 6 selections", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tasks: [
+          "code-building",
+          "writing",
+          "research",
+          "project-management",
+          "scheduling",
+          "personal",
+        ],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("wear a lot of hats");
+    });
+
+    it("no tasks with tools: no-signal branch", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tools: ["gmail", "linear"],
+        tasks: [],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("What's on your plate?");
+      expect(greeting).toContain("I can ask you a few questions");
+    });
+
+    it("missing name uses Hey comma opener", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tasks: ["code-building"],
+        assistantName: "Pip",
+      });
+      expect(greeting).toStartWith("Hey, I'm Pip.");
+    });
+
+    it("3-selection falls back to highest-priority single template", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tasks: ["writing", "research", "scheduling"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("drafting something or cleaning up docs");
+    });
+
+    it("unlisted 2-combo falls back to highest-priority single", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tasks: ["research", "personal"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain(
+        "digging into a topic or making sense of something",
+      );
+    });
+
+    it("uses capital I throughout", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tasks: ["code-building"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("I'm Pip");
+      expect(greeting).toContain("I'll get sharper");
+      expect(greeting).toContain("Am I on the right track");
+    });
+
+    it("two-paragraph structure with blank line", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tasks: ["code-building"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      const paragraphs = greeting.split("\n\n");
+      expect(paragraphs.length).toBe(2);
+    });
+
+    it("picks relevant tools for guess, not arbitrary selection order", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tools: [
+          "notion",
+          "linear",
+          "gmail",
+          "google-calendar",
+          "github",
+          "apple-notes",
+        ],
+        tasks: ["code-building", "project-management"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("You mentioned using GitHub and Linear");
+      expect(greeting).not.toContain("Apple Notes");
+      expect(greeting).not.toContain("Notion");
+    });
+
+    it("falls back to no-tool prefix when no relevant tools match", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tools: ["notion", "apple-notes"],
+        tasks: ["code-building"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("Probably shipping something or debugging");
+      expect(greeting).not.toContain("You mentioned using");
+    });
+
+    it("life admin guess uses verb phrase", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tools: ["gmail", "google-calendar"],
+        tasks: ["personal"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain(
+        "You mentioned using Gmail and Google Calendar",
+      );
+      expect(greeting).toContain("juggling travel, bills, or household stuff");
+    });
+
+    it("uses personalized greeting when assistantName present but no user name/tasks/tools", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("I'm Pip");
+      expect(greeting).not.toContain("no name, no memories");
+    });
+
+    it("falls back to no-signal branch for unknown task types", () => {
+      const greeting = getCannedFirstGreeting({
+        ...base,
+        tasks: ["future-task-type"],
+        userName: "Bob",
+        assistantName: "Pip",
+      });
+      expect(greeting).toContain("What's on your plate?");
+      expect(greeting).not.toContain("\n\n\n");
     });
   });
 });

package/src/__tests__/gemini-provider.test.ts

@@ -422,7 +422,6 @@ describe("GeminiProvider", () => {
     expect(contents[1].role).toBe("model");
     expect(contents[1].parts[0]).toEqual({
       functionCall: {
-        id: "call_abc",
         name: "file_read",
         args: { path: "/tmp/test" },
       },
@@ -430,7 +429,6 @@ describe("GeminiProvider", () => {
     expect(contents[2].role).toBe("user");
     expect(contents[2].parts[0]).toEqual({
       functionResponse: {
-        id: "call_abc",
         name: "file_read",
         response: { output: "file content here" },
       },
@@ -464,7 +462,6 @@ describe("GeminiProvider", () => {
     }>;
     expect(contents[0].parts[0]).toEqual({
       functionResponse: {
-        id: "unknown_id",
         name: "unknown_id",
         response: { output: "some result" },
       },

package/src/__tests__/guardian-grant-minting.test.ts

@@ -31,6 +31,10 @@ import {
 import * as approvalMessageComposer from "../runtime/approval-message-composer.js";
 import * as gatewayClient from "../runtime/gateway-client.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
+import {
+  _clearApprovalPromptTsTrackerForTesting,
+  trackApprovalPromptTs,
+} from "../runtime/routes/approval-prompt-ts-tracker.js";
 import { handleApprovalInterception } from "../runtime/routes/guardian-approval-interception.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 
@@ -60,6 +64,7 @@ function resetTables(): void {
     /* tables may not exist yet */
   }
   pendingInteractions.clear();
+  _clearApprovalPromptTsTrackerForTesting();
 }
 
 function createTestGuardianApproval(
@@ -227,6 +232,8 @@ describe("guardian grant minting on tool-approval decisions", () => {
       TOOL_NAME,
       TOOL_INPUT,
     );
+    const approvalMessageTs = "1700000000.000100";
+    trackApprovalPromptTs("slack", GUARDIAN_CHAT, approvalMessageTs);
 
     const result = await handleApprovalInterception({
       conversationId: "guardian-conv-1",
@@ -238,6 +245,7 @@ describe("guardian grant minting on tool-approval decisions", () => {
       replyCallbackUrl: "https://gateway.test/deliver",
       trustCtx: makeTrustContext(),
       assistantId: ASSISTANT_ID,
+      approvalMessageTs,
     });
 
     expect(result.handled).toBe(true);

package/src/__tests__/headless-browser-interactions.test.ts

@@ -392,7 +392,7 @@ describe("executeBrowserClick (CDP)", () => {
     const result = await executeBrowserClick({ element_id: "e99" }, ctx);
     expect(result.isError).toBe(true);
     expect(result.content).toContain('element_id "e99" not found');
-    expect(result.content).toContain("browser_snapshot");
+    expect(result.content).toContain("snapshot");
     // Resolution failed before acquiring a CdpClient.
     expect(sendCalls).toHaveLength(0);
   });

package/src/__tests__/headless-browser-mode.test.ts

@@ -550,6 +550,63 @@ describe("browser_mode wiring through tool execution", () => {
     expect(result.content).toContain("Remediation:");
   });
 
+  // ── Transport-classified host-browser errors produce failover diagnostics ──
+
+  test("pinned extension with transport-classified host_browser error surfaces failover diagnostics", async () => {
+    // Simulate a structured transport error envelope from the host_browser
+    // dispatcher (e.g. { code: "unreachable", message: "..." }) that the
+    // extension-cdp-client now classifies as transport_error.
+    factoryThrowError = new CdpError(
+      "transport_error",
+      "Host browser not reachable",
+      {
+        attemptDiagnostics: [
+          {
+            candidateKind: "extension",
+            inclusionReason: "pinned mode: extension",
+            stage: "send",
+            errorCode: "transport_error",
+            errorMessage: "Host browser not reachable",
+          },
+        ],
+      },
+    );
+
+    const result = await executeBrowserNavigate(
+      { url: "https://example.com", browser_mode: "extension" },
+      ctx,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Browser mode "extension" failed');
+    expect(result.content).toContain("extension: FAILED at send");
+    expect(result.content).toContain("Reason: Host browser not reachable");
+    expect(result.content).toContain("Remediation:");
+    expect(result.content).toContain("extension is installed and enabled");
+  });
+
+  test("pinned extension with timeout transport error surfaces failover diagnostics in snapshot", async () => {
+    factoryThrowError = new CdpError("transport_error", "CDP call timed out", {
+      attemptDiagnostics: [
+        {
+          candidateKind: "extension",
+          inclusionReason: "pinned mode: extension",
+          stage: "send",
+          errorCode: "transport_error",
+          errorMessage: "CDP call timed out",
+        },
+      ],
+    });
+
+    const result = await executeBrowserSnapshot(
+      { browser_mode: "extension" },
+      ctx,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Browser mode "extension" failed');
+    expect(result.content).toContain("extension: FAILED at send");
+    expect(result.content).toContain("Remediation:");
+  });
+
   // ── Per-conversation sticky backend kind ─────────────────────────
 
   test("auto-mode call after an explicit pin sticks to the pinned kind", async () => {