@mailmodo/a2a 0.3.5 → 0.3.7

package/dist/client/index.js

@@ -21,20 +21,48 @@ 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,
-  createAuthenticatingFetchWithRetry: () => createAuthenticatingFetchWithRetry
+  PushNotificationNotSupportedError: () => PushNotificationNotSupportedError,
+  RestTransport: () => RestTransport,
+  RestTransportFactory: () => RestTransportFactory,
+  ServiceParameters: () => ServiceParameters,
+  TaskNotCancelableError: () => TaskNotCancelableError,
+  TaskNotFoundError: () => TaskNotFoundError,
+  UnsupportedOperationError: () => UnsupportedOperationError,
+  createAuthenticatingFetchWithRetry: () => createAuthenticatingFetchWithRetry,
+  withA2AExtensions: () => withA2AExtensions
 });
 module.exports = __toCommonJS(client_exports);
 
 // src/constants.ts
 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");
@@ -78,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;
@@ -87,6 +147,10 @@ var JsonRpcTransport = class _JsonRpcTransport {
     this.endpoint = options.endpoint;
     this.customFetchImpl = options.fetchImpl;
   }
+  async getExtendedAgentCard(options, idOverride) {
+    const rpcResponse = await this._sendRpcRequest("agent/getAuthenticatedExtendedCard", void 0, idOverride, options);
+    return rpcResponse.result;
+  }
   async sendMessage(params, options, idOverride) {
     const rpcResponse = await this._sendRpcRequest(
       "message/send",
@@ -162,7 +226,7 @@ var JsonRpcTransport = class _JsonRpcTransport {
       params,
       id: requestId
     };
-    const httpResponse = await this._fetchRpc(rpcRequest, "application/json", options?.signal);
+    const httpResponse = await this._fetchRpc(rpcRequest, "application/json", options);
     if (!httpResponse.ok) {
       let errorBodyText = "(empty or non-JSON response)";
       let errorJson;
@@ -194,15 +258,16 @@ var JsonRpcTransport = class _JsonRpcTransport {
     }
     return rpcResponse;
   }
-  async _fetchRpc(rpcRequest, acceptHeader = "application/json", signal) {
+  async _fetchRpc(rpcRequest, acceptHeader = "application/json", options) {
     const requestInit = {
       method: "POST",
       headers: {
+        ...options?.serviceParameters,
         "Content-Type": "application/json",
         Accept: acceptHeader
       },
       body: JSON.stringify(rpcRequest),
-      signal
+      signal: options?.signal
     };
     return this._fetch(this.endpoint, requestInit);
   }
@@ -214,7 +279,7 @@ var JsonRpcTransport = class _JsonRpcTransport {
       params,
       id: clientRequestId
     };
-    const response = await this._fetchRpc(rpcRequest, "text/event-stream", options?.signal);
+    const response = await this._fetchRpc(rpcRequest, "text/event-stream", options);
     if (!response.ok) {
       let errorBody = "";
       let errorJson;
@@ -241,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) {
@@ -297,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(
@@ -827,7 +845,7 @@ var DefaultAgentCardResolver = class {
   }
 };
 var AgentCardResolver = {
-  Default: new DefaultAgentCardResolver()
+  default: new DefaultAgentCardResolver()
 };
 
 // src/client/multitransport-client.ts
@@ -837,6 +855,20 @@ var Client = class {
     this.agentCard = agentCard;
     this.config = config;
   }
+  /**
+   * If the current agent card supports the extended feature, it will try to fetch the extended agent card from the server,
+   * Otherwise it will return the current agent card value.
+   */
+  async getAgentCard(options) {
+    if (this.agentCard.supportsAuthenticatedExtendedCard) {
+      this.agentCard = await this.executeWithInterceptors(
+        { method: "getAgentCard" },
+        options,
+        (_, options2) => this.transport.getExtendedAgentCard(options2)
+      );
+    }
+    return this.agentCard;
+  }
   /**
    * Sends a message to an agent to initiate a new interaction or to continue an existing one.
    * Uses blocking mode by default.
@@ -861,6 +893,7 @@ var Client = class {
     params = this.applyClientConfig({ params, blocking: true });
     const beforeArgs = {
       input: { method, value: params },
+      agentCard: this.agentCard,
       options
     };
     const beforeResult = await this.interceptBefore(beforeArgs);
@@ -868,6 +901,7 @@ var Client = class {
       const earlyReturn = beforeResult.earlyReturn.value;
       const afterArgs = {
         result: { method, value: earlyReturn },
+        agentCard: this.agentCard,
         options: beforeArgs.options
       };
       await this.interceptAfter(afterArgs, beforeResult.executed);
@@ -878,6 +912,7 @@ var Client = class {
       const result = await this.transport.sendMessage(beforeArgs.input.value, beforeArgs.options);
       const afterArgs = {
         result: { method, value: result },
+        agentCard: this.agentCard,
         options: beforeArgs.options
       };
       await this.interceptAfter(afterArgs);
@@ -890,6 +925,7 @@ var Client = class {
     )) {
       const afterArgs = {
         result: { method, value: event },
+        agentCard: this.agentCard,
         options: beforeArgs.options
       };
       await this.interceptAfter(afterArgs);
@@ -977,12 +1013,17 @@ var Client = class {
    */
   async *resubscribeTask(params, options) {
     const method = "resubscribeTask";
-    const beforeArgs = { input: { method, value: params }, options };
+    const beforeArgs = {
+      input: { method, value: params },
+      agentCard: this.agentCard,
+      options
+    };
     const beforeResult = await this.interceptBefore(beforeArgs);
     if (beforeResult) {
       const earlyReturn = beforeResult.earlyReturn.value;
       const afterArgs = {
         result: { method, value: earlyReturn },
+        agentCard: this.agentCard,
         options: beforeArgs.options
       };
       await this.interceptAfter(afterArgs, beforeResult.executed);
@@ -995,6 +1036,7 @@ var Client = class {
     )) {
       const afterArgs = {
         result: { method, value: event },
+        agentCard: this.agentCard,
         options: beforeArgs.options
       };
       await this.interceptAfter(afterArgs);
@@ -1021,6 +1063,7 @@ var Client = class {
   async executeWithInterceptors(input, options, transportCall) {
     const beforeArgs = {
       input,
+      agentCard: this.agentCard,
       options
     };
     const beforeResult = await this.interceptBefore(beforeArgs);
@@ -1030,6 +1073,7 @@ var Client = class {
           method: input.method,
           value: beforeResult.earlyReturn.value
         },
+        agentCard: this.agentCard,
         options: beforeArgs.options
       };
       await this.interceptAfter(afterArgs2, beforeResult.executed);
@@ -1038,6 +1082,7 @@ var Client = class {
     const result = await transportCall(beforeArgs.input.value, beforeArgs.options);
     const afterArgs = {
       result: { method: input.method, value: result },
+      agentCard: this.agentCard,
       options: beforeArgs.options
     };
     await this.interceptAfter(afterArgs);
@@ -1060,10 +1105,8 @@ var Client = class {
     }
   }
   async interceptAfter(args, interceptors) {
-    if (!this.config?.interceptors || this.config.interceptors.length === 0) {
-      return;
-    }
-    for (const interceptor of interceptors ?? this.config.interceptors) {
+    const reversedInterceptors = [...interceptors ?? this.config?.interceptors ?? []].reverse();
+    for (const interceptor of reversedInterceptors) {
       await interceptor.after(args);
       if (args.earlyReturn) {
         return;
@@ -1072,35 +1115,283 @@ 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 = {
-  Default: {
-    transports: [new JsonRpcTransportFactory()]
+  /**
+   * SDK default options for {@link ClientFactory}.
+   */
+  default: {
+    transports: [new JsonRpcTransportFactory(), new RestTransportFactory()]
+  },
+  /**
+   * Creates new options by merging an original and an override object.
+   * Transports are merged based on `TransportFactory.protocolName`,
+   * interceptors are concatenated, other fields are overriden.
+   *
+   * @example
+   * ```ts
+   * const options = ClientFactoryOptions.createFrom(ClientFactoryOptions.default, {
+   *  transports: [new MyCustomTransportFactory()], // adds a custom transport
+   *  clientConfig: { interceptors: [new MyInterceptor()] }, // adds a custom interceptor
+   * });
+   * ```
+   */
+  createFrom(original, overrides) {
+    return {
+      ...original,
+      ...overrides,
+      transports: mergeTransports(original.transports, overrides.transports),
+      clientConfig: {
+        ...original.clientConfig ?? {},
+        ...overrides.clientConfig ?? {},
+        interceptors: mergeArrays(
+          original.clientConfig?.interceptors,
+          overrides.clientConfig?.interceptors
+        ),
+        acceptedOutputModes: overrides.clientConfig?.acceptedOutputModes ?? original.clientConfig?.acceptedOutputModes
+      },
+      preferredTransports: overrides.preferredTransports ?? original.preferredTransports
+    };
   }
 };
 var ClientFactory = class {
-  constructor(options = ClientFactoryOptions.Default) {
+  constructor(options = ClientFactoryOptions.default) {
     this.options = options;
     if (!options.transports || options.transports.length === 0) {
       throw new Error("No transports provided");
     }
-    for (const transport of options.transports) {
-      if (this.transportsByName.has(transport.protocolName)) {
-        throw new Error(`Duplicate transport name: ${transport.protocolName}`);
-      }
-      this.transportsByName.set(transport.protocolName, transport);
-    }
+    this.transportsByName = transportsByName(options.transports);
     for (const transport of options.preferredTransports ?? []) {
-      const factory = this.options.transports.find((t) => t.protocolName === transport);
-      if (!factory) {
+      if (!this.transportsByName.has(transport)) {
         throw new Error(
           `Unknown preferred transport: ${transport}, available transports: ${[...this.transportsByName.keys()].join()}`
         );
       }
     }
-    this.agentCardResolver = options.cardResolver ?? AgentCardResolver.Default;
+    this.agentCardResolver = options.cardResolver ?? AgentCardResolver.default;
   }
-  transportsByName = /* @__PURE__ */ new Map();
+  transportsByName;
   agentCardResolver;
   /**
    * Creates a new client from the provided agent card.
@@ -1108,7 +1399,7 @@ var ClientFactory = class {
   async createFromAgentCard(agentCard) {
     const agentCardPreferred = agentCard.preferredTransport ?? JsonRpcTransportFactory.name;
     const additionalInterfaces = agentCard.additionalInterfaces ?? [];
-    const urlsPerAgentTransports = new Map([
+    const urlsPerAgentTransports = new CaseInsensitiveMap([
       [agentCardPreferred, agentCard.url],
       ...additionalInterfaces.map((i) => [i.transport, i.url])
     ]);
@@ -1138,21 +1429,177 @@ var ClientFactory = class {
   /**
    * Downloads agent card using AgentCardResolver from options
    * and creates a new client from the downloaded card.
+   *
+   * @example
+   * ```ts
+   * const factory = new ClientFactory(); // use default options and default {@link AgentCardResolver}.
+   * const client1 = await factory.createFromUrl('https://example.com'); // /.well-known/agent-card.json is used by default
+   * const client2 = await factory.createFromUrl('https://example.com', '/my-agent-card.json'); // specify custom path
+   * const client3 = await factory.createFromUrl('https://example.com/my-agent-card.json', ''); // specify full URL and set path to empty
+   * ```
    */
-  async createFromAgentCardUrl(baseUrl, path) {
+  async createFromUrl(baseUrl, path) {
     const agentCard = await this.agentCardResolver.resolve(baseUrl, path);
-    return await this.createFromAgentCard(agentCard);
+    return this.createFromAgentCard(agentCard);
+  }
+};
+function mergeTransports(original, overrides) {
+  if (!overrides) {
+    return original;
+  }
+  const result = transportsByName(original);
+  const overridesByName = transportsByName(overrides);
+  for (const [name, factory] of overridesByName) {
+    result.set(name, factory);
+  }
+  return Array.from(result.values());
+}
+function transportsByName(transports) {
+  const result = new CaseInsensitiveMap();
+  if (!transports) {
+    return result;
+  }
+  for (const t of transports) {
+    if (result.has(t.protocolName)) {
+      throw new Error(`Duplicate protocol name: ${t.protocolName}`);
+    }
+    result.set(t.protocolName, t);
+  }
+  return result;
+}
+function mergeArrays(a1, a2) {
+  if (!a1 && !a2) {
+    return void 0;
+  }
+  return [...a1 ?? [], ...a2 ?? []];
+}
+var CaseInsensitiveMap = class extends Map {
+  normalizeKey(key) {
+    return key.toUpperCase();
+  }
+  set(key, value) {
+    return super.set(this.normalizeKey(key), value);
+  }
+  get(key) {
+    return super.get(this.normalizeKey(key));
+  }
+  has(key) {
+    return super.has(this.normalizeKey(key));
+  }
+  delete(key) {
+    return super.delete(this.normalizeKey(key));
+  }
+};
+
+// 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(",");
+  }
+};
+
+// src/client/service-parameters.ts
+var ServiceParameters = {
+  create(...updates) {
+    return ServiceParameters.createFrom(void 0, ...updates);
+  },
+  createFrom: (serviceParameters, ...updates) => {
+    const result = serviceParameters ? { ...serviceParameters } : {};
+    for (const update of updates) {
+      update(result);
+    }
+    return result;
+  }
+};
+function withA2AExtensions(...extensions) {
+  return (parameters) => {
+    parameters[HTTP_EXTENSION_HEADER] = Extensions.toServiceParameter(extensions);
+  };
+}
+
+// src/client/context.ts
+var ClientCallContext = {
+  /**
+   * Create a new {@link ClientCallContext} with optional updates applied.
+   */
+  create: (...updates) => {
+    return ClientCallContext.createFrom(void 0, ...updates);
+  },
+  /**
+   * Create a new {@link ClientCallContext} based on an existing one with updates applied.
+   */
+  createFrom: (context, ...updates) => {
+    const result = context ? { ...context } : {};
+    for (const update of updates) {
+      update(result);
+    }
+    return result;
+  }
+};
+var ClientCallContextKey = class {
+  symbol;
+  constructor(description) {
+    this.symbol = Symbol(description);
+  }
+  set(value) {
+    return (context) => {
+      context[this.symbol] = value;
+    };
+  }
+  get(context) {
+    return context[this.symbol];
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   A2AClient,
   AgentCardResolver,
+  AuthenticatedExtendedCardNotConfiguredError,
   Client,
+  ClientCallContext,
+  ClientCallContextKey,
   ClientFactory,
   ClientFactoryOptions,
+  ContentTypeNotSupportedError,
   DefaultAgentCardResolver,
+  InvalidAgentResponseError,
   JsonRpcTransport,
   JsonRpcTransportFactory,
-  createAuthenticatingFetchWithRetry
+  PushNotificationNotSupportedError,
+  RestTransport,
+  RestTransportFactory,
+  ServiceParameters,
+  TaskNotCancelableError,
+  TaskNotFoundError,
+  UnsupportedOperationError,
+  createAuthenticatingFetchWithRetry,
+  withA2AExtensions
 });