@vellumai/assistant 0.7.0 → 0.7.1

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

@@ -65,7 +65,15 @@ describe("first-greeting", () => {
 
     it("no-onboarding greeting uses two-paragraph structure", () => {
       expect(CANNED_FIRST_GREETING).toContain("\n\n");
-      expect(CANNED_FIRST_GREETING).toContain("I can ask");
+      const paragraphs = CANNED_FIRST_GREETING.split("\n\n");
+      expect(paragraphs.length).toBe(2);
+    });
+
+    it("no-onboarding greeting does not contain old self-deprecation text", () => {
+      expect(CANNED_FIRST_GREETING).not.toContain("no name, no memories");
+      expect(CANNED_FIRST_GREETING).not.toContain("Brand new");
+      expect(CANNED_FIRST_GREETING).not.toContain("I can ask");
+      expect(CANNED_FIRST_GREETING).not.toContain("get sharper");
     });
   });
 
@@ -73,229 +81,227 @@ describe("first-greeting", () => {
     const base: OnboardingGreetingContext = {
       tools: [],
       tasks: [],
-      tone: "balanced",
+      tone: "grounded",
     };
 
-    it("full dev stack: GitHub + Linear, Building + PM", () => {
+    it("grounded + name + assistantName", () => {
       const greeting = getCannedFirstGreeting({
         ...base,
-        tools: ["github", "linear"],
-        tasks: ["code-building", "project-management"],
-        userName: "Bob",
-        assistantName: "Pip",
+        tone: "grounded",
+        userName: "Alice",
+        assistantName: "Pax",
       });
-      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).toBe(
+        "Hey Alice, I'm Pax.\n\nWe can get into whatever you've got, or just talk first — that tends to go better. Up to you.",
       );
-      expect(greeting).toContain("\n\n");
     });
 
-    it("PM + comms: Linear + Notion, PM + Writing", () => {
+    it("warm + name + assistantName", () => {
       const greeting = getCannedFirstGreeting({
         ...base,
-        tools: ["linear", "notion"],
-        tasks: ["project-management", "writing"],
-        userName: "Bob",
-        assistantName: "Pip",
+        tone: "warm",
+        userName: "Alice",
+        assistantName: "Remy",
       });
-      expect(greeting).toContain("You mentioned using Notion and Linear");
-      expect(greeting).toContain("writing a spec or pushing something forward");
+      expect(greeting).toBe(
+        "Hey Alice, I'm Remy. Good to meet you.\n\nWe can start on something specific, or just talk for a bit first — honestly that tends to work out better. Either way, I'm here.",
+      );
     });
 
-    it("writer: Notion + Google Drive, Writing only", () => {
+    it("energetic + no names", () => {
       const greeting = getCannedFirstGreeting({
         ...base,
-        tools: ["notion", "google-drive"],
-        tasks: ["writing"],
-        userName: "Bob",
-        assistantName: "Luna",
+        tone: "energetic",
+        assistantName: "Pax",
       });
-      expect(greeting).toContain("You mentioned using Notion and Google Drive");
-      expect(greeting).toContain("drafting something or cleaning up docs");
+      expect(greeting).toBe(
+        "Hey, I'm Pax. Let's see what you've got.\n\nWe can jump straight into whatever you've got, or take a few minutes to just talk first. What sounds right?",
+      );
     });
 
-    it("single task no tools: Building only", () => {
+    it("poetic + name + assistantName", () => {
       const greeting = getCannedFirstGreeting({
         ...base,
-        tasks: ["code-building"],
-        userName: "Bob",
-        assistantName: "Pip",
+        tone: "poetic",
+        userName: "Alice",
+        assistantName: "Pax",
       });
-      expect(greeting).toContain("Probably shipping something or debugging");
-      expect(greeting).not.toContain("You mentioned using");
+      expect(greeting).toBe(
+        "Hey Alice, I'm Pax.\n\nWe can start with whatever's in front of you, or just talk for a bit first. Either way.",
+      );
     });
 
-    it("single tool single task: GitHub + Building", () => {
+    it("name only (no assistantName)", () => {
       const greeting = getCannedFirstGreeting({
         ...base,
-        tools: ["github"],
-        tasks: ["code-building"],
-        userName: "Bob",
-        assistantName: "Pip",
+        tone: "grounded",
+        userName: "Alice",
       });
-      expect(greeting).toContain("You mentioned using GitHub");
+      expect(greeting).toBe(
+        "Hey Alice,\n\nWe can get into whatever you've got, or just talk first — that tends to go better. Up to you.",
+      );
     });
 
-    it("many hats: 4 selections", () => {
+    it("assistantName only (no userName)", () => {
       const greeting = getCannedFirstGreeting({
         ...base,
-        tasks: ["code-building", "writing", "research", "project-management"],
-        userName: "Bob",
-        assistantName: "Pip",
+        tone: "grounded",
+        assistantName: "Pax",
       });
-      expect(greeting).toContain("wear a lot of hats");
-      expect(greeting).toContain("Where should we start?");
+      expect(greeting).toBe(
+        "Hey, I'm Pax.\n\nWe can get into whatever you've got, or just talk first — that tends to go better. Up to you.",
+      );
     });
 
-    it("many hats: 6 selections", () => {
+    it("no name, no assistantName, no tone returns CANNED_FIRST_GREETING", () => {
       const greeting = getCannedFirstGreeting({
-        ...base,
-        tasks: [
-          "code-building",
-          "writing",
-          "research",
-          "project-management",
-          "scheduling",
-          "personal",
-        ],
-        userName: "Bob",
-        assistantName: "Pip",
+        tools: [],
+        tasks: [],
+        tone: "",
       });
-      expect(greeting).toContain("wear a lot of hats");
+      expect(greeting).toBe(CANNED_FIRST_GREETING);
     });
 
-    it("no tasks with tools: no-signal branch", () => {
+    it("no names but valid tone uses tone-aware greeting", () => {
       const greeting = getCannedFirstGreeting({
-        ...base,
-        tools: ["gmail", "linear"],
+        tools: [],
         tasks: [],
-        userName: "Bob",
-        assistantName: "Pip",
+        tone: "warm",
       });
-      expect(greeting).toContain("What's on your plate?");
-      expect(greeting).toContain("I can ask you a few questions");
+      expect(greeting).toBe(
+        "Hey,\n\nWe can start on something specific, or just talk for a bit first — honestly that tends to work out better. Either way, I'm here.",
+      );
     });
 
-    it("missing name uses Hey comma opener", () => {
-      const greeting = getCannedFirstGreeting({
-        ...base,
-        tasks: ["code-building"],
-        assistantName: "Pip",
-      });
-      expect(greeting).toStartWith("Hey, I'm Pip.");
+    it("each valid tone with no names produces distinct invite", () => {
+      const greetings = ["grounded", "warm", "energetic", "poetic"].map(
+        (tone) => getCannedFirstGreeting({ tools: [], tasks: [], tone }),
+      );
+      const unique = new Set(greetings);
+      expect(unique.size).toBe(4);
     });
 
-    it("3-selection falls back to highest-priority single template", () => {
+    it("unknown tone falls back to grounded defaults", () => {
       const greeting = getCannedFirstGreeting({
         ...base,
-        tasks: ["writing", "research", "scheduling"],
-        userName: "Bob",
-        assistantName: "Pip",
+        tone: "mysterious-future-tone",
+        userName: "Alice",
+        assistantName: "Pax",
       });
-      expect(greeting).toContain("drafting something or cleaning up docs");
+      expect(greeting).toBe(
+        "Hey Alice, I'm Pax.\n\nWe can get into whatever you've got, or just talk first — that tends to go better. Up to you.",
+      );
     });
 
-    it("unlisted 2-combo falls back to highest-priority single", () => {
+    it("two-paragraph structure preserved", () => {
       const greeting = getCannedFirstGreeting({
         ...base,
-        tasks: ["research", "personal"],
-        userName: "Bob",
-        assistantName: "Pip",
+        tone: "grounded",
+        userName: "Alice",
+        assistantName: "Pax",
       });
-      expect(greeting).toContain(
-        "digging into a topic or making sense of something",
+      const paragraphs = greeting.split("\n\n");
+      expect(paragraphs.length).toBe(2);
+    });
+  });
+
+  describe("tone-specific greetings", () => {
+    const base: OnboardingGreetingContext = {
+      tools: [],
+      tasks: [],
+      tone: "grounded",
+      userName: "Bob",
+      assistantName: "Pax",
+    };
+
+    it("grounded intro close is empty, invite is grounded", () => {
+      const greeting = getCannedFirstGreeting({ ...base, tone: "grounded" });
+      const [intro, invite] = greeting.split("\n\n");
+      expect(intro).toBe("Hey Bob, I'm Pax.");
+      expect(invite).toBe(
+        "We can get into whatever you've got, or just talk first — that tends to go better. Up to you.",
       );
     });
 
-    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("warm intro close is 'Good to meet you.', invite is warm", () => {
+      const greeting = getCannedFirstGreeting({ ...base, tone: "warm" });
+      const [intro, invite] = greeting.split("\n\n");
+      expect(intro).toBe("Hey Bob, I'm Pax. Good to meet you.");
+      expect(invite).toBe(
+        "We can start on something specific, or just talk for a bit first — honestly that tends to work out better. Either way, I'm here.",
+      );
     });
 
-    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("energetic intro close is 'Let's see what you've got.', invite is energetic", () => {
+      const greeting = getCannedFirstGreeting({ ...base, tone: "energetic" });
+      const [intro, invite] = greeting.split("\n\n");
+      expect(intro).toBe("Hey Bob, I'm Pax. Let's see what you've got.");
+      expect(invite).toBe(
+        "We can jump straight into whatever you've got, or take a few minutes to just talk first. What sounds right?",
+      );
     });
 
-    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("poetic intro close is empty, invite is poetic", () => {
+      const greeting = getCannedFirstGreeting({ ...base, tone: "poetic" });
+      const [intro, invite] = greeting.split("\n\n");
+      expect(intro).toBe("Hey Bob, I'm Pax.");
+      expect(invite).toBe(
+        "We can start with whatever's in front of you, or just talk for a bit first. Either way.",
+      );
     });
 
-    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",
+    it("each tone produces a distinct full greeting", () => {
+      const tones = ["grounded", "warm", "energetic", "poetic"];
+      const greetings = tones.map((tone) => {
+        return getCannedFirstGreeting({ ...base, tone });
       });
-      expect(greeting).toContain("Probably shipping something or debugging");
-      expect(greeting).not.toContain("You mentioned using");
+      const unique = new Set(greetings);
+      expect(unique.size).toBe(tones.length);
     });
 
-    it("life admin guess uses verb phrase", () => {
-      const greeting = getCannedFirstGreeting({
-        ...base,
-        tools: ["gmail", "google-calendar"],
-        tasks: ["personal"],
-        userName: "Bob",
-        assistantName: "Pip",
+    it("each tone produces distinct invite text", () => {
+      const tones = ["grounded", "warm", "energetic", "poetic"];
+      const invites = tones.map((tone) => {
+        const greeting = getCannedFirstGreeting({ ...base, tone });
+        return greeting.split("\n\n")[1];
       });
-      expect(greeting).toContain(
-        "You mentioned using Gmail and Google Calendar",
-      );
-      expect(greeting).toContain("juggling travel, bills, or household stuff");
+      const unique = new Set(invites);
+      expect(unique.size).toBe(tones.length);
     });
+  });
 
-    it("uses personalized greeting when assistantName present but no user name/tasks/tools", () => {
+  describe("tasks and tools fields are ignored", () => {
+    it("tasks do not appear in output", () => {
       const greeting = getCannedFirstGreeting({
-        ...base,
-        assistantName: "Pip",
+        tools: ["github", "linear"],
+        tasks: ["code-building", "project-management"],
+        tone: "grounded",
+        userName: "Alice",
+        assistantName: "Pax",
       });
-      expect(greeting).toContain("I'm Pip");
-      expect(greeting).not.toContain("no name, no memories");
+      expect(greeting).not.toContain("GitHub");
+      expect(greeting).not.toContain("Linear");
+      expect(greeting).not.toContain("code");
+      expect(greeting).not.toContain("shipping");
+      expect(greeting).not.toContain("You mentioned using");
+      expect(greeting).not.toContain("wear a lot of hats");
+      expect(greeting).not.toContain("Am I on the right track");
     });
 
-    it("falls back to no-signal branch for unknown task types", () => {
+    it("tools do not appear in output", () => {
       const greeting = getCannedFirstGreeting({
-        ...base,
-        tasks: ["future-task-type"],
+        tools: ["gmail", "google-calendar", "slack", "notion"],
+        tasks: ["scheduling", "personal", "writing", "research"],
+        tone: "warm",
         userName: "Bob",
-        assistantName: "Pip",
+        assistantName: "Remy",
       });
-      expect(greeting).toContain("What's on your plate?");
-      expect(greeting).not.toContain("\n\n\n");
+      expect(greeting).not.toContain("Gmail");
+      expect(greeting).not.toContain("Google Calendar");
+      expect(greeting).not.toContain("Slack");
+      expect(greeting).not.toContain("Notion");
+      expect(greeting).not.toContain("scheduling");
+      expect(greeting).not.toContain("personal");
     });
   });
 });

package/src/__tests__/fixtures/mock-chrome-extension.ts

@@ -1,18 +1,17 @@
 /**
  * Mock Chrome extension test fixture.
  *
- * Opens a WebSocket to the runtime's `/v1/browser-relay` endpoint using a
- * caller-supplied JWT (so the upgrade handler registers the connection
- * under the guardianId encoded in the token), handles incoming
- * `host_browser_request` frames by calling a mock CDP proxy, and POSTs
+ * Subscribes to the runtime's `/events` SSE endpoint (registering in the
+ * client registry with `interfaceId: "chrome-extension"`), handles incoming
+ * `host_browser_request` events by calling a mock CDP proxy, and POSTs
  * the result back to `/v1/host-browser-result`.
  *
- * Used by e2e tests (PR 15/16) to exercise the full round-trip without
- * requiring a real Chrome browser or the real extension worker.
+ * Optionally opens a WebSocket to `/v1/browser-relay` for sending inbound
+ * frames (events, session-invalidation, keepalive) and for the WS result
+ * transport variant.
  *
- * The fixture is intentionally minimal — it does not implement heartbeats
- * or reconnect logic. It only needs to carry host_browser_request frames
- * end-to-end.
+ * Used by e2e tests to exercise the full round-trip without requiring a
+ * real Chrome browser or the real extension worker.
  */
 
 // ── Types ───────────────────────────────────────────────────────────
@@ -73,13 +72,14 @@ export interface MockChromeExtensionOptions {
    *   - "http" (default): POST to `/v1/host-browser-result`.
    *   - "ws": send a `host_browser_result` frame back over the same
    *     `/v1/browser-relay` WebSocket that delivered the request.
-   *
-   * Both transports are expected to be fully functional in the runtime.
-   * The HTTP path is the legacy transport; the WS path was added so the
-   * extension can avoid an extra round-trip through the cloud ingress
-   * stack for each CDP command.
    */
   resultTransport?: "http" | "ws";
+  /**
+   * Separate JWT for SSE `/events` auth. When the primary `token` is a
+   * capability token (not a JWT), provide a real JWT here so the SSE
+   * endpoint accepts the connection.
+   */
+  sseToken?: string;
 }
 
 export interface MockChromeExtension {
@@ -172,9 +172,12 @@ export function createMockChromeExtension(
   const baseHttp = options.runtimeBaseUrl.replace(/\/$/, "");
   const wsBase = baseHttp.replace(/^http/i, "ws");
   const wsUrl = `${wsBase}/v1/browser-relay?token=${encodeURIComponent(options.token)}`;
+  const clientId = `mock-ext-${crypto.randomUUID()}`;
 
   let ws: WebSocket | null = null;
-  let connected = false;
+  let wsConnected = false;
+  let sseAbort: AbortController | null = null;
+  let sseConnected = false;
   let handler = options.cdpHandler ?? defaultCdpHandler;
   const receivedRequests: HostBrowserRequestFrame[] = [];
   const receivedCancels: HostBrowserCancelFrame[] = [];
@@ -197,9 +200,6 @@ export function createMockChromeExtension(
     } finally {
       inFlight.delete(frame.requestId);
     }
-    // If the request was aborted mid-flight, drop the result entirely
-    // (mirroring the production dispatcher, which doesn't POST a result
-    // for cancelled requests).
     if (abortCtl.signal.aborted) return;
 
     const body: HostBrowserResultBody = {
@@ -208,21 +208,12 @@ export function createMockChromeExtension(
       isError: result.isError,
     };
     if (resultTransport === "ws") {
-      // Send the result back over the same `/v1/browser-relay` socket
-      // that delivered the request. The runtime WS message handler
-      // parses `host_browser_result` frames and resolves the pending
-      // interaction via the same core resolver the HTTP endpoint uses.
       const sock = ws;
       if (sock && sock.readyState === WebSocket.OPEN) {
         try {
-          sock.send(
-            JSON.stringify({
-              type: "host_browser_result",
-              ...body,
-            }),
-          );
+          sock.send(JSON.stringify({ type: "host_browser_result", ...body }));
         } catch {
-          // Best-effort — mirrors the HTTP POST failure mode.
+          // best-effort
         }
       }
       return;
@@ -236,14 +227,13 @@ export function createMockChromeExtension(
         },
         body: JSON.stringify(body),
       });
-      // Consume the body so Bun doesn't leak the response handle.
       await res.body?.cancel();
     } catch {
-      // Best-effort — if the runtime has torn down the server, the POST
-      // will throw. Tests assert on proxy behaviour, not POST success.
+      // best-effort
     }
   }
 
+  /** Handle an incoming message (from SSE event or WS frame). */
   function handleMessage(raw: string): void {
     let parsed: unknown;
     try {
@@ -269,43 +259,92 @@ export function createMockChromeExtension(
       }
       return;
     }
-    // Ignore any other frames.
+  }
+
+  /** Start SSE connection to /events — registers in client registry and
+   *  receives outbound host_browser events from the event hub. */
+  async function startSse(): Promise<void> {
+    sseAbort = new AbortController();
+    const sseUrl = `${baseHttp}/v1/events`;
+    const res = await fetch(sseUrl, {
+      headers: {
+        Accept: "text/event-stream",
+        Authorization: `Bearer ${options.sseToken ?? options.token}`,
+        "X-Vellum-Client-Id": clientId,
+        "X-Vellum-Interface-Id": "chrome-extension",
+      },
+      signal: sseAbort.signal,
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`SSE connect failed: ${res.status}`);
+    }
+    sseConnected = true;
+
+    // Read SSE stream in the background
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    void (async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          // Parse SSE frames: "data: ...\n\n"
+          const parts = buffer.split("\n\n");
+          buffer = parts.pop() ?? "";
+          for (const part of parts) {
+            const lines = part.split("\n");
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                const data = line.slice(6);
+                // SSE data is JSON-encoded AssistantEvent; extract
+                // the message field
+                try {
+                  const event = JSON.parse(data) as {
+                    message?: unknown;
+                  };
+                  if (event.message) {
+                    handleMessage(JSON.stringify(event.message));
+                  }
+                } catch {
+                  // skip malformed SSE data
+                }
+              }
+            }
+          }
+        }
+      } catch {
+        // SSE stream ended (abort or server shutdown)
+      } finally {
+        sseConnected = false;
+      }
+    })();
+  }
+
+  /** Start the optional WS connection for sending inbound frames. */
+  async function startWs(): Promise<void> {
+    const wsOptions: { headers?: Record<string, string> } = {};
+    if (options.extraHandshakeHeaders) {
+      wsOptions.headers = options.extraHandshakeHeaders;
+    }
+    ws = new WebSocket(wsUrl, wsOptions as unknown as string | string[]);
+    ws.addEventListener("open", () => {
+      wsConnected = true;
+    });
+    ws.addEventListener("close", () => {
+      wsConnected = false;
+    });
   }
 
   return {
     async start() {
-      if (ws) return;
-      // Bun's `WebSocket` constructor accepts a second-argument options
-      // object with a `headers` field (a Bun-specific extension of the
-      // standard WebSocket API). We forward `extraHandshakeHeaders`
-      // through it so tests using service tokens can supply the
-      // `x-guardian-id` fallback expected by `/v1/browser-relay`.
-      //
-      // We cast through `unknown` because the DOM `WebSocket` type only
-      // knows about `(url, protocols)`. If this fixture is ever run in
-      // an environment that isn't Bun, the options object would be
-      // silently ignored — acceptable for a test fixture.
-      const wsOptions: { headers?: Record<string, string> } = {};
-      if (options.extraHandshakeHeaders) {
-        wsOptions.headers = options.extraHandshakeHeaders;
-      }
-      ws = new WebSocket(wsUrl, wsOptions as unknown as string | string[]);
-      ws.addEventListener("open", () => {
-        connected = true;
-      });
-      ws.addEventListener("message", (ev: MessageEvent) => {
-        const data = ev.data;
-        if (typeof data === "string") {
-          handleMessage(data);
-        } else if (data instanceof ArrayBuffer) {
-          handleMessage(new TextDecoder().decode(data));
-        }
-      });
-      ws.addEventListener("close", () => {
-        connected = false;
-      });
+      await startSse();
+      await startWs();
     },
     async stop() {
+      sseAbort?.abort();
+      sseAbort = null;
       const sock = ws;
       ws = null;
       if (sock) {
@@ -322,10 +361,10 @@ export function createMockChromeExtension(
     },
     async waitForConnection(timeoutMs = 2000) {
       const deadline = Date.now() + timeoutMs;
-      while (!connected) {
+      while (!sseConnected || !wsConnected) {
         if (Date.now() > deadline) {
           throw new Error(
-            `mock-chrome-extension: timed out waiting for WebSocket OPEN after ${timeoutMs}ms`,
+            `mock-chrome-extension: timed out waiting for connection (SSE=${sseConnected}, WS=${wsConnected}) after ${timeoutMs}ms`,
           );
         }
         await new Promise((r) => setTimeout(r, 10));
@@ -341,9 +380,12 @@ export function createMockChromeExtension(
       handler = next;
     },
     forceDisconnect() {
+      sseAbort?.abort();
+      sseAbort = null;
+      sseConnected = false;
       const sock = ws;
       ws = null;
-      connected = false;
+      wsConnected = false;
       if (sock) {
         try {
           sock.close(4000, "forced disconnect");