@google/adk 0.4.0 → 0.6.0

package/dist/cjs/a2a/agent_executor.js

@@ -0,0 +1,221 @@
+/**
+  * @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 agent_executor_exports = {};
+__export(agent_executor_exports, {
+  A2AAgentExecutor: () => A2AAgentExecutor
+});
+module.exports = __toCommonJS(agent_executor_exports);
+var import_runner = require("../runner/runner.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_event_processor_utils = require("./event_processor_utils.js");
+var import_executor_context = require("./executor_context.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 A2AAgentExecutor {
+  constructor(config) {
+    this.config = config;
+    this.agentPartialArtifactIdsMap = {};
+  }
+  async execute(ctx, eventBus) {
+    var _a, _b;
+    const a2aUserMessage = ctx.userMessage;
+    if (!a2aUserMessage) {
+      throw new Error("message not provided");
+    }
+    const userId = `A2A_USER_${ctx.contextId}`;
+    const sessionId = ctx.contextId;
+    const genAIUserMessage = (0, import_part_converter_utils.toGenAIContent)(a2aUserMessage);
+    const adkRunner = await getAdkRunner(this.config.runner);
+    const session = await getAdkSession(
+      userId,
+      sessionId,
+      adkRunner.sessionService,
+      adkRunner.appName
+    );
+    const executorContext = (0, import_executor_context.createExecutorContext)({
+      session,
+      userContent: genAIUserMessage,
+      requestContext: ctx
+    });
+    try {
+      if (this.config.beforeExecuteCallback) {
+        await this.config.beforeExecuteCallback(ctx);
+      }
+      if (ctx.task) {
+        const inputRequiredEvent = (0, import_event_processor_utils.getTaskInputRequiredEvent)(
+          ctx.task,
+          genAIUserMessage
+        );
+        if (inputRequiredEvent) {
+          await this.publishFinalTaskStatus({
+            executorContext,
+            eventBus,
+            event: inputRequiredEvent
+          });
+          return;
+        }
+      }
+      if (!ctx.task) {
+        eventBus.publish(
+          (0, import_a2a_event.createTask)({
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            message: a2aUserMessage
+          })
+        );
+      }
+      eventBus.publish(
+        (0, import_a2a_event.createTaskWorkingEvent)({
+          taskId: ctx.taskId,
+          contextId: ctx.contextId
+        })
+      );
+      const adkEvents = [];
+      for await (const adkEvent of adkRunner.runAsync({
+        userId,
+        sessionId,
+        newMessage: genAIUserMessage,
+        runConfig: this.config.runConfig
+      })) {
+        adkEvents.push(adkEvent);
+        const a2aEvent = this.convertAdkEventToA2AEvent(
+          adkEvent,
+          executorContext
+        );
+        if (!a2aEvent) {
+          continue;
+        }
+        await ((_b = (_a = this.config).afterEventCallback) == null ? void 0 : _b.call(
+          _a,
+          executorContext,
+          adkEvent,
+          a2aEvent
+        ));
+        eventBus.publish(a2aEvent);
+      }
+      await this.publishFinalTaskStatus({
+        executorContext,
+        eventBus,
+        event: (0, import_event_processor_utils.getFinalTaskStatusUpdate)(adkEvents, executorContext)
+      });
+    } catch (e) {
+      const error = e;
+      await this.publishFinalTaskStatus({
+        executorContext,
+        eventBus,
+        error,
+        event: (0, import_a2a_event.createTaskFailedEvent)({
+          taskId: ctx.taskId,
+          contextId: ctx.contextId,
+          error: new Error(`Agent run failed: ${error.message}`),
+          metadata: (0, import_metadata_converter_utils.getA2ASessionMetadata)(executorContext)
+        })
+      });
+    }
+  }
+  // Task cancellation is not supported in this implementation yet.
+  async cancelTask(_taskId) {
+    throw new Error("Task cancellation is not supported yet.");
+  }
+  convertAdkEventToA2AEvent(adkEvent, executorContext) {
+    var _a;
+    const a2aParts = (0, import_part_converter_utils.toA2AParts)(
+      (_a = adkEvent.content) == null ? void 0 : _a.parts,
+      adkEvent.longRunningToolIds
+    );
+    if (a2aParts.length === 0) {
+      return void 0;
+    }
+    const artifactId = this.agentPartialArtifactIdsMap[adkEvent.author] || (0, import_env_aware_utils.randomUUID)();
+    const a2aEvent = (0, import_a2a_event.createTaskArtifactUpdateEvent)({
+      taskId: executorContext.requestContext.taskId,
+      contextId: executorContext.requestContext.contextId,
+      artifactId,
+      parts: a2aParts,
+      metadata: (0, import_metadata_converter_utils.getA2AEventMetadata)(adkEvent, executorContext),
+      append: adkEvent.partial,
+      lastChunk: !adkEvent.partial
+    });
+    if (adkEvent.partial) {
+      this.agentPartialArtifactIdsMap[adkEvent.author] = artifactId;
+    } else {
+      delete this.agentPartialArtifactIdsMap[adkEvent.author];
+    }
+    return a2aEvent;
+  }
+  /**
+   * Writes the final status event to the queue.
+   */
+  async publishFinalTaskStatus({
+    executorContext,
+    eventBus,
+    event,
+    error
+  }) {
+    var _a, _b;
+    try {
+      await ((_b = (_a = this.config).afterExecuteCallback) == null ? void 0 : _b.call(_a, executorContext, event, error));
+    } catch (e) {
+      import_logger.logger.error("Error in afterExecuteCallback:", e);
+    }
+    eventBus.publish(event);
+  }
+}
+async function getAdkSession(userId, sessionId, sessionService, appName) {
+  const session = await sessionService.getSession({
+    appName,
+    userId,
+    sessionId
+  });
+  if (session) {
+    return session;
+  }
+  return sessionService.createSession({
+    appName,
+    userId,
+    sessionId
+  });
+}
+async function getAdkRunner(runnerOrConfig) {
+  if (typeof runnerOrConfig === "function") {
+    const result = await runnerOrConfig();
+    return getAdkRunner(result);
+  }
+  if ((0, import_runner.isRunner)(runnerOrConfig)) {
+    return runnerOrConfig;
+  }
+  return new import_runner.Runner(runnerOrConfig);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2AAgentExecutor
+});

package/dist/cjs/a2a/agent_to_a2a.js

@@ -0,0 +1,115 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_to_a2a_exports = {};
+__export(agent_to_a2a_exports, {
+  toA2a: () => toA2a
+});
+module.exports = __toCommonJS(agent_to_a2a_exports);
+var import_sdk = require("@a2a-js/sdk");
+var import_server = require("@a2a-js/sdk/server");
+var import_express = require("@a2a-js/sdk/server/express");
+var import_express2 = __toESM(require("express"), 1);
+var import_run_config = require("../agents/run_config.js");
+var import_in_memory_session_service = require("../sessions/in_memory_session_service.js");
+var import_agent_card = require("./agent_card.js");
+var import_agent_executor = require("./agent_executor.js");
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+async function toA2a(agent, options = {}) {
+  var _a, _b, _c, _d;
+  const host = (_a = options.host) != null ? _a : "localhost";
+  const port = (_b = options.port) != null ? _b : 8e3;
+  const protocol = (_c = options.protocol) != null ? _c : "http";
+  const basePath = options.basePath || "";
+  const rpcUrl = `${protocol}://${host}:${port}${basePath}`;
+  const agentCard = options.agentCard ? await (0, import_agent_card.resolveAgentCard)(options.agentCard) : await (0, import_agent_card.getA2AAgentCard)(agent, [
+    {
+      url: `${rpcUrl}/jsonrpc`,
+      transport: "JSONRPC"
+    },
+    {
+      url: `${rpcUrl}/rest`,
+      transport: "HTTP+JSON"
+    }
+  ]);
+  const agentExecutor = new import_agent_executor.A2AAgentExecutor({
+    runner: options.runner || {
+      agent,
+      appName: agent.name,
+      sessionService: options.sessionService || new import_in_memory_session_service.InMemorySessionService(),
+      memoryService: options.memoryService,
+      artifactService: options.artifactService
+    },
+    runConfig: {
+      streamingMode: import_run_config.StreamingMode.SSE
+    }
+  });
+  const requestHandler = new import_server.DefaultRequestHandler(
+    agentCard,
+    new import_server.InMemoryTaskStore(),
+    agentExecutor
+  );
+  const app = (_d = options.app) != null ? _d : (0, import_express2.default)();
+  if (!options.app) {
+    app.use(import_express2.default.urlencoded({ limit: "50mb", extended: true }));
+    app.use(import_express2.default.json({ limit: "50mb" }));
+  }
+  app.use(
+    `${basePath}/${import_sdk.AGENT_CARD_PATH}`,
+    (0, import_express.agentCardHandler)({ agentCardProvider: requestHandler })
+  );
+  app.use(
+    `${basePath}/rest`,
+    (0, import_express.restHandler)({
+      requestHandler,
+      userBuilder: import_express.UserBuilder.noAuthentication
+    })
+  );
+  app.use(
+    `${basePath}/jsonrpc`,
+    (0, import_express.jsonRpcHandler)({
+      requestHandler,
+      userBuilder: import_express.UserBuilder.noAuthentication
+    })
+  );
+  return app;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toA2a
+});

package/dist/cjs/a2a/event_converter_utils.js

@@ -0,0 +1,201 @@
+/**
+  * @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 event_converter_utils_exports = {};
+__export(event_converter_utils_exports, {
+  toA2AMessage: () => toA2AMessage,
+  toAdkEvent: () => toAdkEvent
+});
+module.exports = __toCommonJS(event_converter_utils_exports);
+var import_genai = require("@google/genai");
+var import_event = require("../events/event.js");
+var import_event_actions = require("../events/event_actions.js");
+var import_env_aware_utils = require("../utils/env_aware_utils.js");
+var import_a2a_event = require("./a2a_event.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
+ */
+function toA2AMessage(event, {
+  appName,
+  userId,
+  sessionId
+}) {
+  var _a;
+  return {
+    kind: "message",
+    messageId: (0, import_env_aware_utils.randomUUID)(),
+    role: event.author === import_a2a_event.MessageRole.USER ? import_a2a_event.MessageRole.USER : import_a2a_event.MessageRole.AGENT,
+    parts: (0, import_part_converter_utils.toA2AParts)(((_a = event.content) == null ? void 0 : _a.parts) || [], event.longRunningToolIds),
+    metadata: (0, import_metadata_converter_utils.getA2AEventMetadata)(event, { appName, userId, sessionId })
+  };
+}
+function toAdkEvent(event, invocationId, agentName) {
+  if ((0, import_a2a_event.isMessage)(event)) {
+    return messageToAdkEvent(event, invocationId, agentName);
+  }
+  if ((0, import_a2a_event.isTask)(event)) {
+    return taskToAdkEvent(event, invocationId, agentName);
+  }
+  if ((0, import_a2a_event.isTaskArtifactUpdateEvent)(event)) {
+    return artifactUpdateToAdkEvent(event, invocationId, agentName);
+  }
+  if ((0, import_a2a_event.isTaskStatusUpdateEvent)(event)) {
+    return event.final ? finalTaskStatusUpdateToAdkEvent(event, invocationId, agentName) : taskStatusUpdateToAdkEvent(event, invocationId, agentName);
+  }
+  return void 0;
+}
+function messageToAdkEvent(msg, invocationId, agentName, parentEvent) {
+  const parts = (0, import_part_converter_utils.toGenAIParts)(msg.parts);
+  return {
+    ...createAdkEventFromMetadata(parentEvent || msg),
+    invocationId,
+    author: msg.role === import_a2a_event.MessageRole.USER ? import_a2a_event.MessageRole.USER : agentName,
+    content: msg.role === import_a2a_event.MessageRole.USER ? (0, import_genai.createUserContent)(parts) : (0, import_genai.createModelContent)(parts),
+    turnComplete: true,
+    partial: false
+  };
+}
+function artifactUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
+  var _a;
+  const partsToConvert = ((_a = a2aEvent.artifact) == null ? void 0 : _a.parts) || [];
+  if (partsToConvert.length === 0) {
+    return void 0;
+  }
+  const partial = !!(0, import_a2a_event.getEventMetadata)(a2aEvent)[import_metadata_converter_utils.A2AMetadataKeys.PARTIAL] || a2aEvent.append || !a2aEvent.lastChunk;
+  return {
+    ...createAdkEventFromMetadata(a2aEvent),
+    invocationId,
+    author: agentName,
+    content: (0, import_genai.createModelContent)((0, import_part_converter_utils.toGenAIParts)(partsToConvert)),
+    longRunningToolIds: getLongRunningToolIDs(partsToConvert),
+    partial
+  };
+}
+function finalTaskStatusUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
+  var _a;
+  const partsToConvert = ((_a = a2aEvent.status.message) == null ? void 0 : _a.parts) || [];
+  if (partsToConvert.length === 0) {
+    return void 0;
+  }
+  const parts = (0, import_part_converter_utils.toGenAIParts)(partsToConvert);
+  const isFailedTask = (0, import_a2a_event.isFailedTaskStatusUpdateEvent)(a2aEvent);
+  const hasContent = !isFailedTask && parts.length > 0;
+  return {
+    ...createAdkEventFromMetadata(a2aEvent),
+    invocationId,
+    author: agentName,
+    errorMessage: isFailedTask ? (0, import_a2a_event.getFailedTaskStatusUpdateEventError)(a2aEvent) : void 0,
+    content: hasContent ? (0, import_genai.createModelContent)(parts) : void 0,
+    longRunningToolIds: getLongRunningToolIDs(partsToConvert),
+    turnComplete: true
+  };
+}
+function taskStatusUpdateToAdkEvent(a2aEvent, invocationId, agentName) {
+  const msg = a2aEvent.status.message;
+  if (!msg) {
+    return void 0;
+  }
+  const parts = (0, import_part_converter_utils.toGenAIParts)(msg.parts);
+  return {
+    ...createAdkEventFromMetadata(a2aEvent),
+    invocationId,
+    author: agentName,
+    content: (0, import_genai.createModelContent)(parts),
+    turnComplete: false,
+    partial: true
+  };
+}
+function taskToAdkEvent(a2aTask, invocationId, agentName) {
+  var _a, _b;
+  const parts = [];
+  const longRunningToolIds = [];
+  if (a2aTask.artifacts) {
+    for (const artifact of a2aTask.artifacts) {
+      if (((_a = artifact.parts) == null ? void 0 : _a.length) > 0) {
+        const artifactParts = (0, import_part_converter_utils.toGenAIParts)(artifact.parts);
+        parts.push(...artifactParts);
+        longRunningToolIds.push(...getLongRunningToolIDs(artifact.parts));
+      }
+    }
+  }
+  if ((_b = a2aTask.status) == null ? void 0 : _b.message) {
+    const a2aParts = a2aTask.status.message.parts;
+    const genAIParts = (0, import_part_converter_utils.toGenAIParts)(a2aParts);
+    parts.push(...genAIParts);
+    longRunningToolIds.push(...getLongRunningToolIDs(a2aParts));
+  }
+  const isTerminal = (0, import_a2a_event.isTerminalTaskStatusUpdateEvent)(a2aTask) || (0, import_a2a_event.isInputRequiredTaskStatusUpdateEvent)(a2aTask);
+  const isFailed = (0, import_a2a_event.isFailedTaskStatusUpdateEvent)(a2aTask);
+  if (parts.length === 0 && !isTerminal) {
+    return void 0;
+  }
+  return {
+    ...createAdkEventFromMetadata(a2aTask),
+    invocationId,
+    author: agentName,
+    content: isFailed ? void 0 : (0, import_genai.createModelContent)(parts),
+    errorMessage: isFailed ? (0, import_a2a_event.getFailedTaskStatusUpdateEventError)(a2aTask) : void 0,
+    longRunningToolIds,
+    turnComplete: isTerminal
+  };
+}
+function createAdkEventFromMetadata(a2aEvent) {
+  const metadata = a2aEvent.metadata || {};
+  return (0, import_event.createEvent)({
+    branch: metadata[import_metadata_converter_utils.A2AMetadataKeys.BRANCH],
+    author: metadata[import_metadata_converter_utils.A2AMetadataKeys.AUTHOR],
+    partial: metadata[import_metadata_converter_utils.A2AMetadataKeys.PARTIAL],
+    errorCode: metadata[import_metadata_converter_utils.A2AMetadataKeys.ERROR_CODE],
+    errorMessage: metadata[import_metadata_converter_utils.A2AMetadataKeys.ERROR_MESSAGE],
+    citationMetadata: metadata[import_metadata_converter_utils.A2AMetadataKeys.CITATION_METADATA],
+    groundingMetadata: metadata[import_metadata_converter_utils.A2AMetadataKeys.GROUNDING_METADATA],
+    usageMetadata: metadata[import_metadata_converter_utils.A2AMetadataKeys.USAGE_METADATA],
+    customMetadata: metadata[import_metadata_converter_utils.A2AMetadataKeys.CUSTOM_METADATA],
+    actions: (0, import_event_actions.createEventActions)({
+      escalate: !!metadata[import_metadata_converter_utils.A2AMetadataKeys.ESCALATE],
+      transferToAgent: metadata[import_metadata_converter_utils.A2AMetadataKeys.TRANSFER_TO_AGENT]
+    })
+  });
+}
+function getLongRunningToolIDs(parts) {
+  const ids = [];
+  for (const a2aPart of parts) {
+    if (a2aPart.metadata && a2aPart.metadata[import_metadata_converter_utils.A2AMetadataKeys.IS_LONG_RUNNING]) {
+      const genAIPart = (0, import_part_converter_utils.toGenAIPart)(a2aPart);
+      if (genAIPart.functionCall && genAIPart.functionCall.id) {
+        ids.push(genAIPart.functionCall.id);
+      }
+    }
+  }
+  return ids;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toA2AMessage,
+  toAdkEvent
+});