@google/adk 0.1.0

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

@@ -0,0 +1,18 @@
+import { BaseTool, RunAsyncToolRequest, 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.
+ */
+declare class GoogleSearchTool extends BaseTool {
+    constructor();
+    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest({ toolContext, llmRequest }: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of GoogleSearchTool.
+ */
+export declare const GOOGLE_SEARCH: GoogleSearchTool;
+export {};

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,57 @@
+/**
+ * @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';
+/**
+ * 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;
+    header?: Record<string, unknown>;
+    timeout?: Number;
+    sseReadTimeout?: Number;
+    terminateOnClose?: boolean;
+}
+/**
+ * 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,30 @@
+/**
+ * @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.
+ */
+export declare class MCPTool extends BaseTool {
+    private readonly mcpTool;
+    private readonly mcpSessionManager;
+    constructor(mcpTool: Tool, mcpSessionManager: MCPSessionManager);
+    _getDeclaration(): FunctionDeclaration;
+    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
+}

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

@@ -0,0 +1,39 @@
+/**
+ * @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.
+ *
+ * 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[]);
+    getTools(context?: ReadonlyContext): Promise<BaseTool[]>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CallbackContext } from '../agents/callback_context.js';
+import { InvocationContext } from '../agents/invocation_context.js';
+import { AuthCredential } from '../auth/auth_credential.js';
+import { AuthConfig } from '../auth/auth_tool.js';
+import { EventActions } from '../events/event_actions.js';
+import { SearchMemoryResponse } from '../memory/base_memory_service.js';
+import { ToolConfirmation } from '../tools/tool_confirmation.js';
+export declare class ToolContext extends CallbackContext {
+    readonly functionCallId?: string;
+    toolConfirmation?: ToolConfirmation;
+    /**
+     * @param params.invocationContext The invocation context of the tool.
+     * @param params.eventActions The event actions of the current tool call.
+     * @param params.functionCallId The function call id of the current tool call.
+     *     This id was returned in the function call event from LLM to identify a
+     *     function call. If LLM didn't return this id, ADK will assign one to it.
+     *     This id is used to map function call response to the original function
+     *     call.
+     * @param params.toolConfirmation The tool confirmation of the current tool
+     *     call.
+     */
+    constructor({ invocationContext, eventActions, functionCallId, toolConfirmation, }: {
+        invocationContext: InvocationContext;
+        eventActions?: EventActions;
+        functionCallId?: string;
+        toolConfirmation?: ToolConfirmation;
+    });
+    get actions(): EventActions;
+    requestCredential(authConfig: AuthConfig): void;
+    /**
+     * Gets the auth credential for the given auth config.
+     *
+     * @param authConfig The auth config to get the auth credential for.
+     * @return The auth credential for the given auth config.
+     */
+    getAuthResponse(authConfig: AuthConfig): AuthCredential | undefined;
+    /**
+     * Lists the filenames of the artifacts attached to the current session.
+     *
+     * @return A promise that resolves to a list of artifact filenames.
+     */
+    listArtifacts(): Promise<string[]>;
+    /**
+     * Searches the memory of the current user.
+     *
+     * @param query The query to search memory for.
+     * @return A promise that resolves to SearchMemoryResponse containing the
+     *     matching memories.
+     */
+    searchMemory(query: string): Promise<SearchMemoryResponse>;
+    /**
+     * Requests confirmation for the current tool call.
+     */
+    requestConfirmation({ hint, payload }: {
+        hint?: string;
+        payload?: unknown;
+    }): void;
+}

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

@@ -0,0 +1 @@
+export declare function deepClone<T>(obj: T): T;

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

@@ -0,0 +1,31 @@
+/**
+ * @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;

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Schema } from '@google/genai';
+import { z } from 'zod';
+declare const MCPToolSchema: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "object";
+    required?: string[] | undefined;
+    properties?: Record<string, unknown> | undefined;
+}, {
+    type: "object";
+    required?: string[] | undefined;
+    properties?: Record<string, unknown> | undefined;
+}>;
+type MCPToolSchema = z.infer<typeof MCPToolSchema>;
+export declare function toGeminiSchema(mcpSchema?: MCPToolSchema): Schema | undefined;
+export {};

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

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Log levels for the logger. */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+/**
+ * Logger interface for ADK.
+ */
+export interface Logger {
+    log(level: LogLevel, ...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+/**
+ * Sets the log level for the logger.
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/**
+ * Simple logger class for ADK.
+ */
+declare class SimpleLogger implements Logger {
+    log(level: LogLevel, ...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+/**
+ * The logger instance for ADK.
+ */
+export declare const logger: SimpleLogger;
+export {};

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

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Extract the actual model name from either simple or path-based format.
+ *
+ * @param modelString Either a simple model name like "gemini-2.5-pro" or
+ *     a path-based model name like "projects/.../models/gemini-2.0-flash-001"
+ * @return The extracted model name (e.g., "gemini-2.5-pro")
+ */
+export declare function extractModelName(modelString: string): string;
+/**
+ * Check if the model is a Gemini model using regex patterns.
+ *
+ * @param modelString Either a simple model name or path - based model name
+ * @return true if it's a Gemini model, false otherwise.
+ */
+export declare function isGeminiModel(modelString: string): boolean;
+/**
+ * Check if the model is a Gemini 1.x model using regex patterns.
+ *
+ * @param modelString Either a simple model name or path - based model name
+ * @return true if it's a Gemini 1.x model, false otherwise.
+ */
+export declare function isGemini1Model(modelString: string): boolean;
+/**
+ * Check if the model is a Gemini 2.x model using regex patterns.
+ *
+ * @param modelString Either a simple model name or path - based model name
+ * @return true if it's a Gemini 2.x model, false otherwise.
+ */
+export declare function isGemini2Model(modelString: string): boolean;

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

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Schema } from '@google/genai';
+import { ZodObject } from 'zod';
+/**
+ * Returns true if the given object is a V3 ZodObject.
+ */
+export declare function isZodObject(obj: unknown): obj is ZodObject<any>;
+export declare function zodObjectToSchema(schema: ZodObject<any>): Schema;

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

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The Google LLM variant to use.
+ * see
+ * https://google.github.io/adk-docs/get-started/quickstart/#set-up-the-model
+ */
+export declare enum GoogleLLMVariant {
+    /**
+     * For using credentials from Google Vertex AI
+     */
+    VERTEX_AI = "VERTEX_AI",
+    /**
+     * For using API Key from Google AI Studio
+     */
+    GEMINI_API = "GEMINI_API"
+}
+/**
+ * Gets the Google LLM variant to use.
+ */
+export declare function getGoogleLlmVariant(): GoogleLLMVariant;

package/dist/types/version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const version = "0.1.0";

package/dist/web/agents/active_streaming_tool.js

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class ActiveStreamingTool {
+  constructor(params = {}) {
+    this.task = params.task;
+    this.stream = params.stream;
+  }
+}
+export {
+  ActiveStreamingTool
+};