| import { vi } from "vitest"; |
| import type { |
| ComputerUseCapabilityDescriptor, |
| ComputerUseV2ActionName, |
| } from "../../plugins/computer-use-contract.js"; |
|
|
| const mocks = vi.hoisted(() => ({ |
| listNodesMock: vi.fn(), |
| callGatewayToolMock: vi.fn(), |
| sleepMock: vi.fn(), |
| gatewayComputerStatusMock: vi.fn(), |
| })); |
|
|
| export const listNodesMock = mocks.listNodesMock; |
| export const callGatewayToolMock = mocks.callGatewayToolMock; |
| export const sleepMock = mocks.sleepMock; |
| export const gatewayComputerStatusMock = mocks.gatewayComputerStatusMock; |
| export const TINY_PNG_BASE64 = |
| "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII="; |
| export const COMPUTER_ACT_COMMAND = "computer.act"; |
|
|
| vi.mock("./nodes-utils.js", async (importOriginal) => { |
| const actual = await importOriginal<typeof import("./nodes-utils.js")>(); |
| return { ...actual, listNodes: listNodesMock }; |
| }); |
|
|
| vi.mock("./gateway.js", async (importOriginal) => { |
| const actual = await importOriginal<typeof import("./gateway.js")>(); |
| return { ...actual, callGatewayTool: callGatewayToolMock }; |
| }); |
|
|
| vi.mock("../../utils/sleep.js", () => ({ sleep: sleepMock })); |
| vi.mock("./computer-tool-gateway.js", () => ({ |
| loadGatewayComputerStatus: gatewayComputerStatusMock, |
| bindGatewayComputerCleanup: async () => undefined, |
| })); |
|
|
| export const { createComputerTool, invalidateComputerFrameIfMissing } = |
| await import("./computer-tool.js"); |
| export const { loadPairedComputerUseAvailabilityForSurface } = |
| await import("../computer-use-node-capabilities.js"); |
| const { DEFAULT_IMAGE_MAX_DIMENSION_PX } = await import("../image-sanitization.js"); |
|
|
| |
| export const EFFECTIVE_REF_WIDTH = Math.min(1280, DEFAULT_IMAGE_MAX_DIMENSION_PX); |
|
|
| export function macComputerNode(overrides?: Record<string, unknown>) { |
| return { |
| nodeId: "mac-1", |
| displayName: "Studio", |
| platform: "macos", |
| connected: true, |
| commands: ["screen.snapshot", "computer.act"], |
| ...overrides, |
| }; |
| } |
|
|
| export function v2Descriptor( |
| actions: ComputerUseV2ActionName[], |
| overrides: Partial<ComputerUseCapabilityDescriptor> = {}, |
| ): ComputerUseCapabilityDescriptor { |
| return { |
| contractVersion: 2 as const, |
| provider: { id: "fixture", label: "Fixture", generation: "generation-1" }, |
| actions, |
| targets: ["screen", "window", "element", "browser"] as const, |
| deliveryModes: ["background", "foreground"] as const, |
| observations: ["image", "accessibility", "browser"] as const, |
| features: { recording: false, agentCursor: false, multiDisplay: false }, |
| ...overrides, |
| }; |
| } |
|
|
| export type ComputerTool = ReturnType<typeof createComputerTool>; |
| export type ComputerToolOptions = NonNullable<Parameters<typeof createComputerTool>[0]>; |
| export type ComputerActBody = { |
| nodeId?: string; |
| command?: string; |
| idempotencyKey?: string; |
| params?: Record<string, unknown>; |
| }; |
|
|
| export function readActionEnum(tool: ComputerTool): string[] { |
| const schema = tool.parameters as { properties?: { action?: { enum?: string[] } } }; |
| return schema.properties?.action?.enum ?? []; |
| } |
|
|
| export function screenshotPayload(screenIndex = 0, base64 = TINY_PNG_BASE64) { |
| return { |
| payload: { |
| format: "png", |
| base64, |
| displayFrameId: `display-${screenIndex}-frame`, |
| width: 1280, |
| height: 800, |
| screenIndex, |
| }, |
| }; |
| } |
|
|
| export function readFrameId(result: { details?: unknown }): string { |
| const frameId = (result.details as { frameId?: unknown } | undefined)?.frameId; |
| if (typeof frameId !== "string") { |
| throw new Error("missing frameId"); |
| } |
| return frameId; |
| } |
|
|
| export function readLastComputerActParams( |
| action?: ComputerUseV2ActionName, |
| ): Record<string, unknown> { |
| const call = callGatewayToolMock.mock.calls.findLast((entry) => { |
| const body = entry[2] as ComputerActBody; |
| return body.command === COMPUTER_ACT_COMMAND && (!action || body.params?.action === action); |
| }); |
| const body = call?.[2] as { params?: Record<string, unknown> } | undefined; |
| if (!body?.params) { |
| throw new Error("missing computer.act request"); |
| } |
| const { executionId: _executionId, ...params } = body.params; |
| return params; |
| } |
|
|
| export function createVisionComputerTool(options: ComputerToolOptions = {}) { |
| return createComputerTool({ modelHasVision: true, ...options }); |
| } |
|
|
| export function resetComputerToolMocks() { |
| listNodesMock.mockReset(); |
| callGatewayToolMock.mockReset(); |
| gatewayComputerStatusMock.mockReset(); |
| gatewayComputerStatusMock.mockResolvedValue({ configured: false, available: false }); |
| sleepMock.mockReset(); |
| sleepMock.mockImplementation((ms: number, signal?: AbortSignal) => { |
| if (signal?.aborted) { |
| return Promise.reject(new Error("Aborted")); |
| } |
| if (ms === 500 || !signal) { |
| return Promise.resolve(); |
| } |
| return new Promise<void>((_resolve, reject) => { |
| signal.addEventListener("abort", () => reject(new Error("Aborted")), { once: true }); |
| }); |
| }); |
| listNodesMock.mockResolvedValue([macComputerNode()]); |
| callGatewayToolMock.mockImplementation(async (_method, _opts, body) => |
| (body as ComputerActBody).command === COMPUTER_ACT_COMMAND |
| ? { payload: { ok: true } } |
| : screenshotPayload(), |
| ); |
| } |
|
|
