@google/adk 0.2.5 → 0.4.0

package/dist/types/models/google_llm.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { GoogleGenAI } from '@google/genai';
+import { GoogleGenAI, HttpOptions } from '@google/genai';
 import { GoogleLLMVariant } from '../utils/variant_utils.js';
 import { BaseLlm } from './base_llm.js';
 import { BaseLlmConnection } from './base_llm_connection.js';
@@ -45,7 +45,7 @@ export interface GeminiParams {
  */
 export declare class Gemini extends BaseLlm {
     private readonly apiKey?;
-    private readonly vertexai;
+    protected readonly vertexai: boolean;
     private readonly project?;
     private readonly location?;
     private readonly headers?;
@@ -72,9 +72,11 @@ export declare class Gemini extends BaseLlm {
      * @yields LlmResponse: The model response.
      */
     generateContentAsync(llmRequest: LlmRequest, stream?: boolean): AsyncGenerator<LlmResponse, void>;
+    protected getHttpOptions(): HttpOptions;
     get apiClient(): GoogleGenAI;
     get apiBackend(): GoogleLLMVariant;
     get liveApiVersion(): string;
+    protected getLiveHttpOptions(): HttpOptions;
     get liveApiClient(): GoogleGenAI;
     /**
      * Connects to the Gemini model and returns an llm connection.
@@ -85,3 +87,4 @@ export declare class Gemini extends BaseLlm {
     connect(llmRequest: LlmRequest): Promise<BaseLlmConnection>;
     private preprocessRequest;
 }
+export declare function geminiInitParams({ model, vertexai, project, location, apiKey, }: GeminiParams): GeminiParams;

package/dist/types/models/llm_response.d.ts

@@ -46,7 +46,7 @@ export interface LlmResponse {
      * NOTE: the entire object must be JSON serializable.
      */
     customMetadata?: {
-        [key: string]: any;
+        [key: string]: unknown;
     };
     /**
      * The usage metadata of the LlmResponse.

package/dist/types/plugins/logging_plugin.d.ts

@@ -46,53 +46,53 @@ export declare class LoggingPlugin extends BasePlugin {
      * @param name The name of the plugin instance.
      */
     constructor(name?: string);
-    onUserMessageCallback({ invocationContext, userMessage }: {
+    onUserMessageCallback({ invocationContext, userMessage, }: {
         invocationContext: InvocationContext;
         userMessage: Content;
     }): Promise<Content | undefined>;
-    beforeRunCallback({ invocationContext }: {
+    beforeRunCallback({ invocationContext, }: {
         invocationContext: InvocationContext;
     }): Promise<Content | undefined>;
-    onEventCallback({ invocationContext, event }: {
+    onEventCallback({ event, }: {
         invocationContext: InvocationContext;
         event: Event;
     }): Promise<Event | undefined>;
-    afterRunCallback({ invocationContext }: {
+    afterRunCallback({ invocationContext, }: {
         invocationContext: InvocationContext;
     }): Promise<void>;
-    beforeAgentCallback({ agent, callbackContext }: {
+    beforeAgentCallback({ callbackContext, }: {
         agent: BaseAgent;
         callbackContext: CallbackContext;
     }): Promise<Content | undefined>;
-    afterAgentCallback({ agent, callbackContext }: {
+    afterAgentCallback({ callbackContext, }: {
         agent: BaseAgent;
         callbackContext: CallbackContext;
     }): Promise<Content | undefined>;
-    beforeModelCallback({ callbackContext, llmRequest }: {
+    beforeModelCallback({ callbackContext, llmRequest, }: {
         callbackContext: CallbackContext;
         llmRequest: LlmRequest;
     }): Promise<LlmResponse | undefined>;
-    afterModelCallback({ callbackContext, llmResponse }: {
+    afterModelCallback({ callbackContext, llmResponse, }: {
         callbackContext: CallbackContext;
         llmResponse: LlmResponse;
     }): Promise<LlmResponse | undefined>;
-    beforeToolCallback({ tool, toolArgs, toolContext }: {
+    beforeToolCallback({ tool, toolArgs, toolContext, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;
     }): Promise<Record<string, unknown> | undefined>;
-    afterToolCallback({ tool, toolArgs, toolContext, result }: {
+    afterToolCallback({ tool, toolContext, result, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;
         result: Record<string, unknown>;
     }): Promise<Record<string, unknown> | undefined>;
-    onModelErrorCallback({ callbackContext, llmRequest, error }: {
+    onModelErrorCallback({ callbackContext, error, }: {
         callbackContext: CallbackContext;
         llmRequest: LlmRequest;
         error: Error;
     }): Promise<LlmResponse | undefined>;
-    onToolErrorCallback({ tool, toolArgs, toolContext, error }: {
+    onToolErrorCallback({ tool, toolArgs, toolContext, error, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;

package/dist/types/plugins/plugin_manager.d.ts

@@ -67,47 +67,47 @@ export declare class PluginManager {
     /**
      * Runs the `onUserMessageCallback` for all plugins.
      */
-    runOnUserMessageCallback({ userMessage, invocationContext }: {
+    runOnUserMessageCallback({ userMessage, invocationContext, }: {
         userMessage: Content;
         invocationContext: InvocationContext;
     }): Promise<Content | undefined>;
     /**
      * Runs the `beforeRunCallback` for all plugins.
      */
-    runBeforeRunCallback({ invocationContext }: {
+    runBeforeRunCallback({ invocationContext, }: {
         invocationContext: InvocationContext;
     }): Promise<Content | undefined>;
     /**
      * Runs the `afterRunCallback` for all plugins.
      */
-    runAfterRunCallback({ invocationContext }: {
+    runAfterRunCallback({ invocationContext, }: {
         invocationContext: InvocationContext;
     }): Promise<void>;
     /**
      * Runs the `onEventCallback` for all plugins.
      */
-    runOnEventCallback({ invocationContext, event }: {
+    runOnEventCallback({ invocationContext, event, }: {
         invocationContext: InvocationContext;
         event: Event;
     }): Promise<Event | undefined>;
     /**
      * Runs the `beforeAgentCallback` for all plugins.
      */
-    runBeforeAgentCallback({ agent, callbackContext }: {
+    runBeforeAgentCallback({ agent, callbackContext, }: {
         agent: BaseAgent;
         callbackContext: CallbackContext;
     }): Promise<Content | undefined>;
     /**
      * Runs the `afterAgentCallback` for all plugins.
      */
-    runAfterAgentCallback({ agent, callbackContext }: {
+    runAfterAgentCallback({ agent, callbackContext, }: {
         agent: BaseAgent;
         callbackContext: CallbackContext;
     }): Promise<Content | undefined>;
     /**
      * Runs the `beforeToolCallback` for all plugins.
      */
-    runBeforeToolCallback({ tool, toolArgs, toolContext }: {
+    runBeforeToolCallback({ tool, toolArgs, toolContext, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;
@@ -115,7 +115,7 @@ export declare class PluginManager {
     /**
      * Runs the `afterToolCallback` for all plugins.
      */
-    runAfterToolCallback({ tool, toolArgs, toolContext, result }: {
+    runAfterToolCallback({ tool, toolArgs, toolContext, result, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;
@@ -124,7 +124,7 @@ export declare class PluginManager {
     /**
      * Runs the `onModelErrorCallback` for all plugins.
      */
-    runOnModelErrorCallback({ callbackContext, llmRequest, error }: {
+    runOnModelErrorCallback({ callbackContext, llmRequest, error, }: {
         callbackContext: CallbackContext;
         llmRequest: LlmRequest;
         error: Error;
@@ -132,21 +132,21 @@ export declare class PluginManager {
     /**
      * Runs the `beforeModelCallback` for all plugins.
      */
-    runBeforeModelCallback({ callbackContext, llmRequest }: {
+    runBeforeModelCallback({ callbackContext, llmRequest, }: {
         callbackContext: CallbackContext;
         llmRequest: LlmRequest;
     }): Promise<LlmResponse | undefined>;
     /**
      * Runs the `afterModelCallback` for all plugins.
      */
-    runAfterModelCallback({ callbackContext, llmResponse }: {
+    runAfterModelCallback({ callbackContext, llmResponse, }: {
         callbackContext: CallbackContext;
         llmResponse: LlmResponse;
     }): Promise<LlmResponse | undefined>;
     /**
      * Runs the `onToolErrorCallback` for all plugins.
      */
-    runOnToolErrorCallback({ tool, toolArgs, toolContext, error }: {
+    runOnToolErrorCallback({ tool, toolArgs, toolContext, error, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
         toolContext: ToolContext;

package/dist/types/plugins/security_plugin.d.ts

@@ -29,7 +29,7 @@ export interface BasePolicyEngine {
     evaluate(context: ToolCallPolicyContext): Promise<PolicyCheckResult>;
 }
 export declare class InMemoryPolicyEngine implements BasePolicyEngine {
-    evaluate(context: ToolCallPolicyContext): Promise<PolicyCheckResult>;
+    evaluate(): Promise<PolicyCheckResult>;
 }
 /**
  *  Security Plugin for running Orcas agents.

package/dist/types/runner/runner.d.ts

@@ -40,6 +40,21 @@ export declare class Runner {
     readonly memoryService?: BaseMemoryService;
     readonly credentialService?: BaseCredentialService;
     constructor(input: RunnerConfig);
+    /**
+     * Runs the agent with a new, ephemeral session.
+     *
+     * @param params.userId The user ID of the session.
+     * @param params.newMessage A new message to append to the session.
+     * @param params.stateDelta An optional state delta to apply to the session.
+     * @param params.runConfig The run config for the agent.
+     * @yields The Events generated by the agent.
+     */
+    runEphemeral(params: {
+        userId: string;
+        newMessage: Content;
+        stateDelta?: Record<string, unknown>;
+        runConfig?: RunConfig;
+    }): AsyncGenerator<Event, void, undefined>;
     /**
      * Runs the agent with the given message, and returns an async generator of
      * events.
@@ -55,7 +70,7 @@ export declare class Runner {
         userId: string;
         sessionId: string;
         newMessage: Content;
-        stateDelta?: Record<string, any>;
+        stateDelta?: Record<string, unknown>;
         runConfig?: RunConfig;
     }): AsyncGenerator<Event, void, undefined>;
     /**

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

@@ -99,6 +99,13 @@ export declare abstract class BaseSessionService {
      *     found.
      */
     abstract getSession(request: GetSessionRequest): Promise<Session | undefined>;
+    /**
+     * Gets a session or creates one if it doesn't exist.
+     *
+     * @param request The request to get or create a session.
+     * @return A promise that resolves to the session instance.
+     */
+    getOrCreateSession(request: CreateSessionRequest): Promise<Session>;
     /**
      * Lists sessions for a user.
      *
@@ -127,3 +134,16 @@ export declare abstract class BaseSessionService {
      */
     private updateSessionState;
 }
+/**
+ * Removes temporary state delta keys from the event.
+ */
+export declare function trimTempDeltaState(event: Event): Event;
+/**
+ * Merges app state, user state, and session state.
+ *
+ * @param appState The application state.
+ * @param userState The user state.
+ * @param sessionState The session state.
+ * @return The merged state.
+ */
+export declare function mergeStates(appState?: Record<string, unknown>, userState?: Record<string, unknown>, sessionState?: Record<string, unknown>): Record<string, unknown>;

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

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Options as MikroDBOptions } from '@mikro-orm/core';
+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 a URI is a database connection URI.
+ *
+ * @param uri The URI to check.
+ * @returns True if the URI is a database connection URI, false otherwise.
+ */
+export declare function isDatabaseConnectionString(uri?: string): boolean;
+/**
+ * A session service that uses a SQL database for storage via MikroORM.
+ */
+export declare class DatabaseSessionService extends BaseSessionService {
+    private orm?;
+    private initialized;
+    private options;
+    constructor(connectionStringOrOptions: MikroDBOptions | string);
+    init(): Promise<void>;
+    createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
+    getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
+    listSessions({ appName, userId, }: ListSessionsRequest): Promise<ListSessionsResponse>;
+    deleteSession({ appName, userId, sessionId, }: DeleteSessionRequest): Promise<void>;
+    appendEvent({ session, event, }: AppendEventRequest): Promise<Event>;
+}

package/dist/types/sessions/db/operations.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MikroORM, Options as MikroORMOptions } from '@mikro-orm/core';
+/**
+ * Parses a database connection URI and returns MikroORM Options.
+ *
+ * @param uri The database connection URI (e.g., "postgres://user:password@host:port/database")
+ * @returns MikroORM Options configured for the database
+ * @throws Error if the URI is invalid or unsupported
+ */
+export declare function getConnectionOptionsFromUri(uri: string): MikroORMOptions;
+/**
+ * Creates a database and tables if they don't exist.
+ *
+ * @param url The database connection URI (e.g., "postgres://user:password@host:port/database")
+ * @returns Promise<void>
+ * @throws Error if the URI is invalid or unsupported
+ */
+export declare function ensureDatabaseCreated(ormOrUrlOrOptions: MikroORM | MikroORMOptions | string): Promise<void>;
+/**
+ * Validates the schema version.
+ *
+ * @param orm The MikroORM instance.
+ * @throws Error if the schema version is not compatible.
+ */
+export declare function validateDatabaseSchemaVersion(orm: MikroORM): Promise<void>;

package/dist/types/sessions/db/schema.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { PrimaryKey } from '@mikro-orm/core';
+import { Event } from '../../events/event.js';
+export declare const SCHEMA_VERSION_KEY = "schema_version";
+export declare const SCHEMA_VERSION_1_JSON = "1";
+export declare class StorageMetadata {
+    key: string;
+    value: string;
+}
+export declare class StorageAppState {
+    appName: string;
+    state: Record<string, unknown>;
+    updateTime: Date;
+}
+export declare class StorageUserState {
+    [PrimaryKey.name]?: [string, string] | undefined;
+    appName: string;
+    userId: string;
+    state: Record<string, unknown>;
+    updateTime: Date;
+}
+export declare class StorageSession {
+    [PrimaryKey.name]?: [string, string, string] | undefined;
+    id: string;
+    appName: string;
+    userId: string;
+    state: Record<string, unknown>;
+    createTime: Date;
+    updateTime: Date;
+}
+export declare class StorageEvent {
+    [PrimaryKey.name]?: [string, string, string, string] | undefined;
+    id: string;
+    appName: string;
+    userId: string;
+    sessionId: string;
+    invocationId: string;
+    timestamp: Date;
+    eventData: Event;
+}
+export declare const ENTITIES: (typeof StorageMetadata | typeof StorageAppState | typeof StorageEvent)[];

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

@@ -1,6 +1,10 @@
 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 an in-memory memory service URI.
+ */
+export declare function isInMemoryConnectionString(uri?: string): boolean;
 /**
  * An in-memory implementation of the session service.
  */
@@ -18,10 +22,9 @@ export declare class InMemorySessionService extends BaseSessionService {
      * A map from app name to a map from key to the value.
      */
     private appState;
-    createSession({ appName, userId, state, sessionId }: CreateSessionRequest): Promise<Session>;
-    getSession({ appName, userId, sessionId, config }: GetSessionRequest): Promise<Session | undefined>;
-    listSessions({ appName, userId }: ListSessionsRequest): Promise<ListSessionsResponse>;
-    deleteSession({ appName, userId, sessionId }: DeleteSessionRequest): Promise<void>;
-    appendEvent({ session, event }: AppendEventRequest): Promise<Event>;
-    private mergeState;
+    createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;
+    getSession({ appName, userId, sessionId, config, }: GetSessionRequest): Promise<Session | undefined>;
+    listSessions({ appName, userId, }: ListSessionsRequest): Promise<ListSessionsResponse>;
+    deleteSession({ appName, userId, sessionId, }: DeleteSessionRequest): Promise<void>;
+    appendEvent({ session, event, }: AppendEventRequest): Promise<Event>;
 }

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

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseSessionService } from './base_session_service.js';
+export declare function getSessionServiceFromUri(uri: string): BaseSessionService;

package/dist/types/telemetry/setup.d.ts

@@ -3,9 +3,9 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { Resource } from '@opentelemetry/resources';
 import { LogRecordProcessor } from '@opentelemetry/sdk-logs';
 import { MetricReader } from '@opentelemetry/sdk-metrics';
-import { Resource } from '@opentelemetry/resources';
 import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
 export interface OtelExportersConfig {
     enableTracing?: boolean;

package/dist/types/telemetry/tracing.d.ts

@@ -101,11 +101,12 @@ export interface TraceSendDataParams {
  */
 export declare function traceSendData({ invocationContext, eventId, data, }: TraceSendDataParams): void;
 /**
- * Binds an async generator to OpenTelemetry context for trace propagation.
- * This is a temporary solution.
- * @param ctx - The OpenTelemetry context to bind the generator to
- * @param generator - The async generator to be bound to the context
+ * Runs an async generator function with both OTEL context and JavaScript 'this' context.
  *
- * @returns A new async generator that executes all operations within the provided context
+ * @param otelContext - The OpenTelemetry context to bind the generator to
+ * @param generatorFnContext - The 'this' context to bind to the generator function
+ * @param generatorFn - The generator function to execute
+ *
+ * @returns A new async generator that executes within both contexts
  */
-export declare function bindAsyncGenerator<T = unknown, TReturn = any, TNext = unknown>(ctx: Context, generator: AsyncGenerator<T, TReturn, TNext>): AsyncGenerator<T, TReturn, TNext>;
+export declare function runAsyncGeneratorWithOtelContext<TThis, T>(otelContext: Context, generatorFnContext: TThis, generatorFn: (this: TThis) => AsyncGenerator<T, void, void>): AsyncGenerator<T, void, void>;

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

@@ -46,6 +46,6 @@ export declare class AgentTool extends BaseTool {
     private readonly skipSummarization;
     constructor(config: AgentToolConfig);
     _getDeclaration(): FunctionDeclaration;
-    runAsync({ args, toolContext }: RunAsyncToolRequest): Promise<unknown>;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
 }
 export {};

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

@@ -89,7 +89,7 @@ export declare abstract class BaseTool {
      *
      * @param request The request to process the LLM request.
      */
-    processLlmRequest({ toolContext, llmRequest }: ToolProcessLlmRequest): Promise<void>;
+    processLlmRequest({ llmRequest }: ToolProcessLlmRequest): Promise<void>;
     /**
      * The Google API LLM variant to use.
      */

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

@@ -60,5 +60,6 @@ export declare abstract class BaseToolset {
      * @param toolContext The context of the tool.
      * @param llmRequest The outgoing LLM request, mutable this method.
      */
-    processLlmRequest(toolContext: ToolContext, llmRequest: LlmRequest): Promise<void>;
+    processLlmRequest(toolContext: ToolContext, // eslint-disable-line @typescript-eslint/no-unused-vars
+    llmRequest: LlmRequest): Promise<void>;
 }

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Part } from '@google/genai';
-import { BaseArtifactService, DeleteArtifactRequest, ListArtifactKeysRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from '../artifacts/base_artifact_service.js';
+import { ArtifactVersion, BaseArtifactService, DeleteArtifactRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from '../artifacts/base_artifact_service.js';
 import { ToolContext } from './tool_context.js';
 /**
  * Artifact service that forwards to the parent tool context.
@@ -15,7 +15,9 @@ export declare class ForwardingArtifactService implements BaseArtifactService {
     constructor(toolContext: ToolContext);
     saveArtifact(request: SaveArtifactRequest): Promise<number>;
     loadArtifact(request: LoadArtifactRequest): Promise<Part | undefined>;
-    listArtifactKeys(request: ListArtifactKeysRequest): Promise<string[]>;
+    listArtifactKeys(): Promise<string[]>;
     deleteArtifact(request: DeleteArtifactRequest): Promise<void>;
     listVersions(request: ListVersionsRequest): Promise<number[]>;
+    listArtifactVersions(request: ListVersionsRequest): Promise<ArtifactVersion[]>;
+    getArtifactVersion(request: LoadArtifactRequest): Promise<ArtifactVersion | undefined>;
 }

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

@@ -4,14 +4,15 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { FunctionDeclaration, Schema } from '@google/genai';
-import { type infer as zInfer, ZodObject, type ZodRawShape } from 'zod';
+import { z as z3 } from 'zod/v3';
+import { z as z4 } from 'zod/v4';
 import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
 import { ToolContext } from './tool_context.js';
 /**
  * Input parameters of the function tool.
  */
-export type ToolInputParameters = undefined | ZodObject<ZodRawShape> | Schema;
-export type ToolExecuteArgument<TParameters extends ToolInputParameters> = TParameters extends ZodObject<infer T, infer U, infer V> ? zInfer<ZodObject<T, U, V>> : TParameters extends Schema ? unknown : string;
+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?: ToolContext) => Promise<unknown> | unknown;
 /**
  * The configuration options for creating a function-based tool.

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

@@ -1,4 +1,4 @@
-import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+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.
@@ -8,8 +8,8 @@ import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_too
  */
 export declare class GoogleSearchTool extends BaseTool {
     constructor();
-    runAsync(request: RunAsyncToolRequest): Promise<unknown>;
-    processLlmRequest({ toolContext, llmRequest, }: ToolProcessLlmRequest): Promise<void>;
+    runAsync(): Promise<unknown>;
+    processLlmRequest({ llmRequest, }: ToolProcessLlmRequest): Promise<void>;
 }
 /**
  * A global instance of {@link GoogleSearchTool}.

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

@@ -5,6 +5,7 @@
  */
 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
@@ -13,7 +14,7 @@ import { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js
 export interface StdioConnectionParams {
     type: 'StdioConnectionParams';
     serverParams: StdioServerParameters;
-    timeout?: Number;
+    timeout?: number;
 }
 /**
  * Defines the parameters for establishing a connection to an MCP server over
@@ -28,10 +29,16 @@ export interface StdioConnectionParams {
 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;
+    timeout?: number;
+    sseReadTimeout?: number;
     terminateOnClose?: boolean;
+    transportOptions?: StreamableHTTPClientTransportOptions;
 }
 /**
  * A union of all supported MCP connection parameter types.

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

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

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

@@ -29,3 +29,10 @@ export declare function base64Decode(data: string): string;
  * @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/gemini_schema_util.d.ts

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