@vellumai/assistant 0.12.2 → 0.12.3-staging.2

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

@@ -0,0 +1,186 @@
+import type { ModeSession } from "../api/mode-session.js";
+import type { BrowserOperationLifecycle } from "../browser/operations.js";
+import type {
+  ConversationModeSessionCoordinator,
+  ModeSessionSourceHandle,
+  ModeSessionTerminalDisposition,
+} from "./conversation-mode-session.js";
+import { claimModeSessionTurn } from "./mode-session-tracking.js";
+
+export type { BrowserOperationLifecycle } from "../browser/operations.js";
+
+type ModeSessionCoordinator = Pick<
+  ConversationModeSessionCoordinator,
+  | "activateSource"
+  | "claimTurn"
+  | "getTurnOwner"
+  | "recordActivity"
+  | "retireSource"
+>;
+
+export interface BrowserOperationToken {
+  readonly turnId: string;
+  readonly lifecycle: Exclude<BrowserOperationLifecycle, "status">;
+  readonly owner: ModeSession;
+  readonly handle?: ModeSessionSourceHandle;
+}
+
+const BROWSER_SOURCE_ID = "browser";
+
+/** Maps typed browser operations onto the shared session coordinator. */
+export class BrowserModeSessionProducer {
+  readonly #coordinator: ModeSessionCoordinator;
+  readonly #generation: number;
+  readonly #isTrackingEnabled: () => boolean;
+  #activeHandle?: ModeSessionSourceHandle;
+
+  constructor(
+    coordinator: ModeSessionCoordinator,
+    generation = 1,
+    isTrackingEnabled: () => boolean = () => true,
+  ) {
+    this.#coordinator = coordinator;
+    this.#generation = generation;
+    this.#isTrackingEnabled = isTrackingEnabled;
+  }
+
+  beginOperation(input: {
+    turnId: string;
+    lifecycle: BrowserOperationLifecycle;
+    at: number;
+  }): BrowserOperationToken | undefined {
+    if (input.lifecycle === "status") {
+      return undefined;
+    }
+
+    const existingOwner = this.#coordinator.getTurnOwner(input.turnId);
+    if (existingOwner) {
+      const handle = this.#activeHandle;
+      return {
+        turnId: input.turnId,
+        lifecycle: input.lifecycle,
+        owner: existingOwner,
+        ...(handle &&
+        (input.lifecycle === "terminal" || handle.id === existingOwner.id)
+          ? { handle }
+          : {}),
+      };
+    }
+
+    if (input.lifecycle === "terminal") {
+      const handle = this.#activeHandle;
+      if (!handle) {
+        return undefined;
+      }
+      const owner = claimModeSessionTurn(
+        this.#coordinator,
+        input.turnId,
+        handle,
+        input.at,
+      );
+      if (!owner || owner.id !== handle.id) {
+        return undefined;
+      }
+      return {
+        turnId: input.turnId,
+        lifecycle: input.lifecycle,
+        owner,
+        handle,
+      };
+    }
+
+    if (!this.#isTrackingEnabled()) {
+      return undefined;
+    }
+
+    const handle = this.#coordinator.activateSource({
+      sourceId: BROWSER_SOURCE_ID,
+      generation: this.#generation,
+      mode: "browser",
+      sourceStartedAt: input.at,
+    });
+    if (!handle) {
+      return undefined;
+    }
+    const owner = claimModeSessionTurn(
+      this.#coordinator,
+      input.turnId,
+      handle,
+      input.at,
+    );
+    if (!owner) {
+      return undefined;
+    }
+    if (owner.id === handle.id) {
+      this.#activeHandle = handle;
+    }
+    return {
+      turnId: input.turnId,
+      lifecycle: input.lifecycle,
+      owner,
+      ...(owner.id === handle.id ? { handle } : {}),
+    };
+  }
+
+  finishOperation(
+    token: BrowserOperationToken | undefined,
+    outcome: {
+      at: number;
+      isError: boolean;
+      cancelled: boolean;
+      terminalReason?: "browser_closed" | "browser_detached";
+    },
+  ): boolean {
+    if (!token) {
+      return false;
+    }
+
+    const handle = token.handle;
+    if (outcome.cancelled) {
+      if (!handle || !this.#isCurrent(handle)) {
+        return false;
+      }
+      return this.#retire(handle, {
+        status: "interrupted",
+        endReason: "browser_operation_cancelled",
+      });
+    }
+
+    if (token.lifecycle === "terminal") {
+      if (!handle || !this.#isCurrent(handle)) {
+        return false;
+      }
+      if (!outcome.isError) {
+        return this.#retire(handle, {
+          status: "completed",
+          endReason: outcome.terminalReason ?? "browser_closed",
+        });
+      }
+    }
+
+    return this.#coordinator.recordActivity(token.turnId, outcome.at);
+  }
+
+  #isCurrent(handle: ModeSessionSourceHandle): boolean {
+    const active = this.#activeHandle;
+    return (
+      active?.sourceId === handle.sourceId &&
+      active.generation === handle.generation &&
+      active.activation === handle.activation &&
+      active.id === handle.id
+    );
+  }
+
+  #retire(
+    handle: ModeSessionSourceHandle,
+    disposition: ModeSessionTerminalDisposition,
+  ): boolean {
+    try {
+      return this.#coordinator.retireSource(handle, disposition);
+    } finally {
+      if (this.#isCurrent(handle)) {
+        this.#activeHandle = undefined;
+      }
+    }
+  }
+}

package/src/daemon/chat-credential-redaction.ts

@@ -10,7 +10,8 @@
  *
  *   1. While a turn runs, every shell-style tool command is scanned for
  *      `credentials reveal` invocations and the referenced credentials
- *      (`--service`/`--field` flags or a positional UUID) are recorded as
+ *      (`--service`/`--field` flags, a positional UUID, or a legacy
+ *      `service/field` path) are recorded as
  *      *candidates* ({@link collectRevealRefsFromCommand}).
  *   2. At persist time, only those candidates' plaintexts are fetched from
  *      the credential store — a scoped read of secrets that were already in
@@ -55,6 +56,7 @@ import {
 } from "../security/secret-scanner.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
 import { getCredentialMetadataById } from "../tools/credentials/metadata-store.js";
+import { parseServiceFieldRef } from "../tools/credentials/ref-parse.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("chat-credential-redaction");
@@ -106,6 +108,12 @@ const SERVICE_FLAG_RE = new RegExp(String.raw`--service(?:=|\s+)${FLAG_VALUE}`);
 const FIELD_FLAG_RE = new RegExp(String.raw`--field(?:=|\s+)${FLAG_VALUE}`);
 const UUID_RE =
   /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i;
+// The CLI's single positional argument, directly after `reveal`. A UUID is
+// handled above; anything else is tried as a legacy `service/field` path via
+// the shared grammar in `parseServiceFieldRef`. The route rejects that form
+// as an id today, so no plaintext prints; staging the ref is defense in depth
+// so a future lookup that does succeed is already proof-gated.
+const POSITIONAL_RE = /\breveal\s+([^\s"'\\()<>`-][^\s"'\\()<>`]*)/;
 
 /**
  * Extract a flag's value from a segment, undoing the shell quoting the
@@ -265,6 +273,13 @@ export function collectRevealRefsFromCommand(
       const id = UUID_RE.exec(invocation)?.[0];
       if (id) {
         refs.push({ id });
+        continue;
+      }
+      const positional = POSITIONAL_RE.exec(invocation)?.[1];
+      const pathRef =
+        positional === undefined ? undefined : parseServiceFieldRef(positional);
+      if (pathRef) {
+        refs.push(pathRef);
       }
       // No parseable identity → no ref. The span still gets redacted at
       // persist; it just won't be revealable.

package/src/daemon/computer-use-mode-session.test.ts

@@ -0,0 +1,210 @@
+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 { ComputerUseModeSessionProducer } from "./computer-use-mode-session.js";
+import type { ModeSessionSourceHandle } from "./conversation-mode-session.js";
+
+function createCoordinator() {
+  let owner: ModeSession | undefined;
+  let activation = 0;
+  const activated: Array<{
+    sourceId: string;
+    generation: number;
+    mode: "computer_use";
+    sourceStartedAt: number;
+  }> = [];
+  const retired: ModeSessionSourceHandle[] = [];
+  const activity: Array<{ turnId: string; at: number }> = [];
+  const draining: string[] = [];
+
+  const coordinator = {
+    activateSource(input: {
+      sourceId: string;
+      generation: number;
+      mode: "computer_use";
+      sourceStartedAt: number;
+    }): ModeSessionSourceHandle {
+      activated.push(input);
+      activation += 1;
+      return {
+        sourceId: input.sourceId,
+        generation: input.generation,
+        activation,
+        id: `session-${activation}`,
+        mode: input.mode,
+      };
+    },
+    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) => {
+      retired.push(handle);
+      return true;
+    },
+    beginDraining: (turnId: string) => {
+      draining.push(turnId);
+      return true;
+    },
+  };
+
+  return {
+    coordinator,
+    activated,
+    retired,
+    activity,
+    draining,
+    clearOwner: () => {
+      owner = undefined;
+    },
+    setOwner: (next: ModeSession) => {
+      owner = next;
+    },
+  };
+}
+
+describe("ComputerUseModeSessionProducer", () => {
+  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 ComputerUseModeSessionProducer(state.coordinator);
+      expect(() =>
+        producer.recordAction({
+          turnId: "turn-123",
+          source: { sourceId: "computer", generation: 1 },
+          at: 100,
+        }),
+      ).toThrow("tracking unavailable");
+      expect(state.retired).toHaveLength(1);
+      expect(state.retired[0]?.mode).toBe("computer_use");
+      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 ComputerUseModeSessionProducer(
+      state.coordinator,
+      isSessionGroupsEnabled,
+    );
+    const source = { sourceId: "proxy-123", generation: 2 };
+
+    setOverridesForTesting({ "session-groups": false });
+    expect(
+      producer.recordAction({ turnId: "turn-disabled", source, at: 100 }),
+    ).toBeUndefined();
+    expect(state.activated).toEqual([]);
+
+    setOverridesForTesting({ "session-groups": true });
+    expect(
+      producer.recordAction({ turnId: "turn-enabled", source, at: 110 }),
+    ).toEqual({ id: "session-1", mode: "computer_use" });
+
+    setOverridesForTesting({ "session-groups": false });
+    expect(producer.endTask({ turnId: "turn-enabled", source })).toBe(true);
+    expect(state.retired).toHaveLength(1);
+    expect(state.draining).toEqual(["turn-enabled"]);
+  });
+
+  test("activates on the first action and records later action activity", () => {
+    const state = createCoordinator();
+    const producer = new ComputerUseModeSessionProducer(state.coordinator);
+    const source = { sourceId: "proxy-123", generation: 2 };
+
+    expect(
+      producer.recordAction({ turnId: "turn-123", source, at: 100 }),
+    ).toEqual({ id: "session-1", mode: "computer_use" });
+    expect(state.activated).toEqual([
+      expect.objectContaining({ ...source, sourceStartedAt: 100 }),
+    ]);
+
+    producer.recordAction({ turnId: "turn-123", source, at: 120 });
+    expect(state.activated).toHaveLength(1);
+    expect(state.activity).toEqual([{ turnId: "turn-123", at: 120 }]);
+  });
+
+  test("keeps an existing mode owner without activating a secondary run", () => {
+    const state = createCoordinator();
+    state.setOwner({ id: "live-123", mode: "live_vision" });
+    const producer = new ComputerUseModeSessionProducer(state.coordinator);
+
+    expect(
+      producer.recordAction({
+        turnId: "turn-123",
+        source: { sourceId: "proxy-123", generation: 0 },
+        at: 100,
+      }),
+    ).toEqual({ id: "live-123", mode: "live_vision" });
+    expect(state.activated).toEqual([]);
+    expect(state.activity).toEqual([{ turnId: "turn-123", at: 100 }]);
+  });
+
+  test("terminal end retires its exact handle and begins final reply drain", () => {
+    const state = createCoordinator();
+    const producer = new ComputerUseModeSessionProducer(state.coordinator);
+    const source = { sourceId: "proxy-123", generation: 3 };
+    producer.recordAction({ turnId: "turn-123", source, at: 100 });
+
+    expect(producer.endTask({ turnId: "turn-123", source })).toBe(true);
+    expect(state.retired).toEqual([
+      expect.objectContaining({
+        sourceId: "proxy-123",
+        generation: 3,
+        activation: 1,
+        id: "session-1",
+      }),
+    ]);
+    expect(state.draining).toEqual(["turn-123"]);
+  });
+
+  test("stale terminal callbacks cannot retire a replacement activation", () => {
+    const state = createCoordinator();
+    const producer = new ComputerUseModeSessionProducer(state.coordinator);
+    const oldSource = { sourceId: "proxy-123", generation: 3 };
+    producer.recordAction({ turnId: "turn-old", source: oldSource, at: 100 });
+    state.clearOwner();
+
+    const nextSource = { sourceId: "proxy-123", generation: 4 };
+    producer.recordAction({ turnId: "turn-new", source: nextSource, at: 200 });
+
+    expect(producer.endTask({ turnId: "turn-old", source: oldSource })).toBe(
+      false,
+    );
+    expect(state.retired).toEqual([]);
+    expect(producer.endTask({ turnId: "turn-new", source: nextSource })).toBe(
+      true,
+    );
+    expect(state.retired[0]).toMatchObject({
+      generation: 4,
+      activation: 2,
+      id: "session-2",
+    });
+  });
+});

package/src/daemon/computer-use-mode-session.ts

@@ -0,0 +1,105 @@
+import type { ModeSession } from "../api/mode-session.js";
+import type {
+  ConversationModeSessionCoordinator,
+  ModeSessionSourceHandle,
+} from "./conversation-mode-session.js";
+import { claimModeSessionTurn } from "./mode-session-tracking.js";
+
+type ModeSessionCoordinator = Pick<
+  ConversationModeSessionCoordinator,
+  | "activateSource"
+  | "beginDraining"
+  | "claimTurn"
+  | "getTurnOwner"
+  | "recordActivity"
+  | "retireSource"
+>;
+
+export interface ComputerUseSourceIdentity {
+  sourceId: string;
+  generation: number;
+}
+
+/** Maps validated host computer actions onto the shared session coordinator. */
+export class ComputerUseModeSessionProducer {
+  readonly #coordinator: ModeSessionCoordinator;
+  readonly #isTrackingEnabled: () => boolean;
+  #activeHandle?: ModeSessionSourceHandle;
+
+  constructor(
+    coordinator: ModeSessionCoordinator,
+    isTrackingEnabled: () => boolean = () => true,
+  ) {
+    this.#coordinator = coordinator;
+    this.#isTrackingEnabled = isTrackingEnabled;
+  }
+
+  recordAction(input: {
+    turnId: string;
+    source: ComputerUseSourceIdentity;
+    at: number;
+  }): ModeSession | undefined {
+    const existingOwner = this.#coordinator.getTurnOwner(input.turnId);
+    if (existingOwner) {
+      this.#coordinator.recordActivity(input.turnId, input.at);
+      return existingOwner;
+    }
+
+    if (!this.#isTrackingEnabled()) {
+      return undefined;
+    }
+
+    const handle = this.#coordinator.activateSource({
+      ...input.source,
+      mode: "computer_use",
+      sourceStartedAt: input.at,
+    });
+    if (!handle) {
+      return undefined;
+    }
+    const owner = claimModeSessionTurn(
+      this.#coordinator,
+      input.turnId,
+      handle,
+      input.at,
+    );
+    if (owner?.id === handle.id) {
+      this.#activeHandle = handle;
+    }
+    return owner;
+  }
+
+  endTask(input: {
+    turnId?: string;
+    source: ComputerUseSourceIdentity;
+    disposition?: {
+      status: "completed" | "interrupted";
+      endReason: string;
+    };
+  }): boolean {
+    const handle = this.#activeHandle;
+    if (
+      !handle ||
+      handle.sourceId !== input.source.sourceId ||
+      handle.generation !== input.source.generation
+    ) {
+      return false;
+    }
+
+    this.#activeHandle = undefined;
+    const retired = this.#coordinator.retireSource(
+      handle,
+      input.disposition ?? {
+        status: "completed",
+        endReason: "computer_use_ended",
+      },
+    );
+    if (
+      input.turnId &&
+      this.#coordinator.getTurnOwner(input.turnId)?.id === handle.id
+    ) {
+      this.#coordinator.beginDraining(input.turnId);
+    }
+    return retired;
+  }
+}

package/src/daemon/config-watcher.ts

@@ -190,12 +190,22 @@ export class ConfigWatcher {
         if (this.suppressReload) {
           return;
         }
+        const prevMcpGlobalMax = this.lastConfig?.tools.mcpGlobalMaxTools;
         try {
           const changed = await this.refreshConfigFromSources();
           if (changed) {
             evictConversationsForReload();
             refreshAuthenticatedApiRateLimit();
             publishConfigChanged();
+            const nextMcpGlobalMax = getConfig().tools.mcpGlobalMaxTools;
+            if (prevMcpGlobalMax !== nextMcpGlobalMax) {
+              reloadMcpServers().catch((err: unknown) => {
+                log.error(
+                  { err },
+                  "MCP reload after tools.mcpGlobalMaxTools change failed",
+                );
+              });
+            }
           }
         } catch (err) {
           log.error(