@a2a-js/sdk 0.2.5 → 0.3.1

package/dist/server/index.js

@@ -1,3 +1,8 @@
+import {
+  A2AError,
+  JsonRpcTransportHandler
+} from "../chunk-JA52GYRU.js";
+
 // src/server/agent_execution/request_context.ts
 var RequestContext = class {
   userMessage;
@@ -124,81 +129,6 @@ var ExecutionEventQueue = class {
 // src/server/request_handler/default_request_handler.ts
 import { v4 as uuidv4 } from "uuid";
 
-// src/server/error.ts
-var A2AError = class _A2AError extends Error {
-  code;
-  data;
-  taskId;
-  // Optional task ID context
-  constructor(code, message, data, taskId) {
-    super(message);
-    this.name = "A2AError";
-    this.code = code;
-    this.data = data;
-    this.taskId = taskId;
-  }
-  /**
-   * Formats the error into a standard JSON-RPC error object structure.
-   */
-  toJSONRPCError() {
-    const errorObject = {
-      code: this.code,
-      message: this.message
-    };
-    if (this.data !== void 0) {
-      errorObject.data = this.data;
-    }
-    return errorObject;
-  }
-  // Static factory methods for common errors
-  static parseError(message, data) {
-    return new _A2AError(-32700, message, data);
-  }
-  static invalidRequest(message, data) {
-    return new _A2AError(-32600, message, data);
-  }
-  static methodNotFound(method) {
-    return new _A2AError(
-      -32601,
-      `Method not found: ${method}`
-    );
-  }
-  static invalidParams(message, data) {
-    return new _A2AError(-32602, message, data);
-  }
-  static internalError(message, data) {
-    return new _A2AError(-32603, message, data);
-  }
-  static taskNotFound(taskId) {
-    return new _A2AError(
-      -32001,
-      `Task not found: ${taskId}`,
-      void 0,
-      taskId
-    );
-  }
-  static taskNotCancelable(taskId) {
-    return new _A2AError(
-      -32002,
-      `Task not cancelable: ${taskId}`,
-      void 0,
-      taskId
-    );
-  }
-  static pushNotificationNotSupported() {
-    return new _A2AError(
-      -32003,
-      "Push Notification is not supported"
-    );
-  }
-  static unsupportedOperation(operation) {
-    return new _A2AError(
-      -32004,
-      `Unsupported operation: ${operation}`
-    );
-  }
-};
-
 // src/server/result_manager.ts
 var ResultManager = class {
   taskStore;
@@ -331,20 +261,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 +505,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.");
@@ -634,203 +623,8 @@ var InMemoryTaskStore = class {
     this.store.set(task.id, { ...task });
   }
 };
-
-// src/server/transports/jsonrpc_transport_handler.ts
-var JsonRpcTransportHandler = class {
-  requestHandler;
-  constructor(requestHandler) {
-    this.requestHandler = requestHandler;
-  }
-  /**
-   * Handles an incoming JSON-RPC request.
-   * For streaming methods, it returns an AsyncGenerator of JSONRPCResult.
-   * For non-streaming methods, it returns a Promise of a single JSONRPCMessage (Result or ErrorResponse).
-   */
-  async handle(requestBody) {
-    let rpcRequest;
-    try {
-      if (typeof requestBody === "string") {
-        rpcRequest = JSON.parse(requestBody);
-      } else if (typeof requestBody === "object" && requestBody !== null) {
-        rpcRequest = requestBody;
-      } else {
-        throw A2AError.parseError("Invalid request body type.");
-      }
-      if (rpcRequest.jsonrpc !== "2.0" || !rpcRequest.method || typeof rpcRequest.method !== "string") {
-        throw A2AError.invalidRequest(
-          "Invalid JSON-RPC request structure."
-        );
-      }
-    } catch (error) {
-      const a2aError = error instanceof A2AError ? error : A2AError.parseError(error.message || "Failed to parse JSON request.");
-      return {
-        jsonrpc: "2.0",
-        id: typeof rpcRequest?.id !== "undefined" ? rpcRequest.id : null,
-        error: a2aError.toJSONRPCError()
-      };
-    }
-    const { method, params = {}, id: requestId = null } = rpcRequest;
-    try {
-      if (method === "message/stream" || method === "tasks/resubscribe") {
-        const agentCard = await this.requestHandler.getAgentCard();
-        if (!agentCard.capabilities.streaming) {
-          throw A2AError.unsupportedOperation(`Method ${method} requires streaming capability.`);
-        }
-        const agentEventStream = method === "message/stream" ? this.requestHandler.sendMessageStream(params) : this.requestHandler.resubscribe(params);
-        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(params);
-            break;
-          case "tasks/get":
-            result = await this.requestHandler.getTask(params);
-            break;
-          case "tasks/cancel":
-            result = await this.requestHandler.cancelTask(params);
-            break;
-          case "tasks/pushNotificationConfig/set":
-            result = await this.requestHandler.setTaskPushNotificationConfig(
-              params
-            );
-            break;
-          case "tasks/pushNotificationConfig/get":
-            result = await this.requestHandler.getTaskPushNotificationConfig(
-              params
-            );
-            break;
-          default:
-            throw A2AError.methodNotFound(method);
-        }
-        return {
-          jsonrpc: "2.0",
-          id: requestId,
-          result
-        };
-      }
-    } catch (error) {
-      const a2aError = error instanceof A2AError ? error : A2AError.internalError(error.message || "An unexpected error occurred.");
-      return {
-        jsonrpc: "2.0",
-        id: requestId,
-        error: a2aError.toJSONRPCError()
-      };
-    }
-  }
-};
-
-// src/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,