@google/adk 0.4.0 → 0.5.0

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/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,7 +11,7 @@ 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.
  *

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

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

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

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

@@ -1,8 +1,3 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
 /** Log levels for the logger. */
 export declare enum LogLevel {
     DEBUG = 0,
@@ -19,11 +14,8 @@ export interface Logger {
     info(...args: unknown[]): void;
     warn(...args: unknown[]): void;
     error(...args: unknown[]): void;
+    setLogLevel(level: LogLevel): void;
 }
-/**
- * Sets the log level for the logger.
- */
-export declare function setLogLevel(level: LogLevel): void;
 /**
  * Sets a custom logger for ADK, or null to disable logging.
  */
@@ -36,6 +28,10 @@ export declare function getLogger(): Logger;
  * Resets the logger to the default SimpleLogger.
  */
 export declare function resetLogger(): void;
+/**
+ * Sets the log level for the logger.
+ */
+export declare function setLogLevel(level: LogLevel): void;
 /**
  * The logger instance for ADK.
  */

package/dist/types/version.d.ts

@@ -3,4 +3,4 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export declare const version = "0.4.0";
+export declare const version = "0.5.0";

package/dist/web/a2a/a2a_event.js

@@ -0,0 +1,243 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { randomUUID } from "../utils/env_aware_utils.js";
+var MessageRole = /* @__PURE__ */ ((MessageRole2) => {
+  MessageRole2["USER"] = "user";
+  MessageRole2["AGENT"] = "agent";
+  return MessageRole2;
+})(MessageRole || {});
+function isTaskStatusUpdateEvent(event) {
+  return (event == null ? void 0 : event.kind) === "status-update";
+}
+function isTaskArtifactUpdateEvent(event) {
+  return (event == null ? void 0 : event.kind) === "artifact-update";
+}
+function isMessage(event) {
+  return (event == null ? void 0 : event.kind) === "message";
+}
+function isTask(event) {
+  return (event == null ? void 0 : event.kind) === "task";
+}
+function getEventMetadata(event) {
+  if (isTaskArtifactUpdateEvent(event)) {
+    return event.artifact.metadata || {};
+  }
+  if (isTaskStatusUpdateEvent(event) || isTask(event) || isMessage(event)) {
+    return event.metadata || {};
+  }
+  return {};
+}
+function isFailedTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "failed";
+}
+function isTerminalTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && ["completed", "failed", "canceled", "rejected"].includes(event.status.state);
+}
+function isInputRequiredTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "input-required";
+}
+function getFailedTaskStatusUpdateEventError(event) {
+  var _a;
+  if (!isFailedTaskStatusUpdateEvent(event)) {
+    return void 0;
+  }
+  const parts = ((_a = event.status.message) == null ? void 0 : _a.parts) || [];
+  if (parts.length === 0) {
+    return void 0;
+  }
+  if (parts[0].kind !== "text") {
+    return void 0;
+  }
+  return parts[0].text;
+}
+function createTaskSubmittedEvent({
+  taskId,
+  contextId,
+  message
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: false,
+    status: {
+      state: "submitted",
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createTask({
+  contextId,
+  message,
+  taskId
+}) {
+  return {
+    kind: "task",
+    id: taskId || randomUUID(),
+    contextId,
+    history: [message],
+    status: {
+      state: "submitted",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createTaskWorkingEvent({
+  taskId,
+  contextId,
+  message
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: false,
+    status: {
+      state: "working",
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createTaskCompletedEvent({
+  taskId,
+  contextId,
+  metadata = {}
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "completed",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTaskArtifactUpdateEvent({
+  taskId,
+  contextId,
+  artifactId,
+  parts = [],
+  metadata,
+  append,
+  lastChunk
+}) {
+  return {
+    kind: "artifact-update",
+    taskId,
+    contextId,
+    append,
+    lastChunk,
+    artifact: {
+      artifactId: artifactId || randomUUID(),
+      parts,
+      metadata
+    }
+  };
+}
+function createTaskFailedEvent({
+  taskId,
+  contextId,
+  error,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    status: {
+      state: "failed",
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts: [
+          {
+            kind: "text",
+            text: error.message
+          }
+        ]
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata,
+    final: true
+  };
+}
+function createTaskInputRequiredEvent({
+  taskId,
+  contextId,
+  parts
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "input-required",
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function createInputMissingErrorEvent({
+  taskId,
+  contextId,
+  parts
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "input-required",
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+export {
+  MessageRole,
+  createInputMissingErrorEvent,
+  createTask,
+  createTaskArtifactUpdateEvent,
+  createTaskCompletedEvent,
+  createTaskFailedEvent,
+  createTaskInputRequiredEvent,
+  createTaskSubmittedEvent,
+  createTaskWorkingEvent,
+  getEventMetadata,
+  getFailedTaskStatusUpdateEventError,
+  isFailedTaskStatusUpdateEvent,
+  isInputRequiredTaskStatusUpdateEvent,
+  isMessage,
+  isTask,
+  isTaskArtifactUpdateEvent,
+  isTaskStatusUpdateEvent,
+  isTerminalTaskStatusUpdateEvent
+};