@artinet/sdk 0.5.16 → 0.5.18

package/README.md

@@ -8,26 +8,44 @@
 
 # artinet-sdk
 
-Give your AI agent the power to communicate with any other agent, no matter the framework.
+Create Agents that communicate across framework.
 
 The artinet-sdk is a TypeScript library that adds a standardized, interoperable communication layer to your agents.
 
 ## Features
 
-- **Easy To Use:** The AgentBuilder lets you quickly create an Agent2Agent API, while handling all of the communication complexity.
-- **No Vendor Lock-In:** Create agents that can communicate with other agents across frameworks and ecosystems with just a few lines of code.
+- **Hassle Free:** Use the AgentBuilder to quickly setup an AgentServer.
+- **No Vendor Lock-In:** Let your agents communicate with other agents across frameworks and ecosystems.
 - **Flexible Design:** Everything you need to build collaborative agents while remaining modular enough for advanced configuration.
 
 ## Quick Start
 
-Use the [`create-agent`](https://www.npmjs.com/package/@artinet/create-agent) command:
+**Use the [`create-agent`](https://www.npmjs.com/package/@artinet/create-agent) command:**
 
 ```bash
 npx @artinet/create-agent@latest
 ```
-
 It has [serveral template projects](https://github.com/the-artinet-project/create-agent/tree/main/templates) that you can use to jump right into agent building.
 
+**Or use [`easy-a2a`](https://github.com/the-artinet-project/easy-a2a):**
+
+```typescript
+const agent = a2a({
+  baseURL: "https://your-api.com/api/v1",
+  apiKey: "your-api-key",
+})
+  .ai("You are a helpful assistant.")
+  .createAgent({
+    agentCard: "MyAgent",
+  });
+```
+
+To build agents backed by OpenAI API compatible endpoints.
+
+```bash
+npm install easy-a2a
+```
+
 ## Table of Contents
 
 - [artinet-sdk](#artinet-sdk)
@@ -41,6 +59,7 @@ It has [serveral template projects](https://github.com/the-artinet-project/creat
   - [Usage](#usage)
     - [Client](#client)
       - [Basic Client Usage](#basic-client-usage)
+      - [Browser Usage](#browser-usage)
       - [Streaming Updates](#streaming-updates)
       - [Authentication](#authentication)
     - [Server](#server)
@@ -51,30 +70,11 @@ It has [serveral template projects](https://github.com/the-artinet-project/creat
       - [Persistent Storage](#persistent-storage)
       - [Advanced Server Customization](#advanced-server-customization)
       - [Cross Protocol Support](#cross-protocol-support)
+  - [**Migration Changes**](#migration-changes)
   - [Contributing](#contributing)
   - [License](#license)
   - [Acknowledgements](#acknowledgements)
 
-**Breaking Changes since v0.5.8**
-
-- Pino has been removed and replaced with console for better portability and is set to silent by default.
-- The default handler for streamMessage no longer automatically emits an initial `submitted` and `working` event.
-- Agent Registration, Bundling and Deployment utils have been removed (email us: humans@artinet.io for support).
-- `@artinet/metadata-validator` has been removed due to build issues.
-- getTask now correctly takes TaskQueryParams as an argument vs TaskIdParams in accordance with the A2A spec.
-- AgentBuilder now returns a unique messageId for each status update instead of the original user provided messageId.
-- AgentBuilder now prefers the contextId & taskId from the calling context.
-- In a future release the following packages will be set as peer dependancies to reduce the size of the build: `@modelcontextprotocol/sdk`, `@trpc/server`, `cors`, `express`
-- The `history` object from `TaskAndHistory` is deprecated and no longer being updated. Use `Task.history` instead.
-- The `A2AClient` now checks `/.well-known/agent-card.json` as a opposed to `/.well-known/agent.json` in-line with the A2A spec.
-- The `A2AClient` now uses uses the `AgentCard`.url if an `AgentCard` has been successfully retrieved, else it will default to the `baseUrl`.
-- The examples folder will be removed in favor of [`create-agent`](https://github.com/the-artinet-project/create-agent).
-- In `Task` the `contextId` field is now required (inline with the A2A spec).
-- In `AgentSkill` the `tag` field is now required (inline with the A2A spec).
-- Optional fields in Agent2Agent Zod schemas are now nullable for better interoperability.
-- The `EngineBuilder` constructor is now protected and open for extension.
-- `AgentBuilder` will now throw an error if it recieves an invalid `FilePart`.
-
 ## Installation
 
 ```bash
@@ -114,21 +114,13 @@ const { app, agent } = createAgentServer({
     return `You said: ${userInput}`;
   })
   .createAgent({
-    agentCard: {
-      name: "QuickStart Agent",
-      description: "A simple agent that echoes the user's message",
-      url: "http://localhost:4000/a2a",
-      version: "0.1.0",
-      capabilities: { streaming: true },
-      skills: [{ id: "echo", name: "Echo Skill" }],
-      ...
-    },
+    agentCard: "QuickStart Agent",
   }),
   basePath: "/a2a"
 });
 
-app.listen(4000, () => {
-  console.log("A2A Server running at http://localhost:4000/a2a");
+app.listen(3000, () => {
+  console.log("A2A Server running at http://localhost:3000/a2a");
 });
 ```
 
@@ -138,7 +130,7 @@ app.listen(4000, () => {
 import { A2AClient, TaskStatusUpdateEvent } from "@artinet/sdk";
 
 async function runClient() {
-  const client = new A2AClient("http://localhost:4000/a2a");
+  const client = new A2AClient("http://localhost:3000/a2a");
 
   const stream = client.sendStreamingMessage("Hello World!");
 
@@ -176,6 +168,43 @@ const client = new A2AClient("https://your-a2a-server.com/a2a");
 const task: Task = await client.sendMessage("What is the capital of France?");
 ```
 
+#### Browser Usage
+
+_Experimental_
+
+The Client can be used directly in browsers. You'll need to load the required external dependencies: `zod`, `uuid`, and `eventsource-parser`.
+
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <!-- Required external dependencies -->
+    <script type="importmap">
+      {
+        "imports": {
+          "zod": "https://esm.sh/zod@3.23.8",
+          "uuid": "https://esm.sh/uuid@11.1.0",
+          "eventsource-parser": "https://esm.sh/eventsource-parser@3.0.1"
+        }
+      }
+    </script>
+  </head>
+  <body>
+    <script type="module">
+      const { A2AClient } = await import("@artinet/sdk");
+      const client = new A2AClient("http://localhost:4000/a2a");
+
+      const stream = await client.sendStreamingMessage("Hello!");
+      for await (const update of stream) {
+        console.log(update);
+      }
+    </script>
+  </body>
+</html>
+```
+
+> **Note:** Uses [esm.sh](https://esm.sh) as a CDN. See [`examples/browser-example.html`](examples/browser-example.html) for a complete example.
+
 #### Streaming Updates
 
 Receive real-time updates via SSE using `message/stream`.
@@ -271,13 +300,7 @@ const { app, agent } = createAgentServer({
       return `Task completed. Status: ${status}`;
     }) //A final Task is returned to the caller which contains all of the emitted parts.
     .createAgent({
-      agentCard: {
-        name: "Multi-Step Agent",
-        url: "http://localhost:3000/a2a",
-        version: "1.0.0",
-        capabilities: { streaming: true },
-        skills: [{ id: "multi-processor", name: "Multi-Step Processor" }],
-      },
+      agentCard: "Multi-Step Agent",
     }),
   basePath: "/a2a",
 });
@@ -382,13 +405,7 @@ const agent = createAgent({
       ...
     });
   },
-  agentCard: {
-    name: "Event-Monitored Agent",
-    url: "http://localhost:3000/a2a",
-    version: "1.0.0",
-    capabilities: { streaming: true },
-    skills: [{ id: "monitor", name: "Monitored Agent" }],
-  },
+  agentCard: "Event-Monitored Agent",
   contexts: customContextManager,
   tasks: new TaskManager(),
   eventOverrides: { //for even greater control create your own Event Handlers
@@ -602,13 +619,7 @@ const mcpAgent = createMCPAgent({
   },
   agent: createAgent({
     engine: myAgentEngine,
-    agentCard: {
-      name: "My Agent",
-      url: "http://localhost:3000/a2a",
-      version: "1.0.0",
-      capabilities: { streaming: true },
-      skills: [{ id: "helper", name: "Helper Agent" }],
-    },
+    agentCard: "MCP Agent",
   }),
   agentCardUri: "agent://card", //customize the URI for your AgentCard
 });
@@ -650,6 +661,45 @@ const result = await client.callTool({
 - `send-streaming-message`, `task-resubscribe` & `push-notifications` etc are currently not supported by default.
 - Leverage the A2A Zod Schemas to manually implement your own tools.
 
+## **Migration Changes**
+
+\*_since v0.5.8_
+
+- Pino has been removed and replaced with console for better portability and is set to silent by default.
+- The default handler for streamMessage no longer automatically emits an initial `submitted` and `working` event.
+- Agent Registration, Bundling and Deployment utils have been removed (email us: humans@artinet.io for support).
+- `@artinet/metadata-validator` has been removed due to build issues.
+- getTask now correctly takes TaskQueryParams as an argument vs TaskIdParams in accordance with the A2A spec.
+- AgentBuilder now returns a unique messageId for each status update instead of the original user provided messageId.
+- AgentBuilder now prefers the contextId & taskId from the calling context.
+- In a future release the following packages will be set as peer dependancies to reduce the size of the build: `@modelcontextprotocol/sdk`, `@trpc/server`, `cors`, `express`
+- The `history` object from `TaskAndHistory` is deprecated and no longer being updated. Use `Task.history` instead.
+- The `A2AClient` now checks `/.well-known/agent-card.json` as a opposed to `/.well-known/agent.json` in-line with the A2A spec.
+- The `A2AClient` now uses uses the `AgentCard`.url if an `AgentCard` has been successfully retrieved, else it will default to the `baseUrl`.
+- The examples folder will be removed in favor of [`create-agent`](https://github.com/the-artinet-project/create-agent).
+- In `Task` the `contextId` field is now required (inline with the A2A spec).
+- In `AgentSkill` the `tag` field is now required (inline with the A2A spec).
+- ~~Optional fields in Agent2Agent Zod schemas are now nullable for better interoperability.~~ **Nullable Schemas have been reverted.**
+- The `EngineBuilder` constructor is now protected and open for extension.
+- `AgentBuilder` will now throw an error if it recieves an invalid `FilePart`.
+- `createAgent`/`createService` can now take a single string (i.e. agentName) as valid value for the AgentCard and will populate the rest of the required fields with placeholder values (see `src/services/a2a/helpers/agentcard-builder.ts` for reference).
+- `createAgentServer` no longer adds `express.json()` to the root of the express server and now uses the utility function `rpcParser` only on the agents `basePath` and has stricter JSON-RPC validation measures.
+- `A2AClient` now exposes `mergePath` making it easier to access `AgentCards` that are not exposed at the root.
+- `AgentBuilder` now checks for cancellations after each step.
+- `createAgent` exposes the `enforceParamValidation` flag which triggers stricter enforcement of `A2ASchemas` (This will be enabled by default in a future release).
+- `AgentCardBuilder` now sets the `preferredTransport` field to the default (`JSONRPC`) if none is provided (inline with the A2A spec).
+- The default `sendMessage` implementation now supports the `MessageSendConfiguration`.`blocking` toggle.
+- The default `sendMessage` and `getTask` implementations now support the `MessageSendConfiguration`.`historyLength` parameter.
+- The Express Server now provides support for `AuthenticatedExtendedCard`.
+
+> **Note:** The Official A2A Javascript SDK is now more stable. So over the course of future releases @artinet/sdk will be merging in utilities directly from `@a2a-js/sdk` as a peer-dependancy.
+
+> This will **NOT** change the core architecture or design of @artinet/sdk, but it will make integration with the emerging Agent2Agent ecosystem easier while allowing us to focus on the adoption of additional communication protocols. We aim to complete this migration by v0.6 which will be our first LTS release.
+
+> This will **NOT** require the modification of existing `AgentEngine`'s, the current architecture was designed with this shift in mind and is the reason behind our use of loosely typed Interfaces, MPSC & SPMC queues vs EventBus and the design of the `CoreExecute` contract (onStart, onUpdate, onError, onCancel & onComplete).
+
+> This will mean that the more concrete implementations in `src/services/a2a` will become more generic implementations in `src/services/core`.
+
 ## Contributing
 
 Contributions are welcome! Please open an issue or submit a Pull Request on [GitHub](https://github.com/the-artinet-project/artinet-sdk).

package/dist/browser/browser.d.ts

@@ -0,0 +1,9 @@
+export * from "./types/index.js";
+export * from "./client/index.js";
+export { executeJsonRpcRequest, executeGetRequest, createJsonRpcRequest, sendJsonRpcRequest, } from "./transport/rpc/rpc-client.js";
+export { executeStreamEvents } from "./transport/streaming/event-stream.js";
+export * from "./utils/common/constants.js";
+export * from "./utils/common/errors.js";
+export * from "./utils/common/utils.js";
+export * from "./utils/logging/log.js";
+export { A2AClient } from "./client/a2a-client.js";

package/dist/browser/browser.js

@@ -0,0 +1,10 @@
+//browser only entry point
+export * from "./types/index.js";
+export * from "./client/index.js";
+export { executeJsonRpcRequest, executeGetRequest, createJsonRpcRequest, sendJsonRpcRequest, } from "./transport/rpc/rpc-client.js";
+export { executeStreamEvents } from "./transport/streaming/event-stream.js";
+export * from "./utils/common/constants.js";
+export * from "./utils/common/errors.js";
+export * from "./utils/common/utils.js";
+export * from "./utils/logging/log.js";
+export { A2AClient } from "./client/a2a-client.js";

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

@@ -0,0 +1,126 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AgentCard, MessageSendParams, TaskQueryParams, TaskIdParams, TaskPushNotificationConfig, Task, Message, UpdateEvent } from "../types/index.js";
+import type { Client } from "../types/interfaces/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<AgentCard>;
+    /**
+     * Refreshes the cached AgentCard by fetching it again from the server.
+     * @returns A promise resolving to the updated AgentCard.
+     */
+    refreshAgentCard(): Promise<AgentCard>;
+    /**
+     * Sends a Message to an agent server.
+     * @param params The parameters for the message/send method.
+     * @returns A promise resolving to Message/Task response from the agent server or null.
+     */
+    sendMessage(params: MessageSendParams | string): Promise<Message | 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: MessageSendParams): Promise<Message | 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: MessageSendParams | string): AsyncIterable<UpdateEvent>;
+    /**
+     * @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: MessageSendParams): AsyncIterable<UpdateEvent>;
+    /**
+     * 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: TaskQueryParams): Promise<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: TaskIdParams): Promise<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: TaskPushNotificationConfig): Promise<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: TaskIdParams): Promise<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: TaskQueryParams): AsyncIterable<UpdateEvent>;
+    /**
+     * 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;
+}

package/dist/browser/client/a2a-client.js

@@ -0,0 +1,221 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { executeJsonRpcRequest, executeGetRequest, } from "../transport/rpc/rpc-client.js";
+import { executeStreamEvents } from "../transport/streaming/event-stream.js";
+import { INTERNAL_ERROR } from "../utils/common/errors.js";
+import { logError } from "../utils/logging/log.js";
+import { createMessageSendParams } from "../services/a2a/helpers/message-builder.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 class A2AClient {
+    /**
+     * 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, headers = {}, fallbackPath, mergePath = false) {
+        this.cachedAgentCard = null;
+        this.customHeaders = {};
+        this.baseUrl = typeof baseUrl === "string" ? new URL(baseUrl) : baseUrl;
+        this.customHeaders = headers;
+        this.fallbackPath = fallbackPath ?? "/agent-card";
+        this.agentUrl = this.baseUrl;
+        this.mergePath = mergePath;
+    }
+    /**
+     * Retrieves the AgentCard from the A2A server.
+     * Caches the result after the first successful fetch.
+     * @returns A promise resolving to the AgentCard.
+     */
+    async agentCard() {
+        if (this.cachedAgentCard) {
+            return this.cachedAgentCard;
+        }
+        // Standard location for agent cards
+        const wellKnownUrl = new URL("/.well-known/agent-card.json", this.baseUrl);
+        if (this.mergePath) {
+            wellKnownUrl.pathname = this.baseUrl.pathname + wellKnownUrl.pathname;
+        }
+        try {
+            try {
+                if (!URL.canParse(wellKnownUrl)) {
+                    throw new Error("Invalid well-known URL");
+                }
+                const card = await executeGetRequest(wellKnownUrl, this.customHeaders, "agent card (well-known)");
+                if (!card.name || card.name === null || card.name === undefined) {
+                    throw new Error("No agent card found");
+                }
+                this.cachedAgentCard = card;
+            }
+            catch (error) {
+                const fallbackUrl = new URL(this.fallbackPath, this.baseUrl);
+                if (this.mergePath) {
+                    fallbackUrl.pathname = this.baseUrl.pathname + fallbackUrl.pathname;
+                }
+                const fallbackCard = await executeGetRequest(fallbackUrl, this.customHeaders, "agent card (fallback)");
+                if (!fallbackCard.name ||
+                    fallbackCard.name === null ||
+                    fallbackCard.name === undefined) {
+                    throw new Error("No fallback agent card found");
+                }
+                this.cachedAgentCard = fallbackCard;
+            }
+        }
+        catch (error) {
+            logError("A2AClient:agentCard", "Failed to fetch or parse agent card:", error);
+            throw INTERNAL_ERROR(`Could not retrieve agent card: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        this.agentUrl = new URL(this.cachedAgentCard.url, this.baseUrl);
+        return this.cachedAgentCard;
+    }
+    /**
+     * Refreshes the cached AgentCard by fetching it again from the server.
+     * @returns A promise resolving to the updated AgentCard.
+     */
+    async refreshAgentCard() {
+        this.cachedAgentCard = null;
+        return this.agentCard();
+    }
+    /**
+     * Sends a Message to an agent server.
+     * @param params The parameters for the message/send method.
+     * @returns A promise resolving to Message/Task response from the agent server or null.
+     */
+    async sendMessage(params) {
+        return await executeJsonRpcRequest(this.agentUrl, "message/send", createMessageSendParams(params), this.customHeaders);
+    }
+    /**
+     * @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.
+     */
+    async sendTask(params) {
+        return await this.sendMessage(params);
+    }
+    /**
+     * 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) {
+        return executeStreamEvents(this.agentUrl, "message/stream", createMessageSendParams(params), this.customHeaders);
+    }
+    /**
+     * @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) {
+        return this.sendStreamingMessage(params);
+    }
+    /**
+     * 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.
+     */
+    async getTask(params) {
+        return await executeJsonRpcRequest(this.agentUrl, "tasks/get", params, this.customHeaders);
+    }
+    /**
+     * 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.
+     */
+    async cancelTask(params) {
+        return await executeJsonRpcRequest(this.agentUrl, "tasks/cancel", params, this.customHeaders);
+    }
+    /**
+     * 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.
+     */
+    async setTaskPushNotification(params) {
+        return await executeJsonRpcRequest(this.agentUrl, "tasks/pushNotificationConfig/set", params, this.customHeaders);
+    }
+    /**
+     * 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.
+     */
+    async getTaskPushNotification(params) {
+        return await executeJsonRpcRequest(this.agentUrl, "tasks/pushNotificationConfig/get", params, this.customHeaders);
+    }
+    /**
+     * 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) {
+        return executeStreamEvents(this.agentUrl, "tasks/resubscribe", params, this.customHeaders);
+    }
+    /**
+     * 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.
+     */
+    async supports(capability) {
+        try {
+            const card = await this.agentCard();
+            if (!card.capabilities) {
+                return false;
+            }
+            switch (capability) {
+                case "streaming":
+                    return !!card.capabilities.streaming;
+                case "pushNotifications":
+                    return !!card.capabilities.pushNotifications;
+                case "stateTransitionHistory":
+                    return !!card.capabilities.stateTransitionHistory;
+                default:
+                    return false;
+            }
+        }
+        catch (error) {
+            logError("A2AClient:supports", `Failed to determine support for capability '${capability}':`, error);
+            return false; // Assume not supported if card fetch fails
+        }
+    }
+    /**
+     * Sets custom headers to be included in all requests.
+     * @param headers A record of header name/value pairs.
+     */
+    setHeaders(headers) {
+        this.customHeaders = { ...headers };
+    }
+    /**
+     * Adds a single custom header to be included in all requests.
+     * @param name The header name.
+     * @param value The header value.
+     */
+    addHeader(name, value) {
+        this.customHeaders[name] = value;
+    }
+    /**
+     * Removes a custom header.
+     * @param name The header name to remove.
+     */
+    removeHeader(name) {
+        delete this.customHeaders[name];
+    }
+    /**
+     * Clears all custom headers.
+     */
+    clearHeaders() {
+        this.customHeaders = {};
+    }
+}

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

@@ -0,0 +1 @@
+export * from "./a2a-client.js";

package/dist/browser/client/index.js

@@ -0,0 +1 @@
+export * from "./a2a-client.js";

package/dist/browser/services/a2a/helpers/message-builder.d.ts

@@ -0,0 +1,12 @@
+import { MessageSendParams, Message as MessageType, MessageSendConfiguration } from "../../../types/index.js";
+export declare class MessageBuilder {
+    message: MessageType;
+    constructor(message?: Partial<MessageType>);
+    valueOf(): MessageType;
+}
+export declare class MessageSendConfigurationBuilder {
+    configuration: MessageSendConfiguration;
+    constructor(configuration?: Partial<MessageSendConfiguration> | null);
+    valueOf(): MessageSendConfiguration;
+}
+export declare const createMessageSendParams: (messageSendParams: Partial<MessageSendParams> | string) => MessageSendParams;