@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/backgroundChildThreads/add-running-agent.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Background Child Threads - Add Running Agent Tool
+ *
+ * Adds a running background agent to tracking.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddRunningAgentTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const backgroundChildThreads_1 = __importDefault(require("../../modules/backgroundChildThreads"));
+class AddRunningAgentInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            backgroundChildThreads_1.default.addRunningAgent(this.params.threadId, this.params.data, this.params.groupId);
+            const groupInfo = this.params.groupId ? ` to group ${this.params.groupId}` : '';
+            return {
+                llmContent: `Successfully added running agent ${this.params.threadId}${groupInfo}`,
+                returnDisplay: `Added running agent ${this.params.threadId}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for adding a running agent
+ */
+class AddRunningAgentTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('background_threads_add_running_agent', 'Add Running Agent', 'Adds a running background agent to tracking with optional group ID.', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                threadId: {
+                    type: 'string',
+                    description: 'The thread ID',
+                },
+                data: {
+                    type: 'object',
+                    description: 'The agent data',
+                },
+                groupId: {
+                    type: 'string',
+                    description: 'Optional group ID',
+                },
+            },
+            required: ['threadId', 'data'],
+        });
+    }
+    createInvocation(params) {
+        return new AddRunningAgentInvocation(params);
+    }
+}
+exports.AddRunningAgentTool = AddRunningAgentTool;

package/dist/tools/backgroundChildThreads/check-background-agent-completion.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Background Child Threads - Check Background Agent Completion Tool
+ *
+ * Checks if any background agent has completed.
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for checking completion (none required)
+ */
+export interface CheckBackgroundAgentCompletionParams {
+}
+/**
+ * Tool for checking background agent completion
+ */
+export declare class CheckBackgroundAgentCompletionTool extends BaseDeclarativeTool<CheckBackgroundAgentCompletionParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: CheckBackgroundAgentCompletionParams): ToolInvocation<CheckBackgroundAgentCompletionParams, ToolResult>;
+}

package/dist/tools/backgroundChildThreads/check-background-agent-completion.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Background Child Threads - Check Background Agent Completion Tool
+ *
+ * Checks if any background agent has completed.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckBackgroundAgentCompletionTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const backgroundChildThreads_1 = __importDefault(require("../../modules/backgroundChildThreads"));
+class CheckBackgroundAgentCompletionInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const completion = backgroundChildThreads_1.default.checkForBackgroundAgentCompletion();
+            if (completion) {
+                return {
+                    llmContent: `Background agent completion found: ${JSON.stringify(completion)}`,
+                    returnDisplay: 'Completion found',
+                };
+            }
+            else {
+                return {
+                    llmContent: 'No background agent completions available',
+                    returnDisplay: 'No completions',
+                };
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for checking background agent completion
+ */
+class CheckBackgroundAgentCompletionTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('background_threads_check_completion', 'Check Background Agent Completion', 'Checks if any background agent has completed. Returns completion data or null.', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+            required: [],
+        });
+    }
+    createInvocation(params) {
+        return new CheckBackgroundAgentCompletionInvocation(params);
+    }
+}
+exports.CheckBackgroundAgentCompletionTool = CheckBackgroundAgentCompletionTool;

package/dist/tools/backgroundChildThreads/get-running-agent-count.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Background Child Threads - Get Running Agent Count Tool
+ *
+ * Gets the count of currently running background agents.
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for getting running agent count (none required)
+ */
+export interface GetRunningAgentCountParams {
+}
+/**
+ * Tool for getting running agent count
+ */
+export declare class GetRunningAgentCountTool extends BaseDeclarativeTool<GetRunningAgentCountParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: GetRunningAgentCountParams): ToolInvocation<GetRunningAgentCountParams, ToolResult>;
+}

package/dist/tools/backgroundChildThreads/get-running-agent-count.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Background Child Threads - Get Running Agent Count Tool
+ *
+ * Gets the count of currently running background agents.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetRunningAgentCountTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const backgroundChildThreads_1 = __importDefault(require("../../modules/backgroundChildThreads"));
+class GetRunningAgentCountInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const count = backgroundChildThreads_1.default.getRunningAgentCount();
+            return {
+                llmContent: `Currently ${count} background agent(s) running`,
+                returnDisplay: `Count: ${count}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for getting running agent count
+ */
+class GetRunningAgentCountTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('background_threads_get_running_count', 'Get Running Agent Count', 'Gets the number of currently running background agents.', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+            required: [],
+        });
+    }
+    createInvocation(params) {
+        return new GetRunningAgentCountInvocation(params);
+    }
+}
+exports.GetRunningAgentCountTool = GetRunningAgentCountTool;

package/dist/tools/backgroundChildThreads/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Background Child Threads Tools
+ *
+ * Tools for tracking and managing background child agent threads.
+ */
+export { AddRunningAgentTool, type AddRunningAgentParams } from './add-running-agent';
+export { GetRunningAgentCountTool, type GetRunningAgentCountParams } from './get-running-agent-count';
+export { CheckBackgroundAgentCompletionTool, type CheckBackgroundAgentCompletionParams } from './check-background-agent-completion';
+export { OnBackgroundAgentCompletionTool, type OnBackgroundAgentCompletionParams } from './on-background-agent-completion';
+import { AddRunningAgentTool } from './add-running-agent';
+import { GetRunningAgentCountTool } from './get-running-agent-count';
+import { CheckBackgroundAgentCompletionTool } from './check-background-agent-completion';
+import { OnBackgroundAgentCompletionTool } from './on-background-agent-completion';
+/**
+ * Array of all background child threads tools
+ */
+export declare const backgroundChildThreadsTools: (AddRunningAgentTool | GetRunningAgentCountTool | CheckBackgroundAgentCompletionTool | OnBackgroundAgentCompletionTool)[];

package/dist/tools/backgroundChildThreads/index.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Background Child Threads Tools
+ *
+ * Tools for tracking and managing background child agent threads.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backgroundChildThreadsTools = exports.OnBackgroundAgentCompletionTool = exports.CheckBackgroundAgentCompletionTool = exports.GetRunningAgentCountTool = exports.AddRunningAgentTool = void 0;
+var add_running_agent_1 = require("./add-running-agent");
+Object.defineProperty(exports, "AddRunningAgentTool", { enumerable: true, get: function () { return add_running_agent_1.AddRunningAgentTool; } });
+var get_running_agent_count_1 = require("./get-running-agent-count");
+Object.defineProperty(exports, "GetRunningAgentCountTool", { enumerable: true, get: function () { return get_running_agent_count_1.GetRunningAgentCountTool; } });
+var check_background_agent_completion_1 = require("./check-background-agent-completion");
+Object.defineProperty(exports, "CheckBackgroundAgentCompletionTool", { enumerable: true, get: function () { return check_background_agent_completion_1.CheckBackgroundAgentCompletionTool; } });
+var on_background_agent_completion_1 = require("./on-background-agent-completion");
+Object.defineProperty(exports, "OnBackgroundAgentCompletionTool", { enumerable: true, get: function () { return on_background_agent_completion_1.OnBackgroundAgentCompletionTool; } });
+const add_running_agent_2 = require("./add-running-agent");
+const get_running_agent_count_2 = require("./get-running-agent-count");
+const check_background_agent_completion_2 = require("./check-background-agent-completion");
+const on_background_agent_completion_2 = require("./on-background-agent-completion");
+/**
+ * Array of all background child threads tools
+ */
+exports.backgroundChildThreadsTools = [
+    new add_running_agent_2.AddRunningAgentTool(),
+    new get_running_agent_count_2.GetRunningAgentCountTool(),
+    new check_background_agent_completion_2.CheckBackgroundAgentCompletionTool(),
+    new on_background_agent_completion_2.OnBackgroundAgentCompletionTool(),
+];

package/dist/tools/backgroundChildThreads/on-background-agent-completion.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Background Child Threads - On Background Agent Completion Tool
+ *
+ * Waits for background agent completion.
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for waiting for completion (none required)
+ */
+export interface OnBackgroundAgentCompletionParams {
+}
+/**
+ * Tool for waiting for background agent completion
+ */
+export declare class OnBackgroundAgentCompletionTool extends BaseDeclarativeTool<OnBackgroundAgentCompletionParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: OnBackgroundAgentCompletionParams): ToolInvocation<OnBackgroundAgentCompletionParams, ToolResult>;
+}

package/dist/tools/backgroundChildThreads/on-background-agent-completion.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Background Child Threads - On Background Agent Completion Tool
+ *
+ * Waits for background agent completion.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnBackgroundAgentCompletionTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const backgroundChildThreads_1 = __importDefault(require("../../modules/backgroundChildThreads"));
+class OnBackgroundAgentCompletionInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const completion = await backgroundChildThreads_1.default.onBackgroundAgentCompletion();
+            return {
+                llmContent: `Background agent completed: ${JSON.stringify(completion)}`,
+                returnDisplay: 'Completion received',
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for waiting for background agent completion
+ */
+class OnBackgroundAgentCompletionTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('background_threads_on_completion', 'Wait for Background Agent Completion', 'Waits for a background agent to complete. This is a blocking call.', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+            required: [],
+        });
+    }
+    createInvocation(params) {
+        return new OnBackgroundAgentCompletionInvocation(params);
+    }
+}
+exports.OnBackgroundAgentCompletionTool = OnBackgroundAgentCompletionTool;

package/dist/tools/base-tool.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Base classes for tool implementations in codeboltjs
+ */
+import type { ToolBuilder, ToolInvocation, ToolResult, ToolLocation, ToolCallConfirmationDetails, Kind, OpenAIToolSchema, OpenAIFunctionCall, FunctionDeclaration } from './types';
+export type { ToolInvocation, ToolResult, ToolLocation, ToolCallConfirmationDetails, } from './types';
+export { Kind } from './types';
+/**
+ * A convenience base class for ToolInvocation
+ */
+export declare abstract class BaseToolInvocation<TParams extends object, TResult extends ToolResult> implements ToolInvocation<TParams, TResult> {
+    readonly params: TParams;
+    constructor(params: TParams);
+    toolLocations(): ToolLocation[];
+    shouldConfirmExecute(_abortSignal: AbortSignal): Promise<ToolCallConfirmationDetails | false>;
+    abstract execute(signal: AbortSignal, updateOutput?: (output: string) => void): Promise<TResult>;
+}
+/**
+ * Base class for tools that separates validation from execution
+ */
+export declare abstract class DeclarativeTool<TParams extends object, TResult extends ToolResult> implements ToolBuilder<TParams, TResult> {
+    readonly name: string;
+    readonly displayName: string;
+    readonly description: string;
+    readonly kind: Kind;
+    readonly parameterSchema: unknown;
+    readonly isOutputMarkdown: boolean;
+    readonly canUpdateOutput: boolean;
+    constructor(name: string, displayName: string, description: string, kind: Kind, parameterSchema: unknown, isOutputMarkdown?: boolean, canUpdateOutput?: boolean);
+    /**
+     * One sentence explanation as to why this tool is being used, and how it contributes to the goal.
+     * Defaults to description if not implemented by subclass.
+     */
+    get explanation(): string;
+    /**
+     * Primary schema format (OpenAI tool schema)
+     */
+    get schema(): OpenAIToolSchema;
+    /**
+     * Get OpenAI function call format
+     */
+    get openAIFunctionCall(): OpenAIFunctionCall;
+    /**
+     * Get Google GenAI schema format (for backward compatibility)
+     */
+    get genAISchema(): FunctionDeclaration;
+    /**
+     * Validates the raw tool parameters.
+     * Subclasses should override this to add custom validation logic
+     * beyond the JSON schema check.
+     */
+    validateToolParams(_params: TParams): string | null;
+    /**
+     * The core of the pattern. It validates parameters and, if successful,
+     * returns a `ToolInvocation` object that encapsulates the logic for the
+     * specific, validated call.
+     */
+    abstract build(params: TParams): ToolInvocation<TParams, TResult>;
+    /**
+     * A convenience method that builds and executes the tool in one step.
+     */
+    buildAndExecute(params: TParams, signal: AbortSignal, updateOutput?: (output: string) => void): Promise<TResult>;
+    /**
+     * Similar to `build` but never throws.
+     */
+    private silentBuild;
+    /**
+     * A convenience method that builds and executes the tool in one step.
+     * Never throws.
+     */
+    validateBuildAndExecute(params: TParams, abortSignal: AbortSignal): Promise<ToolResult>;
+}
+/**
+ * Base class for declarative tools with built-in validation
+ */
+export declare abstract class BaseDeclarativeTool<TParams extends object, TResult extends ToolResult> extends DeclarativeTool<TParams, TResult> {
+    build(params: TParams): ToolInvocation<TParams, TResult>;
+    validateToolParams(params: TParams): string | null;
+    protected validateToolParamValues(_params: TParams): string | null;
+    protected abstract createInvocation(params: TParams): ToolInvocation<TParams, TResult>;
+}

package/dist/tools/base-tool.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Base classes for tool implementations in codeboltjs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDeclarativeTool = exports.DeclarativeTool = exports.BaseToolInvocation = exports.Kind = void 0;
+const types_1 = require("./types");
+const schema_validator_1 = require("./utils/schema-validator");
+// Re-export Kind as both type and value
+var types_2 = require("./types");
+Object.defineProperty(exports, "Kind", { enumerable: true, get: function () { return types_2.Kind; } });
+/**
+ * A convenience base class for ToolInvocation
+ */
+class BaseToolInvocation {
+    constructor(params) {
+        this.params = params;
+    }
+    toolLocations() {
+        return [];
+    }
+    shouldConfirmExecute(_abortSignal) {
+        return Promise.resolve(false);
+    }
+}
+exports.BaseToolInvocation = BaseToolInvocation;
+/**
+ * Base class for tools that separates validation from execution
+ */
+class DeclarativeTool {
+    constructor(name, displayName, description, kind, parameterSchema, isOutputMarkdown = true, canUpdateOutput = false) {
+        this.name = name;
+        this.displayName = displayName;
+        this.description = description;
+        this.kind = kind;
+        this.parameterSchema = parameterSchema;
+        this.isOutputMarkdown = isOutputMarkdown;
+        this.canUpdateOutput = canUpdateOutput;
+    }
+    /**
+     * One sentence explanation as to why this tool is being used, and how it contributes to the goal.
+     * Defaults to description if not implemented by subclass.
+     */
+    get explanation() {
+        return this.description;
+    }
+    /**
+     * Primary schema format (OpenAI tool schema)
+     */
+    get schema() {
+        var _a, _b;
+        return {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: this.description,
+                parameters: {
+                    type: 'object',
+                    properties: ((_a = this.parameterSchema) === null || _a === void 0 ? void 0 : _a.properties) || {},
+                    required: ((_b = this.parameterSchema) === null || _b === void 0 ? void 0 : _b.required) || [],
+                    additionalProperties: false,
+                },
+            },
+        };
+    }
+    /**
+     * Get OpenAI function call format
+     */
+    get openAIFunctionCall() {
+        var _a, _b;
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: {
+                type: 'object',
+                properties: ((_a = this.parameterSchema) === null || _a === void 0 ? void 0 : _a.properties) || {},
+                required: ((_b = this.parameterSchema) === null || _b === void 0 ? void 0 : _b.required) || [],
+                additionalProperties: false,
+            },
+        };
+    }
+    /**
+     * Get Google GenAI schema format (for backward compatibility)
+     */
+    get genAISchema() {
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: this.parameterSchema,
+        };
+    }
+    /**
+     * Validates the raw tool parameters.
+     * Subclasses should override this to add custom validation logic
+     * beyond the JSON schema check.
+     */
+    validateToolParams(_params) {
+        return null;
+    }
+    /**
+     * A convenience method that builds and executes the tool in one step.
+     */
+    async buildAndExecute(params, signal, updateOutput) {
+        const invocation = this.build(params);
+        return invocation.execute(signal, updateOutput);
+    }
+    /**
+     * Similar to `build` but never throws.
+     */
+    silentBuild(params) {
+        try {
+            return this.build(params);
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                return e;
+            }
+            return new Error(String(e));
+        }
+    }
+    /**
+     * A convenience method that builds and executes the tool in one step.
+     * Never throws.
+     */
+    async validateBuildAndExecute(params, abortSignal) {
+        const invocationOrError = this.silentBuild(params);
+        if (invocationOrError instanceof Error) {
+            const errorMessage = invocationOrError.message;
+            return {
+                llmContent: `Error: Invalid parameters provided. Reason: ${errorMessage}`,
+                returnDisplay: errorMessage,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.INVALID_TOOL_PARAMS,
+                },
+            };
+        }
+        try {
+            return await invocationOrError.execute(abortSignal);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                llmContent: `Error: Tool call execution failed. Reason: ${errorMessage}`,
+                returnDisplay: errorMessage,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+exports.DeclarativeTool = DeclarativeTool;
+/**
+ * Base class for declarative tools with built-in validation
+ */
+class BaseDeclarativeTool extends DeclarativeTool {
+    build(params) {
+        const validationError = this.validateToolParams(params);
+        if (validationError) {
+            throw new Error(validationError);
+        }
+        return this.createInvocation(params);
+    }
+    validateToolParams(params) {
+        const errors = schema_validator_1.SchemaValidator.validate(this.schema.function.parameters, params);
+        if (errors) {
+            return errors;
+        }
+        return this.validateToolParamValues(params);
+    }
+    validateToolParamValues(_params) {
+        return null;
+    }
+}
+exports.BaseDeclarativeTool = BaseDeclarativeTool;

package/dist/tools/browser/browser-action.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Browser Action Tool - Performs browser automation actions
+ * Wraps the SDK's cbbrowser methods
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Supported browser actions
+ */
+export type BrowserActionType = 'navigate' | 'screenshot' | 'click' | 'type' | 'scroll' | 'get_content' | 'get_html' | 'get_markdown' | 'get_url' | 'close' | 'enter' | 'search';
+/**
+ * Parameters for the BrowserAction tool
+ */
+export interface BrowserActionToolParams {
+    /**
+     * The browser action to perform
+     */
+    action: BrowserActionType;
+    /**
+     * URL for navigate action
+     */
+    url?: string;
+    /**
+     * Element ID for click/type/search actions
+     */
+    element_id?: string;
+    /**
+     * Text for type action
+     */
+    text?: string;
+    /**
+     * Query for search action
+     */
+    query?: string;
+    /**
+     * Scroll direction ('up', 'down', 'left', 'right')
+     */
+    direction?: string;
+    /**
+     * Pixels to scroll
+     */
+    pixels?: string;
+    /**
+     * Browser instance ID (optional)
+     */
+    instance_id?: string;
+}
+/**
+ * Implementation of the BrowserAction tool logic
+ */
+export declare class BrowserActionTool extends BaseDeclarativeTool<BrowserActionToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: BrowserActionToolParams): string | null;
+    protected createInvocation(params: BrowserActionToolParams): ToolInvocation<BrowserActionToolParams, ToolResult>;
+}