@vellumai/assistant 0.4.46 → 0.4.49

package/src/__tests__/computer-use-session-lifecycle.test.ts

@@ -1,322 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-
-// Mock config before importing modules that depend on it.
-// The permissions mode must be 'workspace' so computer-use tools
-// go through normal workspace trust evaluation instead of prompting.
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    provider: "mock-provider",
-    permissions: { mode: "workspace" },
-    apiKeys: {},
-    sandbox: { enabled: false },
-    timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },
-    skills: { load: { extraDirs: [] } },
-    secretDetection: { enabled: false },
-    contextWindow: {
-      enabled: true,
-      maxInputTokens: 180000,
-      targetBudgetRatio: 0.3,
-      compactThreshold: 0.8,
-      summaryBudgetRatio: 0.05,
-    },
-  }),
-  invalidateConfigCache: () => {},
-}));
-
-import { ComputerUseSession } from "../daemon/computer-use-session.js";
-import type {
-  CuObservation,
-  ServerMessage,
-} from "../daemon/message-protocol.js";
-import type { Provider, ProviderResponse } from "../providers/types.js";
-
-function createProvider(responses: ProviderResponse[]): {
-  provider: Provider;
-  getCalls: () => number;
-} {
-  let calls = 0;
-  const provider: Provider = {
-    name: "mock",
-    async sendMessage() {
-      const response = responses[calls] ?? responses[responses.length - 1];
-      calls++;
-      return response;
-    },
-  };
-  return { provider, getCalls: () => calls };
-}
-
-describe("ComputerUseSession lifecycle", () => {
-  test("stops provider loop immediately after terminal computer_use_done tool", async () => {
-    const { provider, getCalls } = createProvider([
-      {
-        content: [
-          {
-            type: "tool_use",
-            id: "tu-1",
-            name: "computer_use_done",
-            input: { summary: "Task finished" },
-          },
-        ],
-        model: "mock-model",
-        usage: { inputTokens: 10, outputTokens: 5 },
-        stopReason: "tool_use",
-      },
-      {
-        content: [{ type: "text", text: "This should never be requested" }],
-        model: "mock-model",
-        usage: { inputTokens: 10, outputTokens: 5 },
-        stopReason: "end_turn",
-      },
-    ]);
-
-    const sentMessages: ServerMessage[] = [];
-    let terminalCalls = 0;
-
-    const session = new ComputerUseSession(
-      "cu-test-1",
-      "test task",
-      1440,
-      900,
-      provider,
-      (msg) => {
-        sentMessages.push(msg);
-      },
-      "computer_use",
-      () => {
-        terminalCalls++;
-      },
-    );
-
-    const observation: CuObservation = {
-      type: "cu_observation",
-      sessionId: "cu-test-1",
-      axTree: 'Window "Test" [1]',
-    };
-
-    await session.handleObservation(observation);
-
-    // If computer_use_done does not abort the loop, we'd see an extra provider call.
-    expect(getCalls()).toBe(1);
-    expect(session.getState()).toBe("complete");
-    expect(terminalCalls).toBe(1);
-
-    const completes = sentMessages.filter(
-      (msg): msg is Extract<ServerMessage, { type: "cu_complete" }> =>
-        msg.type === "cu_complete",
-    );
-    expect(completes).toHaveLength(1);
-    expect(completes[0].summary).toBe("Task finished");
-  });
-
-  test("notifies terminal callback only once on repeated abort calls", () => {
-    const { provider } = createProvider([
-      {
-        content: [{ type: "text", text: "unused" }],
-        model: "mock-model",
-        usage: { inputTokens: 1, outputTokens: 1 },
-        stopReason: "end_turn",
-      },
-    ]);
-
-    let terminalCalls = 0;
-    const session = new ComputerUseSession(
-      "cu-test-2",
-      "test task",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-      () => {
-        terminalCalls++;
-      },
-    );
-
-    session.abort();
-    session.abort();
-
-    expect(terminalCalls).toBe(1);
-    expect(session.getState()).toBe("error");
-  });
-
-  test("CU session passes exactly 10 computer_use_* tools to the agent loop", async () => {
-    let capturedTools: string[] = [];
-    const provider: Provider = {
-      name: "mock",
-      async sendMessage(_msgs, tools) {
-        capturedTools = (tools ?? []).map((t) => t.name);
-        return {
-          content: [
-            {
-              type: "tool_use",
-              id: "tu-capture",
-              name: "computer_use_done",
-              input: { summary: "Done" },
-            },
-          ],
-          model: "mock-model",
-          usage: { inputTokens: 10, outputTokens: 5 },
-          stopReason: "tool_use",
-        };
-      },
-    };
-
-    const session = new ComputerUseSession(
-      "cu-tool-capture",
-      "capture tools",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-    );
-
-    await session.handleObservation({
-      type: "cu_observation",
-      sessionId: "cu-tool-capture",
-      axTree: 'Window "Test" [1]',
-    });
-
-    const cuTools = capturedTools.filter((n) => n.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(10);
-
-    // Assert exact set of expected CU tool names
-    const expectedCuTools = [
-      "computer_use_click",
-      "computer_use_type_text",
-      "computer_use_key",
-      "computer_use_scroll",
-      "computer_use_drag",
-      "computer_use_wait",
-      "computer_use_open_app",
-      "computer_use_run_applescript",
-      "computer_use_done",
-      "computer_use_respond",
-    ];
-    for (const name of expectedCuTools) {
-      expect(cuTools).toContain(name);
-    }
-  });
-
-  test("computer_use_respond is a terminal tool that completes the session", async () => {
-    const { provider } = createProvider([
-      {
-        content: [
-          {
-            type: "tool_use",
-            id: "tu-respond",
-            name: "computer_use_respond",
-            input: {
-              answer: "The meeting is at 3pm",
-              reasoning: "Found in calendar",
-            },
-          },
-        ],
-        model: "mock-model",
-        usage: { inputTokens: 10, outputTokens: 5 },
-        stopReason: "tool_use",
-      },
-    ]);
-
-    const sentMessages: ServerMessage[] = [];
-    const session = new ComputerUseSession(
-      "cu-respond-test",
-      "check my schedule",
-      1440,
-      900,
-      provider,
-      (msg) => {
-        sentMessages.push(msg);
-      },
-      "computer_use",
-    );
-
-    await session.handleObservation({
-      type: "cu_observation",
-      sessionId: "cu-respond-test",
-      axTree: 'Window "Calendar" [1]',
-    });
-
-    expect(session.getState()).toBe("complete");
-    const completes = sentMessages.filter(
-      (msg): msg is Extract<ServerMessage, { type: "cu_complete" }> =>
-        msg.type === "cu_complete",
-    );
-    expect(completes).toHaveLength(1);
-    expect(completes[0].summary).toBe("The meeting is at 3pm");
-    expect(completes[0].isResponse).toBe(true);
-  });
-
-  test("default construction preactivates computer-use skill and provides 10 CU tools", async () => {
-    let capturedTools: string[] = [];
-    const provider: Provider = {
-      name: "mock",
-      async sendMessage(_msgs, tools) {
-        capturedTools = (tools ?? []).map((t) => t.name);
-        return {
-          content: [
-            {
-              type: "tool_use",
-              id: "tu-default",
-              name: "computer_use_done",
-              input: { summary: "Done" },
-            },
-          ],
-          model: "mock-model",
-          usage: { inputTokens: 10, outputTokens: 5 },
-          stopReason: "tool_use",
-        };
-      },
-    };
-
-    // No preactivatedSkillIds passed — defaults to ['computer-use'] via skill projection
-    const session = new ComputerUseSession(
-      "cu-default-projection",
-      "test default projection",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-      undefined,
-    );
-
-    await session.handleObservation({
-      type: "cu_observation",
-      sessionId: "cu-default-projection",
-      axTree: 'Window "Test" [1]',
-    });
-
-    const cuTools = capturedTools.filter((n) => n.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(10);
-  });
-
-  test("constructor accepts preactivatedSkillIds parameter", () => {
-    const { provider } = createProvider([
-      {
-        content: [{ type: "text", text: "unused" }],
-        model: "mock-model",
-        usage: { inputTokens: 1, outputTokens: 1 },
-        stopReason: "end_turn",
-      },
-    ]);
-
-    // Should not throw
-    const session = new ComputerUseSession(
-      "cu-preactivated",
-      "test preactivated",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-      undefined,
-      ["computer-use"],
-    );
-
-    expect(session).toBeDefined();
-  });
-});

package/src/__tests__/computer-use-session-working-dir.test.ts

@@ -1,166 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { CuObservation } from "../daemon/message-protocol.js";
-import type { Provider } from "../providers/types.js";
-
-let capturedWorkingDir: string | undefined;
-
-const noopLogger = new Proxy({} as Record<string, unknown>, {
-  get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
-});
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realLogger = require("../util/logger.js");
-mock.module("../util/logger.js", () => ({
-  ...realLogger,
-  getLogger: () => noopLogger,
-  getCliLogger: () => noopLogger,
-  isDebug: () => false,
-  truncateForLog: (value: string, maxLen = 500) =>
-    value.length > maxLen ? value.slice(0, maxLen) + "..." : value,
-  initLogger: () => {},
-  pruneOldLogFiles: () => 0,
-}));
-
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realPlatform = require("../util/platform.js");
-mock.module("../util/platform.js", () => ({
-  ...realPlatform,
-  getRootDir: () => "/tmp",
-  getDataDir: () => "/tmp/data",
-
-  getSandboxRootDir: () => "/tmp/sandbox",
-  getSandboxWorkingDir: () => "/tmp/workspace",
-  getInterfacesDir: () => "/tmp/interfaces",
-  getWorkspaceDir: () => "/tmp/workspace",
-  getWorkspaceConfigPath: () => "/tmp/workspace/config.json",
-  getWorkspaceSkillsDir: () => "/tmp/workspace/skills",
-  getWorkspaceHooksDir: () => "/tmp/workspace/hooks",
-  getWorkspacePromptPath: (file: string) => `/tmp/workspace/${file}`,
-  getPlatformName: () => "linux",
-  getClipboardCommand: () => null,
-  getPidPath: () => "/tmp/test.pid",
-  getDbPath: () => "/tmp/data/db/assistant.db",
-  getLogPath: () => "/tmp/test.log",
-  getHistoryPath: () => "/tmp/data/history",
-  getHooksDir: () => "/tmp/hooks",
-  readSessionToken: () => null,
-  ensureDataDir: () => {},
-  isMacOS: () => false,
-  isLinux: () => true,
-  isWindows: () => false,
-  normalizeAssistantId: (id: string) => id,
-  readLockfile: () => null,
-  writeLockfile: () => {},
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    daemon: { standaloneRecording: false },
-    provider: "mock-provider",
-    model: "mock-model",
-    permissions: { mode: "workspace" },
-    apiKeys: {},
-    sandbox: { enabled: false, backend: "native" },
-    timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },
-    skills: { load: { extraDirs: [] } },
-    secretDetection: {
-      enabled: false,
-      allowOneTimeSend: false,
-      customPatterns: [],
-      entropyThreshold: 3.5,
-    },
-    contextWindow: {
-      enabled: true,
-      maxInputTokens: 180000,
-      targetBudgetRatio: 0.30,
-      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
-    },
-    assistantFeatureFlagValues: {},
-  }),
-  loadConfig: () => ({}),
-  loadRawConfig: () => ({}),
-  saveConfig: () => {},
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-  applyNestedDefaults: (config: unknown) => config,
-  getNestedValue: () => undefined,
-  setNestedValue: () => {},
-  syncConfigToLockfile: () => {},
-  API_KEY_PROVIDERS: [],
-}));
-
-const { ToolExecutor } = await import("../tools/executor.js");
-const { ComputerUseSession } =
-  await import("../daemon/computer-use-session.js");
-
-const originalExecute = ToolExecutor.prototype.execute;
-
-describe("ComputerUseSession working directory", () => {
-  beforeEach(() => {
-    capturedWorkingDir = undefined;
-    ToolExecutor.prototype.execute = async function (
-      _name: string,
-      _input: Record<string, unknown>,
-      context: { workingDir: string },
-    ) {
-      capturedWorkingDir = context.workingDir;
-      return { content: "ok", isError: false };
-    } as typeof ToolExecutor.prototype.execute;
-  });
-
-  afterEach(() => {
-    ToolExecutor.prototype.execute = originalExecute;
-  });
-
-  test("uses sandbox working directory for tool execution context", async () => {
-    let providerCalls = 0;
-    const provider: Provider = {
-      name: "mock-provider",
-      async sendMessage() {
-        const calls = providerCalls++;
-        if (calls === 0) {
-          return {
-            content: [
-              {
-                type: "tool_use",
-                id: "toolu_1",
-                name: "computer_use_click",
-                input: { element_id: 1 },
-              },
-            ],
-            model: "mock-model",
-            usage: { inputTokens: 1, outputTokens: 1 },
-            stopReason: "tool_use",
-          };
-        }
-        return {
-          content: [{ type: "text", text: "unused" }],
-          model: "mock-model",
-          usage: { inputTokens: 1, outputTokens: 1 },
-          stopReason: "end_turn",
-        };
-      },
-    };
-
-    const session = new ComputerUseSession(
-      "cu-sandbox-1",
-      "test task",
-      1440,
-      900,
-      provider,
-      () => {},
-    );
-
-    const observation: CuObservation = {
-      type: "cu_observation",
-      sessionId: "cu-sandbox-1",
-      axTree: 'Window "Test" [1]',
-    };
-
-    await session.handleObservation(observation);
-
-    expect(capturedWorkingDir).toBe("/tmp/workspace");
-  });
-});

package/src/__tests__/computer-use-skill-baseline.test.ts

@@ -1,78 +0,0 @@
-import { afterAll, describe, expect, test } from "bun:test";
-
-import { buildToolDefinitions } from "../daemon/session-tool-setup.js";
-import {
-  __resetRegistryForTesting,
-  getAllToolDefinitions,
-  getAllTools,
-  getTool,
-  initializeTools,
-} from "../tools/registry.js";
-import {
-  assertComputerUseToolsAbsent,
-  COMPUTER_USE_TOOL_NAMES,
-} from "./test-support/computer-use-skill-harness.js";
-
-afterAll(() => {
-  __resetRegistryForTesting();
-});
-
-describe("computer-use skill baseline: registry tool surfaces", () => {
-  test("no computer_use_* action tools are registered after initializeTools() (migrated to skill)", async () => {
-    await initializeTools();
-
-    for (const name of COMPUTER_USE_TOOL_NAMES) {
-      const tool = getTool(name);
-      expect(tool).toBeUndefined();
-    }
-  });
-
-  test("computer_use_request_control is registered in core after initializeTools()", async () => {
-    await initializeTools();
-
-    const tool = getTool("computer_use_request_control");
-    expect(tool).toBeDefined();
-  });
-
-  test("getAllToolDefinitions() excludes all computer_use_* tools (proxy exclusion)", async () => {
-    await initializeTools();
-
-    const defNames = getAllToolDefinitions().map((d) => d.name);
-    assertComputerUseToolsAbsent(defNames);
-  });
-
-  test("getAllToolDefinitions() excludes computer_use_request_control (proxy exclusion)", async () => {
-    await initializeTools();
-
-    const defNames = getAllToolDefinitions().map((d) => d.name);
-    expect(defNames).not.toContain("computer_use_request_control");
-  });
-
-  test("buildToolDefinitions() includes computer_use_request_control for text sessions", async () => {
-    await initializeTools();
-
-    const defNames = buildToolDefinitions().map((d) => d.name);
-    expect(defNames).toContain("computer_use_request_control");
-  });
-
-  test("buildToolDefinitions() excludes all computer_use_* action tools from text sessions", async () => {
-    await initializeTools();
-
-    const defNames = buildToolDefinitions().map((d) => d.name);
-    // The only computer_use_* tool in text sessions is the escalation tool
-    const cuActionTools = defNames.filter(
-      (n) =>
-        n.startsWith("computer_use_") && n !== "computer_use_request_control",
-    );
-    expect(cuActionTools).toHaveLength(0);
-  });
-
-  test("post-cutover count: 1 computer_use_* tool in core registry (escalation only)", async () => {
-    await initializeTools();
-
-    const allTools = getAllTools();
-    const cuTools = allTools.filter((t) => t.name.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(1);
-    expect(cuTools[0].name).toBe("computer_use_request_control");
-  });
-});

package/src/__tests__/computer-use-skill-endstate.test.ts

@@ -1,105 +0,0 @@
-import { join } from "node:path";
-import { beforeAll, describe, expect, test } from "bun:test";
-
-import { getBundledSkillsDir } from "../config/skills.js";
-import { buildToolDefinitions } from "../daemon/session-tool-setup.js";
-import { parseToolManifestFile } from "../skills/tool-manifest.js";
-import {
-  __resetRegistryForTesting,
-  getAllToolDefinitions,
-  getAllTools,
-  getTool,
-  initializeTools,
-} from "../tools/registry.js";
-import {
-  COMPUTER_USE_TOOL_COUNT,
-  COMPUTER_USE_TOOL_NAMES,
-} from "./test-support/computer-use-skill-harness.js";
-
-beforeAll(async () => {
-  __resetRegistryForTesting();
-  await initializeTools();
-});
-
-describe("computer-use skill end-state", () => {
-  // ── Core Registry ──────────────────────────────────────────────────
-
-  test("core registry contains 1 computer_use_* tool (escalation only)", () => {
-    const allTools = getAllTools();
-    const cuTools = allTools.filter((t) => t.name.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(1);
-    expect(cuTools[0].name).toBe("computer_use_request_control");
-  });
-
-  test("computer_use_request_control is resolvable from core registry", () => {
-    expect(getTool("computer_use_request_control")).toBeDefined();
-  });
-
-  test("no action tool from COMPUTER_USE_TOOL_NAMES is resolvable from core registry", () => {
-    for (const name of COMPUTER_USE_TOOL_NAMES) {
-      expect(getTool(name)).toBeUndefined();
-    }
-  });
-
-  // ── getAllToolDefinitions (excludes proxy & skill tools) ──────────
-
-  test("getAllToolDefinitions() excludes computer_use_* tools", () => {
-    const defs = getAllToolDefinitions();
-    const cuDefs = defs.filter((d) => d.name.startsWith("computer_use_"));
-    expect(cuDefs).toHaveLength(0);
-  });
-
-  test("getAllToolDefinitions() excludes computer_use_request_control (proxy exclusion)", () => {
-    const defs = getAllToolDefinitions();
-    const found = defs.find((d) => d.name === "computer_use_request_control");
-    expect(found).toBeUndefined();
-  });
-
-  // ── buildToolDefinitions (text session tool set) ─────────────────
-
-  test("buildToolDefinitions() includes computer_use_request_control", () => {
-    const defs = buildToolDefinitions();
-    const found = defs.find((d) => d.name === "computer_use_request_control");
-    expect(found).toBeDefined();
-  });
-
-  test("buildToolDefinitions() excludes computer_use_* action tools", () => {
-    const defs = buildToolDefinitions();
-    const cuDefs = defs.filter(
-      (d) =>
-        d.name.startsWith("computer_use_") &&
-        d.name !== "computer_use_request_control",
-    );
-    expect(cuDefs).toHaveLength(0);
-  });
-
-  // ── Bundled Skill Catalog ────────────────────────────────────────
-
-  test(
-    "computer-use skill has exactly " +
-      COMPUTER_USE_TOOL_COUNT +
-      " tools in TOOLS.json",
-    () => {
-      const manifestPath = join(
-        getBundledSkillsDir(),
-        "computer-use",
-        "TOOLS.json",
-      );
-      const manifest = parseToolManifestFile(manifestPath);
-      expect(manifest.tools).toHaveLength(COMPUTER_USE_TOOL_COUNT);
-    },
-  );
-
-  test("bundled skill tool names match expected computer_use_* names", () => {
-    const manifestPath = join(
-      getBundledSkillsDir(),
-      "computer-use",
-      "TOOLS.json",
-    );
-    const manifest = parseToolManifestFile(manifestPath);
-    const toolNames = new Set(manifest.tools.map((t) => t.name));
-    for (const name of COMPUTER_USE_TOOL_NAMES) {
-      expect(toolNames.has(name)).toBe(true);
-    }
-  });
-});