@artinet/sdk 0.6.0-preview.2 → 0.6.0

package/dist/browser/transport/rpc/rpc-client.js

@@ -1,189 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * HTTP JSON-RPC client utilities.
- * Handles the common pattern of sending JSON-RPC requests and processing responses.
- */
-import { v4 as uuidv4 } from "uuid";
-import { SystemError, INTERNAL_ERROR, PARSE_ERROR, } from "../../utils/common/errors.js";
-import { parseResponse } from "./parser.js";
-import { logger } from "../../config/index.js";
-/**
- * Creates a JSON-RPC request body with the specified method and parameters.
- *, ErrorCodeParseError
- * @param method The JSON-RPC method name
- * @param params The parameters for the method
- * @param requestId Optional request ID (generates a UUID v4 if not provided)
- * @returns A properly formatted JSON-RPC request object
- */
-export function createJsonRpcRequest(method, params, requestId = uuidv4()) {
-    return {
-        jsonrpc: "2.0",
-        id: requestId,
-        method,
-        params,
-    };
-}
-/**
- * Sends a JSON-RPC request to the specified endpoint.
- *
- * @param baseUrl The API endpoint URL
- * @param method The JSON-RPC method name
- * @param params The parameters for the method
- * @param headers Custom headers to include in the request
- * @param acceptHeader The desired Accept header ('application/json' or 'text/event-stream')
- * @returns A Promise resolving to the fetch Response object
- * @throws RpcError if there's a network error
- */
-export async function sendJsonRpcRequest(baseUrl, method, params, headers = {}, acceptHeader = "application/json") {
-    const requestBody = createJsonRpcRequest(method, params);
-    try {
-        return await fetch(baseUrl, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "Access-Control-Allow-Origin": "*",
-                Accept: acceptHeader,
-                ...headers,
-            },
-            priority: "high",
-            mode: "cors",
-            keepalive: true,
-            body: JSON.stringify(requestBody),
-        });
-    }
-    catch (networkError) {
-        logger.error("SendJsonRpcRequest: Network error during RPC call:", networkError);
-        // Wrap network errors into a standard error format
-        throw INTERNAL_ERROR(networkError);
-    }
-}
-/**
- * Sends a GET request to the specified endpoint.
- * This is used for non-JSON-RPC calls like agent card retrieval.
- *
- * @param url The endpoint URL
- * @param headers Custom headers to include in the request
- * @returns A Promise resolving to the fetch Response object
- * @throws RpcError if there's a network error
- */
-export async function sendGetRequest(url, headers = {}) {
-    try {
-        return await fetch(url, {
-            method: "GET",
-            headers: {
-                Accept: "application/json",
-                ...headers,
-            },
-        });
-    }
-    catch (networkError) {
-        logger.error("SendGetRequest: Network error during GET request:", networkError);
-        throw INTERNAL_ERROR(networkError);
-    }
-}
-/**
- * Processes a standard JSON-RPC response (non-streaming).
- * Parses the response, validates it, and returns the result payload.
- *
- * @param response The fetch Response object
- * @param expectedMethod Optional method name for logging purposes
- * @returns A promise resolving to the result payload
- * @throws RpcError if there's an error in the response
- */
-export async function handleJsonRpcResponse(response, expectedMethod) {
-    let responseBody = null;
-    try {
-        responseBody = await response.text();
-        if (!response.ok) {
-            try {
-                // Try to parse error as JSON-RPC
-                parseResponse(responseBody);
-                // If we get here, it means there was no error in the response
-                // But the HTTP status was not OK, so we throw a generic error
-            }
-            catch (parseError) {
-                logger.warn("handleJsonRpcResponse", "Error parsing JSON-RPC response:", parseError);
-            }
-            // Throw a generic HTTP error if we couldn't extract an RPC error
-            throw new Error(`HTTP error ${response.status}: ${response.statusText}${responseBody ? ` - ${responseBody}` : ""}`);
-        }
-        // Parse and validate the response
-        // If it has an error, parseResponse will throw
-        // If it doesn't have a result, parseResponse will also throw
-        const jsonResponse = parseResponse(responseBody);
-        // At this point, we know we have a valid result
-        // NonNullable is used in the return type to ensure TypeScript knows this
-        return jsonResponse.result;
-    }
-    catch (error) {
-        logger.error(`handleJsonRpcResponse: Error processing response [${expectedMethod}]:`, error);
-        // Re-throw RpcError instances directly, wrap others
-        if (error instanceof SystemError) {
-            throw error;
-        }
-        else {
-            throw INTERNAL_ERROR(error);
-        }
-    }
-}
-/**
- * Processes a JSON response from a regular GET request.
- * Handles error checking and returns the parsed JSON.
- *
- * @param response The fetch Response object
- * @param endpoint Optional endpoint description for logging purposes
- * @returns A promise resolving to the parsed JSON
- * @throws RpcError if there's a response error
- */
-export async function handleJsonResponse(response, endpoint) {
-    let responseBody = null;
-    try {
-        responseBody = await response.text();
-        if (!response.ok) {
-            throw new Error(`HTTP error ${response.status}: ${response.statusText}${responseBody ? ` - ${responseBody}` : ""}`);
-        }
-        return JSON.parse(responseBody);
-    }
-    catch (error) {
-        logger.error(`handleJsonResponse: Error processing response for ${endpoint || "unknown endpoint"}:`, error);
-        if (error instanceof SystemError) {
-            throw error;
-        }
-        else {
-            throw PARSE_ERROR(error);
-        }
-    }
-}
-/**
- * Sends a JSON-RPC request and processes the response in a single operation.
- * This combines sendJsonRpcRequest and handleJsonRpcResponse into one call.
- *
- * @param baseUrl The API endpoint URL
- * @param method The JSON-RPC method name
- * @param params The parameters for the method
- * @param headers Custom headers to include in the request
- * @param acceptHeader The desired Accept header ('application/json' or 'text/event-stream')
- * @returns A Promise resolving to the result payload
- * @throws RpcError if there's a network error or error in the response
- */
-export async function executeJsonRpcRequest(baseUrl, method, params, headers = {}, acceptHeader = "application/json") {
-    const response = await sendJsonRpcRequest(baseUrl, method, params, headers, acceptHeader);
-    return handleJsonRpcResponse(response, method);
-}
-/**
- * Sends a GET request and processes the JSON response.
- * Helper for non-RPC REST endpoints.
- *
- * @param url The endpoint URL
- * @param headers Custom headers to include in the request
- * @param endpoint Optional endpoint description for logging
- * @returns A Promise resolving to the parsed JSON
- * @throws RpcError if there's a network error or error in the response
- */
-export async function executeGetRequest(url, headers = {}, endpoint) {
-    const response = await sendGetRequest(url, headers);
-    return handleJsonResponse(response, endpoint);
-}

package/dist/browser/transport/streaming/event-stream.d.ts

@@ -1,25 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import { A2A, MCP } from "../../types/index.js";
-/**
- * Creates an async generator for processing task events from an SSE stream
- *
- * @template T The type of task event to process (TaskStatusUpdateEvent or TaskArtifactUpdateEvent)
- * @param response The fetch Response object containing the event stream
- * @returns An async generator yielding the specified type of task events from StreamingResponse
- */
-export declare function handleEventStream<StreamRes extends MCP.JSONRPCResultResponse>(response: Response): AsyncGenerator<NonNullable<StreamRes["result"]>>;
-/**
- * Executes a streaming JSON-RPC request and yields events as they arrive
- *
- * @template Req The type of request being made
- * @template StreamRes The type of streaming response expected
- * @param baseUrl The base URL for the API
- * @param method The JSON-RPC method to call
- * @param params The parameters for the method
- * @param customHeaders Any custom headers to include in the request
- * @returns An AsyncIterable yielding events from the stream
- */
-export declare function executeStreamEvents<Req extends A2A.A2ARequest, StreamRes extends MCP.JSONRPCResultResponse>(baseUrl: URL, method: Req["method"], params: Req["params"], customHeaders: Record<string, string>): AsyncIterable<NonNullable<StreamRes["result"]>>;

package/dist/browser/transport/streaming/event-stream.js

@@ -1,100 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * Event stream utilities for handling Server-Sent Events (SSE).
- */
-import { parseResponse } from "../rpc/parser.js";
-import { createParser, } from "eventsource-parser";
-import { sendJsonRpcRequest } from "../rpc/rpc-client.js";
-import { logger } from "../../config/index.js";
-/**
- * Creates an async generator for processing task events from an SSE stream
- *
- * @template T The type of task event to process (TaskStatusUpdateEvent or TaskArtifactUpdateEvent)
- * @param response The fetch Response object containing the event stream
- * @returns An async generator yielding the specified type of task events from StreamingResponse
- */
-export async function* handleEventStream(response) {
-    if (!response.ok || !response.body) {
-        let errorText = null;
-        try {
-            errorText = await response.text();
-        }
-        catch (_) { }
-        const err = new Error(`HTTP error [${response.status}:${response.statusText}] - ${errorText}`);
-        logger.error(`handleEventStream: HTTP error [${response.status}:${response.statusText}] - ${errorText}`, err);
-        throw err;
-    }
-    // Use eventsource-parser to process the SSE stream
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    const events = [];
-    const parser = createParser({
-        onEvent: (event) => {
-            if (event.data) {
-                if (event.event === "close") {
-                    logger.debug("handleEventStream", "Stream closed");
-                    return;
-                }
-                try {
-                    const parsedData = parseResponse(event.data);
-                    const eventResult = parsedData.result;
-                    if (eventResult) {
-                        events.push(eventResult);
-                    }
-                    else {
-                        logger.warn("handleEventStream", "Failed to parse SSE data", parsedData);
-                    }
-                    // if (parsedData.final && parsedData.final === true) {
-                    //   logDebug("handleEventStream", "Stream completed");
-                    //   return;
-                    // }
-                }
-                catch (e) {
-                    logger.warn("handleEventStream", "Failed to parse SSE data", e);
-                }
-            }
-        },
-        onError: (error) => {
-            logger.error("handleEventStream: Error parsing SSE data", error);
-        },
-        onRetry: (retry) => {
-            logger.warn("handleEventStream", "Retrying SSE connection", retry);
-        },
-    });
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            const chunk = decoder.decode(value, { stream: true });
-            parser.feed(chunk);
-            while (events.length > 0) {
-                yield events.shift();
-            }
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-}
-/**
- * Executes a streaming JSON-RPC request and yields events as they arrive
- *
- * @template Req The type of request being made
- * @template StreamRes The type of streaming response expected
- * @param baseUrl The base URL for the API
- * @param method The JSON-RPC method to call
- * @param params The parameters for the method
- * @param customHeaders Any custom headers to include in the request
- * @returns An AsyncIterable yielding events from the stream
- */
-export async function* executeStreamEvents(baseUrl, method, params, customHeaders) {
-    logger.debug("executeStreamEvents", `Sending streaming request to: ${baseUrl.toString()}, method: ${method}`);
-    const responsePromise = sendJsonRpcRequest(baseUrl, method, params, customHeaders, "text/event-stream");
-    const response = await responsePromise;
-    logger.debug("executeStreamEvents", "Response", response);
-    yield* handleEventStream(response);
-}

package/dist/browser/types/client.d.ts

@@ -1,133 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import { A2A } from "./a2a/index.js";
-/**
- * @interface Client
- * @description Defines the standard contract for an A2A (Agent-to-Agent) client implementation.
- * This interface allows consumers to create custom client solutions while ensuring
- * compatibility with the A2A protocol. It outlines the core functionalities
- * required for interacting with an A2A agent server, including task management,
- * capability discovery, and communication configuration.
- */
-export interface Client {
-    /**
-     * @description Fetches the agent's metadata (AgentCard) from a well-known path or a fallback path.
-     * The AgentCard contains essential information about the agent, such as its capabilities and endpoints.
-     * @param {string} wellKnownPath The standard path (e.g., "/.well-known/a2a") to look for the AgentCard.
-     * @param {string} fallbackPath An alternative path to check if the well-known path fails.
-     * @returns {Promise<A2A.AgentCard>} A promise that resolves with the AgentCard object.
-     * @async
-     */
-    agentCard(): Promise<A2A.AgentCard>;
-    /**
-     * @description Refreshes the cached AgentCard information by re-fetching it from the server.
-     * Useful when the agent's capabilities or configuration might have changed.
-     * @returns {Promise<A2A.AgentCard>} A promise that resolves with the updated AgentCard object.
-     * @async
-     */
-    refreshAgentCard(): Promise<A2A.AgentCard>;
-    /**
-     * @description Sends a task request to the agent server.
-     * @param {A2A.MessageSendParams} params Parameters required to send the task, including the task definition and metadata.
-     * @returns {Promise<A2A.Task | null>} A promise that resolves with the initial Task object representing the submitted task, or null if the submission failed.
-     * @async
-     */
-    sendMessage(params: A2A.MessageSendParams): Promise<A2A.Message | A2A.Task | null>;
-    /**
-     * @deprecated Will be removed in v6.Use sendMessage instead.
-     * @description Sends a task request to the agent server.
-     * @param {MessageSendParams} params Parameters required to send the task, including the task definition and metadata.
-     * @returns {Promise<Task | null>} A promise that resolves with the initial Task object representing the submitted task, or null if the submission failed.
-     * @async
-     */
-    sendTask(params: A2A.MessageSendParams): Promise<A2A.Message | A2A.Task | null>;
-    /**
-     * @description Sends a task request and subscribes to real-time updates (status changes, artifact updates) for that task.
-     * This uses a streaming connection if available.
-     * @param {MessageSendParams} params Parameters required to send the task.
-     * @returns {AsyncIterable<UpdateEvent>} An async iterable that yields task status and artifact updates.
-     * @async
-     */
-    sendStreamingMessage(params: A2A.MessageSendParams): AsyncIterable<A2A.Update>;
-    /**
-     * @deprecated Will be removed in v6Use sendStreamingMessage instead.
-     * @description Sends a task request and subscribes to real-time updates (status changes, artifact updates) for that task.
-     * This uses a streaming connection if available.
-     * @param {MessageSendParams} params Parameters required to send the task.
-     * @returns {AsyncIterable<UpdateEvent>} An async iterable that yields task status and artifact updates.
-     * @async
-     */
-    sendTaskSubscribe(params: A2A.MessageSendParams): AsyncIterable<A2A.Update>;
-    /**
-     * @description Retrieves the current state of a specific task by its ID.
-     * @param {A2A.TaskQueryParams} params Parameters containing the task ID to query.
-     * @returns {Promise<A2A.Task | null>} A promise that resolves with the Task object, or null if the task is not found.
-     * @async
-     */
-    getTask(params: A2A.TaskQueryParams): Promise<A2A.Task | null>;
-    /**
-     * @description Sends a request to cancel an ongoing task.
-     * @param {A2A.TaskIdParams} params Parameters containing the ID of the task to cancel.
-     * @returns {Promise<A2A.Task | null>} A promise that resolves with the final state of the cancelled Task object, or null if cancellation failed or the task wasn't found.
-     * @async
-     */
-    cancelTask(params: A2A.TaskIdParams): Promise<A2A.Task | null>;
-    /**
-     * @description Configures push notifications for a specific task. This allows the client
-     * to receive updates asynchronously via a specified webhook URL.
-     * Requires the agent to support the 'pushNotifications' capability.
-     * @param {A2A.TaskPushNotificationConfig} params The configuration details for the push notification, including the task ID and webhook URL.
-     * @returns {Promise<A2A.TaskPushNotificationConfig | null>} A promise that resolves with the applied configuration, or null if the configuration failed.
-     * @async
-     */
-    setTaskPushNotification(params: A2A.TaskPushNotificationConfig): Promise<A2A.TaskPushNotificationConfig | null>;
-    /**
-     * @description Retrieves the current push notification configuration for a specific task.
-     * @param {A2A.TaskIdParams} params Parameters containing the task ID.
-     * @returns {Promise<A2A.TaskPushNotificationConfig | null>} A promise that resolves with the push notification configuration, or null if not configured or not found.
-     * @async
-     */
-    getTaskPushNotification(params: A2A.TaskIdParams): Promise<A2A.TaskPushNotificationConfig | null>;
-    /**
-     * @description Resubscribes to updates for an existing task, potentially after a connection drop or client restart.
-     * This allows resuming the stream of status and artifact updates.
-     * @param {A2A.TaskQueryParams} params Parameters containing the task ID to resubscribe to.
-     * @returns {AsyncIterable<UpdateEvent>} An async iterable that yields task status and artifact updates.
-     * @async
-     */
-    resubscribeTask(params: A2A.TaskQueryParams): AsyncIterable<A2A.Update>;
-    /**
-     * @description Checks if the agent server supports a specific capability.
-     * @param {"streaming" | "pushNotifications" | "stateTransitionHistory"} capability The capability to check for.
-     * @returns {Promise<boolean>} A promise that resolves to true if the capability is supported, false otherwise.
-     * @async
-     */
-    supports(capability: "streaming" | "pushNotifications" | "stateTransitionHistory"): Promise<boolean>;
-    /**
-     * @description Sets multiple HTTP headers to be included in all subsequent requests made by the client instance.
-     * Replaces any previously set headers.
-     * @param {Record<string, string>} headers An object containing header names and values.
-     * @returns {void}
-     */
-    setHeaders(headers: Record<string, string>): void;
-    /**
-     * @description Adds or updates a single HTTP header for subsequent requests.
-     * @param {string} name The name of the header.
-     * @param {string} value The value of the header.
-     * @returns {void}
-     */
-    addHeader(name: string, value: string): void;
-    /**
-     * @description Removes a specific HTTP header from subsequent requests.
-     * @param {string} name The name of the header to remove.
-     * @returns {void}
-     */
-    removeHeader(name: string): void;
-    /**
-     * @description Clears all custom HTTP headers previously set on the client instance.
-     * @returns {void}
-     */
-    clearHeaders(): void;
-}

package/dist/browser/types/client.js

@@ -1,5 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-export {};

package/dist/browser/utils/common/errors.js

@@ -1,95 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import { A2A } from "../../types/index.js";
-import * as describe from "../../create/describe.js";
-import { formatJson } from "./utils.js";
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export class SystemError extends Error {
-    constructor(message, code, data) {
-        super(message + " " + formatJson({ cause: data }));
-        // this.name = "RpcError";
-        this.message = message;
-        this.code = code;
-        this.data = data;
-    }
-}
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const PARSE_ERROR = (data) => new SystemError("Invalid JSON payload", A2A.ErrorCodeParseError, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const INVALID_REQUEST = (data) => new SystemError("Request payload validation error", A2A.ErrorCodeInvalidRequest, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const METHOD_NOT_FOUND = (data) => new SystemError("Method not found", A2A.ErrorCodeMethodNotFound, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const INVALID_PARAMS = (data) => new SystemError("Invalid parameters", A2A.ErrorCodeInvalidParams, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const INTERNAL_ERROR = (data) => new SystemError("Internal error", A2A.ErrorCodeInternalError, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const TASK_NOT_FOUND = (data) => new SystemError("Task not found", A2A.ErrorCodeTaskNotFound, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const TASK_NOT_CANCELABLE = (data) => new SystemError("Task cannot be canceled", A2A.ErrorCodeTaskNotCancelable, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const PUSH_NOTIFICATION_NOT_SUPPORTED = (data) => new SystemError("Push Notifications is not supported", A2A.ErrorCodePushNotificationNotSupported, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED = (data) => new SystemError("Authenticated Extended Card is not configured", A2A.ErrorCodeAuthenticatedExtendedCardNotConfigured, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const UNSUPPORTED_OPERATION = (data) => new SystemError("This operation is not supported", A2A.ErrorCodeUnsupportedOperation, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const CONTENT_TYPE_NOT_SUPPORTED = (data) => new SystemError("Content type not supported", A2A.ErrorCodeContentTypeNotSupported, data);
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export const INVALID_AGENT_RESPONSE = (data) => new SystemError("Invalid agent response", A2A.ErrorCodeInvalidAgentResponse, data);
-/**
- * @deprecated Use {@link describe.update.failed} instead
- * @since 0.6.0
- */
-export const FAILED_UPDATE = (taskId, contextId, messageId = "failed-update", errMessage) => {
-    return describe.update.failed({
-        taskId,
-        contextId,
-        final: true,
-        message: describe.message({
-            messageId,
-            parts: [{ kind: "text", text: errMessage }],
-        }),
-    });
-};

package/dist/client/a2a-client.d.ts

@@ -1,127 +0,0 @@
-/**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
- */
-import { A2A } from "../types/index.js";
-import type { Client } from "../types/client.js";
-/**
- * A2AClient is the main client class for interacting with Agent2Agent (A2A) protocol-compliant services.
- * It provides methods for sending tasks, retrieving statuses, canceling operations, and handling streaming responses.
- */
-export declare class A2AClient implements Client {
-    private baseUrl;
-    private cachedAgentCard;
-    private customHeaders;
-    private fallbackPath;
-    private agentUrl;
-    private mergePath;
-    /**
-     * Creates a new A2AClient instance.
-     * @param baseUrl The base URL for the A2A server.
-     * @param headers Optional custom headers to include in all requests.
-     * @param fallbackPath Optional fallback path to use if the agent card is not found at the base URL.
-     * @example
-     * const client = new A2AClient("http://localhost:4000/a2a");
-     * const card = await client.agentCard();
-     * console.log(card);
-     * @example
-     * const client = new A2AClient("http://localhost:4000/a2a", {}, "/agent-card");
-     * const card = await client.agentCard();
-     * console.log(card);
-     */
-    constructor(baseUrl: URL | string, headers?: Record<string, string>, fallbackPath?: string, mergePath?: boolean);
-    /**
-     * Retrieves the AgentCard from the A2A server.
-     * Caches the result after the first successful fetch.
-     * @returns A promise resolving to the AgentCard.
-     */
-    agentCard(): Promise<A2A.AgentCard>;
-    /**
-     * Retrieves the AgentCard from the A2A server.
-     * @returns A promise resolving to the AgentCard.
-     */
-    getAgentCard(): Promise<A2A.AgentCard>;
-    /**
-     * Refreshes the cached AgentCard by fetching it again from the server.
-     * @returns A promise resolving to the updated AgentCard.
-     */
-    refreshAgentCard(): Promise<A2A.AgentCard>;
-    sendMessage(params: A2A.MessageSendParams): Promise<A2A.Message | A2A.Task | null>;
-    sendMessage(params: string | A2A.MessageSendParams["message"]): Promise<A2A.Message | A2A.Task | null>;
-    /**
-     * @deprecated Use sendMessage instead.
-     * Sends a task request to the agent (non-streaming).
-     * @param params The parameters for the message/send method.
-     * @returns A promise resolving to the Task object or null.
-     */
-    sendTask(params: A2A.MessageSendParams): Promise<A2A.Message | A2A.Task | null>;
-    /**
-     * Sends a Message and returns a stream of status and artifact updates.
-     * @param params Task parameters for the request
-     * @returns An AsyncIterable that yields TaskStatusUpdateEvent/TaskArtifactUpdateEvent/Task/Message payloads.
-     */
-    sendStreamingMessage(params: A2A.MessageSendParams | string): AsyncIterable<A2A.Update>;
-    /**
-     * @deprecated Use sendStreamingMessage instead.
-     * Sends a task and returns a subscription to status and artifact updates.
-     * @param params Task parameters for the request
-     * @returns An AsyncIterable that yields TaskStatusUpdateEvent or TaskArtifactUpdateEvent payloads.
-     */
-    sendTaskSubscribe(params: A2A.MessageSendParams): AsyncIterable<A2A.Update>;
-    /**
-     * Retrieves the current state of a task.
-     * @param params The parameters for the tasks/get method.
-     * @returns A promise resolving to the Task object or null.
-     */
-    getTask(params: A2A.TaskQueryParams): Promise<A2A.Task | null>;
-    /**
-     * Cancels a currently running task.
-     * @param params The parameters for the tasks/cancel method.
-     * @returns A promise resolving to the updated Task object (usually canceled state) or null.
-     */
-    cancelTask(params: A2A.TaskIdParams): Promise<A2A.Task | null>;
-    /**
-     * Sets or updates the push notification config for a task.
-     * @param params The parameters for the tasks/pushNotificationConfig/set method (which is TaskPushNotificationConfig).
-     * @returns A promise resolving to the confirmed TaskPushNotificationConfig or null.
-     */
-    setTaskPushNotification(params: A2A.TaskPushNotificationConfig): Promise<A2A.TaskPushNotificationConfig | null>;
-    /**
-     * Retrieves the currently configured push notification config for a task.
-     * @param params The parameters for the tasks/pushNotificationConfig/get method.
-     * @returns A promise resolving to the TaskPushNotificationConfig or null.
-     */
-    getTaskPushNotification(params: A2A.TaskIdParams): Promise<A2A.TaskPushNotificationConfig | null>;
-    /**
-     * Resubscribes to an existing task's update stream.
-     * @param params Parameters identifying the task to resubscribe to
-     * @returns An AsyncIterable that yields TaskStatusUpdateEvent or TaskArtifactUpdateEvent payloads.
-     */
-    resubscribeTask(params: A2A.TaskQueryParams): AsyncIterable<A2A.Update>;
-    /**
-     * Checks if the server supports a specific capability based on the agent card.
-     * @param capability The capability to check (e.g., 'streaming', 'pushNotifications').
-     * @returns A promise resolving to true if the capability is supported.
-     */
-    supports(capability: "streaming" | "pushNotifications" | "stateTransitionHistory"): Promise<boolean>;
-    /**
-     * Sets custom headers to be included in all requests.
-     * @param headers A record of header name/value pairs.
-     */
-    setHeaders(headers: Record<string, string>): void;
-    /**
-     * Adds a single custom header to be included in all requests.
-     * @param name The header name.
-     * @param value The header value.
-     */
-    addHeader(name: string, value: string): void;
-    /**
-     * Removes a custom header.
-     * @param name The header name to remove.
-     */
-    removeHeader(name: string): void;
-    /**
-     * Clears all custom headers.
-     */
-    clearHeaders(): void;
-}