@mailmodo/a2a 0.3.3 → 0.3.7

package/dist/index.js

@@ -1,30 +1,7 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-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));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -37,1644 +14,58 @@ 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);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-var __await = function(promise, isYieldStar) {
-  this[0] = promise;
-  this[1] = isYieldStar;
-};
-var __asyncGenerator = (__this, __arguments, generator) => {
-  var resume = (k, v, yes, no) => {
-    try {
-      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
-      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
-    } catch (e) {
-      no(e);
-    }
-  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
-  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
-};
-var __yieldStar = (value) => {
-  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
-  if (obj == null) {
-    obj = value[__knownSymbol("iterator")]();
-    method = (k) => it[k] = (x) => obj[k](x);
-  } else {
-    obj = obj.call(value);
-    method = (k) => it[k] = (v) => {
-      if (isAwait) {
-        isAwait = false;
-        if (k === "throw") throw v;
-        return v;
-      }
-      isAwait = true;
-      return {
-        done: false,
-        value: new __await(new Promise((resolve) => {
-          var x = obj[k](v);
-          if (!(x instanceof Object)) __typeError("Object expected");
-          resolve(x);
-        }), 1)
-      };
-    };
-  }
-  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
-    throw x;
-  }, "return" in obj && method("return"), it;
-};
-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);
 
 // 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,
-  isArtifactUpdate: () => isArtifactUpdate,
-  isObject: () => isObject,
-  isTaskStatusUpdate: () => isTaskStatusUpdate
+  Extensions: () => Extensions,
+  HTTP_EXTENSION_HEADER: () => HTTP_EXTENSION_HEADER
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/constants.ts
 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 {
-  constructor(userMessage, taskId, contextId, task, referenceTasks) {
-    this.userMessage = userMessage;
-    this.taskId = taskId;
-    this.contextId = contextId;
-    this.task = task;
-    this.referenceTasks = referenceTasks;
-  }
-};
-
-// 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 {
-  constructor() {
-    this.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 {
-  constructor(eventBus) {
-    this.eventQueue = [];
-    this.stopped = false;
-    this.handleEvent = (event) => {
-      if (this.stopped) return;
-      this.eventQueue.push(event);
-      if (this.resolvePromise) {
-        this.resolvePromise();
-        this.resolvePromise = void 0;
-      }
-    };
-    this.handleFinished = () => {
-      this.stop();
-    };
-    this.eventBus = eventBus;
-    this.eventBus.on("event", this.handleEvent);
-    this.eventBus.on("finished", this.handleFinished);
-  }
-  /**
-   * 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.
-   */
-  events() {
-    return __asyncGenerator(this, null, function* () {
-      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) {
-          yield new __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;
-}
-
-// src/server/request_handler/default_request_handler.ts
-var import_uuid = require("uuid");
-
-// src/server/error.ts
-var A2AError = class _A2AError extends Error {
-  // 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 {
-  // 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.
-   */
-  processEvent(event) {
-    return __async(this, null, function* () {
-      var _a, _b, _c;
-      if (event.kind === "message") {
-        this.finalMessageResult = event;
-      } else if (event.kind === "task") {
-        const taskEvent = event;
-        this.currentTask = __spreadValues({}, taskEvent);
-        if (this.latestUserMessage) {
-          if (!((_a = this.currentTask.history) == null ? void 0 : _a.find((msg) => msg.messageId === this.latestUserMessage.messageId))) {
-            this.currentTask.history = [this.latestUserMessage, ...this.currentTask.history || []];
-          }
-        }
-        yield 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 (!((_b = this.currentTask.history) == null ? void 0 : _b.find((msg) => msg.messageId === updateEvent.status.message.messageId))) {
-              this.currentTask.history = [...this.currentTask.history || [], updateEvent.status.message];
-            }
-          }
-          yield this.saveCurrentTask();
-        } else if (!this.currentTask && updateEvent.taskId) {
-          const loaded = yield this.taskStore.load(updateEvent.taskId);
-          if (loaded) {
-            this.currentTask = loaded;
-            this.currentTask.status = updateEvent.status;
-            if (updateEvent.status.message) {
-              if (!((_c = this.currentTask.history) == null ? void 0 : _c.find((msg) => msg.messageId === updateEvent.status.message.messageId))) {
-                this.currentTask.history = [...this.currentTask.history || [], updateEvent.status.message];
-              }
-            }
-            yield 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 = __spreadValues(__spreadValues({}, existingArtifact.metadata), artifactEvent.artifact.metadata);
-            } else {
-              this.currentTask.artifacts[existingArtifactIndex] = artifactEvent.artifact;
-            }
-          } else {
-            this.currentTask.artifacts.push(artifactEvent.artifact);
-          }
-          yield this.saveCurrentTask();
-        } else if (!this.currentTask && artifactEvent.taskId) {
-          const loaded = yield 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);
-            }
-            yield this.saveCurrentTask();
-          } else {
-            console.warn(`ResultManager: Received artifact update for unknown task ${artifactEvent.taskId}`);
-          }
-        }
-      }
-    });
-  }
-  saveCurrentTask() {
-    return __async(this, null, function* () {
-      if (this.currentTask) {
-        yield 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/request_handler/default_request_handler.ts
-var terminalStates = ["completed", "failed", "canceled", "rejected"];
-var DefaultRequestHandler = class {
-  constructor(agentCard, taskStore, agentExecutor, eventBusManager = new DefaultExecutionEventBusManager(), extendedAgentCard) {
-    // Store for push notification configurations (could be part of TaskStore or separate)
-    this.pushNotificationConfigs = /* @__PURE__ */ new Map();
-    this.agentCard = agentCard;
-    this.taskStore = taskStore;
-    this.agentExecutor = agentExecutor;
-    this.eventBusManager = eventBusManager;
-    this.extendedAgentCard = extendedAgentCard;
-  }
-  getAgentCard() {
-    return __async(this, null, function* () {
-      return this.agentCard;
-    });
-  }
-  getAuthenticatedExtendedAgentCard() {
-    return __async(this, null, function* () {
-      if (!this.extendedAgentCard) {
-        throw A2AError.authenticatedExtendedCardNotConfigured();
-      }
-      return this.extendedAgentCard;
-    });
-  }
-  _createRequestContext(incomingMessage, taskId, isStream) {
-    return __async(this, null, function* () {
-      let task;
-      let referenceTasks;
-      if (incomingMessage.taskId) {
-        task = yield 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.`);
-        }
-      }
-      if (incomingMessage.referenceTaskIds && incomingMessage.referenceTaskIds.length > 0) {
-        referenceTasks = [];
-        for (const refId of incomingMessage.referenceTaskIds) {
-          const refTask = yield this.taskStore.load(refId);
-          if (refTask) {
-            referenceTasks.push(refTask);
-          } else {
-            console.warn(`Reference task ${refId} not found.`);
-          }
-        }
-      }
-      const contextId = incomingMessage.contextId || (task == null ? void 0 : task.contextId) || (0, import_uuid.v4)();
-      const messageForContext = __spreadProps(__spreadValues({}, incomingMessage), {
-        contextId
-      });
-      return new RequestContext(
-        messageForContext,
-        taskId,
-        contextId,
-        task,
-        referenceTasks
-      );
-    });
-  }
-  _processEvents(taskId, resultManager, eventQueue, options) {
-    return __async(this, null, function* () {
-      let firstResultSent = false;
-      try {
-        try {
-          for (var iter = __forAwait(eventQueue.events()), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
-            const event = temp.value;
-            yield resultManager.processEvent(event);
-            if ((options == null ? void 0 : options.firstResultResolver) && !firstResultSent) {
-              if (event.kind === "message" || event.kind === "task") {
-                options.firstResultResolver(event);
-                firstResultSent = true;
-              }
-            }
-          }
-        } catch (temp) {
-          error = [temp];
-        } finally {
-          try {
-            more && (temp = iter.return) && (yield temp.call(iter));
-          } finally {
-            if (error)
-              throw error[0];
-          }
-        }
-        if ((options == null ? void 0 : options.firstResultRejector) && !firstResultSent) {
-          options.firstResultRejector(A2AError.internalError("Execution finished before a message or task was produced."));
-        }
-      } catch (error2) {
-        console.error(`Event processing loop failed for task ${taskId}:`, error2);
-        if ((options == null ? void 0 : options.firstResultRejector) && !firstResultSent) {
-          options.firstResultRejector(error2);
-        }
-        throw error2;
-      } finally {
-        this.eventBusManager.cleanupByTaskId(taskId);
-      }
-    });
-  }
-  sendMessage(params) {
-    return __async(this, null, function* () {
-      var _a;
-      const incomingMessage = params.message;
-      if (!incomingMessage.messageId) {
-        throw A2AError.invalidParams("message.messageId is required.");
-      }
-      const isBlocking = ((_a = params.configuration) == null ? void 0 : _a.blocking) !== false;
-      const taskId = incomingMessage.taskId || (0, import_uuid.v4)();
-      const resultManager = new ResultManager(this.taskStore);
-      resultManager.setContext(incomingMessage);
-      const requestContext = yield this._createRequestContext(incomingMessage, taskId, false);
-      const finalMessageForAgent = requestContext.userMessage;
-      const eventBus = this.eventBusManager.createOrGetByTaskId(taskId);
-      const eventQueue = new ExecutionEventQueue(eventBus);
-      this.agentExecutor.execute(requestContext, eventBus).catch((err) => {
-        var _a2, _b, _c, _d, _e;
-        console.error(`Agent execution failed for message ${finalMessageForAgent.messageId}:`, err);
-        const errorTask = {
-          id: ((_a2 = requestContext.task) == null ? void 0 : _a2.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: (_b = requestContext.task) == null ? void 0 : _b.id,
-              contextId: finalMessageForAgent.contextId
-            },
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          },
-          history: ((_c = requestContext.task) == null ? void 0 : _c.history) ? [...requestContext.task.history] : [],
-          kind: "task"
-        };
-        if (finalMessageForAgent) {
-          if (!((_d = errorTask.history) == null ? void 0 : _d.find((m) => m.messageId === finalMessageForAgent.messageId))) {
-            (_e = errorTask.history) == null ? void 0 : _e.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) {
-        yield 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
-          });
-        });
-      }
-    });
-  }
-  sendMessageStream(params) {
-    return __asyncGenerator(this, null, function* () {
-      const incomingMessage = params.message;
-      if (!incomingMessage.messageId) {
-        throw A2AError.invalidParams("message.messageId is required for streaming.");
-      }
-      const taskId = incomingMessage.taskId || (0, import_uuid.v4)();
-      const resultManager = new ResultManager(this.taskStore);
-      resultManager.setContext(incomingMessage);
-      const requestContext = yield new __await(this._createRequestContext(incomingMessage, taskId, true));
-      const finalMessageForAgent = requestContext.userMessage;
-      const eventBus = this.eventBusManager.createOrGetByTaskId(taskId);
-      const eventQueue = new ExecutionEventQueue(eventBus);
-      this.agentExecutor.execute(requestContext, eventBus).catch((err) => {
-        var _a, _b;
-        console.error(`Agent execution failed for stream message ${finalMessageForAgent.messageId}:`, err);
-        const errorTaskStatus = {
-          kind: "status-update",
-          taskId: ((_a = requestContext.task) == null ? void 0 : _a.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: (_b = requestContext.task) == null ? void 0 : _b.id,
-              contextId: finalMessageForAgent.contextId
-            },
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          },
-          final: true
-          // This will terminate the stream for the client
-        };
-        eventBus.publish(errorTaskStatus);
-      });
-      try {
-        try {
-          for (var iter = __forAwait(eventQueue.events()), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-            const event = temp.value;
-            yield new __await(resultManager.processEvent(event));
-            yield event;
-          }
-        } catch (temp) {
-          error = [temp];
-        } finally {
-          try {
-            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-          } finally {
-            if (error)
-              throw error[0];
-          }
-        }
-      } finally {
-        this.eventBusManager.cleanupByTaskId(taskId);
-      }
-    });
-  }
-  getTask(params) {
-    return __async(this, null, function* () {
-      const task = yield 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;
-    });
-  }
-  cancelTask(params) {
-    return __async(this, null, function* () {
-      const task = yield 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) {
-        yield this.agentExecutor.cancelTask(params.id, eventBus);
-      } 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];
-        yield this.taskStore.save(task);
-      }
-      const latestTask = yield this.taskStore.load(params.id);
-      return latestTask;
-    });
-  }
-  setTaskPushNotificationConfig(params) {
-    return __async(this, null, function* () {
-      if (!this.agentCard.capabilities.pushNotifications) {
-        throw A2AError.pushNotificationNotSupported();
-      }
-      const task = yield this.taskStore.load(params.taskId);
-      if (!task) {
-        throw A2AError.taskNotFound(params.taskId);
-      }
-      const { taskId, pushNotificationConfig } = params;
-      if (!pushNotificationConfig.id) {
-        pushNotificationConfig.id = taskId;
-      }
-      const configs = this.pushNotificationConfigs.get(taskId) || [];
-      const updatedConfigs = configs.filter((c) => c.id !== pushNotificationConfig.id);
-      updatedConfigs.push(pushNotificationConfig);
-      this.pushNotificationConfigs.set(taskId, updatedConfigs);
-      return params;
-    });
-  }
-  getTaskPushNotificationConfig(params) {
-    return __async(this, null, function* () {
-      if (!this.agentCard.capabilities.pushNotifications) {
-        throw A2AError.pushNotificationNotSupported();
-      }
-      const task = yield this.taskStore.load(params.id);
-      if (!task) {
-        throw A2AError.taskNotFound(params.id);
-      }
-      const configs = this.pushNotificationConfigs.get(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 };
-    });
-  }
-  listTaskPushNotificationConfigs(params) {
-    return __async(this, null, function* () {
-      if (!this.agentCard.capabilities.pushNotifications) {
-        throw A2AError.pushNotificationNotSupported();
-      }
-      const task = yield this.taskStore.load(params.id);
-      if (!task) {
-        throw A2AError.taskNotFound(params.id);
-      }
-      const configs = this.pushNotificationConfigs.get(params.id) || [];
-      return configs.map((config) => ({
-        taskId: params.id,
-        pushNotificationConfig: config
-      }));
-    });
-  }
-  deleteTaskPushNotificationConfig(params) {
-    return __async(this, null, function* () {
-      if (!this.agentCard.capabilities.pushNotifications) {
-        throw A2AError.pushNotificationNotSupported();
-      }
-      const task = yield this.taskStore.load(params.id);
-      if (!task) {
-        throw A2AError.taskNotFound(params.id);
-      }
-      const { id: taskId, pushNotificationConfigId } = params;
-      const configs = this.pushNotificationConfigs.get(taskId);
-      if (!configs) {
-        return;
-      }
-      const updatedConfigs = configs.filter((c) => c.id !== pushNotificationConfigId);
-      if (updatedConfigs.length === 0) {
-        this.pushNotificationConfigs.delete(taskId);
-      } else if (updatedConfigs.length < configs.length) {
-        this.pushNotificationConfigs.set(taskId, updatedConfigs);
-      }
-    });
-  }
-  resubscribe(params) {
-    return __asyncGenerator(this, null, function* () {
-      if (!this.agentCard.capabilities.streaming) {
-        throw A2AError.unsupportedOperation("Streaming (and thus resubscription) is not supported.");
-      }
-      const task = yield new __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 {
-        try {
-          for (var iter = __forAwait(eventQueue.events()), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-            const event = temp.value;
-            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;
-            }
-          }
-        } catch (temp) {
-          error = [temp];
-        } finally {
-          try {
-            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-          } finally {
-            if (error)
-              throw error[0];
-          }
-        }
-      } finally {
-        eventQueue.stop();
-      }
-    });
-  }
-};
-
-// src/server/store.ts
-var InMemoryTaskStore = class {
-  constructor() {
-    this.store = /* @__PURE__ */ new Map();
-  }
-  load(taskId) {
-    return __async(this, null, function* () {
-      const entry = this.store.get(taskId);
-      return entry ? __spreadValues({}, entry) : void 0;
-    });
-  }
-  save(task) {
-    return __async(this, null, function* () {
-      this.store.set(task.id, __spreadValues({}, task));
-    });
-  }
-};
-
-// src/server/transports/jsonrpc_transport_handler.ts
-var JsonRpcTransportHandler = class {
-  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).
-   */
-  handle(requestBody) {
-    return __async(this, null, function* () {
-      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 (rpcRequest.jsonrpc !== "2.0" || !rpcRequest.method || typeof rpcRequest.method !== "string") {
-          throw A2AError.invalidRequest(
-            "Invalid JSON-RPC request structure."
-          );
-        }
-      } catch (error) {
-        const a2aError = error instanceof A2AError ? error : A2AError.parseError(error.message || "Failed to parse JSON request.");
-        return {
-          jsonrpc: "2.0",
-          id: typeof (rpcRequest == null ? void 0 : rpcRequest.id) !== "undefined" ? rpcRequest.id : null,
-          error: a2aError.toJSONRPCError()
-        };
-      }
-      const { method, id: requestId = null } = rpcRequest;
-      try {
-        if (method === "agent/getAuthenticatedExtendedCard") {
-          const result = yield this.requestHandler.getAuthenticatedExtendedAgentCard();
-          return {
-            jsonrpc: "2.0",
-            id: requestId,
-            result
-          };
-        }
-        if (!rpcRequest.params) {
-          throw A2AError.invalidParams(`'params' is required for '${method}'`);
-        }
-        if (method === "message/stream" || method === "tasks/resubscribe") {
-          const params = rpcRequest.params;
-          const agentCard = yield this.requestHandler.getAgentCard();
-          if (!agentCard.capabilities.streaming) {
-            throw A2AError.unsupportedOperation(`Method ${method} requires streaming capability.`);
-          }
-          const agentEventStream = method === "message/stream" ? this.requestHandler.sendMessageStream(params) : this.requestHandler.resubscribe(params);
-          return function jsonRpcEventStream() {
-            return __asyncGenerator(this, null, function* () {
-              try {
-                try {
-                  for (var iter = __forAwait(agentEventStream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
-                    const event = temp.value;
-                    yield {
-                      jsonrpc: "2.0",
-                      id: requestId,
-                      // Use the original request ID for all streamed responses
-                      result: event
-                    };
-                  }
-                } catch (temp) {
-                  error = [temp];
-                } finally {
-                  try {
-                    more && (temp = iter.return) && (yield new __await(temp.call(iter)));
-                  } finally {
-                    if (error)
-                      throw error[0];
-                  }
-                }
-              } 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 = yield this.requestHandler.sendMessage(rpcRequest.params);
-              break;
-            case "tasks/get":
-              result = yield this.requestHandler.getTask(rpcRequest.params);
-              break;
-            case "tasks/cancel":
-              result = yield this.requestHandler.cancelTask(rpcRequest.params);
-              break;
-            case "tasks/pushNotificationConfig/set":
-              result = yield this.requestHandler.setTaskPushNotificationConfig(
-                rpcRequest.params
-              );
-              break;
-            case "tasks/pushNotificationConfig/get":
-              result = yield this.requestHandler.getTaskPushNotificationConfig(
-                rpcRequest.params
-              );
-              break;
-            case "tasks/pushNotificationConfig/delete":
-              yield this.requestHandler.deleteTaskPushNotificationConfig(
-                rpcRequest.params
-              );
-              result = null;
-              break;
-            case "tasks/pushNotificationConfig/list":
-              result = yield this.requestHandler.listTaskPushNotificationConfigs(
-                rpcRequest.params
-              );
-              break;
-            default:
-              throw A2AError.methodNotFound(method);
-          }
-          return {
-            jsonrpc: "2.0",
-            id: requestId,
-            result
-          };
-        }
-      } catch (error) {
-        const a2aError = error instanceof A2AError ? error : A2AError.internalError(error.message || "An unexpected error occurred.");
-        return {
-          jsonrpc: "2.0",
-          id: requestId,
-          error: a2aError.toJSONRPCError()
-        };
-      }
-    });
-  }
-};
-
-// src/client/client.ts
-var A2AClient = class _A2AClient {
+// src/extensions.ts
+var Extensions = {
   /**
-   * 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.
+   * Creates new {@link Extensions} from `current` and `additional`.
+   * If `current` already contains `additional` it is returned unmodified.
    */
-  constructor(agentCard, options) {
-    this.requestIdCounter = 1;
-    this.customFetchImpl = options == null ? void 0 : 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 == null ? void 0 : 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);
+  createFrom: (current, additional) => {
+    if (current?.includes(additional)) {
+      return current;
     }
-  }
+    return [...current ?? [], additional];
+  },
   /**
-   * 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.
+   * Creates {@link Extensions} from comma separated extensions identifiers as per
+   * https://a2a-protocol.org/latest/specification/#326-service-parameters.
+   * Parses the output of `toServiceParameter`.
    */
-  _fetch(...args) {
-    if (this.customFetchImpl) {
-      return this.customFetchImpl(...args);
-    }
-    if (typeof fetch === "function") {
-      return fetch(...args);
+  parseServiceParameter: (value) => {
+    if (!value) {
+      return [];
     }
-    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`."
+    const unique = new Set(
+      value.split(",").map((ext) => ext.trim()).filter((ext) => ext.length > 0)
     );
-  }
-  /**
-   * 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 fromCardUrl(agentCardUrl, options) {
-    return __async(this, null, function* () {
-      const fetchImpl = options == null ? void 0 : options.fetchImpl;
-      const requestInit = {
-        headers: { "Accept": "application/json" }
-      };
-      let response;
-      if (fetchImpl) {
-        response = yield fetchImpl(agentCardUrl, requestInit);
-      } else if (typeof fetch === "function") {
-        response = yield 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 = yield 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);
-    });
-  }
-  /**
-   * Helper method to make a generic JSON-RPC POST request.
-   * @param method The RPC method name.
-   * @param params The parameters for the RPC method.
-   * @returns A Promise that resolves to the RPC response.
-   */
-  _postRpcRequest(method, params) {
-    return __async(this, null, function* () {
-      const endpoint = yield this._getServiceEndpoint();
-      const requestId = this.requestIdCounter++;
-      const rpcRequest = {
-        jsonrpc: "2.0",
-        method,
-        params,
-        // Cast because TParams structure varies per method
-        id: requestId
-      };
-      const httpResponse = yield this._fetchRpc(endpoint, rpcRequest);
-      if (!httpResponse.ok) {
-        let errorBodyText = "(empty or non-JSON response)";
-        try {
-          errorBodyText = yield httpResponse.text();
-          const errorJson = JSON.parse(errorBodyText);
-          if (errorJson.jsonrpc && errorJson.error) {
-            return errorJson;
-          } else if (!errorJson.jsonrpc && errorJson.error) {
-            throw new Error(`RPC error for ${method}: ${errorJson.error.message} (Code: ${errorJson.error.code}, HTTP Status: ${httpResponse.status}) Data: ${JSON.stringify(errorJson.error.data || {})}`);
-          } else if (!errorJson.jsonrpc) {
-            throw new Error(`HTTP error for ${method}! Status: ${httpResponse.status} ${httpResponse.statusText}. Response: ${errorBodyText}`);
-          }
-        } catch (e) {
-          if (e.message.startsWith("RPC error for") || e.message.startsWith("HTTP error for")) throw e;
-          throw new Error(`HTTP error for ${method}! Status: ${httpResponse.status} ${httpResponse.statusText}. Response: ${errorBodyText}`);
-        }
-      }
-      const rpcResponse = yield httpResponse.json();
-      if (rpcResponse.id !== requestId) {
-        console.error(`CRITICAL: RPC response ID mismatch for method ${method}. Expected ${requestId}, got ${rpcResponse.id}. This may lead to incorrect response handling.`);
-      }
-      return rpcResponse;
-    });
-  }
-  /**
-   * Internal helper method to fetch the RPC service endpoint.
-   * @param url The URL to fetch.
-   * @param rpcRequest The JSON-RPC request to send.
-   * @param acceptHeader The Accept header to use.  Defaults to "application/json".
-   * @returns A Promise that resolves to the fetch HTTP response.
-   */
-  _fetchRpc(url, rpcRequest, acceptHeader = "application/json") {
-    return __async(this, null, function* () {
-      const requestInit = {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Accept": acceptHeader
-          // Expect JSON response for non-streaming requests
-        },
-        body: JSON.stringify(rpcRequest)
-      };
-      return this._fetch(url, requestInit);
-    });
-  }
-  /**
-   * 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.
-   */
-  sendMessage(params) {
-    return __async(this, null, function* () {
-      return this._postRpcRequest("message/send", params);
-    });
-  }
-  /**
-   * 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.
-   */
-  sendMessageStream(params) {
-    return __asyncGenerator(this, null, function* () {
-      var _a, _b;
-      const agentCard = yield new __await(this.agentCardPromise);
-      if (!((_a = agentCard.capabilities) == null ? void 0 : _a.streaming)) {
-        throw new Error("Agent does not support streaming (AgentCard.capabilities.streaming is not true).");
-      }
-      const endpoint = yield new __await(this._getServiceEndpoint());
-      const clientRequestId = this.requestIdCounter++;
-      const rpcRequest = {
-        // This is the initial JSON-RPC request to establish the stream
-        jsonrpc: "2.0",
-        method: "message/stream",
-        params,
-        id: clientRequestId
-      };
-      const response = yield new __await(this._fetchRpc(endpoint, rpcRequest, "text/event-stream"));
-      if (!response.ok) {
-        let errorBody = "";
-        try {
-          errorBody = yield new __await(response.text());
-          const errorJson = JSON.parse(errorBody);
-          if (errorJson.error) {
-            throw new Error(`HTTP error establishing stream for message/stream: ${response.status} ${response.statusText}. RPC Error: ${errorJson.error.message} (Code: ${errorJson.error.code})`);
-          }
-        } catch (e) {
-          if (e.message.startsWith("HTTP error establishing stream")) throw e;
-          throw new Error(`HTTP error establishing stream for message/stream: ${response.status} ${response.statusText}. Response: ${errorBody || "(empty)"}`);
-        }
-        throw new Error(`HTTP error establishing stream for message/stream: ${response.status} ${response.statusText}`);
-      }
-      if (!((_b = response.headers.get("Content-Type")) == null ? void 0 : _b.startsWith("text/event-stream"))) {
-        throw new Error("Invalid response Content-Type for SSE stream. Expected 'text/event-stream'.");
-      }
-      yield* __yieldStar(this._parseA2ASseStream(response, clientRequestId));
-    });
-  }
+    return Array.from(unique);
+  },
   /**
-   * 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.
+   * Converts {@link Extensions} to comma separated extensions identifiers as per
+   * https://a2a-protocol.org/latest/specification/#326-service-parameters.
    */
-  setTaskPushNotificationConfig(params) {
-    return __async(this, null, function* () {
-      var _a;
-      const agentCard = yield this.agentCardPromise;
-      if (!((_a = agentCard.capabilities) == null ? void 0 : _a.pushNotifications)) {
-        throw new Error("Agent does not support push notifications (AgentCard.capabilities.pushNotifications is not true).");
-      }
-      return this._postRpcRequest(
-        "tasks/pushNotificationConfig/set",
-        params
-      );
-    });
-  }
-  /**
-   * Gets the push notification configuration for a given task.
-   * @param params Parameters containing the taskId.
-   * @returns A Promise resolving to GetTaskPushNotificationConfigResponse.
-   */
-  getTaskPushNotificationConfig(params) {
-    return __async(this, null, function* () {
-      return this._postRpcRequest(
-        "tasks/pushNotificationConfig/get",
-        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.
-   */
-  getTask(params) {
-    return __async(this, null, function* () {
-      return this._postRpcRequest("tasks/get", 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.
-   */
-  cancelTask(params) {
-    return __async(this, null, function* () {
-      return this._postRpcRequest("tasks/cancel", params);
-    });
-  }
-  /**
-   * 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).
-   */
-  resubscribeTask(params) {
-    return __asyncGenerator(this, null, function* () {
-      var _a, _b;
-      const agentCard = yield new __await(this.agentCardPromise);
-      if (!((_a = agentCard.capabilities) == null ? void 0 : _a.streaming)) {
-        throw new Error("Agent does not support streaming (required for tasks/resubscribe).");
-      }
-      const endpoint = yield new __await(this._getServiceEndpoint());
-      const clientRequestId = this.requestIdCounter++;
-      const rpcRequest = {
-        // Initial JSON-RPC request to establish the stream
-        jsonrpc: "2.0",
-        method: "tasks/resubscribe",
-        params,
-        id: clientRequestId
-      };
-      const response = yield new __await(this._fetch(endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Accept": "text/event-stream"
-        },
-        body: JSON.stringify(rpcRequest)
-      }));
-      if (!response.ok) {
-        let errorBody = "";
-        try {
-          errorBody = yield new __await(response.text());
-          const errorJson = JSON.parse(errorBody);
-          if (errorJson.error) {
-            throw new Error(`HTTP error establishing stream for tasks/resubscribe: ${response.status} ${response.statusText}. RPC Error: ${errorJson.error.message} (Code: ${errorJson.error.code})`);
-          }
-        } catch (e) {
-          if (e.message.startsWith("HTTP error establishing stream")) throw e;
-          throw new Error(`HTTP error establishing stream for tasks/resubscribe: ${response.status} ${response.statusText}. Response: ${errorBody || "(empty)"}`);
-        }
-        throw new Error(`HTTP error establishing stream for tasks/resubscribe: ${response.status} ${response.statusText}`);
-      }
-      if (!((_b = response.headers.get("Content-Type")) == null ? void 0 : _b.startsWith("text/event-stream"))) {
-        throw new Error("Invalid response Content-Type for SSE stream on resubscribe. Expected 'text/event-stream'.");
-      }
-      yield* __yieldStar(this._parseA2ASseStream(response, clientRequestId));
-    });
-  }
-  /**
-   * Parses an HTTP response body as an A2A Server-Sent Event stream.
-   * Each 'data' field of an SSE event is expected to be a JSON-RPC 2.0 Response object,
-   * specifically a SendStreamingMessageResponse (or similar structure for resubscribe).
-   * @param response The HTTP Response object whose body is the SSE stream.
-   * @param originalRequestId The ID of the client's JSON-RPC request that initiated this stream.
-   * Used to validate the `id` in the streamed JSON-RPC responses.
-   * @returns An AsyncGenerator yielding the `result` field of each valid JSON-RPC success response from the stream.
-   */
-  _parseA2ASseStream(response, originalRequestId) {
-    return __asyncGenerator(this, null, function* () {
-      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 } = yield new __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";
-            } else if (line.startsWith(":")) {
-            } else if (line.includes(":")) {
-            }
-          }
-        }
-      } catch (error) {
-        console.error("Error reading or parsing SSE stream:", error.message);
-        throw error;
-      } finally {
-        reader.releaseLock();
-      }
-    });
-  }
-  /**
-   * Processes a single SSE event's data string, expecting it to be a JSON-RPC response.
-   * @param jsonData The string content from one or more 'data:' lines of an SSE event.
-   * @param originalRequestId The ID of the client's request that initiated the stream.
-   * @returns The `result` field of the parsed JSON-RPC success response.
-   * @throws Error if data is not valid JSON, not a valid JSON-RPC response, an error response, or ID mismatch.
-   */
-  _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 (this.isErrorResponse(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}`);
-      }
-      const successResponse = a2aStreamResponse;
-      return successResponse.result;
-    } catch (e) {
-      if (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.message}`);
-    }
-  }
-  isErrorResponse(response) {
-    return "error" in response;
-  }
-  ////////////////////////////////////////////////////////////////////////////////
-  // 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
-  ////////////////////////////////////////////////////////////////////////////////
-  /**
-   * 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.
-   */
-  _fetchAndCacheAgentCard(agentBaseUrl, agentCardPath) {
-    return __async(this, null, function* () {
-      try {
-        const agentCardUrl = this.resolveAgentCardUrl(agentBaseUrl, agentCardPath);
-        const response = yield 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 = yield 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.
-  */
-  getAgentCard(agentBaseUrl, agentCardPath) {
-    return __async(this, null, function* () {
-      if (agentBaseUrl) {
-        const agentCardUrl = this.resolveAgentCardUrl(agentBaseUrl, agentCardPath);
-        const response = yield 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 yield 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.
-   */
-  _getServiceEndpoint() {
-    return __async(this, null, function* () {
-      if (this.serviceEndpointUrl) {
-        return this.serviceEndpointUrl;
-      }
-      yield this.agentCardPromise;
-      if (!this.serviceEndpointUrl) {
-        throw new Error("Agent Card URL for RPC endpoint is not available. Fetching might have failed.");
-      }
-      return this.serviceEndpointUrl;
-    });
-  }
-};
-
-// src/client/auth-handler.ts
-function createAuthenticatingFetchWithRetry(fetchImpl, authHandler) {
-  function authFetch(url, init) {
-    return __async(this, null, function* () {
-      const authHeaders = (yield authHandler.headers()) || {};
-      const mergedInit = __spreadProps(__spreadValues({}, init || {}), {
-        headers: __spreadValues(__spreadValues({}, authHeaders), (init == null ? void 0 : init.headers) || {})
-      });
-      let response = yield fetchImpl(url, mergedInit);
-      const updatedHeaders = yield authHandler.shouldRetryWithHeaders(mergedInit, response);
-      if (updatedHeaders) {
-        const retryInit = __spreadProps(__spreadValues({}, init || {}), {
-          headers: __spreadValues(__spreadValues({}, updatedHeaders), (init == null ? void 0 : init.headers) || {})
-        });
-        response = yield fetchImpl(url, retryInit);
-        if (response.ok && authHandler.onSuccessfulRetry) {
-          yield 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_express = __toESM(require("express"));
-var A2AExpressApp = class {
-  constructor(requestHandler) {
-    this.requestHandler = requestHandler;
-    this.jsonRpcTransportHandler = new JsonRpcTransportHandler(requestHandler);
-  }
-  /**
-   * 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_express.default.Router();
-    router.use(import_express.default.json(), ...middlewares != null ? middlewares : []);
-    router.get(`/${agentCardPath}`, (req, res) => __async(this, null, function* () {
-      try {
-        const agentCard = yield this.requestHandler.getAgentCard();
-        res.json(agentCard);
-      } catch (error) {
-        console.error("Error fetching agent card:", error);
-        res.status(500).json({ error: "Failed to retrieve agent card" });
-      }
-    }));
-    router.post("/", (req, res) => __async(this, null, function* () {
-      var _a, _b, _c;
-      try {
-        const rpcResponseOrStream = yield this.jsonRpcTransportHandler.handle(req.body);
-        if (typeof (rpcResponseOrStream == null ? void 0 : 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 {
-            try {
-              for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
-                const event = temp.value;
-                res.write(`id: ${(/* @__PURE__ */ new Date()).getTime()}
-`);
-                res.write(`data: ${JSON.stringify(event)}
-
-`);
-              }
-            } catch (temp) {
-              error = [temp];
-            } finally {
-              try {
-                more && (temp = iter.return) && (yield temp.call(iter));
-              } finally {
-                if (error)
-                  throw error[0];
-              }
-            }
-          } catch (streamError) {
-            console.error(`Error during SSE streaming (request ${(_a = req.body) == null ? void 0 : _a.id}):`, streamError);
-            const a2aError = streamError instanceof A2AError ? streamError : A2AError.internalError(streamError.message || "Streaming error.");
-            const errorResponse = {
-              jsonrpc: "2.0",
-              id: ((_b = req.body) == null ? void 0 : _b.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 (error2) {
-        console.error("Unhandled error in A2AExpressApp POST handler:", error2);
-        const a2aError = error2 instanceof A2AError ? error2 : A2AError.internalError("General processing error.");
-        const errorResponse = {
-          jsonrpc: "2.0",
-          id: ((_c = req.body) == null ? void 0 : _c.id) || null,
-          error: a2aError.toJSONRPCError()
-        };
-        if (!res.headersSent) {
-          res.status(500).json(errorResponse);
-        } else if (!res.writableEnded) {
-          res.end();
-        }
-      }
-    }));
-    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,
-  isArtifactUpdate,
-  isObject,
-  isTaskStatusUpdate
+  Extensions,
+  HTTP_EXTENSION_HEADER
 });