@artinet/sdk 0.5.17 → 0.6.0-preview.1

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

@@ -0,0 +1,31 @@
+import { EventEmitter } from "events";
+export interface Service<Params extends object = object, Result extends unknown = void> {
+    execute: (params: Params) => Promise<Result>;
+    stop: () => Promise<void>;
+}
+export interface Context<State extends object = object> {
+    readonly contextId: string;
+    readonly isCancelled: () => Promise<boolean>;
+    readonly abortSignal: AbortSignal;
+    readonly messages?: AsyncIterable<unknown>;
+    readonly publisher?: Publisher;
+    readonly getState: (args?: string) => Promise<State | undefined>;
+    metadata?: Record<string, unknown>;
+    readonly hooks?: Record<string, (...args: unknown[]) => Promise<unknown>>;
+}
+export interface Manager<T = object> {
+    get: (id: string) => Promise<T | undefined>;
+    set: (id: string, data?: T) => Promise<void>;
+    delete: (id: string) => Promise<void>;
+    has?: (id: string) => Promise<boolean>;
+    list?: () => Promise<T[]>;
+}
+export type Optional<T extends object = object> = Partial<T> & {
+    contextId: string;
+};
+export interface Contexts<T extends Context = Context> extends Manager<T> {
+}
+export interface Publisher<EventMap extends Record<string, any[]> = Record<string, any[]>> extends EventEmitter<EventMap> {
+}
+export interface Consumer<Received extends unknown, EventMap extends Record<string, any[]> = Record<string, any[]>> extends AsyncIterable<Received, Received, Received | undefined>, Publisher<EventMap> {
+}

package/dist/browser/types/core/index.d.ts

@@ -0,0 +1 @@
+export * as core from "./core.js";

package/dist/browser/types/core/index.js

@@ -0,0 +1 @@
+export * as core from "./core.js";

package/dist/{types/interfaces/services → browser/types}/index.d.ts

@@ -1,4 +1,7 @@
 export * from "./a2a/index.js";
 export * from "./core/index.js";
 export * from "./mcp/index.js";
+export * from "./client.js";
 export * from "./protocol.js";
+export * from "./storage.js";
+export * from "./utils/index.js";

package/dist/{types/interfaces/services → browser/types}/index.js

@@ -1,4 +1,7 @@
 export * from "./a2a/index.js";
 export * from "./core/index.js";
 export * from "./mcp/index.js";
+export * from "./client.js";
 export * from "./protocol.js";
+export * from "./storage.js";
+export * from "./utils/index.js";

package/dist/browser/types/mcp/index.d.ts

@@ -0,0 +1 @@
+export * as MCP from "./mcp.js";

package/dist/browser/types/mcp/index.js

@@ -0,0 +1 @@
+export * as MCP from "./mcp.js";

package/dist/{types/interfaces/services/mcp/service.d.ts → browser/types/mcp/mcp.d.ts}

@@ -10,11 +10,11 @@
  * managing service lifecycle.
  *
  * @module MCPService
- * @version 0.5.7
+ * @version 0.6.0-preview
  * @since 0.5.7
  * @author The Artinet Project
  */
-import { ServiceInterface } from "../core/index.js";
+import { core } from "../core/index.js";
 /**
  * Main interface for MCP service implementations.
  *
@@ -40,10 +40,11 @@ import { ServiceInterface } from "../core/index.js";
  * @public
  * @since 0.5.7
  */
-export interface MCPServiceInterface extends Omit<ServiceInterface, "execute"> {
+export interface Service extends Omit<core.Service, "execute"> {
     /**
      * Registers tools for the MCP service.
      * @param uri - The URI of the agent card resource.
      */
     registerTools?: (uri: string) => void;
 }
+export * from "@artinet/types/mcp";

package/dist/browser/types/mcp/mcp.js

@@ -0,0 +1,5 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "@artinet/types/mcp";

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

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Interface for a store of data.
+ * @deprecated Use IStore instead
+ * @template T - The type of data to store
+ */
+export interface Store<T> {
+    set(data: T, id?: string): Promise<void>;
+    get(id: string): Promise<T | undefined>;
+}
+/**
+ * Interface for a store of data.
+ * @template T - The type of data to store
+ */
+export interface IStore<T> {
+    set(id: string, data: T): Promise<void>;
+    get(id: string): Promise<T | undefined>;
+}

package/dist/browser/types/utils/index.d.ts

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

package/dist/browser/types/utils/index.js

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

package/dist/browser/types/utils/transform.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Type-safe object key transformation utilities using built-in TypeScript utility types
+ */
+/**
+ * Forces TypeScript to evaluate and flatten intersection types into a single object type
+ * This makes IDE tooltips and type displays much cleaner
+ */
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Configuration for renaming keys - maps old key names to new key names
+ * For best results, use `as const` to preserve literal string types
+ */
+export type RenameConfig<T extends object> = {
+    readonly [K in keyof T]?: string;
+};
+/**
+ * Transform object type by renaming specified keys using built-in utility types
+ * This combines Pick/Omit patterns with Record to achieve key renaming
+ * Uses Simplify to flatten the final type for cleaner IDE display
+ */
+export type TransformKeys<T extends object, Config extends RenameConfig<T>> = Simplify<Omit<T, keyof Config> & {
+    [OriginalKey in keyof Config & keyof T as Config[OriginalKey] extends string ? Config[OriginalKey] : OriginalKey]: T[OriginalKey];
+}>;
+/**
+ * Runtime function to transform object keys based on configuration
+ * Uses the TransformKeys utility type for return type inference
+ */
+export declare function transformKeys<T extends object, Config extends RenameConfig<T>>(obj: T, config: Config): TransformKeys<T, Config>;
+/**
+ * Helper type to extract the transformed type for a given object and config
+ * Useful for declaring variables with the expected transformed type
+ * Uses Simplify to show clean, flattened types in IDE
+ */
+export type Transformed<T extends object, Config extends RenameConfig<T>> = Simplify<TransformKeys<T, Config>>;
+/**
+ * Utility to create a type-safe rename configuration with better intellisense
+ * The returned function preserves literal string types
+ */
+export declare function createRenameConfig<T extends object>(): <Config extends RenameConfig<T>>(config: Config) => Config;
+/**
+ * Common transformation patterns using built-in utility types
+ */
+export declare namespace TransformPatterns {
+    /**
+     * Convert snake_case keys to camelCase
+     * This is a type-level template but would need runtime implementation
+     */
+    type SnakeToCamel<T extends string> = T extends `${infer First}_${infer Rest}` ? `${First}${Capitalize<SnakeToCamel<Rest>>}` : T;
+    /**
+     * Pick specific keys and optionally rename them
+     */
+    type PickAndRename<T extends object, Keys extends keyof T, Config extends Partial<Record<Keys, string>>> = Simplify<TransformKeys<Pick<T, Keys>, Config>>;
+    /**
+     * Omit specific keys and optionally rename remaining ones
+     */
+    type OmitAndRename<T extends object, OmitKeys extends keyof T, Config extends RenameConfig<Omit<T, OmitKeys>>> = Simplify<TransformKeys<Omit<T, OmitKeys>, Config>>;
+}
+export {};

package/dist/browser/types/utils/transform.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Runtime function to transform object keys based on configuration
+ * Uses the TransformKeys utility type for return type inference
+ */
+export function transformKeys(obj, config) {
+    const result = {};
+    // Process each property in the original object
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const newKeyName = config[key];
+            if (typeof newKeyName === "string") {
+                // Rename the key
+                result[newKeyName] = obj[key];
+            }
+            else {
+                // Keep original key
+                result[key] = obj[key];
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Utility to create a type-safe rename configuration with better intellisense
+ * The returned function preserves literal string types
+ */
+export function createRenameConfig() {
+    return function (config) {
+        return config;
+    };
+}

package/dist/browser/utils/common/constants.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../types/index.js";
+export declare const STATUS_UPDATE: (taskId: string, contextId: string, status: A2A.TaskState, message?: A2A.Message, timestamp?: string, final?: boolean) => A2A.TaskStatusUpdateEvent;
+export declare const WORKING_UPDATE: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+export declare const CANCEL_UPDATE: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+export declare const SUBMITTED_UPDATE: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+export declare const FAILED_UPDATE_EVENT: (taskId: string, contextId: string, message?: A2A.Message, timestamp?: string) => A2A.TaskStatusUpdateEvent;
+export declare const FINAL_STATES: A2A.TaskState[];

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

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../types/index.js";
+import { getCurrentTimestamp } from "./utils.js";
+//todo: protocol specific so move to a2a folder
+export const STATUS_UPDATE = (taskId, contextId, status, message, timestamp = getCurrentTimestamp(), final = false) => {
+    return {
+        taskId: taskId,
+        contextId: contextId,
+        kind: "status-update",
+        status: {
+            state: status,
+            message: message,
+            timestamp: timestamp,
+        },
+        final: final,
+    };
+};
+export const WORKING_UPDATE = (taskId, contextId, message, timestamp) => {
+    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.working, message, timestamp);
+};
+export const CANCEL_UPDATE = (taskId, contextId, message, timestamp) => {
+    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.canceled, message, timestamp, true);
+};
+export const SUBMITTED_UPDATE = (taskId, contextId, message, timestamp) => {
+    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.submitted, message, timestamp);
+};
+export const FAILED_UPDATE_EVENT = (taskId, contextId, message, timestamp) => {
+    return STATUS_UPDATE(taskId, contextId, A2A.TaskState.failed, message, timestamp, true);
+};
+export const FINAL_STATES = [
+    A2A.TaskState.completed,
+    A2A.TaskState.failed,
+    A2A.TaskState.canceled,
+    A2A.TaskState.rejected,
+];

package/dist/browser/utils/common/errors.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A, MCP } from "../../types/index.js";
+export declare class SystemError<T extends MCP.JSONRPCError> extends Error {
+    message: string;
+    code: T["error"]["code"];
+    data: T["error"]["data"];
+    constructor(message: string, code: T["error"]["code"], data: T["error"]["data"]);
+}
+export declare const PARSE_ERROR: <T extends A2A.JSONParseError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const INVALID_REQUEST: <T extends A2A.InvalidRequestError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const METHOD_NOT_FOUND: <T extends A2A.MethodNotFoundError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const INVALID_PARAMS: <T extends A2A.InvalidParamsError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const INTERNAL_ERROR: <T extends A2A.InternalError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const TASK_NOT_FOUND: <T extends A2A.TaskNotFoundError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const TASK_NOT_CANCELABLE: <T extends A2A.TaskNotCancelableError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const PUSH_NOTIFICATION_NOT_SUPPORTED: <T extends A2A.A2AError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED: <T extends A2A.AuthenticatedExtendedCardNotConfiguredError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const UNSUPPORTED_OPERATION: <T extends A2A.A2AError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const CONTENT_TYPE_NOT_SUPPORTED: <T extends A2A.ContentTypeNotSupportedError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const INVALID_AGENT_RESPONSE: <T extends A2A.InvalidAgentResponseError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const FAILED_UPDATE: (taskId: string, contextId: string, messageId: string | undefined, errMessage: string) => A2A.TaskStatusUpdateEvent;

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

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

package/dist/browser/utils/common/utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Generates a timestamp in ISO 8601 format.
+ * @returns The current timestamp as a string.
+ */
+export declare function getCurrentTimestamp(): string;
+/**
+ * Sleeps for a given number of milliseconds.
+ * @param ms - The number of milliseconds to sleep.
+ * @returns A promise that resolves when the sleep is complete.
+ *
+ * @example
+ * ```typescript
+ * await sleep(1000);
+ * ```
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Formats a JSON object into a string with indentation.
+ * @param json - The JSON object to format.
+ * @returns A string representation of the JSON object.
+ */
+export declare function formatJson(json: object): string;
+/**
+ * Formats an error into a standard error object for logging.
+ * @param error - The error to format.
+ * @returns A standard error object.
+ */
+export declare function formatError(error: unknown): Error;

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

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Generates a timestamp in ISO 8601 format.
+ * @returns The current timestamp as a string.
+ */
+export function getCurrentTimestamp() {
+    return new Date().toISOString();
+}
+/**
+ * Sleeps for a given number of milliseconds.
+ * @param ms - The number of milliseconds to sleep.
+ * @returns A promise that resolves when the sleep is complete.
+ *
+ * @example
+ * ```typescript
+ * await sleep(1000);
+ * ```
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Formats a JSON object into a string with indentation.
+ * @param json - The JSON object to format.
+ * @returns A string representation of the JSON object.
+ */
+export function formatJson(json) {
+    return JSON.stringify(json, null, 2);
+}
+/**
+ * Formats an error into a standard error object for logging.
+ * @param error - The error to format.
+ * @returns A standard error object.
+ */
+export function formatError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error));
+}

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

@@ -2,8 +2,8 @@
  * 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";
+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.
@@ -14,6 +14,7 @@ export declare class A2AClient implements Client {
     private customHeaders;
     private fallbackPath;
     private agentUrl;
+    private mergePath;
     /**
      * Creates a new A2AClient instance.
      * @param baseUrl The base URL for the A2A server.
@@ -28,74 +29,75 @@ export declare class A2AClient implements Client {
      * const card = await client.agentCard();
      * console.log(card);
      */
-    constructor(baseUrl: URL | string, headers?: Record<string, string>, fallbackPath?: string);
+    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>;
+    agentCard(): Promise<A2A.AgentCard>;
     /**
-     * Refreshes the cached AgentCard by fetching it again from the server.
-     * @returns A promise resolving to the updated AgentCard.
+     * Retrieves the AgentCard from the A2A server.
+     * @returns A promise resolving to the AgentCard.
      */
-    refreshAgentCard(): Promise<AgentCard>;
+    getAgentCard(): Promise<A2A.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.
+     * Refreshes the cached AgentCard by fetching it again from the server.
+     * @returns A promise resolving to the updated AgentCard.
      */
-    sendMessage(params: MessageSendParams | string): Promise<Message | Task | null>;
+    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: MessageSendParams): Promise<Message | Task | 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: MessageSendParams | string): AsyncIterable<UpdateEvent>;
+    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: MessageSendParams): AsyncIterable<UpdateEvent>;
+    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: TaskQueryParams): Promise<Task | 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: TaskIdParams): Promise<Task | 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: TaskPushNotificationConfig): Promise<TaskPushNotificationConfig | 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: TaskIdParams): Promise<TaskPushNotificationConfig | 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: TaskQueryParams): AsyncIterable<UpdateEvent>;
+    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').

package/dist/client/a2a-client.js

@@ -2,9 +2,10 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { executeJsonRpcRequest, executeGetRequest, executeStreamEvents, } from "../transport/index.js";
-import { INTERNAL_ERROR } from "../utils/index.js";
-import { logError } from "../utils/logging/index.js";
+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 { logger } from "../config/index.js";
 import { createMessageSendParams } from "../services/a2a/helpers/message-builder.js";
 /**
  * A2AClient is the main client class for interacting with Agent2Agent (A2A) protocol-compliant services.
@@ -16,6 +17,7 @@ export class A2AClient {
     customHeaders = {};
     fallbackPath;
     agentUrl;
+    mergePath;
     /**
      * Creates a new A2AClient instance.
      * @param baseUrl The base URL for the A2A server.
@@ -30,11 +32,12 @@ export class A2AClient {
      * const card = await client.agentCard();
      * console.log(card);
      */
-    constructor(baseUrl, headers = {}, fallbackPath) {
+    constructor(baseUrl, headers = {}, fallbackPath, mergePath = false) {
         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.
@@ -47,6 +50,9 @@ export class A2AClient {
         }
         // 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)) {
@@ -59,23 +65,34 @@ export class A2AClient {
                 this.cachedAgentCard = card;
             }
             catch (error) {
+                logger.error("A2AClient:agentCard: Failed to fetch agent card (well-known):", 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");
+                    throw new Error("No fallback agent card found" + error);
                 }
                 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)}`);
+            logger.error("A2AClient:agentCard: Failed to fetch or parse agent card:", error);
+            throw INTERNAL_ERROR(error);
         }
         this.agentUrl = new URL(this.cachedAgentCard.url, this.baseUrl);
         return this.cachedAgentCard;
     }
+    /**
+     * Retrieves the AgentCard from the A2A server.
+     * @returns A promise resolving to the AgentCard.
+     */
+    getAgentCard() {
+        return this.agentCard();
+    }
     /**
      * Refreshes the cached AgentCard by fetching it again from the server.
      * @returns A promise resolving to the updated AgentCard.
@@ -90,7 +107,11 @@ export class A2AClient {
      * @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);
+        return await executeJsonRpcRequest(this.agentUrl, "message/send", typeof params === "string"
+            ? createMessageSendParams(params)
+            : typeof params === "object" && "message" in params
+                ? params
+                : createMessageSendParams({ message: params }), this.customHeaders);
     }
     /**
      * @deprecated Use sendMessage instead.
@@ -181,7 +202,7 @@ export class A2AClient {
             }
         }
         catch (error) {
-            logError("A2AClient:supports", `Failed to determine support for capability '${capability}':`, error);
+            logger.error(`A2AClient:supports: Failed to determine support for capability '${capability}':`, error);
             return false; // Assume not supported if card fetch fails
         }
     }