@google/adk 0.5.0 → 0.6.0

package/README.md

@@ -1,3 +1,3 @@
 # @google/adk
 
-Please see README for adk-js at https://github.com/google/adk-js
+Please see README for adk-js at https://github.com/google/adk-js

package/dist/cjs/a2a/a2a_event.js

@@ -25,6 +25,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var a2a_event_exports = {};
 __export(a2a_event_exports, {
   MessageRole: () => MessageRole,
+  TaskState: () => TaskState,
   createInputMissingErrorEvent: () => createInputMissingErrorEvent,
   createTask: () => createTask,
   createTaskArtifactUpdateEvent: () => createTaskArtifactUpdateEvent,
@@ -55,6 +56,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";
 }
@@ -77,13 +88,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;
@@ -102,7 +118,8 @@ function getFailedTaskStatusUpdateEventError(event) {
 function createTaskSubmittedEvent({
   taskId,
   contextId,
-  message
+  message,
+  metadata
 }) {
   return {
     kind: "status-update",
@@ -110,16 +127,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",
@@ -127,15 +146,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",
@@ -143,16 +164,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",
@@ -160,7 +182,7 @@ function createTaskCompletedEvent({
     contextId,
     final: true,
     status: {
-      state: "completed",
+      state: "completed" /* COMPLETED */,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     },
     metadata
@@ -183,9 +205,9 @@ function createTaskArtifactUpdateEvent({
     lastChunk,
     artifact: {
       artifactId: artifactId || (0, import_env_aware_utils.randomUUID)(),
-      parts,
-      metadata
-    }
+      parts
+    },
+    metadata
   };
 }
 function createTaskFailedEvent({
@@ -198,8 +220,9 @@ function createTaskFailedEvent({
     kind: "status-update",
     taskId,
     contextId,
+    final: true,
     status: {
-      state: "failed",
+      state: "failed" /* FAILED */,
       message: {
         kind: "message",
         messageId: (0, import_env_aware_utils.randomUUID)(),
@@ -215,14 +238,14 @@ function createTaskFailedEvent({
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     },
-    metadata,
-    final: true
+    metadata
   };
 }
 function createTaskInputRequiredEvent({
   taskId,
   contextId,
-  parts
+  parts,
+  metadata
 }) {
   return {
     kind: "status-update",
@@ -230,7 +253,7 @@ function createTaskInputRequiredEvent({
     contextId,
     final: true,
     status: {
-      state: "input-required",
+      state: "input-required" /* INPUT_REQUIRED */,
       message: {
         kind: "message",
         messageId: (0, import_env_aware_utils.randomUUID)(),
@@ -240,13 +263,15 @@ function createTaskInputRequiredEvent({
         parts
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
+    },
+    metadata
   };
 }
 function createInputMissingErrorEvent({
   taskId,
   contextId,
-  parts
+  parts,
+  metadata
 }) {
   return {
     kind: "status-update",
@@ -254,7 +279,7 @@ function createInputMissingErrorEvent({
     contextId,
     final: true,
     status: {
-      state: "input-required",
+      state: "input-required" /* INPUT_REQUIRED */,
       message: {
         kind: "message",
         messageId: (0, import_env_aware_utils.randomUUID)(),
@@ -264,12 +289,14 @@ function createInputMissingErrorEvent({
         parts
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
+    },
+    metadata
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MessageRole,
+  TaskState,
   createInputMissingErrorEvent,
   createTask,
   createTaskArtifactUpdateEvent,

package/dist/cjs/a2a/a2a_remote_agent.js

@@ -0,0 +1,174 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var a2a_remote_agent_exports = {};
+__export(a2a_remote_agent_exports, {
+  AGENT_CARD_PATH: () => import_sdk.AGENT_CARD_PATH,
+  RemoteA2AAgent: () => RemoteA2AAgent
+});
+module.exports = __toCommonJS(a2a_remote_agent_exports);
+var import_sdk = require("@a2a-js/sdk");
+var import_client = require("@a2a-js/sdk/client");
+var import_base_agent = require("../agents/base_agent.js");
+var import_event = require("../events/event.js");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_logger = require("../utils/logger.js");
+var import_a2a_event = require("./a2a_event.js");
+var import_a2a_remote_agent_run_processor = require("./a2a_remote_agent_run_processor.js");
+var import_a2a_remote_agent_utils = require("./a2a_remote_agent_utils.js");
+var import_agent_card = require("./agent_card.js");
+var import_event_converter_utils = require("./event_converter_utils.js");
+var import_metadata_converter_utils = require("./metadata_converter_utils.js");
+var import_part_converter_utils = require("./part_converter_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class RemoteA2AAgent extends import_base_agent.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 (0, import_agent_card.resolveAgentCard)(this.a2aConfig.agentCard);
+    const factory = this.a2aConfig.clientFactory || new import_client.ClientFactory();
+    this.client = await factory.createFromAgentCard(this.card);
+    this.isInitialized = true;
+  }
+  async *runAsyncImpl(context) {
+    var _a, _b;
+    await this.init();
+    try {
+      const events = context.session.events;
+      if (events.length === 0) {
+        throw new Error("No events in session to send");
+      }
+      const userFnCall = (0, import_a2a_remote_agent_utils.getUserFunctionCallAt)(
+        context.session,
+        events.length - 1
+      );
+      let parts;
+      let taskId = void 0;
+      let contextId = void 0;
+      if (userFnCall) {
+        const event = userFnCall.response;
+        parts = (0, import_part_converter_utils.toA2AParts)(
+          ((_a = event.content) == null ? void 0 : _a.parts) || [],
+          event.longRunningToolIds
+        );
+        taskId = userFnCall.taskId;
+        contextId = userFnCall.contextId;
+      } else {
+        const missing = (0, import_a2a_remote_agent_utils.toMissingRemoteSessionParts)(context, context.session);
+        parts = missing.parts;
+        contextId = missing.contextId;
+      }
+      const message = {
+        kind: "message",
+        messageId: (0, import_env_aware_utils.randomUUID)(),
+        role: import_a2a_event.MessageRole.USER,
+        parts,
+        metadata: {
+          ...(0, import_metadata_converter_utils.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 import_a2a_remote_agent_run_processor.A2ARemoteAgentRunProcessor(params);
+      if (this.a2aConfig.beforeRequestCallbacks) {
+        for (const callback of this.a2aConfig.beforeRequestCallbacks) {
+          await callback(context, params);
+        }
+      }
+      const useStreaming = ((_b = this.card.capabilities) == null ? void 0 : _b.streaming) !== false;
+      if (useStreaming) {
+        for await (const chunk of this.client.sendMessageStream(params)) {
+          if (this.a2aConfig.afterRequestCallbacks) {
+            for (const callback of this.a2aConfig.afterRequestCallbacks) {
+              await callback(context, chunk);
+            }
+          }
+          const adkEvent = (0, import_event_converter_utils.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;
+          }
+        }
+      } else {
+        const result = await this.client.sendMessage(params);
+        if (this.a2aConfig.afterRequestCallbacks) {
+          for (const callback of this.a2aConfig.afterRequestCallbacks) {
+            await callback(context, result);
+          }
+        }
+        const adkEvent = (0, import_event_converter_utils.toAdkEvent)(result, context.invocationId, this.name);
+        if (adkEvent) {
+          processor.updateCustomMetadata(adkEvent, result);
+          yield adkEvent;
+        }
+      }
+    } catch (e) {
+      const error = e;
+      import_logger.logger.error(`A2ARemoteAgent ${this.name} failed:`, error);
+      yield (0, import_event.createEvent)({
+        author: this.name,
+        invocationId: context.invocationId,
+        errorMessage: error.message,
+        turnComplete: true
+      });
+    }
+  }
+  runLiveImpl(_context) {
+    throw new Error("Live mode is not supported in A2ARemoteAgent yet.");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_CARD_PATH,
+  RemoteA2AAgent
+});

package/dist/cjs/a2a/a2a_remote_agent_run_processor.js

@@ -0,0 +1,198 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var a2a_remote_agent_run_processor_exports = {};
+__export(a2a_remote_agent_run_processor_exports, {
+  A2ARemoteAgentRunProcessor: () => A2ARemoteAgentRunProcessor
+});
+module.exports = __toCommonJS(a2a_remote_agent_run_processor_exports);
+var import_genai = require("@google/genai");
+var import_event = require("../events/event.js");
+var import_a2a_event = require("./a2a_event.js");
+var import_metadata_converter_utils = require("./metadata_converter_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 = (0, import_a2a_event.getEventMetadata)(a2aEvent);
+    if (metadata[import_metadata_converter_utils.A2AMetadataKeys.PARTIAL]) {
+      return [adkEvent];
+    }
+    if ((0, import_a2a_event.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 ((0, import_a2a_event.isTask)(a2aEvent)) {
+      this.aggregations.clear();
+      this.aggregationOrder = [];
+      return [adkEvent];
+    }
+    if (!(0, import_a2a_event.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 = (0, import_event.createEvent)({
+      author: context.agent.name,
+      invocationId: context.invocationId,
+      content: agg.parts.length > 0 ? (0, import_genai.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 (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:${k}`] = v;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2ARemoteAgentRunProcessor
+});