@google/adk 2.2.0 → 2.3.0

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

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { JsonObject } from '../../../utils/json_utils.js';
+import { ConnectorSpec } from './connections_client.js';
+/** Options for {@link IntegrationClient}. */
+export interface IntegrationClientOptions {
+    /** The Google Cloud project ID. */
+    project: string;
+    /** The Google Cloud location, such as `us-central1`. */
+    location: string;
+    /** The integration name. */
+    integration?: string;
+    /** The API trigger ID of the integration. */
+    trigger?: string;
+    /** The connection name. */
+    connection?: string;
+    /**
+     * Operations to expose, keyed by entity name, such as
+     * `{Issues: ['LIST', 'GET']}`. An empty list exposes every operation the
+     * entity supports.
+     */
+    entityOperations?: Record<string, string[]>;
+    /** Actions to expose. */
+    actions?: string[];
+    /**
+     * A service-account key, as a JSON string. When omitted, requests use
+     * Application Default Credentials.
+     */
+    serviceAccountJson?: string;
+}
+/**
+ * A client for Google Cloud Application Integration.
+ *
+ * It returns the OpenAPI spec of an integration API trigger, or builds one for
+ * the entity operations and actions of an Integration Connectors connection.
+ */
+export declare class IntegrationClient {
+    private readonly project;
+    private readonly location;
+    private readonly integration?;
+    private readonly trigger?;
+    private readonly connection?;
+    private readonly entityOperations;
+    private readonly actions;
+    private readonly serviceAccountJson?;
+    private readonly tokenSource;
+    constructor(options: IntegrationClientOptions);
+    /**
+     * Fetches the OpenAPI spec Application Integration generates for the API
+     * trigger of the integration.
+     *
+     * @throws Error For a rejected request, a missing credential, or a response
+     *   that carries no parseable spec.
+     */
+    getOpenApiSpecForIntegration(): Promise<JsonObject>;
+    /**
+     * Builds an OpenAPI spec for the entity operations and actions of the
+     * connection.
+     *
+     * Every operation becomes a POST to the `ExecuteConnection` integration,
+     * with a path fragment that keeps the paths distinct.
+     *
+     * @param toolName Prefix of every generated `operationId`.
+     * @param toolInstructions Text appended to every operation description.
+     * @throws Error When neither entity operations nor actions are configured,
+     *   or an operation is not one of create, update, delete, list or get.
+     */
+    getOpenApiSpecForConnection(toolName?: string, toolInstructions?: string): Promise<ConnectorSpec>;
+}

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

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { Context } from '../agents/context.js';
+import { SchemaLike } from '../utils/schema.js';
+import { FunctionTool, ToolInputParameters } from './function_tool.js';
+/**
+ * Schema formats accepted on a wrapped CrewAI tool.
+ */
+export type CrewaiSchemaLike = SchemaLike | {
+    jsonSchema: () => Record<string, unknown>;
+} | {
+    modelJsonSchema: () => Record<string, unknown>;
+} | Record<string, unknown>;
+/**
+ * Structural interface for a CrewAI tool instance.
+ */
+export interface CrewaiToolLike {
+    /**
+     * The name of the CrewAI tool.
+     */
+    name?: string;
+    /**
+     * The description of the CrewAI tool.
+     */
+    description?: string;
+    /**
+     * Optional parameters schema for the tool.
+     */
+    argsSchema?: CrewaiSchemaLike;
+    /**
+     * Executes the CrewAI tool with the given arguments.
+     */
+    run(args: Record<string, unknown>, toolContext?: Context): unknown | Promise<unknown>;
+}
+/**
+ * Configuration options for {@link CrewaiTool}.
+ */
+export interface CrewaiToolConfig {
+    /**
+     * The wrapped CrewAI tool instance.
+     */
+    tool: CrewaiToolLike;
+    /**
+     * Optional custom name override. When omitted or empty, defaults to
+     * `tool.name` with spaces replaced by underscores and lowercased.
+     */
+    name?: string;
+    /**
+     * Optional custom description override. When omitted or empty, defaults to
+     * `tool.description`.
+     */
+    description?: string;
+}
+declare const CREWAI_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of {@link CrewaiTool}.
+ */
+export declare function isCrewaiTool(obj: unknown): obj is CrewaiTool;
+/**
+ * Wrapper class that adapts a CrewAI tool for use in ADK.
+ *
+ * If the original tool name and description are not suitable, you can override
+ * them in the constructor.
+ */
+export declare class CrewaiTool extends FunctionTool<ToolInputParameters> {
+    /** A unique symbol to identify ADK CrewaiTool class. */
+    readonly [CREWAI_TOOL_SIGNATURE_SYMBOL] = true;
+    /**
+     * The wrapped CrewAI tool.
+     */
+    readonly tool: CrewaiToolLike;
+    constructor(toolOrConfig: CrewaiToolConfig | CrewaiToolLike, options?: {
+        name?: string;
+        description?: string;
+    });
+    /**
+     * Builds the `FunctionDeclaration` for the wrapped CrewAI tool.
+     */
+    _getDeclaration(): FunctionDeclaration;
+}
+export {};

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

@@ -12,9 +12,19 @@ import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_too
  * This tool is executed for each LLM request and is never called by the model;
  * it only mutates the outgoing request by appending few-shot instructions built
  * from the latest user query.
+ *
+ * The constructor checks `examples` at runtime, so a malformed value fails
+ * where it is supplied rather than on every later LLM request.
  */
 export declare class ExampleTool extends BaseTool {
+    /** The examples to add to the LLM request. */
     readonly examples: Example[] | BaseExampleProvider;
+    /**
+     * @param examples - A list of {@link Example}s, or a
+     *   {@link BaseExampleProvider} that returns them for a query.
+     * @throws {InputValidationError} When `examples` is neither a
+     *   {@link BaseExampleProvider} nor a list of well-formed examples.
+     */
     constructor(examples: Example[] | BaseExampleProvider);
     runAsync(_request: RunAsyncToolRequest): Promise<unknown>;
     processLlmRequest({ toolContext, llmRequest, }: ToolProcessLlmRequest): Promise<void>;

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

@@ -8,6 +8,8 @@ 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';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { SchemaLike } from '../utils/schema.js';
 /**
  * Input parameters of the function tool.
  */
@@ -59,6 +61,8 @@ export type ToolOptions<TParameters extends ToolInputParameters> = {
     name?: string;
     description: string;
     parameters?: TParameters;
+    /** Optional schema describing the tool's return value. */
+    response?: SchemaLike;
     execute: ToolExecuteFunction<TParameters>;
     isLongRunning?: boolean;
     /**
@@ -80,6 +84,14 @@ export type ToolOptions<TParameters extends ToolInputParameters> = {
      */
     requireConfirmation?: RequireConfirmation<TParameters>;
 };
+/**
+ * The parameters for `_callLive`.
+ */
+export interface CallLiveToolRequest {
+    args: Record<string, unknown>;
+    toolContext: Context;
+    invocationContext: InvocationContext;
+}
 /**
  * A unique symbol to identify ADK agent classes.
  * Defined once and shared by all BaseTool instances.
@@ -114,6 +126,7 @@ export declare class FunctionTool<TParameters extends ToolInputParameters = unde
     readonly [FUNCTION_TOOL_SIGNATURE_SYMBOL] = true;
     private readonly execute;
     private readonly parameters?;
+    private readonly response?;
     private readonly requireConfirmation;
     /**
      * The constructor acts as the user-friendly factory.
@@ -136,6 +149,13 @@ export declare class FunctionTool<TParameters extends ToolInputParameters = unde
      *     `parameters` schema rejects the arguments or `execute` throws.
      */
     runAsync(req: RunAsyncToolRequest): Promise<unknown>;
+    /**
+     * Invokes the tool in live streaming mode, injecting any active input stream
+     * from the invocation context and yielding items from the returned stream.
+     *
+     * @param req The live tool invocation request.
+     */
+    _callLive(req: CallLiveToolRequest): AsyncGenerator<unknown, void, void>;
     /**
      * Whether this call is gated on human approval — the static flag, or the
      * predicate evaluated against the validated arguments.
@@ -157,4 +177,16 @@ export declare class FunctionTool<TParameters extends ToolInputParameters = unde
      */
     private checkConfirmation;
 }
+/**
+ * Builds a `FunctionDeclaration` from a normalized parameter schema.
+ */
+export declare function buildFunctionDeclarationUtil(vertexai: boolean, name: string, description: string, func: unknown, beforeParamSchema: Record<string, unknown>): FunctionDeclaration;
+/**
+ * Builds a `FunctionDeclaration` for a LangChain tool parameter map.
+ */
+export declare function buildFunctionDeclarationForLangchain(vertexai: boolean, name: string, description: string, func: unknown, paramSchema: Record<string, unknown>): FunctionDeclaration;
+/**
+ * Builds a `FunctionDeclaration` for a CrewAI tool parameter schema.
+ */
+export declare function buildFunctionDeclarationForParamsForCrewai(vertexai: boolean, name: string, description: string, func: unknown, paramSchema: Record<string, unknown>): FunctionDeclaration;
 export {};

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

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest } from '../base_tool.js';
+import { RestApiTool } from '../openapi_tool/rest_api_tool.js';
+declare const GOOGLE_API_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of {@link GoogleApiTool}.
+ */
+export declare function isGoogleApiTool(obj: unknown): obj is GoogleApiTool;
+/**
+ * Wraps a {@link RestApiTool} created from a Google API specification and adds
+ * helper methods for configuring Google OpenID Connect credentials.
+ */
+export declare class GoogleApiTool extends BaseTool {
+    readonly [GOOGLE_API_TOOL_SIGNATURE_SYMBOL] = true;
+    readonly restApiTool: RestApiTool;
+    constructor(restApiTool: RestApiTool);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+    /**
+     * Configures OpenID Connect OAuth2 client credentials on the underlying
+     * {@link RestApiTool}.
+     */
+    configureAuth(clientId: string, clientSecret: string): void;
+}
+export {};

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

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+import { ReadonlyContext } from '../../agents/readonly_context.js';
+import { BaseToolset, ToolPredicate } from '../base_toolset.js';
+import { OpenAPIToolset } from '../openapi_tool/openapi_toolset.js';
+import { RestApiTool } from '../openapi_tool/rest_api_tool.js';
+import { GoogleApiTool } from './google_api_tool.js';
+declare const GOOGLE_API_TOOL_SET_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Options for constructing a {@link GoogleApiToolSet}.
+ */
+export interface GoogleApiToolSetOptions {
+    apiName?: string;
+    apiVersion?: string;
+    toolFilter?: ToolPredicate | string[];
+}
+/**
+ * Options for loading an {@link OpenAPIToolset} pre-configured with Google
+ * OpenID Connect endpoints.
+ */
+export interface LoadToolSetWithOidcAuthOptions {
+    specFile?: string;
+    specDict?: OpenAPIV3.Document;
+    scopes?: string[];
+    callerDir?: string;
+}
+/**
+ * Type guard to check if an object is an instance of {@link GoogleApiToolSet}.
+ */
+export declare function isGoogleApiToolSet(obj: unknown): obj is GoogleApiToolSet;
+/**
+ * Toolset that wraps Google Discovery API operations as {@link GoogleApiTool}
+ * instances configured for Google OpenID Connect authentication.
+ */
+export declare class GoogleApiToolSet extends BaseToolset {
+    readonly [GOOGLE_API_TOOL_SET_SIGNATURE_SYMBOL] = true;
+    readonly apiName?: string;
+    readonly apiVersion?: string;
+    private tools;
+    private toolsLoaded;
+    private loadingPromise?;
+    private pendingAuth?;
+    constructor(tools?: Array<RestApiTool | GoogleApiTool>, options?: GoogleApiToolSetOptions);
+    private ensureToolsLoaded;
+    /**
+     * Returns all tools in the toolset matching the active `toolFilter`.
+     */
+    getTools(context?: ReadonlyContext): Promise<GoogleApiTool[]>;
+    /**
+     * Finds a tool in the toolset by name.
+     */
+    getTool(toolName: string): Promise<GoogleApiTool | undefined>;
+    /**
+     * Configures OAuth2 client ID and secret across all tools in the toolset.
+     */
+    configureAuth(clientId: string, clientSecret: string): void;
+    close(): Promise<void>;
+    /**
+     * Builds an {@link OpenAPIToolset} from an OpenAPI specification dictionary
+     * or YAML/JSON file and configures it with Google's OpenID Connect endpoints.
+     */
+    static loadToolSetWithOidcAuth(options?: LoadToolSetWithOidcAuthOptions): OpenAPIToolset;
+    /**
+     * Fetches and converts a Google API Discovery document and returns a
+     * {@link GoogleApiToolSet} containing its operations.
+     */
+    static loadToolSet(apiName: string, apiVersion: string): Promise<GoogleApiToolSet>;
+}
+/**
+ * Creates a lazy-loaded {@link GoogleApiToolSet} singleton without triggering
+ * the `@experimental` class constructor warning at module import time.
+ */
+export declare function createLazyGoogleApiToolSet(apiName: string, apiVersion: string): GoogleApiToolSet;
+export {};

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

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Pre-configured {@link GoogleApiToolSet} for the Google Calendar v3 API.
+ */
+export declare const calendarToolSet: import("./google_api_tool_set.js").GoogleApiToolSet;
+/**
+ * Pre-configured {@link GoogleApiToolSet} for the Google BigQuery v2 API.
+ */
+export declare const bigqueryToolSet: import("./google_api_tool_set.js").GoogleApiToolSet;
+/**
+ * Pre-configured {@link GoogleApiToolSet} for the Gmail v1 API.
+ */
+export declare const gmailToolSet: import("./google_api_tool_set.js").GoogleApiToolSet;
+/**
+ * Pre-configured {@link GoogleApiToolSet} for the YouTube Data v3 API.
+ */
+export declare const youtubeToolSet: import("./google_api_tool_set.js").GoogleApiToolSet;
+/**
+ * Pre-configured {@link GoogleApiToolSet} for the Google Slides v1 API.
+ */
+export declare const slidesToolSet: import("./google_api_tool_set.js").GoogleApiToolSet;
+/**
+ * Pre-configured {@link GoogleApiToolSet} for the Google Sheets v4 API.
+ */
+export declare const sheetsToolSet: import("./google_api_tool_set.js").GoogleApiToolSet;
+/**
+ * Pre-configured {@link GoogleApiToolSet} for the Google Docs v1 API.
+ */
+export declare const docsToolSet: import("./google_api_tool_set.js").GoogleApiToolSet;

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

@@ -0,0 +1,164 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { OpenAPIV3 } from 'openapi-types';
+/**
+ * Scope metadata in a Google API Discovery document.
+ */
+export interface GoogleApiOAuth2Scope {
+    description?: string;
+}
+/**
+ * Parameter metadata in a Google API Discovery document.
+ */
+export interface GoogleApiParameter {
+    type?: string;
+    description?: string;
+    required?: boolean;
+    location?: string;
+    format?: string;
+    enum?: string[];
+    default?: unknown;
+    pattern?: string;
+    minimum?: string;
+    maximum?: string;
+}
+/**
+ * Schema definition in a Google API Discovery document.
+ */
+export interface GoogleApiSchema {
+    type?: string;
+    description?: string;
+    format?: string;
+    enum?: string[];
+    pattern?: string;
+    default?: unknown;
+    required?: boolean;
+    $ref?: string;
+    properties?: Record<string, GoogleApiSchema>;
+    items?: GoogleApiSchema;
+    minimum?: string;
+    maximum?: string;
+    location?: string;
+}
+/**
+ * Method definition in a Google API Discovery document.
+ */
+export interface GoogleApiMethod {
+    id?: string;
+    path?: string;
+    httpMethod?: string;
+    description?: string;
+    parameters?: Record<string, GoogleApiParameter>;
+    request?: {
+        $ref?: string;
+    };
+    response?: {
+        $ref?: string;
+    };
+    scopes?: string[];
+}
+/**
+ * Resource definition in a Google API Discovery document.
+ */
+export interface GoogleApiResource {
+    methods?: Record<string, GoogleApiMethod>;
+    resources?: Record<string, GoogleApiResource>;
+}
+/**
+ * Root structure of a Google API Discovery REST specification.
+ */
+export interface GoogleApiSpec {
+    kind?: string;
+    id?: string;
+    name?: string;
+    version?: string;
+    title?: string;
+    description?: string;
+    documentationLink?: string;
+    protocol?: string;
+    rootUrl?: string;
+    servicePath?: string;
+    auth?: {
+        oauth2?: {
+            scopes?: Record<string, GoogleApiOAuth2Scope>;
+        };
+    };
+    schemas?: Record<string, GoogleApiSchema>;
+    resources?: Record<string, GoogleApiResource>;
+    methods?: Record<string, GoogleApiMethod>;
+}
+/**
+ * Converts a Google Discovery schema reference (`#Name` or `Name`) to an
+ * OpenAPI v3 component schema reference (`#/components/schemas/Name`).
+ */
+export declare function normalizeGoogleSchemaRef(ref: string): string;
+/**
+ * Populates the OpenAPI `info` and optional `externalDocs` sections from a
+ * Google API Discovery document.
+ */
+export declare function convertInfo(googleApiSpec: GoogleApiSpec, openapiSpec: OpenAPIV3.Document, apiName: string, apiVersion: string): void;
+/**
+ * Populates the OpenAPI `servers` list from the Google Discovery `rootUrl` and
+ * `servicePath`.
+ */
+export declare function convertServers(googleApiSpec: GoogleApiSpec, openapiSpec: OpenAPIV3.Document, apiName: string, apiVersion: string): void;
+/**
+ * Populates `components.securitySchemes` and top-level `security` from a
+ * Google API Discovery document.
+ */
+export declare function convertSecuritySchemes(googleApiSpec: GoogleApiSpec, openapiSpec: OpenAPIV3.Document): void;
+/**
+ * Recursively converts a Google API Discovery schema object to an OpenAPI v3
+ * schema or reference object.
+ */
+export declare function convertSchemaObject(schemaDef: GoogleApiSchema): OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+/**
+ * Populates `components.schemas` from a Google API Discovery document.
+ */
+export declare function convertSchemas(googleApiSpec: GoogleApiSpec, openapiSpec: OpenAPIV3.Document): void;
+/**
+ * Extracts `{param}` and `{+param}` placeholder names from a URL path.
+ */
+export declare function extractPathParameters(path: string): string[];
+/**
+ * Converts a Google API parameter definition into an OpenAPI parameter schema.
+ */
+export declare function convertParameterSchema(paramData: GoogleApiParameter): OpenAPIV3.SchemaObject;
+/**
+ * Converts a Google API method definition into an OpenAPI operation object.
+ */
+export declare function convertOperation(methodData: GoogleApiMethod, pathParams: string[]): OpenAPIV3.OperationObject;
+/**
+ * Converts a dictionary of Google API methods into OpenAPI path operations.
+ */
+export declare function convertMethods(methods: Record<string, GoogleApiMethod>, _resourcePath: string, openapiSpec: OpenAPIV3.Document): void;
+/**
+ * Recursively converts nested Google API resources and their methods into
+ * OpenAPI paths.
+ */
+export declare function convertResources(resources: Record<string, GoogleApiResource>, openapiSpec: OpenAPIV3.Document, parentPath?: string): void;
+/**
+ * Converts Google API Discovery documents into OpenAPI v3.0.0 specifications.
+ */
+export declare class GoogleApiToOpenApiConverter {
+    readonly apiName: string;
+    readonly apiVersion: string;
+    googleApiSpec: GoogleApiSpec | null;
+    openapiSpec: OpenAPIV3.Document;
+    constructor(apiName: string, apiVersion: string);
+    /**
+     * Fetches the Google API specification from the Google Discovery service.
+     */
+    fetchGoogleApiSpec(): Promise<void>;
+    /**
+     * Converts the Google API specification into OpenAPI v3 format.
+     */
+    convert(): Promise<OpenAPIV3.Document>;
+    /**
+     * Saves the converted OpenAPI specification to a JSON file.
+     */
+    saveOpenapiSpec(outputPath: string): void;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export { GoogleApiTool, isGoogleApiTool } from './google_api_tool.js';
+export { GoogleApiToolSet, isGoogleApiToolSet } from './google_api_tool_set.js';
+export type { GoogleApiToolSetOptions, LoadToolSetWithOidcAuthOptions, } from './google_api_tool_set.js';
+export { bigqueryToolSet, calendarToolSet, docsToolSet, gmailToolSet, sheetsToolSet, slidesToolSet, youtubeToolSet, } from './google_api_tool_sets.js';
+export { GoogleApiToOpenApiConverter } from './googleapi_to_openapi_converter.js';
+export type { GoogleApiMethod, GoogleApiOAuth2Scope, GoogleApiParameter, GoogleApiResource, GoogleApiSchema, GoogleApiSpec, } from './googleapi_to_openapi_converter.js';

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

@@ -0,0 +1,103 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { Context } from '../agents/context.js';
+import { SchemaLike } from '../utils/schema.js';
+import { FunctionTool, ToolInputParameters } from './function_tool.js';
+/**
+ * Schema formats accepted on a wrapped LangChain tool.
+ */
+export type LangchainSchemaLike = SchemaLike | {
+    jsonSchema: () => Record<string, unknown>;
+} | {
+    modelJsonSchema: () => Record<string, unknown>;
+} | Record<string, unknown>;
+/**
+ * Structural interface for a LangChain tool instance.
+ */
+export interface LangchainToolLike {
+    /**
+     * The name of the LangChain tool.
+     */
+    name?: string;
+    /**
+     * The description of the LangChain tool.
+     */
+    description?: string;
+    /**
+     * Optional parameter schema (`argsSchema`).
+     */
+    argsSchema?: LangchainSchemaLike;
+    /**
+     * Optional parameter schema (`StructuredTool.schema`).
+     */
+    schema?: LangchainSchemaLike;
+    /**
+     * Optional raw parameter properties map (`BaseTool.args`).
+     */
+    args?: Record<string, unknown>;
+    /**
+     * Executes the tool (`BaseTool._run`).
+     */
+    _run?(args: Record<string, unknown>, toolContext?: Context): unknown | Promise<unknown>;
+    /**
+     * Executes the tool (`StructuredTool._call`).
+     */
+    _call?(args: Record<string, unknown>, toolContext?: Context): unknown | Promise<unknown>;
+    /**
+     * Executes the tool (`Runnable.invoke`).
+     */
+    invoke?(args: Record<string, unknown>, toolContext?: Context): unknown | Promise<unknown>;
+    /**
+     * Executes a simple convention-based tool (`tool.run`).
+     */
+    run?(args: Record<string, unknown>, toolContext?: Context): unknown | Promise<unknown>;
+}
+/**
+ * Configuration options for {@link LangchainTool}.
+ */
+export interface LangchainToolConfig {
+    /**
+     * The wrapped LangChain tool instance.
+     */
+    tool: LangchainToolLike;
+    /**
+     * Optional custom name override.
+     */
+    name?: string;
+    /**
+     * Optional custom description override.
+     */
+    description?: string;
+}
+declare const LANGCHAIN_TOOL_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of {@link LangchainTool}.
+ */
+export declare function isLangchainTool(obj: unknown): obj is LangchainTool;
+/**
+ * Wrapper class that adapts a LangChain tool for use in ADK.
+ *
+ * If the original tool name and description are not suitable, you can override
+ * them in the constructor.
+ */
+export declare class LangchainTool extends FunctionTool<ToolInputParameters> {
+    /** A unique symbol to identify ADK LangchainTool class. */
+    readonly [LANGCHAIN_TOOL_SIGNATURE_SYMBOL] = true;
+    /**
+     * The wrapped LangChain tool.
+     */
+    readonly tool: LangchainToolLike;
+    constructor(toolOrConfig: LangchainToolConfig | LangchainToolLike, options?: {
+        name?: string;
+        description?: string;
+    });
+    /**
+     * Builds the `FunctionDeclaration` for the wrapped LangChain tool.
+     */
+    _getDeclaration(): FunctionDeclaration;
+}
+export {};

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

@@ -7,6 +7,9 @@
  * `@google/adk/tools/mcp` subpath: the MCP tools only, without the full ADK
  * barrel. Also re-exported from `@google/adk`.
  */
+export { toGeminiSchema } from '../../utils/gemini_schema_util.js';
+export type { MCPToolSchema } from '../../utils/gemini_schema_util.js';
+export { genaiSchemaToJsonSchema } from '../../utils/genai_schema_to_json.js';
 export * from './load_mcp_resource_tool.js';
 export * from './mcp_session_manager.js';
 export * from './mcp_tool.js';