@a2a-js/sdk 0.3.4 → 0.3.6

package/dist/server/index.cjs

@@ -29,23 +29,27 @@ __export(server_exports, {
   InMemoryTaskStore: () => InMemoryTaskStore,
   JsonRpcTransportHandler: () => JsonRpcTransportHandler,
   RequestContext: () => RequestContext,
-  ResultManager: () => ResultManager
+  ResultManager: () => ResultManager,
+  ServerCallContext: () => ServerCallContext,
+  UnauthenticatedUser: () => UnauthenticatedUser
 });
 module.exports = __toCommonJS(server_exports);
 
 // src/server/agent_execution/request_context.ts
 var RequestContext = class {
   userMessage;
-  task;
-  referenceTasks;
   taskId;
   contextId;
-  constructor(userMessage, taskId, contextId, task, referenceTasks) {
+  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;
   }
 };
 
@@ -69,7 +73,7 @@ var DefaultExecutionEventBusManager = class {
   /**
    * Creates or retrieves an existing ExecutionEventBus based on the taskId.
    * @param taskId The ID of the task.
-   * @returns An instance of IExecutionEventBus.
+   * @returns An instance of ExecutionEventBus.
    */
   createOrGetByTaskId(taskId) {
     if (!this.taskIdToBus.has(taskId)) {
@@ -80,7 +84,7 @@ var DefaultExecutionEventBusManager = class {
   /**
    * Retrieves an existing ExecutionEventBus based on the taskId.
    * @param taskId The ID of the task.
-   * @returns An instance of IExecutionEventBus or undefined if not found.
+   * @returns An instance of ExecutionEventBus or undefined if not found.
    */
   getByTaskId(taskId) {
     return this.taskIdToBus.get(taskId);
@@ -193,10 +197,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);
@@ -205,51 +206,34 @@ 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;
+  serverCallContext;
   currentTask;
   latestUserMessage;
   // To add to history if a new task is created
   finalMessageResult;
   // Stores the message if it's the final result
-  constructor(taskStore) {
+  constructor(taskStore, serverCallContext) {
     this.taskStore = taskStore;
+    this.serverCallContext = serverCallContext;
   }
   setContext(latestUserMessage) {
     this.latestUserMessage = latestUserMessage;
@@ -265,7 +249,9 @@ var ResultManager = class {
       const taskEvent = event;
       this.currentTask = { ...taskEvent };
       if (this.latestUserMessage) {
-        if (!this.currentTask.history?.find((msg) => msg.messageId === this.latestUserMessage.messageId)) {
+        if (!this.currentTask.history?.find(
+          (msg) => msg.messageId === this.latestUserMessage.messageId
+        )) {
           this.currentTask.history = [this.latestUserMessage, ...this.currentTask.history || []];
         }
       }
@@ -275,24 +261,36 @@ var ResultManager = class {
       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];
+          if (!this.currentTask.history?.find(
+            (msg) => msg.messageId === updateEvent.status.message.messageId
+          )) {
+            this.currentTask.history = [
+              ...this.currentTask.history || [],
+              updateEvent.status.message
+            ];
           }
         }
         await this.saveCurrentTask();
       } else if (!this.currentTask && updateEvent.taskId) {
-        const loaded = await this.taskStore.load(updateEvent.taskId);
+        const loaded = await this.taskStore.load(updateEvent.taskId, this.serverCallContext);
         if (loaded) {
           this.currentTask = loaded;
           this.currentTask.status = updateEvent.status;
           if (updateEvent.status.message) {
-            if (!this.currentTask.history?.find((msg) => msg.messageId === updateEvent.status.message.messageId)) {
-              this.currentTask.history = [...this.currentTask.history || [], updateEvent.status.message];
+            if (!this.currentTask.history?.find(
+              (msg) => msg.messageId === updateEvent.status.message.messageId
+            )) {
+              this.currentTask.history = [
+                ...this.currentTask.history || [],
+                updateEvent.status.message
+              ];
             }
           }
           await this.saveCurrentTask();
         } else {
-          console.warn(`ResultManager: Received status update for unknown task ${updateEvent.taskId}`);
+          console.warn(
+            `ResultManager: Received status update for unknown task ${updateEvent.taskId}`
+          );
         }
       }
     } else if (event.kind === "artifact-update") {
@@ -308,9 +306,14 @@ var ResultManager = class {
           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.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 };
+            if (artifactEvent.artifact.metadata)
+              existingArtifact.metadata = {
+                ...existingArtifact.metadata,
+                ...artifactEvent.artifact.metadata
+              };
           } else {
             this.currentTask.artifacts[existingArtifactIndex] = artifactEvent.artifact;
           }
@@ -319,7 +322,7 @@ var ResultManager = class {
         }
         await this.saveCurrentTask();
       } else if (!this.currentTask && artifactEvent.taskId) {
-        const loaded = await this.taskStore.load(artifactEvent.taskId);
+        const loaded = await this.taskStore.load(artifactEvent.taskId, this.serverCallContext);
         if (loaded) {
           this.currentTask = loaded;
           if (!this.currentTask.artifacts) this.currentTask.artifacts = [];
@@ -328,7 +331,9 @@ var ResultManager = class {
           );
           if (existingArtifactIndex !== -1) {
             if (artifactEvent.append) {
-              this.currentTask.artifacts[existingArtifactIndex].parts.push(...artifactEvent.artifact.parts);
+              this.currentTask.artifacts[existingArtifactIndex].parts.push(
+                ...artifactEvent.artifact.parts
+              );
             } else {
               this.currentTask.artifacts[existingArtifactIndex] = artifactEvent.artifact;
             }
@@ -337,14 +342,16 @@ var ResultManager = class {
           }
           await this.saveCurrentTask();
         } else {
-          console.warn(`ResultManager: Received artifact update for unknown task ${artifactEvent.taskId}`);
+          console.warn(
+            `ResultManager: Received artifact update for unknown task ${artifactEvent.taskId}`
+          );
         }
       }
     }
   }
   async saveCurrentTask() {
     if (this.currentTask) {
-      await this.taskStore.save(this.currentTask);
+      await this.taskStore.save(this.currentTask, this.serverCallContext);
     }
   }
   /**
@@ -410,9 +417,11 @@ var InMemoryPushNotificationStore = class {
 // 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",
@@ -424,10 +433,25 @@ var DefaultPushNotificationSender = class {
     if (!pushConfigs || pushConfigs.length === 0) {
       return;
     }
-    pushConfigs.forEach((pushConfig) => {
-      this._dispatchNotification(task, pushConfig).catch((error) => {
-        console.error(`Error sending push notification for task_id=${task.id} to URL: ${pushConfig.url}. Error:`, error);
+    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) {
@@ -451,30 +475,86 @@ var DefaultPushNotificationSender = class {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
       console.info(`Push notification sent for task_id=${task.id} to URL: ${url}`);
-    } catch (error) {
-      console.error(`Error sending push notification for task_id=${task.id} to URL: ${url}. Error:`, error);
     } finally {
       clearTimeout(timeoutId);
     }
   }
 };
 
+// src/extensions.ts
+var Extensions = {
+  /**
+   * Creates new {@link Extensions} from `current` and `additional`.
+   * If `current` already contains `additional` it is returned unmodified.
+   */
+  createFrom: (current, additional) => {
+    if (current?.includes(additional)) {
+      return current;
+    }
+    return [...current ?? [], additional];
+  },
+  /**
+   * Creates {@link Extensions} from comma separated extensions identifiers as per
+   * https://a2a-protocol.org/latest/specification/#326-service-parameters.
+   * Parses the output of `toServiceParameter`.
+   */
+  parseServiceParameter: (value) => {
+    if (!value) {
+      return [];
+    }
+    const unique = new Set(
+      value.split(",").map((ext) => ext.trim()).filter((ext) => ext.length > 0)
+    );
+    return Array.from(unique);
+  },
+  /**
+   * Converts {@link Extensions} to comma separated extensions identifiers as per
+   * https://a2a-protocol.org/latest/specification/#326-service-parameters.
+   */
+  toServiceParameter: (value) => {
+    return value.join(",");
+  }
+};
+
+// 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) {
+    this._activatedExtensions = Extensions.createFrom(this._activatedExtensions, uri);
+  }
+};
+
 // src/server/request_handler/default_request_handler.ts
 var terminalStates = ["completed", "failed", "canceled", "rejected"];
 var DefaultRequestHandler = class {
   agentCard;
-  extendedAgentCard;
   taskStore;
   agentExecutor;
   eventBusManager;
   pushNotificationStore;
   pushNotificationSender;
-  constructor(agentCard, taskStore, agentExecutor, eventBusManager = new DefaultExecutionEventBusManager(), pushNotificationStore, pushNotificationSender, extendedAgentCard) {
+  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);
@@ -483,28 +563,42 @@ var DefaultRequestHandler = class {
   async getAgentCard() {
     return this.agentCard;
   }
-  async getAuthenticatedExtendedAgentCard() {
-    if (!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();
     }
-    return this.extendedAgentCard;
+    if (typeof this.extendedAgentCardProvider === "function") {
+      return this.extendedAgentCardProvider(context);
+    }
+    if (context?.user?.isAuthenticated) {
+      return this.extendedAgentCardProvider;
+    }
+    return this.agentCard;
   }
-  async _createRequestContext(incomingMessage, taskId, isStream) {
+  async _createRequestContext(incomingMessage, context) {
     let task;
     let referenceTasks;
     if (incomingMessage.taskId) {
-      task = await this.taskStore.load(incomingMessage.taskId);
+      task = await this.taskStore.load(incomingMessage.taskId, context);
       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.`);
+        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, context);
     }
+    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);
+        const refTask = await this.taskStore.load(refId, context);
         if (refTask) {
           referenceTasks.push(refTask);
         } else {
@@ -513,54 +607,74 @@ var DefaultRequestHandler = class {
       }
     }
     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 = context.requestedExtensions.filter(
+        (extension) => exposedExtensions.has(extension)
+      );
+      context = new ServerCallContext(validExtensions, context.user);
+    }
     const messageForContext = {
       ...incomingMessage,
-      contextId
-    };
-    return new RequestContext(
-      messageForContext,
-      taskId,
       contextId,
-      task,
-      referenceTasks
-    );
+      taskId
+    };
+    return new RequestContext(messageForContext, taskId, contextId, task, referenceTasks, context);
   }
-  async _processEvents(taskId, resultManager, eventQueue, options) {
+  async _processEvents(taskId, resultManager, eventQueue, context, options) {
     let firstResultSent = false;
     try {
       for await (const event of eventQueue.events()) {
         await resultManager.processEvent(event);
-        await this._sendPushNotificationIfNeeded(event);
+        try {
+          await this._sendPushNotificationIfNeeded(event, context);
+        } catch (error) {
+          console.error(`Error sending push notification: ${error}`);
+        }
         if (options?.firstResultResolver && !firstResultSent) {
-          if (event.kind === "message" || event.kind === "task") {
-            options.firstResultResolver(event);
+          let firstResult;
+          if (event.kind === "message") {
+            firstResult = event;
+          } else {
+            firstResult = resultManager.getCurrentTask();
+          }
+          if (firstResult) {
+            options.firstResultResolver(firstResult);
             firstResultSent = true;
           }
         }
       }
       if (options?.firstResultRejector && !firstResultSent) {
-        options.firstResultRejector(A2AError.internalError("Execution finished before a message or task was produced."));
+        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);
-      if (options?.firstResultRejector && !firstResultSent) {
-        options.firstResultRejector(error);
-      }
-      throw error;
+      this._handleProcessingError(
+        error,
+        resultManager,
+        firstResultSent,
+        taskId,
+        options?.firstResultRejector
+      );
     } finally {
       this.eventBusManager.cleanupByTaskId(taskId);
     }
   }
-  async sendMessage(params) {
+  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 taskId = incomingMessage.taskId || (0, import_uuid.v4)();
-    const resultManager = new ResultManager(this.taskStore);
+    const resultManager = new ResultManager(this.taskStore, context);
     resultManager.setContext(incomingMessage);
-    const requestContext = await this._createRequestContext(incomingMessage, taskId, false);
+    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);
@@ -605,30 +719,32 @@ var DefaultRequestHandler = class {
       eventBus.finished();
     });
     if (isBlocking) {
-      await this._processEvents(taskId, resultManager, eventQueue);
+      await this._processEvents(taskId, resultManager, eventQueue, context);
       const finalResult = resultManager.getFinalResult();
       if (!finalResult) {
-        throw A2AError.internalError("Agent execution finished without a result, and no task context found.");
+        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, {
+        this._processEvents(taskId, resultManager, eventQueue, context, {
           firstResultResolver: resolve,
           firstResultRejector: reject
         });
       });
     }
   }
-  async *sendMessageStream(params) {
+  async *sendMessageStream(params, context) {
     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);
+    const resultManager = new ResultManager(this.taskStore, context);
     resultManager.setContext(incomingMessage);
-    const requestContext = await this._createRequestContext(incomingMessage, taskId, true);
+    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);
@@ -636,7 +752,10 @@ var DefaultRequestHandler = class {
       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);
+      console.error(
+        `Agent execution failed for stream message ${finalMessageForAgent.messageId}:`,
+        err
+      );
       const errorTaskStatus = {
         kind: "status-update",
         taskId: requestContext.task?.id || (0, import_uuid.v4)(),
@@ -662,15 +781,15 @@ var DefaultRequestHandler = class {
     try {
       for await (const event of eventQueue.events()) {
         await resultManager.processEvent(event);
-        await this._sendPushNotificationIfNeeded(event);
+        await this._sendPushNotificationIfNeeded(event, context);
         yield event;
       }
     } finally {
       this.eventBusManager.cleanupByTaskId(taskId);
     }
   }
-  async getTask(params) {
-    const task = await this.taskStore.load(params.id);
+  async getTask(params, context) {
+    const task = await this.taskStore.load(params.id, context);
     if (!task) {
       throw A2AError.taskNotFound(params.id);
     }
@@ -683,8 +802,8 @@ var DefaultRequestHandler = class {
     }
     return task;
   }
-  async cancelTask(params) {
-    const task = await this.taskStore.load(params.id);
+  async cancelTask(params, context) {
+    const task = await this.taskStore.load(params.id, context);
     if (!task) {
       throw A2AError.taskNotFound(params.id);
     }
@@ -694,7 +813,14 @@ var DefaultRequestHandler = class {
     }
     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, context),
+        eventQueue,
+        context
+      );
     } else {
       task.status = {
         state: "canceled",
@@ -710,16 +836,22 @@ var DefaultRequestHandler = class {
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       task.history = [...task.history || [], task.status.message];
-      await this.taskStore.save(task);
+      await this.taskStore.save(task, context);
+    }
+    const latestTask = await this.taskStore.load(params.id, context);
+    if (!latestTask) {
+      throw A2AError.internalError(`Task ${params.id} not found after cancellation.`);
+    }
+    if (latestTask.status.state != "canceled") {
+      throw A2AError.taskNotCancelable(params.id);
     }
-    const latestTask = await this.taskStore.load(params.id);
     return latestTask;
   }
-  async setTaskPushNotificationConfig(params) {
+  async setTaskPushNotificationConfig(params, context) {
     if (!this.agentCard.capabilities.pushNotifications) {
       throw A2AError.pushNotificationNotSupported();
     }
-    const task = await this.taskStore.load(params.taskId);
+    const task = await this.taskStore.load(params.taskId, context);
     if (!task) {
       throw A2AError.taskNotFound(params.taskId);
     }
@@ -730,11 +862,11 @@ var DefaultRequestHandler = class {
     await this.pushNotificationStore?.save(taskId, pushNotificationConfig);
     return params;
   }
-  async getTaskPushNotificationConfig(params) {
+  async getTaskPushNotificationConfig(params, context) {
     if (!this.agentCard.capabilities.pushNotifications) {
       throw A2AError.pushNotificationNotSupported();
     }
-    const task = await this.taskStore.load(params.id);
+    const task = await this.taskStore.load(params.id, context);
     if (!task) {
       throw A2AError.taskNotFound(params.id);
     }
@@ -750,15 +882,17 @@ var DefaultRequestHandler = class {
     }
     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}.`);
+      throw A2AError.internalError(
+        `Push notification config with id '${configId}' not found for task ${params.id}.`
+      );
     }
     return { taskId: params.id, pushNotificationConfig: config };
   }
-  async listTaskPushNotificationConfigs(params) {
+  async listTaskPushNotificationConfigs(params, context) {
     if (!this.agentCard.capabilities.pushNotifications) {
       throw A2AError.pushNotificationNotSupported();
     }
-    const task = await this.taskStore.load(params.id);
+    const task = await this.taskStore.load(params.id, context);
     if (!task) {
       throw A2AError.taskNotFound(params.id);
     }
@@ -768,22 +902,22 @@ var DefaultRequestHandler = class {
       pushNotificationConfig: config
     }));
   }
-  async deleteTaskPushNotificationConfig(params) {
+  async deleteTaskPushNotificationConfig(params, context) {
     if (!this.agentCard.capabilities.pushNotifications) {
       throw A2AError.pushNotificationNotSupported();
     }
-    const task = await this.taskStore.load(params.id);
+    const task = await this.taskStore.load(params.id, context);
     if (!task) {
       throw A2AError.taskNotFound(params.id);
     }
     const { id: taskId, pushNotificationConfigId } = params;
     await this.pushNotificationStore?.delete(taskId, pushNotificationConfigId);
   }
-  async *resubscribe(params) {
+  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);
+    const task = await this.taskStore.load(params.id, context);
     if (!task) {
       throw A2AError.taskNotFound(params.id);
     }
@@ -812,7 +946,7 @@ var DefaultRequestHandler = class {
       eventQueue.stop();
     }
   }
-  async _sendPushNotificationIfNeeded(event) {
+  async _sendPushNotificationIfNeeded(event, context) {
     if (!this.agentCard.capabilities.pushNotifications) {
       return;
     }
@@ -827,13 +961,53 @@ var DefaultRequestHandler = class {
       console.error(`Task ID not found for event ${event.kind}.`);
       return;
     }
-    const task = await this.taskStore.load(taskId);
+    const task = await this.taskStore.load(taskId, context);
     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
@@ -848,7 +1022,7 @@ var InMemoryTaskStore = class {
   }
 };
 
-// src/server/transports/jsonrpc_transport_handler.ts
+// src/server/transports/jsonrpc/jsonrpc_transport_handler.ts
 var JsonRpcTransportHandler = class {
   requestHandler;
   constructor(requestHandler) {
@@ -859,7 +1033,7 @@ 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).
    */
-  async handle(requestBody) {
+  async handle(requestBody, context) {
     let rpcRequest;
     try {
       if (typeof requestBody === "string") {
@@ -869,31 +1043,23 @@ var JsonRpcTransportHandler = class {
       } else {
         throw A2AError.parseError("Invalid request body type.");
       }
-      if (rpcRequest.jsonrpc !== "2.0" || !rpcRequest.method || typeof rpcRequest.method !== "string") {
-        throw A2AError.invalidRequest(
-          "Invalid JSON-RPC request structure."
-        );
+      if (!this.isRequestValid(rpcRequest)) {
+        throw A2AError.invalidRequest("Invalid JSON-RPC Request.");
       }
     } catch (error) {
-      const a2aError = error instanceof A2AError ? error : A2AError.parseError(error.message || "Failed to parse JSON request.");
+      const a2aError = error instanceof A2AError ? error : A2AError.parseError(
+        error instanceof SyntaxError && error.message || "Failed to parse JSON request."
+      );
       return {
         jsonrpc: "2.0",
-        id: typeof rpcRequest?.id !== "undefined" ? rpcRequest.id : null,
+        id: rpcRequest?.id !== void 0 ? rpcRequest.id : null,
         error: a2aError.toJSONRPCError()
       };
     }
     const { method, id: requestId = null } = rpcRequest;
     try {
-      if (method === "agent/getAuthenticatedExtendedCard") {
-        const result = await this.requestHandler.getAuthenticatedExtendedAgentCard();
-        return {
-          jsonrpc: "2.0",
-          id: requestId,
-          result
-        };
-      }
-      if (!rpcRequest.params) {
-        throw A2AError.invalidParams(`'params' is required for '${method}'`);
+      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;
@@ -901,8 +1067,8 @@ var JsonRpcTransportHandler = class {
         if (!agentCard.capabilities.streaming) {
           throw A2AError.unsupportedOperation(`Method ${method} requires streaming capability.`);
         }
-        const agentEventStream = method === "message/stream" ? this.requestHandler.sendMessageStream(params) : this.requestHandler.resubscribe(params);
-        return async function* jsonRpcEventStream() {
+        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 {
@@ -913,43 +1079,50 @@ var JsonRpcTransportHandler = class {
               };
             }
           } catch (streamError) {
-            console.error(`Error in agent event stream for ${method} (request ${requestId}):`, 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);
+            result = await this.requestHandler.sendMessage(rpcRequest.params, context);
             break;
           case "tasks/get":
-            result = await this.requestHandler.getTask(rpcRequest.params);
+            result = await this.requestHandler.getTask(rpcRequest.params, context);
             break;
           case "tasks/cancel":
-            result = await this.requestHandler.cancelTask(rpcRequest.params);
+            result = await this.requestHandler.cancelTask(rpcRequest.params, context);
             break;
           case "tasks/pushNotificationConfig/set":
             result = await this.requestHandler.setTaskPushNotificationConfig(
-              rpcRequest.params
+              rpcRequest.params,
+              context
             );
             break;
           case "tasks/pushNotificationConfig/get":
             result = await this.requestHandler.getTaskPushNotificationConfig(
-              rpcRequest.params
+              rpcRequest.params,
+              context
             );
             break;
           case "tasks/pushNotificationConfig/delete":
-            await this.requestHandler.deleteTaskPushNotificationConfig(
-              rpcRequest.params
-            );
+            await this.requestHandler.deleteTaskPushNotificationConfig(rpcRequest.params, context);
             result = null;
             break;
           case "tasks/pushNotificationConfig/list":
             result = await this.requestHandler.listTaskPushNotificationConfigs(
-              rpcRequest.params
+              rpcRequest.params,
+              context
             );
             break;
+          case "agent/getAuthenticatedExtendedCard":
+            result = await this.requestHandler.getAuthenticatedExtendedAgentCard(context);
+            break;
           default:
             throw A2AError.methodNotFound(method);
         }
@@ -960,7 +1133,14 @@ var JsonRpcTransportHandler = class {
         };
       }
     } catch (error) {
-      const a2aError = error instanceof A2AError ? error : A2AError.internalError(error.message || "An unexpected error occurred.");
+      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,
@@ -968,6 +1148,47 @@ var JsonRpcTransportHandler = class {
       };
     }
   }
+  // 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/server/authentication/user.ts
+var UnauthenticatedUser = class {
+  get isAuthenticated() {
+    return false;
+  }
+  get userName() {
+    return "";
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -981,5 +1202,7 @@ var JsonRpcTransportHandler = class {
   InMemoryTaskStore,
   JsonRpcTransportHandler,
   RequestContext,
-  ResultManager
+  ResultManager,
+  ServerCallContext,
+  UnauthenticatedUser
 });