@google/adk 2.0.0 → 2.1.0

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

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseTool, IN_MODEL_TOOL_SYMBOL, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool the model runs itself. It is switched on through request parameters
+ * — Google Search, URL context, the grounding and retrieval tools — and never
+ * executes here.
+ *
+ * Such a tool has no function declaration, so `BaseTool.processLlmRequest`
+ * returns before the line that registers it in `llmRequest.toolsDict`. That
+ * left the model primed with a name the framework could not route: a model
+ * that returns one as an explicit function call, rather than running it,
+ * produced a call that failed to resolve even though the user had registered
+ * the tool. Registering the name here keeps the call resolvable, and
+ * `runAsync` answers it by telling the model the tool is not callable.
+ *
+ * A tool whose `applyBuiltInConfig` returns without configuring anything —
+ * every one of them does when the request carries no model — still claims its
+ * name. That request never reaches a model, so no function call can come back
+ * for it and the registration is inert.
+ */
+export declare abstract class BuiltInTool extends BaseTool {
+    /** Marks this tool as one the model runs itself. */
+    readonly [IN_MODEL_TOOL_SYMBOL] = true;
+    /**
+     * Adds this tool's configuration to the request.
+     *
+     * @param request The request to process the LLM request.
+     */
+    protected abstract applyBuiltInConfig(request: ToolProcessLlmRequest): Promise<void>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+    /**
+     * Answers a function call the model should not have made. The tool is
+     * already configured on the request and its results arrive as grounding
+     * metadata, so the model is told to use those rather than call again.
+     */
+    runAsync(): Promise<unknown>;
+}

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

@@ -1,5 +1,6 @@
 import { LlmRequest } from '../models/llm_request.js';
-import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+import { ToolProcessLlmRequest } from './base_tool.js';
+import { BuiltInTool } from './built_in_tool.js';
 /**
  * Appends the Enterprise Web Search built-in tool to the LLM request when the
  * target model supports it.
@@ -15,10 +16,9 @@ export declare function applyEnterpriseWebSearch(llmRequest: LlmRequest): void;
  * This tool operates internally within the model and does not require or
  * perform local code execution.
  */
-export declare class EnterpriseWebSearchTool extends BaseTool {
+export declare class EnterpriseWebSearchTool extends BuiltInTool {
     constructor();
-    runAsync(): Promise<unknown>;
-    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+    protected applyBuiltInConfig({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
 }
 /**
  * A global instance of {@link EnterpriseWebSearchTool}.

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

@@ -4,21 +4,34 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Part } from '@google/genai';
-import { ArtifactVersion, BaseArtifactService, DeleteArtifactRequest, ListArtifactKeysRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from '../artifacts/base_artifact_service.js';
+import { ArtifactVersion } from '../artifacts/base_artifact_service.js';
+import { SessionArtifactService, SessionLoadArtifactRequest, SessionSaveArtifactRequest } from '../artifacts/session_artifact_service.js';
 import { Context } from '../agents/context.js';
+/**
+ * A unique symbol to identify session-scoped artifact services.
+ *
+ * Resolves to the same symbol as the one used by `isSessionArtifactService` in
+ * `session_artifact_service.ts` because `Symbol.for` looks up the global
+ * symbol registry.
+ */
+declare const SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL: unique symbol;
 /**
  * Artifact service that forwards to the parent tool context.
  */
-export declare class ForwardingArtifactService implements BaseArtifactService {
+export declare class ForwardingArtifactService implements SessionArtifactService {
     private readonly toolContext;
-    private readonly invocationContext;
+    /**
+     * Brands this class as a session-scoped artifact service.
+     */
+    readonly [SESSION_ARTIFACT_SERVICE_SIGNATURE_SYMBOL] = true;
     constructor(toolContext: Context);
-    saveArtifact(request: SaveArtifactRequest): Promise<number>;
-    loadArtifact(request: LoadArtifactRequest): Promise<Part | undefined>;
-    listArtifactKeys(_request: ListArtifactKeysRequest): Promise<string[]>;
+    saveArtifact(request: SessionSaveArtifactRequest): Promise<number>;
+    loadArtifact(request: SessionLoadArtifactRequest): Promise<Part | undefined>;
+    listArtifactKeys(): Promise<string[]>;
     private getArtifactService;
-    deleteArtifact(request: DeleteArtifactRequest): Promise<void>;
-    listVersions(request: ListVersionsRequest): Promise<number[]>;
-    listArtifactVersions(request: ListVersionsRequest): Promise<ArtifactVersion[]>;
-    getArtifactVersion(request: LoadArtifactRequest): Promise<ArtifactVersion | undefined>;
+    deleteArtifact(filename: string): Promise<void>;
+    listVersions(filename: string): Promise<number[]>;
+    listArtifactVersions(filename: string): Promise<ArtifactVersion[]>;
+    getArtifactVersion(request: SessionLoadArtifactRequest): Promise<ArtifactVersion | undefined>;
 }
+export {};

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

@@ -29,11 +29,31 @@ export type ToolExecuteFunction<TParameters extends ToolInputParameters> = (inpu
 export type RequireConfirmation<TParameters extends ToolInputParameters> = boolean | ((input: ToolExecuteArgument<TParameters>, toolContext?: Context) => boolean | Promise<boolean>);
 /**
  * The configuration options for creating a function-based tool.
- * The `name`, `description` and `parameters` fields are used to generate the
- * tool definition that is passed to the LLM prompt.
  *
- * Note: Unlike Python's ADK, JSDoc on the `execute` function is ignored
- * for tool definition generation.
+ * What the model is shown about the tool is built from these options: `name`,
+ * `description` and the `parameters` schema become its function declaration.
+ * TypeScript types and JSDoc are erased at runtime and cannot be read back, so
+ * `description` is required and per-argument descriptions have to live in the
+ * schema — typically as Zod `.describe()` calls.
+ *
+ * ```ts
+ * new FunctionTool({
+ *   name: 'get_weather',
+ *   description: 'Returns the current weather for a city.',
+ *   parameters: z.object({
+ *     city: z.string().describe('City name, e.g. "San Francisco".'),
+ *   }),
+ *   execute: async ({city}) => fetchWeather(city),
+ * });
+ * ```
+ *
+ * A subclass may add to the declaration it derives from these options: given
+ * the identical options, {@link LongRunningFunctionTool} appends a sentence to
+ * `description` telling the model not to re-invoke a call that is still in
+ * flight.
+ *
+ * `parameters` is a description for the model, and only a Zod object schema is
+ * additionally enforced at call time — see {@link FunctionTool.runAsync}.
  */
 export type ToolOptions<TParameters extends ToolInputParameters> = {
     name?: string;
@@ -74,10 +94,20 @@ export declare function isFunctionTool(obj: unknown): obj is FunctionTool;
 /**
  * A tool that wraps a user-defined function, making it callable by an LLM.
  *
- * The function's name, description, and parameter schema are exposed to the
+ * The tool's name, description, and parameter schema are exposed to the
  * model as a function declaration. When the model requests a call, the
- * framework validates the arguments and invokes the user-provided `execute`
- * callback.
+ * framework invokes the user-provided `execute` callback with the arguments
+ * the model produced.
+ *
+ * Those arguments are checked only when `parameters` is a Zod object schema:
+ * it is applied with `parse()`, so a call that does not match is rejected and
+ * `execute` receives the parsed value. Keys the schema does not declare are
+ * handled however that schema says: a plain `z.object()` drops them,
+ * `.passthrough()` forwards them, `.strict()` rejects the call. A plain
+ * genai `Schema`, or no `parameters` at all, is shown to the model but is not
+ * a runtime guard — the arguments reach `execute` exactly as the model
+ * produced them, wrong types and extra keys included. Validate them inside
+ * `execute` on that path.
  */
 export declare class FunctionTool<TParameters extends ToolInputParameters = undefined> extends BaseTool {
     /** A unique symbol to identify ADK function tool class. */
@@ -96,11 +126,14 @@ export declare class FunctionTool<TParameters extends ToolInputParameters = unde
      */
     _getDeclaration(): FunctionDeclaration;
     /**
-     * Validates the model-provided arguments against the parameter schema and
-     * invokes the user-defined `execute` function.
+     * Invokes the user-defined `execute` function with the model-provided
+     * arguments, after parsing them when `parameters` is a Zod object schema.
+     * Any other `parameters` value is passed through unchecked.
      *
      * @param req The tool request containing arguments and tool context.
      * @returns A promise resolving to the function's return value.
+     * @throws {Error} Wrapped as `Error in tool '<name>': …` when a Zod
+     *     `parameters` schema rejects the arguments or `execute` throws.
      */
     runAsync(req: RunAsyncToolRequest): Promise<unknown>;
     /**

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

@@ -1,5 +1,6 @@
 import { LlmRequest } from '../models/llm_request.js';
-import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+import { ToolProcessLlmRequest } from './base_tool.js';
+import { BuiltInTool } from './built_in_tool.js';
 /**
  * Applies Google Maps grounding to the LLM request if supported.
  */
@@ -11,10 +12,9 @@ export declare function applyGoogleMapsGrounding(llmRequest: LlmRequest): void;
  * This tool operates internally within the model and does not require or
  * perform local code execution.
  */
-export declare class GoogleMapsGroundingTool extends BaseTool {
+export declare class GoogleMapsGroundingTool extends BuiltInTool {
     constructor();
-    runAsync(): Promise<unknown>;
-    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+    protected applyBuiltInConfig({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
 }
 /**
  * A global instance of {@link GoogleMapsGroundingTool}.

package/dist/types/tools/google_search_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 is automatically invoked by Gemini 2 models to retrieve
  * search results from Google Search.
@@ -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 GoogleSearchTool extends BaseTool {
+export declare class GoogleSearchTool extends BuiltInTool {
     constructor();
-    runAsync(): Promise<unknown>;
-    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+    protected applyBuiltInConfig({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
 }
 /**
  * A global instance of {@link GoogleSearchTool}.

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

@@ -10,7 +10,7 @@ import { FunctionTool, ToolInputParameters, ToolOptions } from './function_tool.
  * asynchronously.
  *
  * The framework invokes the user-provided function and delivers the response
- * back to the model once it completes, identified by the `function_call_id`.
+ * back to the model once it completes, matched up by the function call's `id`.
  * The model is also instructed not to re-invoke the tool while a call is
  * already in flight.
  */

package/dist/types/tools/mcp/mcp_toolset.d.ts

@@ -24,18 +24,19 @@ import { MCPConnectionParams } from './mcp_session_manager.js';
  * LLM invokes the prefixed tool, this toolset transparently strips the prefix
  * before sending the request to the underlying MCP server.
  *
- * Usage:
- *   import { MCPToolset } from '@google/adk';
- *   import { StreamableHTTPConnectionParamsSchema } from '@google/adk';
+ * @example
+ * ```ts
+ * import {MCPToolset} from '@google/adk';
+ * import type {StreamableHTTPConnectionParams} from '@google/adk';
  *
- *   const connectionParams = StreamableHTTPConnectionParamsSchema.parse({
- *     type: "StreamableHTTPConnectionParams",
- *     url: "http://localhost:8788/mcp"
- *   });
- *
- *   const mcpToolset = new MCPToolset(connectionParams);
- *   const tools = await mcpToolset.getTools();
+ * const connectionParams: StreamableHTTPConnectionParams = {
+ *   type: 'StreamableHTTPConnectionParams',
+ *   url: 'http://localhost:8788/mcp',
+ * };
  *
+ * const mcpToolset = new MCPToolset(connectionParams);
+ * const tools = await mcpToolset.getTools();
+ * ```
  */
 export declare class MCPToolset extends BaseToolset {
     private readonly mcpSessionManager;

package/dist/types/tools/openapi_tool/auth/auth_helpers.d.ts

@@ -8,11 +8,16 @@ import { AuthCredential } from '../../../auth/auth_credential.js';
 /**
  * Applies the given credential to the request headers and URL.
  *
+ * An HTTP credential that carries no usable token throws, so the caller never
+ * sends an unauthenticated request in place of an authenticated one.
+ *
  * @param url The target URL.
  * @param headers The request headers.
  * @param credential The auth credential.
  * @param authScheme The auth scheme from OpenAPI spec.
  * @returns The updated URL (if modified by query params).
+ * @throws {Error} If an HTTP credential holds basic credentials, or holds no
+ *   credentials at all.
  */
 export declare function applyCredential(url: string, headers: Record<string, string>, credential?: AuthCredential, authScheme?: OpenAPIV3.SecuritySchemeObject): string;
 /**

package/dist/types/tools/openapi_tool/auth/credential_exchangers/auto_auth_credential_exchanger.d.ts

@@ -8,7 +8,6 @@ import { AuthScheme } from '../../../../auth/auth_schemes.js';
 import { BaseCredentialExchanger, ExchangeResult } from '../../../../auth/exchanger/base_credential_exchanger.js';
 /**
  * Automatically selects the appropriate credential exchanger based on the auth scheme.
- * Ported from Python implementation.
  */
 export declare class AutoAuthCredentialExchanger implements BaseCredentialExchanger {
     private exchangers;

package/dist/types/tools/openapi_tool/auth/credential_exchangers/service_account_exchanger.d.ts

@@ -8,7 +8,6 @@ import { AuthScheme } from '../../../../auth/auth_schemes.js';
 import { BaseCredentialExchanger, ExchangeResult } from '../../../../auth/exchanger/base_credential_exchanger.js';
 /**
  * Fetches credentials for Google Service Account.
- * Ported from Python implementation.
  */
 export declare class ServiceAccountCredentialExchanger implements BaseCredentialExchanger {
     exchange(params: {

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/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/utils/crypto_shim.d.ts

@@ -14,3 +14,19 @@
  * back to and the only correct move is to fail rather than degrade.
  */
 export declare function randomUUID(): string;
+/**
+ * Stand-in for `createHash`, reached from the PKCE helpers in
+ * `auth/oauth2/oauth2_utils.ts`.
+ *
+ * A PKCE code challenge needs a synchronous SHA-256, and the Web Crypto API
+ * offers none: `crypto.subtle.digest` is asynchronous, while `generateAuthUri`
+ * is called from synchronous public API. PKCE is therefore unavailable in the
+ * bundled web build, and this throws rather than emit an authorization request
+ * with a missing or forged challenge.
+ */
+export declare function createHash(_algorithm: string): never;
+/**
+ * Stand-in for `randomBytes`, reached when the PKCE helpers in
+ * `auth/oauth2/oauth2_utils.ts` generate a code verifier.
+ */
+export declare function randomBytes(_size: number): never;

package/dist/types/utils/gemini_schema_util.d.ts

@@ -4,12 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Schema } from '@google/genai';
-import { z } from 'zod';
-declare const MCPToolSchemaObject: z.ZodObject<{
-    type: z.ZodLiteral<"object">;
-    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    required: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-type MCPToolSchema = z.infer<typeof MCPToolSchemaObject>;
+type MCPToolSchema = {
+    type: 'object';
+    properties?: Record<string, unknown>;
+    required?: string[];
+};
 export declare function toGeminiSchema(mcpSchema?: MCPToolSchema): Schema | undefined;
 export {};