@google/adk 0.4.0 → 0.6.0

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

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that loads the artifacts and adds them to the session.
+ */
+export declare class LoadArtifactsTool extends BaseTool {
+    constructor();
+    _getDeclaration(): FunctionDeclaration | undefined;
+    runAsync({ args }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+    private appendArtifactsToLlmRequest;
+}
+/**
+ * A global instance of {@link LoadArtifactsTool}.
+ */
+export declare const LOAD_ARTIFACTS: LoadArtifactsTool;

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

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { FunctionDeclaration } from '@google/genai';
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that loads the memory for the current user.
+ *
+ * NOTE: Currently this tool only uses text part from the memory.
+ */
+export declare class LoadMemoryTool extends BaseTool {
+    constructor();
+    _getDeclaration(): FunctionDeclaration | undefined;
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link LoadMemoryTool}.
+ */
+export declare const LOAD_MEMORY: LoadMemoryTool;

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/tools/preload_memory_tool.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { BaseTool, RunAsyncToolRequest, ToolProcessLlmRequest } from './base_tool.js';
+/**
+ * A tool that preloads the memory for the current user.
+ *
+ * This tool will be automatically executed for each llm_request, and it won't be
+ * called by the model.
+ *
+ * NOTE: Currently this tool only uses text part from the memory.
+ */
+export declare class PreloadMemoryTool extends BaseTool {
+    constructor();
+    runAsync({ args, toolContext, }: RunAsyncToolRequest): Promise<unknown>;
+    processLlmRequest(request: ToolProcessLlmRequest): Promise<void>;
+}
+/**
+ * A global instance of {@link PreloadMemoryTool}.
+ */
+export declare const PRELOAD_MEMORY: PreloadMemoryTool;

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.6.0";

package/dist/web/a2a/a2a_event.js

@@ -0,0 +1,269 @@
+/**
+ * @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 || {});
+var TaskState = /* @__PURE__ */ ((TaskState2) => {
+  TaskState2["SUBMITTED"] = "submitted";
+  TaskState2["WORKING"] = "working";
+  TaskState2["COMPLETED"] = "completed";
+  TaskState2["FAILED"] = "failed";
+  TaskState2["CANCELED"] = "canceled";
+  TaskState2["REJECTED"] = "rejected";
+  TaskState2["INPUT_REQUIRED"] = "input-required";
+  return TaskState2;
+})(TaskState || {});
+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" /* FAILED */;
+}
+function isTerminalTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && [
+    "completed" /* COMPLETED */,
+    "failed" /* FAILED */,
+    "canceled" /* CANCELED */,
+    "rejected" /* REJECTED */
+  ].includes(event.status.state);
+}
+function isInputRequiredTaskStatusUpdateEvent(event) {
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "input-required" /* 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,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: false,
+    status: {
+      state: "submitted" /* SUBMITTED */,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTask({
+  contextId,
+  message,
+  taskId,
+  metadata
+}) {
+  return {
+    kind: "task",
+    id: taskId || randomUUID(),
+    contextId,
+    history: [message],
+    status: {
+      state: "submitted" /* SUBMITTED */,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTaskWorkingEvent({
+  taskId,
+  contextId,
+  message,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: false,
+    status: {
+      state: "working" /* WORKING */,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTaskCompletedEvent({
+  taskId,
+  contextId,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "completed" /* 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,
+    final: true,
+    status: {
+      state: "failed" /* FAILED */,
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts: [
+          {
+            kind: "text",
+            text: error.message
+          }
+        ]
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createTaskInputRequiredEvent({
+  taskId,
+  contextId,
+  parts,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "input-required" /* INPUT_REQUIRED */,
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+function createInputMissingErrorEvent({
+  taskId,
+  contextId,
+  parts,
+  metadata
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    final: true,
+    status: {
+      state: "input-required" /* INPUT_REQUIRED */,
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "agent",
+        taskId,
+        contextId,
+        parts
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    metadata
+  };
+}
+export {
+  MessageRole,
+  TaskState,
+  createInputMissingErrorEvent,
+  createTask,
+  createTaskArtifactUpdateEvent,
+  createTaskCompletedEvent,
+  createTaskFailedEvent,
+  createTaskInputRequiredEvent,
+  createTaskSubmittedEvent,
+  createTaskWorkingEvent,
+  getEventMetadata,
+  getFailedTaskStatusUpdateEventError,
+  isFailedTaskStatusUpdateEvent,
+  isInputRequiredTaskStatusUpdateEvent,
+  isMessage,
+  isTask,
+  isTaskArtifactUpdateEvent,
+  isTaskStatusUpdateEvent,
+  isTerminalTaskStatusUpdateEvent
+};

package/dist/web/a2a/a2a_remote_agent.js

@@ -0,0 +1,193 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  AGENT_CARD_PATH
+} from "@a2a-js/sdk";
+import { ClientFactory } from "@a2a-js/sdk/client";
+import { BaseAgent } from "../agents/base_agent.js";
+import { createEvent } from "../events/event.js";
+import { randomUUID } from "../utils/env_aware_utils.js";
+import { logger } from "../utils/logger.js";
+import { MessageRole } from "./a2a_event.js";
+import { A2ARemoteAgentRunProcessor } from "./a2a_remote_agent_run_processor.js";
+import {
+  getUserFunctionCallAt,
+  toMissingRemoteSessionParts
+} from "./a2a_remote_agent_utils.js";
+import { resolveAgentCard } from "./agent_card.js";
+import { toAdkEvent } from "./event_converter_utils.js";
+import { getA2ASessionMetadata } from "./metadata_converter_utils.js";
+import { toA2AParts } from "./part_converter_utils.js";
+class RemoteA2AAgent extends BaseAgent {
+  constructor(a2aConfig) {
+    super(a2aConfig);
+    this.a2aConfig = a2aConfig;
+    this.isInitialized = false;
+    if (!a2aConfig.agentCard) {
+      throw new Error("AgentCard must be provided");
+    }
+  }
+  async init() {
+    if (this.isInitialized) {
+      return;
+    }
+    this.card = await resolveAgentCard(this.a2aConfig.agentCard);
+    const factory = this.a2aConfig.clientFactory || new ClientFactory();
+    this.client = await factory.createFromAgentCard(this.card);
+    this.isInitialized = true;
+  }
+  runAsyncImpl(context) {
+    return __asyncGenerator(this, null, function* () {
+      var _a, _b;
+      yield new __await(this.init());
+      try {
+        const events = context.session.events;
+        if (events.length === 0) {
+          throw new Error("No events in session to send");
+        }
+        const userFnCall = getUserFunctionCallAt(
+          context.session,
+          events.length - 1
+        );
+        let parts;
+        let taskId = void 0;
+        let contextId = void 0;
+        if (userFnCall) {
+          const event = userFnCall.response;
+          parts = toA2AParts(
+            ((_a = event.content) == null ? void 0 : _a.parts) || [],
+            event.longRunningToolIds
+          );
+          taskId = userFnCall.taskId;
+          contextId = userFnCall.contextId;
+        } else {
+          const missing = toMissingRemoteSessionParts(context, context.session);
+          parts = missing.parts;
+          contextId = missing.contextId;
+        }
+        const message = {
+          kind: "message",
+          messageId: randomUUID(),
+          role: MessageRole.USER,
+          parts,
+          metadata: __spreadValues({}, getA2ASessionMetadata({
+            appName: context.session.appName,
+            userId: context.session.userId,
+            sessionId: context.session.id
+          }))
+        };
+        if (taskId) message.taskId = taskId;
+        if (contextId) message.contextId = contextId;
+        const params = {
+          message,
+          configuration: this.a2aConfig.messageSendConfig
+        };
+        const processor = new A2ARemoteAgentRunProcessor(params);
+        if (this.a2aConfig.beforeRequestCallbacks) {
+          for (const callback of this.a2aConfig.beforeRequestCallbacks) {
+            yield new __await(callback(context, params));
+          }
+        }
+        const useStreaming = ((_b = this.card.capabilities) == null ? void 0 : _b.streaming) !== false;
+        if (useStreaming) {
+          try {
+            for (var iter = __forAwait(this.client.sendMessageStream(params)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+              const chunk = temp.value;
+              if (this.a2aConfig.afterRequestCallbacks) {
+                for (const callback of this.a2aConfig.afterRequestCallbacks) {
+                  yield new __await(callback(context, chunk));
+                }
+              }
+              const adkEvent = toAdkEvent(chunk, context.invocationId, this.name);
+              if (!adkEvent) {
+                continue;
+              }
+              processor.updateCustomMetadata(adkEvent, chunk);
+              const eventsToEmit = processor.aggregatePartial(
+                context,
+                chunk,
+                adkEvent
+              );
+              for (const ev of eventsToEmit) {
+                yield ev;
+              }
+            }
+          } catch (temp) {
+            error = [temp];
+          } finally {
+            try {
+              more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+            } finally {
+              if (error)
+                throw error[0];
+            }
+          }
+        } else {
+          const result = yield new __await(this.client.sendMessage(params));
+          if (this.a2aConfig.afterRequestCallbacks) {
+            for (const callback of this.a2aConfig.afterRequestCallbacks) {
+              yield new __await(callback(context, result));
+            }
+          }
+          const adkEvent = toAdkEvent(result, context.invocationId, this.name);
+          if (adkEvent) {
+            processor.updateCustomMetadata(adkEvent, result);
+            yield adkEvent;
+          }
+        }
+      } catch (e) {
+        const error2 = e;
+        logger.error("A2ARemoteAgent ".concat(this.name, " failed:"), error2);
+        yield createEvent({
+          author: this.name,
+          invocationId: context.invocationId,
+          errorMessage: error2.message,
+          turnComplete: true
+        });
+      }
+    });
+  }
+  runLiveImpl(_context) {
+    throw new Error("Live mode is not supported in A2ARemoteAgent yet.");
+  }
+}
+export {
+  AGENT_CARD_PATH,
+  RemoteA2AAgent
+};