@mailmodo/a2a 0.3.5 → 0.3.7

package/dist/server/express/index.js

@@ -30,7 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var express_exports = {};
 __export(express_exports, {
   A2AExpressApp: () => A2AExpressApp,
-  UserBuilder: () => UserBuilder
+  UserBuilder: () => UserBuilder,
+  agentCardHandler: () => agentCardHandler,
+  jsonRpcHandler: () => jsonRpcHandler,
+  restHandler: () => restHandler
 });
 module.exports = __toCommonJS(express_exports);
 
@@ -103,7 +106,7 @@ var A2AError = class _A2AError extends Error {
   }
 };
 
-// src/server/transports/jsonrpc_transport_handler.ts
+// src/server/transports/jsonrpc/jsonrpc_transport_handler.ts
 var JsonRpcTransportHandler = class {
   requestHandler;
   constructor(requestHandler) {
@@ -262,6 +265,41 @@ var JsonRpcTransportHandler = 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;
@@ -281,25 +319,10 @@ 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);
   }
 };
 
-// src/server/utils.ts
-function getRequestedExtensions(values) {
-  if (!values) {
-    return /* @__PURE__ */ new Set();
-  }
-  return new Set(
-    values.split(",").map((ext) => ext.trim()).filter((ext) => ext.length > 0)
-  );
-}
-
 // src/server/authentication/user.ts
 var UnauthenticatedUser = class {
   get isAuthenticated() {
@@ -310,6 +333,26 @@ var UnauthenticatedUser = class {
   }
 };
 
+// src/sse_utils.ts
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive",
+  "X-Accel-Buffering": "no"
+  // Disable buffering in nginx
+};
+function formatSSEEvent(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+function formatSSEErrorEvent(error) {
+  return `event: error
+data: ${JSON.stringify(error)}
+
+`;
+}
+
 // src/server/express/json_rpc_handler.ts
 function jsonRpcHandler(options) {
   const jsonRpcTransportHandler = new JsonRpcTransportHandler(options.requestHandler);
@@ -319,7 +362,7 @@ function jsonRpcHandler(options) {
     try {
       const user = await options.userBuilder(req);
       const context = new ServerCallContext(
-        getRequestedExtensions(req.header(HTTP_EXTENSION_HEADER)),
+        Extensions.parseServiceParameter(req.header(HTTP_EXTENSION_HEADER)),
         user ?? new UnauthenticatedUser()
       );
       const rpcResponseOrStream = await jsonRpcTransportHandler.handle(req.body, context);
@@ -328,17 +371,13 @@ function jsonRpcHandler(options) {
       }
       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");
+        Object.entries(SSE_HEADERS).forEach(([key, value]) => {
+          res.setHeader(key, value);
+        });
         res.flushHeaders();
         try {
           for await (const event of stream) {
-            res.write(`id: ${(/* @__PURE__ */ new Date()).getTime()}
-`);
-            res.write(`data: ${JSON.stringify(event)}
-
-`);
+            res.write(formatSSEEvent(event));
           }
         } catch (streamError) {
           console.error(`Error during SSE streaming (request ${req.body?.id}):`, streamError);
@@ -359,13 +398,7 @@ function jsonRpcHandler(options) {
           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)}
-
-`);
+            res.write(formatSSEErrorEvent(errorResponse));
           }
         } finally {
           if (!res.writableEnded) {
@@ -425,14 +458,14 @@ function agentCardHandler(options) {
 
 // src/server/express/common.ts
 var UserBuilder = {
-  NoAuthentication: () => Promise.resolve(new UnauthenticatedUser())
+  noAuthentication: () => Promise.resolve(new UnauthenticatedUser())
 };
 
 // src/server/express/a2a_express_app.ts
 var A2AExpressApp = class {
   requestHandler;
   userBuilder;
-  constructor(requestHandler, userBuilder = UserBuilder.NoAuthentication) {
+  constructor(requestHandler, userBuilder = UserBuilder.noAuthentication) {
     this.requestHandler = requestHandler;
     this.userBuilder = userBuilder;
   }
@@ -461,8 +494,501 @@ var A2AExpressApp = class {
     return app;
   }
 };
+
+// src/server/express/rest_handler.ts
+var import_express4 = __toESM(require("express"));
+
+// src/errors.ts
+var A2A_ERROR_CODE = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  TASK_NOT_FOUND: -32001,
+  TASK_NOT_CANCELABLE: -32002,
+  PUSH_NOTIFICATION_NOT_SUPPORTED: -32003,
+  UNSUPPORTED_OPERATION: -32004,
+  CONTENT_TYPE_NOT_SUPPORTED: -32005,
+  INVALID_AGENT_RESPONSE: -32006,
+  AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED: -32007
+};
+
+// src/server/transports/rest/rest_transport_handler.ts
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501
+};
+function mapErrorToStatus(errorCode) {
+  switch (errorCode) {
+    case A2A_ERROR_CODE.PARSE_ERROR:
+    case A2A_ERROR_CODE.INVALID_REQUEST:
+    case A2A_ERROR_CODE.INVALID_PARAMS:
+      return HTTP_STATUS.BAD_REQUEST;
+    case A2A_ERROR_CODE.METHOD_NOT_FOUND:
+    case A2A_ERROR_CODE.TASK_NOT_FOUND:
+      return HTTP_STATUS.NOT_FOUND;
+    case A2A_ERROR_CODE.TASK_NOT_CANCELABLE:
+      return HTTP_STATUS.CONFLICT;
+    case A2A_ERROR_CODE.PUSH_NOTIFICATION_NOT_SUPPORTED:
+    case A2A_ERROR_CODE.UNSUPPORTED_OPERATION:
+      return HTTP_STATUS.BAD_REQUEST;
+    default:
+      return HTTP_STATUS.INTERNAL_SERVER_ERROR;
+  }
+}
+function toHTTPError(error) {
+  const errorObject = {
+    code: error.code,
+    message: error.message
+  };
+  if (error.data !== void 0) {
+    errorObject.data = error.data;
+  }
+  return errorObject;
+}
+var RestTransportHandler = class _RestTransportHandler {
+  requestHandler;
+  constructor(requestHandler) {
+    this.requestHandler = requestHandler;
+  }
+  // ==========================================================================
+  // Public API Methods
+  // ==========================================================================
+  /**
+   * Gets the agent card (for capability checks).
+   */
+  async getAgentCard() {
+    return this.requestHandler.getAgentCard();
+  }
+  /**
+   * Gets the authenticated extended agent card.
+   */
+  async getAuthenticatedExtendedAgentCard(context) {
+    return this.requestHandler.getAuthenticatedExtendedAgentCard(context);
+  }
+  /**
+   * Sends a message to the agent.
+   * Accepts both snake_case and camelCase input, returns camelCase.
+   */
+  async sendMessage(params, context) {
+    const normalized = this.normalizeMessageParams(params);
+    return this.requestHandler.sendMessage(normalized, context);
+  }
+  /**
+   * Sends a message with streaming response.
+   * Accepts both snake_case and camelCase input, returns camelCase stream.
+   * @throws {A2AError} UnsupportedOperation if streaming not supported
+   */
+  async sendMessageStream(params, context) {
+    await this.requireCapability("streaming");
+    const normalized = this.normalizeMessageParams(params);
+    return this.requestHandler.sendMessageStream(normalized, context);
+  }
+  /**
+   * Gets a task by ID.
+   * Validates historyLength parameter if provided.
+   */
+  async getTask(taskId, context, historyLength) {
+    const params = { id: taskId };
+    if (historyLength !== void 0) {
+      params.historyLength = this.parseHistoryLength(historyLength);
+    }
+    return this.requestHandler.getTask(params, context);
+  }
+  /**
+   * Cancels a task.
+   */
+  async cancelTask(taskId, context) {
+    const params = { id: taskId };
+    return this.requestHandler.cancelTask(params, context);
+  }
+  /**
+   * Resubscribes to task updates.
+   * Returns camelCase stream of task updates.
+   * @throws {A2AError} UnsupportedOperation if streaming not supported
+   */
+  async resubscribe(taskId, context) {
+    await this.requireCapability("streaming");
+    const params = { id: taskId };
+    return this.requestHandler.resubscribe(params, context);
+  }
+  /**
+   * Sets a push notification configuration.
+   * Accepts both snake_case and camelCase input, returns camelCase.
+   * @throws {A2AError} PushNotificationNotSupported if push notifications not supported
+   */
+  async setTaskPushNotificationConfig(config, context) {
+    await this.requireCapability("pushNotifications");
+    const normalized = this.normalizeTaskPushNotificationConfig(config);
+    return this.requestHandler.setTaskPushNotificationConfig(normalized, context);
+  }
+  /**
+   * Lists all push notification configurations for a task.
+   */
+  async listTaskPushNotificationConfigs(taskId, context) {
+    return this.requestHandler.listTaskPushNotificationConfigs({ id: taskId }, context);
+  }
+  /**
+   * Gets a specific push notification configuration.
+   */
+  async getTaskPushNotificationConfig(taskId, configId, context) {
+    return this.requestHandler.getTaskPushNotificationConfig(
+      { id: taskId, pushNotificationConfigId: configId },
+      context
+    );
+  }
+  /**
+   * Deletes a push notification configuration.
+   */
+  async deleteTaskPushNotificationConfig(taskId, configId, context) {
+    await this.requestHandler.deleteTaskPushNotificationConfig(
+      { id: taskId, pushNotificationConfigId: configId },
+      context
+    );
+  }
+  // ==========================================================================
+  // Private Transformation Methods
+  // ==========================================================================
+  // All type conversion between REST (snake_case) and internal (camelCase) formats
+  /**
+   * Validates and normalizes message parameters.
+   * Accepts both snake_case and camelCase input.
+   * @throws {A2AError} InvalidParams if message is missing or conversion fails
+   */
+  normalizeMessageParams(input) {
+    if (!input.message) {
+      throw A2AError.invalidParams("message is required");
+    }
+    try {
+      return this.normalizeMessageSendParams(input);
+    } catch (error) {
+      if (error instanceof A2AError) throw error;
+      throw A2AError.invalidParams(
+        error instanceof Error ? error.message : "Invalid message parameters"
+      );
+    }
+  }
+  /**
+   * Static map of capability to error for missing capabilities.
+   */
+  static CAPABILITY_ERRORS = {
+    streaming: () => A2AError.unsupportedOperation("Agent does not support streaming"),
+    pushNotifications: () => A2AError.pushNotificationNotSupported()
+  };
+  /**
+   * Validates that the agent supports a required capability.
+   * @throws {A2AError} UnsupportedOperation for streaming, PushNotificationNotSupported for push notifications
+   */
+  async requireCapability(capability) {
+    const agentCard = await this.getAgentCard();
+    if (!agentCard.capabilities?.[capability]) {
+      throw _RestTransportHandler.CAPABILITY_ERRORS[capability]();
+    }
+  }
+  /**
+   * Parses and validates historyLength query parameter.
+   */
+  parseHistoryLength(value) {
+    if (value === void 0 || value === null) {
+      throw A2AError.invalidParams("historyLength is required");
+    }
+    const parsed = parseInt(String(value), 10);
+    if (isNaN(parsed)) {
+      throw A2AError.invalidParams("historyLength must be a valid integer");
+    }
+    if (parsed < 0) {
+      throw A2AError.invalidParams("historyLength must be non-negative");
+    }
+    return parsed;
+  }
+  /**
+   * Normalizes Part input - accepts both snake_case and camelCase for file mimeType.
+   */
+  normalizePart(part) {
+    if (part.kind === "text") return { kind: "text", text: part.text };
+    if (part.kind === "file") {
+      const file = this.normalizeFile(part.file);
+      return { kind: "file", file, metadata: part.metadata };
+    }
+    return { kind: "data", data: part.data, metadata: part.metadata };
+  }
+  /**
+   * Normalizes File input - accepts both snake_case (mime_type) and camelCase (mimeType).
+   */
+  normalizeFile(f) {
+    const file = f;
+    const mimeType = file.mimeType ?? file.mime_type;
+    if ("bytes" in file) {
+      return { bytes: file.bytes, mimeType, name: file.name };
+    }
+    return { uri: file.uri, mimeType, name: file.name };
+  }
+  /**
+   * Normalizes Message input - accepts both snake_case and camelCase.
+   */
+  normalizeMessage(input) {
+    const m = input;
+    const messageId = m.messageId ?? m.message_id;
+    if (!messageId) {
+      throw A2AError.invalidParams("message.messageId is required");
+    }
+    if (!m.parts || !Array.isArray(m.parts)) {
+      throw A2AError.invalidParams("message.parts must be an array");
+    }
+    return {
+      contextId: m.contextId ?? m.context_id,
+      extensions: m.extensions,
+      kind: "message",
+      messageId,
+      metadata: m.metadata,
+      parts: m.parts.map((p) => this.normalizePart(p)),
+      referenceTaskIds: m.referenceTaskIds ?? m.reference_task_ids,
+      role: m.role,
+      taskId: m.taskId ?? m.task_id
+    };
+  }
+  /**
+   * Normalizes MessageSendParams - accepts both snake_case and camelCase.
+   */
+  normalizeMessageSendParams(input) {
+    const p = input;
+    const config = p.configuration;
+    return {
+      configuration: config ? {
+        acceptedOutputModes: config.acceptedOutputModes ?? config.accepted_output_modes,
+        blocking: config.blocking,
+        historyLength: config.historyLength ?? config.history_length
+      } : void 0,
+      message: this.normalizeMessage(p.message),
+      metadata: p.metadata
+    };
+  }
+  /**
+   * Normalizes TaskPushNotificationConfig - accepts both snake_case and camelCase.
+   */
+  normalizeTaskPushNotificationConfig(input) {
+    const c = input;
+    const taskId = c.taskId ?? c.task_id;
+    if (!taskId) {
+      throw A2AError.invalidParams("taskId is required");
+    }
+    const pnConfig = c.pushNotificationConfig ?? c.push_notification_config;
+    if (!pnConfig) {
+      throw A2AError.invalidParams("pushNotificationConfig is required");
+    }
+    return {
+      pushNotificationConfig: pnConfig,
+      taskId
+    };
+  }
+};
+
+// src/server/express/rest_handler.ts
+var restErrorHandler = (err, _req, res, next) => {
+  if (err instanceof SyntaxError && "body" in err) {
+    const a2aError = A2AError.parseError("Invalid JSON payload.");
+    return res.status(400).json(toHTTPError(a2aError));
+  }
+  next(err);
+};
+function restHandler(options) {
+  const router = import_express4.default.Router();
+  const restTransportHandler = new RestTransportHandler(options.requestHandler);
+  router.use(import_express4.default.json(), restErrorHandler);
+  const buildContext = async (req) => {
+    const user = await options.userBuilder(req);
+    return new ServerCallContext(
+      Extensions.parseServiceParameter(req.header(HTTP_EXTENSION_HEADER)),
+      user
+    );
+  };
+  const setExtensionsHeader = (res, context) => {
+    if (context.activatedExtensions) {
+      res.setHeader(HTTP_EXTENSION_HEADER, Array.from(context.activatedExtensions));
+    }
+  };
+  const sendResponse = (res, statusCode, context, body) => {
+    setExtensionsHeader(res, context);
+    res.status(statusCode);
+    if (statusCode === HTTP_STATUS.NO_CONTENT) {
+      res.end();
+    } else {
+      res.json(body);
+    }
+  };
+  const sendStreamResponse = async (res, stream, context) => {
+    const iterator = stream[Symbol.asyncIterator]();
+    let firstResult;
+    try {
+      firstResult = await iterator.next();
+    } catch (error) {
+      const a2aError = error instanceof A2AError ? error : A2AError.internalError(error instanceof Error ? error.message : "Streaming error");
+      const statusCode = mapErrorToStatus(a2aError.code);
+      sendResponse(res, statusCode, context, toHTTPError(a2aError));
+      return;
+    }
+    Object.entries(SSE_HEADERS).forEach(([key, value]) => {
+      res.setHeader(key, value);
+    });
+    setExtensionsHeader(res, context);
+    res.flushHeaders();
+    try {
+      if (!firstResult.done) {
+        res.write(formatSSEEvent(firstResult.value));
+      }
+      for await (const event of { [Symbol.asyncIterator]: () => iterator }) {
+        res.write(formatSSEEvent(event));
+      }
+    } catch (streamError) {
+      console.error("SSE streaming error:", streamError);
+      const a2aError = streamError instanceof A2AError ? streamError : A2AError.internalError(
+        streamError instanceof Error ? streamError.message : "Streaming error"
+      );
+      if (!res.writableEnded) {
+        res.write(formatSSEErrorEvent(toHTTPError(a2aError)));
+      }
+    } finally {
+      if (!res.writableEnded) {
+        res.end();
+      }
+    }
+  };
+  const handleError = (res, error) => {
+    if (res.headersSent) {
+      if (!res.writableEnded) {
+        res.end();
+      }
+      return;
+    }
+    const a2aError = error instanceof A2AError ? error : A2AError.internalError(error instanceof Error ? error.message : "Internal server error");
+    const statusCode = mapErrorToStatus(a2aError.code);
+    res.status(statusCode).json(toHTTPError(a2aError));
+  };
+  const asyncHandler = (handler) => {
+    return async (req, res) => {
+      try {
+        await handler(req, res);
+      } catch (error) {
+        handleError(res, error);
+      }
+    };
+  };
+  router.get(
+    "/v1/card",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const result = await restTransportHandler.getAuthenticatedExtendedAgentCard(context);
+      sendResponse(res, HTTP_STATUS.OK, context, result);
+    })
+  );
+  router.post(
+    "/v1/message\\:send",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const result = await restTransportHandler.sendMessage(req.body, context);
+      sendResponse(res, HTTP_STATUS.CREATED, context, result);
+    })
+  );
+  router.post(
+    "/v1/message\\:stream",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const stream = await restTransportHandler.sendMessageStream(req.body, context);
+      await sendStreamResponse(res, stream, context);
+    })
+  );
+  router.get(
+    "/v1/tasks/:taskId",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const result = await restTransportHandler.getTask(
+        req.params.taskId,
+        context,
+        req.query.historyLength
+      );
+      sendResponse(res, HTTP_STATUS.OK, context, result);
+    })
+  );
+  router.post(
+    "/v1/tasks/:taskId\\:cancel",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const result = await restTransportHandler.cancelTask(req.params.taskId, context);
+      sendResponse(res, HTTP_STATUS.ACCEPTED, context, result);
+    })
+  );
+  router.post(
+    "/v1/tasks/:taskId\\:subscribe",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const stream = await restTransportHandler.resubscribe(req.params.taskId, context);
+      await sendStreamResponse(res, stream, context);
+    })
+  );
+  router.post(
+    "/v1/tasks/:taskId/pushNotificationConfigs",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const config = {
+        ...req.body,
+        taskId: req.params.taskId,
+        task_id: req.params.taskId
+      };
+      const result = await restTransportHandler.setTaskPushNotificationConfig(config, context);
+      sendResponse(res, HTTP_STATUS.CREATED, context, result);
+    })
+  );
+  router.get(
+    "/v1/tasks/:taskId/pushNotificationConfigs",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const result = await restTransportHandler.listTaskPushNotificationConfigs(
+        req.params.taskId,
+        context
+      );
+      sendResponse(res, HTTP_STATUS.OK, context, result);
+    })
+  );
+  router.get(
+    "/v1/tasks/:taskId/pushNotificationConfigs/:configId",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const result = await restTransportHandler.getTaskPushNotificationConfig(
+        req.params.taskId,
+        req.params.configId,
+        context
+      );
+      sendResponse(res, HTTP_STATUS.OK, context, result);
+    })
+  );
+  router.delete(
+    "/v1/tasks/:taskId/pushNotificationConfigs/:configId",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      await restTransportHandler.deleteTaskPushNotificationConfig(
+        req.params.taskId,
+        req.params.configId,
+        context
+      );
+      sendResponse(res, HTTP_STATUS.NO_CONTENT, context);
+    })
+  );
+  return router;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   A2AExpressApp,
-  UserBuilder
+  UserBuilder,
+  agentCardHandler,
+  jsonRpcHandler,
+  restHandler
 });