@mailmodo/a2a 0.3.3 → 0.3.5

package/dist/index.js

@@ -1,30 +1,9 @@
 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 });
@@ -46,70 +25,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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 = {};
@@ -128,6 +43,7 @@ __export(index_exports, {
   ResultManager: () => ResultManager,
   createAuthenticatingFetchWithRetry: () => createAuthenticatingFetchWithRetry,
   getCurrentTimestamp: () => getCurrentTimestamp,
+  getRequestedExtensions: () => getRequestedExtensions,
   isArtifactUpdate: () => isArtifactUpdate,
   isObject: () => isObject,
   isTaskStatusUpdate: () => isTaskStatusUpdate
@@ -136,15 +52,23 @@ 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) {
+  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;
   }
 };
 
@@ -164,9 +88,7 @@ var DefaultExecutionEventBus = class extends import_events.EventEmitter {
 
 // src/server/events/execution_event_bus_manager.ts
 var DefaultExecutionEventBusManager = class {
-  constructor() {
-    this.taskIdToBus = /* @__PURE__ */ new Map();
-  }
+  taskIdToBus = /* @__PURE__ */ new Map();
   /**
    * Creates or retrieves an existing ExecutionEventBus based on the taskId.
    * @param taskId The ID of the task.
@@ -202,45 +124,46 @@ var DefaultExecutionEventBusManager = class {
 
 // src/server/events/execution_event_queue.ts
 var ExecutionEventQueue = class {
+  eventBus;
+  eventQueue = [];
+  resolvePromise;
+  stopped = false;
+  boundHandleEvent;
   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);
   }
+  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.
    */
-  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;
-          }));
+  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.
@@ -269,12 +192,23 @@ function isTaskStatusUpdate(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);
@@ -304,10 +238,7 @@ var A2AError = class _A2AError extends Error {
     return new _A2AError(-32600, message, data);
   }
   static methodNotFound(method) {
-    return new _A2AError(
-      -32601,
-      `Method not found: ${method}`
-    );
+    return new _A2AError(-32601, `Method not found: ${method}`);
   }
   static invalidParams(message, data) {
     return new _A2AError(-32602, message, data);
@@ -316,43 +247,29 @@ var A2AError = class _A2AError extends Error {
     return new _A2AError(-32603, message, data);
   }
   static taskNotFound(taskId) {
-    return new _A2AError(
-      -32001,
-      `Task not found: ${taskId}`,
-      void 0,
-      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
-    );
+    return new _A2AError(-32002, `Task not cancelable: ${taskId}`, void 0, taskId);
   }
   static pushNotificationNotSupported() {
-    return new _A2AError(
-      -32003,
-      "Push Notification is not supported"
-    );
+    return new _A2AError(-32003, "Push Notification is not supported");
   }
   static unsupportedOperation(operation) {
-    return new _A2AError(
-      -32004,
-      `Unsupported operation: ${operation}`
-    );
+    return new _A2AError(-32004, `Unsupported operation: ${operation}`);
   }
   static authenticatedExtendedCardNotConfigured() {
-    return new _A2AError(
-      -32007,
-      `Extended card not configured.`
-    );
+    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;
@@ -364,99 +281,117 @@ var ResultManager = class {
    * 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 || []];
+  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
+            ];
           }
         }
-        yield this.saveCurrentTask();
-      } else if (event.kind === "status-update") {
-        const updateEvent = event;
-        if (this.currentTask && this.currentTask.id === updateEvent.taskId) {
+        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 (!((_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];
+            if (!this.currentTask.history?.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();
+          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 {
-            console.warn(`ResultManager: Received status update for unknown task ${updateEvent.taskId}`);
+            this.currentTask.artifacts[existingArtifactIndex] = artifactEvent.artifact;
           }
+        } else {
+          this.currentTask.artifacts.push(artifactEvent.artifact);
         }
-      } else if (event.kind === "artifact-update") {
-        const artifactEvent = event;
-        if (this.currentTask && this.currentTask.id === artifactEvent.taskId) {
-          if (!this.currentTask.artifacts) {
-            this.currentTask.artifacts = [];
-          }
+        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) {
-              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);
+              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 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}`);
-          }
+          await 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);
-      }
-    });
+  async saveCurrentTask() {
+    if (this.currentTask) {
+      await this.taskStore.save(this.currentTask);
+    }
   }
   /**
    * Gets the final result, which could be a Message or a Task.
@@ -479,440 +414,623 @@ var ResultManager = class {
   }
 };
 
+// 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 {
-  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();
+  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.extendedAgentCard = extendedAgentCard;
+    this.extendedAgentCardProvider = extendedAgentCardProvider;
+    if (agentCard.capabilities.pushNotifications) {
+      this.pushNotificationStore = pushNotificationStore || new InMemoryPushNotificationStore();
+      this.pushNotificationSender = pushNotificationSender || new DefaultPushNotificationSender(this.pushNotificationStore);
+    }
   }
-  getAgentCard() {
-    return __async(this, null, function* () {
-      return this.agentCard;
-    });
+  async getAgentCard() {
+    return this.agentCard;
   }
-  getAuthenticatedExtendedAgentCard() {
-    return __async(this, null, function* () {
-      if (!this.extendedAgentCard) {
-        throw A2AError.authenticatedExtendedCardNotConfigured();
-      }
-      return this.extendedAgentCard;
-    });
+  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;
   }
-  _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.`);
-        }
+  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 (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.`);
-          }
+      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 == null ? void 0 : task.contextId) || (0, import_uuid.v4)();
-      const messageForContext = __spreadProps(__spreadValues({}, incomingMessage), {
-        contextId
-      });
-      return new RequestContext(
-        messageForContext,
-        taskId,
-        contextId,
-        task,
-        referenceTasks
+    }
+    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);
   }
-  _processEvents(taskId, resultManager, eventQueue, options) {
-    return __async(this, null, function* () {
-      let firstResultSent = false;
-      try {
+  async _processEvents(taskId, resultManager, eventQueue, options) {
+    let firstResultSent = false;
+    try {
+      for await (const event of eventQueue.events()) {
+        await resultManager.processEvent(event);
         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;
-              }
-            }
+          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();
           }
-        } catch (temp) {
-          error = [temp];
-        } finally {
-          try {
-            more && (temp = iter.return) && (yield temp.call(iter));
-          } finally {
-            if (error)
-              throw error[0];
+          if (firstResult) {
+            options.firstResultResolver(firstResult);
+            firstResultSent = true;
           }
         }
-        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
-          });
-        });
+      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);
+    }
   }
-  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()
+  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
           },
-          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];
-          }
+          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);
         }
-      } finally {
-        this.eventBusManager.cleanupByTaskId(taskId);
       }
+      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();
     });
-  }
-  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 = [];
+    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 task;
-    });
+      return finalResult;
+    } else {
+      return new Promise((resolve, reject) => {
+        this._processEvents(taskId, resultManager, eventQueue, {
+          firstResultResolver: resolve,
+          firstResultRejector: reject
+        });
+      });
+    }
   }
-  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",
+  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: {
-            // 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
+            parts: [{ kind: "text", text: `Agent execution error: ${err.message}` }],
+            taskId: requestContext.task?.id,
+            contextId: finalMessageForAgent.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;
+        },
+        final: true
+        // This will terminate the stream for the client
+      };
+      eventBus.publish(errorTaskStatus);
     });
-  }
-  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;
+    try {
+      for await (const event of eventQueue.events()) {
+        await resultManager.processEvent(event);
+        await this._sendPushNotificationIfNeeded(event);
+        yield event;
       }
-      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;
-    });
+    } finally {
+      this.eventBusManager.cleanupByTaskId(taskId);
+    }
   }
-  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}.`);
+  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);
       }
-      return { taskId: params.id, pushNotificationConfig: config };
-    });
+    } else {
+      task.history = [];
+    }
+    return task;
   }
-  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
-      }));
-    });
+  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;
   }
-  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);
-      }
-    });
+  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;
   }
-  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];
-          }
+  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();
       }
-    });
+    } 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 {
-  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;
-    });
+  store = /* @__PURE__ */ new Map();
+  async load(taskId) {
+    const entry = this.store.get(taskId);
+    return entry ? { ...entry } : void 0;
   }
-  save(task) {
-    return __async(this, null, function* () {
-      this.store.set(task.id, __spreadValues({}, task));
-    });
+  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;
   }
@@ -921,156 +1039,556 @@ var JsonRpcTransportHandler = class {
    * 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.");
+  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.`);
         }
-        if (rpcRequest.jsonrpc !== "2.0" || !rpcRequest.method || typeof rpcRequest.method !== "string") {
-          throw A2AError.invalidRequest(
-            "Invalid JSON-RPC request structure."
-          );
+        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);
         }
-      } 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()
+          id: requestId,
+          result
         };
       }
-      const { method, id: requestId = null } = rpcRequest;
+    } 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 {
-        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.`);
+        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;
           }
-          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;
+        }
+        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
               );
-              break;
-            default:
-              throw A2AError.methodNotFound(method);
+              yield result;
+              eventDataBuffer = "";
+            }
+          } else if (line.startsWith("data:")) {
+            eventDataBuffer += line.substring(5).trimStart() + "\n";
           }
-          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()
-        };
       }
-    });
+    } 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.requestIdCounter = 1;
-    this.customFetchImpl = options == null ? void 0 : options.fetchImpl;
+    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 == null ? void 0 : options.agentCardPath);
+      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.");
+        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. 
+   * 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.
@@ -1093,97 +1611,36 @@ var A2AClient = class _A2AClient {
    * @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);
-    });
+  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.
@@ -1193,10 +1650,11 @@ var A2AClient = class _A2AClient {
    * @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);
-    });
+  async sendMessage(params) {
+    return await this.invokeJsonRpc(
+      (t, p, id) => t.sendMessage(p, _A2AClient.emptyOptions, id),
+      params
+    );
   }
   /**
    * Sends a message to the agent and streams back responses using Server-Sent Events (SSE).
@@ -1207,42 +1665,15 @@ var A2AClient = class _A2AClient {
    * @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));
-    });
+  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)."
+      );
+    }
+    const transport = await this._getOrCreateTransport();
+    yield* transport.sendMessageStream(params);
   }
   /**
    * Sets or updates the push notification configuration for a given task.
@@ -1250,192 +1681,102 @@ var A2AClient = class _A2AClient {
    * @param params Parameters containing the taskId and the TaskPushNotificationConfig.
    * @returns A Promise resolving to SetTaskPushNotificationConfigResponse.
    */
-  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
+  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)."
       );
-    });
+    }
+    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.
    */
-  getTaskPushNotificationConfig(params) {
-    return __async(this, null, function* () {
-      return this._postRpcRequest(
-        "tasks/pushNotificationConfig/get",
-        params
-      );
-    });
+  async getTaskPushNotificationConfig(params) {
+    return await this.invokeJsonRpc(
+      (t, p, id) => t.getTaskPushNotificationConfig(p, _A2AClient.emptyOptions, id),
+      params
+    );
+  }
+  /**
+   * Lists the push notification configurations for a given task.
+   * @param params Parameters containing the taskId.
+   * @returns A Promise resolving to ListTaskPushNotificationConfigResponse.
+   */
+  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.
    */
-  getTask(params) {
-    return __async(this, null, function* () {
-      return this._postRpcRequest("tasks/get", params);
-    });
+  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.
    */
-  cancelTask(params) {
-    return __async(this, null, function* () {
-      return this._postRpcRequest("tasks/cancel", params);
-    });
+  async cancelTask(params) {
+    return await this.invokeJsonRpc(
+      (t, p, id) => t.cancelTask(p, _A2AClient.emptyOptions, id),
+      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).
+   * @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.
    */
-  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",
+  async callExtensionMethod(method, params) {
+    const transport = await this._getOrCreateTransport();
+    try {
+      return await transport.callExtensionMethod(
+        method,
         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();
+        this.requestIdCounter++
+      );
+    } catch (e) {
+      const errorResponse = extractJSONRPCError(e);
+      if (errorResponse) {
+        return errorResponse;
       }
-    });
+      throw e;
+    }
   }
   /**
-   * 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.
+   * 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).
    */
-  _processSseEventData(jsonData, originalRequestId) {
-    if (!jsonData.trim()) {
-      throw new Error("Attempted to process empty SSE event data.");
+  async *resubscribeTask(params) {
+    const agentCard = await this.agentCardPromise;
+    if (!agentCard.capabilities?.streaming) {
+      throw new Error("Agent does not support streaming (required for tasks/resubscribe).");
     }
-    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;
+    const transport = await this._getOrCreateTransport();
+    yield* transport.resubscribeTask(params);
   }
   ////////////////////////////////////////////////////////////////////////////////
   // Functions used to support old A2AClient Constructor to be deprecated soon
@@ -1446,7 +1787,16 @@ var A2AClient = class _A2AClient {
   // * 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.
@@ -1454,51 +1804,53 @@ var A2AClient = class _A2AClient {
    * @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;
+  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.
-  */
-  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();
+   * 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 this.agentCardPromise;
-    });
+      return await response.json();
+    }
+    return this.agentCardPromise;
   }
   /**
    * Determines the agent card URL based on the agent URL.
@@ -1512,41 +1864,73 @@ var A2AClient = class _A2AClient {
    * 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.");
-      }
+  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) {
-  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);
+  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;
-    });
+    }
+    return response;
   }
   Object.setPrototypeOf(authFetch, Object.getPrototypeOf(fetchImpl));
   Object.defineProperties(authFetch, Object.getOwnPropertyDescriptors(fetchImpl));
@@ -1554,106 +1938,168 @@ function createAuthenticatingFetchWithRetry(fetchImpl, authHandler) {
 }
 
 // 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"));
-var A2AExpressApp = class {
-  constructor(requestHandler) {
-    this.requestHandler = requestHandler;
-    this.jsonRpcTransportHandler = new JsonRpcTransportHandler(requestHandler);
+
+// src/server/authentication/user.ts
+var UnauthenticatedUser = class {
+  get isAuthenticated() {
+    return false;
   }
-  /**
-   * 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()}
+  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)}
+            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()}
+          }
+        } 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(`event: error
 `);
-              res.write(`data: ${JSON.stringify(errorResponse)}
+            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();
+        } 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;
   }
@@ -1674,6 +2120,7 @@ var A2AExpressApp = class {
   ResultManager,
   createAuthenticatingFetchWithRetry,
   getCurrentTimestamp,
+  getRequestedExtensions,
   isArtifactUpdate,
   isObject,
   isTaskStatusUpdate