@google/adk 2.3.0 → 2.5.0

package/dist/types/tools/application_integration_tool/integration_connector_tool.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { AuthCredential } from '../../auth/auth_credential.js';
+import { AuthScheme } from '../../auth/auth_schemes.js';
+import { BaseTool, BaseToolParams, RunAsyncToolRequest } from '../base_tool.js';
+import { RestApiTool } from '../openapi_tool/rest_api_tool.js';
+/** Options for {@link IntegrationConnectorTool}. */
+export interface IntegrationConnectorToolOptions extends BaseToolParams {
+    /** The Integration Connectors connection resource name. */
+    connectionName: string;
+    /** The host of the connection, or `''` when it has none. */
+    connectionHost: string;
+    /** The Service Directory name of the connection. */
+    connectionServiceName: string;
+    /** The Integration Connectors entity targeted by the tool, if any. */
+    entity?: string;
+    /** The connector operation executed by the tool, if any. */
+    operation?: string;
+    /** The connector action executed by the tool, if any. */
+    action?: string;
+    /** The underlying {@link RestApiTool} that executes the HTTP request. */
+    restApiTool: RestApiTool;
+    /** The authentication scheme for dynamic end-user credentials, if any. */
+    authScheme?: AuthScheme;
+    /** The authentication credential for dynamic end-user credentials, if any. */
+    authCredential?: AuthCredential;
+}
+/**
+ * Wraps a {@link RestApiTool} for an Integration Connectors operation, hiding
+ * connection and routing fields from the model declaration and injecting them
+ * when the tool runs.
+ */
+export declare class IntegrationConnectorTool extends BaseTool {
+    /**
+     * Request fields that {@link IntegrationConnectorTool} injects at runtime and
+     * excludes from the function declaration shown to the model.
+     */
+    static readonly EXCLUDE_FIELDS: readonly string[];
+    /**
+     * Request fields that {@link IntegrationConnectorTool} removes from the
+     * `required` list in the function declaration shown to the model.
+     */
+    static readonly OPTIONAL_FIELDS: readonly string[];
+    readonly connectionName: string;
+    readonly connectionHost: string;
+    readonly connectionServiceName: string;
+    readonly entity: string;
+    readonly operation: string;
+    readonly action: string;
+    readonly restApiTool: RestApiTool;
+    readonly authScheme?: AuthScheme;
+    readonly authCredential?: AuthCredential;
+    constructor(options: IntegrationConnectorToolOptions);
+    /**
+     * Returns the Gemini `FunctionDeclaration` with connection routing fields
+     * removed from `parameters.properties` and optional and excluded fields
+     * removed from `parameters.required`.
+     */
+    _getDeclaration(): FunctionDeclaration;
+    /**
+     * Injects the connection details and the configured entity, operation, and
+     * action into a copy of `request.args` and delegates execution to the wrapped
+     * {@link RestApiTool}.
+     */
+    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+}

package/dist/types/tools/base_toolset.d.ts

@@ -8,11 +8,12 @@ import { LlmRequest } from '../models/llm_request.js';
 import { Context } from '../agents/context.js';
 import { BaseTool } from './base_tool.js';
 /**
- * Function to decide whether a tool should be exposed to LLM. Toolset
- * implementer could consider whether to accept such instance in the toolset's
- * constructor and apply the predicate in getTools method.
+ * Decides whether a tool should be exposed to the LLM based on the tool and
+ * optional context.
  */
-export type ToolPredicate = (tool: BaseTool, readonlyContext: ReadonlyContext) => boolean;
+export type ToolPredicate = {
+    bivariance(tool: BaseTool, readonlyContext?: ReadonlyContext): boolean;
+}['bivariance'];
 /**
  * A unique symbol to identify ADK agent classes.
  * Defined once and shared by all BaseTool instances.
@@ -28,7 +29,7 @@ export declare abstract class BaseToolset {
     readonly toolFilter: ToolPredicate | string[];
     readonly prefix?: string | undefined;
     readonly [BASE_TOOLSET_SIGNATURE_SYMBOL] = true;
-    constructor(toolFilter: ToolPredicate | string[], prefix?: string | undefined);
+    constructor(toolFilter?: ToolPredicate | string[], prefix?: string | undefined);
     /**
      * Returns the tools that should be exposed to LLM.
      *
@@ -55,7 +56,7 @@ export declare abstract class BaseToolset {
      * @param context Context used to filter tools available to the agent.
      * @return Whether the tool should be exposed to LLM.
      */
-    protected isToolSelected(tool: BaseTool, context: ReadonlyContext): boolean;
+    protected isToolSelected(tool: BaseTool, context?: ReadonlyContext): boolean;
     /**
      * Processes the outgoing LLM request for this toolset. This method will be
      * called before each tool processes the llm request.

package/dist/types/tools/computer_use/base_computer.d.ts

@@ -0,0 +1,281 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Context } from '../../agents/context.js';
+/**
+ * The environment a {@link BaseComputer} operates in.
+ */
+export declare enum ComputerEnvironment {
+    /** Defaults to browser. */
+    ENVIRONMENT_UNSPECIFIED = "ENVIRONMENT_UNSPECIFIED",
+    /** Operates in a web browser. */
+    ENVIRONMENT_BROWSER = "ENVIRONMENT_BROWSER"
+}
+/**
+ * The current state of the computer environment, returned by every
+ * {@link BaseComputer} action.
+ */
+export interface ComputerState {
+    /** The screenshot in PNG format. */
+    screenshot?: Uint8Array;
+    /** The current URL of the webpage being displayed. */
+    url?: string;
+}
+/** A direction to scroll in. */
+export type ScrollDirection = 'up' | 'down' | 'left' | 'right';
+/**
+ * Throws when the computer use feature is turned off.
+ *
+ * @throws {Error} If `ADK_DISABLE_COMPUTER_USE` or a feature override turned
+ *     the feature off.
+ */
+export declare function checkComputerUseEnabled(): void;
+declare const BASE_COMPUTER_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of {@link BaseComputer}.
+ *
+ * @param obj The object to check.
+ * @returns True if the object is an instance of BaseComputer, false otherwise.
+ */
+export declare function isBaseComputer(obj: unknown): obj is BaseComputer;
+/**
+ * Defines an interface for computer environments.
+ *
+ * This abstract base class defines the standard interface for controlling
+ * computer environments, including web browsers and other interactive systems.
+ * Coordinates passed to the action methods are absolute pixel values, scaled
+ * to the width and height returned by {@link screenSize}.
+ *
+ * The optional methods (`doubleClick`, `tripleClick`, `middleClick`,
+ * `rightClick`, `mouseDown`, `mouseUp`, `keyDown` and `keyUp`) are exposed to
+ * the model only when a subclass implements them.
+ *
+ * The Gemini 3.x actions `click`, `move`, `type`, `scroll`, `take_screenshot`,
+ * `press_key` and `hotkey` are always exposed. Each one calls the subclass
+ * method of the same name (`click`, `move`, `type`, `scroll`,
+ * `takeScreenshot`, `pressKey`, `hotkey`) when it is defined, and otherwise
+ * calls the matching predefined method.
+ */
+export declare abstract class BaseComputer {
+    /** A unique symbol to identify ADK base computer class. */
+    readonly [BASE_COMPUTER_SIGNATURE_SYMBOL] = true;
+    constructor();
+    /** Initializes the computer. */
+    initialize(): Promise<void>;
+    /** Cleans up the resources of the computer. */
+    close(): Promise<void>;
+    /**
+     * Called before each tool invocation to prepare resources.
+     *
+     * Override this to set up session-level resources (a sandbox, tokens, and so
+     * on), using the state of `toolContext` for persistence across invocations.
+     *
+     * @param _toolContext The tool context with session state access.
+     */
+    prepare(_toolContext: Context): Promise<void>;
+    /**
+     * Returns the screen size of the environment.
+     *
+     * @returns A tuple of (width, height) in pixels.
+     */
+    abstract screenSize(): Promise<[number, number]>;
+    /** Returns the environment of the computer. */
+    abstract environment(): Promise<ComputerEnvironment>;
+    /**
+     * Opens the web browser.
+     *
+     * @returns The current state after opening the browser.
+     */
+    abstract openWebBrowser(): Promise<ComputerState>;
+    /**
+     * Clicks at a specific x, y coordinate on the webpage.
+     *
+     * @param x The x-coordinate to click at.
+     * @param y The y-coordinate to click at.
+     * @returns The current state after clicking.
+     */
+    abstract clickAt(x: number, y: number): Promise<ComputerState>;
+    /**
+     * Hovers at a specific x, y coordinate on the webpage.
+     *
+     * May be used to explore sub-menus that appear on hover.
+     *
+     * @param x The x-coordinate to hover at.
+     * @param y The y-coordinate to hover at.
+     * @returns The current state after hovering.
+     */
+    abstract hoverAt(x: number, y: number): Promise<ComputerState>;
+    /**
+     * Types text at a specific x, y coordinate.
+     *
+     * @param x The x-coordinate to type at.
+     * @param y The y-coordinate to type at.
+     * @param text The text to type.
+     * @param pressEnter Whether to press ENTER after typing. The toolset passes
+     *     `true` when the model does not say.
+     * @param clearBeforeTyping Whether to clear existing content before typing.
+     *     The toolset passes `true` when the model does not say.
+     * @returns The current state after typing.
+     */
+    abstract typeTextAt(x: number, y: number, text: string, pressEnter?: boolean, clearBeforeTyping?: boolean): Promise<ComputerState>;
+    /**
+     * Types text into the currently focused element.
+     *
+     * By default, this calls {@link keyCombination} once per character in `text`
+     * (and once for `"Enter"` when `pressEnter` is true). Because
+     * `keyCombination` is designed for key names and typically captures a new
+     * screenshot on every call, this fallback costs one round trip and screenshot
+     * per character, and relies on the backend accepting single characters in
+     * `keyCombination`. Subclasses should override this method to use native
+     * bulk text input.
+     *
+     * @param text The text to type.
+     * @param pressEnter Whether to press ENTER after typing.
+     * @returns The current state after typing.
+     */
+    typeText(text: string, pressEnter?: boolean): Promise<ComputerState>;
+    /**
+     * Scrolls the entire webpage up, down, left or right.
+     *
+     * @param direction The direction to scroll.
+     * @returns The current state after scrolling.
+     */
+    abstract scrollDocument(direction: ScrollDirection): Promise<ComputerState>;
+    /**
+     * Scrolls up, down, right, or left at an x, y coordinate by magnitude.
+     *
+     * @param x The x-coordinate to scroll at.
+     * @param y The y-coordinate to scroll at.
+     * @param direction The direction to scroll.
+     * @param magnitude The amount to scroll.
+     * @returns The current state after scrolling.
+     */
+    abstract scrollAt(x: number, y: number, direction: ScrollDirection, magnitude: number): Promise<ComputerState>;
+    /**
+     * Waits for n seconds to allow unfinished webpage processes to complete.
+     *
+     * @param seconds The number of seconds to wait.
+     * @returns The current state after waiting.
+     */
+    abstract wait(seconds: number): Promise<ComputerState>;
+    /**
+     * Navigates back to the previous webpage in the browser history.
+     *
+     * @returns The current state after navigating back.
+     */
+    abstract goBack(): Promise<ComputerState>;
+    /**
+     * Navigates forward to the next webpage in the browser history.
+     *
+     * @returns The current state after navigating forward.
+     */
+    abstract goForward(): Promise<ComputerState>;
+    /**
+     * Directly jumps to a search engine home page.
+     *
+     * Used when you need to start with a search, for example because the current
+     * website doesn't have the information needed or a new task is being
+     * started.
+     *
+     * @returns The current state after navigating to search.
+     */
+    abstract search(): Promise<ComputerState>;
+    /**
+     * Navigates directly to a specified URL.
+     *
+     * @param url The URL to navigate to.
+     * @returns The current state after navigation.
+     */
+    abstract navigate(url: string): Promise<ComputerState>;
+    /**
+     * Presses keyboard keys and combinations, such as "control+c" or "enter".
+     *
+     * @param keys The keys to press in combination.
+     * @returns The current state after the key press.
+     */
+    abstract keyCombination(keys: string[]): Promise<ComputerState>;
+    /**
+     * Drags an element from an x, y coordinate and drops it at a destination
+     * coordinate.
+     *
+     * @param x The x-coordinate to start dragging from.
+     * @param y The y-coordinate to start dragging from.
+     * @param destinationX The x-coordinate to drop at.
+     * @param destinationY The y-coordinate to drop at.
+     * @returns The current state after drag and drop.
+     */
+    abstract dragAndDrop(x: number, y: number, destinationX: number, destinationY: number): Promise<ComputerState>;
+    /**
+     * Returns the current state of the current webpage.
+     *
+     * @returns The current environment state.
+     */
+    abstract currentState(): Promise<ComputerState>;
+    /** Double-clicks at a specific x, y coordinate. */
+    doubleClick?(x: number, y: number, button?: string): Promise<ComputerState>;
+    /** Triple-clicks at a specific x, y coordinate. */
+    tripleClick?(x: number, y: number, button?: string): Promise<ComputerState>;
+    /** Clicks the middle mouse button at a specific x, y coordinate. */
+    middleClick?(x: number, y: number, button?: string): Promise<ComputerState>;
+    /** Clicks the right mouse button at a specific x, y coordinate. */
+    rightClick?(x: number, y: number, button?: string): Promise<ComputerState>;
+    /** Presses a mouse button down at a specific x, y coordinate. */
+    mouseDown?(x: number, y: number, button?: string): Promise<ComputerState>;
+    /** Releases a mouse button at a specific x, y coordinate. */
+    mouseUp?(x: number, y: number, button?: string): Promise<ComputerState>;
+    /** Presses a keyboard key down and holds it. */
+    keyDown?(key: string): Promise<ComputerState>;
+    /** Releases a keyboard key. */
+    keyUp?(key: string): Promise<ComputerState>;
+    /**
+     * Clicks at a specific x, y coordinate with the given mouse button.
+     *
+     * When defined, the `click` action calls this instead of {@link clickAt}
+     * and passes the model's `button`.
+     */
+    click?(x: number, y: number, button?: string): Promise<ComputerState>;
+    /**
+     * Moves the cursor to a specific x, y coordinate.
+     *
+     * When defined, the `move` action calls this instead of {@link hoverAt}.
+     */
+    move?(x: number, y: number): Promise<ComputerState>;
+    /**
+     * Types text into the currently focused element.
+     *
+     * When defined, the `type` action calls this instead of {@link typeText}.
+     * `pressEnter` is `undefined` when the model does not say.
+     */
+    type?(text: string, pressEnter?: boolean): Promise<ComputerState>;
+    /**
+     * Scrolls at a specific x, y coordinate by a number of pixels.
+     *
+     * When defined, the `scroll` action calls this instead of {@link scrollAt}.
+     * `magnitudeInPixels` is `undefined` when the model does not say.
+     */
+    scroll?(x: number, y: number, direction: ScrollDirection, magnitudeInPixels?: number): Promise<ComputerState>;
+    /**
+     * Takes a screenshot of the current state.
+     *
+     * When defined, the `take_screenshot` action calls this instead of
+     * {@link currentState}.
+     */
+    takeScreenshot?(): Promise<ComputerState>;
+    /**
+     * Presses a single keyboard key.
+     *
+     * When defined, the `press_key` action calls this instead of
+     * {@link keyCombination}.
+     */
+    pressKey?(key: string): Promise<ComputerState>;
+    /**
+     * Presses a combination of keyboard keys simultaneously.
+     *
+     * When defined, the `hotkey` action calls this instead of
+     * {@link keyCombination}.
+     */
+    hotkey?(keys: string[]): Promise<ComputerState>;
+}
+export {};

package/dist/types/tools/computer_use/computer_use_actions.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Schema } from '@google/genai';
+import { BaseComputer } from './base_computer.js';
+/**
+ * A computer use action the model can call, before it is wrapped in a
+ * `ComputerUseTool`.
+ */
+export interface ComputerAction {
+    /** The predefined function name the model calls, such as `click_at`. */
+    readonly name: string;
+    /** The description of the action. */
+    readonly description: string;
+    /** The schema of the action's arguments. */
+    readonly parameters: Schema;
+    /** Runs the action on the computer with the model's arguments. */
+    execute(args: Record<string, unknown>): Promise<unknown>;
+}
+/** The options for {@link createComputerActions}. */
+export interface ComputerActionsOptions {
+    /** The computer the actions run on. */
+    computer: BaseComputer;
+    /** Whether `navigate` may target private and loopback hosts. */
+    allowPrivateNetworkAccess: boolean;
+}
+/**
+ * The predefined actions that map one-to-one onto {@link BaseComputer}
+ * methods, in the order the toolset exposes them.
+ */
+export declare const LEGACY_ACTION_NAMES: readonly string[];
+/** Gemini 3.x mouse actions that are exposed only when the computer has them. */
+export declare const OPTIONAL_MOUSE_ACTIONS: readonly ["double_click", "triple_click", "middle_click", "right_click", "mouse_down", "mouse_up"];
+/** Gemini 3.x key actions that are exposed only when the computer has them. */
+export declare const OPTIONAL_KEY_ACTIONS: readonly ["key_down", "key_up"];
+/**
+ * Returns the optional Gemini 3.x actions that `computer` does not implement.
+ *
+ * @param computer The computer to probe.
+ * @returns The action names, in their canonical order.
+ */
+export declare function unimplementedOptionalActions(computer: BaseComputer): string[];
+/**
+ * Builds every action the computer supports: the predefined actions, the
+ * Gemini 3.x actions that translate onto them, and the optional Gemini 3.x
+ * actions the computer implements.
+ *
+ * @param options The computer and its configuration.
+ * @returns The actions, legacy ones first.
+ */
+export declare function createComputerActions(options: ComputerActionsOptions): ComputerAction[];

package/dist/types/tools/computer_use/computer_use_tool.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Schema } from '@google/genai';
+import { Context } from '../../agents/context.js';
+import { RunAsyncToolRequest, ToolProcessLlmRequest } from '../base_tool.js';
+import { FunctionTool } from '../function_tool.js';
+/**
+ * The function a {@link ComputerUseTool} wraps. It receives the model's
+ * arguments, with coordinates already scaled to the screen.
+ */
+export type ComputerUseFunction = (args: Record<string, unknown>, toolContext?: Context) => Promise<unknown> | unknown;
+/**
+ * The options for creating a {@link ComputerUseTool}.
+ */
+export interface ComputerUseToolOptions {
+    /** The name of the computer use action, such as `click_at`. */
+    name: string;
+    /** The description of the action. */
+    description: string;
+    /** The schema of the action's arguments. */
+    parameters?: Schema;
+    /** The computer control function to wrap. */
+    execute: ComputerUseFunction;
+    /**
+     * The actual screen size as (width, height) in pixels. This represents the
+     * real dimensions of the target screen.
+     */
+    screenSize: readonly [number, number];
+    /**
+     * The virtual coordinate space as (width, height) that the model uses to
+     * specify coordinates. Coordinates from the model are scaled from this space
+     * to `screenSize`. Defaults to (1000, 1000), so the model works with a
+     * 1000x1000 screen regardless of the actual screen dimensions.
+     */
+    virtualScreenSize?: readonly [number, number];
+}
+declare const COMPUTER_USE_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of {@link ComputerUseTool}.
+ *
+ * @param obj The object to check.
+ * @returns True if the object is an instance of ComputerUseTool, false
+ *     otherwise.
+ */
+export declare function isComputerUseTool(obj: unknown): obj is ComputerUseTool;
+/**
+ * A tool that wraps computer control functions for use with LLMs.
+ *
+ * This tool scales coordinates from a virtual coordinate space (by default
+ * 1000x1000) to the actual screen size. This lets the model work with a
+ * consistent coordinate system regardless of the actual screen dimensions,
+ * which makes its output more predictable.
+ *
+ * When the wrapped function returns a {@link ComputerState}, the tool returns
+ * `{image: {mimetype, data}, url}` with the screenshot base64-encoded; the
+ * agent then sends the image to the model as part of the function response.
+ *
+ * When the model marks a call with a `safety_decision` of
+ * `require_confirmation`, the tool asks the user to confirm before it runs and
+ * adds `safety_acknowledgement: 'true'` to the response once confirmed.
+ */
+export declare class ComputerUseTool extends FunctionTool<Schema> {
+    /** A unique symbol to identify ADK computer use tool class. */
+    readonly [COMPUTER_USE_TOOL_SIGNATURE_SYMBOL] = true;
+    /** The wrapped computer control function. */
+    readonly func: ComputerUseFunction;
+    /** The actual screen size as (width, height) in pixels. */
+    readonly screenSize: readonly [number, number];
+    /** The virtual coordinate space as (width, height). */
+    readonly virtualScreenSize: readonly [number, number];
+    /**
+     * @param options The options for the tool.
+     * @throws {Error} If `screenSize` or `virtualScreenSize` is not a pair of
+     *     positive numbers.
+     */
+    constructor(options: ComputerUseToolOptions);
+    /**
+     * Runs the computer control function with scaled coordinates.
+     *
+     * @param request The tool request containing arguments and tool context.
+     * @returns The function's result, with a {@link ComputerState} converted to
+     *     a response carrying the base64-encoded screenshot.
+     * @throws {Error} If a coordinate is not numeric, or the function returns a
+     *     state with no screenshot.
+     */
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    /**
+     * Whether this call needs user confirmation: when the model marked it with
+     * a `safety_decision` of `require_confirmation`, or when the base tool says
+     * so.
+     *
+     * @param args The arguments the tool would run with.
+     * @param toolContext The context of the call, when there is one.
+     * @returns Whether the call requires confirmation.
+     */
+    checkRequireConfirmation(args: Record<string, unknown>, toolContext?: Context): Promise<boolean>;
+    /**
+     * Adds nothing to the request: {@link ComputerUseToolset} adds the single
+     * computer use configuration and registers its tools by name.
+     */
+    processLlmRequest(_request: ToolProcessLlmRequest): Promise<void>;
+    /** Returns a copy of `args` with every coordinate scaled to the screen. */
+    private scaleCoordinates;
+}
+export {};

package/dist/types/tools/computer_use/computer_use_toolset.d.ts

@@ -0,0 +1,132 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Context } from '../../agents/context.js';
+import { LlmRequest } from '../../models/llm_request.js';
+import { BaseToolset } from '../base_toolset.js';
+import { BaseComputer } from './base_computer.js';
+import { ComputerUseFunction, ComputerUseTool } from './computer_use_tool.js';
+/**
+ * A computer use function, as returned by the adapter passed to
+ * {@link adaptComputerUseTool}.
+ */
+export interface AdaptedComputerUseFunction {
+    /** The name of the new tool. */
+    name: string;
+    /** The description of the new tool. */
+    description: string;
+    /** The new computer use function. */
+    execute: ComputerUseFunction;
+}
+/** The parameters of {@link adaptComputerUseTool}. */
+export interface AdaptComputerUseToolParams {
+    /** The predefined action to adapt, such as `wait`. */
+    methodName: string;
+    /**
+     * Receives the original computer use function and returns the new one. It
+     * may be async.
+     */
+    adapter: (func: ComputerUseFunction) => AdaptedComputerUseFunction | Promise<AdaptedComputerUseFunction>;
+    /** The request holding the tools. */
+    llmRequest: LlmRequest;
+}
+/**
+ * Replaces a computer use tool in the request with an adapted version.
+ *
+ * The adapted tool keeps the original tool's screen size and virtual screen
+ * size. When the adapted function has a new name, the original tool is
+ * removed from the request.
+ *
+ * @param params The action to adapt, the adapter and the request.
+ */
+export declare function adaptComputerUseTool({ methodName, adapter, llmRequest, }: AdaptComputerUseToolParams): Promise<void>;
+/**
+ * The options for creating a {@link ComputerUseToolset}.
+ */
+export interface ComputerUseToolsetOptions {
+    /** The computer environment to expose as tools. */
+    computer: BaseComputer;
+    /**
+     * Names of computer use actions that should not be exposed as tools. Both
+     * legacy names (such as `click_at`) and Gemini 3.x names (such as `click`)
+     * are accepted. Each is expanded to its counterpart locally, and translated
+     * to the target model's action schema in the request.
+     */
+    excludedPredefinedFunctions?: readonly string[];
+    /**
+     * By default `navigate` refuses urls whose host is not publicly routable.
+     * Set this to true when the agent is meant to drive the browser against
+     * localhost or an internal host.
+     */
+    allowPrivateNetworkAccess?: boolean;
+}
+declare const COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of
+ * {@link ComputerUseToolset}.
+ *
+ * @param obj The object to check.
+ * @returns True if the object is an instance of ComputerUseToolset, false
+ *     otherwise.
+ */
+export declare function isComputerUseToolset(obj: unknown): obj is ComputerUseToolset;
+/**
+ * A toolset that exposes the actions of a {@link BaseComputer} to an agent.
+ *
+ * The toolset initializes the computer on first use and wraps each action in a
+ * {@link ComputerUseTool}. Actions on one computer run one at a time, and the
+ * computer's `prepare()` runs before each of them. When the agent builds a
+ * request, the toolset registers its tools and adds the computer use
+ * configuration that tells the model which predefined actions it may call.
+ *
+ * ```ts
+ * const agent = new LlmAgent({
+ *   name: 'browser_agent',
+ *   model: 'gemini-flash-latest',
+ *   tools: [new ComputerUseToolset({computer: new MyBrowserComputer()})],
+ * });
+ * ```
+ */
+export declare class ComputerUseToolset extends BaseToolset {
+    /** A unique symbol to identify ADK computer use toolset class. */
+    readonly [COMPUTER_USE_TOOLSET_SIGNATURE_SYMBOL] = true;
+    private readonly computer;
+    private readonly excludedPredefinedFunctions?;
+    private readonly allowPrivateNetworkAccess;
+    private initializing?;
+    private loadingTools?;
+    private closed;
+    /**
+     * @param options The computer and its configuration.
+     */
+    constructor(options: ComputerUseToolsetOptions);
+    /**
+     * Returns a tool for every action the computer supports, except the
+     * excluded ones. The computer is initialized on the first call, and the
+     * tools are cached until {@link close}.
+     */
+    getTools(): Promise<ComputerUseTool[]>;
+    /**
+     * Closes the computer and drops the cached tools. The next call to
+     * {@link getTools} initializes the computer again.
+     */
+    close(): Promise<void>;
+    /**
+     * Registers the computer use tools in the request and adds the computer use
+     * configuration, unless the request already has one.
+     *
+     * @param _toolContext The context of the tool.
+     * @param llmRequest The outgoing request.
+     */
+    processLlmRequest(_toolContext: Context, llmRequest: LlmRequest): Promise<void>;
+    private ensureInitialized;
+    private loadTools;
+    /**
+     * Wraps an action so it runs exclusively on the computer, after the
+     * computer has prepared for the calling session.
+     */
+    private bindToComputer;
+}
+export {};