@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -6,6 +6,7 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { CONSOLIDATION_ALLOWED_TOOLS } from "../../plugins/defaults/memory/substrate/consolidation-tool-surface.js";
 import type { Conversation } from "../conversation.js";
 import type { ChannelCapabilities } from "../conversation-runtime-assembly.js";
 
@@ -779,3 +780,45 @@ describe("isToolActiveForContext — allowlist-only tools (delete_memory_page)",
     ).toBe(false);
   });
 });
+
+describe("isToolActiveForContext — memory consolidation surface resolves onto the wire", () => {
+  // A background job conversation is not a subagent, so SUBAGENT_ONLY tools
+  // are filtered off before the allowlist applies. Every name the
+  // consolidation run allowlists must survive that gate, or the tool is
+  // silently missing from the run while the allowlist still claims it.
+  const consolidationCtx = () =>
+    makeCtx({
+      subagentAllowedTools: new Set(CONSOLIDATION_ALLOWED_TOOLS),
+      subagentToolGateMode: "wire",
+    });
+
+  test("every allowlisted tool is active for a background conversation", () => {
+    for (const name of CONSOLIDATION_ALLOWED_TOOLS) {
+      expect(isToolActiveForContext(name, consolidationCtx()), name).toBe(true);
+    }
+  });
+
+  test("the shell and the page-delete primitive are on the surface", () => {
+    expect(isToolActiveForContext("bash", consolidationCtx())).toBe(true);
+    expect(
+      isToolActiveForContext("delete_memory_page", consolidationCtx()),
+    ).toBe(true);
+  });
+
+  test("network egress and host-proxy tools stay off the wire", () => {
+    for (const name of [
+      "web_fetch",
+      "web_search",
+      "network_request",
+      "host_bash",
+      "host_file_read",
+      "host_file_write",
+      "host_file_edit",
+      "host_cu",
+    ]) {
+      expect(isToolActiveForContext(name, consolidationCtx()), name).toBe(
+        false,
+      );
+    }
+  });
+});

package/src/daemon/__tests__/inference-profile-notification.test.ts

@@ -47,6 +47,7 @@ mock.module("../../plugins/defaults/memory/v2/activation-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ────────────────────────────────────────────────────
+import { mockUnownedModeSessions } from "../../__tests__/helpers/mock-conversation.js";
 import type { AgentEvent } from "../../agent/loop.js";
 import type { Message } from "../../providers/types.js";
 import type {
@@ -68,6 +69,7 @@ function makeDeps(): EventHandlerDeps {
       provider: { name: "mock-provider" },
       currentTurnSurfaces: [],
       trustContext: undefined,
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: () => {},
     reqId: "req-profile-notify",

package/src/daemon/__tests__/turn-tail-deleted-conversation.test.ts

@@ -128,6 +128,7 @@ async function runSettle(): Promise<Message[]> {
     ctx,
     state: {
       lastAssistantMessageId: ASSISTANT_MESSAGE_ID,
+      assistantMessageIdsToSync: new Set(),
       inflightWriters: new Map<string, InflightContentWriter>(),
     },
     rlog,
@@ -169,4 +170,39 @@ describe("settleTurnContent conversation deleted after the terminal SSE", () =>
     expect(diskSyncCalls).toEqual([ASSISTANT_MESSAGE_ID]);
     expect(messages).toEqual(TRUNCATED_MESSAGES);
   });
+
+  test("exports a queued attachment target only once when it is the final row", async () => {
+    const ctx = { conversationId: CONVERSATION_ID, messages: [] as Message[] };
+
+    await settleTurnContent({
+      ctx,
+      state: {
+        lastAssistantMessageId: ASSISTANT_MESSAGE_ID,
+        assistantMessageIdsToSync: new Set([ASSISTANT_MESSAGE_ID]),
+        inflightWriters: new Map<string, InflightContentWriter>(),
+      },
+      rlog,
+    });
+
+    expect(diskSyncCalls).toEqual([ASSISTANT_MESSAGE_ID]);
+  });
+
+  test("exports an earlier attachment target before the final private row", async () => {
+    const ctx = { conversationId: CONVERSATION_ID, messages: [] as Message[] };
+
+    await settleTurnContent({
+      ctx,
+      state: {
+        lastAssistantMessageId: ASSISTANT_MESSAGE_ID,
+        assistantMessageIdsToSync: new Set(["msg-delivered-reply"]),
+        inflightWriters: new Map<string, InflightContentWriter>(),
+      },
+      rlog,
+    });
+
+    expect(diskSyncCalls).toEqual([
+      "msg-delivered-reply",
+      ASSISTANT_MESSAGE_ID,
+    ]);
+  });
 });

package/src/daemon/assistant-attachments.ts

@@ -109,8 +109,8 @@ export function classifyKind(mimeType: string): "image" | "video" | "document" {
 // Validation / cap enforcement
 // ---------------------------------------------------------------------------
 
-interface ValidatedDrafts {
-  accepted: AssistantAttachmentDraft[];
+interface ValidatedDrafts<T extends AssistantAttachmentDraft> {
+  accepted: T[];
   warnings: string[];
 }
 
@@ -119,10 +119,10 @@ interface ValidatedDrafts {
  *
  * - Rejects individual drafts that exceed `MAX_ASSISTANT_ATTACHMENT_BYTES`.
  */
-export function validateDrafts(
-  drafts: AssistantAttachmentDraft[],
-): ValidatedDrafts {
-  const accepted: AssistantAttachmentDraft[] = [];
+export function validateDrafts<T extends AssistantAttachmentDraft>(
+  drafts: T[],
+): ValidatedDrafts<T> {
+  const accepted: T[] = [];
   const warnings: string[] = [];
 
   for (const draft of drafts) {
@@ -800,6 +800,16 @@ function toolNameToFilePrefix(toolName?: string): string {
     .toLowerCase();
 }
 
+/** Shared download name for an image produced by a tool result. */
+export function toolImageFilename(
+  mediaType: string,
+  toolName?: string,
+  title?: string,
+): string {
+  const ext = mediaType.split("/")[1] ?? "png";
+  return `${title || toolNameToFilePrefix(toolName)}.${ext}`;
+}
+
 /**
  * Convert tool content blocks (images/files from tool results) into
  * attachment drafts. Blocks that aren't image or file types are skipped.
@@ -820,12 +830,10 @@ export function contentBlocksToDrafts(
       const src = b.source as ImageBlock["source"];
       const data = src.data;
       const mimeType = src.media_type;
-      const ext = mimeType.split("/")[1] ?? "png";
       const title = typeof b._title === "string" ? b._title : undefined;
-      const prefix = title || toolNameToFilePrefix(toolName);
       drafts.push({
         sourceType: "tool_block",
-        filename: `${prefix}.${ext}`,
+        filename: toolImageFilename(mimeType, toolName, title),
         mimeType,
         dataBase64: data,
         sizeBytes: estimateBase64Bytes(data),
@@ -918,9 +926,9 @@ export function cleanAssistantContent(content: readonly unknown[]): {
  * data from being attached twice when it appears as both a directive tag
  * (user-chosen name) and an auto-converted tool block ("tool-output.png").
  */
-export function deduplicateDrafts(
-  drafts: AssistantAttachmentDraft[],
-): AssistantAttachmentDraft[] {
+export function deduplicateDrafts<T extends AssistantAttachmentDraft>(
+  drafts: T[],
+): T[] {
   const seenKeys = new Set<string>();
   const seenDirectiveHashes = new Set<string>();
   return drafts.filter((d) => {

package/src/daemon/browser-mode-session.test.ts

@@ -0,0 +1,402 @@
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { setOverridesForTesting } from "../__tests__/feature-flag-test-helpers.js";
+import type { ModeSession } from "../api/mode-session.js";
+import { isSessionGroupsEnabled } from "../config/session-groups-gate.js";
+import { BrowserModeSessionProducer } from "./browser-mode-session.js";
+import type {
+  ModeSessionSourceHandle,
+  ModeSessionTerminalDisposition,
+} from "./conversation-mode-session.js";
+
+function createCoordinator() {
+  let owner: ModeSession | undefined;
+  let activation = 0;
+  const activated: ModeSessionSourceHandle[] = [];
+  const retired: Array<{
+    handle: ModeSessionSourceHandle;
+    disposition?: ModeSessionTerminalDisposition;
+  }> = [];
+  const activity: Array<{ turnId: string; at: number }> = [];
+
+  const coordinator = {
+    activateSource(input: {
+      sourceId: string;
+      generation: number;
+      mode: "browser";
+      sourceStartedAt: number;
+    }): ModeSessionSourceHandle {
+      activation += 1;
+      const handle = {
+        sourceId: input.sourceId,
+        generation: input.generation,
+        activation,
+        id: `browser-${activation}`,
+        mode: input.mode,
+      } as const;
+      activated.push(handle);
+      return handle;
+    },
+    claimTurn(
+      _turnId: string,
+      handle: ModeSessionSourceHandle,
+      _at: number,
+    ): ModeSession {
+      owner ??= { id: handle.id, mode: handle.mode };
+      return owner;
+    },
+    getTurnOwner: () => owner,
+    recordActivity: (turnId: string, at: number) => {
+      activity.push({ turnId, at });
+      return true;
+    },
+    retireSource: (
+      handle: ModeSessionSourceHandle,
+      disposition?: ModeSessionTerminalDisposition,
+    ) => {
+      retired.push({ handle, disposition });
+      return true;
+    },
+  };
+
+  return {
+    coordinator,
+    activated,
+    retired,
+    activity,
+    clearOwner: () => {
+      owner = undefined;
+    },
+    setOwner: (next: ModeSession) => {
+      owner = next;
+    },
+  };
+}
+
+describe("BrowserModeSessionProducer", () => {
+  afterEach(() => {
+    setOverridesForTesting({});
+  });
+
+  test.each([false, true])(
+    "retires failed admission while preserving a partial turn owner (%s)",
+    (partial) => {
+      const state = createCoordinator();
+      const claim = state.coordinator.claimTurn;
+      state.coordinator.claimTurn = (...args) => {
+        if (partial) {
+          claim(...args);
+        }
+        throw new Error("tracking unavailable");
+      };
+      const producer = new BrowserModeSessionProducer(state.coordinator);
+      expect(() =>
+        producer.beginOperation({
+          turnId: "turn-123",
+          lifecycle: "action",
+          at: 100,
+        }),
+      ).toThrow("tracking unavailable");
+      expect(state.retired).toHaveLength(1);
+      expect(state.retired[0]?.disposition).toMatchObject({
+        status: "interrupted",
+        endReason: "tracking_failed",
+      });
+      if (partial) {
+        expect(state.coordinator.getTurnOwner()).toBeDefined();
+      } else {
+        expect(state.coordinator.getTurnOwner()).toBeUndefined();
+      }
+    },
+  );
+
+  test("admits new tracking only while the shared feature flag is enabled", () => {
+    const state = createCoordinator();
+    const producer = new BrowserModeSessionProducer(
+      state.coordinator,
+      1,
+      isSessionGroupsEnabled,
+    );
+
+    setOverridesForTesting({});
+    expect(isSessionGroupsEnabled()).toBe(false);
+    expect(
+      producer.beginOperation({
+        turnId: "turn-disabled",
+        lifecycle: "action",
+        at: 100,
+      }),
+    ).toBeUndefined();
+    expect(state.activated).toEqual([]);
+
+    setOverridesForTesting({ "session-groups": true });
+    const admitted = producer.beginOperation({
+      turnId: "turn-enabled",
+      lifecycle: "action",
+      at: 110,
+    });
+    expect(admitted?.owner).toEqual({ id: "browser-1", mode: "browser" });
+
+    setOverridesForTesting({ "session-groups": false });
+    state.clearOwner();
+    const close = producer.beginOperation({
+      turnId: "turn-close",
+      lifecycle: "terminal",
+      at: 120,
+    });
+    expect(close?.owner).toEqual({ id: "browser-1", mode: "browser" });
+    expect(
+      producer.finishOperation(close, {
+        at: 130,
+        isError: false,
+        cancelled: false,
+        terminalReason: "browser_closed",
+      }),
+    ).toBe(true);
+    expect(state.retired).toHaveLength(1);
+  });
+
+  test("claims the first action and records repeated successful activity", () => {
+    const state = createCoordinator();
+    const producer = new BrowserModeSessionProducer(state.coordinator);
+
+    const first = producer.beginOperation({
+      turnId: "turn-1",
+      lifecycle: "action",
+      at: 100,
+    });
+    expect(first?.owner).toEqual({ id: "browser-1", mode: "browser" });
+    expect(state.activated).toHaveLength(1);
+    expect(
+      producer.finishOperation(first, {
+        at: 120,
+        isError: false,
+        cancelled: false,
+      }),
+    ).toBe(true);
+    expect(state.activity).toEqual([{ turnId: "turn-1", at: 120 }]);
+
+    const repeated = producer.beginOperation({
+      turnId: "turn-1",
+      lifecycle: "action",
+      at: 130,
+    });
+    expect(repeated?.owner.id).toBe("browser-1");
+    expect(state.activated).toHaveLength(1);
+  });
+
+  test("status and a terminal operation without an active run are inert", () => {
+    const state = createCoordinator();
+    const producer = new BrowserModeSessionProducer(state.coordinator);
+
+    expect(
+      producer.beginOperation({
+        turnId: "turn-1",
+        lifecycle: "status",
+        at: 100,
+      }),
+    ).toBeUndefined();
+    expect(
+      producer.beginOperation({
+        turnId: "turn-1",
+        lifecycle: "terminal",
+        at: 110,
+      }),
+    ).toBeUndefined();
+    expect(state.activated).toEqual([]);
+  });
+
+  test("keeps an existing non-browser owner without activating a nested run", () => {
+    const state = createCoordinator();
+    state.setOwner({ id: "live-1", mode: "live_vision" });
+    const producer = new BrowserModeSessionProducer(state.coordinator);
+
+    const token = producer.beginOperation({
+      turnId: "turn-1",
+      lifecycle: "action",
+      at: 100,
+    });
+    expect(token).toMatchObject({ owner: { id: "live-1" } });
+    expect(token?.handle).toBeUndefined();
+    expect(state.activated).toEqual([]);
+    expect(
+      producer.finishOperation(token, {
+        at: 120,
+        isError: false,
+        cancelled: false,
+      }),
+    ).toBe(true);
+    expect(state.activity).toEqual([{ turnId: "turn-1", at: 120 }]);
+  });
+
+  test("successful close retires the active run with a completed disposition", () => {
+    const state = createCoordinator();
+    const producer = new BrowserModeSessionProducer(state.coordinator);
+    producer.beginOperation({
+      turnId: "turn-1",
+      lifecycle: "action",
+      at: 100,
+    });
+    state.clearOwner();
+
+    const close = producer.beginOperation({
+      turnId: "turn-close",
+      lifecycle: "terminal",
+      at: 200,
+    });
+    expect(close?.owner.id).toBe("browser-1");
+    expect(
+      producer.finishOperation(close, {
+        at: 220,
+        isError: false,
+        cancelled: false,
+        terminalReason: "browser_closed",
+      }),
+    ).toBe(true);
+    expect(state.retired).toEqual([
+      {
+        handle: expect.objectContaining({ id: "browser-1", activation: 1 }),
+        disposition: {
+          status: "completed",
+          endReason: "browser_closed",
+        },
+      },
+    ]);
+  });
+
+  test("a foreign-owned terminal operation retires only the captured browser run", () => {
+    const state = createCoordinator();
+    const producer = new BrowserModeSessionProducer(state.coordinator);
+    producer.beginOperation({
+      turnId: "turn-browser",
+      lifecycle: "action",
+      at: 100,
+    });
+    state.setOwner({ id: "live-1", mode: "live_vision" });
+
+    const close = producer.beginOperation({
+      turnId: "turn-live",
+      lifecycle: "terminal",
+      at: 200,
+    });
+    expect(close).toMatchObject({
+      owner: { id: "live-1", mode: "live_vision" },
+      handle: { id: "browser-1", activation: 1 },
+    });
+    expect(
+      producer.finishOperation(close, {
+        at: 220,
+        isError: false,
+        cancelled: false,
+        terminalReason: "browser_detached",
+      }),
+    ).toBe(true);
+    expect(state.retired.at(-1)).toEqual({
+      handle: expect.objectContaining({ id: "browser-1", activation: 1 }),
+      disposition: {
+        status: "completed",
+        endReason: "browser_detached",
+      },
+    });
+
+    state.clearOwner();
+    producer.beginOperation({
+      turnId: "turn-browser-2",
+      lifecycle: "action",
+      at: 300,
+    });
+    expect(
+      producer.finishOperation(close, {
+        at: 320,
+        isError: true,
+        cancelled: false,
+      }),
+    ).toBe(false);
+    expect(state.retired).toHaveLength(1);
+  });
+
+  test("a failed close keeps the session active until a successful retry", () => {
+    const state = createCoordinator();
+    const producer = new BrowserModeSessionProducer(state.coordinator);
+    const action = producer.beginOperation({
+      turnId: "turn-1",
+      lifecycle: "action",
+      at: 100,
+    });
+    const close = producer.beginOperation({
+      turnId: "turn-1",
+      lifecycle: "terminal",
+      at: 110,
+    });
+    expect(
+      producer.finishOperation(close, {
+        at: 120,
+        isError: true,
+        cancelled: false,
+      }),
+    ).toBe(true);
+    expect(state.retired).toHaveLength(0);
+    expect(state.activity).toEqual([{ turnId: "turn-1", at: 120 }]);
+
+    const retry = producer.beginOperation({
+      turnId: "turn-1",
+      lifecycle: "terminal",
+      at: 130,
+    });
+    expect(retry?.handle).toEqual(action?.handle);
+    producer.finishOperation(retry, {
+      at: 140,
+      isError: false,
+      cancelled: false,
+    });
+    expect(state.retired[0]?.disposition).toEqual({
+      status: "completed",
+      endReason: "browser_closed",
+    });
+  });
+
+  test("cancellation retires the exact run while accepted output remains on its captured turn", () => {
+    const state = createCoordinator();
+    const producer = new BrowserModeSessionProducer(state.coordinator);
+    const stale = producer.beginOperation({
+      turnId: "turn-1",
+      lifecycle: "action",
+      at: 100,
+    });
+    expect(
+      producer.finishOperation(stale, {
+        at: 120,
+        isError: true,
+        cancelled: true,
+      }),
+    ).toBe(true);
+    expect(state.retired[0]?.disposition).toEqual({
+      status: "interrupted",
+      endReason: "browser_operation_cancelled",
+    });
+
+    state.clearOwner();
+    const current = producer.beginOperation({
+      turnId: "turn-2",
+      lifecycle: "action",
+      at: 200,
+    });
+    expect(current?.handle?.activation).toBe(2);
+    expect(
+      producer.finishOperation(stale, {
+        at: 210,
+        isError: true,
+        cancelled: true,
+      }),
+    ).toBe(false);
+    expect(
+      producer.finishOperation(stale, {
+        at: 220,
+        isError: false,
+        cancelled: false,
+      }),
+    ).toBe(true);
+    expect(state.activity).toEqual([{ turnId: "turn-1", at: 220 }]);
+    expect(state.retired).toHaveLength(1);
+  });
+});