@mailmodo/a2a 0.3.3 → 0.3.7

package/dist/a2a_request_handler-1Isk3l-0.d.mts

@@ -0,0 +1,49 @@
+import { E as Extensions, ae as AgentCard, x as MessageSendParams, F as Message, ay as Task, aQ as TaskStatusUpdateEvent, aS as TaskArtifactUpdateEvent, X as TaskQueryParams, Z as TaskIdParams, $ as TaskPushNotificationConfig, a3 as GetTaskPushNotificationConfigParams, a7 as ListTaskPushNotificationConfigParams, a9 as DeleteTaskPushNotificationConfigParams } from './extensions-DvruCIzw.mjs';
+
+/**
+ * Represents a user accessing A2A server.
+ */
+interface User {
+    /**
+     * Indicates whether the user is authenticated.
+     */
+    get isAuthenticated(): boolean;
+    /**
+     * A unique name (identifier) for the user.
+     */
+    get userName(): string;
+}
+/**
+ * An implementation of {@link User} representing an unauthenticated user.
+ */
+declare class UnauthenticatedUser implements User {
+    get isAuthenticated(): boolean;
+    get userName(): string;
+}
+
+declare class ServerCallContext {
+    private readonly _requestedExtensions?;
+    private readonly _user?;
+    private _activatedExtensions?;
+    constructor(requestedExtensions?: Extensions, user?: User);
+    get user(): User | undefined;
+    get activatedExtensions(): Extensions | undefined;
+    get requestedExtensions(): Extensions | undefined;
+    addActivatedExtension(uri: string): void;
+}
+
+interface A2ARequestHandler {
+    getAgentCard(): Promise<AgentCard>;
+    getAuthenticatedExtendedAgentCard(context?: ServerCallContext): Promise<AgentCard>;
+    sendMessage(params: MessageSendParams, context?: ServerCallContext): Promise<Message | Task>;
+    sendMessageStream(params: MessageSendParams, context?: ServerCallContext): AsyncGenerator<Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
+    getTask(params: TaskQueryParams, context?: ServerCallContext): Promise<Task>;
+    cancelTask(params: TaskIdParams, context?: ServerCallContext): Promise<Task>;
+    setTaskPushNotificationConfig(params: TaskPushNotificationConfig, context?: ServerCallContext): Promise<TaskPushNotificationConfig>;
+    getTaskPushNotificationConfig(params: TaskIdParams | GetTaskPushNotificationConfigParams, context?: ServerCallContext): Promise<TaskPushNotificationConfig>;
+    listTaskPushNotificationConfigs(params: ListTaskPushNotificationConfigParams, context?: ServerCallContext): Promise<TaskPushNotificationConfig[]>;
+    deleteTaskPushNotificationConfig(params: DeleteTaskPushNotificationConfigParams, context?: ServerCallContext): Promise<void>;
+    resubscribe(params: TaskIdParams, context?: ServerCallContext): AsyncGenerator<Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
+}
+
+export { type A2ARequestHandler as A, ServerCallContext as S, type User as U, UnauthenticatedUser as a };

package/dist/a2a_request_handler-BuP9LgXH.d.ts

@@ -0,0 +1,49 @@
+import { E as Extensions, ae as AgentCard, x as MessageSendParams, F as Message, ay as Task, aQ as TaskStatusUpdateEvent, aS as TaskArtifactUpdateEvent, X as TaskQueryParams, Z as TaskIdParams, $ as TaskPushNotificationConfig, a3 as GetTaskPushNotificationConfigParams, a7 as ListTaskPushNotificationConfigParams, a9 as DeleteTaskPushNotificationConfigParams } from './extensions-DvruCIzw.js';
+
+/**
+ * Represents a user accessing A2A server.
+ */
+interface User {
+    /**
+     * Indicates whether the user is authenticated.
+     */
+    get isAuthenticated(): boolean;
+    /**
+     * A unique name (identifier) for the user.
+     */
+    get userName(): string;
+}
+/**
+ * An implementation of {@link User} representing an unauthenticated user.
+ */
+declare class UnauthenticatedUser implements User {
+    get isAuthenticated(): boolean;
+    get userName(): string;
+}
+
+declare class ServerCallContext {
+    private readonly _requestedExtensions?;
+    private readonly _user?;
+    private _activatedExtensions?;
+    constructor(requestedExtensions?: Extensions, user?: User);
+    get user(): User | undefined;
+    get activatedExtensions(): Extensions | undefined;
+    get requestedExtensions(): Extensions | undefined;
+    addActivatedExtension(uri: string): void;
+}
+
+interface A2ARequestHandler {
+    getAgentCard(): Promise<AgentCard>;
+    getAuthenticatedExtendedAgentCard(context?: ServerCallContext): Promise<AgentCard>;
+    sendMessage(params: MessageSendParams, context?: ServerCallContext): Promise<Message | Task>;
+    sendMessageStream(params: MessageSendParams, context?: ServerCallContext): AsyncGenerator<Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
+    getTask(params: TaskQueryParams, context?: ServerCallContext): Promise<Task>;
+    cancelTask(params: TaskIdParams, context?: ServerCallContext): Promise<Task>;
+    setTaskPushNotificationConfig(params: TaskPushNotificationConfig, context?: ServerCallContext): Promise<TaskPushNotificationConfig>;
+    getTaskPushNotificationConfig(params: TaskIdParams | GetTaskPushNotificationConfigParams, context?: ServerCallContext): Promise<TaskPushNotificationConfig>;
+    listTaskPushNotificationConfigs(params: ListTaskPushNotificationConfigParams, context?: ServerCallContext): Promise<TaskPushNotificationConfig[]>;
+    deleteTaskPushNotificationConfig(params: DeleteTaskPushNotificationConfigParams, context?: ServerCallContext): Promise<void>;
+    resubscribe(params: TaskIdParams, context?: ServerCallContext): AsyncGenerator<Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
+}
+
+export { type A2ARequestHandler as A, ServerCallContext as S, type User as U, UnauthenticatedUser as a };

package/dist/chunk-7JFJW6P6.mjs

@@ -0,0 +1,38 @@
+// 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(",");
+  }
+};
+
+export {
+  Extensions
+};

package/dist/chunk-AZGEDUZX.mjs

@@ -0,0 +1,261 @@
+import {
+  Extensions
+} from "./chunk-7JFJW6P6.mjs";
+
+// 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}`);
+  }
+  static authenticatedExtendedCardNotConfigured() {
+    return new _A2AError(-32007, `Extended card not configured.`);
+  }
+};
+
+// src/server/context.ts
+var ServerCallContext = class {
+  _requestedExtensions;
+  _user;
+  _activatedExtensions;
+  constructor(requestedExtensions, user) {
+    this._requestedExtensions = requestedExtensions;
+    this._user = user;
+  }
+  get user() {
+    return this._user;
+  }
+  get activatedExtensions() {
+    return this._activatedExtensions;
+  }
+  get requestedExtensions() {
+    return this._requestedExtensions;
+  }
+  addActivatedExtension(uri) {
+    this._activatedExtensions = Extensions.createFrom(this._activatedExtensions, uri);
+  }
+};
+
+// src/server/transports/jsonrpc/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, context) {
+    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 (!this.isRequestValid(rpcRequest)) {
+        throw A2AError.invalidRequest("Invalid JSON-RPC Request.");
+      }
+    } catch (error) {
+      const a2aError = error instanceof A2AError ? error : A2AError.parseError(
+        error instanceof SyntaxError && error.message || "Failed to parse JSON request."
+      );
+      return {
+        jsonrpc: "2.0",
+        id: rpcRequest?.id !== void 0 ? rpcRequest.id : null,
+        error: a2aError.toJSONRPCError()
+      };
+    }
+    const { method, id: requestId = null } = rpcRequest;
+    try {
+      if (method !== "agent/getAuthenticatedExtendedCard" && !this.paramsAreValid(rpcRequest.params)) {
+        throw A2AError.invalidParams(`Invalid method parameters.`);
+      }
+      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.`);
+        }
+        const agentEventStream = method === "message/stream" ? this.requestHandler.sendMessageStream(params, context) : this.requestHandler.resubscribe(params, context);
+        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(rpcRequest.params, context);
+            break;
+          case "tasks/get":
+            result = await this.requestHandler.getTask(rpcRequest.params, context);
+            break;
+          case "tasks/cancel":
+            result = await this.requestHandler.cancelTask(rpcRequest.params, context);
+            break;
+          case "tasks/pushNotificationConfig/set":
+            result = await this.requestHandler.setTaskPushNotificationConfig(
+              rpcRequest.params,
+              context
+            );
+            break;
+          case "tasks/pushNotificationConfig/get":
+            result = await this.requestHandler.getTaskPushNotificationConfig(
+              rpcRequest.params,
+              context
+            );
+            break;
+          case "tasks/pushNotificationConfig/delete":
+            await this.requestHandler.deleteTaskPushNotificationConfig(rpcRequest.params, context);
+            result = null;
+            break;
+          case "tasks/pushNotificationConfig/list":
+            result = await this.requestHandler.listTaskPushNotificationConfigs(
+              rpcRequest.params,
+              context
+            );
+            break;
+          case "agent/getAuthenticatedExtendedCard":
+            result = await this.requestHandler.getAuthenticatedExtendedAgentCard(context);
+            break;
+          default:
+            throw A2AError.methodNotFound(method);
+        }
+        return {
+          jsonrpc: "2.0",
+          id: requestId,
+          result
+        };
+      }
+    } catch (error) {
+      let a2aError;
+      if (error instanceof A2AError) {
+        a2aError = error;
+      } else {
+        a2aError = A2AError.internalError(
+          error instanceof Error && error.message || "An unexpected error occurred."
+        );
+      }
+      return {
+        jsonrpc: "2.0",
+        id: requestId,
+        error: a2aError.toJSONRPCError()
+      };
+    }
+  }
+  // Validates the basic structure of a JSON-RPC request
+  isRequestValid(rpcRequest) {
+    if (rpcRequest.jsonrpc !== "2.0") {
+      return false;
+    }
+    if ("id" in rpcRequest) {
+      const id = rpcRequest.id;
+      const isString = typeof id === "string";
+      const isInteger = typeof id === "number" && Number.isInteger(id);
+      const isNull = id === null;
+      if (!isString && !isInteger && !isNull) {
+        return false;
+      }
+    }
+    if (!rpcRequest.method || typeof rpcRequest.method !== "string") {
+      return false;
+    }
+    return true;
+  }
+  // Validates that params is an object with non-empty string keys
+  paramsAreValid(params) {
+    if (typeof params !== "object" || params === null || Array.isArray(params)) {
+      return false;
+    }
+    for (const key of Object.keys(params)) {
+      if (key === "") {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/server/authentication/user.ts
+var UnauthenticatedUser = class {
+  get isAuthenticated() {
+    return false;
+  }
+  get userName() {
+    return "";
+  }
+};
+
+export {
+  A2AError,
+  ServerCallContext,
+  JsonRpcTransportHandler,
+  UnauthenticatedUser
+};

package/dist/chunk-BNBEZNW7.mjs

@@ -0,0 +1,122 @@
+// 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
+};
+var TaskNotFoundError = class extends Error {
+  constructor(message) {
+    super(message ?? "Task not found");
+    this.name = "TaskNotFoundError";
+  }
+};
+var TaskNotCancelableError = class extends Error {
+  constructor(message) {
+    super(message ?? "Task cannot be canceled");
+    this.name = "TaskNotCancelableError";
+  }
+};
+var PushNotificationNotSupportedError = class extends Error {
+  constructor(message) {
+    super(message ?? "Push Notification is not supported");
+    this.name = "PushNotificationNotSupportedError";
+  }
+};
+var UnsupportedOperationError = class extends Error {
+  constructor(message) {
+    super(message ?? "This operation is not supported");
+    this.name = "UnsupportedOperationError";
+  }
+};
+var ContentTypeNotSupportedError = class extends Error {
+  constructor(message) {
+    super(message ?? "Incompatible content types");
+    this.name = "ContentTypeNotSupportedError";
+  }
+};
+var InvalidAgentResponseError = class extends Error {
+  constructor(message) {
+    super(message ?? "Invalid agent response type");
+    this.name = "InvalidAgentResponseError";
+  }
+};
+var AuthenticatedExtendedCardNotConfiguredError = class extends Error {
+  constructor(message) {
+    super(message ?? "Authenticated Extended Card not configured");
+    this.name = "AuthenticatedExtendedCardNotConfiguredError";
+  }
+};
+
+// 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)}
+
+`;
+}
+async function* parseSseStream(response) {
+  if (!response.body) {
+    throw new Error("SSE response body is undefined. Cannot read stream.");
+  }
+  let buffer = "";
+  let eventType = "message";
+  let eventData = "";
+  for await (const value of response.body.pipeThrough(new TextDecoderStream())) {
+    buffer += value;
+    let lineEndIndex;
+    while ((lineEndIndex = buffer.indexOf("\n")) >= 0) {
+      const line = buffer.substring(0, lineEndIndex).trim();
+      buffer = buffer.substring(lineEndIndex + 1);
+      if (line === "") {
+        if (eventData) {
+          yield { type: eventType, data: eventData };
+          eventData = "";
+          eventType = "message";
+        }
+      } else if (line.startsWith("event:")) {
+        eventType = line.substring("event:".length).trim();
+      } else if (line.startsWith("data:")) {
+        eventData = line.substring("data:".length).trim();
+      }
+    }
+  }
+  if (eventData) {
+    yield { type: eventType, data: eventData };
+  }
+}
+
+export {
+  A2A_ERROR_CODE,
+  TaskNotFoundError,
+  TaskNotCancelableError,
+  PushNotificationNotSupportedError,
+  UnsupportedOperationError,
+  ContentTypeNotSupportedError,
+  InvalidAgentResponseError,
+  AuthenticatedExtendedCardNotConfiguredError,
+  SSE_HEADERS,
+  formatSSEEvent,
+  formatSSEErrorEvent,
+  parseSseStream
+};

package/dist/chunk-PHP7LM4Y.mjs

@@ -0,0 +1,8 @@
+// src/constants.ts
+var AGENT_CARD_PATH = ".well-known/agent-card.json";
+var HTTP_EXTENSION_HEADER = "X-A2A-Extensions";
+
+export {
+  AGENT_CARD_PATH,
+  HTTP_EXTENSION_HEADER
+};