@a2a-js/sdk 0.3.6 → 0.3.7

package/README.md

@@ -23,13 +23,13 @@ npm install @a2a-js/sdk
 
 ### For Server Usage
 
-If you plan to use the A2A server functionality (`A2AExpressApp`), you'll also need to install Express as it's a peer dependency:
+If you plan to use the Express integration (imports from `@a2a-js/sdk/server/express`) for A2A server, you'll also need to install Express as it's a peer dependency:
 
 ```bash
 npm install express
 ```
 
-You can also find JavaScript samples [here](https://github.com/google-a2a/a2a-samples/tree/main/samples/js).
+You can also find some samples [here](https://github.com/a2aproject/a2a-js/tree/main/src/samples).
 
 ---
 
@@ -121,8 +121,8 @@ The [`ClientFactory`](src/client/factory.ts) makes it easy to communicate with a
 
 ```typescript
 // client.ts
-import { ClientFactory, SendMessageSuccessResponse } from '@a2a-js/sdk/client';
-import { Message, MessageSendParams } from '@a2a-js/sdk';
+import { ClientFactory } from '@a2a-js/sdk/client';
+import { Message, MessageSendParams, SendMessageSuccessResponse } from '@a2a-js/sdk';
 import { v4 as uuidv4 } from 'uuid';
 
 async function run() {
@@ -222,8 +222,8 @@ The client sends a message and receives a `Task` object as the result.
 
 ```typescript
 // client.ts
-import { ClientFactory, SendMessageSuccessResponse } from '@a2a-js/sdk/client';
-import { Message, MessageSendParams, Task } from '@a2a-js/sdk';
+import { ClientFactory } from '@a2a-js/sdk/client';
+import { Message, MessageSendParams, SendMessageSuccessResponse, Task } from '@a2a-js/sdk';
 // ... other imports ...
 
 const factory = new ClientFactory();
@@ -354,7 +354,7 @@ Here's how to use it to manage a Bearer token:
 ```typescript
 import {
   ClientFactory,
-  ClientFactoryOptions
+  ClientFactoryOptions,
   JsonRpcTransportFactory,
   AuthenticationHandler,
   createAuthenticatingFetchWithRetry,

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/client/index.cjs

@@ -21,15 +21,24 @@ var client_exports = {};
 __export(client_exports, {
   A2AClient: () => A2AClient,
   AgentCardResolver: () => AgentCardResolver,
+  AuthenticatedExtendedCardNotConfiguredError: () => AuthenticatedExtendedCardNotConfiguredError,
   Client: () => Client,
   ClientCallContext: () => ClientCallContext,
   ClientCallContextKey: () => ClientCallContextKey,
   ClientFactory: () => ClientFactory,
   ClientFactoryOptions: () => ClientFactoryOptions,
+  ContentTypeNotSupportedError: () => ContentTypeNotSupportedError,
   DefaultAgentCardResolver: () => DefaultAgentCardResolver,
+  InvalidAgentResponseError: () => InvalidAgentResponseError,
   JsonRpcTransport: () => JsonRpcTransport,
   JsonRpcTransportFactory: () => JsonRpcTransportFactory,
+  PushNotificationNotSupportedError: () => PushNotificationNotSupportedError,
+  RestTransport: () => RestTransport,
+  RestTransportFactory: () => RestTransportFactory,
   ServiceParameters: () => ServiceParameters,
+  TaskNotCancelableError: () => TaskNotCancelableError,
+  TaskNotFoundError: () => TaskNotFoundError,
+  UnsupportedOperationError: () => UnsupportedOperationError,
   createAuthenticatingFetchWithRetry: () => createAuthenticatingFetchWithRetry,
   withA2AExtensions: () => withA2AExtensions
 });
@@ -40,6 +49,20 @@ var AGENT_CARD_PATH = ".well-known/agent-card.json";
 var HTTP_EXTENSION_HEADER = "X-A2A-Extensions";
 
 // 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");
@@ -83,6 +106,38 @@ var AuthenticatedExtendedCardNotConfiguredError = class extends Error {
   }
 };
 
+// src/sse_utils.ts
+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 };
+  }
+}
+
 // src/client/transports/json_rpc_transport.ts
 var JsonRpcTransport = class _JsonRpcTransport {
   customFetchImpl;
@@ -251,55 +306,8 @@ var JsonRpcTransport = class _JsonRpcTransport {
         `Invalid response Content-Type for SSE stream for ${method}. Expected 'text/event-stream'.`
       );
     }
-    yield* this._parseA2ASseStream(response, clientRequestId);
-  }
-  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";
-          }
-        }
-      }
-    } catch (error) {
-      console.error(
-        "Error reading or parsing SSE stream:",
-        error instanceof Error && error.message || "Error unknown"
-      );
-      throw error;
-    } finally {
-      reader.releaseLock();
+    for await (const event of parseSseStream(response)) {
+      yield this._processSseEventData(event.data, clientRequestId);
     }
   }
   _processSseEventData(jsonData, originalRequestId) {
@@ -307,7 +315,7 @@ var JsonRpcTransport = class _JsonRpcTransport {
       throw new Error("Attempted to process empty SSE event data.");
     }
     try {
-      const sseJsonRpcResponse = JSON.parse(jsonData.replace(/\n$/, ""));
+      const sseJsonRpcResponse = JSON.parse(jsonData);
       const a2aStreamResponse = sseJsonRpcResponse;
       if (a2aStreamResponse.id !== originalRequestId) {
         console.warn(
@@ -1107,13 +1115,234 @@ var Client = class {
   }
 };
 
+// src/client/transports/rest_transport.ts
+var RestTransport = class _RestTransport {
+  customFetchImpl;
+  endpoint;
+  constructor(options) {
+    this.endpoint = options.endpoint.replace(/\/+$/, "");
+    this.customFetchImpl = options.fetchImpl;
+  }
+  async getExtendedAgentCard(options) {
+    return this._sendRequest("GET", "/v1/card", void 0, options);
+  }
+  async sendMessage(params, options) {
+    return this._sendRequest("POST", "/v1/message:send", params, options);
+  }
+  async *sendMessageStream(params, options) {
+    yield* this._sendStreamingRequest("/v1/message:stream", params, options);
+  }
+  async setTaskPushNotificationConfig(params, options) {
+    return this._sendRequest(
+      "POST",
+      `/v1/tasks/${encodeURIComponent(params.taskId)}/pushNotificationConfigs`,
+      {
+        pushNotificationConfig: params.pushNotificationConfig
+      },
+      options
+    );
+  }
+  async getTaskPushNotificationConfig(params, options) {
+    const { pushNotificationConfigId } = params;
+    if (!pushNotificationConfigId) {
+      throw new Error(
+        "pushNotificationConfigId is required for getTaskPushNotificationConfig with REST transport."
+      );
+    }
+    return this._sendRequest(
+      "GET",
+      `/v1/tasks/${encodeURIComponent(params.id)}/pushNotificationConfigs/${encodeURIComponent(pushNotificationConfigId)}`,
+      void 0,
+      options
+    );
+  }
+  async listTaskPushNotificationConfig(params, options) {
+    return this._sendRequest(
+      "GET",
+      `/v1/tasks/${encodeURIComponent(params.id)}/pushNotificationConfigs`,
+      void 0,
+      options
+    );
+  }
+  async deleteTaskPushNotificationConfig(params, options) {
+    await this._sendRequest(
+      "DELETE",
+      `/v1/tasks/${encodeURIComponent(params.id)}/pushNotificationConfigs/${encodeURIComponent(params.pushNotificationConfigId)}`,
+      void 0,
+      options
+    );
+  }
+  async getTask(params, options) {
+    const queryParams = new URLSearchParams();
+    if (params.historyLength !== void 0) {
+      queryParams.set("historyLength", String(params.historyLength));
+    }
+    const queryString = queryParams.toString();
+    const path = `/v1/tasks/${encodeURIComponent(params.id)}${queryString ? `?${queryString}` : ""}`;
+    return this._sendRequest("GET", path, void 0, options);
+  }
+  async cancelTask(params, options) {
+    return this._sendRequest(
+      "POST",
+      `/v1/tasks/${encodeURIComponent(params.id)}:cancel`,
+      void 0,
+      options
+    );
+  }
+  async *resubscribeTask(params, options) {
+    yield* this._sendStreamingRequest(
+      `/v1/tasks/${encodeURIComponent(params.id)}:subscribe`,
+      void 0,
+      options
+    );
+  }
+  _fetch(...args) {
+    if (this.customFetchImpl) {
+      return this.customFetchImpl(...args);
+    }
+    if (typeof fetch === "function") {
+      return fetch(...args);
+    }
+    throw new Error(
+      "A `fetch` implementation was not provided and is not available in the global scope. Please provide a `fetchImpl` in the RestTransportOptions."
+    );
+  }
+  _buildHeaders(options, acceptHeader = "application/json") {
+    return {
+      ...options?.serviceParameters,
+      "Content-Type": "application/json",
+      Accept: acceptHeader
+    };
+  }
+  async _sendRequest(method, path, body, options) {
+    const url = `${this.endpoint}${path}`;
+    const requestInit = {
+      method,
+      headers: this._buildHeaders(options),
+      signal: options?.signal
+    };
+    if (body !== void 0 && method !== "GET") {
+      requestInit.body = JSON.stringify(body);
+    }
+    const response = await this._fetch(url, requestInit);
+    if (!response.ok) {
+      await this._handleErrorResponse(response, path);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const result = await response.json();
+    return result;
+  }
+  async _handleErrorResponse(response, path) {
+    let errorBodyText = "(empty or non-JSON response)";
+    let errorBody;
+    try {
+      errorBodyText = await response.text();
+      if (errorBodyText) {
+        errorBody = JSON.parse(errorBodyText);
+      }
+    } catch (e) {
+      throw new Error(
+        `HTTP error for ${path}! Status: ${response.status} ${response.statusText}. Response: ${errorBodyText}`,
+        { cause: e }
+      );
+    }
+    if (errorBody && typeof errorBody.code === "number") {
+      throw _RestTransport.mapToError(errorBody);
+    }
+    throw new Error(
+      `HTTP error for ${path}! Status: ${response.status} ${response.statusText}. Response: ${errorBodyText}`
+    );
+  }
+  async *_sendStreamingRequest(path, body, options) {
+    const url = `${this.endpoint}${path}`;
+    const requestInit = {
+      method: "POST",
+      headers: this._buildHeaders(options, "text/event-stream"),
+      signal: options?.signal
+    };
+    if (body !== void 0) {
+      requestInit.body = JSON.stringify(body);
+    }
+    const response = await this._fetch(url, requestInit);
+    if (!response.ok) {
+      await this._handleErrorResponse(response, path);
+    }
+    const contentType = response.headers.get("Content-Type");
+    if (!contentType?.startsWith("text/event-stream")) {
+      throw new Error(
+        `Invalid response Content-Type for SSE stream. Expected 'text/event-stream', got '${contentType}'.`
+      );
+    }
+    for await (const event of parseSseStream(response)) {
+      if (event.type === "error") {
+        const errorData = JSON.parse(event.data);
+        throw _RestTransport.mapToError(errorData);
+      }
+      yield this._processSseEventData(event.data);
+    }
+  }
+  _processSseEventData(jsonData) {
+    if (!jsonData.trim()) {
+      throw new Error("Attempted to process empty SSE event data.");
+    }
+    try {
+      const data = JSON.parse(jsonData);
+      return data;
+    } catch (e) {
+      console.error("Failed to parse SSE event data:", jsonData, e);
+      throw new Error(
+        `Failed to parse SSE event data: "${jsonData.substring(0, 100)}...". Original error: ${e instanceof Error && e.message || "Unknown error"}`
+      );
+    }
+  }
+  static mapToError(error) {
+    switch (error.code) {
+      case A2A_ERROR_CODE.TASK_NOT_FOUND:
+        return new TaskNotFoundError(error.message);
+      case A2A_ERROR_CODE.TASK_NOT_CANCELABLE:
+        return new TaskNotCancelableError(error.message);
+      case A2A_ERROR_CODE.PUSH_NOTIFICATION_NOT_SUPPORTED:
+        return new PushNotificationNotSupportedError(error.message);
+      case A2A_ERROR_CODE.UNSUPPORTED_OPERATION:
+        return new UnsupportedOperationError(error.message);
+      case A2A_ERROR_CODE.CONTENT_TYPE_NOT_SUPPORTED:
+        return new ContentTypeNotSupportedError(error.message);
+      case A2A_ERROR_CODE.INVALID_AGENT_RESPONSE:
+        return new InvalidAgentResponseError(error.message);
+      case A2A_ERROR_CODE.AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED:
+        return new AuthenticatedExtendedCardNotConfiguredError(error.message);
+      default:
+        return new Error(
+          `REST error: ${error.message} (Code: ${error.code})${error.data ? ` Data: ${JSON.stringify(error.data)}` : ""}`
+        );
+    }
+  }
+};
+var RestTransportFactory = class _RestTransportFactory {
+  constructor(options) {
+    this.options = options;
+  }
+  static name = "HTTP+JSON";
+  get protocolName() {
+    return _RestTransportFactory.name;
+  }
+  async create(url, _agentCard) {
+    return new RestTransport({
+      endpoint: url,
+      fetchImpl: this.options?.fetchImpl
+    });
+  }
+};
+
 // src/client/factory.ts
 var ClientFactoryOptions = {
   /**
    * SDK default options for {@link ClientFactory}.
    */
   default: {
-    transports: [new JsonRpcTransportFactory()]
+    transports: [new JsonRpcTransportFactory(), new RestTransportFactory()]
   },
   /**
    * Creates new options by merging an original and an override object.
@@ -1337,15 +1566,24 @@ var ClientCallContextKey = class {
 0 && (module.exports = {
   A2AClient,
   AgentCardResolver,
+  AuthenticatedExtendedCardNotConfiguredError,
   Client,
   ClientCallContext,
   ClientCallContextKey,
   ClientFactory,
   ClientFactoryOptions,
+  ContentTypeNotSupportedError,
   DefaultAgentCardResolver,
+  InvalidAgentResponseError,
   JsonRpcTransport,
   JsonRpcTransportFactory,
+  PushNotificationNotSupportedError,
+  RestTransport,
+  RestTransportFactory,
   ServiceParameters,
+  TaskNotCancelableError,
+  TaskNotFoundError,
+  UnsupportedOperationError,
   createAuthenticatingFetchWithRetry,
   withA2AExtensions
 });

package/dist/client/index.d.cts

@@ -566,6 +566,28 @@ declare class ClientFactory {
     createFromUrl(baseUrl: string, path?: string): Promise<Client>;
 }
 
+declare class TaskNotFoundError extends Error {
+    constructor(message?: string);
+}
+declare class TaskNotCancelableError extends Error {
+    constructor(message?: string);
+}
+declare class PushNotificationNotSupportedError extends Error {
+    constructor(message?: string);
+}
+declare class UnsupportedOperationError extends Error {
+    constructor(message?: string);
+}
+declare class ContentTypeNotSupportedError extends Error {
+    constructor(message?: string);
+}
+declare class InvalidAgentResponseError extends Error {
+    constructor(message?: string);
+}
+declare class AuthenticatedExtendedCardNotConfiguredError extends Error {
+    constructor(message?: string);
+}
+
 interface JsonRpcTransportOptions {
     endpoint: string;
     fetchImpl?: typeof fetch;
@@ -590,7 +612,6 @@ declare class JsonRpcTransport implements Transport {
     private _sendRpcRequest;
     private _fetchRpc;
     private _sendStreamingRequest;
-    private _parseA2ASseStream;
     private _processSseEventData;
     private static mapToError;
 }
@@ -605,4 +626,41 @@ declare class JsonRpcTransportFactory implements TransportFactory {
     create(url: string, _agentCard: AgentCard): Promise<Transport>;
 }
 
-export { A2AClient, type A2AClientOptions, type AfterArgs, AgentCardResolver, type AgentCardResolverOptions, type AuthenticationHandler, type BeforeArgs, type CallInterceptor, Client, ClientCallContext, ClientCallContextKey, type ClientCallInput, type ClientCallResult, type ClientConfig, ClientFactory, ClientFactoryOptions, type ContextUpdate, DefaultAgentCardResolver, type HttpHeaders, JsonRpcTransport, JsonRpcTransportFactory, type JsonRpcTransportOptions, type RequestOptions, ServiceParameters, type ServiceParametersUpdate, type Transport, type TransportFactory, createAuthenticatingFetchWithRetry, withA2AExtensions };
+interface RestTransportOptions {
+    endpoint: string;
+    fetchImpl?: typeof fetch;
+}
+declare class RestTransport implements Transport {
+    private readonly customFetchImpl?;
+    private readonly endpoint;
+    constructor(options: RestTransportOptions);
+    getExtendedAgentCard(options?: RequestOptions): Promise<AgentCard>;
+    sendMessage(params: MessageSendParams, options?: RequestOptions): Promise<SendMessageResult>;
+    sendMessageStream(params: MessageSendParams, options?: RequestOptions): AsyncGenerator<A2AStreamEventData, void, undefined>;
+    setTaskPushNotificationConfig(params: TaskPushNotificationConfig, options?: RequestOptions): Promise<TaskPushNotificationConfig>;
+    getTaskPushNotificationConfig(params: GetTaskPushNotificationConfigParams, options?: RequestOptions): Promise<TaskPushNotificationConfig>;
+    listTaskPushNotificationConfig(params: ListTaskPushNotificationConfigParams, options?: RequestOptions): Promise<TaskPushNotificationConfig[]>;
+    deleteTaskPushNotificationConfig(params: DeleteTaskPushNotificationConfigParams, options?: RequestOptions): Promise<void>;
+    getTask(params: TaskQueryParams, options?: RequestOptions): Promise<Task>;
+    cancelTask(params: TaskIdParams, options?: RequestOptions): Promise<Task>;
+    resubscribeTask(params: TaskIdParams, options?: RequestOptions): AsyncGenerator<A2AStreamEventData, void, undefined>;
+    private _fetch;
+    private _buildHeaders;
+    private _sendRequest;
+    private _handleErrorResponse;
+    private _sendStreamingRequest;
+    private _processSseEventData;
+    private static mapToError;
+}
+interface RestTransportFactoryOptions {
+    fetchImpl?: typeof fetch;
+}
+declare class RestTransportFactory implements TransportFactory {
+    private readonly options?;
+    static readonly name: TransportProtocolName;
+    constructor(options?: RestTransportFactoryOptions);
+    get protocolName(): string;
+    create(url: string, _agentCard: AgentCard): Promise<Transport>;
+}
+
+export { A2AClient, type A2AClientOptions, type AfterArgs, AgentCardResolver, type AgentCardResolverOptions, AuthenticatedExtendedCardNotConfiguredError, type AuthenticationHandler, type BeforeArgs, type CallInterceptor, Client, ClientCallContext, ClientCallContextKey, type ClientCallInput, type ClientCallResult, type ClientConfig, ClientFactory, ClientFactoryOptions, ContentTypeNotSupportedError, type ContextUpdate, DefaultAgentCardResolver, type HttpHeaders, InvalidAgentResponseError, JsonRpcTransport, JsonRpcTransportFactory, type JsonRpcTransportOptions, PushNotificationNotSupportedError, type RequestOptions, RestTransport, RestTransportFactory, type RestTransportOptions, ServiceParameters, type ServiceParametersUpdate, TaskNotCancelableError, TaskNotFoundError, type Transport, type TransportFactory, UnsupportedOperationError, createAuthenticatingFetchWithRetry, withA2AExtensions };