@google/adk 1.1.0 → 1.3.0

package/dist/types/sessions/vertex_ai_session_service.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Sessions } from '@google-cloud/vertexai/build/src/genai/sessions.js';
+import { Event } from '../events/event.js';
+import { AppendEventRequest, BaseSessionService, CreateSessionRequest, DeleteSessionRequest, GetSessionRequest, ListSessionsRequest, ListSessionsResponse } from './base_session_service.js';
+import { Session } from './session.js';
+/**
+ * Checks if the given URI is a Vertex AI session service URI.
+ */
+export declare function isVertexAiConnectionString(uri?: string): boolean;
+export interface VertexAiSessionServiceOptions {
+    projectId?: string;
+    location?: string;
+    agentEngineId?: string;
+    expressModeApiKey?: string;
+    sessions?: Sessions;
+}
+/**
+ * A session service implementation that integrates with Vertex AI Agent Engine Sessions.
+ */
+export declare class VertexAiSessionService extends BaseSessionService {
+    private sessions;
+    private agentEngineId?;
+    private expressModeApiKey?;
+    private projectId?;
+    private location?;
+    constructor(options: VertexAiSessionServiceOptions);
+    private getReasoningEngineId;
+    createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
+    getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
+    listSessions({ appName, userId, limit, offset, page, order, }: ListSessionsRequest): Promise<ListSessionsResponse>;
+    deleteSession({ appName, userId: _userId, sessionId, }: DeleteSessionRequest): Promise<void>;
+    appendEvent({ session, event, }: AppendEventRequest): Promise<Event>;
+}

package/dist/types/skills/gcp_skill_registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Client } from '@google-cloud/vertexai';
+import { Frontmatter, Skill } from './skill.js';
+import { SkillRegistry } from './skill_registry.js';
+export interface GCPSkillRegistryOptions {
+    projectId?: string;
+    location?: string;
+    client?: Client;
+}
+/**
+ * GCP implementation of SkillRegistry using GCP Skill Registry API.
+ */
+export declare class GCPSkillRegistry implements SkillRegistry {
+    private readonly projectId?;
+    private readonly location?;
+    private readonly client;
+    constructor(options?: GCPSkillRegistryOptions);
+    getSkill(name: string): Promise<Skill>;
+    searchSkills(query: string): Promise<Frontmatter[]>;
+}

package/dist/types/skills/loader.d.ts

@@ -36,3 +36,10 @@ export declare function validateSkillDir(skillDir: string): Promise<string[]>;
  * @returns A promise that resolves to a map of skill names to their corresponding Skill objects.
  */
 export declare function loadAllSkillsInDir(skillsBasePath: string): Promise<Record<string, Skill>>;
+/**
+ * Loads a complete skill directly from in-memory zip file buffer.
+ *
+ * @param zipBuffer - The raw Buffer of the zip file containing the skill.
+ * @returns A Skill object with all components loaded.
+ */
+export declare function loadSkillFromZipBuffer(zipBuffer: Buffer): Skill;

package/dist/types/skills/skill.d.ts

@@ -8,7 +8,7 @@ export declare const SNAKE_OR_KEBAB_NAME_PATTERN: RegExp;
 /**
  * Schema and Type for Skill Frontmatter metadata.
  */
-export declare const FrontmatterSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+export declare const FrontmatterSchema: z.ZodPreprocess<z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     license: z.ZodOptional<z.ZodString>;

package/dist/types/skills/skill_registry.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Frontmatter, Skill } from './skill.js';
+/**
+ * Interface for a skill registry.
+ */
+export interface SkillRegistry {
+    /**
+     * Fetches a skill from the registry.
+     *
+     * @param name The name of the skill.
+     * @returns A Promise resolving to a Skill object.
+     */
+    getSkill(name: string): Promise<Skill>;
+    /**
+     * Searches for skills in the registry.
+     *
+     * @param query The search query.
+     * @returns A Promise resolving to a list of Frontmatter objects for discovery.
+     */
+    searchSkills(query: string): Promise<Frontmatter[]>;
+    /**
+     * Returns the description for the search_skills tool.
+     */
+    searchToolDescription?(): string | undefined;
+}

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

@@ -14,8 +14,17 @@ import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
  *
  */
 export declare class ExitLoopTool extends BaseTool {
+    /** Creates an ExitLoopTool with its fixed name and description. */
     constructor();
+    /** Returns the function declaration for this tool. */
     _getDeclaration(): FunctionDeclaration;
+    /**
+     * Sets `escalate` and `skipSummarization` on the event actions, signalling
+     * the {@link LoopAgent} to stop iterating.
+     *
+     * @param request The tool request containing the current tool context.
+     * @returns An empty string response.
+     */
     runAsync({ toolContext, }: RunAsyncToolRequest): Promise<unknown>;
 }
 /**

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

@@ -12,7 +12,14 @@ 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;
+/**
+ * The arguments passed to the function tool's `execute` callback, inferred
+ * from the `parameters` schema type.
+ */
 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;
+/**
+ * The signature of the user-provided function executed by a {@link FunctionTool}.
+ */
 export type ToolExecuteFunction<TParameters extends ToolInputParameters> = (input: ToolExecuteArgument<TParameters>, tool_context?: Context) => Promise<unknown> | unknown;
 /**
  * The configuration options for creating a function-based tool.
@@ -40,6 +47,14 @@ declare const FUNCTION_TOOL_SIGNATURE_SYMBOL: unique symbol;
  * @returns True if the object is an instance of BaseTool, false otherwise.
  */
 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
+ * model as a function declaration. When the model requests a call, the
+ * framework validates the arguments and invokes the user-provided `execute`
+ * callback.
+ */
 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;
@@ -51,11 +66,16 @@ export declare class FunctionTool<TParameters extends ToolInputParameters = unde
      */
     constructor(options: ToolOptions<TParameters>);
     /**
-     * Provide a schema for the function.
+     * Returns the function declaration derived from the tool's name, description,
+     * and parameter schema.
      */
     _getDeclaration(): FunctionDeclaration;
     /**
-     * Logic for running the tool.
+     * Validates the model-provided arguments against the parameter schema and
+     * invokes the user-defined `execute` function.
+     *
+     * @param req The tool request containing arguments and tool context.
+     * @returns A promise resolving to the function's return value.
      */
     runAsync(req: RunAsyncToolRequest): Promise<unknown>;
 }

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

@@ -5,6 +5,15 @@
  */
 import { FunctionDeclaration } from '@google/genai';
 import { FunctionTool, ToolInputParameters, ToolOptions } from './function_tool.js';
+/**
+ * A {@link FunctionTool} for long-running operations whose result is returned
+ * 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`.
+ * The model is also instructed not to re-invoke the tool while a call is
+ * already in flight.
+ */
 export declare class LongRunningFunctionTool<TParameters extends ToolInputParameters = undefined> extends FunctionTool<TParameters> {
     /**
      * The constructor acts as the user-friendly factory.
@@ -12,7 +21,8 @@ export declare class LongRunningFunctionTool<TParameters extends ToolInputParame
      */
     constructor(options: ToolOptions<TParameters>);
     /**
-     * Provide a schema for the function.
+     * Returns the function declaration with an appended instruction warning the
+     * model not to re-invoke the tool while it is still running.
      */
     _getDeclaration(): FunctionDeclaration;
 }

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

@@ -59,6 +59,9 @@ export type MCPConnectionParams = StdioConnectionParams | StreamableHTTPConnecti
  */
 export declare class MCPSessionManager {
     private readonly connectionParams;
+    private readonly activeSessions;
     constructor(connectionParams: MCPConnectionParams);
     createSession(): Promise<Client>;
+    closeSession(client: Client): Promise<void>;
+    getActiveSessions(): Client[];
 }

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

@@ -3,6 +3,7 @@
  * 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';
@@ -38,6 +39,6 @@ import { MCPConnectionParams } from './mcp_session_manager.js';
 export declare class MCPToolset extends BaseToolset {
     private readonly mcpSessionManager;
     constructor(connectionParams: MCPConnectionParams, toolFilter?: ToolPredicate | string[], prefix?: string);
-    getTools(): Promise<BaseTool[]>;
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
     close(): Promise<void>;
 }

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

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+import { AuthCredential } from '../../../auth/auth_credential.js';
+/**
+ * Applies the given credential to the request headers and URL.
+ *
+ * @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).
+ */
+export declare function applyCredential(url: string, headers: Record<string, string>, credential?: AuthCredential, authScheme?: OpenAPIV3.SecuritySchemeObject): string;
+/**
+ * Helper to create a simple API Key auth scheme.
+ */
+export declare function createApiKeyScheme(name: string, inLocation: 'header' | 'query' | 'cookie'): OpenAPIV3.SecuritySchemeObject;
+/**
+ * Helper to create a simple Bearer Token auth scheme.
+ */
+export declare function createBearerScheme(): OpenAPIV3.SecuritySchemeObject;

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

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthCredential } from '../../../../auth/auth_credential.js';
+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;
+    constructor();
+    exchange(params: {
+        authScheme?: AuthScheme;
+        authCredential: AuthCredential;
+    }): Promise<ExchangeResult>;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AuthCredential } from '../../../../auth/auth_credential.js';
+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: {
+        authScheme?: AuthScheme;
+        authCredential: AuthCredential;
+    }): Promise<ExchangeResult>;
+    private exchangeForDefaultCredential;
+    private exchangeForExplicitCredential;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+import { ApiParameter } from './operation_parser.js';
+export interface OperationEndpoint {
+    baseUrl: string;
+    path: string;
+    method: string;
+}
+export interface ParsedOperation {
+    name: string;
+    description: string;
+    endpoint: OperationEndpoint;
+    operation: OpenAPIV3.OperationObject;
+    parameters: ApiParameter[];
+    returnValue?: ApiParameter;
+    authScheme?: OpenAPIV3.SecuritySchemeObject;
+}
+export declare class OpenApiSpecParser {
+    private preservePropertyNames;
+    constructor(options?: {
+        preservePropertyNames?: boolean;
+    });
+    /**
+     * Parses an OpenAPI specification document and extracts a list of operations.
+     *
+     * @param openapiSpec The OpenAPI V3 document to parse.
+     * @returns An array of parsed operations.
+     */
+    parse(openapiSpec: OpenAPIV3.Document): ParsedOperation[];
+}

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

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+export interface ApiParameter {
+    originalName: string;
+    paramLocation: string;
+    paramSchema: OpenAPIV3.SchemaObject;
+    description?: string;
+    name: string;
+    required: boolean;
+}
+/**
+ * Parses an OpenAPI OperationObject and extracts its parameters, request body, and return value.
+ *
+ * It maps OpenAPI parameters and request bodies into a flat list of `ApiParameter` objects
+ * that are compatible with Gemini's tool function declarations.
+ */
+export declare class OperationParser {
+    private readonly operation;
+    private params;
+    private returnValue?;
+    private preservePropertyNames;
+    constructor(operation: OpenAPIV3.OperationObject, options?: {
+        preservePropertyNames?: boolean;
+    });
+    private getParamName;
+    private processOperationParameters;
+    private processRequestBody;
+    private processReturnValue;
+    private dedupeParamNames;
+    /**
+     * Gets the list of parsed parameters extracted from the OpenAPI operation.
+     *
+     * @returns An array of parsed parameters.
+     */
+    getParameters(): ApiParameter[];
+    /**
+     * Generates a JSON schema representing the arguments of the tool function call.
+     *
+     * @returns A JSON Schema object.
+     */
+    getJsonSchema(): Record<string, unknown>;
+    /**
+     * Gets a valid tool function name derived from the operation's operationId.
+     *
+     * @throws {Error} If the operation does not have an operationId.
+     * @returns A string representing the function name.
+     */
+    getFunctionName(): string;
+    /**
+     * Gets the description of the tool, derived from the operation's description or summary.
+     *
+     * @returns A string representing the description.
+     */
+    getDescription(): string;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * 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';
+export interface AuthPreparationResult {
+    state: 'pending' | 'done';
+    authCredential?: AuthCredential;
+}
+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;
+    prepareAuthCredentials(): Promise<AuthPreparationResult>;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+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';
+export declare class OpenAPIToolset extends BaseToolset {
+    private tools;
+    constructor(options?: {
+        specDict?: OpenAPIV3.Document;
+        specStr?: string;
+        specType?: 'json' | 'yaml';
+        toolFilter?: ToolPredicate | string[];
+        prefix?: string;
+        preservePropertyNames?: boolean;
+        authScheme?: OpenAPIV3.SecuritySchemeObject;
+        authCredential?: AuthCredential;
+        credentialKey?: string;
+        headerProvider?: (context: ReadonlyContext) => Record<string, string>;
+    });
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+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 { OperationEndpoint } from './openapi_spec_parser/openapi_spec_parser.js';
+export declare class RestApiTool extends BaseTool {
+    private readonly endpoint;
+    private readonly operation;
+    private authScheme?;
+    private authCredential?;
+    private operationParser;
+    private headerProvider?;
+    private credentialKey?;
+    constructor(name: string, description: string, endpoint: OperationEndpoint, operation: OpenAPIV3.OperationObject, authScheme?: OpenAPIV3.SecuritySchemeObject | undefined, authCredential?: AuthCredential | undefined, options?: {
+        preservePropertyNames?: boolean;
+        headerProvider?: (context: ReadonlyContext) => Record<string, string>;
+        credentialKey?: string;
+    });
+    configureAuthScheme(authScheme: OpenAPIV3.SecuritySchemeObject): void;
+    configureAuthCredential(authCredential: AuthCredential): void;
+    configureCredentialKey(credentialKey: string): void;
+    _getDeclaration(): FunctionDeclaration;
+    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+}
+export interface PreparedParams {
+    url: string;
+    headers: Record<string, string>;
+    body: unknown;
+    bodyData: Record<string, unknown>;
+}
+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?: {
+    preservePropertyNames?: boolean;
+    headerProvider?: (context: ReadonlyContext) => Record<string, string>;
+    credentialKey?: string;
+}): RestApiTool;

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

@@ -10,6 +10,6 @@ export declare class LoadSkillResourceTool extends BaseTool {
     private toolset;
     constructor(toolset: SkillToolset);
     _getDeclaration(): FunctionDeclaration;
-    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
     processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
 }

package/dist/types/tools/skill/search_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 SearchSkillsTool extends BaseTool {
+    private toolset;
+    constructor(toolset: SkillToolset);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+}

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

@@ -8,6 +8,7 @@ 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 { SkillRegistry } from '../../skills/skill_registry.js';
 import { BaseTool } from '../base_tool.js';
 import { BaseToolset } from '../base_toolset.js';
 export declare class SkillToolset extends BaseToolset {
@@ -15,14 +16,18 @@ export declare class SkillToolset extends BaseToolset {
     private tools;
     additionalTools: Array<BaseTool | BaseToolset>;
     codeExecutor?: BaseCodeExecutor;
+    registry?: SkillRegistry;
     private toolCache;
+    private fetchedSkillCache;
     constructor(skills: Record<string, Skill> | Skill[], options?: {
         codeExecutor?: BaseCodeExecutor;
         additionalTools?: Array<BaseTool | BaseToolset>;
+        registry?: SkillRegistry;
     });
     getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
     close(): Promise<void>;
     getSkill(name: string): Skill | undefined;
+    getOrFetchSkill(name: string, invocationId?: string): Promise<Skill | undefined>;
     processLlmRequest(toolContext: Context, llmRequest: LlmRequest): Promise<void>;
     private resolveAdditionalTools;
 }

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

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A generic, async-safe queue that implements AsyncIterable.
+ */
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private queue;
+    private resolvers;
+    private closed;
+    private errorVal?;
+    push(value: T): void;
+    error(err: unknown): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Recursively converts snake_case keys of an object to camelCase.
+ *
+ * @param val The value to convert.
+ * @returns The converted value.
+ */
+export declare function camelCaseKeys(val: unknown): unknown;