illuma-agents 1.0.45 → 1.0.49

package/src/specs/deepagents.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Deep Agents Unit Tests
+ * 
+ * Tests for the deep agents integration module
+ */
+
+import {
+  DeepAgentBackend,
+  calculateTodoProgress,
+  defaultDeepAgentState,
+  type DeepAgentTodo,
+  type DeepAgentSubagent,
+  type DeepAgentState,
+  type TodoStatus,
+} from '../deepagents';
+
+describe('Deep Agents Types', () => {
+  describe('calculateTodoProgress', () => {
+    it('should return 0 for empty todos', () => {
+      expect(calculateTodoProgress([])).toBe(0);
+    });
+
+    it('should return 0 when no todos are completed', () => {
+      const todos: DeepAgentTodo[] = [
+        { id: '1', content: 'Task 1', status: 'pending' },
+        { id: '2', content: 'Task 2', status: 'in_progress' },
+      ];
+      expect(calculateTodoProgress(todos)).toBe(0);
+    });
+
+    it('should return 50 when half of todos are completed', () => {
+      const todos: DeepAgentTodo[] = [
+        { id: '1', content: 'Task 1', status: 'completed' },
+        { id: '2', content: 'Task 2', status: 'pending' },
+      ];
+      expect(calculateTodoProgress(todos)).toBe(50);
+    });
+
+    it('should return 100 when all todos are completed', () => {
+      const todos: DeepAgentTodo[] = [
+        { id: '1', content: 'Task 1', status: 'completed' },
+        { id: '2', content: 'Task 2', status: 'completed' },
+        { id: '3', content: 'Task 3', status: 'completed' },
+      ];
+      expect(calculateTodoProgress(todos)).toBe(100);
+    });
+
+    it('should round progress correctly', () => {
+      const todos: DeepAgentTodo[] = [
+        { id: '1', content: 'Task 1', status: 'completed' },
+        { id: '2', content: 'Task 2', status: 'pending' },
+        { id: '3', content: 'Task 3', status: 'pending' },
+      ];
+      expect(calculateTodoProgress(todos)).toBe(33); // 33.33... rounds to 33
+    });
+  });
+
+  describe('defaultDeepAgentState', () => {
+    it('should have correct default values', () => {
+      expect(defaultDeepAgentState).toEqual({
+        enabled: false,
+        todos: [],
+        subagents: [],
+        progress: 0,
+        isRunning: false,
+      });
+    });
+
+    it('should be immutable (defensive copy check)', () => {
+      const state = { ...defaultDeepAgentState };
+      state.enabled = true;
+      expect(defaultDeepAgentState.enabled).toBe(false);
+    });
+  });
+
+  describe('TodoStatus type', () => {
+    it('should accept valid status values', () => {
+      const statuses: TodoStatus[] = ['pending', 'in_progress', 'completed', 'cancelled'];
+      expect(statuses).toHaveLength(4);
+    });
+  });
+
+  describe('DeepAgentTodo interface', () => {
+    it('should accept minimal todo', () => {
+      const todo: DeepAgentTodo = {
+        id: '1',
+        content: 'Test task',
+        status: 'pending',
+      };
+      expect(todo.id).toBe('1');
+      expect(todo.content).toBe('Test task');
+      expect(todo.status).toBe('pending');
+    });
+
+    it('should accept todo with optional fields', () => {
+      const todo: DeepAgentTodo = {
+        id: '1',
+        content: 'Test task',
+        status: 'completed',
+        order: 0,
+        createdAt: '2026-01-25T00:00:00Z',
+        updatedAt: '2026-01-25T01:00:00Z',
+      };
+      expect(todo.order).toBe(0);
+      expect(todo.createdAt).toBeDefined();
+      expect(todo.updatedAt).toBeDefined();
+    });
+  });
+
+  describe('DeepAgentSubagent interface', () => {
+    it('should accept minimal subagent', () => {
+      const subagent: DeepAgentSubagent = {
+        id: '1',
+        name: 'Research Agent',
+        status: 'pending',
+      };
+      expect(subagent.id).toBe('1');
+      expect(subagent.name).toBe('Research Agent');
+      expect(subagent.status).toBe('pending');
+    });
+
+    it('should accept subagent with optional fields', () => {
+      const subagent: DeepAgentSubagent = {
+        id: '1',
+        name: 'Research Agent',
+        description: 'Researches topics',
+        status: 'completed',
+        startedAt: '2026-01-25T00:00:00Z',
+        completedAt: '2026-01-25T01:00:00Z',
+      };
+      expect(subagent.description).toBe('Researches topics');
+      expect(subagent.startedAt).toBeDefined();
+      expect(subagent.completedAt).toBeDefined();
+    });
+  });
+});
+
+describe('DeepAgentBackend', () => {
+  describe('constructor', () => {
+    it('should create backend with default options', () => {
+      const backend = new DeepAgentBackend();
+      expect(backend.id).toMatch(/^deep-agent-backend-/);
+    });
+
+    it('should create backend with custom options', () => {
+      const backend = new DeepAgentBackend({
+        rootDir: '/tmp/test',
+        virtualMode: true,
+        timeout: 60000,
+        maxOutputBytes: 50000,
+        conversationId: 'test-convo',
+      });
+      expect(backend.id).toMatch(/^deep-agent-backend-/);
+    });
+  });
+
+  describe('execute', () => {
+    it('should return error for empty command', async () => {
+      const backend = new DeepAgentBackend();
+      const result = await backend.execute('');
+      expect(result.exitCode).toBe(1);
+      expect(result.output).toContain('Error');
+    });
+
+    it('should return warning when no code executor configured', async () => {
+      const backend = new DeepAgentBackend();
+      const result = await backend.execute('echo test');
+      expect(result.exitCode).toBe(1);
+      expect(result.output).toContain('not available');
+    });
+  });
+
+  describe('sendEvent', () => {
+    it('should send event when SSE response is available', () => {
+      const writeData: string[] = [];
+      const mockSseResponse = {
+        write: (data: string) => writeData.push(data),
+        headersSent: false,
+      };
+
+      const backend = new DeepAgentBackend({
+        sseResponse: mockSseResponse,
+        conversationId: 'test-convo',
+      });
+
+      backend.sendEvent('test_event', { foo: 'bar' });
+      
+      expect(writeData.length).toBe(1);
+      expect(writeData[0]).toContain('event: test_event');
+      expect(writeData[0]).toContain('"foo":"bar"');
+    });
+
+    it('should not throw when SSE response is not available', () => {
+      const backend = new DeepAgentBackend();
+      expect(() => backend.sendEvent('test', {})).not.toThrow();
+    });
+  });
+
+  describe('emitTodoUpdate', () => {
+    it('should emit todo update event', () => {
+      const writeData: string[] = [];
+      const mockSseResponse = {
+        write: (data: string) => writeData.push(data),
+        headersSent: false,
+      };
+
+      const todos: DeepAgentTodo[] = [
+        { id: '1', content: 'Task 1', status: 'completed' },
+        { id: '2', content: 'Task 2', status: 'pending' },
+      ];
+
+      const backend = new DeepAgentBackend({
+        sseResponse: mockSseResponse,
+        conversationId: 'test-convo',
+      });
+
+      backend.emitTodoUpdate(todos);
+
+      expect(writeData.length).toBe(1);
+      expect(writeData[0]).toContain('event: deep_research');
+      expect(writeData[0]).toContain('todo_update');
+      expect(writeData[0]).toContain('test-convo');
+    });
+
+    it('should call onTodoUpdate callback', () => {
+      const receivedTodos: DeepAgentTodo[][] = [];
+      const onTodoUpdate = (todos: DeepAgentTodo[]) => receivedTodos.push(todos);
+
+      const todos: DeepAgentTodo[] = [
+        { id: '1', content: 'Task 1', status: 'pending' },
+      ];
+
+      const backend = new DeepAgentBackend({
+        onTodoUpdate,
+      });
+
+      backend.emitTodoUpdate(todos);
+
+      expect(receivedTodos.length).toBe(1);
+      expect(receivedTodos[0]).toEqual(todos);
+    });
+  });
+
+  describe('emitSubagentUpdate', () => {
+    it('should emit subagent update event', () => {
+      const writeData: string[] = [];
+      const mockSseResponse = {
+        write: (data: string) => writeData.push(data),
+        headersSent: false,
+      };
+
+      const subagents: DeepAgentSubagent[] = [
+        { id: '1', name: 'Agent 1', status: 'running' },
+      ];
+
+      const backend = new DeepAgentBackend({
+        sseResponse: mockSseResponse,
+        conversationId: 'test-convo',
+      });
+
+      backend.emitSubagentUpdate(subagents);
+
+      expect(writeData.length).toBe(1);
+      expect(writeData[0]).toContain('event: deep_research');
+      expect(writeData[0]).toContain('subagent_update');
+    });
+
+    it('should call onSubagentUpdate callback', () => {
+      const receivedSubagents: DeepAgentSubagent[][] = [];
+      const onSubagentUpdate = (subagents: DeepAgentSubagent[]) => receivedSubagents.push(subagents);
+
+      const subagents: DeepAgentSubagent[] = [
+        { id: '1', name: 'Agent 1', status: 'running' },
+      ];
+
+      const backend = new DeepAgentBackend({
+        onSubagentUpdate,
+      });
+
+      backend.emitSubagentUpdate(subagents);
+
+      expect(receivedSubagents.length).toBe(1);
+      expect(receivedSubagents[0]).toEqual(subagents);
+    });
+  });
+});

package/dist/cjs/tools/DesktopTools.cjs

@@ -1,363 +0,0 @@
-'use strict';
-
-var zod = require('zod');
-var tools = require('@langchain/core/tools');
-
-/**
- * Desktop tool names - keep in sync with Ranger Desktop Electron app
- * These tools execute locally in the Electron app, NOT on the server
- */
-const EDesktopTools = {
-    SCREENSHOT: 'computer_screenshot',
-    CLICK: 'computer_click',
-    DOUBLE_CLICK: 'computer_double_click',
-    RIGHT_CLICK: 'computer_right_click',
-    TYPE: 'computer_type',
-    KEY: 'computer_key',
-    KEY_COMBO: 'computer_key_combo',
-    SCROLL: 'computer_scroll',
-    DRAG: 'computer_drag',
-    GET_ACTIVE_WINDOW: 'computer_get_active_window',
-    GET_MOUSE_POSITION: 'computer_get_mouse_position',
-    CLIPBOARD_READ: 'clipboard_read',
-    CLIPBOARD_WRITE: 'clipboard_write',
-    CLIPBOARD_PASTE: 'clipboard_paste',
-    WAIT: 'computer_wait',
-    // Native UI Automation tools (Windows) - faster and more reliable than screenshot-based
-    UI_FIND_ELEMENT: 'ui_find_element',
-    UI_CLICK_ELEMENT: 'ui_click_element',
-    UI_GET_WINDOW_TREE: 'ui_get_window_tree',
-    UI_FIND_BUTTONS: 'ui_find_buttons',
-    UI_FIND_INPUTS: 'ui_find_inputs',
-};
-/**
- * Check if desktop capability is available based on request headers or context
- * The Ranger Desktop Electron app sets these headers when connected:
- * - X-Ranger-Desktop: true
- * - X-Ranger-Desktop-Capable: true
- */
-function hasDesktopCapability(req) {
-    if (!req?.headers) {
-        return false;
-    }
-    const desktopApp = req.headers['x-ranger-desktop'];
-    const desktopCapable = req.headers['x-ranger-desktop-capable'];
-    return desktopApp === 'true' || desktopCapable === 'true';
-}
-// Tool schemas
-const ScreenshotSchema = zod.z.object({});
-const ClickSchema = zod.z.object({
-    x: zod.z.number().describe('X coordinate to click'),
-    y: zod.z.number().describe('Y coordinate to click'),
-});
-const DoubleClickSchema = zod.z.object({
-    x: zod.z.number().describe('X coordinate to double-click'),
-    y: zod.z.number().describe('Y coordinate to double-click'),
-});
-const RightClickSchema = zod.z.object({
-    x: zod.z.number().describe('X coordinate to right-click'),
-    y: zod.z.number().describe('Y coordinate to right-click'),
-});
-const TypeSchema = zod.z.object({
-    text: zod.z.string().describe('Text to type'),
-});
-const KeySchema = zod.z.object({
-    key: zod.z
-        .string()
-        .describe('Key to press (e.g., "Enter", "Tab", "Escape", "Backspace", "Delete", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Home", "End", "PageUp", "PageDown", "F1"-"F12")'),
-});
-const KeyComboSchema = zod.z.object({
-    keys: zod.z
-        .array(zod.z.string())
-        .describe('Array of keys to press together (e.g., ["Control", "c"] for copy, ["Alt", "Tab"] for window switch)'),
-});
-const ScrollSchema = zod.z.object({
-    x: zod.z.number().describe('X coordinate to scroll at'),
-    y: zod.z.number().describe('Y coordinate to scroll at'),
-    deltaX: zod.z.number().optional().describe('Horizontal scroll amount (pixels)'),
-    deltaY: zod.z.number().describe('Vertical scroll amount (pixels, negative = up, positive = down)'),
-});
-const DragSchema = zod.z.object({
-    startX: zod.z.number().describe('Starting X coordinate'),
-    startY: zod.z.number().describe('Starting Y coordinate'),
-    endX: zod.z.number().describe('Ending X coordinate'),
-    endY: zod.z.number().describe('Ending Y coordinate'),
-});
-const GetActiveWindowSchema = zod.z.object({});
-const GetMousePositionSchema = zod.z.object({});
-const ClipboardReadSchema = zod.z.object({});
-const ClipboardWriteSchema = zod.z.object({
-    text: zod.z.string().describe('Text to write to clipboard'),
-});
-const ClipboardPasteSchema = zod.z.object({});
-const WaitSchema = zod.z.object({
-    ms: zod.z.number().describe('Milliseconds to wait'),
-});
-// ============ Native UI Automation Schemas (Windows) ============
-const UIFindElementSchema = zod.z.object({
-    name: zod.z.string().optional().describe('Element name/label to find (e.g., "Submit", "OK", "File")'),
-    automationId: zod.z.string().optional().describe('Automation ID of element (unique identifier)'),
-    controlType: zod.z.string().optional().describe('Type of control: Button, Edit, Text, ComboBox, List, Menu, MenuItem, Window, etc.'),
-});
-const UIClickElementSchema = zod.z.object({
-    name: zod.z.string().optional().describe('Element name/label to click'),
-    automationId: zod.z.string().optional().describe('Automation ID of element to click'),
-    controlType: zod.z.string().optional().describe('Type of control: Button, Edit, etc.'),
-    clickType: zod.z.enum(['left', 'right', 'double']).optional().describe('Click type (default: left)'),
-});
-const UIGetWindowTreeSchema = zod.z.object({
-    maxDepth: zod.z.number().optional().describe('Maximum depth to traverse (default: 3)'),
-});
-const UIFindButtonsSchema = zod.z.object({});
-const UIFindInputsSchema = zod.z.object({});
-/**
- * Format desktop action result for LLM consumption
- */
-function formatResultForLLM(result, action) {
-    if (!result.success && result.error) {
-        return `Desktop action "${action}" failed: ${result.error}`;
-    }
-    const parts = [];
-    if (result.screenshot) {
-        parts.push(`Screenshot captured (${result.screenshot.width}x${result.screenshot.height})`);
-        // The base64 image will be handled separately by the message formatter
-    }
-    if (result.activeWindow) {
-        parts.push(`**Active Window:**`);
-        parts.push(`  - Title: ${result.activeWindow.title}`);
-        parts.push(`  - App: ${result.activeWindow.app}`);
-        if (result.activeWindow.bounds) {
-            const b = result.activeWindow.bounds;
-            parts.push(`  - Position: (${b.x}, ${b.y})`);
-            parts.push(`  - Size: ${b.width}x${b.height}`);
-        }
-    }
-    if (result.mousePosition) {
-        parts.push(`**Mouse Position:** (${result.mousePosition.x}, ${result.mousePosition.y})`);
-    }
-    if (result.clipboard !== undefined) {
-        parts.push(`**Clipboard Content:** ${result.clipboard}`);
-    }
-    // UI Automation results
-    if (result.uiElement) {
-        const el = result.uiElement;
-        parts.push(`**UI Element Found:**`);
-        parts.push(`  - Name: "${el.name}"`);
-        parts.push(`  - AutomationId: "${el.automationId}"`);
-        parts.push(`  - Type: ${el.controlType}`);
-        if (el.boundingRectangle) {
-            const b = el.boundingRectangle;
-            parts.push(`  - Bounds: (${b.x}, ${b.y}) ${b.width}x${b.height}`);
-            parts.push(`  - Center: (${Math.round(b.x + b.width / 2)}, ${Math.round(b.y + b.height / 2)})`);
-        }
-        parts.push(`  - Enabled: ${el.isEnabled}`);
-    }
-    if (result.uiElements && result.uiElements.length > 0) {
-        parts.push(`**UI Elements Found (${result.uiElements.length}):**`);
-        for (const el of result.uiElements.slice(0, 20)) { // Limit to 20
-            const bounds = el.boundingRectangle ?
-                ` at (${el.boundingRectangle.x}, ${el.boundingRectangle.y})` : '';
-            parts.push(`  - [${el.controlType}] "${el.name}"${el.automationId ? ` (id: ${el.automationId})` : ''}${bounds}`);
-        }
-        if (result.uiElements.length > 20) {
-            parts.push(`  ... and ${result.uiElements.length - 20} more`);
-        }
-    }
-    if (result.uiTree) {
-        parts.push(`**UI Tree:**`);
-        parts.push('```json');
-        parts.push(JSON.stringify(result.uiTree, null, 2).slice(0, 3000)); // Limit size
-        parts.push('```');
-    }
-    if (result.data && !result.uiElement && !result.uiElements && !result.uiTree) {
-        // Generic data fallback
-        parts.push(`**Result:**`);
-        parts.push(JSON.stringify(result.data, null, 2).slice(0, 2000));
-    }
-    if (parts.length === 0) {
-        parts.push(`Desktop action "${action}" completed successfully.`);
-    }
-    return parts.join('\\n');
-}
-/**
- * Create desktop automation tools for the agent
- * These tools allow AI to control the user's desktop when Ranger Desktop is running
- */
-function createDesktopTools(options = {}) {
-    const { waitForResult } = options;
-    const tools$1 = [];
-    /**
-     * Helper to create tool function that optionally waits for results
-     * The toolCallId is extracted from the RunnableConfig passed by LangChain
-     */
-    const createToolFunction = (action) => {
-        return async (args, config) => {
-            const toolCallId = config?.toolCall?.id ??
-                `desktop_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-            // Create marker for Electron app
-            const marker = {
-                requiresDesktopExecution: true,
-                action,
-                args,
-                toolCallId,
-            };
-            // If no callback, return marker immediately (Electron handles via SSE interception)
-            if (!waitForResult) {
-                return JSON.stringify(marker);
-            }
-            // With callback: wait for actual results from Electron app
-            try {
-                const result = await waitForResult(action, args, toolCallId);
-                return formatResultForLLM(result, action);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                return `Desktop action "${action}" failed: ${errorMessage}`;
-            }
-        };
-    };
-    // computer_screenshot
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.SCREENSHOT), {
-        name: EDesktopTools.SCREENSHOT,
-        description: 'Take a screenshot of the entire screen. Use this to see what is currently displayed on the desktop.',
-        schema: ScreenshotSchema,
-    }));
-    // computer_click
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.CLICK), {
-        name: EDesktopTools.CLICK,
-        description: 'Click the mouse at the specified screen coordinates. Use screenshot first to identify the target location.',
-        schema: ClickSchema,
-    }));
-    // computer_double_click
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.DOUBLE_CLICK), {
-        name: EDesktopTools.DOUBLE_CLICK,
-        description: 'Double-click the mouse at the specified screen coordinates.',
-        schema: DoubleClickSchema,
-    }));
-    // computer_right_click
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.RIGHT_CLICK), {
-        name: EDesktopTools.RIGHT_CLICK,
-        description: 'Right-click the mouse at the specified screen coordinates to open context menus.',
-        schema: RightClickSchema,
-    }));
-    // computer_type
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.TYPE), {
-        name: EDesktopTools.TYPE,
-        description: 'Type text using the keyboard. Make sure the target input field is focused first (use click).',
-        schema: TypeSchema,
-    }));
-    // computer_key
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.KEY), {
-        name: EDesktopTools.KEY,
-        description: 'Press a single key on the keyboard (Enter, Tab, Escape, arrow keys, function keys, etc.).',
-        schema: KeySchema,
-    }));
-    // computer_key_combo
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.KEY_COMBO), {
-        name: EDesktopTools.KEY_COMBO,
-        description: 'Press a key combination (e.g., Ctrl+C to copy, Ctrl+V to paste, Alt+Tab to switch windows).',
-        schema: KeyComboSchema,
-    }));
-    // computer_scroll
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.SCROLL), {
-        name: EDesktopTools.SCROLL,
-        description: 'Scroll at the specified screen coordinates. Use negative deltaY to scroll up, positive to scroll down.',
-        schema: ScrollSchema,
-    }));
-    // computer_drag
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.DRAG), {
-        name: EDesktopTools.DRAG,
-        description: 'Drag the mouse from one position to another (for moving windows, selecting text, etc.).',
-        schema: DragSchema,
-    }));
-    // computer_get_active_window
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.GET_ACTIVE_WINDOW), {
-        name: EDesktopTools.GET_ACTIVE_WINDOW,
-        description: 'Get information about the currently active window (title, application name, position, size).',
-        schema: GetActiveWindowSchema,
-    }));
-    // computer_get_mouse_position
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.GET_MOUSE_POSITION), {
-        name: EDesktopTools.GET_MOUSE_POSITION,
-        description: 'Get the current mouse cursor position on screen.',
-        schema: GetMousePositionSchema,
-    }));
-    // clipboard_read
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.CLIPBOARD_READ), {
-        name: EDesktopTools.CLIPBOARD_READ,
-        description: 'Read the current contents of the system clipboard.',
-        schema: ClipboardReadSchema,
-    }));
-    // clipboard_write
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.CLIPBOARD_WRITE), {
-        name: EDesktopTools.CLIPBOARD_WRITE,
-        description: 'Write text to the system clipboard.',
-        schema: ClipboardWriteSchema,
-    }));
-    // clipboard_paste
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.CLIPBOARD_PASTE), {
-        name: EDesktopTools.CLIPBOARD_PASTE,
-        description: 'Paste the clipboard contents (equivalent to Ctrl+V). Use clipboard_write first to set the content.',
-        schema: ClipboardPasteSchema,
-    }));
-    // computer_wait
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.WAIT), {
-        name: EDesktopTools.WAIT,
-        description: 'Wait for the specified number of milliseconds. Use this to wait for UI animations or loading.',
-        schema: WaitSchema,
-    }));
-    // ============ Native UI Automation Tools (Windows) ============
-    // These are FASTER and MORE RELIABLE than screenshot-based automation
-    // They find elements by semantic properties (name, automationId, type)
-    // instead of relying on pixel coordinates from screenshots
-    // ui_find_element
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.UI_FIND_ELEMENT), {
-        name: EDesktopTools.UI_FIND_ELEMENT,
-        description: '🚀 PREFERRED: Find a UI element by semantic properties (name, automationId, controlType). MUCH FASTER than screenshot analysis. Returns element bounds for clicking. Windows only.',
-        schema: UIFindElementSchema,
-    }));
-    // ui_click_element
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.UI_CLICK_ELEMENT), {
-        name: EDesktopTools.UI_CLICK_ELEMENT,
-        description: '🚀 PREFERRED: Find and click a UI element by name/automationId. More reliable than coordinate-based clicking. Example: ui_click_element({name: "OK"}) or ui_click_element({controlType: "Button", name: "Submit"}). Windows only.',
-        schema: UIClickElementSchema,
-    }));
-    // ui_get_window_tree
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.UI_GET_WINDOW_TREE), {
-        name: EDesktopTools.UI_GET_WINDOW_TREE,
-        description: 'Get the UI element tree of the active window. Shows all buttons, inputs, menus, etc. with their names and automationIds. Use this to discover elements before clicking. Windows only.',
-        schema: UIGetWindowTreeSchema,
-    }));
-    // ui_find_buttons
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.UI_FIND_BUTTONS), {
-        name: EDesktopTools.UI_FIND_BUTTONS,
-        description: 'Find all clickable buttons in the active window. Returns list with names and positions. Useful for discovering available actions. Windows only.',
-        schema: UIFindButtonsSchema,
-    }));
-    // ui_find_inputs
-    tools$1.push(tools.tool(createToolFunction(EDesktopTools.UI_FIND_INPUTS), {
-        name: EDesktopTools.UI_FIND_INPUTS,
-        description: 'Find all text input fields in the active window. Returns list with names and positions. Useful for discovering form fields. Windows only.',
-        schema: UIFindInputsSchema,
-    }));
-    return tools$1;
-}
-/**
- * Get all desktop tool names
- */
-function getDesktopToolNames() {
-    return Object.values(EDesktopTools);
-}
-/**
- * Check if a tool name is a desktop tool
- */
-function isDesktopTool(name) {
-    return Object.values(EDesktopTools).includes(name);
-}
-
-exports.EDesktopTools = EDesktopTools;
-exports.createDesktopTools = createDesktopTools;
-exports.getDesktopToolNames = getDesktopToolNames;
-exports.hasDesktopCapability = hasDesktopCapability;
-exports.isDesktopTool = isDesktopTool;
-//# sourceMappingURL=DesktopTools.cjs.map