@artinet/sdk 0.6.0-preview.2 → 0.6.0

package/dist/browser/messenger/messenger.js

@@ -0,0 +1,245 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../types/index.js";
+import { validateSchema } from "../utils/schema-validation.js";
+import { logger } from "../config/index.js";
+import * as describe from "../create/describe.js";
+import { ClientFactory, ClientFactoryOptions, } from "@a2a-js/sdk/client";
+class HeaderInterceptor {
+    constructor(_getCustomHeaders) {
+        this._getCustomHeaders = _getCustomHeaders;
+    }
+    before(args) {
+        const options = args.options ?? { serviceParameters: {} };
+        const serviceParameters = options.serviceParameters;
+        options.serviceParameters = {
+            ...serviceParameters,
+            ...this._getCustomHeaders(),
+        };
+        args.options = options;
+        return Promise.resolve();
+    }
+    after() {
+        return Promise.resolve();
+    }
+}
+/**
+ * Messenger is the main communication client for interacting with remote A2A-compatible services.
+ * It provides methods for sending messages, retrieving tasks, canceling operations, and handling streaming responses.
+ */
+class Messenger {
+    constructor(baseUrl, _headers = {}, _fallbackPath, factory = ClientFactoryOptions.default, config) {
+        this._headers = _headers;
+        this._fallbackPath = _fallbackPath;
+        this._baseUrl = typeof baseUrl === "string" ? baseUrl : baseUrl.toString();
+        this._fallbackPath = _fallbackPath ?? "/agent.json";
+        this._factory = new ClientFactory(ClientFactoryOptions.createFrom(factory, {
+            clientConfig: {
+                ...config,
+                interceptors: [
+                    ...(config?.interceptors ?? []),
+                    new HeaderInterceptor(() => this.headers),
+                ],
+            },
+        }));
+        this.clientPromise = this.reset(this._baseUrl, this._fallbackPath);
+    }
+    async reset(baseUrl = this._baseUrl, fallbackPath = this._fallbackPath) {
+        this._baseUrl = typeof baseUrl === "string" ? baseUrl : baseUrl.toString();
+        this._fallbackPath = fallbackPath ?? "/agent.json";
+        this.clientPromise = this._factory
+            .createFromUrl(this._baseUrl)
+            .catch(async (error) => {
+            if (!this._fallbackPath) {
+                logger.error("Messenger: Failed to create client, no fallback path provided", { error });
+                throw error;
+            }
+            logger.warn("Messenger: Failed to create client, falling back to fallback path: ", { error, fallbackPath: this._fallbackPath });
+            return await this._factory
+                .createFromUrl(this._baseUrl, this._fallbackPath)
+                .catch(async (error) => {
+                logger.error("Messenger: Failed to create client, at fallback path: ", { error, fallbackPath: this._fallbackPath });
+                throw error;
+            });
+        });
+        return this.clientPromise;
+    }
+    get baseUrl() {
+        return this._baseUrl;
+    }
+    get headers() {
+        return this._headers;
+    }
+    set headers(headers) {
+        this._headers = headers;
+    }
+    get _client() {
+        return this.clientPromise;
+    }
+    /**
+     * Retrieves the AgentCard from the A2A server.
+     * @returns A promise resolving to the AgentCard.
+     */
+    async getAgentCard(requestOptions) {
+        const client = await this._client;
+        return await client.getAgentCard(requestOptions);
+    }
+    /**
+     * Sends a Message to an agent server.
+     * @param params The {@link A2A.MessageSendParams} for the message/send method.
+     * @param options The {@link RequestOptions} for the request.
+     * @returns A promise resolving to {@link A2A.SendMessageSuccessResult} from the agent server.
+     */
+    async sendMessage(params, options) {
+        const client = await this._client;
+        return await validateSchema(A2A.SendMessageSuccessResultSchema, await client.sendMessage(describe.messageSendParams(params), options));
+    }
+    /**
+     * 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.
+     */
+    async *sendMessageStream(params, options) {
+        try {
+            const client = await this._client;
+            yield* client.sendMessageStream(describe.messageSendParams(params), options);
+        }
+        catch (error) {
+            logger.error("Messenger: Failed to send message stream", { error });
+            throw error;
+        }
+    }
+    /**
+     * 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, options) {
+        const client = await this._client;
+        return await validateSchema(A2A.TaskSchema, await client.getTask(params, options));
+    }
+    /**
+     * 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, options) {
+        const client = await this._client;
+        return await validateSchema(A2A.TaskSchema, await client.cancelTask(params, options));
+    }
+    /**
+     * 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 setTaskPushNotificationConfig(params, options) {
+        const client = await this._client;
+        return await validateSchema(A2A.TaskPushNotificationConfigSchema, await client.setTaskPushNotificationConfig(params, options));
+    }
+    /**
+     * 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 getTaskPushNotificationConfig(params, options) {
+        const client = await this._client;
+        return await validateSchema(A2A.TaskPushNotificationConfigSchema, await client.getTaskPushNotificationConfig(params, options));
+    }
+    async listTaskPushNotificationConfig(params, options) {
+        const client = await this._client;
+        return await validateSchema(A2A.ListTaskPushNotificationConfigResultSchema, await client.listTaskPushNotificationConfig(params, options));
+    }
+    async deleteTaskPushNotificationConfig(params, options) {
+        const client = await this._client;
+        return client.deleteTaskPushNotificationConfig(params, options);
+    }
+    /**
+     * 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.
+     */
+    async *resubscribeTask(params, options) {
+        try {
+            const client = await this._client;
+            yield* client.resubscribeTask(params, options);
+        }
+        catch (error) {
+            logger.error("Messenger: Failed to resubscribe task", { error });
+            throw error;
+        }
+    }
+    /**
+     * 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) {
+        const card = await this.getAgentCard();
+        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;
+            case "extentions":
+                return !!card.capabilities.extensions;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Adds a single header to be included in all requests.
+     * @param name The header name.
+     * @param value The header value.
+     */
+    addHeader(name, value) {
+        this.headers[name] = value;
+    }
+    /**
+     * Removes a header.
+     * @param name The header name to remove.
+     */
+    removeHeader(name) {
+        delete this.headers[name];
+    }
+    static async create({ baseUrl, headers, fallbackPath, factory, config, }) {
+        const messenger = new Messenger(baseUrl, headers, fallbackPath, factory, config);
+        const card = await messenger.getAgentCard();
+        /**Validate the agent card to ensure the target conforms to the A2A specification */
+        await validateSchema(A2A.AgentCardSchema, card).catch((error) => {
+            logger.warn("Messenger: Invalid agent card detected", { error });
+        });
+        return messenger;
+    }
+}
+/**
+ * Creates a new Messenger 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 messenger = createMessenger({
+ *   baseUrl: "http://localhost:4000/a2a",
+ * });
+ * const card = await messenger.getAgentCard();
+ * console.log(card);
+ * @example
+ * const messenger = createMessenger({
+ *   baseUrl: "http://localhost:4000/a2a",
+ *   fallbackPath: "/agent-card",
+ * });
+ * const card = await messenger.getAgentCard();
+ * console.log(card);
+ */
+export const createMessenger = Messenger.create;
+export const AgentMessenger = Messenger;
+/**
+ * @deprecated Use {@link createMessenger} instead.
+ */
+export const A2AClient = Messenger;

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

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { AgentCard, Message, Task, AgentExtension, TaskQueryParams, TaskIdParams, MessageSendParams, SendMessageSuccessResult } from "@artinet/types/a2a";
+import { AgentCard, Message, Task, AgentExtension, TaskQueryParams, TaskIdParams, MessageSendParams, SendMessageSuccessResult, PushNotificationConfig } from "@artinet/types/a2a";
 import { core } from "../core/index.js";
 import { z } from "zod/v4";
 export type AgentCardParams = (Partial<AgentCard> & Required<Pick<AgentCard, "name">>) | string;
@@ -46,14 +46,14 @@ export declare const UpdateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     contextId: z.ZodString;
     status: z.ZodObject<{
         state: z.ZodEnum<{
-            failed: "failed";
             unknown: "unknown";
+            submitted: "submitted";
+            working: "working";
+            "input-required": "input-required";
             completed: "completed";
             canceled: "canceled";
+            failed: "failed";
             rejected: "rejected";
-            working: "working";
-            submitted: "submitted";
-            "input-required": "input-required";
             "auth-required": "auth-required";
         }>;
         message: z.ZodOptional<z.ZodObject<{
@@ -168,14 +168,14 @@ export declare const UpdateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"status-update">;
     status: z.ZodObject<{
         state: z.ZodEnum<{
-            failed: "failed";
             unknown: "unknown";
+            submitted: "submitted";
+            working: "working";
+            "input-required": "input-required";
             completed: "completed";
             canceled: "canceled";
+            failed: "failed";
             rejected: "rejected";
-            working: "working";
-            submitted: "submitted";
-            "input-required": "input-required";
             "auth-required": "auth-required";
         }>;
         message: z.ZodOptional<z.ZodObject<{
@@ -272,13 +272,13 @@ export interface Context extends BaseContext {
     readonly messages: MessageConsumerProxy;
     extensions?: AgentExtension[];
     references?: Task[];
+    userId?: string;
     getTask: () => Promise<Task>;
 }
 export type ContextParams = Omit<BaseContext, "publisher" | "isCancelled" | "getState" | "abortSignal"> & Omit<Partial<Context>, "userMessage" | "taskId"> & {
     messenger: MessageConsumerProxy;
     task: Task;
     overrides?: Partial<Omit<EventConsumer, "contextId">>;
-    abortSignal?: AbortSignal;
 };
 export interface Contexts extends core.Contexts<Context> {
     create: (params: ContextParams) => Promise<Context>;
@@ -294,20 +294,38 @@ export interface Cancellations extends Omit<core.Manager<void>, "get"> {
 }
 export interface Connections extends Omit<core.Manager<void>, "get"> {
 }
-export interface ServiceOptions {
-    abortSignal?: AbortSignal;
+export interface Notifier {
+    notify: (task: Task, update: Update, context?: Context) => Promise<void>;
+    register: (taskId: string, config: PushNotificationConfig) => Promise<void>;
+}
+export type ServiceOptions = Pick<ContextParams, "userId" | "extensions"> & {
+    task?: Task;
+    signal?: AbortSignal;
+    notifier?: Notifier;
+};
+export interface Handles {
+    getTask: (input: TaskQueryParams, context: Context) => Promise<Task>;
+    cancelTask: (input: TaskIdParams, context: Context) => Promise<Task>;
+    sendMessage: (message: MessageSendParams, context: Context) => Promise<SendMessageSuccessResult>;
+    /**
+     * @deprecated Use sendMessageStream instead
+     */
+    streamMessage: (message: MessageSendParams, context: Context) => AsyncGenerator<Update>;
+    sendMessageStream: (message: MessageSendParams, context: Context) => AsyncGenerator<Update>;
+    resubscribe: (input: TaskIdParams, context: Context) => AsyncGenerator<Update>;
 }
 export interface RequestHandler {
-    getTask: (input: TaskQueryParams, context?: Context, options?: ServiceOptions) => Promise<Task>;
-    cancelTask: (input: TaskIdParams, context?: Context, options?: ServiceOptions) => Promise<Task>;
-    sendMessage: (message: MessageSendParams, context?: Context, options?: ServiceOptions) => Promise<SendMessageSuccessResult>;
-    streamMessage: (message: MessageSendParams, context?: Context, options?: ServiceOptions) => AsyncGenerator<Update>;
-    resubscribe: (input: TaskIdParams, context?: Context, options?: ServiceOptions) => AsyncGenerator<Update>;
+    getTask: (input: TaskQueryParams, options?: ServiceOptions) => Promise<Task>;
+    cancelTask: (input: TaskIdParams, options?: ServiceOptions) => Promise<Task>;
+    sendMessage: (message: MessageSendParams, options?: ServiceOptions) => Promise<SendMessageSuccessResult>;
+    /**
+     * @deprecated Use sendMessageStream instead
+     */
+    streamMessage: (message: MessageSendParams, options?: ServiceOptions) => AsyncGenerator<Update>;
+    sendMessageStream: (message: MessageSendParams, options?: ServiceOptions) => AsyncGenerator<Update>;
+    resubscribe: (input: TaskIdParams, options?: ServiceOptions) => AsyncGenerator<Update>;
     getAgentCard: () => Promise<AgentCard>;
 }
-export interface ExtendedHandler extends RequestHandler {
-    getAuthenticatedExtendedCard: () => Promise<AgentCard>;
-}
 export interface Stream {
     readonly contextId: string;
     isAlive: boolean;

package/dist/browser/types/a2a/a2a.js

@@ -2,7 +2,6 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-//lets stay really granular with the imports
 import { TaskArtifactUpdateEventSchema, MessageSchema, TaskSchema, TaskStatusUpdateEventSchema, } from "@artinet/types/a2a";
 import { z } from "zod/v4";
 export const UpdateSchema = z.discriminatedUnion("kind", [

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

@@ -1,4 +1,5 @@
-import { EventEmitter } from "events";
+import { EventEmitter } from "eventemitter3";
+import { IStore } from "../storage.js";
 export interface Service<Params extends object = object, Result extends unknown = void> {
     execute: (params: Params) => Promise<Result>;
     stop: () => Promise<void>;
@@ -11,9 +12,10 @@ export interface Context<State extends object = object> {
     readonly publisher?: Publisher;
     readonly getState: (args?: string) => Promise<State | undefined>;
     metadata?: Record<string, unknown>;
+    /**hooks allow consumers to modify context on the fly*/
     readonly hooks?: Record<string, (...args: unknown[]) => Promise<unknown>>;
 }
-export interface Manager<T = object> {
+export interface Manager<T = object> extends IStore<T> {
     get: (id: string) => Promise<T | undefined>;
     set: (id: string, data?: T) => Promise<void>;
     delete: (id: string) => Promise<void>;

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

@@ -1,7 +1,6 @@
 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/index.js

@@ -1,7 +1,6 @@
 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/storage.d.ts

@@ -1,18 +1,6 @@
 /**
- * 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.
+ * @note prefer implementing `Manager` instead of `IStore` as it provides a more robust interface.
+ *  Interface for a store of data.
  * @template T - The type of data to store
  */
 export interface IStore<T> {

package/dist/browser/types/storage.js

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

package/dist/browser/utils/{common/constants.d.ts → constants.d.ts}

@@ -2,5 +2,5 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { A2A } from "../../types/index.js";
+import { A2A } from "../types/index.js";
 export declare const FINAL_STATES: A2A.TaskState[];

package/dist/{utils/common → browser/utils}/constants.js

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { A2A } from "../../types/index.js";
+import { A2A } from "../types/index.js";
 export const FINAL_STATES = [
     A2A.TaskState.completed,
     A2A.TaskState.failed,

package/dist/browser/utils/{common/errors.d.ts → errors.d.ts}

@@ -2,77 +2,58 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { A2A, MCP } from "../../types/index.js";
+import { A2A, MCP } from "../types/index.js";
 /**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
  * @since 0.6.0
  */
 export declare class SystemError<T extends MCP.JSONRPCErrorResponse> extends Error {
-    message: string;
     code: T["error"]["code"];
-    data: T["error"]["data"];
-    constructor(message: string, code: T["error"]["code"], data: T["error"]["data"]);
+    data?: T["error"]["data"];
+    taskId?: string;
+    message: string;
+    constructor(message: string, code: T["error"]["code"], data?: T["error"]["data"], taskId?: string);
 }
 /**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export declare const PARSE_ERROR: <T extends A2A.JSONParseError>(data: T["error"]["data"]) => SystemError<T>;
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export declare const INVALID_REQUEST: <T extends A2A.InvalidRequestError>(data: T["error"]["data"]) => SystemError<T>;
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export declare const METHOD_NOT_FOUND: <T extends A2A.MethodNotFoundError>(data: T["error"]["data"]) => SystemError<T>;
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
  * @since 0.6.0
  */
-export declare const INVALID_PARAMS: <T extends A2A.InvalidParamsError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const PARSE_ERROR: <T extends A2A.JSONParseError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
 /**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
  * @since 0.6.0
  */
-export declare const INTERNAL_ERROR: <T extends A2A.InternalError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const INVALID_REQUEST: <T extends A2A.InvalidRequestError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
 /**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
- * @since 0.6.0
- */
-export declare const TASK_NOT_FOUND: <T extends A2A.TaskNotFoundError>(data: T["error"]["data"]) => SystemError<T>;
-/**
- * @deprecated Use errors from the `@a2a-js/sdk` package instead
  * @since 0.6.0
  */
-export declare const TASK_NOT_CANCELABLE: <T extends A2A.TaskNotCancelableError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const METHOD_NOT_FOUND: <T extends A2A.MethodNotFoundError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
+export declare const INVALID_PARAMS: <T extends A2A.InvalidParamsError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
+export declare const INTERNAL_ERROR: <T extends A2A.InternalError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
+export declare const TASK_NOT_FOUND: <T extends A2A.TaskNotFoundError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
+export declare const TASK_NOT_CANCELABLE: <T extends A2A.TaskNotCancelableError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
 /**
  * @deprecated Use errors from the `@a2a-js/sdk` package instead
  * @since 0.6.0
  */
-export declare const PUSH_NOTIFICATION_NOT_SUPPORTED: <T extends A2A.A2AError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const PUSH_NOTIFICATION_NOT_SUPPORTED: <T extends A2A.PushNotificationNotSupportedError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
 /**
  * @deprecated Use errors from the `@a2a-js/sdk` package instead
  * @since 0.6.0
  */
-export declare const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED: <T extends A2A.AuthenticatedExtendedCardNotConfiguredError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED: <T extends A2A.AuthenticatedExtendedCardNotConfiguredError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
 /**
  * @deprecated Use errors from the `@a2a-js/sdk` package instead
  * @since 0.6.0
  */
-export declare const UNSUPPORTED_OPERATION: <T extends A2A.A2AError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const UNSUPPORTED_OPERATION: <T extends A2A.A2AError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
 /**
  * @deprecated Use errors from the `@a2a-js/sdk` package instead
  * @since 0.6.0
  */
-export declare const CONTENT_TYPE_NOT_SUPPORTED: <T extends A2A.ContentTypeNotSupportedError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const CONTENT_TYPE_NOT_SUPPORTED: <T extends A2A.ContentTypeNotSupportedError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
 /**
  * @deprecated Use errors from the `@a2a-js/sdk` package instead
  * @since 0.6.0
  */
-export declare const INVALID_AGENT_RESPONSE: <T extends A2A.InvalidAgentResponseError>(data: T["error"]["data"]) => SystemError<T>;
+export declare const INVALID_AGENT_RESPONSE: <T extends A2A.InvalidAgentResponseError>(data: T["error"]["data"], taskId?: string) => SystemError<T>;
 /**
  * @deprecated Use {@link describe.update.failed} instead
  * @since 0.6.0

package/dist/browser/utils/errors.js

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

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

@@ -0,0 +1,6 @@
+/**Only export browser compatible utils */
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./parse.js";
+export * from "./schema-validation.js";
+export * from "./utils.js";

package/dist/browser/utils/index.js

@@ -0,0 +1,6 @@
+/**Only export browser compatible utils */
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./parse.js";
+export * from "./schema-validation.js";
+export * from "./utils.js";

package/dist/{utils/common → browser/utils}/parse.js

@@ -1,5 +1,5 @@
 import { validateSchema } from "./schema-validation.js";
-import { logger } from "../../config/index.js";
+import { logger } from "../config/index.js";
 export function safeParse(json) {
     try {
         return JSON.parse(json);

package/dist/{utils/common → browser/utils}/schema-validation.js

@@ -2,8 +2,8 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { INVALID_PARAMS } from "../index.js";
-import { logger } from "../../config/index.js";
+import { INVALID_PARAMS } from "./errors.js";
+import { logger } from "../config/index.js";
 export async function validateSchema(schema, data) {
     return await schema.parseAsync(data).catch((error) => {
         logger.error("Schema validation failed", error);