@google/adk 0.4.0 → 0.6.0

package/dist/web/a2a/agent_executor.js

@@ -0,0 +1,216 @@
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+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 { isRunner, Runner } from "../runner/runner.js";
+import { randomUUID } from "../utils/env_aware_utils.js";
+import { logger } from "../utils/logger.js";
+import {
+  createTask,
+  createTaskArtifactUpdateEvent,
+  createTaskFailedEvent,
+  createTaskWorkingEvent
+} from "./a2a_event.js";
+import {
+  getFinalTaskStatusUpdate,
+  getTaskInputRequiredEvent
+} from "./event_processor_utils.js";
+import { createExecutorContext } from "./executor_context.js";
+import {
+  getA2AEventMetadata,
+  getA2ASessionMetadata
+} from "./metadata_converter_utils.js";
+import { toA2AParts, toGenAIContent } from "./part_converter_utils.js";
+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_".concat(ctx.contextId);
+    const sessionId = ctx.contextId;
+    const genAIUserMessage = toGenAIContent(a2aUserMessage);
+    const adkRunner = await getAdkRunner(this.config.runner);
+    const session = await getAdkSession(
+      userId,
+      sessionId,
+      adkRunner.sessionService,
+      adkRunner.appName
+    );
+    const executorContext = createExecutorContext({
+      session,
+      userContent: genAIUserMessage,
+      requestContext: ctx
+    });
+    try {
+      if (this.config.beforeExecuteCallback) {
+        await this.config.beforeExecuteCallback(ctx);
+      }
+      if (ctx.task) {
+        const inputRequiredEvent = getTaskInputRequiredEvent(
+          ctx.task,
+          genAIUserMessage
+        );
+        if (inputRequiredEvent) {
+          await this.publishFinalTaskStatus({
+            executorContext,
+            eventBus,
+            event: inputRequiredEvent
+          });
+          return;
+        }
+      }
+      if (!ctx.task) {
+        eventBus.publish(
+          createTask({
+            taskId: ctx.taskId,
+            contextId: ctx.contextId,
+            message: a2aUserMessage
+          })
+        );
+      }
+      eventBus.publish(
+        createTaskWorkingEvent({
+          taskId: ctx.taskId,
+          contextId: ctx.contextId
+        })
+      );
+      const adkEvents = [];
+      try {
+        for (var iter = __forAwait(adkRunner.runAsync({
+          userId,
+          sessionId,
+          newMessage: genAIUserMessage,
+          runConfig: this.config.runConfig
+        })), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+          const adkEvent = temp.value;
+          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);
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && await temp.call(iter);
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      await this.publishFinalTaskStatus({
+        executorContext,
+        eventBus,
+        event: getFinalTaskStatusUpdate(adkEvents, executorContext)
+      });
+    } catch (e) {
+      const error2 = e;
+      await this.publishFinalTaskStatus({
+        executorContext,
+        eventBus,
+        error: error2,
+        event: createTaskFailedEvent({
+          taskId: ctx.taskId,
+          contextId: ctx.contextId,
+          error: new Error("Agent run failed: ".concat(error2.message)),
+          metadata: 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 = toA2AParts(
+      (_a = adkEvent.content) == null ? void 0 : _a.parts,
+      adkEvent.longRunningToolIds
+    );
+    if (a2aParts.length === 0) {
+      return void 0;
+    }
+    const artifactId = this.agentPartialArtifactIdsMap[adkEvent.author] || randomUUID();
+    const a2aEvent = createTaskArtifactUpdateEvent({
+      taskId: executorContext.requestContext.taskId,
+      contextId: executorContext.requestContext.contextId,
+      artifactId,
+      parts: a2aParts,
+      metadata: 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) {
+      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 (isRunner(runnerOrConfig)) {
+    return runnerOrConfig;
+  }
+  return new Runner(runnerOrConfig);
+}
+export {
+  A2AAgentExecutor
+};

package/dist/web/a2a/agent_to_a2a.js

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AGENT_CARD_PATH } from "@a2a-js/sdk";
+import { DefaultRequestHandler, InMemoryTaskStore } from "@a2a-js/sdk/server";
+import {
+  agentCardHandler,
+  jsonRpcHandler,
+  restHandler,
+  UserBuilder
+} from "@a2a-js/sdk/server/express";
+import express from "express";
+import { StreamingMode } from "../agents/run_config.js";
+import { InMemorySessionService } from "../sessions/in_memory_session_service.js";
+import { getA2AAgentCard, resolveAgentCard } from "./agent_card.js";
+import { A2AAgentExecutor } from "./agent_executor.js";
+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 = "".concat(protocol, "://").concat(host, ":").concat(port).concat(basePath);
+  const agentCard = options.agentCard ? await resolveAgentCard(options.agentCard) : await getA2AAgentCard(agent, [
+    {
+      url: "".concat(rpcUrl, "/jsonrpc"),
+      transport: "JSONRPC"
+    },
+    {
+      url: "".concat(rpcUrl, "/rest"),
+      transport: "HTTP+JSON"
+    }
+  ]);
+  const agentExecutor = new A2AAgentExecutor({
+    runner: options.runner || {
+      agent,
+      appName: agent.name,
+      sessionService: options.sessionService || new InMemorySessionService(),
+      memoryService: options.memoryService,
+      artifactService: options.artifactService
+    },
+    runConfig: {
+      streamingMode: StreamingMode.SSE
+    }
+  });
+  const requestHandler = new DefaultRequestHandler(
+    agentCard,
+    new InMemoryTaskStore(),
+    agentExecutor
+  );
+  const app = (_d = options.app) != null ? _d : express();
+  if (!options.app) {
+    app.use(express.urlencoded({ limit: "50mb", extended: true }));
+    app.use(express.json({ limit: "50mb" }));
+  }
+  app.use(
+    "".concat(basePath, "/").concat(AGENT_CARD_PATH),
+    agentCardHandler({ agentCardProvider: requestHandler })
+  );
+  app.use(
+    "".concat(basePath, "/rest"),
+    restHandler({
+      requestHandler,
+      userBuilder: UserBuilder.noAuthentication
+    })
+  );
+  app.use(
+    "".concat(basePath, "/jsonrpc"),
+    jsonRpcHandler({
+      requestHandler,
+      userBuilder: UserBuilder.noAuthentication
+    })
+  );
+  return app;
+}
+export {
+  toA2a
+};

package/dist/web/a2a/event_converter_utils.js

@@ -0,0 +1,201 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {
+  createModelContent,
+  createUserContent
+} from "@google/genai";
+import { createEvent } from "../events/event.js";
+import { createEventActions } from "../events/event_actions.js";
+import { randomUUID } from "../utils/env_aware_utils.js";
+import {
+  getEventMetadata,
+  getFailedTaskStatusUpdateEventError,
+  isFailedTaskStatusUpdateEvent,
+  isInputRequiredTaskStatusUpdateEvent,
+  isMessage,
+  isTask,
+  isTaskArtifactUpdateEvent,
+  isTaskStatusUpdateEvent,
+  isTerminalTaskStatusUpdateEvent,
+  MessageRole
+} from "./a2a_event.js";
+import {
+  A2AMetadataKeys,
+  getA2AEventMetadata
+} from "./metadata_converter_utils.js";
+import { toA2AParts, toGenAIPart, toGenAIParts } from "./part_converter_utils.js";
+function toA2AMessage(event, {
+  appName,
+  userId,
+  sessionId
+}) {
+  var _a;
+  return {
+    kind: "message",
+    messageId: randomUUID(),
+    role: event.author === MessageRole.USER ? MessageRole.USER : MessageRole.AGENT,
+    parts: toA2AParts(((_a = event.content) == null ? void 0 : _a.parts) || [], event.longRunningToolIds),
+    metadata: getA2AEventMetadata(event, { appName, userId, sessionId })
+  };
+}
+function toAdkEvent(event, invocationId, agentName) {
+  if (isMessage(event)) {
+    return messageToAdkEvent(event, invocationId, agentName);
+  }
+  if (isTask(event)) {
+    return taskToAdkEvent(event, invocationId, agentName);
+  }
+  if (isTaskArtifactUpdateEvent(event)) {
+    return artifactUpdateToAdkEvent(event, invocationId, agentName);
+  }
+  if (isTaskStatusUpdateEvent(event)) {
+    return event.final ? finalTaskStatusUpdateToAdkEvent(event, invocationId, agentName) : taskStatusUpdateToAdkEvent(event, invocationId, agentName);
+  }
+  return void 0;
+}
+function messageToAdkEvent(msg, invocationId, agentName, parentEvent) {
+  const parts = toGenAIParts(msg.parts);
+  return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(parentEvent || msg)), {
+    invocationId,
+    author: msg.role === MessageRole.USER ? MessageRole.USER : agentName,
+    content: msg.role === MessageRole.USER ? createUserContent(parts) : 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 = !!getEventMetadata(a2aEvent)[A2AMetadataKeys.PARTIAL] || a2aEvent.append || !a2aEvent.lastChunk;
+  return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(a2aEvent)), {
+    invocationId,
+    author: agentName,
+    content: createModelContent(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 = toGenAIParts(partsToConvert);
+  const isFailedTask = isFailedTaskStatusUpdateEvent(a2aEvent);
+  const hasContent = !isFailedTask && parts.length > 0;
+  return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(a2aEvent)), {
+    invocationId,
+    author: agentName,
+    errorMessage: isFailedTask ? getFailedTaskStatusUpdateEventError(a2aEvent) : void 0,
+    content: hasContent ? 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 = toGenAIParts(msg.parts);
+  return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(a2aEvent)), {
+    invocationId,
+    author: agentName,
+    content: 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 = 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 = toGenAIParts(a2aParts);
+    parts.push(...genAIParts);
+    longRunningToolIds.push(...getLongRunningToolIDs(a2aParts));
+  }
+  const isTerminal = isTerminalTaskStatusUpdateEvent(a2aTask) || isInputRequiredTaskStatusUpdateEvent(a2aTask);
+  const isFailed = isFailedTaskStatusUpdateEvent(a2aTask);
+  if (parts.length === 0 && !isTerminal) {
+    return void 0;
+  }
+  return __spreadProps(__spreadValues({}, createAdkEventFromMetadata(a2aTask)), {
+    invocationId,
+    author: agentName,
+    content: isFailed ? void 0 : createModelContent(parts),
+    errorMessage: isFailed ? getFailedTaskStatusUpdateEventError(a2aTask) : void 0,
+    longRunningToolIds,
+    turnComplete: isTerminal
+  });
+}
+function createAdkEventFromMetadata(a2aEvent) {
+  const metadata = a2aEvent.metadata || {};
+  return createEvent({
+    branch: metadata[A2AMetadataKeys.BRANCH],
+    author: metadata[A2AMetadataKeys.AUTHOR],
+    partial: metadata[A2AMetadataKeys.PARTIAL],
+    errorCode: metadata[A2AMetadataKeys.ERROR_CODE],
+    errorMessage: metadata[A2AMetadataKeys.ERROR_MESSAGE],
+    citationMetadata: metadata[A2AMetadataKeys.CITATION_METADATA],
+    groundingMetadata: metadata[A2AMetadataKeys.GROUNDING_METADATA],
+    usageMetadata: metadata[A2AMetadataKeys.USAGE_METADATA],
+    customMetadata: metadata[A2AMetadataKeys.CUSTOM_METADATA],
+    actions: createEventActions({
+      escalate: !!metadata[A2AMetadataKeys.ESCALATE],
+      transferToAgent: metadata[A2AMetadataKeys.TRANSFER_TO_AGENT]
+    })
+  });
+}
+function getLongRunningToolIDs(parts) {
+  const ids = [];
+  for (const a2aPart of parts) {
+    if (a2aPart.metadata && a2aPart.metadata[A2AMetadataKeys.IS_LONG_RUNNING]) {
+      const genAIPart = toGenAIPart(a2aPart);
+      if (genAIPart.functionCall && genAIPart.functionCall.id) {
+        ids.push(genAIPart.functionCall.id);
+      }
+    }
+  }
+  return ids;
+}
+export {
+  toA2AMessage,
+  toAdkEvent
+};

package/dist/web/a2a/event_processor_utils.js

@@ -0,0 +1,168 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createEventActions } from "../events/event_actions.js";
+import {
+  createInputMissingErrorEvent,
+  createTaskCompletedEvent,
+  createTaskFailedEvent,
+  createTaskInputRequiredEvent,
+  isInputRequiredTaskStatusUpdateEvent
+} from "./a2a_event.js";
+import {
+  getA2AEventMetadata,
+  getA2AEventMetadataFromActions,
+  getA2ASessionMetadata
+} from "./metadata_converter_utils.js";
+import { toA2AParts, toGenAIParts } from "./part_converter_utils.js";
+function getFinalTaskStatusUpdate(adkEvents, context) {
+  var _a, _b;
+  const finalEventActions = createEventActions();
+  for (const adkEvent of adkEvents) {
+    if (adkEvent.errorCode || adkEvent.errorMessage) {
+      return createTaskFailedEvent({
+        taskId: context.requestContext.taskId,
+        contextId: context.requestContext.contextId,
+        error: new Error(adkEvent.errorMessage || adkEvent.errorCode),
+        metadata: __spreadValues(__spreadValues({}, getA2AEventMetadata(adkEvent, context)), getA2AEventMetadataFromActions(finalEventActions))
+      });
+    }
+    finalEventActions.escalate = finalEventActions.escalate || ((_a = adkEvent.actions) == null ? void 0 : _a.escalate);
+    if ((_b = adkEvent.actions) == null ? void 0 : _b.transferToAgent) {
+      finalEventActions.transferToAgent = adkEvent.actions.transferToAgent;
+    }
+  }
+  const inputRequiredEvent = scanForInputRequiredEvents(adkEvents, context);
+  if (inputRequiredEvent) {
+    return __spreadProps(__spreadValues({}, inputRequiredEvent), {
+      metadata: __spreadValues(__spreadValues({}, inputRequiredEvent.metadata), getA2AEventMetadataFromActions(finalEventActions))
+    });
+  }
+  return createTaskCompletedEvent({
+    taskId: context.requestContext.taskId,
+    contextId: context.requestContext.contextId,
+    metadata: __spreadValues(__spreadValues({}, getA2ASessionMetadata(context)), getA2AEventMetadataFromActions(finalEventActions))
+  });
+}
+function scanForInputRequiredEvents(adkEvents, context) {
+  var _a, _b;
+  const inputRequiredParts = [];
+  const inputRequiredFunctionCallIds = /* @__PURE__ */ new Set();
+  for (const adkEvent of adkEvents) {
+    if (!((_b = (_a = adkEvent.content) == null ? void 0 : _a.parts) == null ? void 0 : _b.length)) {
+      continue;
+    }
+    for (const genAIPart of adkEvent.content.parts) {
+      const longRunningFunctionCallId = getLongRunnningFunctionCallId(
+        genAIPart,
+        adkEvent.longRunningToolIds,
+        inputRequiredParts
+      );
+      if (!longRunningFunctionCallId) {
+        continue;
+      }
+      const isAlreadyAdded = inputRequiredFunctionCallIds.has(
+        longRunningFunctionCallId
+      );
+      if (isAlreadyAdded) {
+        continue;
+      }
+      inputRequiredParts.push(genAIPart);
+      inputRequiredFunctionCallIds.add(longRunningFunctionCallId);
+    }
+  }
+  if (inputRequiredParts.length > 0) {
+    return createTaskInputRequiredEvent({
+      taskId: context.requestContext.taskId,
+      contextId: context.requestContext.contextId,
+      parts: toA2AParts(inputRequiredParts, [...inputRequiredFunctionCallIds]),
+      metadata: getA2ASessionMetadata(context)
+    });
+  }
+  return void 0;
+}
+function getLongRunnningFunctionCallId(genAIPart, longRunningToolIds = [], inputRequiredParts = []) {
+  var _a, _b, _c;
+  const functionCallId = (_a = genAIPart.functionCall) == null ? void 0 : _a.id;
+  const functionResponseId = (_b = genAIPart.functionResponse) == null ? void 0 : _b.id;
+  if (!functionCallId && !functionResponseId) {
+    return;
+  }
+  if (functionCallId && longRunningToolIds.includes(functionCallId)) {
+    return functionCallId;
+  }
+  if (functionResponseId && longRunningToolIds.includes(functionResponseId)) {
+    return functionResponseId;
+  }
+  for (const part of inputRequiredParts) {
+    if (((_c = part.functionCall) == null ? void 0 : _c.id) === functionResponseId) {
+      return functionResponseId;
+    }
+  }
+  return;
+}
+function getTaskInputRequiredEvent(task, genAIContent) {
+  var _a;
+  if (!task || !isInputRequiredTaskStatusUpdateEvent(task) || !task.status.message) {
+    return void 0;
+  }
+  const statusMsg = task.status.message;
+  const taskParts = toGenAIParts(statusMsg.parts);
+  for (const taskPart of taskParts) {
+    const functionCallId = (_a = taskPart.functionCall) == null ? void 0 : _a.id;
+    if (!functionCallId) {
+      continue;
+    }
+    const hasMatchingResponse = ((genAIContent == null ? void 0 : genAIContent.parts) || []).some(
+      (p) => {
+        var _a2;
+        return ((_a2 = p.functionResponse) == null ? void 0 : _a2.id) === functionCallId;
+      }
+    );
+    if (!hasMatchingResponse) {
+      return createInputMissingErrorEvent({
+        taskId: task.id,
+        contextId: task.contextId,
+        parts: [
+          ...statusMsg.parts.filter((p) => {
+            var _a2;
+            return !((_a2 = p.metadata) == null ? void 0 : _a2.validation_error);
+          }),
+          {
+            kind: "text",
+            text: "No input provided for function call id ".concat(functionCallId),
+            metadata: {
+              validation_error: true
+            }
+          }
+        ]
+      });
+    }
+  }
+  return void 0;
+}
+export {
+  getFinalTaskStatusUpdate,
+  getTaskInputRequiredEvent
+};

package/dist/web/a2a/executor_context.js

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function createExecutorContext({
+  session,
+  userContent,
+  requestContext
+}) {
+  return {
+    userId: session.userId,
+    sessionId: session.id,
+    appName: session.appName,
+    readonlyState: session.state,
+    events: session.events,
+    userContent,
+    requestContext
+  };
+}
+export {
+  createExecutorContext
+};