@vellumai/assistant 0.11.1 → 0.11.2-staging.2

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -339,6 +339,64 @@ describe("tool preview lifecycle", () => {
       expect((emitted as any).conversationId).toBe("test-session-id");
     });
 
+    test("a streaming ui_show visual announces its surface exactly once", () => {
+      const collector = createEventCollector();
+      const deps = createMockDeps({ onEvent: collector.onEvent });
+
+      for (const accumulatedJson of [
+        '{"surface_type": "vis',
+        '{"surface_type": "visual", "data": {"html": "<sv',
+        '{"surface_type": "visual", "data": {"html": "<svg viewBox=',
+      ]) {
+        handleInputJsonDelta(state, deps, {
+          type: "input_json_delta",
+          toolName: "ui_show",
+          toolUseId: "toolu_visual",
+          accumulatedJson,
+        });
+      }
+
+      expect(collector.events).toHaveLength(1);
+      const emitted = collector.events[0] as any;
+      expect(emitted.type).toBe("ui_surface_pending");
+      expect(emitted.surfaceType).toBe("visual");
+      expect(emitted.toolUseId).toBe("toolu_visual");
+      expect(emitted.conversationId).toBe("test-session-id");
+    });
+
+    test("a ui_show for any other surface type announces nothing", () => {
+      const collector = createEventCollector();
+      const deps = createMockDeps({ onEvent: collector.onEvent });
+
+      handleInputJsonDelta(state, deps, {
+        type: "input_json_delta",
+        toolName: "ui_show",
+        toolUseId: "toolu_card",
+        accumulatedJson:
+          '{"surface_type": "card", "data": {"title": "Deploy", "body": "' +
+          "x".repeat(600) +
+          '"}}',
+      });
+
+      expect(collector.events).toEqual([]);
+    });
+
+    test("a ui_show never streams its input to the client", () => {
+      const collector = createEventCollector();
+      const deps = createMockDeps({ onEvent: collector.onEvent });
+
+      handleInputJsonDelta(state, deps, {
+        type: "input_json_delta",
+        toolName: "ui_show",
+        toolUseId: "toolu_visual_input",
+        accumulatedJson: '{"surface_type": "visual", "data": {"html": "<svg"}}',
+      });
+
+      expect(collector.events.some((e) => e.type === "tool_input_delta")).toBe(
+        false,
+      );
+    });
+
     test("handleToolResult includes toolUseId", async () => {
       const collector = createEventCollector();
       const deps = createMockDeps({

package/src/__tests__/tool-result-spool.test.ts

@@ -293,10 +293,11 @@ describe("AgentLoop result-time spooling", () => {
 
   test("spools the raw output even when it exceeds the post-tool-use truncation budget", async () => {
     // maxInputTokens of 10k gives the default truncate plugin a 12k-char
-    // budget (0.3 share × 4 chars/token). The spool must run before that
-    // hook, so the file holds all 20k chars of raw output rather than the
-    // hook's tail-dropped copy — otherwise the omitted tail is unrecoverable.
-    const HUGE = "z".repeat(20_000);
+    // budget (0.3 share × 4 chars/token); HUGE exceeds both that budget and
+    // the spool threshold. The spool must run before that hook, so the file
+    // holds the full raw output rather than the hook's tail-dropped copy;
+    // otherwise the omitted tail is unrecoverable.
+    const HUGE = "z".repeat(THRESHOLD_CHARS + 5_000);
     const { provider } = createMockProvider([
       toolUseResponse("tu_1", "fetch_transcript", {}),
       textResponse("Done."),

package/src/__tests__/turn-boundary-resolution.test.ts

@@ -4,6 +4,8 @@ import {
   addMessage,
   createConversation,
   getAssistantMessageIdsInTurn,
+  PROVIDER_ERROR_MESSAGE_KIND,
+  SYSTEM_CARD_MESSAGE_KIND,
 } from "../persistence/conversation-crud.js";
 import { getDb, getLogsDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
@@ -154,4 +156,55 @@ describe("getAssistantMessageIdsInTurn", () => {
     const firstTurnResult = getAssistantMessageIdsInTurn(a1.id);
     expect(firstTurnResult).toEqual([a1.id]);
   });
+
+  test("provider-error row after an assistant row: not grouped into the turn", async () => {
+    const conv = createConversation("provider-error-after");
+    await addMessage(conv.id, "user", "Do the thing", {
+      skipIndexing: true,
+    });
+    const a1 = await addMessage(conv.id, "assistant", "Partial progress...", {
+      skipIndexing: true,
+    });
+    const pe = await addMessage(conv.id, "assistant", "Provider failed.", {
+      skipIndexing: true,
+      metadata: { messageKind: PROVIDER_ERROR_MESSAGE_KIND },
+    });
+
+    expect(getAssistantMessageIdsInTurn(a1.id)).toEqual([a1.id]);
+    expect(getAssistantMessageIdsInTurn(pe.id)).toEqual([pe.id]);
+  });
+
+  test("assistant row after a provider-error row: earlier standalone row excluded", async () => {
+    const conv = createConversation("provider-error-before");
+    await addMessage(conv.id, "user", "Do the thing", {
+      skipIndexing: true,
+    });
+    const pe = await addMessage(conv.id, "assistant", "Provider failed.", {
+      skipIndexing: true,
+      metadata: { messageKind: PROVIDER_ERROR_MESSAGE_KIND },
+    });
+    const a1 = await addMessage(conv.id, "assistant", "Recovered reply", {
+      skipIndexing: true,
+    });
+
+    expect(getAssistantMessageIdsInTurn(a1.id)).toEqual([a1.id]);
+    expect(getAssistantMessageIdsInTurn(pe.id)).toEqual([pe.id]);
+  });
+
+  test("system card adjacent to an assistant row: not grouped into the turn", async () => {
+    const conv = createConversation("system-card-adjacent");
+    await addMessage(conv.id, "user", "Summarize please", {
+      skipIndexing: true,
+    });
+    const a1 = await addMessage(conv.id, "assistant", "Working on it...", {
+      skipIndexing: true,
+    });
+    const card = await addMessage(conv.id, "assistant", "Compacted.", {
+      skipIndexing: true,
+      metadata: { messageKind: SYSTEM_CARD_MESSAGE_KIND },
+    });
+
+    expect(getAssistantMessageIdsInTurn(a1.id)).toEqual([a1.id]);
+    expect(getAssistantMessageIdsInTurn(card.id)).toEqual([card.id]);
+  });
 });

package/src/__tests__/turn-events-store.test.ts

@@ -301,6 +301,32 @@ describe("queryUnreportedTurnEvents", () => {
     expect(byId[final.id].outcome).toBeNull();
   });
 
+  test("projects the scripted flag, keeping false distinct from unknown", async () => {
+    const conv = createConversation({ conversationType: "standard" });
+    const scripted = await addMessage(conv.id, "user", "auto-sent kickoff", {
+      metadata: { scripted: true },
+    });
+    const typed = await addMessage(conv.id, "user", "a real message", {
+      metadata: { scripted: false },
+    });
+    const legacy = await addMessage(conv.id, "user", "row predating the flag");
+
+    const events = queryUnreportedTurnEvents(0, undefined, 100);
+    const byId = Object.fromEntries(events.map((e) => [e.id, e]));
+
+    // sqlite's json_extract yields 1/0 for JSON booleans, so these must come
+    // back as real booleans. A raw 1 would be rejected by the platform's
+    // BooleanField and the event silently dropped at ingest.
+    expect(byId[scripted.id].scripted).toBe(true);
+    expect(byId[typed.id].scripted).toBe(false);
+
+    // The three-state contract: a row persisted before the flag existed is
+    // UNKNOWN, not "the user typed it". Collapsing this to false is exactly
+    // the bug the flag exists to fix, so assert null rather than falsy.
+    expect(byId[legacy.id].scripted).toBeNull();
+    expect(byId[legacy.id].scripted).not.toBe(false);
+  });
+
   test("stampTurnOutcome never throws, even for a nonexistent message id", () => {
     expect(() => stampTurnOutcome("no-such-message", "failed")).not.toThrow();
   });