@mailmodo/a2a 0.3.5 → 0.3.7

package/dist/server/index.js

@@ -54,16 +54,194 @@ var RequestContext = class {
 };
 
 // src/server/events/execution_event_bus.ts
-var import_events = require("events");
-var DefaultExecutionEventBus = class extends import_events.EventEmitter {
-  constructor() {
-    super();
+var CustomEventImpl = typeof CustomEvent !== "undefined" ? CustomEvent : class CustomEventPolyfill extends Event {
+  detail;
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.detail = eventInitDict?.detail ?? null;
   }
+};
+function isAgentExecutionCustomEvent(e) {
+  return e instanceof CustomEventImpl;
+}
+var DefaultExecutionEventBus = class extends EventTarget {
+  // Separate storage for each event type - both use the interface's Listener type
+  // but are invoked differently (with event payload vs. no arguments)
+  eventListeners = /* @__PURE__ */ new Map();
+  finishedListeners = /* @__PURE__ */ new Map();
   publish(event) {
-    this.emit("event", event);
+    this.dispatchEvent(new CustomEventImpl("event", { detail: event }));
   }
   finished() {
-    this.emit("finished");
+    this.dispatchEvent(new Event("finished"));
+  }
+  /**
+   * EventEmitter-compatible 'on' method.
+   * Wraps the listener to extract event detail from CustomEvent.
+   * Supports multiple registrations of the same listener (like EventEmitter).
+   * @param eventName The event name to listen for.
+   * @param listener The callback function to invoke when the event is emitted.
+   * @returns This instance for method chaining.
+   */
+  on(eventName, listener) {
+    if (eventName === "event") {
+      this.addEventListenerInternal(listener);
+    } else {
+      this.addFinishedListenerInternal(listener);
+    }
+    return this;
+  }
+  /**
+   * EventEmitter-compatible 'off' method.
+   * Uses the stored wrapped listener for proper removal.
+   * Removes at most one instance of a listener per call (like EventEmitter).
+   * @param eventName The event name to stop listening for.
+   * @param listener The callback function to remove.
+   * @returns This instance for method chaining.
+   */
+  off(eventName, listener) {
+    if (eventName === "event") {
+      this.removeEventListenerInternal(listener);
+    } else {
+      this.removeFinishedListenerInternal(listener);
+    }
+    return this;
+  }
+  /**
+   * EventEmitter-compatible 'once' method.
+   * Listener is automatically removed after first invocation.
+   * Supports multiple registrations of the same listener (like EventEmitter).
+   * @param eventName The event name to listen for once.
+   * @param listener The callback function to invoke when the event is emitted.
+   * @returns This instance for method chaining.
+   */
+  once(eventName, listener) {
+    if (eventName === "event") {
+      this.addEventListenerOnceInternal(listener);
+    } else {
+      this.addFinishedListenerOnceInternal(listener);
+    }
+    return this;
+  }
+  /**
+   * EventEmitter-compatible 'removeAllListeners' method.
+   * Removes all listeners for a specific event or all events.
+   * @param eventName Optional event name to remove listeners for. If omitted, removes all.
+   * @returns This instance for method chaining.
+   */
+  removeAllListeners(eventName) {
+    if (eventName === void 0 || eventName === "event") {
+      for (const wrappedListeners of this.eventListeners.values()) {
+        for (const wrapped of wrappedListeners) {
+          this.removeEventListener("event", wrapped);
+        }
+      }
+      this.eventListeners.clear();
+    }
+    if (eventName === void 0 || eventName === "finished") {
+      for (const wrappedListeners of this.finishedListeners.values()) {
+        for (const wrapped of wrappedListeners) {
+          this.removeEventListener("finished", wrapped);
+        }
+      }
+      this.finishedListeners.clear();
+    }
+    return this;
+  }
+  // ========================
+  // Helper methods for listener tracking
+  // ========================
+  /**
+   * Adds a wrapped listener to the tracking map.
+   */
+  trackListener(listenerMap, listener, wrapped) {
+    const existing = listenerMap.get(listener);
+    if (existing) {
+      existing.push(wrapped);
+    } else {
+      listenerMap.set(listener, [wrapped]);
+    }
+  }
+  /**
+   * Removes a wrapped listener from the tracking map (for once cleanup).
+   */
+  untrackWrappedListener(listenerMap, listener, wrapped) {
+    const wrappedList = listenerMap.get(listener);
+    if (wrappedList && wrappedList.length > 0) {
+      const index = wrappedList.indexOf(wrapped);
+      if (index !== -1) {
+        wrappedList.splice(index, 1);
+        if (wrappedList.length === 0) {
+          listenerMap.delete(listener);
+        }
+      }
+    }
+  }
+  // ========================
+  // Internal methods for 'event' listeners
+  // ========================
+  addEventListenerInternal(listener) {
+    const wrapped = (e) => {
+      if (!isAgentExecutionCustomEvent(e)) {
+        throw new Error('Internal error: expected CustomEvent for "event" type');
+      }
+      listener.call(this, e.detail);
+    };
+    this.trackListener(this.eventListeners, listener, wrapped);
+    this.addEventListener("event", wrapped);
+  }
+  removeEventListenerInternal(listener) {
+    const wrappedList = this.eventListeners.get(listener);
+    if (wrappedList && wrappedList.length > 0) {
+      const wrapped = wrappedList.pop();
+      if (wrappedList.length === 0) {
+        this.eventListeners.delete(listener);
+      }
+      this.removeEventListener("event", wrapped);
+    }
+  }
+  addEventListenerOnceInternal(listener) {
+    const wrapped = (e) => {
+      if (!isAgentExecutionCustomEvent(e)) {
+        throw new Error('Internal error: expected CustomEvent for "event" type');
+      }
+      this.untrackWrappedListener(this.eventListeners, listener, wrapped);
+      listener.call(this, e.detail);
+    };
+    this.trackListener(this.eventListeners, listener, wrapped);
+    this.addEventListener("event", wrapped, { once: true });
+  }
+  // ========================
+  // Internal methods for 'finished' listeners
+  // ========================
+  // The interface declares listeners as (event: AgentExecutionEvent) => void,
+  // but for 'finished' events they are invoked with no arguments (EventEmitter behavior).
+  // We use Function.prototype.call to invoke with `this` as the event bus (matching
+  // EventEmitter semantics) and no arguments, which is type-safe.
+  addFinishedListenerInternal(listener) {
+    const wrapped = () => {
+      listener.call(this);
+    };
+    this.trackListener(this.finishedListeners, listener, wrapped);
+    this.addEventListener("finished", wrapped);
+  }
+  removeFinishedListenerInternal(listener) {
+    const wrappedList = this.finishedListeners.get(listener);
+    if (wrappedList && wrappedList.length > 0) {
+      const wrapped = wrappedList.pop();
+      if (wrappedList.length === 0) {
+        this.finishedListeners.delete(listener);
+      }
+      this.removeEventListener("finished", wrapped);
+    }
+  }
+  addFinishedListenerOnceInternal(listener) {
+    const wrapped = () => {
+      this.untrackWrappedListener(this.finishedListeners, listener, wrapped);
+      listener.call(this);
+    };
+    this.trackListener(this.finishedListeners, listener, wrapped);
+    this.addEventListener("finished", wrapped, { once: true });
   }
 };
 
@@ -73,7 +251,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)) {
@@ -84,7 +262,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);
@@ -225,13 +403,15 @@ var A2AError = class _A2AError extends Error {
 // 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;
@@ -270,7 +450,7 @@ var ResultManager = class {
         }
         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;
@@ -320,7 +500,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 = [];
@@ -349,7 +529,7 @@ var ResultManager = class {
   }
   async saveCurrentTask() {
     if (this.currentTask) {
-      await this.taskStore.save(this.currentTask);
+      await this.taskStore.save(this.currentTask, this.serverCallContext);
     }
   }
   /**
@@ -479,6 +659,41 @@ var DefaultPushNotificationSender = class {
   }
 };
 
+// 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;
@@ -498,12 +713,7 @@ var ServerCallContext = class {
     return this._requestedExtensions;
   }
   addActivatedExtension(uri) {
-    if (this._requestedExtensions?.has(uri)) {
-      if (!this._activatedExtensions) {
-        this._activatedExtensions = /* @__PURE__ */ new Set();
-      }
-      this._activatedExtensions.add(uri);
-    }
+    this._activatedExtensions = Extensions.createFrom(this._activatedExtensions, uri);
   }
 };
 
@@ -550,7 +760,7 @@ var DefaultRequestHandler = class {
     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);
       }
@@ -560,13 +770,13 @@ var DefaultRequestHandler = class {
         );
       }
       task.history = [...task.history || [], incomingMessage];
-      await this.taskStore.save(task);
+      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 {
@@ -580,10 +790,8 @@ var DefaultRequestHandler = class {
       const exposedExtensions = new Set(
         agentCard.capabilities.extensions?.map((ext) => ext.uri) || []
       );
-      const validExtensions = new Set(
-        Array.from(context.requestedExtensions).filter(
-          (extension) => exposedExtensions.has(extension)
-        )
+      const validExtensions = context.requestedExtensions.filter(
+        (extension) => exposedExtensions.has(extension)
       );
       context = new ServerCallContext(validExtensions, context.user);
     }
@@ -594,13 +802,13 @@ var DefaultRequestHandler = class {
     };
     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);
         try {
-          await this._sendPushNotificationIfNeeded(event);
+          await this._sendPushNotificationIfNeeded(event, context);
         } catch (error) {
           console.error(`Error sending push notification: ${error}`);
         }
@@ -641,7 +849,7 @@ var DefaultRequestHandler = class {
       throw A2AError.invalidParams("message.messageId is required.");
     }
     const isBlocking = params.configuration?.blocking !== false;
-    const resultManager = new ResultManager(this.taskStore);
+    const resultManager = new ResultManager(this.taskStore, context);
     resultManager.setContext(incomingMessage);
     const requestContext = await this._createRequestContext(incomingMessage, context);
     const taskId = requestContext.taskId;
@@ -689,7 +897,7 @@ 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(
@@ -699,7 +907,7 @@ var DefaultRequestHandler = class {
       return finalResult;
     } else {
       return new Promise((resolve, reject) => {
-        this._processEvents(taskId, resultManager, eventQueue, {
+        this._processEvents(taskId, resultManager, eventQueue, context, {
           firstResultResolver: resolve,
           firstResultRejector: reject
         });
@@ -711,7 +919,7 @@ var DefaultRequestHandler = class {
     if (!incomingMessage.messageId) {
       throw A2AError.invalidParams("message.messageId is required for streaming.");
     }
-    const resultManager = new ResultManager(this.taskStore);
+    const resultManager = new ResultManager(this.taskStore, context);
     resultManager.setContext(incomingMessage);
     const requestContext = await this._createRequestContext(incomingMessage, context);
     const taskId = requestContext.taskId;
@@ -751,15 +959,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, _context) {
-    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);
     }
@@ -772,8 +980,8 @@ var DefaultRequestHandler = class {
     }
     return task;
   }
-  async cancelTask(params, _context) {
-    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);
     }
@@ -785,7 +993,12 @@ var DefaultRequestHandler = class {
     if (eventBus) {
       const eventQueue = new ExecutionEventQueue(eventBus);
       await this.agentExecutor.cancelTask(params.id, eventBus);
-      await this._processEvents(params.id, new ResultManager(this.taskStore), eventQueue);
+      await this._processEvents(
+        params.id,
+        new ResultManager(this.taskStore, context),
+        eventQueue,
+        context
+      );
     } else {
       task.status = {
         state: "canceled",
@@ -801,9 +1014,9 @@ 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);
+    const latestTask = await this.taskStore.load(params.id, context);
     if (!latestTask) {
       throw A2AError.internalError(`Task ${params.id} not found after cancellation.`);
     }
@@ -812,11 +1025,11 @@ var DefaultRequestHandler = class {
     }
     return latestTask;
   }
-  async setTaskPushNotificationConfig(params, _context) {
+  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);
     }
@@ -827,11 +1040,11 @@ var DefaultRequestHandler = class {
     await this.pushNotificationStore?.save(taskId, pushNotificationConfig);
     return params;
   }
-  async getTaskPushNotificationConfig(params, _context) {
+  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);
     }
@@ -853,11 +1066,11 @@ var DefaultRequestHandler = class {
     }
     return { taskId: params.id, pushNotificationConfig: config };
   }
-  async listTaskPushNotificationConfigs(params, _context) {
+  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);
     }
@@ -867,22 +1080,22 @@ var DefaultRequestHandler = class {
       pushNotificationConfig: config
     }));
   }
-  async deleteTaskPushNotificationConfig(params, _context) {
+  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, _context) {
+  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);
     }
@@ -911,7 +1124,7 @@ var DefaultRequestHandler = class {
       eventQueue.stop();
     }
   }
-  async _sendPushNotificationIfNeeded(event) {
+  async _sendPushNotificationIfNeeded(event, context) {
     if (!this.agentCard.capabilities.pushNotifications) {
       return;
     }
@@ -926,7 +1139,7 @@ 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;
@@ -987,7 +1200,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) {