@a2a-js/sdk 0.2.5 → 0.3.0

package/dist/server/index.js

@@ -197,6 +197,12 @@ var A2AError = class _A2AError extends Error {
       `Unsupported operation: ${operation}`
     );
   }
+  static authenticatedExtendedCardNotConfigured() {
+    return new _A2AError(
+      -32007,
+      `Extended card not configured.`
+    );
+  }
 };
 
 // src/server/result_manager.ts
@@ -331,20 +337,28 @@ var ResultManager = class {
 var terminalStates = ["completed", "failed", "canceled", "rejected"];
 var DefaultRequestHandler = class {
   agentCard;
+  extendedAgentCard;
   taskStore;
   agentExecutor;
   eventBusManager;
   // Store for push notification configurations (could be part of TaskStore or separate)
   pushNotificationConfigs = /* @__PURE__ */ new Map();
-  constructor(agentCard, taskStore, agentExecutor, eventBusManager = new DefaultExecutionEventBusManager()) {
+  constructor(agentCard, taskStore, agentExecutor, eventBusManager = new DefaultExecutionEventBusManager(), extendedAgentCard) {
     this.agentCard = agentCard;
     this.taskStore = taskStore;
     this.agentExecutor = agentExecutor;
     this.eventBusManager = eventBusManager;
+    this.extendedAgentCard = extendedAgentCard;
   }
   async getAgentCard() {
     return this.agentCard;
   }
+  async getAuthenticatedExtendedAgentCard() {
+    if (!this.extendedAgentCard) {
+      throw A2AError.authenticatedExtendedCardNotConfigured();
+    }
+    return this.extendedAgentCard;
+  }
   async _createRequestContext(incomingMessage, taskId, isStream) {
     let task;
     let referenceTasks;
@@ -567,27 +581,78 @@ var DefaultRequestHandler = class {
     if (!this.agentCard.capabilities.pushNotifications) {
       throw A2AError.pushNotificationNotSupported();
     }
-    const taskAndHistory = await this.taskStore.load(params.taskId);
-    if (!taskAndHistory) {
+    const task = await this.taskStore.load(params.taskId);
+    if (!task) {
       throw A2AError.taskNotFound(params.taskId);
     }
-    this.pushNotificationConfigs.set(params.taskId, params.pushNotificationConfig);
+    const { taskId, pushNotificationConfig } = params;
+    if (!pushNotificationConfig.id) {
+      pushNotificationConfig.id = taskId;
+    }
+    const configs = this.pushNotificationConfigs.get(taskId) || [];
+    const updatedConfigs = configs.filter((c) => c.id !== pushNotificationConfig.id);
+    updatedConfigs.push(pushNotificationConfig);
+    this.pushNotificationConfigs.set(taskId, updatedConfigs);
     return params;
   }
   async getTaskPushNotificationConfig(params) {
     if (!this.agentCard.capabilities.pushNotifications) {
       throw A2AError.pushNotificationNotSupported();
     }
-    const taskAndHistory = await this.taskStore.load(params.id);
-    if (!taskAndHistory) {
+    const task = await this.taskStore.load(params.id);
+    if (!task) {
       throw A2AError.taskNotFound(params.id);
     }
-    const config = this.pushNotificationConfigs.get(params.id);
-    if (!config) {
+    const configs = this.pushNotificationConfigs.get(params.id) || [];
+    if (configs.length === 0) {
       throw A2AError.internalError(`Push notification config not found for task ${params.id}.`);
     }
+    let configId;
+    if ("pushNotificationConfigId" in params && params.pushNotificationConfigId) {
+      configId = params.pushNotificationConfigId;
+    } else {
+      configId = params.id;
+    }
+    const config = configs.find((c) => c.id === configId);
+    if (!config) {
+      throw A2AError.internalError(`Push notification config with id '${configId}' not found for task ${params.id}.`);
+    }
     return { taskId: params.id, pushNotificationConfig: config };
   }
+  async listTaskPushNotificationConfigs(params) {
+    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 = this.pushNotificationConfigs.get(params.id) || [];
+    return configs.map((config) => ({
+      taskId: params.id,
+      pushNotificationConfig: config
+    }));
+  }
+  async deleteTaskPushNotificationConfig(params) {
+    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;
+    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 *resubscribe(params) {
     if (!this.agentCard.capabilities.streaming) {
       throw A2AError.unsupportedOperation("Streaming (and thus resubscription) is not supported.");
@@ -669,9 +734,21 @@ var JsonRpcTransportHandler = class {
         error: a2aError.toJSONRPCError()
       };
     }
-    const { method, params = {}, id: requestId = null } = rpcRequest;
+    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 === "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.`);
@@ -696,22 +773,33 @@ var JsonRpcTransportHandler = class {
         let result;
         switch (method) {
           case "message/send":
-            result = await this.requestHandler.sendMessage(params);
+            result = await this.requestHandler.sendMessage(rpcRequest.params);
             break;
           case "tasks/get":
-            result = await this.requestHandler.getTask(params);
+            result = await this.requestHandler.getTask(rpcRequest.params);
             break;
           case "tasks/cancel":
-            result = await this.requestHandler.cancelTask(params);
+            result = await this.requestHandler.cancelTask(rpcRequest.params);
             break;
           case "tasks/pushNotificationConfig/set":
             result = await this.requestHandler.setTaskPushNotificationConfig(
-              params
+              rpcRequest.params
             );
             break;
           case "tasks/pushNotificationConfig/get":
             result = await this.requestHandler.getTaskPushNotificationConfig(
-              params
+              rpcRequest.params
+            );
+            break;
+          case "tasks/pushNotificationConfig/delete":
+            await this.requestHandler.deleteTaskPushNotificationConfig(
+              rpcRequest.params
+            );
+            result = null;
+            break;
+          case "tasks/pushNotificationConfig/list":
+            result = await this.requestHandler.listTaskPushNotificationConfigs(
+              rpcRequest.params
             );
             break;
           default:
@@ -733,104 +821,8 @@ var JsonRpcTransportHandler = class {
     }
   }
 };
-
-// src/server/a2a_express_app.ts
-import express from "express";
-var A2AExpressApp = class {
-  requestHandler;
-  // Kept for getAgentCard
-  jsonRpcTransportHandler;
-  constructor(requestHandler) {
-    this.requestHandler = requestHandler;
-    this.jsonRpcTransportHandler = new JsonRpcTransportHandler(requestHandler);
-  }
-  /**
-   * Adds A2A routes to an existing Express app.
-   * @param app Optional existing Express app.
-   * @param baseUrl The base URL for A2A endpoints (e.g., "/a2a/api").
-   * @param middlewares Optional array of Express middlewares to apply to the A2A routes.
-   * @returns The Express app with A2A routes.
-   */
-  setupRoutes(app, baseUrl = "", middlewares) {
-    const router = express.Router();
-    router.use(express.json(), ...middlewares ?? []);
-    router.get("/.well-known/agent.json", async (req, res) => {
-      try {
-        const agentCard = await 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("/", async (req, res) => {
-      try {
-        const rpcResponseOrStream = await this.jsonRpcTransportHandler.handle(req.body);
-        if (typeof rpcResponseOrStream?.[Symbol.asyncIterator] === "function") {
-          const stream = rpcResponseOrStream;
-          res.setHeader("Content-Type", "text/event-stream");
-          res.setHeader("Cache-Control", "no-cache");
-          res.setHeader("Connection", "keep-alive");
-          res.flushHeaders();
-          try {
-            for await (const event of stream) {
-              res.write(`id: ${(/* @__PURE__ */ new Date()).getTime()}
-`);
-              res.write(`data: ${JSON.stringify(event)}
-
-`);
-            }
-          } catch (streamError) {
-            console.error(`Error during SSE streaming (request ${req.body?.id}):`, streamError);
-            const a2aError = streamError instanceof A2AError ? streamError : A2AError.internalError(streamError.message || "Streaming error.");
-            const errorResponse = {
-              jsonrpc: "2.0",
-              id: req.body?.id || null,
-              // Use original request ID if available
-              error: a2aError.toJSONRPCError()
-            };
-            if (!res.headersSent) {
-              res.status(500).json(errorResponse);
-            } else {
-              res.write(`id: ${(/* @__PURE__ */ new Date()).getTime()}
-`);
-              res.write(`event: error
-`);
-              res.write(`data: ${JSON.stringify(errorResponse)}
-
-`);
-            }
-          } finally {
-            if (!res.writableEnded) {
-              res.end();
-            }
-          }
-        } else {
-          const rpcResponse = rpcResponseOrStream;
-          res.status(200).json(rpcResponse);
-        }
-      } catch (error) {
-        console.error("Unhandled error in A2AExpressApp 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();
-        }
-      }
-    });
-    app.use(baseUrl, router);
-    return app;
-  }
-};
 export {
   A2AError,
-  A2AExpressApp,
   DefaultExecutionEventBus,
   DefaultExecutionEventBusManager,
   DefaultRequestHandler,