@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.4

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -431,3 +431,115 @@ describe("sendToClient receives state signals", () => {
     });
   });
 });
+
+describe("the sink is fixed for the conversation's life", () => {
+  test("a cold instance delivers activity state with no turn ever having run", () => {
+    // The summarize-up-to route resolves its conversation outside the send
+    // path and emits a thinking indicator before any turn: it must reach the
+    // sink the conversation was built with, not depend on a send having wired
+    // one (LUM-2987).
+    const clientMsgs: AssistantEvent[] = [];
+    const conversation = makeConversation((msg) => clientMsgs.push(msg));
+
+    conversation.emitActivityState("thinking", "context_compacting", {
+      statusText: "Summarizing conversation",
+    });
+
+    const activity = clientMsgs.filter(
+      (m) => m.type === "assistant_activity_state",
+    );
+    expect(activity).toHaveLength(1);
+    expect((activity[0] as { statusText?: string }).statusText).toBe(
+      "Summarizing conversation",
+    );
+  });
+
+  test("presence is a property of the turn, not of delivery", () => {
+    // Nothing is in flight, so no human is asserted present, even though the
+    // sink is live and delivering.
+    const clientMsgs: AssistantEvent[] = [];
+    const conversation = makeConversation((msg) => clientMsgs.push(msg));
+    expect(conversation.hasNoClient).toBe(true);
+    conversation.emitActivityState("thinking", "message_dequeued");
+    expect(clientMsgs).toHaveLength(1);
+    expect(conversation.hasNoClient).toBe(true);
+  });
+});
+
+describe("event observers", () => {
+  test("an observer sees each event after the sink delivered it, and detaches", () => {
+    const order: string[] = [];
+    const conversation = makeConversation((msg) => {
+      order.push(`sink:${msg.type}`);
+    });
+    const detach = conversation.addEventObserver((msg) => {
+      order.push(`observer:${msg.type}`);
+    });
+
+    conversation.emitActivityState("thinking", "message_dequeued");
+    expect(order).toEqual([
+      "sink:assistant_activity_state",
+      "observer:assistant_activity_state",
+    ]);
+
+    detach();
+    conversation.emitActivityState("idle", "message_complete");
+    expect(order).toEqual([
+      "sink:assistant_activity_state",
+      "observer:assistant_activity_state",
+      "sink:assistant_activity_state",
+    ]);
+  });
+
+  test("a throwing observer neither blocks the sink nor its siblings", () => {
+    const seen: string[] = [];
+    const conversation = makeConversation((msg) => {
+      seen.push(`sink:${msg.type}`);
+    });
+    conversation.addEventObserver(() => {
+      throw new Error("observer boom");
+    });
+    conversation.addEventObserver((msg) => {
+      seen.push(`second:${msg.type}`);
+    });
+
+    conversation.emitActivityState("thinking", "message_dequeued");
+    expect(seen).toEqual([
+      "sink:assistant_activity_state",
+      "second:assistant_activity_state",
+    ]);
+  });
+
+  test("the prompter's confirmation_request reaches observers after the sink", () => {
+    // Voice auto-resolves approval prompts it has no UI for; it must observe
+    // the request only once the sink has put it on the wire, so its resolution
+    // lands after the request it answers.
+    const order: string[] = [];
+    const conversation = makeConversation((msg) => {
+      order.push(`sink:${msg.type}`);
+    });
+    conversation.addEventObserver((msg) => {
+      if (msg.type === "confirmation_request") {
+        order.push("observer:confirmation_request");
+        conversation.handleConfirmationResponse(msg.requestId, "deny", {
+          emissionContext: { source: "system" },
+        });
+      }
+    });
+
+    void conversation.prompter.prompt(
+      "bash",
+      { command: "rm -rf /tmp/x" },
+      "high",
+      [],
+      [],
+      undefined,
+      conversation.conversationId,
+      "sandbox",
+      false,
+    );
+
+    expect(order[0]).toBe("sink:confirmation_request");
+    expect(order[1]).toBe("observer:confirmation_request");
+  });
+});

package/src/__tests__/conversation-load-history-repair.test.ts

@@ -713,3 +713,212 @@ describe("loadFromDb tool-result truncation", () => {
     ).toBe(preStubbed);
   });
 });
+
+/**
+ * A guardian card is written into the conversation the request came from by
+ * the notification pairing layer, straight to the DB, while that
+ * conversation's turn is parked awaiting the approval. On the next load it
+ * lands between the parked turn's `tool_use` and its `tool_result`.
+ *
+ * The card is recognized by its own `ui_surface` id rather than a stored
+ * marker, so rows written before this rule existed are dropped on the same
+ * terms as new ones.
+ */
+describe("guardian card rows are not replayed as conversation history", () => {
+  const baseConversation = {
+    id: "conv-1",
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+  };
+
+  /** The parked turn: an approval-gated `tool_use` and the result it got. */
+  const toolUseRow = {
+    id: "m-use",
+    role: "assistant",
+    content: [
+      { type: "text", text: "Running that now." },
+      { type: "tool_use", id: "tu_1", name: "bash", input: { cmd: "ls" } },
+    ],
+  };
+  const toolResultRow = {
+    id: "m-result",
+    role: "user",
+    content: [
+      { type: "tool_result", tool_use_id: "tu_1", content: "REAL RESULT" },
+    ],
+  };
+
+  /** What `buildApprovalCardBlocks` persists: the surface, then its text. */
+  function cardRow(surfaceId: string) {
+    return {
+      id: "m-card",
+      role: "assistant",
+      content: [
+        {
+          type: "ui_surface",
+          surfaceId,
+          surfaceType: "card",
+          title: "Tool Approval",
+          data: {},
+          display: "inline",
+        },
+        { type: "text", text: "Tool Approval\nbash - requested by Alice" },
+      ],
+    };
+  }
+
+  function allBlocks(messages: Message[]) {
+    return messages.flatMap((m) => m.content);
+  }
+
+  function toolResultsFor(messages: Message[], toolUseId: string) {
+    return allBlocks(messages).filter(
+      (b) => b.type === "tool_result" && b.tool_use_id === toolUseId,
+    );
+  }
+
+  function serialized(value: unknown): string {
+    return JSON.stringify(value);
+  }
+
+  beforeEach(() => {
+    nextMockMessageId = 1;
+    mockConversation = { ...baseConversation };
+  });
+
+  // Sensitivity check for the drop below: an ordinary assistant turn in the
+  // same position still corrupts the pair. If the rule ever widened past
+  // guardian cards, this test fails first and says so.
+  test("an ordinary assistant turn between a tool_use and its result still corrupts it", async () => {
+    mockDbMessages = [
+      toolUseRow,
+      {
+        id: "m-card",
+        role: "assistant",
+        content: [{ type: "text", text: "Still working on it." }],
+      },
+      toolResultRow,
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(serialized(messages)).toContain("tool result missing from history");
+    expect(serialized(messages)).toContain("[orphaned tool_result for tu_1]");
+    expect(serialized(toolResultsFor(messages, "tu_1"))).not.toContain(
+      "REAL RESULT",
+    );
+  });
+
+  test("a guardian card is dropped and the real tool_result survives", async () => {
+    mockDbMessages = [
+      toolUseRow,
+      cardRow("tool-approval-req-1"),
+      toolResultRow,
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    // The pair is adjacent and intact: no stub, no downgrade, and exactly one
+    // tool_result for tu_1 carrying the tool's own output.
+    expect(serialized(messages)).not.toContain(
+      "tool result missing from history",
+    );
+    expect(serialized(messages)).not.toContain("[orphaned tool_result");
+    const results = toolResultsFor(messages, "tu_1");
+    expect(results).toHaveLength(1);
+    expect(results[0].type === "tool_result" && results[0].content).toBe(
+      "REAL RESULT",
+    );
+    expect(serialized(messages)).not.toContain("Tool Approval");
+    expect(messages).toHaveLength(2);
+  });
+
+  test("an access-request card is dropped on the same terms", async () => {
+    mockDbMessages = [
+      toolUseRow,
+      cardRow("access-request-req-9"),
+      toolResultRow,
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(serialized(messages)).not.toContain("[orphaned tool_result");
+    expect(messages).toHaveLength(2);
+  });
+
+  test("a card as the tail row leaves history ending on a user message", async () => {
+    // The prefill shape: the approval was delivered and the turn never
+    // resumed, so the card is the last row. Replayed, it makes the history
+    // end on an assistant turn, which extended-thinking models reject with
+    // "does not support assistant message prefill".
+    mockDbMessages = [toolUseRow, cardRow("tool-approval-req-1")];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages[messages.length - 1].role).toBe("user");
+    // The tail is repair's fill for the still-unanswered tool_use, which is
+    // correct here: the tool genuinely never ran.
+    expect(toolResultsFor(messages, "tu_1")).toHaveLength(1);
+  });
+
+  test("a dropped card still restores its ui_surface for action routing", async () => {
+    // Surface lifecycle and model context are different questions. The card is
+    // absent from history, but its Approve/Reject buttons must keep routing
+    // after a restart, which `findConversationBySurfaceId` resolves through
+    // surfaceState rebuilt at load.
+    mockDbMessages = [toolUseRow, cardRow("tool-approval-req-1")];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    expect(serialized(conversation.getMessages())).not.toContain(
+      "tool-approval-req-1",
+    );
+    expect(
+      (
+        conversation as unknown as { surfaceState: Map<string, unknown> }
+      ).surfaceState.has("tool-approval-req-1"),
+    ).toBe(true);
+  });
+
+  test("an assistant turn carrying a non-approval surface stays in history", async () => {
+    // A wake card is unshifted onto a real turn's own content. Its surface id
+    // uses a different prefix, and dropping that row would discard speech.
+    mockDbMessages = [
+      { id: "m-ask", role: "user", content: [{ type: "text", text: "hi" }] },
+      {
+        id: "m-wake",
+        role: "assistant",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: "wake-conv-1-1700000000",
+            surfaceType: "card",
+            title: "Conversation Woke",
+            data: {},
+            display: "inline",
+          },
+          { type: "text", text: "Picking this back up." },
+        ],
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    expect(serialized(conversation.getMessages())).toContain(
+      "Picking this back up.",
+    );
+  });
+});

package/src/__tests__/conversation-notifiers-provenance.test.ts

@@ -35,7 +35,7 @@ describe("live-call question provenance", () => {
 
   test("a row persisted after the turn settled carries the owner, not the stale turn actor", async () => {
     registerConversationNotifiers("conv-n1", {
-      sendToClient: () => {},
+      emit: () => {},
       messages: [],
       // Voice cleanup restored the owner; the per-turn field still holds the
       // finished voice turn's contact.

package/src/__tests__/conversation-queue.test.ts

@@ -11,7 +11,6 @@ import type {
 } from "../agent/loop.js";
 import type { AssistantEvent } from "../api/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
-import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { stampAndBuffer } from "../runtime/assistant-stream-state.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { setConfig } from "./helpers/set-config.js";
@@ -2989,6 +2988,9 @@ describe("Conversation host attachment directives", () => {
         attachments: [],
         onEvent: (e) => events.push(e),
         requestId: "req-1",
+        // A host attachment read prompts only when a human is present to
+        // answer; presence is declared per turn.
+        isInteractive: true,
       });
       await waitForPendingRun(1);
 
@@ -3059,6 +3061,9 @@ describe("Conversation host attachment directives", () => {
         attachments: [],
         onEvent: (e) => events.push(e),
         requestId: "req-1",
+        // A host attachment read prompts only when a human is present to
+        // answer; presence is declared per turn.
+        isInteractive: true,
       });
       await waitForPendingRun(1);
 
@@ -3925,13 +3930,20 @@ describe("subagent notification user_message_echo suppression", () => {
   });
 });
 
-describe("interactive drain sender rebind", () => {
+describe("drained turns deliver through the conversation sink", () => {
   beforeEach(() => {
     pendingRuns = [];
   });
 
-  test("a drained interactive message rebinds the hub sender for its turn, then restores the pre-drain state", async () => {
-    const conversation = makeConversation();
+  test("a confirmation prompt raised in a drained interactive turn reaches the sink", async () => {
+    // The sink is fixed for the conversation's life, so an interactive turn
+    // drained from the queue delivers exactly like a live one: no per-turn
+    // rebinding, nothing for the previous turn's cleanup to clobber. This is
+    // the invariant behind the acp_spawn permission-prompt timeouts (a queued
+    // interactive turn's confirmation_request used to be emitted into a
+    // reset no-op sender and hang until the permission timeout).
+    const sink: AssistantEvent[] = [];
+    const conversation = makeConversation((msg) => sink.push(msg));
     await conversation.loadFromDb();
 
     const p1 = conversation.processMessage({
@@ -3942,78 +3954,46 @@ describe("interactive drain sender rebind", () => {
     });
     await waitForPendingRun(1);
 
-    // Queue an interactive item the way the /v1/messages route does when the
-    // conversation is busy.
-    const result = conversation.enqueueMessage({
+    conversation.enqueueMessage({
       content: "msg-2",
       requestId: "req-2",
       onEvent: () => {},
       isInteractive: true,
     });
-    expect(result.queued).toBe(true);
-
-    // The interactive turn that finishes ahead of the drain resets the
-    // conversation-level sender to a no-op (process-message.ts contract).
-    // The drained turn must not inherit that dead sender: the
-    // PermissionPrompter reads the conversation-level sender, so a
-    // confirmation_request raised during the drained turn would otherwise
-    // reach no client and hang until the permission timeout.
-    conversation.updateClient(() => {}, true);
 
     await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
-    expect(conversation.getCurrentSender()).toBe(broadcastMessage);
+    // The drained turn is in flight and interactive: presence reads a human.
     expect(conversation.hasNoClient).toBe(false);
 
-    await resolveRun(1);
-    await waitForCondition(
-      () => conversation.getCurrentSender() !== broadcastMessage,
+    // A prompt raised now, mid-drained-turn, must land on the sink.
+    void conversation.prompter.prompt(
+      "acp_spawn",
+      { agent: "claude", task: "t" },
+      "high",
+      [],
+      [],
+      undefined,
+      conversation.conversationId,
+      "host",
+      false,
+      undefined,
+      "tool-use-1",
     );
-    expect(conversation.hasNoClient).toBe(true);
-  });
-
-  test("a drained interactive message restores a live pre-drain binding instead of clearing it", async () => {
-    const conversation = makeConversation();
-    await conversation.loadFromDb();
-
-    const p1 = conversation.processMessage({
-      content: "msg-1",
-      attachments: [],
-      onEvent: () => {},
-      requestId: "req-1",
-    });
-    await waitForPendingRun(1);
-
-    conversation.enqueueMessage({
-      content: "msg-2",
-      requestId: "req-2",
-      onEvent: () => {},
-      isInteractive: true,
-    });
-
-    // A live binding predates the drained turn (the send route installs one
-    // when a message is queued behind a non-interactive turn, which performs
-    // no restore). The drain's restore must preserve it for out-of-turn
-    // producers (call transcript and completion notifiers), not clear it.
-    conversation.updateClient(broadcastMessage, false);
-
-    await resolveRun(0);
-    await p1;
-    await waitForPendingRun(2);
-
-    expect(conversation.getCurrentSender()).toBe(broadcastMessage);
-    expect(conversation.hasNoClient).toBe(false);
+    const prompt = sink.find((e) => e.type === "confirmation_request");
+    expect(prompt).toBeDefined();
+    expect((prompt as { toolName: string }).toolName).toBe("acp_spawn");
+    // Settle it so the prompt's timer does not outlive the test.
+    conversation.prompter.denyAllPending();
 
     await resolveRun(1);
-    // The drained turn has ended; the pre-drain live binding must survive.
-    await waitForCondition(() => !conversation.isProcessing());
-    expect(conversation.getCurrentSender()).toBe(broadcastMessage);
-    expect(conversation.hasNoClient).toBe(false);
+    // Turn over: nothing is in flight, so no human is asserted present.
+    await waitForCondition(() => conversation.hasNoClient);
   });
 
-  test("a drained non-interactive message leaves the no-op sender in place", async () => {
+  test("a drained non-interactive turn asserts no human present", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
@@ -4032,13 +4012,10 @@ describe("interactive drain sender rebind", () => {
       isInteractive: false,
     });
 
-    conversation.updateClient(() => {}, true);
-
     await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
-    expect(conversation.getCurrentSender()).not.toBe(broadcastMessage);
     expect(conversation.hasNoClient).toBe(true);
 
     await resolveRun(1);

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -149,7 +149,7 @@ function createFakeConversation(conversationId: string): Conversation {
       return this.turnInterfaceContext;
     },
     ensureActorScopedHistory: async () => {},
-    updateClient: () => {},
+    replayActivityState: () => {},
 
     setHostCuProxy(this: { hostCuProxy: unknown }, proxy: unknown) {
       this.hostCuProxy = proxy;

package/src/__tests__/conversation-routes-enabled-plugins.test.ts

@@ -158,7 +158,7 @@ function makeConversation() {
     currentRequestId: undefined,
     queue: { length: 0 },
     setTrustContext: () => {},
-    updateClient: () => {},
+    replayActivityState: () => {},
     emitConfirmationStateChanged: () => {},
     emitActivityState: () => {},
     setTurnChannelContext: () => {},

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -163,7 +163,7 @@ describe("handleSendMessage guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      updateClient: () => {},
+      replayActivityState: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -253,7 +253,7 @@ describe("handleSendMessage guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      updateClient: () => {},
+      replayActivityState: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -331,7 +331,7 @@ describe("handleSendMessage guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      updateClient: () => {},
+      replayActivityState: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -419,7 +419,7 @@ describe("handleSendMessage guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      updateClient: () => {},
+      replayActivityState: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -507,7 +507,7 @@ describe("handleSendMessage guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      updateClient: () => {},
+      replayActivityState: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -590,7 +590,7 @@ describe("handleSendMessage guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      updateClient: () => {},
+      replayActivityState: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -667,7 +667,7 @@ describe("handleSendMessage guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      updateClient: () => {},
+      replayActivityState: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -746,7 +746,7 @@ describe("handleSendMessage guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      updateClient: () => {},
+      replayActivityState: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},
@@ -826,7 +826,7 @@ describe("handleSendMessage guardian reply interception", () => {
     const runAgentLoop = mock(async () => undefined);
     const session = {
       setTrustContext: () => {},
-      updateClient: () => {},
+      replayActivityState: () => {},
       emitConfirmationStateChanged: () => {},
       emitActivityState: () => {},
       setTurnChannelContext: () => {},

package/src/__tests__/conversation-routes-hidden-queue.test.ts

@@ -169,7 +169,7 @@ function makeConversationWithPendingConfirmation(
     setTrustContext(this: { trustContext: unknown }, ctx: unknown) {
       this.trustContext = ctx;
     },
-    updateClient: () => {},
+    replayActivityState: () => {},
     emitConfirmationStateChanged: () => {},
     emitActivityState: () => {},
     setTurnChannelContext: () => {},

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -233,7 +233,7 @@ function makeConversation() {
     currentRequestId: undefined,
     queue: { length: 0 },
     setTrustContext: () => {},
-    updateClient: (_fn: unknown, _b: boolean) => {},
+    replayActivityState: () => {},
     emitConfirmationStateChanged: () => {},
     emitActivityState: () => {},
     setTurnChannelContext: () => {},