@a2a-js/sdk 0.2.3 → 0.2.4

package/dist/client/index.cjs

@@ -0,0 +1,396 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  A2AClient: () => A2AClient
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/client/client.ts
+var A2AClient = class {
+  agentBaseUrl;
+  agentCardPromise;
+  requestIdCounter = 1;
+  serviceEndpointUrl;
+  // To be populated from AgentCard after fetching
+  /**
+   * Constructs an A2AClient instance.
+   * It initiates fetching the agent card from the provided agent baseUrl.
+   * The Agent Card is expected at `${agentBaseUrl}/.well-known/agent.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).
+   */
+  constructor(agentBaseUrl) {
+    this.agentBaseUrl = agentBaseUrl.replace(/\/$/, "");
+    this.agentCardPromise = this._fetchAndCacheAgentCard();
+  }
+  /**
+   * Fetches the Agent Card from the agent's well-known URI and caches its service endpoint URL.
+   * This method is called by the constructor.
+   * @returns A Promise that resolves to the AgentCard.
+   */
+  async _fetchAndCacheAgentCard() {
+    const agentCardUrl = `${this.agentBaseUrl}/.well-known/agent.json`;
+    try {
+      const response = await fetch(agentCardUrl, {
+        headers: { "Accept": "application/json" }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch Agent Card from ${agentCardUrl}: ${response.status} ${response.statusText}`);
+      }
+      const agentCard = await response.json();
+      if (!agentCard.url) {
+        throw new Error("Fetched Agent Card does not contain a valid 'url' for the service endpoint.");
+      }
+      this.serviceEndpointUrl = agentCard.url;
+      return agentCard;
+    } catch (error) {
+      console.error("Error fetching or parsing Agent Card:");
+      throw error;
+    }
+  }
+  /**
+   * Retrieves the Agent Card.
+   * 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.
+   * 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) {
+    if (agentBaseUrl) {
+      const specificAgentBaseUrl = agentBaseUrl.replace(/\/$/, "");
+      const agentCardUrl = `${specificAgentBaseUrl}/.well-known/agent.json`;
+      const response = await fetch(agentCardUrl, {
+        headers: { "Accept": "application/json" }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch Agent Card from ${agentCardUrl}: ${response.status} ${response.statusText}`);
+      }
+      return await response.json();
+    }
+    return this.agentCardPromise;
+  }
+  /**
+   * 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.
+   */
+  async _getServiceEndpoint() {
+    if (this.serviceEndpointUrl) {
+      return this.serviceEndpointUrl;
+    }
+    await this.agentCardPromise;
+    if (!this.serviceEndpointUrl) {
+      throw new Error("Agent Card URL for RPC endpoint is not available. Fetching might have failed.");
+    }
+    return this.serviceEndpointUrl;
+  }
+  /**
+   * Helper method to make a generic JSON-RPC POST request.
+   * @param method The RPC method name.
+   * @param params The parameters for the RPC method.
+   * @returns A Promise that resolves to the RPC response.
+   */
+  async _postRpcRequest(method, params) {
+    const endpoint = await this._getServiceEndpoint();
+    const requestId = this.requestIdCounter++;
+    const rpcRequest = {
+      jsonrpc: "2.0",
+      method,
+      params,
+      // 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)
+    });
+    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) {
+          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}`);
+        }
+      } catch (e) {
+        if (e.message.startsWith("RPC error for") || e.message.startsWith("HTTP error for")) throw e;
+        throw new Error(`HTTP error for ${method}! Status: ${httpResponse.status} ${httpResponse.statusText}. Response: ${errorBodyText}`);
+      }
+    }
+    const rpcResponse = await httpResponse.json();
+    if (rpcResponse.id !== requestId) {
+      console.error(`CRITICAL: RPC response ID mismatch for method ${method}. Expected ${requestId}, got ${rpcResponse.id}. This may lead to incorrect response handling.`);
+    }
+    return rpcResponse;
+  }
+  /**
+   * Sends a message to the agent.
+   * The behavior (blocking/non-blocking) and push notification configuration
+   * are specified within the `params.configuration` object.
+   * Optionally, `params.message.contextId` or `params.message.taskId` can be provided.
+   * @param params The parameters for sending the message, including the message content and configuration.
+   * @returns A Promise resolving to SendMessageResponse, which can be a Message, Task, or an error.
+   */
+  async sendMessage(params) {
+    return this._postRpcRequest("message/send", params);
+  }
+  /**
+   * Sends a message to the agent and streams back responses using Server-Sent Events (SSE).
+   * Push notification configuration can be specified in `params.configuration`.
+   * Optionally, `params.message.contextId` or `params.message.taskId` can be provided.
+   * Requires the agent to support streaming (`capabilities.streaming: true` in AgentCard).
+   * @param params The parameters for sending the message.
+   * @returns An AsyncGenerator yielding A2AStreamEventData (Message, Task, TaskStatusUpdateEvent, or TaskArtifactUpdateEvent).
+   * The generator throws an error if streaming is not supported or if an HTTP/SSE error occurs.
+   */
+  async *sendMessageStream(params) {
+    const agentCard = await this.agentCardPromise;
+    if (!agentCard.capabilities?.streaming) {
+      throw new Error("Agent does not support streaming (AgentCard.capabilities.streaming is not true).");
+    }
+    const endpoint = await this._getServiceEndpoint();
+    const clientRequestId = this.requestIdCounter++;
+    const rpcRequest = {
+      // This is the initial JSON-RPC request to establish the stream
+      jsonrpc: "2.0",
+      method: "message/stream",
+      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)
+    });
+    if (!response.ok) {
+      let errorBody = "";
+      try {
+        errorBody = await response.text();
+        const errorJson = JSON.parse(errorBody);
+        if (errorJson.error) {
+          throw new Error(`HTTP error establishing stream for message/stream: ${response.status} ${response.statusText}. RPC Error: ${errorJson.error.message} (Code: ${errorJson.error.code})`);
+        }
+      } catch (e) {
+        if (e.message.startsWith("HTTP error establishing stream")) throw e;
+        throw new Error(`HTTP error establishing stream for message/stream: ${response.status} ${response.statusText}. Response: ${errorBody || "(empty)"}`);
+      }
+      throw new Error(`HTTP error establishing stream for message/stream: ${response.status} ${response.statusText}`);
+    }
+    if (!response.headers.get("Content-Type")?.startsWith("text/event-stream")) {
+      throw new Error("Invalid response Content-Type for SSE stream. Expected 'text/event-stream'.");
+    }
+    yield* this._parseA2ASseStream(response, clientRequestId);
+  }
+  /**
+   * Sets or updates the push notification configuration for a given task.
+   * Requires the agent to support push notifications (`capabilities.pushNotifications: true` in AgentCard).
+   * @param params Parameters containing the taskId and the TaskPushNotificationConfig.
+   * @returns A Promise resolving to SetTaskPushNotificationConfigResponse.
+   */
+  async setTaskPushNotificationConfig(params) {
+    const agentCard = await this.agentCardPromise;
+    if (!agentCard.capabilities?.pushNotifications) {
+      throw new Error("Agent does not support push notifications (AgentCard.capabilities.pushNotifications is not true).");
+    }
+    return this._postRpcRequest(
+      "tasks/pushNotificationConfig/set",
+      params
+    );
+  }
+  /**
+   * Gets the push notification configuration for a given task.
+   * @param params Parameters containing the taskId.
+   * @returns A Promise resolving to GetTaskPushNotificationConfigResponse.
+   */
+  async getTaskPushNotificationConfig(params) {
+    return this._postRpcRequest(
+      "tasks/pushNotificationConfig/get",
+      params
+    );
+  }
+  /**
+   * Retrieves a task by its ID.
+   * @param params Parameters containing the taskId and optional historyLength.
+   * @returns A Promise resolving to GetTaskResponse, which contains the Task object or an error.
+   */
+  async getTask(params) {
+    return this._postRpcRequest("tasks/get", params);
+  }
+  /**
+   * Cancels a task by its ID.
+   * @param params Parameters containing the taskId.
+   * @returns A Promise resolving to CancelTaskResponse, which contains the updated Task object or an error.
+   */
+  async cancelTask(params) {
+    return this._postRpcRequest("tasks/cancel", params);
+  }
+  /**
+   * Resubscribes to a task's event stream using Server-Sent Events (SSE).
+   * This is used if a previous SSE connection for an active task was broken.
+   * Requires the agent to support streaming (`capabilities.streaming: true` in AgentCard).
+   * @param params Parameters containing the taskId.
+   * @returns An AsyncGenerator yielding A2AStreamEventData (Message, Task, TaskStatusUpdateEvent, or TaskArtifactUpdateEvent).
+   */
+  async *resubscribeTask(params) {
+    const agentCard = await this.agentCardPromise;
+    if (!agentCard.capabilities?.streaming) {
+      throw new Error("Agent does not support streaming (required for tasks/resubscribe).");
+    }
+    const endpoint = await this._getServiceEndpoint();
+    const clientRequestId = this.requestIdCounter++;
+    const rpcRequest = {
+      // Initial JSON-RPC request to establish the stream
+      jsonrpc: "2.0",
+      method: "tasks/resubscribe",
+      params,
+      id: clientRequestId
+    };
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "text/event-stream"
+      },
+      body: JSON.stringify(rpcRequest)
+    });
+    if (!response.ok) {
+      let errorBody = "";
+      try {
+        errorBody = await response.text();
+        const errorJson = JSON.parse(errorBody);
+        if (errorJson.error) {
+          throw new Error(`HTTP error establishing stream for tasks/resubscribe: ${response.status} ${response.statusText}. RPC Error: ${errorJson.error.message} (Code: ${errorJson.error.code})`);
+        }
+      } catch (e) {
+        if (e.message.startsWith("HTTP error establishing stream")) throw e;
+        throw new Error(`HTTP error establishing stream for tasks/resubscribe: ${response.status} ${response.statusText}. Response: ${errorBody || "(empty)"}`);
+      }
+      throw new Error(`HTTP error establishing stream for tasks/resubscribe: ${response.status} ${response.statusText}`);
+    }
+    if (!response.headers.get("Content-Type")?.startsWith("text/event-stream")) {
+      throw new Error("Invalid response Content-Type for SSE stream on resubscribe. Expected 'text/event-stream'.");
+    }
+    yield* this._parseA2ASseStream(response, clientRequestId);
+  }
+  /**
+   * Parses an HTTP response body as an A2A Server-Sent Event stream.
+   * Each 'data' field of an SSE event is expected to be a JSON-RPC 2.0 Response object,
+   * specifically a SendStreamingMessageResponse (or similar structure for resubscribe).
+   * @param response The HTTP Response object whose body is the SSE stream.
+   * @param originalRequestId The ID of the client's JSON-RPC request that initiated this stream.
+   * Used to validate the `id` in the streamed JSON-RPC responses.
+   * @returns An AsyncGenerator yielding the `result` field of each valid JSON-RPC success response from the stream.
+   */
+  async *_parseA2ASseStream(response, originalRequestId) {
+    if (!response.body) {
+      throw new Error("SSE response body is undefined. Cannot read stream.");
+    }
+    const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+    let buffer = "";
+    let eventDataBuffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          if (eventDataBuffer.trim()) {
+            const result = this._processSseEventData(eventDataBuffer, originalRequestId);
+            yield result;
+          }
+          break;
+        }
+        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 (eventDataBuffer) {
+              const result = this._processSseEventData(eventDataBuffer, originalRequestId);
+              yield result;
+              eventDataBuffer = "";
+            }
+          } else if (line.startsWith("data:")) {
+            eventDataBuffer += line.substring(5).trimStart() + "\n";
+          } else if (line.startsWith(":")) {
+          } else if (line.includes(":")) {
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Error reading or parsing SSE stream:", error.message);
+      throw error;
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Processes a single SSE event's data string, expecting it to be a JSON-RPC response.
+   * @param jsonData The string content from one or more 'data:' lines of an SSE event.
+   * @param originalRequestId The ID of the client's request that initiated the stream.
+   * @returns The `result` field of the parsed JSON-RPC success response.
+   * @throws Error if data is not valid JSON, not a valid JSON-RPC response, an error response, or ID mismatch.
+   */
+  _processSseEventData(jsonData, originalRequestId) {
+    if (!jsonData.trim()) {
+      throw new Error("Attempted to process empty SSE event data.");
+    }
+    try {
+      const sseJsonRpcResponse = JSON.parse(jsonData.replace(/\n$/, ""));
+      const a2aStreamResponse = sseJsonRpcResponse;
+      if (a2aStreamResponse.id !== originalRequestId) {
+        console.warn(`SSE Event's JSON-RPC response ID mismatch. Client request ID: ${originalRequestId}, event response ID: ${a2aStreamResponse.id}.`);
+      }
+      if (this.isErrorResponse(a2aStreamResponse)) {
+        const err = a2aStreamResponse.error;
+        throw new Error(`SSE event contained an error: ${err.message} (Code: ${err.code}) Data: ${JSON.stringify(err.data)}`);
+      }
+      if (!("result" in a2aStreamResponse) || typeof a2aStreamResponse.result === "undefined") {
+        throw new Error(`SSE event JSON-RPC response is missing 'result' field. Data: ${jsonData}`);
+      }
+      const successResponse = a2aStreamResponse;
+      return successResponse.result;
+    } catch (e) {
+      if (e.message.startsWith("SSE event contained an error") || e.message.startsWith("SSE event JSON-RPC response is missing 'result' field")) {
+        throw e;
+      }
+      console.error("Failed to parse SSE event data string or unexpected JSON-RPC structure:", jsonData, e);
+      throw new Error(`Failed to parse SSE event data: "${jsonData.substring(0, 100)}...". Original error: ${e.message}`);
+    }
+  }
+  isErrorResponse(response) {
+    return "error" in response;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2AClient
+});

package/dist/client/index.d.cts

@@ -0,0 +1,120 @@
+import { A as AgentCard, M as MessageSendParams, S as SendMessageResponse, a as Message, T as Task, b as TaskStatusUpdateEvent, c as TaskArtifactUpdateEvent, d as TaskPushNotificationConfig, e as SetTaskPushNotificationConfigResponse, f as TaskIdParams, G as GetTaskPushNotificationConfigResponse, g as TaskQueryParams, h as GetTaskResponse, C as CancelTaskResponse, J as JSONRPCResponse, i as JSONRPCErrorResponse } from '../types-CcBgkR2G.cjs';
+
+type A2AStreamEventData = Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent;
+/**
+ * A2AClient is a TypeScript HTTP client for interacting with A2A-compliant agents.
+ */
+declare class A2AClient {
+    private agentBaseUrl;
+    private agentCardPromise;
+    private requestIdCounter;
+    private serviceEndpointUrl?;
+    /**
+     * Constructs an A2AClient instance.
+     * It initiates fetching the agent card from the provided agent baseUrl.
+     * The Agent Card is expected at `${agentBaseUrl}/.well-known/agent.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).
+     */
+    constructor(agentBaseUrl: string);
+    /**
+     * Fetches the Agent Card from the agent's well-known URI and caches its service endpoint URL.
+     * This method is called by the constructor.
+     * @returns A Promise that resolves to the AgentCard.
+     */
+    private _fetchAndCacheAgentCard;
+    /**
+     * Retrieves the Agent Card.
+     * 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.
+     * 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): Promise<AgentCard>;
+    /**
+     * 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.
+     */
+    private _getServiceEndpoint;
+    /**
+     * Helper method to make a generic JSON-RPC POST request.
+     * @param method The RPC method name.
+     * @param params The parameters for the RPC method.
+     * @returns A Promise that resolves to the RPC response.
+     */
+    private _postRpcRequest;
+    /**
+     * Sends a message to the agent.
+     * The behavior (blocking/non-blocking) and push notification configuration
+     * are specified within the `params.configuration` object.
+     * Optionally, `params.message.contextId` or `params.message.taskId` can be provided.
+     * @param params The parameters for sending the message, including the message content and configuration.
+     * @returns A Promise resolving to SendMessageResponse, which can be a Message, Task, or an error.
+     */
+    sendMessage(params: MessageSendParams): Promise<SendMessageResponse>;
+    /**
+     * Sends a message to the agent and streams back responses using Server-Sent Events (SSE).
+     * Push notification configuration can be specified in `params.configuration`.
+     * Optionally, `params.message.contextId` or `params.message.taskId` can be provided.
+     * Requires the agent to support streaming (`capabilities.streaming: true` in AgentCard).
+     * @param params The parameters for sending the message.
+     * @returns An AsyncGenerator yielding A2AStreamEventData (Message, Task, TaskStatusUpdateEvent, or TaskArtifactUpdateEvent).
+     * The generator throws an error if streaming is not supported or if an HTTP/SSE error occurs.
+     */
+    sendMessageStream(params: MessageSendParams): AsyncGenerator<A2AStreamEventData, void, undefined>;
+    /**
+     * Sets or updates the push notification configuration for a given task.
+     * Requires the agent to support push notifications (`capabilities.pushNotifications: true` in AgentCard).
+     * @param params Parameters containing the taskId and the TaskPushNotificationConfig.
+     * @returns A Promise resolving to SetTaskPushNotificationConfigResponse.
+     */
+    setTaskPushNotificationConfig(params: TaskPushNotificationConfig): Promise<SetTaskPushNotificationConfigResponse>;
+    /**
+     * Gets the push notification configuration for a given task.
+     * @param params Parameters containing the taskId.
+     * @returns A Promise resolving to GetTaskPushNotificationConfigResponse.
+     */
+    getTaskPushNotificationConfig(params: TaskIdParams): Promise<GetTaskPushNotificationConfigResponse>;
+    /**
+     * Retrieves a task by its ID.
+     * @param params Parameters containing the taskId and optional historyLength.
+     * @returns A Promise resolving to GetTaskResponse, which contains the Task object or an error.
+     */
+    getTask(params: TaskQueryParams): Promise<GetTaskResponse>;
+    /**
+     * Cancels a task by its ID.
+     * @param params Parameters containing the taskId.
+     * @returns A Promise resolving to CancelTaskResponse, which contains the updated Task object or an error.
+     */
+    cancelTask(params: TaskIdParams): Promise<CancelTaskResponse>;
+    /**
+     * Resubscribes to a task's event stream using Server-Sent Events (SSE).
+     * This is used if a previous SSE connection for an active task was broken.
+     * Requires the agent to support streaming (`capabilities.streaming: true` in AgentCard).
+     * @param params Parameters containing the taskId.
+     * @returns An AsyncGenerator yielding A2AStreamEventData (Message, Task, TaskStatusUpdateEvent, or TaskArtifactUpdateEvent).
+     */
+    resubscribeTask(params: TaskIdParams): AsyncGenerator<A2AStreamEventData, void, undefined>;
+    /**
+     * Parses an HTTP response body as an A2A Server-Sent Event stream.
+     * Each 'data' field of an SSE event is expected to be a JSON-RPC 2.0 Response object,
+     * specifically a SendStreamingMessageResponse (or similar structure for resubscribe).
+     * @param response The HTTP Response object whose body is the SSE stream.
+     * @param originalRequestId The ID of the client's JSON-RPC request that initiated this stream.
+     * Used to validate the `id` in the streamed JSON-RPC responses.
+     * @returns An AsyncGenerator yielding the `result` field of each valid JSON-RPC success response from the stream.
+     */
+    private _parseA2ASseStream;
+    /**
+     * Processes a single SSE event's data string, expecting it to be a JSON-RPC response.
+     * @param jsonData The string content from one or more 'data:' lines of an SSE event.
+     * @param originalRequestId The ID of the client's request that initiated the stream.
+     * @returns The `result` field of the parsed JSON-RPC success response.
+     * @throws Error if data is not valid JSON, not a valid JSON-RPC response, an error response, or ID mismatch.
+     */
+    private _processSseEventData;
+    isErrorResponse(response: JSONRPCResponse): response is JSONRPCErrorResponse;
+}
+
+export { A2AClient };

package/dist/client/index.d.ts

@@ -0,0 +1,120 @@
+import { A as AgentCard, M as MessageSendParams, S as SendMessageResponse, a as Message, T as Task, b as TaskStatusUpdateEvent, c as TaskArtifactUpdateEvent, d as TaskPushNotificationConfig, e as SetTaskPushNotificationConfigResponse, f as TaskIdParams, G as GetTaskPushNotificationConfigResponse, g as TaskQueryParams, h as GetTaskResponse, C as CancelTaskResponse, J as JSONRPCResponse, i as JSONRPCErrorResponse } from '../types-CcBgkR2G.js';
+
+type A2AStreamEventData = Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent;
+/**
+ * A2AClient is a TypeScript HTTP client for interacting with A2A-compliant agents.
+ */
+declare class A2AClient {
+    private agentBaseUrl;
+    private agentCardPromise;
+    private requestIdCounter;
+    private serviceEndpointUrl?;
+    /**
+     * Constructs an A2AClient instance.
+     * It initiates fetching the agent card from the provided agent baseUrl.
+     * The Agent Card is expected at `${agentBaseUrl}/.well-known/agent.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).
+     */
+    constructor(agentBaseUrl: string);
+    /**
+     * Fetches the Agent Card from the agent's well-known URI and caches its service endpoint URL.
+     * This method is called by the constructor.
+     * @returns A Promise that resolves to the AgentCard.
+     */
+    private _fetchAndCacheAgentCard;
+    /**
+     * Retrieves the Agent Card.
+     * 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.
+     * 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): Promise<AgentCard>;
+    /**
+     * 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.
+     */
+    private _getServiceEndpoint;
+    /**
+     * Helper method to make a generic JSON-RPC POST request.
+     * @param method The RPC method name.
+     * @param params The parameters for the RPC method.
+     * @returns A Promise that resolves to the RPC response.
+     */
+    private _postRpcRequest;
+    /**
+     * Sends a message to the agent.
+     * The behavior (blocking/non-blocking) and push notification configuration
+     * are specified within the `params.configuration` object.
+     * Optionally, `params.message.contextId` or `params.message.taskId` can be provided.
+     * @param params The parameters for sending the message, including the message content and configuration.
+     * @returns A Promise resolving to SendMessageResponse, which can be a Message, Task, or an error.
+     */
+    sendMessage(params: MessageSendParams): Promise<SendMessageResponse>;
+    /**
+     * Sends a message to the agent and streams back responses using Server-Sent Events (SSE).
+     * Push notification configuration can be specified in `params.configuration`.
+     * Optionally, `params.message.contextId` or `params.message.taskId` can be provided.
+     * Requires the agent to support streaming (`capabilities.streaming: true` in AgentCard).
+     * @param params The parameters for sending the message.
+     * @returns An AsyncGenerator yielding A2AStreamEventData (Message, Task, TaskStatusUpdateEvent, or TaskArtifactUpdateEvent).
+     * The generator throws an error if streaming is not supported or if an HTTP/SSE error occurs.
+     */
+    sendMessageStream(params: MessageSendParams): AsyncGenerator<A2AStreamEventData, void, undefined>;
+    /**
+     * Sets or updates the push notification configuration for a given task.
+     * Requires the agent to support push notifications (`capabilities.pushNotifications: true` in AgentCard).
+     * @param params Parameters containing the taskId and the TaskPushNotificationConfig.
+     * @returns A Promise resolving to SetTaskPushNotificationConfigResponse.
+     */
+    setTaskPushNotificationConfig(params: TaskPushNotificationConfig): Promise<SetTaskPushNotificationConfigResponse>;
+    /**
+     * Gets the push notification configuration for a given task.
+     * @param params Parameters containing the taskId.
+     * @returns A Promise resolving to GetTaskPushNotificationConfigResponse.
+     */
+    getTaskPushNotificationConfig(params: TaskIdParams): Promise<GetTaskPushNotificationConfigResponse>;
+    /**
+     * Retrieves a task by its ID.
+     * @param params Parameters containing the taskId and optional historyLength.
+     * @returns A Promise resolving to GetTaskResponse, which contains the Task object or an error.
+     */
+    getTask(params: TaskQueryParams): Promise<GetTaskResponse>;
+    /**
+     * Cancels a task by its ID.
+     * @param params Parameters containing the taskId.
+     * @returns A Promise resolving to CancelTaskResponse, which contains the updated Task object or an error.
+     */
+    cancelTask(params: TaskIdParams): Promise<CancelTaskResponse>;
+    /**
+     * Resubscribes to a task's event stream using Server-Sent Events (SSE).
+     * This is used if a previous SSE connection for an active task was broken.
+     * Requires the agent to support streaming (`capabilities.streaming: true` in AgentCard).
+     * @param params Parameters containing the taskId.
+     * @returns An AsyncGenerator yielding A2AStreamEventData (Message, Task, TaskStatusUpdateEvent, or TaskArtifactUpdateEvent).
+     */
+    resubscribeTask(params: TaskIdParams): AsyncGenerator<A2AStreamEventData, void, undefined>;
+    /**
+     * Parses an HTTP response body as an A2A Server-Sent Event stream.
+     * Each 'data' field of an SSE event is expected to be a JSON-RPC 2.0 Response object,
+     * specifically a SendStreamingMessageResponse (or similar structure for resubscribe).
+     * @param response The HTTP Response object whose body is the SSE stream.
+     * @param originalRequestId The ID of the client's JSON-RPC request that initiated this stream.
+     * Used to validate the `id` in the streamed JSON-RPC responses.
+     * @returns An AsyncGenerator yielding the `result` field of each valid JSON-RPC success response from the stream.
+     */
+    private _parseA2ASseStream;
+    /**
+     * Processes a single SSE event's data string, expecting it to be a JSON-RPC response.
+     * @param jsonData The string content from one or more 'data:' lines of an SSE event.
+     * @param originalRequestId The ID of the client's request that initiated the stream.
+     * @returns The `result` field of the parsed JSON-RPC success response.
+     * @throws Error if data is not valid JSON, not a valid JSON-RPC response, an error response, or ID mismatch.
+     */
+    private _processSseEventData;
+    isErrorResponse(response: JSONRPCResponse): response is JSONRPCErrorResponse;
+}
+
+export { A2AClient };