@google/adk 0.4.0 → 0.6.0

package/dist/types/context/base_context_compactor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InvocationContext } from '../agents/invocation_context.js';
+/**
+ * Interface for compacting the context history in an agent session.
+ */
+export interface BaseContextCompactor {
+    /**
+     * Determines whether the context should be compacted.
+     *
+     * @param invocationContext The current invocation context.
+     * @returns A boolean or a promise resolving to a boolean indicating if compaction should occur.
+     */
+    shouldCompact(invocationContext: InvocationContext): boolean | Promise<boolean>;
+    /**
+     * Compacts the context in place.
+     *
+     * @param invocationContext The current invocation context.
+     */
+    compact(invocationContext: InvocationContext): void | Promise<void>;
+}

package/dist/types/context/summarizers/base_summarizer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from '../../events/event.js';
+import { CompactedEvent } from '../../events/compacted_event.js';
+/**
+ * Interface for summarizing a list of events into a single CompactedEvent.
+ */
+export interface BaseSummarizer {
+    /**
+     * Summarizes the given events into a CompactedEvent.
+     *
+     * @param events The events to summarize.
+     * @returns A promise resolving to the CompactedEvent representation of the events.
+     */
+    summarize(events: Event[]): Promise<CompactedEvent>;
+}

package/dist/types/context/summarizers/llm_summarizer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CompactedEvent } from '../../events/compacted_event.js';
+import { Event } from '../../events/event.js';
+import { BaseLlm } from '../../models/base_llm.js';
+import { BaseSummarizer } from './base_summarizer.js';
+export interface LlmSummarizerOptions {
+    llm: BaseLlm;
+    prompt?: string;
+}
+/**
+ * A summarizer that uses an LLM to generate a compacted representation
+ * of existing events.
+ */
+export declare class LlmSummarizer implements BaseSummarizer {
+    private readonly llm;
+    private readonly prompt;
+    constructor(options: LlmSummarizerOptions);
+    summarize(events: Event[]): Promise<CompactedEvent>;
+}

package/dist/types/context/token_based_context_compactor.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InvocationContext } from '../agents/invocation_context.js';
+import { BaseContextCompactor } from './base_context_compactor.js';
+import { BaseSummarizer } from './summarizers/base_summarizer.js';
+export interface TokenBasedContextCompactorOptions {
+    /** The maximum number of tokens to retain in the session history before compaction. */
+    tokenThreshold: number;
+    /**
+     * The minimum number of raw events to keep at the end of the session.
+     * Compaction will not affect these tail events (unless needed for tool splits).
+     */
+    eventRetentionSize: number;
+    /** The summarizer used to create the compacted event content. */
+    summarizer: BaseSummarizer;
+}
+/**
+ * A context compactor that uses token count to determine when to compact events.
+ * Oldest events are summarized into a CompactedEvent when the session
+ * history exceeds the token threshold.
+ */
+export declare class TokenBasedContextCompactor implements BaseContextCompactor {
+    private readonly tokenThreshold;
+    private readonly eventRetentionSize;
+    private readonly summarizer;
+    constructor(options: TokenBasedContextCompactorOptions);
+    private getActiveEvents;
+    shouldCompact(invocationContext: InvocationContext): boolean | Promise<boolean>;
+    compact(invocationContext: InvocationContext): Promise<void>;
+}

package/dist/types/context/truncating_context_compactor.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InvocationContext } from '../agents/invocation_context.js';
+import { BaseContextCompactor } from './base_context_compactor.js';
+export interface TruncatingContextCompactorOptions {
+    /** The maximum number of events to retain in the session history. */
+    threshold: number;
+    /** Keep the first X events in the history, which often act as the initial grounding prompt. */
+    preserveLeadingEvents?: number;
+}
+/**
+ * A simple context compactor that truncates the oldest events to get under
+ * the given threshold limit.
+ */
+export declare class TruncatingContextCompactor implements BaseContextCompactor {
+    private readonly threshold;
+    private readonly preserveLeadingEvents;
+    constructor(options: TruncatingContextCompactorOptions);
+    shouldCompact(invocationContext: InvocationContext): boolean;
+    compact(invocationContext: InvocationContext): void;
+}

package/dist/types/events/compacted_event.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Event } from './event.js';
+/**
+ * A specialized Event type that represents a synthesized summary of past events.
+ * This is used to compress session history without losing critical context.
+ */
+export interface CompactedEvent extends Event {
+    /**
+     * Identifies this event as a compacted event.
+     */
+    readonly isCompacted: true;
+    /**
+     * The start time of the context that was compacted.
+     */
+    startTime: number;
+    /**
+     * The end time of the context that was compacted.
+     */
+    endTime: number;
+    /**
+     * The summarized content of the compacted events.
+     */
+    compactedContent: string;
+}
+/**
+ * Type guard to check if an event is a CompactedEvent.
+ */
+export declare function isCompactedEvent(event: Event): event is CompactedEvent;
+export declare function createCompactedEvent(params?: Partial<CompactedEvent>): CompactedEvent;

package/dist/types/index.d.ts

@@ -3,6 +3,14 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+export { AGENT_CARD_PATH, RemoteA2AAgent } from './a2a/a2a_remote_agent.js';
+export type { A2AStreamEventData, AfterA2ARequestCallback, BeforeA2ARequestCallback, RemoteA2AAgentConfig, } from './a2a/a2a_remote_agent.js';
+export { getA2AAgentCard } from './a2a/agent_card.js';
+export { A2AAgentExecutor } from './a2a/agent_executor.js';
+export type { AfterEventCallback, AfterExecuteCallback, AgentExecutorConfig, BeforeExecuteCallback, RunnerOrRunnerConfig, } from './a2a/agent_executor.js';
+export { toA2a } from './a2a/agent_to_a2a.js';
+export type { ToA2aOptions } from './a2a/agent_to_a2a.js';
+export type { ExecutorContext } from './a2a/executor_context.js';
 export { FileArtifactService } from './artifacts/file_artifact_service.js';
 export { GcsArtifactService } from './artifacts/gcs_artifact_service.js';
 export { getArtifactServiceFromUri } from './artifacts/registry.js';

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

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Content, FinishReason, GenerateContentResponse, GenerateContentResponseUsageMetadata, GroundingMetadata, LiveServerSessionResumptionUpdate, Transcription } from '@google/genai';
+import { CitationMetadata, Content, FinishReason, GenerateContentResponse, GenerateContentResponseUsageMetadata, GroundingMetadata, LiveServerSessionResumptionUpdate, Transcription } from '@google/genai';
 /**
  * LLM response class that provides the first candidate response from the
  * model if available. Otherwise, returns error code and message.
@@ -17,6 +17,10 @@ export interface LlmResponse {
      * The grounding metadata of the response.
      */
     groundingMetadata?: GroundingMetadata;
+    /**
+     * The citation metadata of the response.
+     */
+    citationMetadata?: CitationMetadata;
     /**
      * Indicates whether the text content is part of a unfinished text stream.
      * Only used for streaming mode and when the content is plain text.

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

@@ -5,13 +5,12 @@
  */
 import { Content } from '@google/genai';
 import { BaseAgent } from '../agents/base_agent.js';
-import { CallbackContext } from '../agents/callback_context.js';
+import { Context } from '../agents/context.js';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event } from '../events/event.js';
 import { LlmRequest } from '../models/llm_request.js';
 import { LlmResponse } from '../models/llm_response.js';
 import { BaseTool } from '../tools/base_tool.js';
-import { ToolContext } from '../tools/tool_context.js';
 /**
  * Base class for creating plugins.
  *
@@ -60,7 +59,7 @@ import { ToolContext } from '../tools/tool_context.js';
  *     {tool, toolArgs, toolContext}: {
  *       tool: BaseTool,
  *       toolArgs: Record<string, unknown>,
- *       toolContext: ToolContext,
+ *       toolContext: Context,
  *     },
  *   ): Promise<Record<string, unknown> | undefined> {
  *     this.logger.info(
@@ -75,7 +74,7 @@ import { ToolContext } from '../tools/tool_context.js';
  *     {tool, toolArgs, toolContext, result}: {
  *       tool: BaseTool,
  *       toolArgs: Record<string, unknown>,
- *       toolContext: ToolContext,
+ *       toolContext: Context,
  *       result: Record<string, unknown>,
  *     },
  *   ): Promise<Record<string, unknown> | undefined> {
@@ -177,7 +176,7 @@ export declare abstract class BasePlugin {
      */
     beforeAgentCallback(params: {
         agent: BaseAgent;
-        callbackContext: CallbackContext;
+        callbackContext: Context;
     }): Promise<Content | undefined>;
     /**
      * Callback executed after an agent's primary logic has completed.
@@ -193,7 +192,7 @@ export declare abstract class BasePlugin {
      */
     afterAgentCallback(params: {
         agent: BaseAgent;
-        callbackContext: CallbackContext;
+        callbackContext: Context;
     }): Promise<Content | undefined>;
     /**
      * Callback executed before a request is sent to the model.
@@ -209,7 +208,7 @@ export declare abstract class BasePlugin {
      *     `undefined` allows the LLM request to proceed normally.
      */
     beforeModelCallback(params: {
-        callbackContext: CallbackContext;
+        callbackContext: Context;
         llmRequest: LlmRequest;
     }): Promise<LlmResponse | undefined>;
     /**
@@ -225,7 +224,7 @@ export declare abstract class BasePlugin {
      *     allows the original response to be used.
      */
     afterModelCallback(params: {
-        callbackContext: CallbackContext;
+        callbackContext: Context;
         llmResponse: LlmResponse;
     }): Promise<LlmResponse | undefined>;
     /**
@@ -243,7 +242,7 @@ export declare abstract class BasePlugin {
      *     the original error to be raised.
      */
     onModelErrorCallback(params: {
-        callbackContext: CallbackContext;
+        callbackContext: Context;
         llmRequest: LlmRequest;
         error: Error;
     }): Promise<LlmResponse | undefined>;
@@ -264,7 +263,7 @@ export declare abstract class BasePlugin {
     beforeToolCallback(params: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
-        toolContext: ToolContext;
+        toolContext: Context;
     }): Promise<Record<string, unknown> | undefined>;
     /**
      * Callback executed after a tool has been called.
@@ -284,14 +283,14 @@ export declare abstract class BasePlugin {
     afterToolCallback(params: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
-        toolContext: ToolContext;
+        toolContext: Context;
         result: Record<string, unknown>;
     }): Promise<Record<string, unknown> | undefined>;
     /**
      * Callback executed when a tool call encounters an error.
       tool: BaseTool;
       toolArgs: Record<string, unknown>;
-      toolContext: ToolContext;
+      toolContext: Context;
       result: Record<string, unknown>;
     }): Promise<Record<string, unknown> | undefined> {
       return;
@@ -314,7 +313,7 @@ export declare abstract class BasePlugin {
     onToolErrorCallback(params: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
-        toolContext: ToolContext;
+        toolContext: Context;
         error: Error;
     }): Promise<Record<string, unknown> | undefined>;
 }

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

@@ -5,13 +5,12 @@
  */
 import { Content } from '@google/genai';
 import { BaseAgent } from '../agents/base_agent.js';
-import { CallbackContext } from '../agents/callback_context.js';
+import { Context } from '../agents/context.js';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event } from '../events/event.js';
 import { LlmRequest } from '../models/llm_request.js';
 import { LlmResponse } from '../models/llm_response.js';
 import { BaseTool } from '../tools/base_tool.js';
-import { ToolContext } from '../tools/tool_context.js';
 import { BasePlugin } from './base_plugin.js';
 /**
  * A plugin that logs important information at each callback point.
@@ -62,40 +61,40 @@ export declare class LoggingPlugin extends BasePlugin {
     }): Promise<void>;
     beforeAgentCallback({ callbackContext, }: {
         agent: BaseAgent;
-        callbackContext: CallbackContext;
+        callbackContext: Context;
     }): Promise<Content | undefined>;
     afterAgentCallback({ callbackContext, }: {
         agent: BaseAgent;
-        callbackContext: CallbackContext;
+        callbackContext: Context;
     }): Promise<Content | undefined>;
     beforeModelCallback({ callbackContext, llmRequest, }: {
-        callbackContext: CallbackContext;
+        callbackContext: Context;
         llmRequest: LlmRequest;
     }): Promise<LlmResponse | undefined>;
     afterModelCallback({ callbackContext, llmResponse, }: {
-        callbackContext: CallbackContext;
+        callbackContext: Context;
         llmResponse: LlmResponse;
     }): Promise<LlmResponse | undefined>;
     beforeToolCallback({ tool, toolArgs, toolContext, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
-        toolContext: ToolContext;
+        toolContext: Context;
     }): Promise<Record<string, unknown> | undefined>;
     afterToolCallback({ tool, toolContext, result, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
-        toolContext: ToolContext;
+        toolContext: Context;
         result: Record<string, unknown>;
     }): Promise<Record<string, unknown> | undefined>;
     onModelErrorCallback({ callbackContext, error, }: {
-        callbackContext: CallbackContext;
+        callbackContext: Context;
         llmRequest: LlmRequest;
         error: Error;
     }): Promise<LlmResponse | undefined>;
     onToolErrorCallback({ tool, toolArgs, toolContext, error, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
-        toolContext: ToolContext;
+        toolContext: Context;
         error: Error;
     }): Promise<Record<string, unknown> | undefined>;
     private log;

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

@@ -5,13 +5,12 @@
  */
 import { Content } from '@google/genai';
 import { BaseAgent } from '../agents/base_agent.js';
-import { CallbackContext } from '../agents/callback_context.js';
+import { Context } from '../agents/context.js';
 import { InvocationContext } from '../agents/invocation_context.js';
 import { Event } from '../events/event.js';
 import { LlmRequest } from '../models/llm_request.js';
 import { LlmResponse } from '../models/llm_response.js';
 import { BaseTool } from '../tools/base_tool.js';
-import { ToolContext } from '../tools/tool_context.js';
 import { BasePlugin } from './base_plugin.js';
 /**
  * Manages the registration and execution of plugins.
@@ -95,14 +94,14 @@ export declare class PluginManager {
      */
     runBeforeAgentCallback({ agent, callbackContext, }: {
         agent: BaseAgent;
-        callbackContext: CallbackContext;
+        callbackContext: Context;
     }): Promise<Content | undefined>;
     /**
      * Runs the `afterAgentCallback` for all plugins.
      */
     runAfterAgentCallback({ agent, callbackContext, }: {
         agent: BaseAgent;
-        callbackContext: CallbackContext;
+        callbackContext: Context;
     }): Promise<Content | undefined>;
     /**
      * Runs the `beforeToolCallback` for all plugins.
@@ -110,7 +109,7 @@ export declare class PluginManager {
     runBeforeToolCallback({ tool, toolArgs, toolContext, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
-        toolContext: ToolContext;
+        toolContext: Context;
     }): Promise<Record<string, unknown> | undefined>;
     /**
      * Runs the `afterToolCallback` for all plugins.
@@ -118,14 +117,14 @@ export declare class PluginManager {
     runAfterToolCallback({ tool, toolArgs, toolContext, result, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
-        toolContext: ToolContext;
+        toolContext: Context;
         result: Record<string, unknown>;
     }): Promise<Record<string, unknown> | undefined>;
     /**
      * Runs the `onModelErrorCallback` for all plugins.
      */
     runOnModelErrorCallback({ callbackContext, llmRequest, error, }: {
-        callbackContext: CallbackContext;
+        callbackContext: Context;
         llmRequest: LlmRequest;
         error: Error;
     }): Promise<LlmResponse | undefined>;
@@ -133,14 +132,14 @@ export declare class PluginManager {
      * Runs the `beforeModelCallback` for all plugins.
      */
     runBeforeModelCallback({ callbackContext, llmRequest, }: {
-        callbackContext: CallbackContext;
+        callbackContext: Context;
         llmRequest: LlmRequest;
     }): Promise<LlmResponse | undefined>;
     /**
      * Runs the `afterModelCallback` for all plugins.
      */
     runAfterModelCallback({ callbackContext, llmResponse, }: {
-        callbackContext: CallbackContext;
+        callbackContext: Context;
         llmResponse: LlmResponse;
     }): Promise<LlmResponse | undefined>;
     /**
@@ -149,7 +148,7 @@ export declare class PluginManager {
     runOnToolErrorCallback({ tool, toolArgs, toolContext, error, }: {
         tool: BaseTool;
         toolArgs: Record<string, unknown>;
-        toolContext: ToolContext;
+        toolContext: Context;
         error: Error;
     }): Promise<Record<string, unknown> | undefined>;
 }

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

@@ -4,10 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { FunctionCall } from '@google/genai';
+import { Context } from '../agents/context.js';
 import { Event } from '../events/event.js';
 import { BasePlugin } from '../plugins/base_plugin.js';
 import { BaseTool } from '../tools/base_tool.js';
-import { ToolContext } from '../tools/tool_context.js';
 export declare const REQUEST_CONFIRMATION_FUNCTION_CALL_NAME = "adk_request_confirmation";
 /**
  * The outcome of a policy check.
@@ -44,7 +44,7 @@ export declare class SecurityPlugin extends BasePlugin {
         toolArgs: {
             [key: string]: unknown;
         };
-        toolContext: ToolContext;
+        toolContext: Context;
     }): Promise<{
         [key: string]: unknown;
     } | undefined>;

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

@@ -31,7 +31,19 @@ export interface RunnerConfig {
     memoryService?: BaseMemoryService;
     credentialService?: BaseCredentialService;
 }
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all Runner instances.
+ */
+declare const RUNNER_SIGNATURE_SYMBOL: unique symbol;
+/**
+ * Type guard to check if an object is an instance of Runner.
+ * @param obj The object to check.
+ * @returns True if the object is an instance of Runner, false otherwise.
+ */
+export declare function isRunner(obj: unknown): obj is Runner;
 export declare class Runner {
+    readonly [RUNNER_SIGNATURE_SYMBOL] = true;
     readonly appName: string;
     readonly agent: BaseAgent;
     readonly pluginManager: PluginManager;
@@ -101,3 +113,4 @@ export declare class Runner {
      */
     private isRoutableLlmAgent;
 }
+export {};

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

@@ -20,7 +20,8 @@ export declare function isDatabaseConnectionString(uri?: string): boolean;
 export declare class DatabaseSessionService extends BaseSessionService {
     private orm?;
     private initialized;
-    private options;
+    private options?;
+    private connectionString?;
     constructor(connectionStringOrOptions: MikroDBOptions | string);
     init(): Promise<void>;
     createSession({ appName, userId, state, sessionId, }: CreateSessionRequest): Promise<Session>;

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

@@ -11,15 +11,14 @@ import { MikroORM, Options as MikroORMOptions } from '@mikro-orm/core';
  * @returns MikroORM Options configured for the database
  * @throws Error if the URI is invalid or unsupported
  */
-export declare function getConnectionOptionsFromUri(uri: string): MikroORMOptions;
+export declare function getConnectionOptionsFromUri(uri: string): Promise<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")
+ * @param orm The MikroORM instance.
  * @returns Promise<void>
- * @throws Error if the URI is invalid or unsupported
  */
-export declare function ensureDatabaseCreated(ormOrUrlOrOptions: MikroORM | MikroORMOptions | string): Promise<void>;
+export declare function ensureDatabaseCreated(orm: MikroORM): Promise<void>;
 /**
  * Validates the schema version.
  *

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

@@ -5,19 +5,19 @@
  */
 import { FunctionDeclaration } from '@google/genai';
 import { LlmRequest } from '../models/llm_request.js';
-import { ToolContext } from './tool_context.js';
+import { Context } from '../agents/context.js';
 /**
  * The parameters for `runAsync`.
  */
 export interface RunAsyncToolRequest {
     args: Record<string, unknown>;
-    toolContext: ToolContext;
+    toolContext: Context;
 }
 /**
  * The parameters for `processLlmRequest`.
  */
 export interface ToolProcessLlmRequest {
-    toolContext: ToolContext;
+    toolContext: Context;
     llmRequest: LlmRequest;
 }
 /**

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

@@ -5,14 +5,20 @@
  */
 import { ReadonlyContext } from '../agents/readonly_context.js';
 import { LlmRequest } from '../models/llm_request.js';
+import { Context } from '../agents/context.js';
 import { BaseTool } from './base_tool.js';
-import { ToolContext } from './tool_context.js';
 /**
  * Function to decide whether a tool should be exposed to LLM. Toolset
  * implementer could consider whether to accept such instance in the toolset's
  * constructor and apply the predicate in getTools method.
  */
 export type ToolPredicate = (tool: BaseTool, readonlyContext: ReadonlyContext) => boolean;
+/**
+ * A unique symbol to identify ADK agent classes.
+ * Defined once and shared by all BaseTool instances.
+ */
+declare const BASE_TOOLSET_SIGNATURE_SYMBOL: unique symbol;
+export declare function isBaseToolset(obj: unknown): obj is BaseToolset;
 /**
  * Base class for toolset.
  *
@@ -20,7 +26,9 @@ export type ToolPredicate = (tool: BaseTool, readonlyContext: ReadonlyContext) =
  */
 export declare abstract class BaseToolset {
     readonly toolFilter: ToolPredicate | string[];
-    constructor(toolFilter: ToolPredicate | string[]);
+    readonly prefix?: string | undefined;
+    readonly [BASE_TOOLSET_SIGNATURE_SYMBOL] = true;
+    constructor(toolFilter: ToolPredicate | string[], prefix?: string | undefined);
     /**
      * Returns the tools that should be exposed to LLM.
      *
@@ -60,6 +68,7 @@ export declare abstract class BaseToolset {
      * @param toolContext The context of the tool.
      * @param llmRequest The outgoing LLM request, mutable this method.
      */
-    processLlmRequest(toolContext: ToolContext, // eslint-disable-line @typescript-eslint/no-unused-vars
+    processLlmRequest(toolContext: Context, // eslint-disable-line @typescript-eslint/no-unused-vars
     llmRequest: LlmRequest): Promise<void>;
 }
+export {};

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

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
+/**
+ * Tool for exiting execution of a {@link LoopAgent}.
+ *
+ * When called by an LLM agent inside a LoopAgent, this tool sets the
+ * `escalate` and `skipSummarization` flags on the event actions,
+ * causing the LoopAgent to stop iterating and exit the loop.
+ *
+ */
+export declare class ExitLoopTool extends BaseTool {
+    constructor();
+    _getDeclaration(): FunctionDeclaration;
+    runAsync({ toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+}
+/**
+ * A global instance of {@link ExitLoopTool}.
+ */
+export declare const EXIT_LOOP: ExitLoopTool;

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

@@ -5,14 +5,14 @@
  */
 import { Part } from '@google/genai';
 import { ArtifactVersion, BaseArtifactService, DeleteArtifactRequest, ListVersionsRequest, LoadArtifactRequest, SaveArtifactRequest } from '../artifacts/base_artifact_service.js';
-import { ToolContext } from './tool_context.js';
+import { Context } from '../agents/context.js';
 /**
  * Artifact service that forwards to the parent tool context.
  */
 export declare class ForwardingArtifactService implements BaseArtifactService {
     private readonly toolContext;
     private readonly invocationContext;
-    constructor(toolContext: ToolContext);
+    constructor(toolContext: Context);
     saveArtifact(request: SaveArtifactRequest): Promise<number>;
     loadArtifact(request: LoadArtifactRequest): Promise<Part | undefined>;
     listArtifactKeys(): Promise<string[]>;

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

@@ -6,14 +6,14 @@
 import { FunctionDeclaration, Schema } from '@google/genai';
 import { z as z3 } from 'zod/v3';
 import { z as z4 } from 'zod/v4';
+import { Context } from '../agents/context.js';
 import { BaseTool, RunAsyncToolRequest } from './base_tool.js';
-import { ToolContext } from './tool_context.js';
 /**
  * Input parameters of the function tool.
  */
 export type ToolInputParameters = z3.ZodObject<z3.ZodRawShape> | z4.ZodObject<z4.ZodRawShape> | Schema | undefined;
 export type ToolExecuteArgument<TParameters extends ToolInputParameters> = TParameters extends z3.ZodObject<infer T, infer U, infer V> ? z3.infer<z3.ZodObject<T, U, V>> : TParameters extends z4.ZodObject<infer T> ? z4.infer<z4.ZodObject<T>> : TParameters extends Schema ? unknown : string;
-export type ToolExecuteFunction<TParameters extends ToolInputParameters> = (input: ToolExecuteArgument<TParameters>, tool_context?: ToolContext) => Promise<unknown> | unknown;
+export type ToolExecuteFunction<TParameters extends ToolInputParameters> = (input: ToolExecuteArgument<TParameters>, tool_context?: Context) => Promise<unknown> | unknown;
 /**
  * The configuration options for creating a function-based tool.
  * The `name`, `description` and `parameters` fields are used to generate the