@google/adk 0.4.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

@@ -0,0 +1,317 @@
+/**
+  * @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_event_exports = {};
+__export(a2a_event_exports, {
+  MessageRole: () => MessageRole,
+  TaskState: () => TaskState,
+  createInputMissingErrorEvent: () => createInputMissingErrorEvent,
+  createTask: () => createTask,
+  createTaskArtifactUpdateEvent: () => createTaskArtifactUpdateEvent,
+  createTaskCompletedEvent: () => createTaskCompletedEvent,
+  createTaskFailedEvent: () => createTaskFailedEvent,
+  createTaskInputRequiredEvent: () => createTaskInputRequiredEvent,
+  createTaskSubmittedEvent: () => createTaskSubmittedEvent,
+  createTaskWorkingEvent: () => createTaskWorkingEvent,
+  getEventMetadata: () => getEventMetadata,
+  getFailedTaskStatusUpdateEventError: () => getFailedTaskStatusUpdateEventError,
+  isFailedTaskStatusUpdateEvent: () => isFailedTaskStatusUpdateEvent,
+  isInputRequiredTaskStatusUpdateEvent: () => isInputRequiredTaskStatusUpdateEvent,
+  isMessage: () => isMessage,
+  isTask: () => isTask,
+  isTaskArtifactUpdateEvent: () => isTaskArtifactUpdateEvent,
+  isTaskStatusUpdateEvent: () => isTaskStatusUpdateEvent,
+  isTerminalTaskStatusUpdateEvent: () => isTerminalTaskStatusUpdateEvent
+});
+module.exports = __toCommonJS(a2a_event_exports);
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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 || (0, import_env_aware_utils.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 || (0, import_env_aware_utils.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: (0, import_env_aware_utils.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: (0, import_env_aware_utils.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: (0, import_env_aware_utils.randomUUID)(),
+        role: "agent",
+        taskId,
+        contextId,
+        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,
+  createTaskCompletedEvent,
+  createTaskFailedEvent,
+  createTaskInputRequiredEvent,
+  createTaskSubmittedEvent,
+  createTaskWorkingEvent,
+  getEventMetadata,
+  getFailedTaskStatusUpdateEventError,
+  isFailedTaskStatusUpdateEvent,
+  isInputRequiredTaskStatusUpdateEvent,
+  isMessage,
+  isTask,
+  isTaskArtifactUpdateEvent,
+  isTaskStatusUpdateEvent,
+  isTerminalTaskStatusUpdateEvent
+});

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
+});