@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/computer-use-tools.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect,test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 
 import {
   allComputerUseTools,
@@ -14,10 +14,10 @@ import {
   computerUseScrollTool,
   computerUseTypeTextTool,
   computerUseWaitTool,
-} from '../tools/computer-use/definitions.js';
-import { requestComputerControlTool } from '../tools/computer-use/request-computer-control.js';
-import { forwardComputerUseProxyTool } from '../tools/computer-use/skill-proxy-bridge.js';
-import type { ToolContext } from '../tools/types.js';
+} from "../tools/computer-use/definitions.js";
+import { requestComputerControlTool } from "../tools/computer-use/request-computer-control.js";
+import { forwardComputerUseProxyTool } from "../tools/computer-use/skill-proxy-bridge.js";
+import type { ToolContext } from "../tools/types.js";
 
 interface JsonSchema {
   type?: string;
@@ -26,44 +26,46 @@ interface JsonSchema {
 }
 
 /** Cast a tool definition's input_schema to a usable JSON Schema shape. */
-function schema(tool: { getDefinition(): { input_schema: object } }): JsonSchema {
+function schema(tool: {
+  getDefinition(): { input_schema: object };
+}): JsonSchema {
   return tool.getDefinition().input_schema as JsonSchema;
 }
 
 const ctx: ToolContext = {
-  workingDir: '/tmp',
-  sessionId: 'test-session',
-  conversationId: 'test-conversation',
-  guardianTrustClass: 'guardian',
+  workingDir: "/tmp",
+  sessionId: "test-session",
+  conversationId: "test-conversation",
+  guardianTrustClass: "guardian",
 };
 
 // ── Tool definitions ────────────────────────────────────────────────
 
-describe('computer-use tool definitions', () => {
-  test('allComputerUseTools contains 12 tools', () => {
+describe("computer-use tool definitions", () => {
+  test("allComputerUseTools contains 12 tools", () => {
     expect(allComputerUseTools.length).toBe(12);
   });
 
-  test('all tools have proxy execution mode', () => {
+  test("all tools have proxy execution mode", () => {
     for (const tool of allComputerUseTools) {
-      expect(tool.executionMode).toBe('proxy');
+      expect(tool.executionMode).toBe("proxy");
     }
-    expect(requestComputerControlTool.executionMode).toBe('proxy');
+    expect(requestComputerControlTool.executionMode).toBe("proxy");
   });
 
-  test('all tools belong to computer-use category', () => {
+  test("all tools belong to computer-use category", () => {
     for (const tool of allComputerUseTools) {
-      expect(tool.category).toBe('computer-use');
+      expect(tool.category).toBe("computer-use");
     }
-    expect(requestComputerControlTool.category).toBe('computer-use');
+    expect(requestComputerControlTool.category).toBe("computer-use");
   });
 
-  test('all tools have unique names', () => {
+  test("all tools have unique names", () => {
     const names = allComputerUseTools.map((t) => t.name);
     expect(new Set(names).size).toBe(names.length);
   });
 
-  test('all tools have descriptions', () => {
+  test("all tools have descriptions", () => {
     for (const tool of allComputerUseTools) {
       expect(tool.description.length).toBeGreaterThan(0);
     }
@@ -72,181 +74,202 @@ describe('computer-use tool definitions', () => {
 
 // ── Click tool variants ─────────────────────────────────────────────
 
-describe('click tool variants', () => {
+describe("click tool variants", () => {
   for (const [tool, label] of [
-    [computerUseClickTool, 'click'],
-    [computerUseDoubleClickTool, 'double_click'],
-    [computerUseRightClickTool, 'right_click'],
+    [computerUseClickTool, "click"],
+    [computerUseDoubleClickTool, "double_click"],
+    [computerUseRightClickTool, "right_click"],
   ] as const) {
     test(`${tool.name} has correct name`, () => {
       expect(tool.name).toBe(`computer_use_${label}`);
     });
 
     test(`${tool.name} schema requires reasoning`, () => {
-      expect(schema(tool).required).toContain('reasoning');
+      expect(schema(tool).required).toContain("reasoning");
     });
 
     test(`${tool.name} schema supports element_id and coordinates`, () => {
       const props = schema(tool).properties as Record<string, { type: string }>;
-      expect(props.element_id.type).toBe('integer');
-      expect(props.x.type).toBe('integer');
-      expect(props.y.type).toBe('integer');
+      expect(props.element_id.type).toBe("integer");
+      expect(props.x.type).toBe("integer");
+      expect(props.y.type).toBe("integer");
     });
 
     test(`${tool.name} execute throws proxy error`, () => {
-      expect(() => tool.execute({}, ctx)).toThrow('Proxy tool');
+      expect(() => tool.execute({}, ctx)).toThrow("Proxy tool");
     });
   }
 });
 
 // ── type_text ───────────────────────────────────────────────────────
 
-describe('computer_use_type_text', () => {
-  test('requires text and reasoning', () => {
-    expect(schema(computerUseTypeTextTool).required).toContain('text');
-    expect(schema(computerUseTypeTextTool).required).toContain('reasoning');
+describe("computer_use_type_text", () => {
+  test("requires text and reasoning", () => {
+    expect(schema(computerUseTypeTextTool).required).toContain("text");
+    expect(schema(computerUseTypeTextTool).required).toContain("reasoning");
   });
 
-  test('execute throws proxy error', () => {
-    expect(() => computerUseTypeTextTool.execute({}, ctx)).toThrow('Proxy tool');
+  test("execute throws proxy error", () => {
+    expect(() => computerUseTypeTextTool.execute({}, ctx)).toThrow(
+      "Proxy tool",
+    );
   });
 });
 
 // ── key ─────────────────────────────────────────────────────────────
 
-describe('computer_use_key', () => {
-  test('requires key and reasoning', () => {
-    expect(schema(computerUseKeyTool).required).toContain('key');
-    expect(schema(computerUseKeyTool).required).toContain('reasoning');
+describe("computer_use_key", () => {
+  test("requires key and reasoning", () => {
+    expect(schema(computerUseKeyTool).required).toContain("key");
+    expect(schema(computerUseKeyTool).required).toContain("reasoning");
   });
 
-  test('execute throws proxy error', () => {
-    expect(() => computerUseKeyTool.execute({}, ctx)).toThrow('Proxy tool');
+  test("execute throws proxy error", () => {
+    expect(() => computerUseKeyTool.execute({}, ctx)).toThrow("Proxy tool");
   });
 });
 
 // ── scroll ──────────────────────────────────────────────────────────
 
-describe('computer_use_scroll', () => {
-  test('requires direction, amount, and reasoning', () => {
-    expect(schema(computerUseScrollTool).required).toContain('direction');
-    expect(schema(computerUseScrollTool).required).toContain('amount');
-    expect(schema(computerUseScrollTool).required).toContain('reasoning');
+describe("computer_use_scroll", () => {
+  test("requires direction, amount, and reasoning", () => {
+    expect(schema(computerUseScrollTool).required).toContain("direction");
+    expect(schema(computerUseScrollTool).required).toContain("amount");
+    expect(schema(computerUseScrollTool).required).toContain("reasoning");
   });
 
-  test('direction enum includes up, down, left, right', () => {
-    const props = schema(computerUseScrollTool).properties as Record<string, { enum?: string[] }>;
-    expect(props.direction.enum).toEqual(['up', 'down', 'left', 'right']);
+  test("direction enum includes up, down, left, right", () => {
+    const props = schema(computerUseScrollTool).properties as Record<
+      string,
+      { enum?: string[] }
+    >;
+    expect(props.direction.enum).toEqual(["up", "down", "left", "right"]);
   });
 });
 
 // ── drag ────────────────────────────────────────────────────────────
 
-describe('computer_use_drag', () => {
-  test('supports source and destination coordinates', () => {
-    const props = schema(computerUseDragTool).properties as Record<string, { type: string }>;
-    expect(props.element_id.type).toBe('integer');
-    expect(props.to_element_id.type).toBe('integer');
-    expect(props.x.type).toBe('integer');
-    expect(props.y.type).toBe('integer');
-    expect(props.to_x.type).toBe('integer');
-    expect(props.to_y.type).toBe('integer');
+describe("computer_use_drag", () => {
+  test("supports source and destination coordinates", () => {
+    const props = schema(computerUseDragTool).properties as Record<
+      string,
+      { type: string }
+    >;
+    expect(props.element_id.type).toBe("integer");
+    expect(props.to_element_id.type).toBe("integer");
+    expect(props.x.type).toBe("integer");
+    expect(props.y.type).toBe("integer");
+    expect(props.to_x.type).toBe("integer");
+    expect(props.to_y.type).toBe("integer");
   });
 
-  test('requires reasoning only', () => {
-    expect(schema(computerUseDragTool).required).toEqual(['reasoning']);
+  test("requires reasoning only", () => {
+    expect(schema(computerUseDragTool).required).toEqual(["reasoning"]);
   });
 });
 
 // ── wait ────────────────────────────────────────────────────────────
 
-describe('computer_use_wait', () => {
-  test('requires duration_ms and reasoning', () => {
-    expect(schema(computerUseWaitTool).required).toContain('duration_ms');
-    expect(schema(computerUseWaitTool).required).toContain('reasoning');
+describe("computer_use_wait", () => {
+  test("requires duration_ms and reasoning", () => {
+    expect(schema(computerUseWaitTool).required).toContain("duration_ms");
+    expect(schema(computerUseWaitTool).required).toContain("reasoning");
   });
 });
 
 // ── open_app ────────────────────────────────────────────────────────
 
-describe('computer_use_open_app', () => {
-  test('requires app_name and reasoning', () => {
-    expect(schema(computerUseOpenAppTool).required).toContain('app_name');
-    expect(schema(computerUseOpenAppTool).required).toContain('reasoning');
+describe("computer_use_open_app", () => {
+  test("requires app_name and reasoning", () => {
+    expect(schema(computerUseOpenAppTool).required).toContain("app_name");
+    expect(schema(computerUseOpenAppTool).required).toContain("reasoning");
   });
 });
 
 // ── run_applescript ─────────────────────────────────────────────────
 
-describe('computer_use_run_applescript', () => {
-  test('requires script and reasoning', () => {
-    expect(schema(computerUseRunAppleScriptTool).required).toContain('script');
-    expect(schema(computerUseRunAppleScriptTool).required).toContain('reasoning');
+describe("computer_use_run_applescript", () => {
+  test("requires script and reasoning", () => {
+    expect(schema(computerUseRunAppleScriptTool).required).toContain("script");
+    expect(schema(computerUseRunAppleScriptTool).required).toContain(
+      "reasoning",
+    );
   });
 
-  test('description warns against do shell script', () => {
-    expect(computerUseRunAppleScriptTool.description).toContain('do shell script');
-    expect(computerUseRunAppleScriptTool.description).toContain('blocked');
+  test("description warns against do shell script", () => {
+    expect(computerUseRunAppleScriptTool.description).toContain(
+      "do shell script",
+    );
+    expect(computerUseRunAppleScriptTool.description).toContain("blocked");
   });
 });
 
 // ── done ────────────────────────────────────────────────────────────
 
-describe('computer_use_done', () => {
-  test('requires summary', () => {
-    expect(schema(computerUseDoneTool).required).toContain('summary');
+describe("computer_use_done", () => {
+  test("requires summary", () => {
+    expect(schema(computerUseDoneTool).required).toContain("summary");
   });
 });
 
 // ── respond ─────────────────────────────────────────────────────────
 
-describe('computer_use_respond', () => {
-  test('requires answer and reasoning', () => {
-    expect(schema(computerUseRespondTool).required).toContain('answer');
-    expect(schema(computerUseRespondTool).required).toContain('reasoning');
+describe("computer_use_respond", () => {
+  test("requires answer and reasoning", () => {
+    expect(schema(computerUseRespondTool).required).toContain("answer");
+    expect(schema(computerUseRespondTool).required).toContain("reasoning");
   });
 });
 
 // ── request_computer_control ────────────────────────────────────────
 
-describe('computer_use_request_control', () => {
-  test('requires task parameter', () => {
-    expect(schema(requestComputerControlTool).required).toContain('task');
+describe("computer_use_request_control", () => {
+  test("requires task parameter", () => {
+    expect(schema(requestComputerControlTool).required).toContain("task");
   });
 
-  test('execute throws proxy error', () => {
-    expect(() => requestComputerControlTool.execute({}, ctx)).toThrow('surfaceProxyResolver');
+  test("execute throws proxy error", () => {
+    expect(() => requestComputerControlTool.execute({}, ctx)).toThrow(
+      "surfaceProxyResolver",
+    );
   });
 });
 
 // ── skill-proxy-bridge ──────────────────────────────────────────────
 
-describe('forwardComputerUseProxyTool', () => {
-  test('returns error when no proxy resolver available', async () => {
-    const result = await forwardComputerUseProxyTool('computer_use_click', {}, ctx);
+describe("forwardComputerUseProxyTool", () => {
+  test("returns error when no proxy resolver available", async () => {
+    const result = await forwardComputerUseProxyTool(
+      "computer_use_click",
+      {},
+      ctx,
+    );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain('no proxy resolver available');
-    expect(result.content).toContain('computer_use_click');
+    expect(result.content).toContain("no proxy resolver available");
+    expect(result.content).toContain("computer_use_click");
   });
 
-  test('delegates to proxy resolver when available', async () => {
+  test("delegates to proxy resolver when available", async () => {
     const ctxWithProxy: ToolContext = {
       ...ctx,
-      proxyToolResolver: async (name: string, input: Record<string, unknown>) => ({
+      proxyToolResolver: async (
+        name: string,
+        input: Record<string, unknown>,
+      ) => ({
         content: `Forwarded ${name} with ${JSON.stringify(input)}`,
         isError: false,
       }),
     };
 
     const result = await forwardComputerUseProxyTool(
-      'computer_use_screenshot',
-      { reasoning: 'test' },
+      "computer_use_screenshot",
+      { reasoning: "test" },
       ctxWithProxy,
     );
 
     expect(result.isError).toBe(false);
-    expect(result.content).toContain('Forwarded computer_use_screenshot');
-    expect(result.content).toContain('test');
+    expect(result.content).toContain("Forwarded computer_use_screenshot");
+    expect(result.content).toContain("test");
   });
 });