@a2a-js/sdk 0.3.0 → 0.3.2

package/README.md

@@ -55,6 +55,7 @@ const movieAgentCard: AgentCard = {
     organization: "A2A Agents",
     url: "https://example.com/a2a-agents", // Added provider URL
   },
+  protocolVersion: "0.3.0", // A2A protocol this agent supports.
   version: "0.0.2", // Incremented version
   capabilities: {
     streaming: true, // Supports streaming
@@ -247,7 +248,7 @@ expressApp.listen(PORT, () => {
     `[MyAgent] Server using new framework started on http://localhost:${PORT}`
   );
   console.log(
-    `[MyAgent] Agent Card: http://localhost:${PORT}/.well-known/agent.json`
+    `[MyAgent] Agent Card: http://localhost:${PORT}/.well-known/agent-card.json`
   );
   console.log("[MyAgent] Press Ctrl+C to stop the server");
 });

package/dist/a2a_request_handler-B5t-IxgA.d.ts

@@ -0,0 +1,17 @@
+import { ac as AgentCard, w as MessageSendParams, B as Message, aw as Task, aO as TaskStatusUpdateEvent, aQ as TaskArtifactUpdateEvent, V as TaskQueryParams, X as TaskIdParams, Z as TaskPushNotificationConfig, a1 as GetTaskPushNotificationConfigParams, a5 as ListTaskPushNotificationConfigParams, a7 as DeleteTaskPushNotificationConfigParams } from './types-DNKcmF0f.js';
+
+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 | GetTaskPushNotificationConfigParams): Promise<TaskPushNotificationConfig>;
+    listTaskPushNotificationConfigs(params: ListTaskPushNotificationConfigParams): Promise<TaskPushNotificationConfig[]>;
+    deleteTaskPushNotificationConfig(params: DeleteTaskPushNotificationConfigParams): Promise<void>;
+    resubscribe(params: TaskIdParams): AsyncGenerator<Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
+}
+
+export type { A2ARequestHandler as A };

package/dist/a2a_request_handler-DUvKWfix.d.cts

@@ -0,0 +1,17 @@
+import { ac as AgentCard, w as MessageSendParams, B as Message, aw as Task, aO as TaskStatusUpdateEvent, aQ as TaskArtifactUpdateEvent, V as TaskQueryParams, X as TaskIdParams, Z as TaskPushNotificationConfig, a1 as GetTaskPushNotificationConfigParams, a5 as ListTaskPushNotificationConfigParams, a7 as DeleteTaskPushNotificationConfigParams } from './types-DNKcmF0f.cjs';
+
+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 | GetTaskPushNotificationConfigParams): Promise<TaskPushNotificationConfig>;
+    listTaskPushNotificationConfigs(params: ListTaskPushNotificationConfigParams): Promise<TaskPushNotificationConfig[]>;
+    deleteTaskPushNotificationConfig(params: DeleteTaskPushNotificationConfigParams): Promise<void>;
+    resubscribe(params: TaskIdParams): AsyncGenerator<Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
+}
+
+export type { A2ARequestHandler as A };

package/dist/chunk-67JNQ6TZ.js

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

package/dist/chunk-JA52GYRU.js

@@ -0,0 +1,207 @@
+// 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/transports/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) {
+    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 (rpcRequest.jsonrpc !== "2.0" || !rpcRequest.method || typeof rpcRequest.method !== "string") {
+        throw A2AError.invalidRequest(
+          "Invalid JSON-RPC request structure."
+        );
+      }
+    } catch (error) {
+      const a2aError = error instanceof A2AError ? error : A2AError.parseError(error.message || "Failed to parse JSON request.");
+      return {
+        jsonrpc: "2.0",
+        id: typeof rpcRequest?.id !== "undefined" ? 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 (!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.`);
+        }
+        const agentEventStream = method === "message/stream" ? this.requestHandler.sendMessageStream(params) : this.requestHandler.resubscribe(params);
+        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);
+            break;
+          case "tasks/get":
+            result = await this.requestHandler.getTask(rpcRequest.params);
+            break;
+          case "tasks/cancel":
+            result = await this.requestHandler.cancelTask(rpcRequest.params);
+            break;
+          case "tasks/pushNotificationConfig/set":
+            result = await this.requestHandler.setTaskPushNotificationConfig(
+              rpcRequest.params
+            );
+            break;
+          case "tasks/pushNotificationConfig/get":
+            result = await this.requestHandler.getTaskPushNotificationConfig(
+              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:
+            throw A2AError.methodNotFound(method);
+        }
+        return {
+          jsonrpc: "2.0",
+          id: requestId,
+          result
+        };
+      }
+    } catch (error) {
+      const a2aError = error instanceof A2AError ? error : A2AError.internalError(error.message || "An unexpected error occurred.");
+      return {
+        jsonrpc: "2.0",
+        id: requestId,
+        error: a2aError.toJSONRPCError()
+      };
+    }
+  }
+};
+
+export {
+  A2AError,
+  JsonRpcTransportHandler
+};

package/dist/client/index.cjs

@@ -19,41 +19,44 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/client/index.ts
 var client_exports = {};
 __export(client_exports, {
-  A2AClient: () => A2AClient
+  A2AClient: () => A2AClient,
+  createAuthenticatingFetchWithRetry: () => createAuthenticatingFetchWithRetry
 });
 module.exports = __toCommonJS(client_exports);
 
+// src/constants.ts
+var AGENT_CARD_PATH = ".well-known/agent-card.json";
+
 // src/client/client.ts
-var A2AClient = class _A2AClient {
-  agentBaseUrl;
-  agentCardPath;
+var A2AClient = class {
   agentCardPromise;
-  static DEFAULT_AGENT_CARD_PATH = ".well-known/agent.json";
   requestIdCounter = 1;
   serviceEndpointUrl;
   // To be populated from AgentCard after fetching
+  fetchImpl;
   /**
    * Constructs an A2AClient instance.
    * It initiates fetching the agent card from the provided agent baseUrl.
-   * The Agent Card is fetched from a path relative to the agentBaseUrl, which defaults to '.well-known/agent.json'.
+   * The Agent Card is fetched from a path relative to the agentBaseUrl, which defaults to '.well-known/agent-card.json'.
    * The `url` field from the Agent Card will be used as the RPC service endpoint.
    * @param agentBaseUrl The base URL of the A2A agent (e.g., https://agent.example.com)
-   * @param agentCardPath path to the agent card, defaults to .well-known/agent.json
+   * @param options Optional. The options for the A2AClient including the fetch implementation, agent card path, and authentication handler.
    */
-  constructor(agentBaseUrl, agentCardPath = _A2AClient.DEFAULT_AGENT_CARD_PATH) {
-    this.agentBaseUrl = agentBaseUrl.replace(/\/$/, "");
-    this.agentCardPath = agentCardPath.replace(/^\//, "");
-    this.agentCardPromise = this._fetchAndCacheAgentCard();
+  constructor(agentBaseUrl, options) {
+    this.fetchImpl = options?.fetchImpl ?? fetch;
+    this.agentCardPromise = this._fetchAndCacheAgentCard(agentBaseUrl, options?.agentCardPath);
   }
   /**
    * Fetches the Agent Card from the agent's well-known URI and caches its service endpoint URL.
    * This method is called by the constructor.
+   * @param agentBaseUrl The base URL of the A2A agent (e.g., https://agent.example.com)
+   * @param agentCardPath path to the agent card, defaults to .well-known/agent-card.json
    * @returns A Promise that resolves to the AgentCard.
    */
-  async _fetchAndCacheAgentCard() {
-    const agentCardUrl = `${this.agentBaseUrl}/${this.agentCardPath}`;
+  async _fetchAndCacheAgentCard(agentBaseUrl, agentCardPath) {
     try {
-      const response = await fetch(agentCardUrl, {
+      const agentCardUrl = this.resolveAgentCardUrl(agentBaseUrl, agentCardPath);
+      const response = await this.fetchImpl(agentCardUrl, {
         headers: { "Accept": "application/json" }
       });
       if (!response.ok) {
@@ -66,7 +69,7 @@ var A2AClient = class _A2AClient {
       this.serviceEndpointUrl = agentCard.url;
       return agentCard;
     } catch (error) {
-      console.error("Error fetching or parsing Agent Card:");
+      console.error("Error fetching or parsing Agent Card:", error);
       throw error;
     }
   }
@@ -75,14 +78,14 @@ var A2AClient = class _A2AClient {
    * If an `agentBaseUrl` is provided, it fetches the card from that specific URL.
    * Otherwise, it returns the card fetched and cached during client construction.
    * @param agentBaseUrl Optional. The base URL of the agent to fetch the card from.
-   * @param agentCardPath path to the agent card, defaults to .well-known/agent.json
+   * @param agentCardPath path to the agent card, defaults to .well-known/agent-card.json
    * If provided, this will fetch a new card, not use the cached one from the constructor's URL.
    * @returns A Promise that resolves to the AgentCard.
    */
-  async getAgentCard(agentBaseUrl, agentCardPath = _A2AClient.DEFAULT_AGENT_CARD_PATH) {
+  async getAgentCard(agentBaseUrl, agentCardPath) {
     if (agentBaseUrl) {
-      const agentCardUrl = `${agentBaseUrl.replace(/\/$/, "")}/${agentCardPath.replace(/^\//, "")}`;
-      const response = await fetch(agentCardUrl, {
+      const agentCardUrl = this.resolveAgentCardUrl(agentBaseUrl, agentCardPath);
+      const response = await this.fetchImpl(agentCardUrl, {
         headers: { "Accept": "application/json" }
       });
       if (!response.ok) {
@@ -92,6 +95,14 @@ var A2AClient = class _A2AClient {
     }
     return this.agentCardPromise;
   }
+  /**
+   * Determines the agent card URL based on the agent URL.
+   * @param agentBaseUrl The agent URL.
+   * @param agentCardPath Optional relative path to the agent card, defaults to .well-known/agent-card.json
+   */
+  resolveAgentCardUrl(agentBaseUrl, agentCardPath = AGENT_CARD_PATH) {
+    return `${agentBaseUrl.replace(/\/$/, "")}/${agentCardPath.replace(/^\//, "")}`;
+  }
   /**
    * Gets the RPC service endpoint URL. Ensures the agent card has been fetched first.
    * @returns A Promise that resolves to the service endpoint URL string.
@@ -122,21 +133,15 @@ var A2AClient = class _A2AClient {
       // Cast because TParams structure varies per method
       id: requestId
     };
-    const httpResponse = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Accept": "application/json"
-        // Expect JSON response for non-streaming requests
-      },
-      body: JSON.stringify(rpcRequest)
-    });
+    const httpResponse = await this._fetchRpc(endpoint, rpcRequest);
     if (!httpResponse.ok) {
       let errorBodyText = "(empty or non-JSON response)";
       try {
         errorBodyText = await httpResponse.text();
         const errorJson = JSON.parse(errorBodyText);
-        if (!errorJson.jsonrpc && errorJson.error) {
+        if (errorJson.jsonrpc && errorJson.error) {
+          return errorJson;
+        } else if (!errorJson.jsonrpc && errorJson.error) {
           throw new Error(`RPC error for ${method}: ${errorJson.error.message} (Code: ${errorJson.error.code}, HTTP Status: ${httpResponse.status}) Data: ${JSON.stringify(errorJson.error.data || {})}`);
         } else if (!errorJson.jsonrpc) {
           throw new Error(`HTTP error for ${method}! Status: ${httpResponse.status} ${httpResponse.statusText}. Response: ${errorBodyText}`);
@@ -152,6 +157,25 @@ var A2AClient = class _A2AClient {
     }
     return rpcResponse;
   }
+  /**
+   * Internal helper method to fetch the RPC service endpoint.
+   * @param url The URL to fetch.
+   * @param rpcRequest The JSON-RPC request to send.
+   * @param acceptHeader The Accept header to use.  Defaults to "application/json".
+   * @returns A Promise that resolves to the fetch HTTP response.
+   */
+  async _fetchRpc(url, rpcRequest, acceptHeader = "application/json") {
+    const requestInit = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": acceptHeader
+        // Expect JSON response for non-streaming requests
+      },
+      body: JSON.stringify(rpcRequest)
+    };
+    return this.fetchImpl(url, requestInit);
+  }
   /**
    * Sends a message to the agent.
    * The behavior (blocking/non-blocking) and push notification configuration
@@ -186,15 +210,7 @@ var A2AClient = class _A2AClient {
       params,
       id: clientRequestId
     };
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Accept": "text/event-stream"
-        // Crucial for SSE
-      },
-      body: JSON.stringify(rpcRequest)
-    });
+    const response = await this._fetchRpc(endpoint, rpcRequest, "text/event-stream");
     if (!response.ok) {
       let errorBody = "";
       try {
@@ -278,7 +294,7 @@ var A2AClient = class _A2AClient {
       params,
       id: clientRequestId
     };
-    const response = await fetch(endpoint, {
+    const response = await this.fetchImpl(endpoint, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -394,7 +410,41 @@ var A2AClient = class _A2AClient {
     return "error" in response;
   }
 };
+
+// src/client/auth-handler.ts
+function createAuthenticatingFetchWithRetry(fetchImpl, authHandler) {
+  async function authFetch(url, init) {
+    const authHeaders = await authHandler.headers() || {};
+    const mergedInit = {
+      ...init || {},
+      headers: {
+        ...authHeaders,
+        ...init?.headers || {}
+      }
+    };
+    let response = await fetchImpl(url, mergedInit);
+    const updatedHeaders = await authHandler.shouldRetryWithHeaders(mergedInit, response);
+    if (updatedHeaders) {
+      const retryInit = {
+        ...init || {},
+        headers: {
+          ...updatedHeaders,
+          ...init?.headers || {}
+        }
+      };
+      response = await fetchImpl(url, retryInit);
+      if (response.ok && authHandler.onSuccessfulRetry) {
+        await authHandler.onSuccessfulRetry(updatedHeaders);
+      }
+    }
+    return response;
+  }
+  Object.setPrototypeOf(authFetch, Object.getPrototypeOf(fetchImpl));
+  Object.defineProperties(authFetch, Object.getOwnPropertyDescriptors(fetchImpl));
+  return authFetch;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  A2AClient
+  A2AClient,
+  createAuthenticatingFetchWithRetry
 });

package/dist/client/index.d.cts

@@ -1,28 +1,32 @@
 import { ac as AgentCard, w as MessageSendParams, S as SendMessageResponse, B as Message, aw as Task, aO as TaskStatusUpdateEvent, aQ as TaskArtifactUpdateEvent, Z as TaskPushNotificationConfig, b as SetTaskPushNotificationConfigResponse, X as TaskIdParams, c as GetTaskPushNotificationConfigResponse, V as TaskQueryParams, G as GetTaskResponse, C as CancelTaskResponse, i as JSONRPCResponse, J as JSONRPCErrorResponse } from '../types-DNKcmF0f.cjs';
 
 type A2AStreamEventData = Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent;
+interface A2AClientOptions {
+    agentCardPath?: string;
+    fetchImpl?: typeof fetch;
+}
 /**
  * A2AClient is a TypeScript HTTP client for interacting with A2A-compliant agents.
  */
 declare class A2AClient {
-    private agentBaseUrl;
-    private agentCardPath;
     private agentCardPromise;
-    private static readonly DEFAULT_AGENT_CARD_PATH;
     private requestIdCounter;
     private serviceEndpointUrl?;
+    private fetchImpl;
     /**
      * Constructs an A2AClient instance.
      * It initiates fetching the agent card from the provided agent baseUrl.
-     * The Agent Card is fetched from a path relative to the agentBaseUrl, which defaults to '.well-known/agent.json'.
+     * The Agent Card is fetched from a path relative to the agentBaseUrl, which defaults to '.well-known/agent-card.json'.
      * The `url` field from the Agent Card will be used as the RPC service endpoint.
      * @param agentBaseUrl The base URL of the A2A agent (e.g., https://agent.example.com)
-     * @param agentCardPath path to the agent card, defaults to .well-known/agent.json
+     * @param options Optional. The options for the A2AClient including the fetch implementation, agent card path, and authentication handler.
      */
-    constructor(agentBaseUrl: string, agentCardPath?: string);
+    constructor(agentBaseUrl: string, options?: A2AClientOptions);
     /**
      * Fetches the Agent Card from the agent's well-known URI and caches its service endpoint URL.
      * This method is called by the constructor.
+     * @param agentBaseUrl The base URL of the A2A agent (e.g., https://agent.example.com)
+     * @param agentCardPath path to the agent card, defaults to .well-known/agent-card.json
      * @returns A Promise that resolves to the AgentCard.
      */
     private _fetchAndCacheAgentCard;
@@ -31,11 +35,17 @@ declare class A2AClient {
      * If an `agentBaseUrl` is provided, it fetches the card from that specific URL.
      * Otherwise, it returns the card fetched and cached during client construction.
      * @param agentBaseUrl Optional. The base URL of the agent to fetch the card from.
-     * @param agentCardPath path to the agent card, defaults to .well-known/agent.json
+     * @param agentCardPath path to the agent card, defaults to .well-known/agent-card.json
      * If provided, this will fetch a new card, not use the cached one from the constructor's URL.
      * @returns A Promise that resolves to the AgentCard.
      */
     getAgentCard(agentBaseUrl?: string, agentCardPath?: string): Promise<AgentCard>;
+    /**
+     * Determines the agent card URL based on the agent URL.
+     * @param agentBaseUrl The agent URL.
+     * @param agentCardPath Optional relative path to the agent card, defaults to .well-known/agent-card.json
+     */
+    private resolveAgentCardUrl;
     /**
      * Gets the RPC service endpoint URL. Ensures the agent card has been fetched first.
      * @returns A Promise that resolves to the service endpoint URL string.
@@ -48,6 +58,14 @@ declare class A2AClient {
      * @returns A Promise that resolves to the RPC response.
      */
     private _postRpcRequest;
+    /**
+     * Internal helper method to fetch the RPC service endpoint.
+     * @param url The URL to fetch.
+     * @param rpcRequest The JSON-RPC request to send.
+     * @param acceptHeader The Accept header to use.  Defaults to "application/json".
+     * @returns A Promise that resolves to the fetch HTTP response.
+     */
+    private _fetchRpc;
     /**
      * Sends a message to the agent.
      * The behavior (blocking/non-blocking) and push notification configuration
@@ -121,4 +139,66 @@ declare class A2AClient {
     isErrorResponse(response: JSONRPCResponse): response is JSONRPCErrorResponse;
 }
 
-export { A2AClient };
+interface HttpHeaders {
+    [key: string]: string;
+}
+/**
+ * Generic interface for handling authentication for HTTP requests.
+ *
+ * - For each HTTP request, this handler is called to provide additional headers to the request through
+ *   the headers() function.
+ * - After the server returns a response, the shouldRetryWithHeaders() function is called.  Usually this
+ *   function responds to a 401 or 403 response or JSON-RPC codes, but can respond to any other signal -
+ *   that is an implementation detail of the AuthenticationHandler.
+ * - If the shouldRetryWithHeaders() function returns new headers, then the request should retried with the provided
+ *   revised headers.  These provisional headers may, or may not, be optimistically stored for subsequent requests -
+ *   that is an implementation detail of the AuthenticationHandler.
+ * - If the request is successful and the onSuccessfulRetry() is defined, then the onSuccessfulRetry() function is
+ *   called with the headers that were used to successfully complete the request.  This callback provides an
+ *   opportunity to save the headers for subsequent requests if they were not already saved.
+ *
+ */
+interface AuthenticationHandler {
+    /**
+     * Provides additional HTTP request headers.
+     * @returns HTTP headers which may include Authorization if available.
+     */
+    headers: () => Promise<HttpHeaders>;
+    /**
+     * For every HTTP response (even 200s) the shouldRetryWithHeaders() method is called.
+     * This method is supposed to check if the request needs to be retried and if, yes,
+     * return a set of headers. An A2A server might indicate auth failures in its response
+     * by JSON-rpc codes, HTTP codes like 401, 403 or headers like WWW-Authenticate.
+     *
+     * @param req The RequestInit object used to invoke fetch()
+     * @param res The fetch Response object
+     * @returns If the HTTP request should be retried then returns the HTTP headers to use,
+     * 	or returns undefined if no retry should be made.
+     */
+    shouldRetryWithHeaders: (req: RequestInit, res: Response) => Promise<HttpHeaders | undefined>;
+    /**
+     * If the last HTTP request using the headers from shouldRetryWithHeaders() was successful, and
+     * this function is implemented, then it will be called with the headers provided from
+     * shouldRetryWithHeaders().
+     *
+     * This callback allows transient headers to be saved for subsequent requests only when they
+     * are validated by the server.
+    */
+    onSuccessfulRetry?: (headers: HttpHeaders) => Promise<void>;
+}
+/**
+ * Higher-order function that wraps fetch with authentication handling logic.
+ * Returns a new fetch function that automatically handles authentication retries for 401/403 responses.
+ *
+ * @param fetchImpl The underlying fetch implementation to wrap
+ * @param authHandler Authentication handler for managing auth headers and retries
+ * @returns A new fetch function with authentication handling capabilities
+ *
+ * Usage examples:
+ * - const authFetch = createAuthHandlingFetch(fetch, authHandler);
+ * - const response = await authFetch(url, options);
+ * - const response = await authFetch(url); // Direct function call
+ */
+declare function createAuthenticatingFetchWithRetry(fetchImpl: typeof fetch, authHandler: AuthenticationHandler): typeof fetch;
+
+export { A2AClient, type A2AClientOptions, type AuthenticationHandler, type HttpHeaders, createAuthenticatingFetchWithRetry };