@mailmodo/a2a 0.3.5 → 0.3.7

package/dist/index.js

@@ -1,8 +1,6 @@
-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)
@@ -16,37 +14,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  A2AClient: () => A2AClient,
-  A2AError: () => A2AError,
-  A2AExpressApp: () => A2AExpressApp,
   AGENT_CARD_PATH: () => AGENT_CARD_PATH,
-  DefaultExecutionEventBus: () => DefaultExecutionEventBus,
-  DefaultExecutionEventBusManager: () => DefaultExecutionEventBusManager,
-  DefaultRequestHandler: () => DefaultRequestHandler,
-  ExecutionEventQueue: () => ExecutionEventQueue,
-  InMemoryTaskStore: () => InMemoryTaskStore,
-  JsonRpcTransportHandler: () => JsonRpcTransportHandler,
-  RequestContext: () => RequestContext,
-  ResultManager: () => ResultManager,
-  createAuthenticatingFetchWithRetry: () => createAuthenticatingFetchWithRetry,
-  getCurrentTimestamp: () => getCurrentTimestamp,
-  getRequestedExtensions: () => getRequestedExtensions,
-  isArtifactUpdate: () => isArtifactUpdate,
-  isObject: () => isObject,
-  isTaskStatusUpdate: () => isTaskStatusUpdate
+  Extensions: () => Extensions,
+  HTTP_EXTENSION_HEADER: () => HTTP_EXTENSION_HEADER
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -54,2074 +29,43 @@ module.exports = __toCommonJS(index_exports);
 var AGENT_CARD_PATH = ".well-known/agent-card.json";
 var HTTP_EXTENSION_HEADER = "X-A2A-Extensions";
 
-// src/server/agent_execution/request_context.ts
-var RequestContext = class {
-  userMessage;
-  taskId;
-  contextId;
-  task;
-  referenceTasks;
-  context;
-  constructor(userMessage, taskId, contextId, task, referenceTasks, context) {
-    this.userMessage = userMessage;
-    this.taskId = taskId;
-    this.contextId = contextId;
-    this.task = task;
-    this.referenceTasks = referenceTasks;
-    this.context = context;
-  }
-};
-
-// src/server/events/execution_event_bus.ts
-var import_events = require("events");
-var DefaultExecutionEventBus = class extends import_events.EventEmitter {
-  constructor() {
-    super();
-  }
-  publish(event) {
-    this.emit("event", event);
-  }
-  finished() {
-    this.emit("finished");
-  }
-};
-
-// src/server/events/execution_event_bus_manager.ts
-var DefaultExecutionEventBusManager = class {
-  taskIdToBus = /* @__PURE__ */ new Map();
-  /**
-   * Creates or retrieves an existing ExecutionEventBus based on the taskId.
-   * @param taskId The ID of the task.
-   * @returns An instance of IExecutionEventBus.
-   */
-  createOrGetByTaskId(taskId) {
-    if (!this.taskIdToBus.has(taskId)) {
-      this.taskIdToBus.set(taskId, new DefaultExecutionEventBus());
-    }
-    return this.taskIdToBus.get(taskId);
-  }
-  /**
-   * Retrieves an existing ExecutionEventBus based on the taskId.
-   * @param taskId The ID of the task.
-   * @returns An instance of IExecutionEventBus or undefined if not found.
-   */
-  getByTaskId(taskId) {
-    return this.taskIdToBus.get(taskId);
-  }
-  /**
-   * Removes the event bus for a given taskId.
-   * This should be called when an execution flow is complete to free resources.
-   * @param taskId The ID of the task.
-   */
-  cleanupByTaskId(taskId) {
-    const bus = this.taskIdToBus.get(taskId);
-    if (bus) {
-      bus.removeAllListeners();
-    }
-    this.taskIdToBus.delete(taskId);
-  }
-};
-
-// src/server/events/execution_event_queue.ts
-var ExecutionEventQueue = class {
-  eventBus;
-  eventQueue = [];
-  resolvePromise;
-  stopped = false;
-  boundHandleEvent;
-  constructor(eventBus) {
-    this.eventBus = eventBus;
-    this.eventBus.on("event", this.handleEvent);
-    this.eventBus.on("finished", this.handleFinished);
-  }
-  handleEvent = (event) => {
-    if (this.stopped) return;
-    this.eventQueue.push(event);
-    if (this.resolvePromise) {
-      this.resolvePromise();
-      this.resolvePromise = void 0;
-    }
-  };
-  handleFinished = () => {
-    this.stop();
-  };
-  /**
-   * Provides an async generator that yields events from the event bus.
-   * Stops when a Message event is received or a TaskStatusUpdateEvent with final=true is received.
-   */
-  async *events() {
-    while (!this.stopped || this.eventQueue.length > 0) {
-      if (this.eventQueue.length > 0) {
-        const event = this.eventQueue.shift();
-        yield event;
-        if (event.kind === "message" || event.kind === "status-update" && event.final) {
-          this.handleFinished();
-          break;
-        }
-      } else if (!this.stopped) {
-        await new Promise((resolve) => {
-          this.resolvePromise = resolve;
-        });
-      }
-    }
-  }
-  /**
-   * Stops the event queue from processing further events.
-   */
-  stop() {
-    this.stopped = true;
-    if (this.resolvePromise) {
-      this.resolvePromise();
-      this.resolvePromise = void 0;
-    }
-    this.eventBus.off("event", this.handleEvent);
-    this.eventBus.off("finished", this.handleFinished);
-  }
-};
-
-// src/server/utils.ts
-function getCurrentTimestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isTaskStatusUpdate(update) {
-  return isObject(update) && "state" in update && !("parts" in update);
-}
-function isArtifactUpdate(update) {
-  return isObject(update) && "parts" in update;
-}
-function getRequestedExtensions(values) {
-  if (!values) {
-    return /* @__PURE__ */ new Set();
-  }
-  return new Set(
-    values.split(",").map((ext) => ext.trim()).filter((ext) => ext.length > 0)
-  );
-}
-
-// src/server/request_handler/default_request_handler.ts
-var import_uuid = require("uuid");
-
-// src/server/error.ts
-var A2AError = class _A2AError extends Error {
-  code;
-  data;
-  taskId;
-  // Optional task ID context
-  constructor(code, message, data, taskId) {
-    super(message);
-    this.name = "A2AError";
-    this.code = code;
-    this.data = data;
-    this.taskId = taskId;
-  }
-  /**
-   * Formats the error into a standard JSON-RPC error object structure.
-   */
-  toJSONRPCError() {
-    const errorObject = {
-      code: this.code,
-      message: this.message
-    };
-    if (this.data !== void 0) {
-      errorObject.data = this.data;
-    }
-    return errorObject;
-  }
-  // Static factory methods for common errors
-  static parseError(message, data) {
-    return new _A2AError(-32700, message, data);
-  }
-  static invalidRequest(message, data) {
-    return new _A2AError(-32600, message, data);
-  }
-  static methodNotFound(method) {
-    return new _A2AError(-32601, `Method not found: ${method}`);
-  }
-  static invalidParams(message, data) {
-    return new _A2AError(-32602, message, data);
-  }
-  static internalError(message, data) {
-    return new _A2AError(-32603, message, data);
-  }
-  static taskNotFound(taskId) {
-    return new _A2AError(-32001, `Task not found: ${taskId}`, void 0, taskId);
-  }
-  static taskNotCancelable(taskId) {
-    return new _A2AError(-32002, `Task not cancelable: ${taskId}`, void 0, taskId);
-  }
-  static pushNotificationNotSupported() {
-    return new _A2AError(-32003, "Push Notification is not supported");
-  }
-  static unsupportedOperation(operation) {
-    return new _A2AError(-32004, `Unsupported operation: ${operation}`);
-  }
-  static authenticatedExtendedCardNotConfigured() {
-    return new _A2AError(-32007, `Extended card not configured.`);
-  }
-};
-
-// src/server/result_manager.ts
-var ResultManager = class {
-  taskStore;
-  currentTask;
-  latestUserMessage;
-  // To add to history if a new task is created
-  finalMessageResult;
-  // Stores the message if it's the final result
-  constructor(taskStore) {
-    this.taskStore = taskStore;
-  }
-  setContext(latestUserMessage) {
-    this.latestUserMessage = latestUserMessage;
-  }
-  /**
-   * Processes an agent execution event and updates the task store.
-   * @param event The agent execution event.
-   */
-  async processEvent(event) {
-    if (event.kind === "message") {
-      this.finalMessageResult = event;
-    } else if (event.kind === "task") {
-      const taskEvent = event;
-      this.currentTask = { ...taskEvent };
-      if (this.latestUserMessage) {
-        if (!this.currentTask.history?.find(
-          (msg) => msg.messageId === this.latestUserMessage.messageId
-        )) {
-          this.currentTask.history = [this.latestUserMessage, ...this.currentTask.history || []];
-        }
-      }
-      await this.saveCurrentTask();
-    } else if (event.kind === "status-update") {
-      const updateEvent = event;
-      if (this.currentTask && this.currentTask.id === updateEvent.taskId) {
-        this.currentTask.status = updateEvent.status;
-        if (updateEvent.status.message) {
-          if (!this.currentTask.history?.find(
-            (msg) => msg.messageId === updateEvent.status.message.messageId
-          )) {
-            this.currentTask.history = [
-              ...this.currentTask.history || [],
-              updateEvent.status.message
-            ];
-          }
-        }
-        await this.saveCurrentTask();
-      } else if (!this.currentTask && updateEvent.taskId) {
-        const loaded = await this.taskStore.load(updateEvent.taskId);
-        if (loaded) {
-          this.currentTask = loaded;
-          this.currentTask.status = updateEvent.status;
-          if (updateEvent.status.message) {
-            if (!this.currentTask.history?.find(
-              (msg) => msg.messageId === updateEvent.status.message.messageId
-            )) {
-              this.currentTask.history = [
-                ...this.currentTask.history || [],
-                updateEvent.status.message
-              ];
-            }
-          }
-          await this.saveCurrentTask();
-        } else {
-          console.warn(
-            `ResultManager: Received status update for unknown task ${updateEvent.taskId}`
-          );
-        }
-      }
-    } else if (event.kind === "artifact-update") {
-      const artifactEvent = event;
-      if (this.currentTask && this.currentTask.id === artifactEvent.taskId) {
-        if (!this.currentTask.artifacts) {
-          this.currentTask.artifacts = [];
-        }
-        const existingArtifactIndex = this.currentTask.artifacts.findIndex(
-          (art) => art.artifactId === artifactEvent.artifact.artifactId
-        );
-        if (existingArtifactIndex !== -1) {
-          if (artifactEvent.append) {
-            const existingArtifact = this.currentTask.artifacts[existingArtifactIndex];
-            existingArtifact.parts.push(...artifactEvent.artifact.parts);
-            if (artifactEvent.artifact.description)
-              existingArtifact.description = artifactEvent.artifact.description;
-            if (artifactEvent.artifact.name) existingArtifact.name = artifactEvent.artifact.name;
-            if (artifactEvent.artifact.metadata)
-              existingArtifact.metadata = {
-                ...existingArtifact.metadata,
-                ...artifactEvent.artifact.metadata
-              };
-          } else {
-            this.currentTask.artifacts[existingArtifactIndex] = artifactEvent.artifact;
-          }
-        } else {
-          this.currentTask.artifacts.push(artifactEvent.artifact);
-        }
-        await this.saveCurrentTask();
-      } else if (!this.currentTask && artifactEvent.taskId) {
-        const loaded = await this.taskStore.load(artifactEvent.taskId);
-        if (loaded) {
-          this.currentTask = loaded;
-          if (!this.currentTask.artifacts) this.currentTask.artifacts = [];
-          const existingArtifactIndex = this.currentTask.artifacts.findIndex(
-            (art) => art.artifactId === artifactEvent.artifact.artifactId
-          );
-          if (existingArtifactIndex !== -1) {
-            if (artifactEvent.append) {
-              this.currentTask.artifacts[existingArtifactIndex].parts.push(
-                ...artifactEvent.artifact.parts
-              );
-            } else {
-              this.currentTask.artifacts[existingArtifactIndex] = artifactEvent.artifact;
-            }
-          } else {
-            this.currentTask.artifacts.push(artifactEvent.artifact);
-          }
-          await this.saveCurrentTask();
-        } else {
-          console.warn(
-            `ResultManager: Received artifact update for unknown task ${artifactEvent.taskId}`
-          );
-        }
-      }
-    }
-  }
-  async saveCurrentTask() {
-    if (this.currentTask) {
-      await this.taskStore.save(this.currentTask);
-    }
-  }
-  /**
-   * Gets the final result, which could be a Message or a Task.
-   * This should be called after the event stream has been fully processed.
-   * @returns The final Message or the current Task.
-   */
-  getFinalResult() {
-    if (this.finalMessageResult) {
-      return this.finalMessageResult;
-    }
-    return this.currentTask;
-  }
-  /**
-   * Gets the task currently being managed by this ResultManager instance.
-   * This task could be one that was started with or one created during agent execution.
-   * @returns The current Task or undefined if no task is active.
-   */
-  getCurrentTask() {
-    return this.currentTask;
-  }
-};
-
-// src/server/push_notification/push_notification_store.ts
-var InMemoryPushNotificationStore = class {
-  store = /* @__PURE__ */ new Map();
-  async save(taskId, pushNotificationConfig) {
-    const configs = this.store.get(taskId) || [];
-    if (!pushNotificationConfig.id) {
-      pushNotificationConfig.id = taskId;
-    }
-    const existingIndex = configs.findIndex((config) => config.id === pushNotificationConfig.id);
-    if (existingIndex !== -1) {
-      configs.splice(existingIndex, 1);
-    }
-    configs.push(pushNotificationConfig);
-    this.store.set(taskId, configs);
-  }
-  async load(taskId) {
-    const configs = this.store.get(taskId);
-    return configs || [];
-  }
-  async delete(taskId, configId) {
-    if (configId === void 0) {
-      configId = taskId;
-    }
-    const configs = this.store.get(taskId);
-    if (!configs) {
-      return;
-    }
-    const configIndex = configs.findIndex((config) => config.id === configId);
-    if (configIndex !== -1) {
-      configs.splice(configIndex, 1);
-    }
-    if (configs.length === 0) {
-      this.store.delete(taskId);
-    } else {
-      this.store.set(taskId, configs);
-    }
-  }
-};
-
-// src/server/push_notification/default_push_notification_sender.ts
-var DefaultPushNotificationSender = class {
-  pushNotificationStore;
-  notificationChain;
-  options;
-  constructor(pushNotificationStore, options = {}) {
-    this.pushNotificationStore = pushNotificationStore;
-    this.notificationChain = /* @__PURE__ */ new Map();
-    this.options = {
-      timeout: 5e3,
-      tokenHeaderName: "X-A2A-Notification-Token",
-      ...options
-    };
-  }
-  async send(task) {
-    const pushConfigs = await this.pushNotificationStore.load(task.id);
-    if (!pushConfigs || pushConfigs.length === 0) {
-      return;
-    }
-    const lastPromise = this.notificationChain.get(task.id) ?? Promise.resolve();
-    const newPromise = lastPromise.then(async () => {
-      const dispatches = pushConfigs.map(async (pushConfig) => {
-        try {
-          await this._dispatchNotification(task, pushConfig);
-        } catch (error) {
-          console.error(
-            `Error sending push notification for task_id=${task.id} to URL: ${pushConfig.url}. Error:`,
-            error
-          );
-        }
-      });
-      await Promise.all(dispatches);
-    });
-    this.notificationChain.set(task.id, newPromise);
-    newPromise.finally(() => {
-      if (this.notificationChain.get(task.id) === newPromise) {
-        this.notificationChain.delete(task.id);
-      }
-    });
-  }
-  async _dispatchNotification(task, pushConfig) {
-    const url = pushConfig.url;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
-    try {
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (pushConfig.token) {
-        headers[this.options.tokenHeaderName] = pushConfig.token;
-      }
-      const response = await fetch(url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(task),
-        signal: controller.signal
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-      console.info(`Push notification sent for task_id=${task.id} to URL: ${url}`);
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-};
-
-// src/server/context.ts
-var ServerCallContext = class {
-  _requestedExtensions;
-  _user;
-  _activatedExtensions;
-  constructor(requestedExtensions, user) {
-    this._requestedExtensions = requestedExtensions;
-    this._user = user;
-  }
-  get user() {
-    return this._user;
-  }
-  get activatedExtensions() {
-    return this._activatedExtensions;
-  }
-  get requestedExtensions() {
-    return this._requestedExtensions;
-  }
-  addActivatedExtension(uri) {
-    if (this._requestedExtensions?.has(uri)) {
-      if (!this._activatedExtensions) {
-        this._activatedExtensions = /* @__PURE__ */ new Set();
-      }
-      this._activatedExtensions.add(uri);
-    }
-  }
-};
-
-// src/server/request_handler/default_request_handler.ts
-var terminalStates = ["completed", "failed", "canceled", "rejected"];
-var DefaultRequestHandler = class {
-  agentCard;
-  taskStore;
-  agentExecutor;
-  eventBusManager;
-  pushNotificationStore;
-  pushNotificationSender;
-  extendedAgentCardProvider;
-  constructor(agentCard, taskStore, agentExecutor, eventBusManager = new DefaultExecutionEventBusManager(), pushNotificationStore, pushNotificationSender, extendedAgentCardProvider) {
-    this.agentCard = agentCard;
-    this.taskStore = taskStore;
-    this.agentExecutor = agentExecutor;
-    this.eventBusManager = eventBusManager;
-    this.extendedAgentCardProvider = extendedAgentCardProvider;
-    if (agentCard.capabilities.pushNotifications) {
-      this.pushNotificationStore = pushNotificationStore || new InMemoryPushNotificationStore();
-      this.pushNotificationSender = pushNotificationSender || new DefaultPushNotificationSender(this.pushNotificationStore);
-    }
-  }
-  async getAgentCard() {
-    return this.agentCard;
-  }
-  async getAuthenticatedExtendedAgentCard(context) {
-    if (!this.agentCard.supportsAuthenticatedExtendedCard) {
-      throw A2AError.unsupportedOperation("Agent does not support authenticated extended card.");
-    }
-    if (!this.extendedAgentCardProvider) {
-      throw A2AError.authenticatedExtendedCardNotConfigured();
-    }
-    if (typeof this.extendedAgentCardProvider === "function") {
-      return this.extendedAgentCardProvider(context);
-    }
-    if (context?.user?.isAuthenticated) {
-      return this.extendedAgentCardProvider;
-    }
-    return this.agentCard;
-  }
-  async _createRequestContext(incomingMessage, context) {
-    let task;
-    let referenceTasks;
-    if (incomingMessage.taskId) {
-      task = await this.taskStore.load(incomingMessage.taskId);
-      if (!task) {
-        throw A2AError.taskNotFound(incomingMessage.taskId);
-      }
-      if (terminalStates.includes(task.status.state)) {
-        throw A2AError.invalidRequest(
-          `Task ${task.id} is in a terminal state (${task.status.state}) and cannot be modified.`
-        );
-      }
-      task.history = [...task.history || [], incomingMessage];
-      await this.taskStore.save(task);
-    }
-    const taskId = incomingMessage.taskId || (0, import_uuid.v4)();
-    if (incomingMessage.referenceTaskIds && incomingMessage.referenceTaskIds.length > 0) {
-      referenceTasks = [];
-      for (const refId of incomingMessage.referenceTaskIds) {
-        const refTask = await this.taskStore.load(refId);
-        if (refTask) {
-          referenceTasks.push(refTask);
-        } else {
-          console.warn(`Reference task ${refId} not found.`);
-        }
-      }
-    }
-    const contextId = incomingMessage.contextId || task?.contextId || (0, import_uuid.v4)();
-    if (context?.requestedExtensions) {
-      const agentCard = await this.getAgentCard();
-      const exposedExtensions = new Set(
-        agentCard.capabilities.extensions?.map((ext) => ext.uri) || []
-      );
-      const validExtensions = new Set(
-        Array.from(context.requestedExtensions).filter(
-          (extension) => exposedExtensions.has(extension)
-        )
-      );
-      context = new ServerCallContext(validExtensions, context.user);
-    }
-    const messageForContext = {
-      ...incomingMessage,
-      contextId,
-      taskId
-    };
-    return new RequestContext(messageForContext, taskId, contextId, task, referenceTasks, context);
-  }
-  async _processEvents(taskId, resultManager, eventQueue, options) {
-    let firstResultSent = false;
-    try {
-      for await (const event of eventQueue.events()) {
-        await resultManager.processEvent(event);
-        try {
-          await this._sendPushNotificationIfNeeded(event);
-        } catch (error) {
-          console.error(`Error sending push notification: ${error}`);
-        }
-        if (options?.firstResultResolver && !firstResultSent) {
-          let firstResult;
-          if (event.kind === "message") {
-            firstResult = event;
-          } else {
-            firstResult = resultManager.getCurrentTask();
-          }
-          if (firstResult) {
-            options.firstResultResolver(firstResult);
-            firstResultSent = true;
-          }
-        }
-      }
-      if (options?.firstResultRejector && !firstResultSent) {
-        options.firstResultRejector(
-          A2AError.internalError("Execution finished before a message or task was produced.")
-        );
-      }
-    } catch (error) {
-      console.error(`Event processing loop failed for task ${taskId}:`, error);
-      this._handleProcessingError(
-        error,
-        resultManager,
-        firstResultSent,
-        taskId,
-        options?.firstResultRejector
-      );
-    } finally {
-      this.eventBusManager.cleanupByTaskId(taskId);
-    }
-  }
-  async sendMessage(params, context) {
-    const incomingMessage = params.message;
-    if (!incomingMessage.messageId) {
-      throw A2AError.invalidParams("message.messageId is required.");
-    }
-    const isBlocking = params.configuration?.blocking !== false;
-    const resultManager = new ResultManager(this.taskStore);
-    resultManager.setContext(incomingMessage);
-    const requestContext = await this._createRequestContext(incomingMessage, context);
-    const taskId = requestContext.taskId;
-    const finalMessageForAgent = requestContext.userMessage;
-    if (params.configuration?.pushNotificationConfig && this.agentCard.capabilities.pushNotifications) {
-      await this.pushNotificationStore?.save(taskId, params.configuration.pushNotificationConfig);
-    }
-    const eventBus = this.eventBusManager.createOrGetByTaskId(taskId);
-    const eventQueue = new ExecutionEventQueue(eventBus);
-    this.agentExecutor.execute(requestContext, eventBus).catch((err) => {
-      console.error(`Agent execution failed for message ${finalMessageForAgent.messageId}:`, err);
-      const errorTask = {
-        id: requestContext.task?.id || (0, import_uuid.v4)(),
-        // Use existing task ID or generate new
-        contextId: finalMessageForAgent.contextId,
-        status: {
-          state: "failed",
-          message: {
-            kind: "message",
-            role: "agent",
-            messageId: (0, import_uuid.v4)(),
-            parts: [{ kind: "text", text: `Agent execution error: ${err.message}` }],
-            taskId: requestContext.task?.id,
-            contextId: finalMessageForAgent.contextId
-          },
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        history: requestContext.task?.history ? [...requestContext.task.history] : [],
-        kind: "task"
-      };
-      if (finalMessageForAgent) {
-        if (!errorTask.history?.find((m) => m.messageId === finalMessageForAgent.messageId)) {
-          errorTask.history?.push(finalMessageForAgent);
-        }
-      }
-      eventBus.publish(errorTask);
-      eventBus.publish({
-        // And publish a final status update
-        kind: "status-update",
-        taskId: errorTask.id,
-        contextId: errorTask.contextId,
-        status: errorTask.status,
-        final: true
-      });
-      eventBus.finished();
-    });
-    if (isBlocking) {
-      await this._processEvents(taskId, resultManager, eventQueue);
-      const finalResult = resultManager.getFinalResult();
-      if (!finalResult) {
-        throw A2AError.internalError(
-          "Agent execution finished without a result, and no task context found."
-        );
-      }
-      return finalResult;
-    } else {
-      return new Promise((resolve, reject) => {
-        this._processEvents(taskId, resultManager, eventQueue, {
-          firstResultResolver: resolve,
-          firstResultRejector: reject
-        });
-      });
-    }
-  }
-  async *sendMessageStream(params, context) {
-    const incomingMessage = params.message;
-    if (!incomingMessage.messageId) {
-      throw A2AError.invalidParams("message.messageId is required for streaming.");
-    }
-    const resultManager = new ResultManager(this.taskStore);
-    resultManager.setContext(incomingMessage);
-    const requestContext = await this._createRequestContext(incomingMessage, context);
-    const taskId = requestContext.taskId;
-    const finalMessageForAgent = requestContext.userMessage;
-    const eventBus = this.eventBusManager.createOrGetByTaskId(taskId);
-    const eventQueue = new ExecutionEventQueue(eventBus);
-    if (params.configuration?.pushNotificationConfig && this.agentCard.capabilities.pushNotifications) {
-      await this.pushNotificationStore?.save(taskId, params.configuration.pushNotificationConfig);
-    }
-    this.agentExecutor.execute(requestContext, eventBus).catch((err) => {
-      console.error(
-        `Agent execution failed for stream message ${finalMessageForAgent.messageId}:`,
-        err
-      );
-      const errorTaskStatus = {
-        kind: "status-update",
-        taskId: requestContext.task?.id || (0, import_uuid.v4)(),
-        // Use existing or a placeholder
-        contextId: finalMessageForAgent.contextId,
-        status: {
-          state: "failed",
-          message: {
-            kind: "message",
-            role: "agent",
-            messageId: (0, import_uuid.v4)(),
-            parts: [{ kind: "text", text: `Agent execution error: ${err.message}` }],
-            taskId: requestContext.task?.id,
-            contextId: finalMessageForAgent.contextId
-          },
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        final: true
-        // This will terminate the stream for the client
-      };
-      eventBus.publish(errorTaskStatus);
-    });
-    try {
-      for await (const event of eventQueue.events()) {
-        await resultManager.processEvent(event);
-        await this._sendPushNotificationIfNeeded(event);
-        yield event;
-      }
-    } finally {
-      this.eventBusManager.cleanupByTaskId(taskId);
-    }
-  }
-  async getTask(params, _context) {
-    const task = await this.taskStore.load(params.id);
-    if (!task) {
-      throw A2AError.taskNotFound(params.id);
-    }
-    if (params.historyLength !== void 0 && params.historyLength >= 0) {
-      if (task.history) {
-        task.history = task.history.slice(-params.historyLength);
-      }
-    } else {
-      task.history = [];
-    }
-    return task;
-  }
-  async cancelTask(params, _context) {
-    const task = await this.taskStore.load(params.id);
-    if (!task) {
-      throw A2AError.taskNotFound(params.id);
-    }
-    const nonCancelableStates = ["completed", "failed", "canceled", "rejected"];
-    if (nonCancelableStates.includes(task.status.state)) {
-      throw A2AError.taskNotCancelable(params.id);
-    }
-    const eventBus = this.eventBusManager.getByTaskId(params.id);
-    if (eventBus) {
-      const eventQueue = new ExecutionEventQueue(eventBus);
-      await this.agentExecutor.cancelTask(params.id, eventBus);
-      await this._processEvents(params.id, new ResultManager(this.taskStore), eventQueue);
-    } else {
-      task.status = {
-        state: "canceled",
-        message: {
-          // Optional: Add a system message indicating cancellation
-          kind: "message",
-          role: "agent",
-          messageId: (0, import_uuid.v4)(),
-          parts: [{ kind: "text", text: "Task cancellation requested by user." }],
-          taskId: task.id,
-          contextId: task.contextId
-        },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      task.history = [...task.history || [], task.status.message];
-      await this.taskStore.save(task);
-    }
-    const latestTask = await this.taskStore.load(params.id);
-    if (!latestTask) {
-      throw A2AError.internalError(`Task ${params.id} not found after cancellation.`);
-    }
-    if (latestTask.status.state != "canceled") {
-      throw A2AError.taskNotCancelable(params.id);
-    }
-    return latestTask;
-  }
-  async setTaskPushNotificationConfig(params, _context) {
-    if (!this.agentCard.capabilities.pushNotifications) {
-      throw A2AError.pushNotificationNotSupported();
-    }
-    const task = await this.taskStore.load(params.taskId);
-    if (!task) {
-      throw A2AError.taskNotFound(params.taskId);
-    }
-    const { taskId, pushNotificationConfig } = params;
-    if (!pushNotificationConfig.id) {
-      pushNotificationConfig.id = taskId;
-    }
-    await this.pushNotificationStore?.save(taskId, pushNotificationConfig);
-    return params;
-  }
-  async getTaskPushNotificationConfig(params, _context) {
-    if (!this.agentCard.capabilities.pushNotifications) {
-      throw A2AError.pushNotificationNotSupported();
-    }
-    const task = await this.taskStore.load(params.id);
-    if (!task) {
-      throw A2AError.taskNotFound(params.id);
-    }
-    const configs = await this.pushNotificationStore?.load(params.id) || [];
-    if (configs.length === 0) {
-      throw A2AError.internalError(`Push notification config not found for task ${params.id}.`);
-    }
-    let configId;
-    if ("pushNotificationConfigId" in params && params.pushNotificationConfigId) {
-      configId = params.pushNotificationConfigId;
-    } else {
-      configId = params.id;
-    }
-    const config = configs.find((c) => c.id === configId);
-    if (!config) {
-      throw A2AError.internalError(
-        `Push notification config with id '${configId}' not found for task ${params.id}.`
-      );
-    }
-    return { taskId: params.id, pushNotificationConfig: config };
-  }
-  async listTaskPushNotificationConfigs(params, _context) {
-    if (!this.agentCard.capabilities.pushNotifications) {
-      throw A2AError.pushNotificationNotSupported();
-    }
-    const task = await this.taskStore.load(params.id);
-    if (!task) {
-      throw A2AError.taskNotFound(params.id);
-    }
-    const configs = await this.pushNotificationStore?.load(params.id) || [];
-    return configs.map((config) => ({
-      taskId: params.id,
-      pushNotificationConfig: config
-    }));
-  }
-  async deleteTaskPushNotificationConfig(params, _context) {
-    if (!this.agentCard.capabilities.pushNotifications) {
-      throw A2AError.pushNotificationNotSupported();
-    }
-    const task = await this.taskStore.load(params.id);
-    if (!task) {
-      throw A2AError.taskNotFound(params.id);
-    }
-    const { id: taskId, pushNotificationConfigId } = params;
-    await this.pushNotificationStore?.delete(taskId, pushNotificationConfigId);
-  }
-  async *resubscribe(params, _context) {
-    if (!this.agentCard.capabilities.streaming) {
-      throw A2AError.unsupportedOperation("Streaming (and thus resubscription) is not supported.");
-    }
-    const task = await this.taskStore.load(params.id);
-    if (!task) {
-      throw A2AError.taskNotFound(params.id);
-    }
-    yield task;
-    const finalStates = ["completed", "failed", "canceled", "rejected"];
-    if (finalStates.includes(task.status.state)) {
-      return;
-    }
-    const eventBus = this.eventBusManager.getByTaskId(params.id);
-    if (!eventBus) {
-      console.warn(`Resubscribe: No active event bus for task ${params.id}.`);
-      return;
-    }
-    const eventQueue = new ExecutionEventQueue(eventBus);
-    try {
-      for await (const event of eventQueue.events()) {
-        if (event.kind === "status-update" && event.taskId === params.id) {
-          yield event;
-        } else if (event.kind === "artifact-update" && event.taskId === params.id) {
-          yield event;
-        } else if (event.kind === "task" && event.id === params.id) {
-          yield event;
-        }
-      }
-    } finally {
-      eventQueue.stop();
-    }
-  }
-  async _sendPushNotificationIfNeeded(event) {
-    if (!this.agentCard.capabilities.pushNotifications) {
-      return;
-    }
-    let taskId = "";
-    if (event.kind == "task") {
-      const task2 = event;
-      taskId = task2.id;
-    } else {
-      taskId = event.taskId;
-    }
-    if (!taskId) {
-      console.error(`Task ID not found for event ${event.kind}.`);
-      return;
-    }
-    const task = await this.taskStore.load(taskId);
-    if (!task) {
-      console.error(`Task ${taskId} not found.`);
-      return;
-    }
-    this.pushNotificationSender?.send(task);
-  }
-  async _handleProcessingError(error, resultManager, firstResultSent, taskId, firstResultRejector) {
-    if (firstResultRejector && !firstResultSent) {
-      firstResultRejector(error);
-      return;
-    }
-    if (!firstResultRejector) {
-      throw error;
-    }
-    const currentTask = resultManager.getCurrentTask();
-    const errorMessage = error instanceof Error && error.message || "Unknown error";
-    if (currentTask) {
-      const statusUpdateFailed = {
-        taskId: currentTask.id,
-        contextId: currentTask.contextId,
-        status: {
-          state: "failed",
-          message: {
-            kind: "message",
-            role: "agent",
-            messageId: (0, import_uuid.v4)(),
-            parts: [{ kind: "text", text: `Event processing loop failed: ${errorMessage}` }],
-            taskId: currentTask.id,
-            contextId: currentTask.contextId
-          },
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        },
-        kind: "status-update",
-        final: true
-      };
-      try {
-        await resultManager.processEvent(statusUpdateFailed);
-      } catch (error2) {
-        console.error(
-          `Event processing loop failed for task ${taskId}: ${error2 instanceof Error && error2.message || "Unknown error"}`
-        );
-      }
-    } else {
-      console.error(`Event processing loop failed for task ${taskId}: ${errorMessage}`);
-    }
-  }
-};
-
-// src/server/store.ts
-var InMemoryTaskStore = class {
-  store = /* @__PURE__ */ new Map();
-  async load(taskId) {
-    const entry = this.store.get(taskId);
-    return entry ? { ...entry } : void 0;
-  }
-  async save(task) {
-    this.store.set(task.id, { ...task });
-  }
-};
-
-// src/server/transports/jsonrpc_transport_handler.ts
-var JsonRpcTransportHandler = class {
-  requestHandler;
-  constructor(requestHandler) {
-    this.requestHandler = requestHandler;
-  }
-  /**
-   * Handles an incoming JSON-RPC request.
-   * For streaming methods, it returns an AsyncGenerator of JSONRPCResult.
-   * For non-streaming methods, it returns a Promise of a single JSONRPCMessage (Result or ErrorResponse).
-   */
-  async handle(requestBody, context) {
-    let rpcRequest;
-    try {
-      if (typeof requestBody === "string") {
-        rpcRequest = JSON.parse(requestBody);
-      } else if (typeof requestBody === "object" && requestBody !== null) {
-        rpcRequest = requestBody;
-      } else {
-        throw A2AError.parseError("Invalid request body type.");
-      }
-      if (!this.isRequestValid(rpcRequest)) {
-        throw A2AError.invalidRequest("Invalid JSON-RPC Request.");
-      }
-    } catch (error) {
-      const a2aError = error instanceof A2AError ? error : A2AError.parseError(
-        error instanceof SyntaxError && error.message || "Failed to parse JSON request."
-      );
-      return {
-        jsonrpc: "2.0",
-        id: rpcRequest?.id !== void 0 ? rpcRequest.id : null,
-        error: a2aError.toJSONRPCError()
-      };
-    }
-    const { method, id: requestId = null } = rpcRequest;
-    try {
-      if (method !== "agent/getAuthenticatedExtendedCard" && !this.paramsAreValid(rpcRequest.params)) {
-        throw A2AError.invalidParams(`Invalid method parameters.`);
-      }
-      if (method === "message/stream" || method === "tasks/resubscribe") {
-        const params = rpcRequest.params;
-        const agentCard = await this.requestHandler.getAgentCard();
-        if (!agentCard.capabilities.streaming) {
-          throw A2AError.unsupportedOperation(`Method ${method} requires streaming capability.`);
-        }
-        const agentEventStream = method === "message/stream" ? this.requestHandler.sendMessageStream(params, context) : this.requestHandler.resubscribe(params, context);
-        return (async function* jsonRpcEventStream() {
-          try {
-            for await (const event of agentEventStream) {
-              yield {
-                jsonrpc: "2.0",
-                id: requestId,
-                // Use the original request ID for all streamed responses
-                result: event
-              };
-            }
-          } catch (streamError) {
-            console.error(
-              `Error in agent event stream for ${method} (request ${requestId}):`,
-              streamError
-            );
-            throw streamError;
-          }
-        })();
-      } else {
-        let result;
-        switch (method) {
-          case "message/send":
-            result = await this.requestHandler.sendMessage(rpcRequest.params, context);
-            break;
-          case "tasks/get":
-            result = await this.requestHandler.getTask(rpcRequest.params, context);
-            break;
-          case "tasks/cancel":
-            result = await this.requestHandler.cancelTask(rpcRequest.params, context);
-            break;
-          case "tasks/pushNotificationConfig/set":
-            result = await this.requestHandler.setTaskPushNotificationConfig(
-              rpcRequest.params,
-              context
-            );
-            break;
-          case "tasks/pushNotificationConfig/get":
-            result = await this.requestHandler.getTaskPushNotificationConfig(
-              rpcRequest.params,
-              context
-            );
-            break;
-          case "tasks/pushNotificationConfig/delete":
-            await this.requestHandler.deleteTaskPushNotificationConfig(rpcRequest.params, context);
-            result = null;
-            break;
-          case "tasks/pushNotificationConfig/list":
-            result = await this.requestHandler.listTaskPushNotificationConfigs(
-              rpcRequest.params,
-              context
-            );
-            break;
-          case "agent/getAuthenticatedExtendedCard":
-            result = await this.requestHandler.getAuthenticatedExtendedAgentCard(context);
-            break;
-          default:
-            throw A2AError.methodNotFound(method);
-        }
-        return {
-          jsonrpc: "2.0",
-          id: requestId,
-          result
-        };
-      }
-    } catch (error) {
-      let a2aError;
-      if (error instanceof A2AError) {
-        a2aError = error;
-      } else {
-        a2aError = A2AError.internalError(
-          error instanceof Error && error.message || "An unexpected error occurred."
-        );
-      }
-      return {
-        jsonrpc: "2.0",
-        id: requestId,
-        error: a2aError.toJSONRPCError()
-      };
-    }
-  }
-  // Validates the basic structure of a JSON-RPC request
-  isRequestValid(rpcRequest) {
-    if (rpcRequest.jsonrpc !== "2.0") {
-      return false;
-    }
-    if ("id" in rpcRequest) {
-      const id = rpcRequest.id;
-      const isString = typeof id === "string";
-      const isInteger = typeof id === "number" && Number.isInteger(id);
-      const isNull = id === null;
-      if (!isString && !isInteger && !isNull) {
-        return false;
-      }
-    }
-    if (!rpcRequest.method || typeof rpcRequest.method !== "string") {
-      return false;
-    }
-    return true;
-  }
-  // Validates that params is an object with non-empty string keys
-  paramsAreValid(params) {
-    if (typeof params !== "object" || params === null || Array.isArray(params)) {
-      return false;
-    }
-    for (const key of Object.keys(params)) {
-      if (key === "") {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-// src/errors.ts
-var TaskNotFoundError = class extends Error {
-  constructor(message) {
-    super(message ?? "Task not found");
-    this.name = "TaskNotFoundError";
-  }
-};
-var TaskNotCancelableError = class extends Error {
-  constructor(message) {
-    super(message ?? "Task cannot be canceled");
-    this.name = "TaskNotCancelableError";
-  }
-};
-var PushNotificationNotSupportedError = class extends Error {
-  constructor(message) {
-    super(message ?? "Push Notification is not supported");
-    this.name = "PushNotificationNotSupportedError";
-  }
-};
-var UnsupportedOperationError = class extends Error {
-  constructor(message) {
-    super(message ?? "This operation is not supported");
-    this.name = "UnsupportedOperationError";
-  }
-};
-var ContentTypeNotSupportedError = class extends Error {
-  constructor(message) {
-    super(message ?? "Incompatible content types");
-    this.name = "ContentTypeNotSupportedError";
-  }
-};
-var InvalidAgentResponseError = class extends Error {
-  constructor(message) {
-    super(message ?? "Invalid agent response type");
-    this.name = "InvalidAgentResponseError";
-  }
-};
-var AuthenticatedExtendedCardNotConfiguredError = class extends Error {
-  constructor(message) {
-    super(message ?? "Authenticated Extended Card not configured");
-    this.name = "AuthenticatedExtendedCardNotConfiguredError";
-  }
-};
-
-// src/client/transports/json_rpc_transport.ts
-var JsonRpcTransport = class _JsonRpcTransport {
-  customFetchImpl;
-  endpoint;
-  requestIdCounter = 1;
-  constructor(options) {
-    this.endpoint = options.endpoint;
-    this.customFetchImpl = options.fetchImpl;
-  }
-  async sendMessage(params, options, idOverride) {
-    const rpcResponse = await this._sendRpcRequest(
-      "message/send",
-      params,
-      idOverride,
-      options
-    );
-    return rpcResponse.result;
-  }
-  async *sendMessageStream(params, options) {
-    yield* this._sendStreamingRequest("message/stream", params, options);
-  }
-  async setTaskPushNotificationConfig(params, options, idOverride) {
-    const rpcResponse = await this._sendRpcRequest("tasks/pushNotificationConfig/set", params, idOverride, options);
-    return rpcResponse.result;
-  }
-  async getTaskPushNotificationConfig(params, options, idOverride) {
-    const rpcResponse = await this._sendRpcRequest("tasks/pushNotificationConfig/get", params, idOverride, options);
-    return rpcResponse.result;
-  }
-  async listTaskPushNotificationConfig(params, options, idOverride) {
-    const rpcResponse = await this._sendRpcRequest("tasks/pushNotificationConfig/list", params, idOverride, options);
-    return rpcResponse.result;
-  }
-  async deleteTaskPushNotificationConfig(params, options, idOverride) {
-    await this._sendRpcRequest("tasks/pushNotificationConfig/delete", params, idOverride, options);
-  }
-  async getTask(params, options, idOverride) {
-    const rpcResponse = await this._sendRpcRequest(
-      "tasks/get",
-      params,
-      idOverride,
-      options
-    );
-    return rpcResponse.result;
-  }
-  async cancelTask(params, options, idOverride) {
-    const rpcResponse = await this._sendRpcRequest(
-      "tasks/cancel",
-      params,
-      idOverride,
-      options
-    );
-    return rpcResponse.result;
-  }
-  async *resubscribeTask(params, options) {
-    yield* this._sendStreamingRequest("tasks/resubscribe", params, options);
-  }
-  async callExtensionMethod(method, params, idOverride, options) {
-    return await this._sendRpcRequest(
-      method,
-      params,
-      idOverride,
-      options
-    );
-  }
-  _fetch(...args) {
-    if (this.customFetchImpl) {
-      return this.customFetchImpl(...args);
-    }
-    if (typeof fetch === "function") {
-      return fetch(...args);
-    }
-    throw new Error(
-      "A `fetch` implementation was not provided and is not available in the global scope. Please provide a `fetchImpl` in the A2ATransportOptions. "
-    );
-  }
-  async _sendRpcRequest(method, params, idOverride, options) {
-    const requestId = idOverride ?? this.requestIdCounter++;
-    const rpcRequest = {
-      jsonrpc: "2.0",
-      method,
-      params,
-      id: requestId
-    };
-    const httpResponse = await this._fetchRpc(rpcRequest, "application/json", options?.signal);
-    if (!httpResponse.ok) {
-      let errorBodyText = "(empty or non-JSON response)";
-      let errorJson;
-      try {
-        errorBodyText = await httpResponse.text();
-        errorJson = JSON.parse(errorBodyText);
-      } catch (e) {
-        throw new Error(
-          `HTTP error for ${method}! Status: ${httpResponse.status} ${httpResponse.statusText}. Response: ${errorBodyText}`,
-          { cause: e }
-        );
-      }
-      if (errorJson.jsonrpc && errorJson.error) {
-        throw _JsonRpcTransport.mapToError(errorJson);
-      } else {
-        throw new Error(
-          `HTTP error for ${method}! Status: ${httpResponse.status} ${httpResponse.statusText}. Response: ${errorBodyText}`
-        );
-      }
-    }
-    const rpcResponse = await httpResponse.json();
-    if (rpcResponse.id !== requestId) {
-      console.error(
-        `CRITICAL: RPC response ID mismatch for method ${method}. Expected ${requestId}, got ${rpcResponse.id}.`
-      );
-    }
-    if ("error" in rpcResponse) {
-      throw _JsonRpcTransport.mapToError(rpcResponse);
-    }
-    return rpcResponse;
-  }
-  async _fetchRpc(rpcRequest, acceptHeader = "application/json", signal) {
-    const requestInit = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: acceptHeader
-      },
-      body: JSON.stringify(rpcRequest),
-      signal
-    };
-    return this._fetch(this.endpoint, requestInit);
-  }
-  async *_sendStreamingRequest(method, params, options) {
-    const clientRequestId = this.requestIdCounter++;
-    const rpcRequest = {
-      jsonrpc: "2.0",
-      method,
-      params,
-      id: clientRequestId
-    };
-    const response = await this._fetchRpc(rpcRequest, "text/event-stream", options?.signal);
-    if (!response.ok) {
-      let errorBody = "";
-      let errorJson;
-      try {
-        errorBody = await response.text();
-        errorJson = JSON.parse(errorBody);
-      } catch (e) {
-        throw new Error(
-          `HTTP error establishing stream for ${method}: ${response.status} ${response.statusText}. Response: ${errorBody || "(empty)"}`,
-          { cause: e }
-        );
-      }
-      if (errorJson.error) {
-        throw new Error(
-          `HTTP error establishing stream for ${method}: ${response.status} ${response.statusText}. RPC Error: ${errorJson.error.message} (Code: ${errorJson.error.code})`
-        );
-      }
-      throw new Error(
-        `HTTP error establishing stream for ${method}: ${response.status} ${response.statusText}`
-      );
-    }
-    if (!response.headers.get("Content-Type")?.startsWith("text/event-stream")) {
-      throw new Error(
-        `Invalid response Content-Type for SSE stream for ${method}. Expected 'text/event-stream'.`
-      );
-    }
-    yield* this._parseA2ASseStream(response, clientRequestId);
-  }
-  async *_parseA2ASseStream(response, originalRequestId) {
-    if (!response.body) {
-      throw new Error("SSE response body is undefined. Cannot read stream.");
-    }
-    const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
-    let buffer = "";
-    let eventDataBuffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          if (eventDataBuffer.trim()) {
-            const result = this._processSseEventData(
-              eventDataBuffer,
-              originalRequestId
-            );
-            yield result;
-          }
-          break;
-        }
-        buffer += value;
-        let lineEndIndex;
-        while ((lineEndIndex = buffer.indexOf("\n")) >= 0) {
-          const line = buffer.substring(0, lineEndIndex).trim();
-          buffer = buffer.substring(lineEndIndex + 1);
-          if (line === "") {
-            if (eventDataBuffer) {
-              const result = this._processSseEventData(
-                eventDataBuffer,
-                originalRequestId
-              );
-              yield result;
-              eventDataBuffer = "";
-            }
-          } else if (line.startsWith("data:")) {
-            eventDataBuffer += line.substring(5).trimStart() + "\n";
-          }
-        }
-      }
-    } catch (error) {
-      console.error(
-        "Error reading or parsing SSE stream:",
-        error instanceof Error && error.message || "Error unknown"
-      );
-      throw error;
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  _processSseEventData(jsonData, originalRequestId) {
-    if (!jsonData.trim()) {
-      throw new Error("Attempted to process empty SSE event data.");
-    }
-    try {
-      const sseJsonRpcResponse = JSON.parse(jsonData.replace(/\n$/, ""));
-      const a2aStreamResponse = sseJsonRpcResponse;
-      if (a2aStreamResponse.id !== originalRequestId) {
-        console.warn(
-          `SSE Event's JSON-RPC response ID mismatch. Client request ID: ${originalRequestId}, event response ID: ${a2aStreamResponse.id}.`
-        );
-      }
-      if ("error" in a2aStreamResponse) {
-        const err = a2aStreamResponse.error;
-        throw new Error(
-          `SSE event contained an error: ${err.message} (Code: ${err.code}) Data: ${JSON.stringify(err.data || {})}`
-        );
-      }
-      if (!("result" in a2aStreamResponse) || typeof a2aStreamResponse.result === "undefined") {
-        throw new Error(`SSE event JSON-RPC response is missing 'result' field. Data: ${jsonData}`);
-      }
-      return a2aStreamResponse.result;
-    } catch (e) {
-      if (e instanceof Error && (e.message.startsWith("SSE event contained an error") || e.message.startsWith("SSE event JSON-RPC response is missing 'result' field"))) {
-        throw e;
-      }
-      console.error(
-        "Failed to parse SSE event data string or unexpected JSON-RPC structure:",
-        jsonData,
-        e
-      );
-      throw new Error(
-        `Failed to parse SSE event data: "${jsonData.substring(0, 100)}...". Original error: ${e instanceof Error && e.message || "Unknown error"}`
-      );
-    }
-  }
-  static mapToError(response) {
-    switch (response.error.code) {
-      case -32001:
-        return new TaskNotFoundJSONRPCError(response);
-      case -32002:
-        return new TaskNotCancelableJSONRPCError(response);
-      case -32003:
-        return new PushNotificationNotSupportedJSONRPCError(response);
-      case -32004:
-        return new UnsupportedOperationJSONRPCError(response);
-      case -32005:
-        return new ContentTypeNotSupportedJSONRPCError(response);
-      case -32006:
-        return new InvalidAgentResponseJSONRPCError(response);
-      case -32007:
-        return new AuthenticatedExtendedCardNotConfiguredJSONRPCError(response);
-      default:
-        return new JSONRPCTransportError(response);
-    }
-  }
-};
-var JSONRPCTransportError = class extends Error {
-  constructor(errorResponse) {
-    super(
-      `JSON-RPC error: ${errorResponse.error.message} (Code: ${errorResponse.error.code}) Data: ${JSON.stringify(errorResponse.error.data || {})}`
-    );
-    this.errorResponse = errorResponse;
-  }
-};
-var TaskNotFoundJSONRPCError = class extends TaskNotFoundError {
-  constructor(errorResponse) {
-    super();
-    this.errorResponse = errorResponse;
-  }
-};
-var TaskNotCancelableJSONRPCError = class extends TaskNotCancelableError {
-  constructor(errorResponse) {
-    super();
-    this.errorResponse = errorResponse;
-  }
-};
-var PushNotificationNotSupportedJSONRPCError = class extends PushNotificationNotSupportedError {
-  constructor(errorResponse) {
-    super();
-    this.errorResponse = errorResponse;
-  }
-};
-var UnsupportedOperationJSONRPCError = class extends UnsupportedOperationError {
-  constructor(errorResponse) {
-    super();
-    this.errorResponse = errorResponse;
-  }
-};
-var ContentTypeNotSupportedJSONRPCError = class extends ContentTypeNotSupportedError {
-  constructor(errorResponse) {
-    super();
-    this.errorResponse = errorResponse;
-  }
-};
-var InvalidAgentResponseJSONRPCError = class extends InvalidAgentResponseError {
-  constructor(errorResponse) {
-    super();
-    this.errorResponse = errorResponse;
-  }
-};
-var AuthenticatedExtendedCardNotConfiguredJSONRPCError = class extends AuthenticatedExtendedCardNotConfiguredError {
-  constructor(errorResponse) {
-    super();
-    this.errorResponse = errorResponse;
-  }
-};
-
-// src/client/client.ts
-var A2AClient = class _A2AClient {
-  static emptyOptions = void 0;
-  agentCardPromise;
-  customFetchImpl;
-  serviceEndpointUrl;
-  // To be populated from AgentCard after fetchin
-  // A2AClient is built around JSON-RPC types, so it will only support JSON-RPC transport, new client with transport agnostic interface is going to be created for multi-transport.
-  // New transport abstraction isn't going to expose individual transport specific fields, so to keep returning JSON-RPC IDs here for compatibility,
-  // keep counter here and pass it to JsonRpcTransport via an optional idOverride parameter (which is not visible via transport-agnostic A2ATransport interface).
-  transport;
-  requestIdCounter = 1;
-  /**
-   * Constructs an A2AClient instance from an AgentCard.
-   * @param agentCard The AgentCard object.
-   * @param options Optional. The options for the A2AClient including the fetch/auth implementation.
-   */
-  constructor(agentCard, options) {
-    this.customFetchImpl = options?.fetchImpl;
-    if (typeof agentCard === "string") {
-      console.warn(
-        "Warning: Constructing A2AClient with a URL is deprecated. Please use A2AClient.fromCardUrl() instead."
-      );
-      this.agentCardPromise = this._fetchAndCacheAgentCard(agentCard, options?.agentCardPath);
-    } else {
-      if (!agentCard.url) {
-        throw new Error(
-          "Provided Agent Card does not contain a valid 'url' for the service endpoint."
-        );
-      }
-      this.serviceEndpointUrl = agentCard.url;
-      this.agentCardPromise = Promise.resolve(agentCard);
-    }
-  }
-  /**
-   * Dynamically resolves the fetch implementation to use for requests.
-   * Prefers a custom implementation if provided, otherwise falls back to the global fetch.
-   * @returns The fetch implementation.
-   * @param args Arguments to pass to the fetch implementation.
-   * @throws If no fetch implementation is available.
-   */
-  _fetch(...args) {
-    if (this.customFetchImpl) {
-      return this.customFetchImpl(...args);
-    }
-    if (typeof fetch === "function") {
-      return fetch(...args);
-    }
-    throw new Error(
-      "A `fetch` implementation was not provided and is not available in the global scope. Please provide a `fetchImpl` in the A2AClientOptions. For earlier Node.js versions (pre-v18), you can use a library like `node-fetch`."
-    );
-  }
-  /**
-   * Creates an A2AClient instance by fetching the AgentCard from a URL then constructing the A2AClient.
-   * @param agentCardUrl The URL of the agent card.
-   * @param options Optional. The options for the A2AClient including the fetch/auth implementation.
-   * @returns A Promise that resolves to a new A2AClient instance.
-   */
-  static async fromCardUrl(agentCardUrl, options) {
-    const fetchImpl = options?.fetchImpl;
-    const requestInit = {
-      headers: { Accept: "application/json" }
-    };
-    let response;
-    if (fetchImpl) {
-      response = await fetchImpl(agentCardUrl, requestInit);
-    } else if (typeof fetch === "function") {
-      response = await fetch(agentCardUrl, requestInit);
-    } else {
-      throw new Error(
-        "A `fetch` implementation was not provided and is not available in the global scope. Please provide a `fetchImpl` in the A2AClientOptions. For earlier Node.js versions (pre-v18), you can use a library like `node-fetch`."
-      );
-    }
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch Agent Card from ${agentCardUrl}: ${response.status} ${response.statusText}`
-      );
-    }
-    let agentCard;
-    try {
-      agentCard = await response.json();
-    } catch (error) {
-      console.error("Failed to parse Agent Card JSON:", error);
-      throw new Error(
-        `Failed to parse Agent Card JSON from ${agentCardUrl}. Original error: ${error.message}`
-      );
-    }
-    return new _A2AClient(agentCard, options);
-  }
-  /**
-   * Sends a message to the agent.
-   * The behavior (blocking/non-blocking) and push notification configuration
-   * are specified within the `params.configuration` object.
-   * Optionally, `params.message.contextId` or `params.message.taskId` can be provided.
-   * @param params The parameters for sending the message, including the message content and configuration.
-   * @returns A Promise resolving to SendMessageResponse, which can be a Message, Task, or an error.
-   */
-  async sendMessage(params) {
-    return await this.invokeJsonRpc(
-      (t, p, id) => t.sendMessage(p, _A2AClient.emptyOptions, id),
-      params
-    );
-  }
+// src/extensions.ts
+var Extensions = {
   /**
-   * Sends a message to the agent and streams back responses using Server-Sent Events (SSE).
-   * Push notification configuration can be specified in `params.configuration`.
-   * Optionally, `params.message.contextId` or `params.message.taskId` can be provided.
-   * Requires the agent to support streaming (`capabilities.streaming: true` in AgentCard).
-   * @param params The parameters for sending the message.
-   * @returns An AsyncGenerator yielding A2AStreamEventData (Message, Task, TaskStatusUpdateEvent, or TaskArtifactUpdateEvent).
-   * The generator throws an error if streaming is not supported or if an HTTP/SSE error occurs.
+   * Creates new {@link Extensions} from `current` and `additional`.
+   * If `current` already contains `additional` it is returned unmodified.
    */
-  async *sendMessageStream(params) {
-    const agentCard = await this.agentCardPromise;
-    if (!agentCard.capabilities?.streaming) {
-      throw new Error(
-        "Agent does not support streaming (AgentCard.capabilities.streaming is not true)."
-      );
+  createFrom: (current, additional) => {
+    if (current?.includes(additional)) {
+      return current;
     }
-    const transport = await this._getOrCreateTransport();
-    yield* transport.sendMessageStream(params);
-  }
+    return [...current ?? [], additional];
+  },
   /**
-   * Sets or updates the push notification configuration for a given task.
-   * Requires the agent to support push notifications (`capabilities.pushNotifications: true` in AgentCard).
-   * @param params Parameters containing the taskId and the TaskPushNotificationConfig.
-   * @returns A Promise resolving to SetTaskPushNotificationConfigResponse.
+   * Creates {@link Extensions} from comma separated extensions identifiers as per
+   * https://a2a-protocol.org/latest/specification/#326-service-parameters.
+   * Parses the output of `toServiceParameter`.
    */
-  async setTaskPushNotificationConfig(params) {
-    const agentCard = await this.agentCardPromise;
-    if (!agentCard.capabilities?.pushNotifications) {
-      throw new Error(
-        "Agent does not support push notifications (AgentCard.capabilities.pushNotifications is not true)."
-      );
+  parseServiceParameter: (value) => {
+    if (!value) {
+      return [];
     }
-    return await this.invokeJsonRpc((t, p, id) => t.setTaskPushNotificationConfig(p, _A2AClient.emptyOptions, id), params);
-  }
-  /**
-   * Gets the push notification configuration for a given task.
-   * @param params Parameters containing the taskId.
-   * @returns A Promise resolving to GetTaskPushNotificationConfigResponse.
-   */
-  async getTaskPushNotificationConfig(params) {
-    return await this.invokeJsonRpc(
-      (t, p, id) => t.getTaskPushNotificationConfig(p, _A2AClient.emptyOptions, id),
-      params
+    const unique = new Set(
+      value.split(",").map((ext) => ext.trim()).filter((ext) => ext.length > 0)
     );
-  }
+    return Array.from(unique);
+  },
   /**
-   * Lists the push notification configurations for a given task.
-   * @param params Parameters containing the taskId.
-   * @returns A Promise resolving to ListTaskPushNotificationConfigResponse.
+   * Converts {@link Extensions} to comma separated extensions identifiers as per
+   * https://a2a-protocol.org/latest/specification/#326-service-parameters.
    */
-  async listTaskPushNotificationConfig(params) {
-    return await this.invokeJsonRpc((t, p, id) => t.listTaskPushNotificationConfig(p, _A2AClient.emptyOptions, id), params);
-  }
-  /**
-   * Deletes the push notification configuration for a given task.
-   * @param params Parameters containing the taskId and push notification configuration ID.
-   * @returns A Promise resolving to DeleteTaskPushNotificationConfigResponse.
-   */
-  async deleteTaskPushNotificationConfig(params) {
-    return await this.invokeJsonRpc((t, p, id) => t.deleteTaskPushNotificationConfig(p, _A2AClient.emptyOptions, id), params);
-  }
-  /**
-   * Retrieves a task by its ID.
-   * @param params Parameters containing the taskId and optional historyLength.
-   * @returns A Promise resolving to GetTaskResponse, which contains the Task object or an error.
-   */
-  async getTask(params) {
-    return await this.invokeJsonRpc(
-      (t, p, id) => t.getTask(p, _A2AClient.emptyOptions, id),
-      params
-    );
-  }
-  /**
-   * Cancels a task by its ID.
-   * @param params Parameters containing the taskId.
-   * @returns A Promise resolving to CancelTaskResponse, which contains the updated Task object or an error.
-   */
-  async cancelTask(params) {
-    return await this.invokeJsonRpc(
-      (t, p, id) => t.cancelTask(p, _A2AClient.emptyOptions, id),
-      params
-    );
-  }
-  /**
-   * @template TExtensionParams The type of parameters for the custom extension method.
-   * @template TExtensionResponse The type of response expected from the custom extension method.
-   * This should extend JSONRPCResponse. This ensures the extension response is still a valid A2A response.
-   * @param method Custom JSON-RPC method defined in the AgentCard's extensions.
-   * @param params Extension paramters defined in the AgentCard's extensions.
-   * @returns A Promise that resolves to the RPC response.
-   */
-  async callExtensionMethod(method, params) {
-    const transport = await this._getOrCreateTransport();
-    try {
-      return await transport.callExtensionMethod(
-        method,
-        params,
-        this.requestIdCounter++
-      );
-    } catch (e) {
-      const errorResponse = extractJSONRPCError(e);
-      if (errorResponse) {
-        return errorResponse;
-      }
-      throw e;
-    }
-  }
-  /**
-   * Resubscribes to a task's event stream using Server-Sent Events (SSE).
-   * This is used if a previous SSE connection for an active task was broken.
-   * Requires the agent to support streaming (`capabilities.streaming: true` in AgentCard).
-   * @param params Parameters containing the taskId.
-   * @returns An AsyncGenerator yielding A2AStreamEventData (Message, Task, TaskStatusUpdateEvent, or TaskArtifactUpdateEvent).
-   */
-  async *resubscribeTask(params) {
-    const agentCard = await this.agentCardPromise;
-    if (!agentCard.capabilities?.streaming) {
-      throw new Error("Agent does not support streaming (required for tasks/resubscribe).");
-    }
-    const transport = await this._getOrCreateTransport();
-    yield* transport.resubscribeTask(params);
-  }
-  ////////////////////////////////////////////////////////////////////////////////
-  // Functions used to support old A2AClient Constructor to be deprecated soon
-  // TODOs:
-  // * remove `agentCardPromise`, and just use agentCard initialized
-  // * _getServiceEndpoint can be made synchronous or deleted and accessed via
-  //   agentCard.url
-  // * getAgentCard changed to this.agentCard
-  // * delete resolveAgentCardUrl(), _fetchAndCacheAgentCard(),
-  //   agentCardPath from A2AClientOptions
-  // * delete _getOrCreateTransport
-  ////////////////////////////////////////////////////////////////////////////////
-  async _getOrCreateTransport() {
-    if (this.transport) {
-      return this.transport;
-    }
-    const endpoint = await this._getServiceEndpoint();
-    this.transport = new JsonRpcTransport({ fetchImpl: this.customFetchImpl, endpoint });
-    return this.transport;
-  }
-  /**
-   * Fetches the Agent Card from the agent's well-known URI and caches its service endpoint URL.
-   * This method is called by the constructor.
-   * @param agentBaseUrl The base URL of the A2A agent (e.g., https://agent.example.com)
-   * @param agentCardPath path to the agent card, defaults to .well-known/agent-card.json
-   * @returns A Promise that resolves to the AgentCard.
-   */
-  async _fetchAndCacheAgentCard(agentBaseUrl, agentCardPath) {
-    try {
-      const agentCardUrl = this.resolveAgentCardUrl(agentBaseUrl, agentCardPath);
-      const response = await this._fetch(agentCardUrl, {
-        headers: { Accept: "application/json" }
-      });
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch Agent Card from ${agentCardUrl}: ${response.status} ${response.statusText}`
-        );
-      }
-      const agentCard = await response.json();
-      if (!agentCard.url) {
-        throw new Error(
-          "Fetched Agent Card does not contain a valid 'url' for the service endpoint."
-        );
-      }
-      this.serviceEndpointUrl = agentCard.url;
-      return agentCard;
-    } catch (error) {
-      console.error("Error fetching or parsing Agent Card:", error);
-      throw error;
-    }
-  }
-  /**
-   * Retrieves the Agent Card.
-   * If an `agentBaseUrl` is provided, it fetches the card from that specific URL.
-   * Otherwise, it returns the card fetched and cached during client construction.
-   * @param agentBaseUrl Optional. The base URL of the agent to fetch the card from.
-   * @param agentCardPath path to the agent card, defaults to .well-known/agent-card.json
-   * If provided, this will fetch a new card, not use the cached one from the constructor's URL.
-   * @returns A Promise that resolves to the AgentCard.
-   */
-  async getAgentCard(agentBaseUrl, agentCardPath) {
-    if (agentBaseUrl) {
-      const agentCardUrl = this.resolveAgentCardUrl(agentBaseUrl, agentCardPath);
-      const response = await this._fetch(agentCardUrl, {
-        headers: { Accept: "application/json" }
-      });
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch Agent Card from ${agentCardUrl}: ${response.status} ${response.statusText}`
-        );
-      }
-      return await response.json();
-    }
-    return this.agentCardPromise;
-  }
-  /**
-   * Determines the agent card URL based on the agent URL.
-   * @param agentBaseUrl The agent URL.
-   * @param agentCardPath Optional relative path to the agent card, defaults to .well-known/agent-card.json
-   */
-  resolveAgentCardUrl(agentBaseUrl, agentCardPath = AGENT_CARD_PATH) {
-    return `${agentBaseUrl.replace(/\/$/, "")}/${agentCardPath.replace(/^\//, "")}`;
-  }
-  /**
-   * Gets the RPC service endpoint URL. Ensures the agent card has been fetched first.
-   * @returns A Promise that resolves to the service endpoint URL string.
-   */
-  async _getServiceEndpoint() {
-    if (this.serviceEndpointUrl) {
-      return this.serviceEndpointUrl;
-    }
-    await this.agentCardPromise;
-    if (!this.serviceEndpointUrl) {
-      throw new Error(
-        "Agent Card URL for RPC endpoint is not available. Fetching might have failed."
-      );
-    }
-    return this.serviceEndpointUrl;
-  }
-  async invokeJsonRpc(caller, params) {
-    const transport = await this._getOrCreateTransport();
-    const requestId = this.requestIdCounter++;
-    try {
-      const result = await caller(transport, params, requestId);
-      return {
-        id: requestId,
-        jsonrpc: "2.0",
-        result: result ?? null
-        // JSON-RPC requires result property on success, it will be null for "void" methods.
-      };
-    } catch (e) {
-      const errorResponse = extractJSONRPCError(e);
-      if (errorResponse) {
-        return errorResponse;
-      }
-      throw e;
-    }
-  }
-};
-function extractJSONRPCError(error) {
-  if (error instanceof Object && "errorResponse" in error && error.errorResponse instanceof Object && "jsonrpc" in error.errorResponse && error.errorResponse.jsonrpc === "2.0" && "error" in error.errorResponse && error.errorResponse.error !== null) {
-    return error.errorResponse;
-  } else {
-    return void 0;
-  }
-}
-
-// src/client/auth-handler.ts
-function createAuthenticatingFetchWithRetry(fetchImpl, authHandler) {
-  async function authFetch(url, init) {
-    const authHeaders = await authHandler.headers() || {};
-    const mergedInit = {
-      ...init || {},
-      headers: {
-        ...authHeaders,
-        ...init?.headers || {}
-      }
-    };
-    let response = await fetchImpl(url, mergedInit);
-    const updatedHeaders = await authHandler.shouldRetryWithHeaders(mergedInit, response);
-    if (updatedHeaders) {
-      const retryInit = {
-        ...init || {},
-        headers: {
-          ...updatedHeaders,
-          ...init?.headers || {}
-        }
-      };
-      response = await fetchImpl(url, retryInit);
-      if (response.ok && authHandler.onSuccessfulRetry) {
-        await authHandler.onSuccessfulRetry(updatedHeaders);
-      }
-    }
-    return response;
-  }
-  Object.setPrototypeOf(authFetch, Object.getPrototypeOf(fetchImpl));
-  Object.defineProperties(authFetch, Object.getOwnPropertyDescriptors(fetchImpl));
-  return authFetch;
-}
-
-// src/server/express/a2a_express_app.ts
-var import_express3 = __toESM(require("express"));
-
-// src/server/express/json_rpc_handler.ts
-var import_express = __toESM(require("express"));
-
-// src/server/authentication/user.ts
-var UnauthenticatedUser = class {
-  get isAuthenticated() {
-    return false;
-  }
-  get userName() {
-    return "";
-  }
-};
-
-// src/server/express/json_rpc_handler.ts
-function jsonRpcHandler(options) {
-  const jsonRpcTransportHandler = new JsonRpcTransportHandler(options.requestHandler);
-  const router = import_express.default.Router();
-  router.use(import_express.default.json(), jsonErrorHandler);
-  router.post("/", async (req, res) => {
-    try {
-      const user = await options.userBuilder(req);
-      const context = new ServerCallContext(
-        getRequestedExtensions(req.header(HTTP_EXTENSION_HEADER)),
-        user ?? new UnauthenticatedUser()
-      );
-      const rpcResponseOrStream = await jsonRpcTransportHandler.handle(req.body, context);
-      if (context.activatedExtensions) {
-        res.setHeader(HTTP_EXTENSION_HEADER, Array.from(context.activatedExtensions));
-      }
-      if (typeof rpcResponseOrStream?.[Symbol.asyncIterator] === "function") {
-        const stream = rpcResponseOrStream;
-        res.setHeader("Content-Type", "text/event-stream");
-        res.setHeader("Cache-Control", "no-cache");
-        res.setHeader("Connection", "keep-alive");
-        res.flushHeaders();
-        try {
-          for await (const event of stream) {
-            res.write(`id: ${(/* @__PURE__ */ new Date()).getTime()}
-`);
-            res.write(`data: ${JSON.stringify(event)}
-
-`);
-          }
-        } catch (streamError) {
-          console.error(`Error during SSE streaming (request ${req.body?.id}):`, streamError);
-          let a2aError;
-          if (streamError instanceof A2AError) {
-            a2aError = streamError;
-          } else {
-            a2aError = A2AError.internalError(
-              streamError instanceof Error && streamError.message || "Streaming error."
-            );
-          }
-          const errorResponse = {
-            jsonrpc: "2.0",
-            id: req.body?.id || null,
-            // Use original request ID if available
-            error: a2aError.toJSONRPCError()
-          };
-          if (!res.headersSent) {
-            res.status(500).json(errorResponse);
-          } else {
-            res.write(`id: ${(/* @__PURE__ */ new Date()).getTime()}
-`);
-            res.write(`event: error
-`);
-            res.write(`data: ${JSON.stringify(errorResponse)}
-
-`);
-          }
-        } finally {
-          if (!res.writableEnded) {
-            res.end();
-          }
-        }
-      } else {
-        const rpcResponse = rpcResponseOrStream;
-        res.status(200).json(rpcResponse);
-      }
-    } catch (error) {
-      console.error("Unhandled error in JSON-RPC POST handler:", error);
-      const a2aError = error instanceof A2AError ? error : A2AError.internalError("General processing error.");
-      const errorResponse = {
-        jsonrpc: "2.0",
-        id: req.body?.id || null,
-        error: a2aError.toJSONRPCError()
-      };
-      if (!res.headersSent) {
-        res.status(500).json(errorResponse);
-      } else if (!res.writableEnded) {
-        res.end();
-      }
-    }
-  });
-  return router;
-}
-var jsonErrorHandler = (err, _req, res, next) => {
-  if (err instanceof SyntaxError && "body" in err) {
-    const a2aError = A2AError.parseError("Invalid JSON payload.");
-    const errorResponse = {
-      jsonrpc: "2.0",
-      id: null,
-      error: a2aError.toJSONRPCError()
-    };
-    return res.status(400).json(errorResponse);
-  }
-  next(err);
-};
-
-// src/server/express/agent_card_handler.ts
-var import_express2 = __toESM(require("express"));
-function agentCardHandler(options) {
-  const router = import_express2.default.Router();
-  const provider = typeof options.agentCardProvider === "function" ? options.agentCardProvider : options.agentCardProvider.getAgentCard.bind(options.agentCardProvider);
-  router.get("/", async (_req, res) => {
-    try {
-      const agentCard = await provider();
-      res.json(agentCard);
-    } catch (error) {
-      console.error("Error fetching agent card:", error);
-      res.status(500).json({ error: "Failed to retrieve agent card" });
-    }
-  });
-  return router;
-}
-
-// src/server/express/common.ts
-var UserBuilder = {
-  NoAuthentication: () => Promise.resolve(new UnauthenticatedUser())
-};
-
-// src/server/express/a2a_express_app.ts
-var A2AExpressApp = class {
-  requestHandler;
-  userBuilder;
-  constructor(requestHandler, userBuilder = UserBuilder.NoAuthentication) {
-    this.requestHandler = requestHandler;
-    this.userBuilder = userBuilder;
-  }
-  /**
-   * Adds A2A routes to an existing Express app.
-   * @param app Optional existing Express app.
-   * @param baseUrl The base URL for A2A endpoints (e.g., "/a2a/api").
-   * @param middlewares Optional array of Express middlewares to apply to the A2A routes.
-   * @param agentCardPath Optional custom path for the agent card endpoint (defaults to .well-known/agent-card.json).
-   * @returns The Express app with A2A routes.
-   */
-  setupRoutes(app, baseUrl = "", middlewares, agentCardPath = AGENT_CARD_PATH) {
-    const router = import_express3.default.Router();
-    router.use(import_express3.default.json(), jsonErrorHandler);
-    if (middlewares && middlewares.length > 0) {
-      router.use(middlewares);
-    }
-    router.use(
-      jsonRpcHandler({
-        requestHandler: this.requestHandler,
-        userBuilder: this.userBuilder
-      })
-    );
-    router.use(`/${agentCardPath}`, agentCardHandler({ agentCardProvider: this.requestHandler }));
-    app.use(baseUrl, router);
-    return app;
+  toServiceParameter: (value) => {
+    return value.join(",");
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  A2AClient,
-  A2AError,
-  A2AExpressApp,
   AGENT_CARD_PATH,
-  DefaultExecutionEventBus,
-  DefaultExecutionEventBusManager,
-  DefaultRequestHandler,
-  ExecutionEventQueue,
-  InMemoryTaskStore,
-  JsonRpcTransportHandler,
-  RequestContext,
-  ResultManager,
-  createAuthenticatingFetchWithRetry,
-  getCurrentTimestamp,
-  getRequestedExtensions,
-  isArtifactUpdate,
-  isObject,
-  isTaskStatusUpdate
+  Extensions,
+  HTTP_EXTENSION_HEADER
 });