@google/adk 2.4.0 → 2.5.0

package/dist/types/tools/application_integration_tool/clients/connections_client.d.ts

@@ -187,7 +187,9 @@ export declare function actionRequest(action: string, options?: {
 /** Builds the response schema of an action. */
 export declare function actionResponse(action: string): JsonObject;
 /** Builds the request schema of the `ExecuteCustomQuery` action. */
-export declare function executeCustomQueryRequest(): JsonObject;
+export declare function executeCustomQueryRequest(options?: {
+    includeDynamicAuthConfig?: boolean;
+}): JsonObject;
 /**
  * A client for the Integration Connectors API.
  *
@@ -208,14 +210,16 @@ export declare class ConnectionsClient {
      * Reads the JSON schema of an entity and the operations it supports.
      *
      * @param entity The entity name.
-     * @throws Error When the API starts no operation for the entity.
+     * @throws Error When the API starts no operation for the entity, or the
+     *   operation fails or times out.
      */
     getEntitySchemaAndOperations(entity: string): Promise<EntitySchemaAndOperations>;
     /**
      * Reads the input and output JSON schemas of an action.
      *
      * @param action The action name.
-     * @throws Error When the API starts no operation for the action.
+     * @throws Error When the API starts no operation for the action, or the
+     *   operation fails or times out.
      */
     getActionSchema(action: string): Promise<ActionSchema>;
     /**
@@ -224,6 +228,11 @@ export declare class ConnectionsClient {
      */
     connectorPayload(jsonSchema: JsonObject): JsonObject;
     private executeApiCall;
-    /** Polls a long-running operation until it reports `done`. */
+    /**
+     * Polls a long-running operation until it reports `done`.
+     *
+     * @throws Error When the operation reports an `error` or does not finish
+     *   within `MAX_OPERATION_POLL_ATTEMPTS` polls.
+     */
     private pollOperation;
 }

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

@@ -29,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.
      *

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 {};

package/dist/types/tools/google_api_tool/google_api_toolset.d.ts

@@ -16,6 +16,7 @@ export interface GoogleApiToolsetOptions {
     clientId?: string;
     clientSecret?: string;
     toolFilter?: ToolPredicate | string[];
+    scopes?: string[];
 }
 /**
  * Type guard to check if an object is an instance of {@link GoogleApiToolset}.
@@ -30,6 +31,7 @@ export declare class GoogleApiToolset extends BaseToolset {
     toolFilter: ToolPredicate | string[];
     readonly apiName?: string;
     readonly apiVersion?: string;
+    readonly scopes?: string[];
     private clientId?;
     private clientSecret?;
     private openapiToolset?;

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

@@ -15,9 +15,13 @@ import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_too
  *
  * @param artifact The artifact to convert.
  * @param artifactName The artifact name used in the placeholder text.
+ * @param options Optional settings controlling how inline media and file
+ *   references are formatted.
  * @return The artifact itself, or a text part that replaces it.
  */
-export declare function asSafePartForLlm(artifact: Part, artifactName: string): Part;
+export declare function asSafePartForLlm(artifact: Part, artifactName: string, options?: {
+    inlineMediaAsPlaceholder?: boolean;
+}): Part;
 /**
  * A tool that loads the artifacts and adds them to the session.
  */