@vellumai/assistant 0.6.5 → 0.6.6

package/src/__tests__/empty-response-pipeline.test.ts

@@ -0,0 +1,305 @@
+/**
+ * Tests for the `emptyResponse` plugin pipeline (PR 18).
+ *
+ * Covers:
+ * - Default plugin decision matches the original inline loop logic for the
+ *   canonical cases (empty-after-tools → nudge, visible-text → accept,
+ *   tool-use-blocks-present → accept, retries-exhausted → accept,
+ *   prior-visible-text-in-run → accept).
+ * - Swapping in a custom middleware that returns `action: "accept"` prevents
+ *   the nudge and lets the loop fall through to history append.
+ * - Swapping in a custom middleware that returns `action: "error"` is
+ *   propagated by the pipeline so the loop can surface a clear error.
+ *
+ * The loop's actual side-effects (history append, retry counter bump, log
+ * emission) live in `agent/loop.ts` and are covered by integration tests in
+ * `conversation-agent-loop.test.ts`. This file isolates the pipeline.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+import {
+  defaultEmptyResponsePlugin,
+  defaultEmptyResponseTerminal,
+} from "../plugins/defaults/empty-response.js";
+import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
+import {
+  getMiddlewaresFor,
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type {
+  EmptyResponseArgs,
+  EmptyResponseDecision,
+  Middleware,
+  Plugin,
+  TurnContext,
+} from "../plugins/types.js";
+import type { ContentBlock } from "../providers/types.js";
+
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+
+const trust: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+};
+
+function makeCtx(): TurnContext {
+  return {
+    requestId: "req-empty-response",
+    conversationId: "conv-empty-response",
+    turnIndex: 2,
+    trust,
+  };
+}
+
+/**
+ * The nudge text has to match the loop's original inline string verbatim —
+ * clients (and the model) may match on this exact text.
+ */
+const CANONICAL_NUDGE_TEXT =
+  "<system_notice>Your previous response was empty. You must respond to the user with a summary of what you found or did. Do not use any tools — just respond with text.</system_notice>";
+
+const emptyTextBlock: ContentBlock = { type: "text", text: "   " };
+
+function makeArgs(
+  overrides: Partial<EmptyResponseArgs> = {},
+): EmptyResponseArgs {
+  return {
+    responseContent: [],
+    toolUseBlocksLength: 0,
+    toolUseTurns: 1,
+    emptyResponseRetries: 0,
+    maxEmptyResponseRetries: 1,
+    priorAssistantHadVisibleText: false,
+    ...overrides,
+  };
+}
+
+async function runEmpty(
+  args: EmptyResponseArgs,
+): Promise<EmptyResponseDecision> {
+  return runPipeline(
+    "emptyResponse",
+    getMiddlewaresFor("emptyResponse"),
+    async (a) => defaultEmptyResponseTerminal(a),
+    args,
+    makeCtx(),
+    DEFAULT_TIMEOUTS.emptyResponse,
+  );
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("emptyResponse pipeline — default decisions", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultEmptyResponsePlugin);
+  });
+
+  test("empty turn after tool results → nudge with canonical text", async () => {
+    // Whitespace-only text counts as empty (matches inline `trim().length > 0`).
+    const decision = await runEmpty(
+      makeArgs({
+        responseContent: [emptyTextBlock],
+        toolUseBlocksLength: 0,
+        toolUseTurns: 2,
+        emptyResponseRetries: 0,
+        priorAssistantHadVisibleText: false,
+      }),
+    );
+    expect(decision.action).toBe("nudge");
+    expect(decision.nudgeText).toBe(CANONICAL_NUDGE_TEXT);
+  });
+
+  test("turn contains visible text → accept", async () => {
+    const decision = await runEmpty(
+      makeArgs({
+        responseContent: [{ type: "text", text: "here is a summary" }],
+      }),
+    );
+    expect(decision.action).toBe("accept");
+  });
+
+  test("turn contains tool_use blocks → accept (not empty)", async () => {
+    const decision = await runEmpty(
+      makeArgs({
+        responseContent: [
+          {
+            type: "tool_use",
+            id: "tu-1",
+            name: "read",
+            input: { path: "/tmp/x" },
+          } as ContentBlock,
+        ],
+        toolUseBlocksLength: 1,
+      }),
+    );
+    expect(decision.action).toBe("accept");
+  });
+
+  test("retries already exhausted → accept", async () => {
+    const decision = await runEmpty(
+      makeArgs({
+        responseContent: [],
+        toolUseTurns: 3,
+        emptyResponseRetries: 1,
+        maxEmptyResponseRetries: 1,
+      }),
+    );
+    expect(decision.action).toBe("accept");
+  });
+
+  test("prior assistant turn already delivered visible text → accept", async () => {
+    // Model said its piece earlier, ended with a side-effect tool, returned
+    // empty. Nudging would force a verbatim re-send of text the user already
+    // saw. Default must accept.
+    const decision = await runEmpty(
+      makeArgs({
+        responseContent: [],
+        toolUseTurns: 2,
+        priorAssistantHadVisibleText: true,
+      }),
+    );
+    expect(decision.action).toBe("accept");
+  });
+
+  test("no prior tool-use turn (toolUseTurns === 0) → accept", async () => {
+    // Empty first assistant response with no tools is not the pattern the
+    // nudge guards against. Default accepts.
+    const decision = await runEmpty(
+      makeArgs({
+        responseContent: [],
+        toolUseTurns: 0,
+      }),
+    );
+    expect(decision.action).toBe("accept");
+  });
+});
+
+describe("emptyResponse pipeline — custom middleware overrides", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+  });
+
+  test("plugin returning action:accept suppresses the nudge", async () => {
+    // Build a plugin whose middleware short-circuits with accept. Register it
+    // as the ONLY plugin so its decision is authoritative. The loop-side
+    // effect (no nudge appended) is covered by integration tests; here we
+    // assert the pipeline returns what the plugin returned.
+    const acceptPlugin: Plugin = {
+      manifest: {
+        name: "force-accept",
+        version: "1.0.0",
+        requires: { pluginRuntime: "v1" },
+      },
+      middleware: {
+        emptyResponse: async () => ({ action: "accept" }),
+      },
+    };
+    registerPlugin(acceptPlugin);
+
+    const decision = await runEmpty(
+      makeArgs({
+        // Conditions the default would nudge on — but the custom plugin wins.
+        responseContent: [],
+        toolUseTurns: 2,
+        emptyResponseRetries: 0,
+        priorAssistantHadVisibleText: false,
+      }),
+    );
+    expect(decision.action).toBe("accept");
+    // `nudgeText` must not leak from the acceptance branch.
+    expect(decision.nudgeText).toBeUndefined();
+  });
+
+  test("plugin returning action:error is propagated to the caller", async () => {
+    const errorPlugin: Plugin = {
+      manifest: {
+        name: "force-error",
+        version: "1.0.0",
+        requires: { pluginRuntime: "v1" },
+      },
+      middleware: {
+        emptyResponse: async () => ({ action: "error" }),
+      },
+    };
+    registerPlugin(errorPlugin);
+
+    const decision = await runEmpty(makeArgs());
+    expect(decision.action).toBe("error");
+  });
+
+  test("plugin overriding default nudge text changes the returned text", async () => {
+    // Exercises the wrapping semantics: the custom plugin observes the
+    // default's decision via `next(args)` and rewrites only the text. This
+    // is the canonical "plugin wraps default" pattern.
+    const rewriterPlugin: Plugin = {
+      manifest: {
+        name: "rewrite-nudge",
+        version: "1.0.0",
+        requires: { pluginRuntime: "v1" },
+      },
+      middleware: {
+        emptyResponse: async (args, next, ctx) => {
+          const downstream = await next(args);
+          if (downstream.action !== "nudge") return downstream;
+          void ctx; // silence lint
+          return { action: "nudge", nudgeText: "ALTERED_NUDGE" };
+        },
+      },
+    };
+    // Register the custom plugin FIRST so it is the outermost middleware; the
+    // default registers second and acts as the inner decision maker.
+    registerPlugin(rewriterPlugin);
+    registerPlugin(defaultEmptyResponsePlugin);
+
+    const decision = await runEmpty(
+      makeArgs({
+        responseContent: [],
+        toolUseTurns: 2,
+        priorAssistantHadVisibleText: false,
+      }),
+    );
+    expect(decision.action).toBe("nudge");
+    expect(decision.nudgeText).toBe("ALTERED_NUDGE");
+  });
+
+  test("user plugin registered AFTER the default still runs (no shadowing)", async () => {
+    // Production registration order: defaults load first via the side-effect
+    // imports in `defaults/index.ts`, then user plugins register on top via
+    // `bootstrapPlugins()`. The user's middleware ends up at a deeper onion
+    // layer than the default. If the default's middleware were to bypass
+    // `next` and decide directly, the user middleware would never run — this
+    // test guards against that regression.
+    registerPlugin(defaultEmptyResponsePlugin);
+
+    let userMiddlewareRan = false;
+    const userMiddleware: Middleware<
+      EmptyResponseArgs,
+      EmptyResponseDecision
+    > = async (args, next) => {
+      userMiddlewareRan = true;
+      return next(args);
+    };
+    registerPlugin({
+      manifest: {
+        name: "late-user-empty-response",
+        version: "0.0.1",
+        requires: { pluginRuntime: "v1", emptyResponseApi: "v1" },
+      },
+      middleware: { emptyResponse: userMiddleware },
+    });
+
+    await runEmpty(
+      makeArgs({
+        responseContent: [],
+        toolUseTurns: 2,
+        priorAssistantHadVisibleText: false,
+      }),
+    );
+
+    expect(userMiddlewareRan).toBe(true);
+  });
+});

package/src/__tests__/extension-id-sync-guard.test.ts

@@ -16,7 +16,7 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-import { ALLOWED_EXTENSION_ORIGINS } from "../runtime/routes/browser-extension-pair-routes.js";
+import { getAllowedExtensionOrigins } from "../runtime/routes/browser-extension-pair-routes.js";
 
 const repoRoot = resolve(__dirname, "..", "..", "..");
 const CANONICAL_CONFIG_REL_PATH =
@@ -176,7 +176,7 @@ describe("Chrome extension allowlist guard", () => {
     const config = parseCanonicalConfig();
     for (const id of config.allowedExtensionIds) {
       const origin = `chrome-extension://${id}/`;
-      expect(ALLOWED_EXTENSION_ORIGINS.has(origin)).toBe(true);
+      expect(getAllowedExtensionOrigins().has(origin)).toBe(true);
     }
   });
 
@@ -198,7 +198,7 @@ describe("Chrome extension allowlist guard", () => {
     const expectedOrigins = new Set(
       config.allowedExtensionIds.map((id) => `chrome-extension://${id}/`),
     );
-    expect(new Set(ALLOWED_EXTENSION_ORIGINS)).toEqual(expectedOrigins);
+    expect(new Set(getAllowedExtensionOrigins())).toEqual(expectedOrigins);
   });
 
   test("concrete extension IDs appear only in canonical config or CWS URLs", () => {

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__/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 () => {