@softactivate/adk 1.1.0

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

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration, Schema } from '@google/genai';
+import { z as z3 } from 'zod/v3';
+import { z as z4 } from 'zod/v4';
+import { Context } from '../agents/context.js';
+import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
+/**
+ * Input parameters of the function tool.
+ */
+export type ToolInputParameters = z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape> | Schema | undefined;
+export type ToolExecuteArgument<TParameters extends ToolInputParameters> = TParameters extends z3.ZodObject<infer T, infer U, infer V> ? z3.infer<z3.ZodObject<T, U, V>> : TParameters extends z4.ZodObject<infer T> ? z4.infer<z4.ZodObject<T>> : TParameters extends Schema ? unknown : string;
+export type ToolExecuteFunction<TParameters extends ToolInputParameters> = (input: ToolExecuteArgument<TParameters>, tool_context?: Context) => Promise<unknown> | unknown;
+/**
+ * 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.
+ */
+export type ToolOptions<TParameters extends ToolInputParameters> = {
+    name?: string;
+    description: string;
+    parameters?: TParameters;
+    execute: ToolExecuteFunction<TParameters>;
+    isLongRunning?: boolean;
+};
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all BaseTool instances.
+ */
+declare const FUNCTION_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of BaseTool.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of BaseTool, false otherwise.
+ */
+export declare function isFunctionTool(obj: unknown): obj is FunctionTool;
+export declare class FunctionTool<TParameters extends ToolInputParameters = undefined> extends BaseTool {
+    /** A unique symbol to identify ADK function tool class. */
+    readonly [FUNCTION_TOOL_SIGNATURE_SYMBOL] = true;
+    private readonly execute;
+    private readonly parameters?;
+    /**
+     * The constructor acts as the user-friendly factory.
+     * @param options The configuration for the tool.
+     */
+    constructor(options: ToolOptions<TParameters>);
+    /**
+     * Provide a schema for the function.
+     */
+    _getDeclaration(): FunctionDeclaration;
+    /**
+     * Logic for running the tool.
+     */
+    runAsync(req: RunAsyncToolRequest): Promise<unknown>;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { LlmRequest } from '../models/llm_request.js';
+import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * Applies Google Maps grounding to the LLM request if supported.
+ */
+export declare function applyGoogleMapsGrounding(llmRequest: LlmRequest): void;
+/**
+ * A built-in tool that is automatically invoked by Gemini 2 models to ground
+ * query results with Google Maps.
+ *
+ * This tool operates internally within the model and does not require or
+ * perform local code execution.
+ */
+export declare class GoogleMapsGroundingTool extends BaseTool {
+    constructor();
+    runAsync(): Promise<unknown>;
+    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link GoogleMapsGroundingTool}.
+ */
+export declare const GOOGLE_MAPS_GROUNDING: GoogleMapsGroundingTool;

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

@@ -0,0 +1,17 @@
+import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A built-in tool that is automatically invoked by Gemini 2 models to retrieve
+ * search results from Google Search.
+ *
+ * This tool operates internally within the model and does not require or
+ * perform local code execution.
+ */
+export declare class GoogleSearchTool extends BaseTool {
+    constructor();
+    runAsync(): Promise<unknown>;
+    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link GoogleSearchTool}.
+ */
+export declare const GOOGLE_SEARCH: GoogleSearchTool;

package/dist/types/tools/load_artifacts_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, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that loads the artifacts and adds them to the session.
+ */
+export declare class LoadArtifactsTool extends BaseTool {
+    constructor();
+    _getDeclaration(): FunctionDeclaration | undefined;
+    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+    private appendArtifactsToLlmRequest;
+}
+/**
+ * A global instance of {@link LoadArtifactsTool}.
+ */
+export declare const LOAD_ARTIFACTS: LoadArtifactsTool;

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

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that loads the memory for the current user.
+ *
+ * NOTE: Currently this tool only uses text part from the memory.
+ */
+export declare class LoadMemoryTool extends BaseTool {
+    constructor();
+    _getDeclaration(): FunctionDeclaration | undefined;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link LoadMemoryTool}.
+ */
+export declare const LOAD_MEMORY: LoadMemoryTool;

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

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { FunctionTool, ToolInputParameters, ToolOptions } from './function_tool.js';
+export declare class LongRunningFunctionTool<TParameters extends ToolInputParameters = undefined> extends FunctionTool<TParameters> {
+    /**
+     * The constructor acts as the user-friendly factory.
+     * @param options The configuration for the tool.
+     */
+    constructor(options: ToolOptions<TParameters>);
+    /**
+     * Provide a schema for the function.
+     */
+    _getDeclaration(): FunctionDeclaration;
+}

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

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+/**
+ * Defines the parameters for establishing a connection to an MCP server using
+ * standard input/output (stdio). This is typically used for running MCP servers
+ * as local child processes.
+ */
+export interface StdioConnectionParams {
+    type: 'StdioConnectionParams';
+    serverParams: StdioServerParameters;
+    timeout?: number;
+}
+/**
+ * Defines the parameters for establishing a connection to an MCP server over
+ * HTTP using Server-Sent Events (SSE) for streaming.
+ *
+ * Usage:
+ *  const connectionParams: StreamableHTTPConnectionParams = {
+ *    type: 'StreamableHTTPConnectionParams',
+ *    url: 'http://localhost:8788/mcp'
+ *  };
+ */
+export interface StreamableHTTPConnectionParams {
+    type: 'StreamableHTTPConnectionParams';
+    url: string;
+    /**
+     * @deprecated
+     * Use transportOptions.requestInit.headers instead.
+     * This field will be ignored if transportOptions is provided even if no headers are specified in transportOptions.
+     */
+    header?: Record<string, unknown>;
+    timeout?: number;
+    sseReadTimeout?: number;
+    terminateOnClose?: boolean;
+    transportOptions?: StreamableHTTPClientTransportOptions;
+}
+/**
+ * A union of all supported MCP connection parameter types.
+ */
+export type MCPConnectionParams = StdioConnectionParams | StreamableHTTPConnectionParams;
+/**
+ * Manages Model Context Protocol (MCP) client sessions.
+ *
+ * This class is responsible for establishing and managing connections to MCP
+ * servers. It supports different transport protocols like Standard I/O (Stdio)
+ * and Server-Sent Events (SSE) over HTTP, determined by the provided
+ * connection parameters.
+ *
+ * The primary purpose of this manager is to abstract away the details of
+ * session creation and connection handling, providing a simple interface for
+ * creating new MCP client instances that can be used to interact with
+ * remote tools.
+ */
+export declare class MCPSessionManager {
+    private readonly connectionParams;
+    constructor(connectionParams: MCPConnectionParams);
+    createSession(): Promise<Client>;
+}

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

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
+import { MCPSessionManager } from './mcp_session_manager.js';
+/**
+ * Represents a tool exposed via the Model Context Protocol (MCP).
+ *
+ * This class acts as a wrapper around a tool definition received from an MCP
+ * server. It translates the MCP tool's schema into a format compatible with
+ * the Gemini AI platform (FunctionDeclaration) and handles the remote
+ * execution of the tool by communicating with the MCP server through an
+ * {@link MCPSessionManager}.
+ *
+ * When an LLM decides to call this tool, the `runAsync` method will be
+ * invoked, which in turn establishes an MCP session, sends a `callTool`
+ * request with the provided arguments, and returns the result from the
+ * remote tool.
+ *
+ * The originalName parameter allows the tool to track the native tool name
+ * exposed by the MCP server. This is critical when the toolset applies a
+ * prefix to tool names (e.g., for LLM namespace disambiguation), ensuring
+ * the correct original name is used when executing on the server.
+ */
+export declare class MCPTool extends BaseTool {
+    private readonly mcpTool;
+    private readonly mcpSessionManager;
+    private readonly originalName;
+    constructor(mcpTool: Tool, mcpSessionManager: MCPSessionManager, originalName?: string);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+}

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

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2025 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 { MCPConnectionParams } from './mcp_session_manager.js';
+/**
+ * A toolset that dynamically discovers and provides tools from a Model Context
+ * Protocol (MCP) server.
+ *
+ * This class connects to an MCP server, retrieves the list of available tools,
+ * and wraps each of them in an {@link MCPTool} instance. This allows the agent
+ * to seamlessly use tools from an external MCP-compliant service.
+ *
+ * The toolset can be configured with a filter to selectively expose a subset
+ * of the tools provided by the MCP server.
+ *
+ * It can also be configured with a prefix. If provided, all tools discovered
+ * from the MCP server will have their names prefixed with `${prefix}_`. When the
+ * 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';
+ *
+ *   const connectionParams = StreamableHTTPConnectionParamsSchema.parse({
+ *     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;
+    constructor(connectionParams: MCPConnectionParams, toolFilter?: ToolPredicate | string[], prefix?: string);
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * 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
+ * called by the model.
+ *
+ * NOTE: Currently this tool only uses text part from the memory.
+ */
+export declare class PreloadMemoryTool extends BaseTool {
+    constructor();
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link PreloadMemoryTool}.
+ */
+export declare const PRELOAD_MEMORY: PreloadMemoryTool;

package/dist/types/tools/skill/list_skills_tool.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
+import { SkillToolset } from './skill_toolset.js';
+export declare class ListSkillsTool extends BaseTool {
+    private toolset;
+    constructor(toolset: SkillToolset);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync(_request: RunAsyncToolRequest): Promise<unknown>;
+}

package/dist/types/tools/skill/load_skill_resource_tool.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from '../base_tool.js';
+import { SkillToolset } from './skill_toolset.js';
+export declare class LoadSkillResourceTool extends BaseTool {
+    private toolset;
+    constructor(toolset: SkillToolset);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+}

package/dist/types/tools/skill/load_skill_tool.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
+import { SkillToolset } from './skill_toolset.js';
+export declare class LoadSkillTool extends BaseTool {
+    private toolset;
+    constructor(toolset: SkillToolset);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+}

package/dist/types/tools/skill/run_skill_inline_script_tool.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
+import { SkillToolset } from './skill_toolset.js';
+export declare class RunSkillInlineScriptTool extends BaseTool {
+    private toolset;
+    constructor(toolset: SkillToolset);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+}

package/dist/types/tools/skill/run_skill_script_tool.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { File } from '../../code_executors/code_execution_utils.js';
+import { Skill } from '../../skills/skill.js';
+import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
+import { SkillToolset } from './skill_toolset.js';
+export declare class RunSkillScriptTool extends BaseTool {
+    private toolset;
+    constructor(toolset: SkillToolset);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+}
+export declare function getSkillResourceFiles(skill: Skill): File[];

package/dist/types/tools/skill/skill_toolset.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Context } from '../../agents/context.js';
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { BaseCodeExecutor } from '../../code_executors/base_code_executor.js';
+import { LlmRequest } from '../../models/llm_request.js';
+import { Skill } from '../../skills/skill.js';
+import { BaseTool } from '../base_tool.js';
+import { BaseToolset } from '../base_toolset.js';
+export declare class SkillToolset extends BaseToolset {
+    skills: Record<string, Skill>;
+    private tools;
+    additionalTools: Array<BaseTool | BaseToolset>;
+    codeExecutor?: BaseCodeExecutor;
+    private toolCache;
+    constructor(skills: Record<string, Skill> | Skill[], options?: {
+        codeExecutor?: BaseCodeExecutor;
+        additionalTools?: Array<BaseTool | BaseToolset>;
+    });
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    close(): Promise<void>;
+    getSkill(name: string): Skill | undefined;
+    processLlmRequest(toolContext: Context, llmRequest: LlmRequest): Promise<void>;
+    private resolveAdditionalTools;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents a tool confirmation configuration.
+ * @experimental  (Experimental, subject to change)
+ */
+export declare class ToolConfirmation {
+    /** The hint text for why the input is needed. */
+    hint: string;
+    /** Whether the tool execution is confirmed. */
+    confirmed: boolean;
+    /**
+     * The custom data payload needed from the user to continue the flow.
+     * It should be JSON serializable.
+     */
+    payload?: unknown;
+    constructor({ hint, confirmed, payload, }: {
+        hint?: string;
+        confirmed: boolean;
+        payload?: unknown;
+    });
+}

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

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

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

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ReadonlyContext } from '../agents/readonly_context.js';
+import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+export interface VertexAISearchDataStoreSpec {
+    dataStore?: string;
+}
+export interface VertexAISearchConfig {
+    datastore?: string;
+    dataStoreSpecs?: VertexAISearchDataStoreSpec[];
+    engine?: string;
+    filter?: string;
+    maxResults?: number;
+}
+export interface BaseVertexAiSearchToolParams {
+    filter?: string;
+    maxResults?: number;
+    bypassMultiToolsLimit?: boolean;
+}
+export interface DataStoreParams extends BaseVertexAiSearchToolParams {
+    dataStoreId: string;
+    searchEngineId?: never;
+    dataStoreSpecs?: never;
+}
+export interface SearchEngineParams extends BaseVertexAiSearchToolParams {
+    searchEngineId: string;
+    dataStoreId?: never;
+    dataStoreSpecs?: VertexAISearchDataStoreSpec[];
+}
+export type VertexAiSearchToolParams = DataStoreParams | SearchEngineParams;
+/**
+ * A built-in tool using Vertex AI Search.
+ */
+export declare class VertexAiSearchTool extends BaseTool {
+    readonly dataStoreId?: string;
+    readonly dataStoreSpecs?: VertexAISearchDataStoreSpec[];
+    readonly searchEngineId?: string;
+    readonly filter?: string;
+    readonly maxResults?: number;
+    readonly bypassMultiToolsLimit: boolean;
+    constructor(params: VertexAiSearchToolParams);
+    runAsync(): Promise<unknown>;
+    /**
+     * Builds the VertexAISearch configuration.
+     *
+     * Override this method in a subclass to dynamically customize the search
+     * configuration based on the context (e.g., set filter based on session
+     * state).
+     */
+    protected buildVertexAiSearchConfig(_readonlyContext: ReadonlyContext): VertexAISearchConfig;
+    processLlmRequest({ toolContext, llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+}

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

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { VertexRagStore } from '@google/genai';
+import { BaseTool, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that retrieves relevant content from a Vertex AI RAG corpus to ground
+ * model responses.
+ *
+ * This tool operates server-side; it modifies the LLM request config to enable
+ * RAG retrieval via the `retrieval.vertexRagStore` field and does not perform
+ * local code execution.
+ *
+ * **Note:** The Vertex AI RAG Engine only supports one corpus per
+ * `ragResources` array. Create one `VertexRagRetrievalTool` instance per
+ * corpus.
+ *
+ * @example
+ * ```ts
+ * import { VertexRagRetrievalTool } from '@google/adk';
+ * import { VertexRagStore } from '@google/genai';
+ *
+ * const ragTool = new VertexRagRetrievalTool({
+ *   ragResources: [{ragCorpus: 'projects/my-project/locations/us-central1/ragCorpora/my-corpus'}],
+ *   similarityTopK: 5,
+ * });
+ *
+ * const agent = new LlmAgent({ tools: [ragTool], ... });
+ * ```
+ */
+export declare class VertexRagRetrievalTool extends BaseTool {
+    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>;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns the current list of client labels that can be added to HTTP Headers.
+ */
+export declare function getClientLabels(): string[];

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

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns true if the environment is a browser.
+ */
+export declare function isBrowser(): boolean;
+export declare function randomUUID(): string;
+/**
+ * Encodes the given string to base64.
+ *
+ * @param data The string to encode.
+ * @return The base64-encoded string.
+ */
+export declare function base64Encode(data: string): string;
+/**
+ * Decodes the given base64 string to a string.
+ *
+ * @param data The base64-encoded string.
+ * @return The decoded string.
+ */
+export declare function base64Decode(data: string): string;
+/**
+ * Checks if the given string is base64-encoded.
+ *
+ * @param data The string to check.
+ * @return True if the string is base64-encoded, false otherwise.
+ */
+export declare function isBase64Encoded(data: string): boolean;
+/**
+ * Gets the boolean value of the given environment variable.
+ *
+ * @param envVar The environment variable to get the value of.
+ * @return The boolean value of the environment variable.
+ */
+export declare function getBooleanEnvVar(envVar: string): boolean;

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

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Decorator to mark classes and methods as experimental.
+ * Logs a warning once per item when the class is instantiated or the method is called.
+ */
+export type Constructor = new (...args: unknown[]) => any;
+export declare function experimental<T extends Constructor | object, P extends string | symbol | undefined = undefined>(target: T, propertyKey?: P, descriptor?: PropertyDescriptor): P extends undefined ? T : PropertyDescriptor;