askui 0.24.1 → 0.25.0

package/dist/cjs/core/models/anthropic/askui-agent.d.ts

@@ -0,0 +1,13 @@
+import { ClaudeAgent } from './claude-agent';
+import { ExecutionRuntime } from '../../../execution/execution-runtime';
+export declare class AskUIAgent extends ClaudeAgent {
+    private osAgentHandler;
+    private executionRuntime;
+    constructor(executionRuntime: ExecutionRuntime);
+    isConnected(): boolean;
+    initializeOsAgentHandler(): Promise<void>;
+    configureAsDesktopAgent(): Promise<void>;
+    configureAsAndroidAgent(): Promise<void>;
+    private static DesktopSystemPrompt;
+    private static AndroidSystemPrompt;
+}

package/dist/cjs/core/models/anthropic/askui-agent.js

@@ -0,0 +1,195 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AskUIAgent = void 0;
+const os_agent_tools_1 = require("./tools/os-agent-tools");
+const claude_agent_1 = require("./claude-agent");
+class AskUIAgent extends claude_agent_1.ClaudeAgent {
+    constructor(executionRuntime) {
+        super((params) => executionRuntime.predictActResponse(params));
+        this.osAgentHandler = undefined;
+        this.executionRuntime = executionRuntime;
+    }
+    isConnected() {
+        return this.osAgentHandler !== undefined;
+    }
+    initializeOsAgentHandler() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.osAgentHandler = yield os_agent_tools_1.OsAgentHandler.createInstance(this.executionRuntime);
+        });
+    }
+    configureAsDesktopAgent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.osAgentHandler) {
+                throw new Error('Agent OS client is not connected');
+            }
+            const tools = [
+                new os_agent_tools_1.AgentErrorTool(),
+                new os_agent_tools_1.ScreenShotTool(this.osAgentHandler),
+                new os_agent_tools_1.MouseMoveTool(this.osAgentHandler),
+                new os_agent_tools_1.MouseClickTool(this.osAgentHandler),
+                new os_agent_tools_1.MouseScrollTool(this.osAgentHandler),
+                new os_agent_tools_1.DesktopKeyPressSequenceTool(this.osAgentHandler),
+                new os_agent_tools_1.DesktopSingleKeyPressTool(this.osAgentHandler),
+                new os_agent_tools_1.TypeTool(this.osAgentHandler),
+            ];
+            this.setTools(tools);
+            this.setSystemPrompt(AskUIAgent.DesktopSystemPrompt);
+        });
+    }
+    configureAsAndroidAgent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.osAgentHandler) {
+                throw new Error('Agent OS client is not connected');
+            }
+            const tools = [
+                new os_agent_tools_1.AgentErrorTool(),
+                new os_agent_tools_1.ScreenShotTool(this.osAgentHandler),
+                new os_agent_tools_1.MouseMoveTool(this.osAgentHandler),
+                new os_agent_tools_1.MouseClickTool(this.osAgentHandler),
+                new os_agent_tools_1.MouseScrollTool(this.osAgentHandler),
+                new os_agent_tools_1.AndroidSingleKeyPressTool(this.osAgentHandler),
+                new os_agent_tools_1.AndroidSequenceKeyPressTool(this.osAgentHandler),
+                new os_agent_tools_1.TypeTool(this.osAgentHandler),
+                new os_agent_tools_1.ExecuteShellCommandTool(this.osAgentHandler),
+            ];
+            this.setTools(tools);
+            this.setSystemPrompt(AskUIAgent.AndroidSystemPrompt);
+        });
+    }
+}
+exports.AskUIAgent = AskUIAgent;
+AskUIAgent.DesktopSystemPrompt = `
+<SYSTEM_CAPABILITY>
+You are an autonomous AI assistant operating on a ${process.platform} machine with ${process.arch} architecture. You have full access to the system and internet connectivity.
+Your main goal is to mimic a human user interacting with a desktop computer. So you should try to use the tools in a way that a human would use a mouse and keyboard to interact with a computer.
+
+Key Capabilities:
+* Full system control through mouse and keyboard interactions
+* Screen capture and analysis
+* Web browser automation and navigation
+* File system access and manipulation
+* PDF document handling and text extraction
+* Error handling and recovery mechanisms
+
+Available Tools:
+* Mouse control (move, click, scroll)
+* Keyboard input (single keys, key combinations, typing)
+* Screen capture and analysis
+* Error reporting and recovery
+
+Current Date: ${new Date().toUTCString()} UTC
+</SYSTEM_CAPABILITY>
+
+<OPERATIONAL_GUIDELINES>
+1. Autonomous Operation:
+   * Work independently to achieve user goals
+   * Make informed decisions based on available information
+   * Chain multiple actions efficiently when possible
+   * Verify results after each significant action
+
+2. Web Interaction:
+   * Launch appropriate browser if not already open
+   * Ensure full page visibility through zoom or scrolling
+   * Handle browser-specific behaviors (e.g., Firefox startup wizard)
+   * Extract and process PDF content when encountered
+
+3. Error Handling:
+   * Detect and analyze failure points
+   * Implement appropriate recovery strategies
+   * Report issues with clear diagnostic information
+   * Use the error tool when stuck or unable to proceed
+
+4. Performance Optimization:
+   * Batch related actions when possible
+   * Minimize unnecessary screen captures
+   * Use efficient navigation patterns
+   * Maintain context between actions
+
+5. Safety and Validation:
+   * Verify coordinates are within screen bounds
+   * Validate input parameters before execution
+   * Ensure proper cleanup after operations
+   * Maintain system stability
+</OPERATIONAL_GUIDELINES>
+
+<IMPORTANT_NOTES>
+* When you are stuck or unable to proceed, use the error tool to raise an error.
+* Always verify tool availability before use
+* Use screenshots strategically for state analysis
+* Report issues promptly with clear diagnostic information
+* Maintain awareness of screen boundaries and coordinate validity
+* Adapt to unexpected situations with appropriate fallback strategies
+</IMPORTANT_NOTES>
+`;
+AskUIAgent.AndroidSystemPrompt = `
+<SYSTEM_CAPABILITY>
+You are an autonomous AI assistant operating on an Android device via ADB. The host machine is ${process.platform} with ${process.arch} architecture and internet connectivity.
+Your main goal is to mimic a human user interacting with an Android device. So you should try to use the tools in a way that a human would use a touch screen to interact with an Android device.
+
+Key Capabilities:
+* Full Android device control through ADB
+* Screen capture and analysis
+* Touch input simulation
+* Android-specific key events
+* Error handling and recovery mechanisms
+
+Available Tools:
+* Touch control (click, swipe, scroll)
+* Android key events (single and sequence)
+* Screen capture and analysis
+* Error reporting and recovery
+
+Current Date: ${new Date().toUTCString()} UTC
+</SYSTEM_CAPABILITY>
+
+<OPERATIONAL_GUIDELINES>
+1. Autonomous Operation:
+   * Work independently to achieve user goals
+   * Make informed decisions based on available information
+   * Chain multiple actions efficiently when possible
+   * Verify results after each significant action
+
+2. Screen Interaction:
+   * Analyze screen state before interactions
+   * Use appropriate input methods (touch, keys)
+   * Handle dynamic UI elements effectively
+   * Implement efficient navigation patterns
+
+3. Error Handling:
+   * Detect and analyze failure points
+   * Implement appropriate recovery strategies
+   * Report issues with clear diagnostic information
+   * Use the error tool when stuck or unable to proceed
+
+4. Performance Optimization:
+   * Batch related actions when possible
+   * Minimize unnecessary screen captures
+   * Use efficient navigation patterns
+   * Maintain context between actions
+
+5. Safety and Validation:
+   * Verify coordinates are within screen bounds
+   * Validate input parameters before execution
+   * Ensure proper cleanup after operations
+   * Maintain device stability
+</OPERATIONAL_GUIDELINES>
+
+<IMPORTANT_NOTES>
+* When you are stuck or unable to proceed, use the error tool to raise an error.
+* Always verify tool availability before use
+* Use screenshots strategically for state analysis
+* Ensure all coordinates are integers and within screen bounds
+* Handle permission issues and device state appropriately
+* Report issues promptly with clear diagnostic information
+* Adapt to unexpected situations with appropriate fallback strategies
+</IMPORTANT_NOTES>
+`;

package/dist/cjs/core/models/anthropic/claude-agent.d.ts

@@ -0,0 +1,40 @@
+import { Beta } from '@anthropic-ai/sdk/resources';
+import { BaseAgentTool } from './tools/base';
+type PredictActResponseFunction = (params: {
+    max_tokens: number;
+    messages: Beta.BetaMessageParam[];
+    model: string;
+    system?: string;
+    tools?: any[];
+    betas?: string[];
+}) => Promise<Beta.BetaMessage>;
+export declare class ClaudeAgent {
+    private predictActResponseFunction;
+    private maxTokens;
+    private onlyNMostRecentImages;
+    private imageTruncationThreshold;
+    private systemPrompt;
+    private model;
+    private betas;
+    private _toolCollection;
+    private tools;
+    private history;
+    constructor(predictActResponseFunction: PredictActResponseFunction);
+    setTools(tools: BaseAgentTool[]): void;
+    addTool(tool: BaseAgentTool): void;
+    listToolNames(): string[];
+    removeToolByName(toolName: string): void;
+    setSystemPrompt(systemPrompt: string): void;
+    private IsConfigured;
+    private get toolCollection();
+    private setHistory;
+    private getHistory;
+    act(goal: string, options?: {
+        chatId?: string;
+        agentHistory?: Beta.BetaMessageParam[];
+    }): Promise<Beta.BetaMessageParam[]>;
+    private makeApiToolResult;
+    private maybePrependSystemToolResult;
+    private static filterNMostRecentImages;
+}
+export {};

package/dist/cjs/core/models/anthropic/claude-agent.js

@@ -0,0 +1,200 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeAgent = void 0;
+const base_1 = require("./tools/base");
+const logger_1 = require("../../../lib/logger");
+class ClaudeAgent {
+    constructor(predictActResponseFunction) {
+        this.predictActResponseFunction = predictActResponseFunction;
+        this.maxTokens = 4096;
+        this.onlyNMostRecentImages = 3;
+        this.imageTruncationThreshold = 10;
+        this.systemPrompt = '';
+        this.model = 'claude-3-5-sonnet-20241022';
+        this.betas = ['computer-use-2024-10-22'];
+        this._toolCollection = undefined;
+        this.tools = [];
+        this.history = {};
+    }
+    setTools(tools) {
+        this._toolCollection = undefined;
+        this.tools = tools;
+    }
+    addTool(tool) {
+        this._toolCollection = undefined;
+        this.tools.push(tool);
+    }
+    listToolNames() {
+        return this.tools.map((tool) => tool.ToolName);
+    }
+    removeToolByName(toolName) {
+        this.tools = this.tools.filter((tool) => tool.ToolName !== toolName);
+    }
+    setSystemPrompt(systemPrompt) {
+        this.systemPrompt = systemPrompt;
+    }
+    IsConfigured() {
+        return this.tools.length > 0 && this.systemPrompt !== '';
+    }
+    get toolCollection() {
+        if (!this._toolCollection) {
+            this._toolCollection = new base_1.ToolCollection(this.tools);
+        }
+        return this._toolCollection;
+    }
+    setHistory(key, messages) {
+        this.history[key] = messages;
+    }
+    getHistory(key) {
+        return this.history[key] || [];
+    }
+    act(goal, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!goal.trim()) {
+                throw new Error('Goal cannot be empty');
+            }
+            if (!this.IsConfigured()) {
+                throw new Error('Claude agent is not configured. Please configure the agent first.');
+            }
+            const messages = [];
+            if (options === null || options === void 0 ? void 0 : options.agentHistory) {
+                messages.push(...options.agentHistory);
+            }
+            if (options === null || options === void 0 ? void 0 : options.chatId) {
+                messages.push(...this.getHistory(options.chatId));
+            }
+            // Add the new goal as a user message
+            messages.push({
+                content: goal,
+                role: 'user',
+            });
+            if (this.onlyNMostRecentImages) {
+                ClaudeAgent.filterNMostRecentImages(messages, this.onlyNMostRecentImages, this.imageTruncationThreshold);
+            }
+            while (true) {
+                const response = yield this.predictActResponseFunction({
+                    max_tokens: this.maxTokens,
+                    messages,
+                    model: this.model,
+                    system: this.systemPrompt,
+                    tools: (new base_1.ToolCollection(this.tools).toParams()),
+                    betas: this.betas,
+                });
+                messages.push({
+                    content: response.content,
+                    role: 'assistant',
+                });
+                const toolResultContent = [];
+                for (const block of response.content) {
+                    if (block.type === 'tool_use') {
+                        logger_1.logger.debug(`Agent will execute tool '${block.name}' with input '${JSON.stringify(block.input)}'`);
+                        const toolUseBlock = block;
+                        const result = yield this.toolCollection.run(toolUseBlock.name, toolUseBlock.input);
+                        const toolResult = this.makeApiToolResult(result, toolUseBlock.id);
+                        toolResultContent.push(toolResult);
+                    }
+                    if (block.type === 'thinking') {
+                        logger_1.logger.debug(`Agent is thinking: ${block.thinking}`);
+                    }
+                    if (block.type === 'text') {
+                        logger_1.logger.info(`Agent: ${block.text}`);
+                    }
+                }
+                if (toolResultContent.length === 0) {
+                    if (options === null || options === void 0 ? void 0 : options.chatId) {
+                        this.setHistory(options.chatId, messages);
+                    }
+                    return messages;
+                }
+                messages.push({
+                    role: 'user',
+                    content: toolResultContent,
+                });
+            }
+        });
+    }
+    makeApiToolResult(result, toolUseId) {
+        const content = [];
+        let isError = false;
+        if (result.error) {
+            isError = true;
+            content.push({
+                type: 'text',
+                text: this.maybePrependSystemToolResult(result, result.error),
+            });
+        }
+        else {
+            if (result.output) {
+                content.push({
+                    type: 'text',
+                    text: this.maybePrependSystemToolResult(result, result.output),
+                });
+            }
+            if (result.base64Images) {
+                for (const base64Image of result.base64Images) {
+                    content.push({
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: 'image/png',
+                            data: base64Image,
+                        },
+                    });
+                }
+            }
+        }
+        return {
+            type: 'tool_result',
+            tool_use_id: toolUseId,
+            content,
+            is_error: isError,
+        };
+    }
+    maybePrependSystemToolResult(result, text) {
+        if (result.system) {
+            return `<system>${result.system}</system>\n${text}`;
+        }
+        return text;
+    }
+    static filterNMostRecentImages(messages, imagesToKeep, minRemovalThreshold = 10) {
+        const toolResultBlocks = messages
+            .flatMap((message) => (Array.isArray(message.content) ? message.content : []))
+            .filter((item) => typeof item === 'object'
+            && 'type' in item
+            && item.type === 'tool_result');
+        const totalImages = toolResultBlocks.reduce((count, result) => {
+            const content = Array.isArray(result.content) ? result.content : [];
+            return count + content.filter((item) => typeof item === 'object'
+                && 'type' in item
+                && item.type === 'image').length;
+        }, 0);
+        let imagesToRemove = totalImages - imagesToKeep;
+        imagesToRemove -= imagesToRemove % minRemovalThreshold;
+        if (imagesToRemove <= 0)
+            return;
+        for (const result of toolResultBlocks) {
+            if (Array.isArray(result.content)) {
+                const newContent = result.content.filter((item) => {
+                    if ('type' in item && item.type === 'image') {
+                        if (imagesToRemove > 0) {
+                            imagesToRemove -= 1;
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                result.content = newContent;
+            }
+        }
+    }
+}
+exports.ClaudeAgent = ClaudeAgent;

package/dist/cjs/core/models/anthropic/index.d.ts

@@ -0,0 +1,4 @@
+import { BetaMessageParam } from '@anthropic-ai/sdk/resources/beta/messages';
+export type AgentHistory = BetaMessageParam[];
+export { AskUIAgent } from './askui-agent';
+export { ToolFailure, ToolError, BaseAgentTool } from './tools/base';

package/dist/cjs/core/models/anthropic/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAgentTool = exports.ToolError = exports.ToolFailure = exports.AskUIAgent = void 0;
+var askui_agent_1 = require("./askui-agent");
+Object.defineProperty(exports, "AskUIAgent", { enumerable: true, get: function () { return askui_agent_1.AskUIAgent; } });
+var base_1 = require("./tools/base");
+Object.defineProperty(exports, "ToolFailure", { enumerable: true, get: function () { return base_1.ToolFailure; } });
+Object.defineProperty(exports, "ToolError", { enumerable: true, get: function () { return base_1.ToolError; } });
+Object.defineProperty(exports, "BaseAgentTool", { enumerable: true, get: function () { return base_1.BaseAgentTool; } });

package/dist/cjs/core/models/anthropic/tools/agent-errors.d.ts

@@ -0,0 +1,2 @@
+export declare class AgentError extends Error {
+}

package/dist/cjs/core/models/anthropic/tools/agent-errors.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentError = void 0;
+class AgentError extends Error {
+}
+exports.AgentError = AgentError;

package/dist/cjs/core/models/anthropic/tools/base.d.ts

@@ -0,0 +1,24 @@
+export interface ToolResult {
+    output?: string;
+    error?: string;
+    base64Images?: string[];
+    system?: string;
+}
+export declare class ToolFailure implements ToolResult {
+    error: string;
+    constructor(error: string);
+}
+export declare class ToolError extends Error {
+    constructor(message: string);
+}
+export declare abstract class BaseAgentTool {
+    abstract execute(params: Record<string, any>): Promise<ToolResult>;
+    abstract toParams(): any;
+    get ToolName(): string;
+}
+export declare class ToolCollection {
+    private toolMap;
+    constructor(tools: BaseAgentTool[]);
+    toParams(): any[];
+    run(name: string, toolInput: Record<string, any>): Promise<ToolResult>;
+}

package/dist/cjs/core/models/anthropic/tools/base.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCollection = exports.BaseAgentTool = exports.ToolError = exports.ToolFailure = void 0;
+/* eslint-disable */
+const agent_errors_1 = require("./agent-errors");
+class ToolFailure {
+    constructor(error) {
+        this.error = error;
+    }
+}
+exports.ToolFailure = ToolFailure;
+class ToolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ToolError';
+    }
+}
+exports.ToolError = ToolError;
+class BaseAgentTool {
+    get ToolName() {
+        return this.constructor.name;
+    }
+}
+exports.BaseAgentTool = BaseAgentTool;
+class ToolCollection {
+    constructor(tools) {
+        this.toolMap = new Map();
+        tools.forEach((tool) => {
+            const params = tool.toParams();
+            this.toolMap.set(params.name, tool);
+        });
+    }
+    toParams() {
+        return Array.from(this.toolMap.values()).map((tool) => tool.toParams());
+    }
+    run(name, toolInput) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tool = this.toolMap.get(name);
+            if (!tool) {
+                return new ToolFailure(`Tool ${name} is invalid`);
+            }
+            try {
+                return yield tool.execute(toolInput);
+            }
+            catch (err) {
+                if (err instanceof agent_errors_1.AgentError) {
+                    throw err;
+                }
+                if (err instanceof ToolError) {
+                    return new ToolFailure(err.message);
+                }
+                return new ToolFailure(`Unknown error: ${err}`);
+            }
+        });
+    }
+}
+exports.ToolCollection = ToolCollection;

package/dist/cjs/core/models/anthropic/tools/os-agent-tools.d.ts

@@ -0,0 +1,113 @@
+import { BetaTool } from '@anthropic-ai/sdk/resources/beta/messages/messages';
+import { MODIFIER_KEY, PC_KEY, ANDROID_KEY, PC_AND_MODIFIER_KEY } from '../../../../execution/dsl';
+import { BaseAgentTool, ToolResult } from './base';
+import { ExecutionRuntime } from '../../../../execution/execution-runtime';
+import { ControlCommand } from '../../../ui-control-commands';
+export declare class OsAgentHandler {
+    private AgentOsClient;
+    private TargetResolution;
+    private screenDimensions;
+    constructor(AgentOsClient: ExecutionRuntime, screenDimensions: {
+        width: number;
+        height: number;
+    });
+    static createInstance(AgentOsClient: ExecutionRuntime): Promise<OsAgentHandler>;
+    getTargetResolution(): {
+        width: number;
+        height: number;
+    };
+    setTargetResolution(width: number, height: number): void;
+    takeScreenshot(): Promise<string>;
+    private scaleCoordinates;
+    requestControl(controlCommand: ControlCommand): Promise<void>;
+}
+export declare class ScreenShotTool extends BaseAgentTool {
+    private osAgentHandler;
+    constructor(osAgentHandler: OsAgentHandler);
+    execute(): Promise<ToolResult>;
+    toParams(): BetaTool;
+}
+export declare class MouseMoveTool extends BaseAgentTool {
+    private osAgentHandler;
+    constructor(osAgentHandler: OsAgentHandler);
+    execute(command: {
+        x: number;
+        y: number;
+    }): Promise<ToolResult>;
+    toParams(): BetaTool;
+}
+export declare class MouseClickTool extends BaseAgentTool {
+    private osAgentHandler;
+    constructor(osAgentHandler: OsAgentHandler);
+    execute(command: {
+        button: 'left' | 'right' | 'middle';
+        doubleClick: boolean;
+    }): Promise<ToolResult>;
+    toParams(): BetaTool;
+}
+export declare class MouseScrollTool extends BaseAgentTool {
+    private osAgentHandler;
+    constructor(osAgentHandler: OsAgentHandler);
+    execute(command: {
+        dx: number;
+        dy: number;
+    }): Promise<ToolResult>;
+    toParams(): BetaTool;
+}
+export declare class DesktopKeyPressSequenceTool extends BaseAgentTool {
+    private osAgentHandler;
+    constructor(osAgentHandler: OsAgentHandler);
+    execute(command: {
+        key: PC_KEY;
+        firstModifier?: MODIFIER_KEY;
+        secondModifier?: MODIFIER_KEY;
+    }): Promise<ToolResult>;
+    toParams(): BetaTool;
+}
+export declare class DesktopSingleKeyPressTool extends BaseAgentTool {
+    private osAgentHandler;
+    constructor(osAgentHandler: OsAgentHandler);
+    execute(command: {
+        key: PC_AND_MODIFIER_KEY;
+    }): Promise<ToolResult>;
+    toParams(): BetaTool;
+}
+export declare class TypeTool extends BaseAgentTool {
+    private osAgentHandler;
+    constructor(osAgentHandler: OsAgentHandler);
+    execute(command: {
+        text: string;
+    }): Promise<ToolResult>;
+    toParams(): BetaTool;
+}
+export declare class AndroidSingleKeyPressTool extends BaseAgentTool {
+    private osAgentHandler;
+    constructor(osAgentHandler: OsAgentHandler);
+    execute(command: {
+        key: ANDROID_KEY;
+    }): Promise<ToolResult>;
+    toParams(): BetaTool;
+}
+export declare class AndroidSequenceKeyPressTool extends BaseAgentTool {
+    private osAgentHandler;
+    constructor(osAgentHandler: OsAgentHandler);
+    execute(command: {
+        keys: ANDROID_KEY[];
+    }): Promise<ToolResult>;
+    toParams(): BetaTool;
+}
+export declare class AgentErrorTool extends BaseAgentTool {
+    constructor();
+    execute(command: {
+        error: string;
+    }): Promise<ToolResult>;
+    toParams(): BetaTool;
+}
+export declare class ExecuteShellCommandTool extends BaseAgentTool {
+    private osAgentHandler;
+    constructor(osAgentHandler: OsAgentHandler);
+    execute(command: {
+        command: string;
+    }): Promise<ToolResult>;
+    toParams(): BetaTool;
+}