@a2a-js/sdk 0.2.4 → 0.3.0

package/dist/server/index.cjs

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,24 +14,16 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/server/index.ts
 var server_exports = {};
 __export(server_exports, {
   A2AError: () => A2AError,
-  A2AExpressApp: () => A2AExpressApp,
   DefaultExecutionEventBus: () => DefaultExecutionEventBus,
   DefaultExecutionEventBusManager: () => DefaultExecutionEventBusManager,
   DefaultRequestHandler: () => DefaultRequestHandler,
+  ExecutionEventQueue: () => ExecutionEventQueue,
   InMemoryTaskStore: () => InMemoryTaskStore,
   JsonRpcTransportHandler: () => JsonRpcTransportHandler,
   RequestContext: () => RequestContext,
@@ -107,6 +97,63 @@ var DefaultExecutionEventBusManager = class {
   }
 };
 
+// src/server/events/execution_event_queue.ts
+var ExecutionEventQueue = class {
+  eventBus;
+  eventQueue = [];
+  resolvePromise;
+  stopped = false;
+  boundHandleEvent;
+  constructor(eventBus) {
+    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.
+   */
+  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.
+   */
+  stop() {
+    this.stopped = true;
+    if (this.resolvePromise) {
+      this.resolvePromise();
+      this.resolvePromise = void 0;
+    }
+    this.eventBus.off("event", this.handleEvent);
+    this.eventBus.off("finished", this.handleFinished);
+  }
+};
+
 // src/server/request_handler/default_request_handler.ts
 var import_uuid = require("uuid");
 
@@ -183,62 +230,11 @@ var A2AError = class _A2AError extends Error {
       `Unsupported operation: ${operation}`
     );
   }
-};
-
-// src/server/events/execution_event_queue.ts
-var ExecutionEventQueue = class {
-  eventBus;
-  eventQueue = [];
-  resolvePromise;
-  stopped = false;
-  boundHandleEvent;
-  constructor(eventBus) {
-    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.
-   */
-  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.
-   */
-  stop() {
-    this.stopped = true;
-    if (this.resolvePromise) {
-      this.resolvePromise();
-      this.resolvePromise = void 0;
-    }
-    this.eventBus.off("event", this.handleEvent);
-    this.eventBus.off("finished", this.handleFinished);
+  static authenticatedExtendedCardNotConfigured() {
+    return new _A2AError(
+      -32007,
+      `Extended card not configured.`
+    );
   }
 };
 
@@ -374,20 +370,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;
@@ -411,11 +415,11 @@ var DefaultRequestHandler = class {
         }
       }
     }
-    const messageForContext = { ...incomingMessage };
-    if (!messageForContext.contextId) {
-      messageForContext.contextId = task?.contextId || (0, import_uuid.v4)();
-    }
-    const contextId = incomingMessage.contextId || (0, import_uuid.v4)();
+    const contextId = incomingMessage.contextId || task?.contextId || (0, import_uuid.v4)();
+    const messageForContext = {
+      ...incomingMessage,
+      contextId
+    };
     return new RequestContext(
       messageForContext,
       taskId,
@@ -610,27 +614,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.");
@@ -712,9 +767,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.`);
@@ -739,22 +806,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:
@@ -776,108 +854,13 @@ var JsonRpcTransportHandler = class {
     }
   }
 };
-
-// src/server/a2a_express_app.ts
-var import_express = __toESM(require("express"), 1);
-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 = import_express.default.Router();
-    router.use(import_express.default.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;
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   A2AError,
-  A2AExpressApp,
   DefaultExecutionEventBus,
   DefaultExecutionEventBusManager,
   DefaultRequestHandler,
+  ExecutionEventQueue,
   InMemoryTaskStore,
   JsonRpcTransportHandler,
   RequestContext,

package/dist/server/index.d.cts

@@ -1,7 +1,5 @@
 import { EventEmitter } from 'events';
-import { a as Message, T as Task, b as TaskStatusUpdateEvent, c as TaskArtifactUpdateEvent, A as AgentCard, M as MessageSendParams, g as TaskQueryParams, f as TaskIdParams, d as TaskPushNotificationConfig, j as JSONRPCError } from '../types-CcBgkR2G.cjs';
-import { A2AResponse } from '../index.cjs';
-import { Express, RequestHandler, ErrorRequestHandler } from 'express';
+import { B as Message, aw as Task, aO as TaskStatusUpdateEvent, aQ as TaskArtifactUpdateEvent, ac as AgentCard, w as MessageSendParams, V as TaskQueryParams, X as TaskIdParams, Z as TaskPushNotificationConfig, a1 as GetTaskPushNotificationConfigParams, a5 as ListTaskPushNotificationConfigParams, a7 as DeleteTaskPushNotificationConfigParams, i as JSONRPCResponse, au as JSONRPCError } from '../types-DNKcmF0f.cjs';
 
 type AgentExecutionEvent = Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent;
 interface ExecutionEventBus {
@@ -71,14 +69,41 @@ declare class DefaultExecutionEventBusManager implements ExecutionEventBusManage
     cleanupByTaskId(taskId: string): void;
 }
 
+/**
+ * An async queue that subscribes to an ExecutionEventBus for events
+ * and provides an async generator to consume them.
+ */
+declare class ExecutionEventQueue {
+    private eventBus;
+    private eventQueue;
+    private resolvePromise?;
+    private stopped;
+    private boundHandleEvent;
+    constructor(eventBus: ExecutionEventBus);
+    private handleEvent;
+    private handleFinished;
+    /**
+     * Provides an async generator that yields events from the event bus.
+     * Stops when a Message event is received or a TaskStatusUpdateEvent with final=true is received.
+     */
+    events(): AsyncGenerator<AgentExecutionEvent, void, undefined>;
+    /**
+     * Stops the event queue from processing further events.
+     */
+    stop(): void;
+}
+
 interface A2ARequestHandler {
     getAgentCard(): Promise<AgentCard>;
+    getAuthenticatedExtendedAgentCard(): Promise<AgentCard>;
     sendMessage(params: MessageSendParams): Promise<Message | Task>;
     sendMessageStream(params: MessageSendParams): AsyncGenerator<Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
     getTask(params: TaskQueryParams): Promise<Task>;
     cancelTask(params: TaskIdParams): Promise<Task>;
     setTaskPushNotificationConfig(params: TaskPushNotificationConfig): Promise<TaskPushNotificationConfig>;
-    getTaskPushNotificationConfig(params: TaskIdParams): Promise<TaskPushNotificationConfig>;
+    getTaskPushNotificationConfig(params: TaskIdParams | GetTaskPushNotificationConfigParams): Promise<TaskPushNotificationConfig>;
+    listTaskPushNotificationConfigs(params: ListTaskPushNotificationConfigParams): Promise<TaskPushNotificationConfig[]>;
+    deleteTaskPushNotificationConfig(params: DeleteTaskPushNotificationConfigParams): Promise<void>;
     resubscribe(params: TaskIdParams): AsyncGenerator<Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
 }
 
@@ -109,12 +134,14 @@ declare class InMemoryTaskStore implements TaskStore {
 
 declare class DefaultRequestHandler implements A2ARequestHandler {
     private readonly agentCard;
+    private readonly extendedAgentCard?;
     private readonly taskStore;
     private readonly agentExecutor;
     private readonly eventBusManager;
     private readonly pushNotificationConfigs;
-    constructor(agentCard: AgentCard, taskStore: TaskStore, agentExecutor: AgentExecutor, eventBusManager?: ExecutionEventBusManager);
+    constructor(agentCard: AgentCard, taskStore: TaskStore, agentExecutor: AgentExecutor, eventBusManager?: ExecutionEventBusManager, extendedAgentCard?: AgentCard);
     getAgentCard(): Promise<AgentCard>;
+    getAuthenticatedExtendedAgentCard(): Promise<AgentCard>;
     private _createRequestContext;
     private _processEvents;
     sendMessage(params: MessageSendParams): Promise<Message | Task>;
@@ -122,7 +149,9 @@ declare class DefaultRequestHandler implements A2ARequestHandler {
     getTask(params: TaskQueryParams): Promise<Task>;
     cancelTask(params: TaskIdParams): Promise<Task>;
     setTaskPushNotificationConfig(params: TaskPushNotificationConfig): Promise<TaskPushNotificationConfig>;
-    getTaskPushNotificationConfig(params: TaskIdParams): Promise<TaskPushNotificationConfig>;
+    getTaskPushNotificationConfig(params: TaskIdParams | GetTaskPushNotificationConfigParams): Promise<TaskPushNotificationConfig>;
+    listTaskPushNotificationConfigs(params: ListTaskPushNotificationConfigParams): Promise<TaskPushNotificationConfig[]>;
+    deleteTaskPushNotificationConfig(params: DeleteTaskPushNotificationConfigParams): Promise<void>;
     resubscribe(params: TaskIdParams): AsyncGenerator<Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
 }
 
@@ -164,21 +193,7 @@ declare class JsonRpcTransportHandler {
      * 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: any): Promise<A2AResponse | AsyncGenerator<A2AResponse, void, undefined>>;
-}
-
-declare class A2AExpressApp {
-    private requestHandler;
-    private jsonRpcTransportHandler;
-    constructor(requestHandler: A2ARequestHandler);
-    /**
-     * 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: Express, baseUrl?: string, middlewares?: Array<RequestHandler | ErrorRequestHandler>): Express;
+    handle(requestBody: any): Promise<JSONRPCResponse | AsyncGenerator<JSONRPCResponse, void, undefined>>;
 }
 
 /**
@@ -202,6 +217,7 @@ declare class A2AError extends Error {
     static taskNotCancelable(taskId: string): A2AError;
     static pushNotificationNotSupported(): A2AError;
     static unsupportedOperation(operation: string): A2AError;
+    static authenticatedExtendedCardNotConfigured(): A2AError;
 }
 
-export { A2AError, A2AExpressApp, type A2ARequestHandler, type AgentExecutor, DefaultExecutionEventBus, DefaultExecutionEventBusManager, DefaultRequestHandler, type ExecutionEventBus, type ExecutionEventBusManager, InMemoryTaskStore, JsonRpcTransportHandler, RequestContext, ResultManager, type TaskStore };
+export { A2AError, type A2ARequestHandler, type AgentExecutionEvent, type AgentExecutor, DefaultExecutionEventBus, DefaultExecutionEventBusManager, DefaultRequestHandler, type ExecutionEventBus, type ExecutionEventBusManager, ExecutionEventQueue, InMemoryTaskStore, JsonRpcTransportHandler, RequestContext, ResultManager, type TaskStore };