@a2a-js/sdk 0.3.5 → 0.3.7

package/dist/a2a_request_handler-B3LxMq3P.d.cts

@@ -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.cjs';
+
+/**
+ * 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-3QDLXHKS.js

@@ -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
+};

package/dist/{chunk-SY3G7ITG.js → chunk-LTPINR5K.js}

@@ -1,3 +1,7 @@
+import {
+  Extensions
+} from "./chunk-ZX6KNMCP.js";
+
 // src/server/error.ts
 var A2AError = class _A2AError extends Error {
   code;
@@ -32,10 +36,7 @@ var A2AError = class _A2AError extends Error {
     return new _A2AError(-32600, message, data);
   }
   static methodNotFound(method) {
-    return new _A2AError(
-      -32601,
-      `Method not found: ${method}`
-    );
+    return new _A2AError(-32601, `Method not found: ${method}`);
   }
   static invalidParams(message, data) {
     return new _A2AError(-32602, message, data);
@@ -44,42 +45,46 @@ var A2AError = class _A2AError extends Error {
     return new _A2AError(-32603, message, data);
   }
   static taskNotFound(taskId) {
-    return new _A2AError(
-      -32001,
-      `Task not found: ${taskId}`,
-      void 0,
-      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
-    );
+    return new _A2AError(-32002, `Task not cancelable: ${taskId}`, void 0, taskId);
   }
   static pushNotificationNotSupported() {
-    return new _A2AError(
-      -32003,
-      "Push Notification is not supported"
-    );
+    return new _A2AError(-32003, "Push Notification is not supported");
   }
   static unsupportedOperation(operation) {
-    return new _A2AError(
-      -32004,
-      `Unsupported operation: ${operation}`
-    );
+    return new _A2AError(-32004, `Unsupported operation: ${operation}`);
   }
   static authenticatedExtendedCardNotConfigured() {
-    return new _A2AError(
-      -32007,
-      `Extended card not configured.`
-    );
+    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_transport_handler.ts
+// src/server/transports/jsonrpc/jsonrpc_transport_handler.ts
 var JsonRpcTransportHandler = class {
   requestHandler;
   constructor(requestHandler) {
@@ -90,7 +95,7 @@ var JsonRpcTransportHandler = class {
    * 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) {
+  async handle(requestBody, context) {
     let rpcRequest;
     try {
       if (typeof requestBody === "string") {
@@ -104,24 +109,18 @@ var JsonRpcTransportHandler = class {
         throw A2AError.invalidRequest("Invalid JSON-RPC Request.");
       }
     } catch (error) {
-      const a2aError = error instanceof A2AError ? error : A2AError.parseError(error.message || "Failed to parse JSON request.");
+      const a2aError = error instanceof A2AError ? error : A2AError.parseError(
+        error instanceof SyntaxError && error.message || "Failed to parse JSON request."
+      );
       return {
         jsonrpc: "2.0",
-        id: typeof rpcRequest?.id !== "undefined" ? rpcRequest.id : null,
+        id: rpcRequest?.id !== void 0 ? rpcRequest.id : null,
         error: a2aError.toJSONRPCError()
       };
     }
     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 (!this.paramsAreValid(rpcRequest.params)) {
+      if (method !== "agent/getAuthenticatedExtendedCard" && !this.paramsAreValid(rpcRequest.params)) {
         throw A2AError.invalidParams(`Invalid method parameters.`);
       }
       if (method === "message/stream" || method === "tasks/resubscribe") {
@@ -130,8 +129,8 @@ var JsonRpcTransportHandler = class {
         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() {
+        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 {
@@ -142,43 +141,50 @@ var JsonRpcTransportHandler = class {
               };
             }
           } catch (streamError) {
-            console.error(`Error in agent event stream for ${method} (request ${requestId}):`, 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);
+            result = await this.requestHandler.sendMessage(rpcRequest.params, context);
             break;
           case "tasks/get":
-            result = await this.requestHandler.getTask(rpcRequest.params);
+            result = await this.requestHandler.getTask(rpcRequest.params, context);
             break;
           case "tasks/cancel":
-            result = await this.requestHandler.cancelTask(rpcRequest.params);
+            result = await this.requestHandler.cancelTask(rpcRequest.params, context);
             break;
           case "tasks/pushNotificationConfig/set":
             result = await this.requestHandler.setTaskPushNotificationConfig(
-              rpcRequest.params
+              rpcRequest.params,
+              context
             );
             break;
           case "tasks/pushNotificationConfig/get":
             result = await this.requestHandler.getTaskPushNotificationConfig(
-              rpcRequest.params
+              rpcRequest.params,
+              context
             );
             break;
           case "tasks/pushNotificationConfig/delete":
-            await this.requestHandler.deleteTaskPushNotificationConfig(
-              rpcRequest.params
-            );
+            await this.requestHandler.deleteTaskPushNotificationConfig(rpcRequest.params, context);
             result = null;
             break;
           case "tasks/pushNotificationConfig/list":
             result = await this.requestHandler.listTaskPushNotificationConfigs(
-              rpcRequest.params
+              rpcRequest.params,
+              context
             );
             break;
+          case "agent/getAuthenticatedExtendedCard":
+            result = await this.requestHandler.getAuthenticatedExtendedAgentCard(context);
+            break;
           default:
             throw A2AError.methodNotFound(method);
         }
@@ -189,7 +195,14 @@ var JsonRpcTransportHandler = class {
         };
       }
     } catch (error) {
-      const a2aError = error instanceof A2AError ? error : A2AError.internalError(error.message || "An unexpected error occurred.");
+      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,
@@ -230,7 +243,19 @@ var JsonRpcTransportHandler = class {
   }
 };
 
+// src/server/authentication/user.ts
+var UnauthenticatedUser = class {
+  get isAuthenticated() {
+    return false;
+  }
+  get userName() {
+    return "";
+  }
+};
+
 export {
   A2AError,
-  JsonRpcTransportHandler
+  ServerCallContext,
+  JsonRpcTransportHandler,
+  UnauthenticatedUser
 };

package/dist/chunk-SJNAG4AL.js

@@ -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-ZX6KNMCP.js

@@ -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
+};