@google/adk 2.0.0 → 2.2.0

package/dist/types/tools/openapi_tool/openapi_spec_parser/tool_auth_handler.d.ts

@@ -3,21 +3,89 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { OpenAPIV3 } from 'openapi-types';
 import { Context } from '../../../agents/context.js';
 import { AuthCredential } from '../../../auth/auth_credential.js';
+import { AuthScheme } from '../../../auth/auth_schemes.js';
+import { BaseCredentialExchanger } from '../../../auth/exchanger/base_credential_exchanger.js';
+/** The outcome of preparing a tool's credential. */
 export interface AuthPreparationResult {
     state: 'pending' | 'done';
+    authScheme?: AuthScheme;
     authCredential?: AuthCredential;
 }
+/** Collaborators a caller may substitute when building a {@link ToolAuthHandler}. */
+export interface ToolAuthHandlerOptions {
+    /** Key under which a credential service loads and saves this credential. */
+    credentialKey?: string;
+    /** Exchanger to use instead of the default `AutoAuthCredentialExchanger`. */
+    credentialExchanger?: BaseCredentialExchanger;
+    /** Store to use instead of one built over the tool's own context. */
+    credentialStore?: ToolContextCredentialStore;
+}
+/**
+ * Stores and retrieves exchanged credentials in the session state carried by a
+ * {@link Context}.
+ */
+export declare class ToolContextCredentialStore {
+    private readonly context;
+    constructor(context: Context);
+    /**
+     * Returns the state key that holds the credential exchanged for this scheme
+     * and credential pair.
+     *
+     * Both operands are hashed into the key, so two tools configured with
+     * different schemes, or with different credentials under one scheme, never
+     * share a slot.
+     *
+     * The key deliberately carries no `temp:` prefix. Session state is a copy and
+     * only the delta is persisted, and `temp:` is cleared at the end of a run,
+     * while an exchanged token has to stay readable across runs.
+     */
+    getCredentialKey(authScheme?: AuthScheme, authCredential?: AuthCredential): string;
+    /**
+     * Returns the credential stored for this scheme and credential pair, or
+     * `undefined` when there is none.
+     *
+     * @throws Error if the state entry under the key is not an
+     *     {@link AuthCredential}, which means something else wrote to the key.
+     */
+    getCredential(authScheme?: AuthScheme, authCredential?: AuthCredential): AuthCredential | undefined;
+    storeCredential(key: string, credential: AuthCredential): void;
+    /**
+     * Makes the credential under `key` unreadable again.
+     *
+     * adk-python deletes the state entry. `State` has no delete, so this writes
+     * `undefined`, which `State.get` returns for a missing key as well, and
+     * {@link getCredential} therefore misses exactly as a delete would make it.
+     */
+    removeCredential(key: string): void;
+}
 export declare class ToolAuthHandler {
     private readonly context;
     private readonly authScheme?;
     private readonly authCredential?;
     private readonly credentialKey?;
-    constructor(context: Context, authScheme?: OpenAPIV3.SecuritySchemeObject | undefined, authCredential?: AuthCredential | undefined, credentialKey?: string | undefined);
-    static fromToolContext(context: Context, authScheme?: OpenAPIV3.SecuritySchemeObject, authCredential?: AuthCredential, options?: {
-        credentialKey?: string;
-    }): ToolAuthHandler;
+    private readonly credentialExchanger?;
+    private readonly credentialStore;
+    constructor(context: Context, authScheme?: AuthScheme, authCredential?: AuthCredential, options?: ToolAuthHandlerOptions);
+    static fromToolContext(context: Context, authScheme?: AuthScheme, authCredential?: AuthCredential, options?: ToolAuthHandlerOptions): ToolAuthHandler;
     prepareAuthCredentials(): Promise<AuthPreparationResult>;
+    /**
+     * Exchanges `credential`, or returns `undefined` when the exchange failed.
+     *
+     * An exchange failure is transient far more often than it is fatal, so it
+     * becomes a `pending` result the client can resume from rather than an
+     * exception that fails the whole tool call.
+     */
+    private tryExchange;
+    /**
+     * Asks the client for a credential, after checking that an interactive
+     * scheme has the OAuth2 client configuration it cannot proceed without.
+     *
+     * @throws Error if an `oauth2` or `openIdConnect` scheme has no OAuth2
+     *     credential.
+     * @throws AuthCredentialMissingError if that credential omits `clientId` or
+     *     `clientSecret`.
+     */
+    private requestCredential;
 }

package/dist/types/tools/openapi_tool/openapi_toolset.d.ts

@@ -8,6 +8,7 @@ import { ReadonlyContext } from '../../agents/readonly_context.js';
 import { AuthCredential } from '../../auth/auth_credential.js';
 import { BaseTool } from '../base_tool.js';
 import { BaseToolset, ToolPredicate } from '../base_toolset.js';
+import { RestApiTool } from './rest_api_tool.js';
 export declare class OpenAPIToolset extends BaseToolset {
     private tools;
     constructor(options?: {
@@ -23,5 +24,15 @@ export declare class OpenAPIToolset extends BaseToolset {
         headerProvider?: (context: ReadonlyContext) => Record<string, string>;
     });
     getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    /**
+     * Returns the parsed tool with the given name, or `undefined` when the spec
+     * produced no such tool.
+     *
+     * The lookup is over every tool parsed from the spec and does not apply
+     * `toolFilter`, which selects what an agent exposes to the model rather than
+     * what the toolset holds. When the toolset was constructed with `prefix`,
+     * pass the prefixed name.
+     */
+    getTool(toolName: string): RestApiTool | undefined;
     close(): Promise<void>;
 }

package/dist/types/tools/openapi_tool/rest_api_tool.d.ts

@@ -8,8 +8,26 @@ import { OpenAPIV3 } from 'openapi-types';
 import { ReadonlyContext } from '../../agents/readonly_context.js';
 import { AuthCredential } from '../../auth/auth_credential.js';
 import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
-import { ApiParameter } from './openapi_spec_parser/operation_parser.js';
+import { ApiParameter, OperationParser } from './openapi_spec_parser/operation_parser.js';
 import { OperationEndpoint } from './openapi_spec_parser/openapi_spec_parser.js';
+/**
+ * The parsed operation `createRestApiTool` accepts.
+ *
+ * `name` and `description` are optional and are derived from the operation
+ * when they are absent. `parameters` and `returnValue` carry an operation the
+ * caller has already parsed, so its names, locations and schemas stay
+ * authoritative.
+ */
+export interface ParsedOperationInput {
+    name?: string;
+    description?: string;
+    endpoint: OperationEndpoint;
+    operation: OpenAPIV3.OperationObject;
+    authScheme?: OpenAPIV3.SecuritySchemeObject;
+    authCredential?: AuthCredential;
+    parameters?: ApiParameter[];
+    returnValue?: ApiParameter;
+}
 export declare class RestApiTool extends BaseTool {
     private readonly endpoint;
     private readonly operation;
@@ -22,6 +40,7 @@ export declare class RestApiTool extends BaseTool {
         preservePropertyNames?: boolean;
         headerProvider?: (context: ReadonlyContext) => Record<string, string>;
         credentialKey?: string;
+        operationParser?: OperationParser;
     });
     configureAuthScheme(authScheme: OpenAPIV3.SecuritySchemeObject): void;
     configureAuthCredential(authCredential: AuthCredential): void;
@@ -34,17 +53,32 @@ export interface PreparedParams {
     headers: Record<string, string>;
     body: unknown;
     bodyData: Record<string, unknown>;
+    cookies: Record<string, string>;
 }
 export declare function prepareRequestParams(endpoint: OperationEndpoint, parameters: ApiParameter[], args: Record<string, unknown>): PreparedParams;
 export declare function prepareRequestBody(requestBody: OpenAPIV3.RequestBodyObject | OpenAPIV3.ReferenceObject | undefined, body: unknown, bodyData: Record<string, unknown>, headers: Record<string, string>): unknown;
-export declare function createRestApiTool(parsed: {
-    name: string;
-    description: string;
-    endpoint: OperationEndpoint;
-    operation: OpenAPIV3.OperationObject;
-    authScheme?: OpenAPIV3.SecuritySchemeObject;
-}, options?: {
+/**
+ * Builds a `RestApiTool` from a parsed operation.
+ *
+ * @param parsed The operation, with the parameters already parsed when the
+ *   caller has them.
+ * @param options Options forwarded to the tool and to its operation parser.
+ * @returns The tool for that operation.
+ */
+export declare function createRestApiTool(parsed: ParsedOperationInput, options?: {
     preservePropertyNames?: boolean;
     headerProvider?: (context: ReadonlyContext) => Record<string, string>;
     credentialKey?: string;
 }): RestApiTool;
+/**
+ * Builds a `RestApiTool` from the JSON string form of a parsed operation.
+ *
+ * This is the only entry point that accepts undecoded input, so it is where
+ * the auth scheme is checked. A scheme reaching `createRestApiTool` as an
+ * object is already constrained by its type.
+ *
+ * @param parsedOperationJson A serialized {@link ParsedOperationInput}.
+ * @returns The tool for that operation.
+ * @throws {Error} If the auth scheme does not declare a known `type`.
+ */
+export declare function createRestApiToolFromJson(parsedOperationJson: string): RestApiTool;

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

@@ -7,7 +7,7 @@ import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_too
 /**
  * A tool that preloads the memory for the current user.
  *
- * This tool will be automatically executed for each llm_request, and it won't be
+ * This tool is automatically executed for each `LlmRequest`, and it won't be
  * called by the model.
  *
  * NOTE: Currently this tool only uses text part from the memory.

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

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Inputs handed to a tool call that is being resumed after it paused for them,
+ * keyed by the id of the interrupt that asked for each one. JSON-serializable.
+ *
+ * Deliberately separate from `ToolConfirmation`. Both travel the same
+ * route — built by a resume processor, threaded through `handleFunctionCallList`
+ * onto the tool context — but they say different things. A `ToolConfirmation`
+ * says a human looked at an action and approved it, and the confirmation gate
+ * runs a tool on the strength of that. `ResumeInputs` says only that the user
+ * answered a question the tool asked; it carries no authority and cannot
+ * satisfy a gate, which is why it has no `confirmed` field to set.
+ *
+ * Named here rather than left as a bare mapping so the distinction above has
+ * somewhere to live, but the shape mirrors `Context.resume_inputs` in
+ * `google/adk-python` (`agents/context.py`): the same flat mapping keyed by
+ * interrupt id, defaulting to empty rather than absent.
+ *
+ * @experimental  (Experimental, subject to change)
+ */
+export type ResumeInputs = Record<string, unknown>;

package/dist/types/tools/retrieval/base_retrieval_tool.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool } from '../base_tool.js';
+/**
+ * The base class for tools that answer a single natural-language query by
+ * retrieving text the framework fetches itself.
+ *
+ * Subclasses supply `runAsync`; this class supplies the declaration the model
+ * sees, so every retrieval tool advertises the same one-argument `query`
+ * signature whatever store backs it.
+ *
+ * Ported from adk-python
+ * `src/google/adk/tools/retrieval/base_retrieval_tool.py` at ref `v0.1.0`.
+ */
+export declare abstract class BaseRetrievalTool extends BaseTool {
+    _getDeclaration(): FunctionDeclaration;
+}

package/dist/types/tools/retrieval/files_retrieval.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LlamaIndexRetrieval, LlamaIndexRetriever } from './llama_index_retrieval.js';
+/** Parameters shared by the `FilesRetrieval` constructor and `create`. */
+export interface FilesRetrievalParams {
+    name: string;
+    description: string;
+    /** The directory whose files are indexed. */
+    inputDir: string;
+}
+/** Parameters for the `FilesRetrieval` constructor. */
+export interface FilesRetrievalConstructorParams extends FilesRetrievalParams {
+    /** A retriever already built over `inputDir`. */
+    retriever: LlamaIndexRetriever;
+}
+/**
+ * A retrieval tool over the files in a local directory.
+ *
+ * Ported from adk-python `src/google/adk/tools/retrieval/files_retrieval.py`
+ * at ref `v0.1.0`.
+ *
+ * adk-python reads the directory and builds the index inside `__init__`.
+ * Both steps are asynchronous in LlamaIndexTS, so they live in the static
+ * `create` instead; the constructor takes the finished retriever, which also
+ * lets a caller supply one built some other way.
+ *
+ * @example
+ * ```ts
+ * const tool = await FilesRetrieval.create({
+ *   name: 'docs',
+ *   description: 'Company documentation.',
+ *   inputDir: './docs',
+ * });
+ * ```
+ */
+export declare class FilesRetrieval extends LlamaIndexRetrieval {
+    readonly inputDir: string;
+    constructor(params: FilesRetrievalConstructorParams);
+    /**
+     * Indexes every file under `inputDir` and returns a tool that retrieves
+     * from it.
+     *
+     * Requires the optional `llamaindex` and `@llamaindex/readers` packages,
+     * and a configured LlamaIndex embedding model.
+     */
+    static create(params: FilesRetrievalParams): Promise<FilesRetrieval>;
+}

package/dist/types/tools/retrieval/llama_index_retrieval.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { RunAsyncToolRequest } from '../base_tool.js';
+import { BaseRetrievalTool } from './base_retrieval_tool.js';
+/**
+ * The part of LlamaIndexTS's `BaseNode` this tool reads.
+ *
+ * A vector retriever returns `TextNode`s, which carry the chunk text on
+ * `text`. The interface is structural so that `llamaindex` stays an optional
+ * dependency — nothing here imports it, matching how adk-python keeps the
+ * import under `TYPE_CHECKING`.
+ */
+export interface LlamaIndexNode {
+    /** The chunk text. */
+    text?: string;
+}
+/** LlamaIndexTS's `NodeWithScore`. */
+export interface LlamaIndexNodeWithScore {
+    node: LlamaIndexNode;
+    score?: number;
+}
+/**
+ * The part of LlamaIndexTS's `BaseRetriever` this tool calls.
+ *
+ * `retrieve` accepts a `QueryType`, which includes a plain string, so passing
+ * the model's `query` argument straight through matches adk-python.
+ */
+export interface LlamaIndexRetriever {
+    retrieve(query: string): Promise<LlamaIndexNodeWithScore[]>;
+}
+/** Parameters for the `LlamaIndexRetrieval` constructor. */
+export interface LlamaIndexRetrievalParams {
+    name: string;
+    description: string;
+    retriever: LlamaIndexRetriever;
+}
+/**
+ * A retrieval tool backed by a LlamaIndex retriever.
+ *
+ * Answers with the text of the single highest-scoring node, as adk-python
+ * does.
+ *
+ * Ported from adk-python
+ * `src/google/adk/tools/retrieval/llama_index_retrieval.py` at ref `v0.1.0`.
+ *
+ * @example
+ * ```ts
+ * const tool = new LlamaIndexRetrieval({
+ *   name: 'docs',
+ *   description: 'Company documentation.',
+ *   retriever: index.asRetriever(),
+ * });
+ * ```
+ */
+export declare class LlamaIndexRetrieval extends BaseRetrievalTool {
+    readonly retriever: LlamaIndexRetriever;
+    constructor(params: LlamaIndexRetrievalParams);
+    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The tool-facing names for the unified agent context.
+ *
+ * `ToolContext` and `CallbackContext` are aliases of {@link Context}, not
+ * subclasses, so a context the framework builds satisfies either name. This
+ * mirrors `adk-python`'s `google.adk.tools.tool_context`, which binds
+ * `ToolContext = Context`.
+ *
+ * Python also re-exports `AuthHandler`, `AuthConfig` and `AuthCredential` from
+ * this module. adk-js does not: the package `exports` map has no entry for this
+ * path, so no consumer can import them from here, and all three already ship
+ * from the package root.
+ */
+export { Context as CallbackContext, Context as ToolContext, } from '../agents/context.js';

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

@@ -1,4 +1,5 @@
-import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+import { ToolProcessLlmRequest } from './base_tool.js';
+import { BuiltInTool } from './built_in_tool.js';
 /**
  * A built-in tool that allows Gemini 2+ models to retrieve content from URLs
  * provided in the conversation.
@@ -6,10 +7,9 @@ import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
  * This tool operates internally within the model and does not require or
  * perform local code execution.
  */
-export declare class UrlContextTool extends BaseTool {
+export declare class UrlContextTool extends BuiltInTool {
     constructor();
-    runAsync(): Promise<unknown>;
-    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+    protected applyBuiltInConfig({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
 }
 /**
  * A global instance of {@link UrlContextTool}.

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

@@ -4,7 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { ReadonlyContext } from '../agents/readonly_context.js';
-import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+import { ToolProcessLlmRequest } from './base_tool.js';
+import { BuiltInTool } from './built_in_tool.js';
 export interface VertexAISearchDataStoreSpec {
     dataStore?: string;
 }
@@ -34,7 +35,7 @@ export type VertexAiSearchToolParams = DataStoreParams | SearchEngineParams;
 /**
  * A built-in tool using Vertex AI Search.
  */
-export declare class VertexAiSearchTool extends BaseTool {
+export declare class VertexAiSearchTool extends BuiltInTool {
     readonly dataStoreId?: string;
     readonly dataStoreSpecs?: VertexAISearchDataStoreSpec[];
     readonly searchEngineId?: string;
@@ -42,7 +43,6 @@ export declare class VertexAiSearchTool extends BaseTool {
     readonly maxResults?: number;
     readonly bypassMultiToolsLimit: boolean;
     constructor(params: VertexAiSearchToolParams);
-    runAsync(): Promise<unknown>;
     /**
      * Builds the VertexAISearch configuration.
      *
@@ -51,5 +51,5 @@ export declare class VertexAiSearchTool extends BaseTool {
      * state).
      */
     protected buildVertexAiSearchConfig(_readonlyContext: ReadonlyContext): VertexAISearchConfig;
-    processLlmRequest({ toolContext, llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+    protected applyBuiltInConfig({ toolContext, llmRequest, }: ToolProcessLlmRequest): Promise<void>;
 }

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

@@ -4,7 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { VertexRagStore } from '@google/genai';
-import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+import { ToolProcessLlmRequest } from './base_tool.js';
+import { BuiltInTool } from './built_in_tool.js';
 /**
  * A tool that retrieves relevant content from a Vertex AI RAG corpus to ground
  * model responses.
@@ -19,24 +20,24 @@ import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
  *
  * @example
  * ```ts
- * import { VertexRagRetrievalTool } from '@google/adk';
- * import { VertexRagStore } from '@google/genai';
+ * import {LlmAgent, VertexRagRetrievalTool} from '@google/adk';
  *
  * const ragTool = new VertexRagRetrievalTool({
- *   ragResources: [{ragCorpus: 'projects/my-project/locations/us-central1/ragCorpora/my-corpus'}],
+ *   ragResources: [
+ *     {ragCorpus: 'projects/my-project/locations/us-central1/ragCorpora/my-corpus'},
+ *   ],
  *   similarityTopK: 5,
  * });
  *
- * const agent = new LlmAgent({ tools: [ragTool], ... });
+ * const agent = new LlmAgent({
+ *   name: 'rag_agent',
+ *   model: 'gemini-2.5-flash',
+ *   tools: [ragTool],
+ * });
  * ```
  */
-export declare class VertexRagRetrievalTool extends BaseTool {
+export declare class VertexRagRetrievalTool extends BuiltInTool {
     private readonly vertexRagStore;
     constructor(config: VertexRagStore);
-    /**
-     * This tool is executed server-side by the Vertex AI RAG Engine.
-     * Local execution is not required.
-     */
-    runAsync(): Promise<unknown>;
-    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+    protected applyBuiltInConfig({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
 }

package/dist/types/tools/webmcp/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * `@google/adk/tools/webmcp` subpath: the WebMCP tools only, without the full
+ * ADK barrel. Also re-exported from `@google/adk`.
+ */
+export * from './webmcp_tool.js';
+export * from './webmcp_toolset.js';
+export * from './webmcp_types.js';

package/dist/types/tools/webmcp/webmcp_tool.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
+import { WebMCPDocument, WebMCPRegisteredTool } from './webmcp_types.js';
+/** Parameters for {@link WebMCPTool}. */
+export interface WebMCPToolParams {
+    /** The tool as reported by `document.modelContext.getTools()`. */
+    tool: WebMCPRegisteredTool;
+    /**
+     * Overrides the name exposed to the model, which the toolset uses to apply
+     * its prefix. Defaults to the tool's own name.
+     */
+    name?: string;
+    /** Document to read `modelContext` from. Defaults to the global document. */
+    document?: WebMCPDocument;
+}
+/**
+ * A tool registered by the page on `document.modelContext`.
+ *
+ * Converts the tool's JSON Schema into a Gemini `FunctionDeclaration` and
+ * executes it through `document.modelContext.executeTool()`, so the page runs
+ * its own handler and updates its own UI.
+ *
+ * A tool annotated `consequentialHint` reports itself as requiring
+ * confirmation, so significant page actions flow through ADK's existing tool
+ * confirmation rather than firing unprompted.
+ */
+export declare class WebMCPTool extends BaseTool {
+    readonly webmcpTool: WebMCPRegisteredTool;
+    private readonly doc?;
+    constructor(params: WebMCPToolParams);
+    /**
+     * The tool's JSON Schema as an object.
+     *
+     * `inputSchema` is specified as an object, but a browser handing back a JSON
+     * string would otherwise convert to a parameterless declaration, leaving the
+     * model no argument names to fill in — it then calls the tool with `{}`.
+     */
+    private resolveInputSchema;
+    _getDeclaration(): FunctionDeclaration;
+    checkRequireConfirmation(): Promise<boolean>;
+    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+}

package/dist/types/tools/webmcp/webmcp_toolset.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { BaseTool } from '../base_tool.js';
+import { BaseToolset, ToolPredicate } from '../base_toolset.js';
+import { WebMCPDocument } from './webmcp_types.js';
+/** Options for {@link WebMCPToolset}. */
+export interface WebMCPToolsetOptions {
+    /** Restricts which tools reach the model, by name or predicate. */
+    toolFilter?: ToolPredicate | string[];
+    /** Prefixes every discovered tool name with `${prefix}_`. */
+    prefix?: string;
+    /**
+     * Secure origins to also collect tools from, for cross-origin iframes. A
+     * cross-origin tool is only returned if its page also exposed it to this
+     * origin via `exposedTo`.
+     */
+    fromOrigins?: string[];
+    /** Document to read `modelContext` from. Defaults to the global document. */
+    document?: WebMCPDocument;
+}
+/**
+ * A toolset backed by the tools a web page registers with WebMCP.
+ *
+ * WebMCP lets a page declare typed, callable tools on `document.modelContext`.
+ * This toolset surfaces them to an in-browser agent, so the agent drives the
+ * page through the handlers it published instead of scraping the DOM. Each
+ * tool's own `execute` runs in the page, so its UI updates as a side effect.
+ *
+ * Unlike {@link MCPToolset}, nothing is transported anywhere: discovery and
+ * execution are same-document browser calls.
+ *
+ * Outside a browser, or in a browser without WebMCP, `getTools()` returns an
+ * empty array rather than throwing, so this is safe to construct anywhere.
+ *
+ * @example
+ * ```ts
+ * import {LlmAgent} from '@google/adk';
+ * import {WebMCPToolset} from '@google/adk/tools/webmcp';
+ *
+ * const agent = new LlmAgent({
+ *   name: 'page_agent',
+ *   model: 'gemini-3.8-live',
+ *   tools: [new WebMCPToolset()],
+ * });
+ * ```
+ *
+ * @see https://developer.chrome.com/docs/ai/webmcp
+ */
+export declare class WebMCPToolset extends BaseToolset {
+    private readonly doc?;
+    private readonly fromOrigins?;
+    private readonly changeListeners;
+    constructor(options?: WebMCPToolsetOptions);
+    /** Whether this document exposes WebMCP. */
+    isSupported(): boolean;
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    /**
+     * Subscribes to the WebMCP `toolchange` event, which fires when the page
+     * registers or removes tools. Returns an unsubscribe function.
+     */
+    onToolChange(listener: () => void): () => void;
+    close(): Promise<void>;
+}