@a2a-js/sdk 0.3.6 → 0.3.7

package/dist/client/index.d.ts

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

package/dist/client/index.js

@@ -1,3 +1,14 @@
+import {
+  A2A_ERROR_CODE,
+  AuthenticatedExtendedCardNotConfiguredError,
+  ContentTypeNotSupportedError,
+  InvalidAgentResponseError,
+  PushNotificationNotSupportedError,
+  TaskNotCancelableError,
+  TaskNotFoundError,
+  UnsupportedOperationError,
+  parseSseStream
+} from "../chunk-SJNAG4AL.js";
 import {
   AGENT_CARD_PATH,
   HTTP_EXTENSION_HEADER
@@ -6,50 +17,6 @@ import {
   Extensions
 } from "../chunk-ZX6KNMCP.js";
 
-// src/errors.ts
-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/client/transports/json_rpc_transport.ts
 var JsonRpcTransport = class _JsonRpcTransport {
   customFetchImpl;
@@ -218,55 +185,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) {
@@ -274,7 +194,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(
@@ -1074,13 +994,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.
@@ -1268,15 +1409,24 @@ var ClientCallContextKey = class {
 export {
   A2AClient,
   AgentCardResolver,
+  AuthenticatedExtendedCardNotConfiguredError,
   Client,
   ClientCallContext,
   ClientCallContextKey,
   ClientFactory,
   ClientFactoryOptions,
+  ContentTypeNotSupportedError,
   DefaultAgentCardResolver,
+  InvalidAgentResponseError,
   JsonRpcTransport,
   JsonRpcTransportFactory,
+  PushNotificationNotSupportedError,
+  RestTransport,
+  RestTransportFactory,
   ServiceParameters,
+  TaskNotCancelableError,
+  TaskNotFoundError,
+  UnsupportedOperationError,
   createAuthenticatingFetchWithRetry,
   withA2AExtensions
 };

package/dist/server/express/index.cjs

@@ -498,6 +498,22 @@ var A2AExpressApp = class {
 // src/server/express/rest_handler.ts
 var import_express4 = __toESM(require("express"), 1);
 
+// 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
+};
+
 // src/server/transports/rest/rest_transport_handler.ts
 var HTTP_STATUS = {
   OK: 200,
@@ -511,17 +527,6 @@ var HTTP_STATUS = {
   INTERNAL_SERVER_ERROR: 500,
   NOT_IMPLEMENTED: 501
 };
-var A2A_ERROR_CODE = {
-  PARSE_ERROR: -32700,
-  INVALID_REQUEST: -32600,
-  METHOD_NOT_FOUND: -32601,
-  INVALID_PARAMS: -32602,
-  TASK_NOT_FOUND: -32001,
-  TASK_NOT_CANCELABLE: -32002,
-  PUSH_NOTIFICATION_NOT_SUPPORTED: -32003,
-  UNSUPPORTED_OPERATION: -32004,
-  UNAUTHORIZED: -32005
-};
 function mapErrorToStatus(errorCode) {
   switch (errorCode) {
     case A2A_ERROR_CODE.PARSE_ERROR:
@@ -536,8 +541,6 @@ function mapErrorToStatus(errorCode) {
     case A2A_ERROR_CODE.PUSH_NOTIFICATION_NOT_SUPPORTED:
     case A2A_ERROR_CODE.UNSUPPORTED_OPERATION:
       return HTTP_STATUS.BAD_REQUEST;
-    case A2A_ERROR_CODE.UNAUTHORIZED:
-      return HTTP_STATUS.UNAUTHORIZED;
     default:
       return HTTP_STATUS.INTERNAL_SERVER_ERROR;
   }
@@ -569,8 +572,8 @@ var RestTransportHandler = class _RestTransportHandler {
   /**
    * Gets the authenticated extended agent card.
    */
-  async getAuthenticatedExtendedAgentCard() {
-    return this.requestHandler.getAuthenticatedExtendedAgentCard();
+  async getAuthenticatedExtendedAgentCard(context) {
+    return this.requestHandler.getAuthenticatedExtendedAgentCard(context);
   }
   /**
    * Sends a message to the agent.
@@ -883,7 +886,7 @@ function restHandler(options) {
     "/v1/card",
     asyncHandler(async (req, res) => {
       const context = await buildContext(req);
-      const result = await restTransportHandler.getAuthenticatedExtendedAgentCard();
+      const result = await restTransportHandler.getAuthenticatedExtendedAgentCard(context);
       sendResponse(res, HTTP_STATUS.OK, context, result);
     })
   );

package/dist/server/express/index.js

@@ -1,3 +1,9 @@
+import {
+  A2A_ERROR_CODE,
+  SSE_HEADERS,
+  formatSSEErrorEvent,
+  formatSSEEvent
+} from "../../chunk-SJNAG4AL.js";
 import {
   AGENT_CARD_PATH,
   HTTP_EXTENSION_HEADER
@@ -17,28 +23,6 @@ import express3 from "express";
 
 // src/server/express/json_rpc_handler.ts
 import express from "express";
-
-// 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)}
-
-`;
-}
-
-// src/server/express/json_rpc_handler.ts
 function jsonRpcHandler(options) {
   const jsonRpcTransportHandler = new JsonRpcTransportHandler(options.requestHandler);
   const router = express.Router();
@@ -196,17 +180,6 @@ var HTTP_STATUS = {
   INTERNAL_SERVER_ERROR: 500,
   NOT_IMPLEMENTED: 501
 };
-var A2A_ERROR_CODE = {
-  PARSE_ERROR: -32700,
-  INVALID_REQUEST: -32600,
-  METHOD_NOT_FOUND: -32601,
-  INVALID_PARAMS: -32602,
-  TASK_NOT_FOUND: -32001,
-  TASK_NOT_CANCELABLE: -32002,
-  PUSH_NOTIFICATION_NOT_SUPPORTED: -32003,
-  UNSUPPORTED_OPERATION: -32004,
-  UNAUTHORIZED: -32005
-};
 function mapErrorToStatus(errorCode) {
   switch (errorCode) {
     case A2A_ERROR_CODE.PARSE_ERROR:
@@ -221,8 +194,6 @@ function mapErrorToStatus(errorCode) {
     case A2A_ERROR_CODE.PUSH_NOTIFICATION_NOT_SUPPORTED:
     case A2A_ERROR_CODE.UNSUPPORTED_OPERATION:
       return HTTP_STATUS.BAD_REQUEST;
-    case A2A_ERROR_CODE.UNAUTHORIZED:
-      return HTTP_STATUS.UNAUTHORIZED;
     default:
       return HTTP_STATUS.INTERNAL_SERVER_ERROR;
   }
@@ -254,8 +225,8 @@ var RestTransportHandler = class _RestTransportHandler {
   /**
    * Gets the authenticated extended agent card.
    */
-  async getAuthenticatedExtendedAgentCard() {
-    return this.requestHandler.getAuthenticatedExtendedAgentCard();
+  async getAuthenticatedExtendedAgentCard(context) {
+    return this.requestHandler.getAuthenticatedExtendedAgentCard(context);
   }
   /**
    * Sends a message to the agent.
@@ -568,7 +539,7 @@ function restHandler(options) {
     "/v1/card",
     asyncHandler(async (req, res) => {
       const context = await buildContext(req);
-      const result = await restTransportHandler.getAuthenticatedExtendedAgentCard();
+      const result = await restTransportHandler.getAuthenticatedExtendedAgentCard(context);
       sendResponse(res, HTTP_STATUS.OK, context, result);
     })
   );