@vellumai/assistant 0.4.16 → 0.4.18

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

@@ -1,43 +1,46 @@
-import { beforeEach, describe, expect, mock, test } from 'bun:test';
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { CuObservation } from '../daemon/ipc-protocol.js';
-import type { Provider } from '../providers/types.js';
+import type { CuObservation } from "../daemon/ipc-protocol.js";
+import type { Provider } from "../providers/types.js";
 
 let capturedWorkingDir: string | undefined;
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
-  getCliLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  getCliLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
   isDebug: () => false,
-  truncateForLog: (value: string, maxLen = 500) => value.length > maxLen ? value.slice(0, maxLen) + '...' : value,
+  truncateForLog: (value: string, maxLen = 500) =>
+    value.length > maxLen ? value.slice(0, maxLen) + "..." : value,
   initLogger: () => {},
   pruneOldLogFiles: () => 0,
 }));
 
-mock.module('../util/platform.js', () => ({
-  getRootDir: () => '/tmp',
-  getDataDir: () => '/tmp/data',
-  getIpcBlobDir: () => '/tmp/data/ipc-blobs',
-  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',
+mock.module("../util/platform.js", () => ({
+  getRootDir: () => "/tmp",
+  getDataDir: () => "/tmp/data",
+  getIpcBlobDir: () => "/tmp/data/ipc-blobs",
+  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',
+  getPlatformName: () => "linux",
   getClipboardCommand: () => null,
-  getSocketPath: () => '/tmp/test.sock',
-  getPidPath: () => '/tmp/test.pid',
-  getDbPath: () => '/tmp/data/db/assistant.db',
-  getLogPath: () => '/tmp/test.log',
-  getHistoryPath: () => '/tmp/data/history',
-  getHooksDir: () => '/tmp/hooks',
+  getSocketPath: () => "/tmp/test.sock",
+  getPidPath: () => "/tmp/test.pid",
+  getDbPath: () => "/tmp/data/db/assistant.db",
+  getLogPath: () => "/tmp/test.log",
+  getHistoryPath: () => "/tmp/data/history",
+  getHooksDir: () => "/tmp/hooks",
   removeSocketFile: () => {},
   ensureDataDir: () => {},
   migrateToDataLayout: () => {},
@@ -50,7 +53,7 @@ mock.module('../util/platform.js', () => ({
   normalizeAssistantId: (id: string) => id,
 }));
 
-mock.module('../tools/executor.js', () => ({
+mock.module("../tools/executor.js", () => ({
   ToolExecutor: class {
     constructor(..._args: unknown[]) {}
 
@@ -60,54 +63,65 @@ mock.module('../tools/executor.js', () => ({
       context: { workingDir: string },
     ) {
       capturedWorkingDir = context.workingDir;
-      return { content: 'ok', isError: false };
+      return { content: "ok", isError: false };
     }
   },
 }));
 
-mock.module('../agent/loop.js', () => ({
+mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
-    private readonly runTool: (name: string, input: Record<string, unknown>) => Promise<unknown>;
+    private readonly runTool: (
+      name: string,
+      input: Record<string, unknown>,
+    ) => Promise<unknown>;
 
     constructor(
       _provider: unknown,
       _systemPrompt: unknown,
       _options: unknown,
       _toolDefs: unknown,
-      toolExecutor: (name: string, input: Record<string, unknown>) => Promise<unknown>,
+      toolExecutor: (
+        name: string,
+        input: Record<string, unknown>,
+      ) => Promise<unknown>,
     ) {
       this.runTool = toolExecutor;
     }
 
-    async run(_messages: unknown, _onEvent: unknown, _signal?: AbortSignal): Promise<void> {
-      await this.runTool('computer_use_click', { element_id: 1 });
+    async run(
+      _messages: unknown,
+      _onEvent: unknown,
+      _signal?: AbortSignal,
+    ): Promise<void> {
+      await this.runTool("computer_use_click", { element_id: 1 });
     }
   },
 }));
 
-const { ComputerUseSession } = await import('../daemon/computer-use-session.js');
+const { ComputerUseSession } =
+  await import("../daemon/computer-use-session.js");
 
-describe('ComputerUseSession working directory', () => {
+describe("ComputerUseSession working directory", () => {
   beforeEach(() => {
     capturedWorkingDir = undefined;
   });
 
-  test('uses sandbox working directory for tool execution context', async () => {
+  test("uses sandbox working directory for tool execution context", async () => {
     const provider: Provider = {
-      name: 'mock-provider',
+      name: "mock-provider",
       async sendMessage() {
         return {
-          content: [{ type: 'text', text: 'unused' }],
-          model: 'mock-model',
+          content: [{ type: "text", text: "unused" }],
+          model: "mock-model",
           usage: { inputTokens: 1, outputTokens: 1 },
-          stopReason: 'end_turn',
+          stopReason: "end_turn",
         };
       },
     };
 
     const session = new ComputerUseSession(
-      'cu-sandbox-1',
-      'test task',
+      "cu-sandbox-1",
+      "test task",
       1440,
       900,
       provider,
@@ -115,13 +129,13 @@ describe('ComputerUseSession working directory', () => {
     );
 
     const observation: CuObservation = {
-      type: 'cu_observation',
-      sessionId: 'cu-sandbox-1',
+      type: "cu_observation",
+      sessionId: "cu-sandbox-1",
       axTree: 'Window "Test" [1]',
     };
 
     await session.handleObservation(observation);
 
-    expect(capturedWorkingDir).toBe('/tmp/workspace');
+    expect(capturedWorkingDir).toBe("/tmp/workspace");
   });
 });

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

@@ -1,22 +1,24 @@
-import { afterAll,describe, expect, test } from 'bun:test';
+import { afterAll, describe, expect, test } from "bun:test";
 
-import { buildToolDefinitions } from '../daemon/session-tool-setup.js';
+import { buildToolDefinitions } from "../daemon/session-tool-setup.js";
 import {
   __resetRegistryForTesting,
   getAllToolDefinitions,
   getAllTools,
   getTool,
   initializeTools,
-} from '../tools/registry.js';
+} from "../tools/registry.js";
 import {
   assertComputerUseToolsAbsent,
   COMPUTER_USE_TOOL_NAMES,
-} from './test-support/computer-use-skill-harness.js';
+} from "./test-support/computer-use-skill-harness.js";
 
-afterAll(() => { __resetRegistryForTesting(); });
+afterAll(() => {
+  __resetRegistryForTesting();
+});
 
-describe('computer-use skill baseline: registry tool surfaces', () => {
-  test('no computer_use_* action tools are registered after initializeTools() (migrated to skill)', async () => {
+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) {
@@ -25,51 +27,52 @@ describe('computer-use skill baseline: registry tool surfaces', () => {
     }
   });
 
-  test('computer_use_request_control is registered in core after initializeTools()', async () => {
+  test("computer_use_request_control is registered in core after initializeTools()", async () => {
     await initializeTools();
 
-    const tool = getTool('computer_use_request_control');
+    const tool = getTool("computer_use_request_control");
     expect(tool).toBeDefined();
   });
 
-  test('getAllToolDefinitions() excludes all computer_use_* tools (proxy exclusion)', async () => {
+  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 () => {
+  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');
+    expect(defNames).not.toContain("computer_use_request_control");
   });
 
-  test('buildToolDefinitions() includes computer_use_request_control for text sessions', async () => {
+  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');
+    expect(defNames).toContain("computer_use_request_control");
   });
 
-  test('buildToolDefinitions() excludes all computer_use_* action tools from text sessions', async () => {
+  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',
+      (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 () => {
+  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_'));
+    const cuTools = allTools.filter((t) => t.name.startsWith("computer_use_"));
     expect(cuTools).toHaveLength(1);
-    expect(cuTools[0].name).toBe('computer_use_request_control');
+    expect(cuTools[0].name).toBe("computer_use_request_control");
   });
 });

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

@@ -1,42 +1,41 @@
-import { join } from 'node:path';
+import { join } from "node:path";
+import { beforeAll, describe, expect, test } from "bun:test";
 
-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 { 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';
+} from "../tools/registry.js";
 import {
   COMPUTER_USE_TOOL_COUNT,
   COMPUTER_USE_TOOL_NAMES,
-} from './test-support/computer-use-skill-harness.js';
+} from "./test-support/computer-use-skill-harness.js";
 
 beforeAll(async () => {
   __resetRegistryForTesting();
   await initializeTools();
 });
 
-describe('computer-use skill end-state', () => {
+describe("computer-use skill end-state", () => {
   // ── Core Registry ──────────────────────────────────────────────────
 
-  test('core registry contains 1 computer_use_* tool (escalation only)', () => {
+  test("core registry contains 1 computer_use_* tool (escalation only)", () => {
     const allTools = getAllTools();
-    const cuTools = allTools.filter((t) => t.name.startsWith('computer_use_'));
+    const cuTools = allTools.filter((t) => t.name.startsWith("computer_use_"));
     expect(cuTools).toHaveLength(1);
-    expect(cuTools[0].name).toBe('computer_use_request_control');
+    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("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', () => {
+  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();
     }
@@ -44,44 +43,59 @@ describe('computer-use skill end-state', () => {
 
   // ── getAllToolDefinitions (excludes proxy & skill tools) ──────────
 
-  test('getAllToolDefinitions() excludes computer_use_* tools', () => {
+  test("getAllToolDefinitions() excludes computer_use_* tools", () => {
     const defs = getAllToolDefinitions();
-    const cuDefs = defs.filter((d) => d.name.startsWith('computer_use_'));
+    const cuDefs = defs.filter((d) => d.name.startsWith("computer_use_"));
     expect(cuDefs).toHaveLength(0);
   });
 
-  test('getAllToolDefinitions() excludes computer_use_request_control (proxy exclusion)', () => {
+  test("getAllToolDefinitions() excludes computer_use_request_control (proxy exclusion)", () => {
     const defs = getAllToolDefinitions();
-    const found = defs.find((d) => d.name === 'computer_use_request_control');
+    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', () => {
+  test("buildToolDefinitions() includes computer_use_request_control", () => {
     const defs = buildToolDefinitions();
-    const found = defs.find((d) => d.name === 'computer_use_request_control');
+    const found = defs.find((d) => d.name === "computer_use_request_control");
     expect(found).toBeDefined();
   });
 
-  test('buildToolDefinitions() excludes computer_use_* action tools', () => {
+  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',
+      (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');
+  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) {