@google/adk 0.5.0 → 0.6.1

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

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

package/dist/web/a2a/a2a_event.js

@@ -9,6 +9,16 @@ var MessageRole = /* @__PURE__ */ ((MessageRole2) => {
   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";
 }
@@ -31,13 +41,18 @@ function getEventMetadata(event) {
   return {};
 }
 function isFailedTaskStatusUpdateEvent(event) {
-  return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "failed";
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "failed" /* FAILED */;
 }
 function isTerminalTaskStatusUpdateEvent(event) {
-  return (isTaskStatusUpdateEvent(event) || isTask(event)) && ["completed", "failed", "canceled", "rejected"].includes(event.status.state);
+  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";
+  return (isTaskStatusUpdateEvent(event) || isTask(event)) && event.status.state === "input-required" /* INPUT_REQUIRED */;
 }
 function getFailedTaskStatusUpdateEventError(event) {
   var _a;
@@ -56,7 +71,8 @@ function getFailedTaskStatusUpdateEventError(event) {
 function createTaskSubmittedEvent({
   taskId,
   contextId,
-  message
+  message,
+  metadata
 }) {
   return {
     kind: "status-update",
@@ -64,16 +80,18 @@ function createTaskSubmittedEvent({
     contextId,
     final: false,
     status: {
-      state: "submitted",
+      state: "submitted" /* SUBMITTED */,
       message,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
+    },
+    metadata
   };
 }
 function createTask({
   contextId,
   message,
-  taskId
+  taskId,
+  metadata
 }) {
   return {
     kind: "task",
@@ -81,15 +99,17 @@ function createTask({
     contextId,
     history: [message],
     status: {
-      state: "submitted",
+      state: "submitted" /* SUBMITTED */,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
+    },
+    metadata
   };
 }
 function createTaskWorkingEvent({
   taskId,
   contextId,
-  message
+  message,
+  metadata
 }) {
   return {
     kind: "status-update",
@@ -97,16 +117,17 @@ function createTaskWorkingEvent({
     contextId,
     final: false,
     status: {
-      state: "working",
+      state: "working" /* WORKING */,
       message,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
+    },
+    metadata
   };
 }
 function createTaskCompletedEvent({
   taskId,
   contextId,
-  metadata = {}
+  metadata
 }) {
   return {
     kind: "status-update",
@@ -114,7 +135,7 @@ function createTaskCompletedEvent({
     contextId,
     final: true,
     status: {
-      state: "completed",
+      state: "completed" /* COMPLETED */,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     },
     metadata
@@ -137,9 +158,9 @@ function createTaskArtifactUpdateEvent({
     lastChunk,
     artifact: {
       artifactId: artifactId || randomUUID(),
-      parts,
-      metadata
-    }
+      parts
+    },
+    metadata
   };
 }
 function createTaskFailedEvent({
@@ -152,8 +173,9 @@ function createTaskFailedEvent({
     kind: "status-update",
     taskId,
     contextId,
+    final: true,
     status: {
-      state: "failed",
+      state: "failed" /* FAILED */,
       message: {
         kind: "message",
         messageId: randomUUID(),
@@ -169,14 +191,14 @@ function createTaskFailedEvent({
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     },
-    metadata,
-    final: true
+    metadata
   };
 }
 function createTaskInputRequiredEvent({
   taskId,
   contextId,
-  parts
+  parts,
+  metadata
 }) {
   return {
     kind: "status-update",
@@ -184,7 +206,7 @@ function createTaskInputRequiredEvent({
     contextId,
     final: true,
     status: {
-      state: "input-required",
+      state: "input-required" /* INPUT_REQUIRED */,
       message: {
         kind: "message",
         messageId: randomUUID(),
@@ -194,13 +216,15 @@ function createTaskInputRequiredEvent({
         parts
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
+    },
+    metadata
   };
 }
 function createInputMissingErrorEvent({
   taskId,
   contextId,
-  parts
+  parts,
+  metadata
 }) {
   return {
     kind: "status-update",
@@ -208,7 +232,7 @@ function createInputMissingErrorEvent({
     contextId,
     final: true,
     status: {
-      state: "input-required",
+      state: "input-required" /* INPUT_REQUIRED */,
       message: {
         kind: "message",
         messageId: randomUUID(),
@@ -218,11 +242,13 @@ function createInputMissingErrorEvent({
         parts
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
+    },
+    metadata
   };
 }
 export {
   MessageRole,
+  TaskState,
   createInputMissingErrorEvent,
   createTask,
   createTaskArtifactUpdateEvent,

package/dist/web/a2a/a2a_remote_agent.js

@@ -0,0 +1,184 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+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 && !a2aConfig.client) {
+      throw new Error("Either AgentCard or Client must be provided");
+    }
+  }
+  async init() {
+    if (this.isInitialized) {
+      return;
+    }
+    if (this.a2aConfig.client) {
+      this.client = this.a2aConfig.client;
+    }
+    if (this.a2aConfig.agentCard) {
+      this.card = await resolveAgentCard(this.a2aConfig.agentCard);
+      if (!this.client) {
+        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: 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 = this.card ? ((_b = this.card.capabilities) == null ? void 0 : _b.streaming) !== false : true;
+        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
+};

package/dist/web/a2a/a2a_remote_agent_run_processor.js

@@ -0,0 +1,182 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  createModelContent
+} from "@google/genai";
+import { createEvent } from "../events/event.js";
+import {
+  getEventMetadata,
+  isTask,
+  isTaskArtifactUpdateEvent,
+  isTaskStatusUpdateEvent
+} from "./a2a_event.js";
+import { A2AMetadataKeys } from "./metadata_converter_utils.js";
+class A2ARemoteAgentRunProcessor {
+  constructor(request) {
+    this.request = request;
+    this.aggregations = /* @__PURE__ */ new Map();
+    this.aggregationOrder = [];
+  }
+  /**
+   * aggregatePartial stores contents of partial events to emit them with the terminal event.
+   * It can return multiple events to emit instead of just the provided one.
+   */
+  aggregatePartial(context, a2aEvent, adkEvent) {
+    const metadata = getEventMetadata(a2aEvent);
+    if (metadata[A2AMetadataKeys.PARTIAL]) {
+      return [adkEvent];
+    }
+    if (isTaskStatusUpdateEvent(a2aEvent) && a2aEvent.final) {
+      const events = [];
+      for (const aid of this.aggregationOrder) {
+        const agg = this.aggregations.get(aid);
+        if (agg) {
+          events.push(this.buildNonPartialAggregation(context, agg));
+        }
+      }
+      this.aggregations.clear();
+      this.aggregationOrder = [];
+      return [...events, adkEvent];
+    }
+    if (isTask(a2aEvent)) {
+      this.aggregations.clear();
+      this.aggregationOrder = [];
+      return [adkEvent];
+    }
+    if (!isTaskArtifactUpdateEvent(a2aEvent)) {
+      return [adkEvent];
+    }
+    const artifactId = a2aEvent.artifact.artifactId;
+    if (!a2aEvent.append) {
+      this.removeAggregation(artifactId);
+      if (a2aEvent.lastChunk) {
+        adkEvent.partial = false;
+        return [adkEvent];
+      }
+    }
+    let aggregation = this.aggregations.get(artifactId);
+    if (!aggregation) {
+      aggregation = {
+        aggregatedText: "",
+        aggregatedThoughts: "",
+        parts: []
+      };
+      this.aggregations.set(artifactId, aggregation);
+      this.aggregationOrder.push(artifactId);
+    } else {
+      this.aggregationOrder = this.aggregationOrder.filter(
+        (id) => id !== artifactId
+      );
+      this.aggregationOrder.push(artifactId);
+    }
+    this.updateAggregation(aggregation, adkEvent);
+    if (!a2aEvent.lastChunk) {
+      return [adkEvent];
+    }
+    this.removeAggregation(artifactId);
+    return [adkEvent, this.buildNonPartialAggregation(context, aggregation)];
+  }
+  removeAggregation(artifactId) {
+    this.aggregations.delete(artifactId);
+    this.aggregationOrder = this.aggregationOrder.filter(
+      (id) => id !== artifactId
+    );
+  }
+  updateAggregation(agg, event) {
+    var _a;
+    const parts = ((_a = event.content) == null ? void 0 : _a.parts) || [];
+    for (const part of parts) {
+      if (part.text && part.text !== "") {
+        if (part.thought) {
+          agg.aggregatedThoughts += part.text;
+        } else {
+          agg.aggregatedText += part.text;
+        }
+      } else {
+        this.promoteTextBlocksToParts(agg);
+        agg.parts.push(part);
+      }
+    }
+    if (event.citationMetadata) {
+      if (!agg.citations) {
+        agg.citations = { citations: [] };
+      }
+      if (!agg.citations.citations) {
+        agg.citations.citations = [];
+      }
+      agg.citations.citations.push(...event.citationMetadata.citations || []);
+    }
+    if (event.customMetadata) {
+      if (!agg.customMeta) {
+        agg.customMeta = {};
+      }
+      Object.assign(agg.customMeta, event.customMetadata);
+    }
+    if (event.groundingMetadata) {
+      agg.grounding = event.groundingMetadata;
+    }
+    if (event.usageMetadata) {
+      agg.usage = event.usageMetadata;
+    }
+  }
+  buildNonPartialAggregation(context, agg) {
+    this.promoteTextBlocksToParts(agg);
+    const result = createEvent({
+      author: context.agent.name,
+      invocationId: context.invocationId,
+      content: agg.parts.length > 0 ? createModelContent([...agg.parts]) : void 0,
+      customMetadata: agg.customMeta,
+      groundingMetadata: agg.grounding,
+      citationMetadata: agg.citations,
+      usageMetadata: agg.usage,
+      turnComplete: false,
+      partial: false
+    });
+    return result;
+  }
+  promoteTextBlocksToParts(agg) {
+    if (agg.aggregatedThoughts !== "") {
+      agg.parts.push({ thought: true, text: agg.aggregatedThoughts });
+      agg.aggregatedThoughts = "";
+    }
+    if (agg.aggregatedText !== "") {
+      agg.parts.push({ text: agg.aggregatedText });
+      agg.aggregatedText = "";
+    }
+  }
+  /**
+   * Adds request and response metadata to the event.
+   */
+  updateCustomMetadata(event, response) {
+    const toAdd = {};
+    if (this.request && event.turnComplete) {
+      toAdd["request"] = this.request;
+    }
+    if (response) {
+      toAdd["response"] = response;
+      if (isTask(response)) {
+        if (response.id) toAdd["task_id"] = response.id;
+        if (response.contextId) toAdd["context_id"] = response.contextId;
+      } else if (response.taskId) {
+        toAdd["task_id"] = response.taskId;
+        if (response.contextId) toAdd["context_id"] = response.contextId;
+      }
+    }
+    if (Object.keys(toAdd).length === 0) {
+      return;
+    }
+    if (!event.customMetadata) {
+      event.customMetadata = {};
+    }
+    for (const [k, v] of Object.entries(toAdd)) {
+      if (v === void 0 || v === null) continue;
+      event.customMetadata["a2a:".concat(k)] = v;
+    }
+  }
+}
+export {
+  A2ARemoteAgentRunProcessor
+};