@artinet/sdk 0.6.0-preview.1 → 0.6.0-preview.2

package/dist/services/a2a/managers.js

@@ -32,10 +32,11 @@ export class Contexts extends Manager {
         });
         logger.debug(`Contexts[create]: params`, { params });
         const baseContext = createBaseContext(params);
+        //todo: consider allowing ContextParams to cascade
         const context = {
             ...createContext({
                 baseContext: baseContext,
-                taskId: params.task?.id ?? params.taskId ?? v4(),
+                taskId: params.task.id,
                 messenger: params.messenger,
                 references: params.references,
                 extensions: params.extensions,
@@ -64,6 +65,11 @@ export class Tasks extends Manager {
     }
     async update(context, update) {
         logger.info(`Tasks[update]: updating task`, { taskId: context.taskId });
+        logger.debug(`Tasks[update]: update`, { update });
+        logger.debug(`Tasks[update]: context`, { context });
+        logger.debug(`Tasks[update]: context task`, {
+            task: await context.getTask(),
+        });
         const task = await handleUpdate({
             context,
             task: await context.getTask(),

package/dist/services/a2a/service.d.ts

@@ -4,6 +4,10 @@
  */
 import { A2A } from "../../types/index.js";
 import { ServiceParams } from "./factory/service.js";
+/**
+ * @note We endeavor to remove all optional parameters from below this class.
+ * This will allow the service to act as the boundary to our Hexagonal Architecture.
+ */
 export declare class Service implements A2A.Service {
     private _agentCard;
     private _engine;
@@ -38,10 +42,10 @@ export declare class Service implements A2A.Service {
     cancelTask(params: A2A.TaskIdParams, context?: A2A.Context, options?: A2A.ServiceOptions): Promise<A2A.Task>;
     sendMessage(params: A2A.MessageSendParams, context?: A2A.Context, options?: A2A.ServiceOptions): Promise<A2A.SendMessageSuccessResult>;
     sendMessage(message: string | A2A.MessageSendParams["message"], context?: A2A.Context, options?: A2A.ServiceOptions): Promise<A2A.SendMessageSuccessResult>;
-    _sendMessage(params: A2A.MessageSendParams, context?: A2A.Context, options?: A2A.ServiceOptions): Promise<A2A.SendMessageSuccessResult>;
+    protected _sendMessage(params: A2A.MessageSendParams, context?: A2A.Context, options?: A2A.ServiceOptions): Promise<A2A.SendMessageSuccessResult>;
     streamMessage(params: A2A.MessageSendParams, context?: A2A.Context, options?: A2A.ServiceOptions): AsyncGenerator<A2A.Update>;
     streamMessage(message: string, context?: A2A.Context, options?: A2A.ServiceOptions): AsyncGenerator<A2A.Update>;
-    _streamMessage(params: A2A.MessageSendParams, context?: A2A.Context, options?: A2A.ServiceOptions): AsyncGenerator<A2A.Update>;
+    sendMessageStream(params: A2A.MessageSendParams, context?: A2A.Context, options?: A2A.ServiceOptions): AsyncGenerator<A2A.Update>;
     resubscribe(params: A2A.TaskIdParams, context?: A2A.Context, options?: A2A.ServiceOptions): AsyncGenerator<A2A.Update>;
     static create(params: ServiceParams): Service;
 }

package/dist/services/a2a/service.js

@@ -3,11 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../../types/index.js";
-import { createMessageSendParams } from "./helpers/message-builder.js";
 import { validateSchema } from "../../utils/common/schema-validation.js";
-import { CANCEL_UPDATE } from "../../utils/common/constants.js";
+import * as describe from "../../create/describe.js";
 import { INVALID_REQUEST, TASK_NOT_FOUND } from "../../utils/common/errors.js";
-import { v4 as uuidv4 } from "uuid";
 import { Messenger } from "./messenger.js";
 import { execute } from "./execute.js";
 import { createService } from "./factory/service.js";
@@ -37,6 +35,10 @@ const getExtensions = async (extensions) => {
     logger.warn("getExtensions: not implemented", { extensions });
     return [];
 };
+/**
+ * @note We endeavor to remove all optional parameters from below this class.
+ * This will allow the service to act as the boundary to our Hexagonal Architecture.
+ */
 export class Service {
     _agentCard;
     _engine;
@@ -115,29 +117,22 @@ export class Service {
     async stop() {
         logger.info(`Service[stop]`);
         for (const context of await this.contexts.list()) {
-            await context.publisher.onCancel(CANCEL_UPDATE(context.taskId, context.contextId, {
-                role: "agent",
-                parts: [
-                    {
-                        kind: "text",
-                        text: "service stopped",
-                    },
-                ],
-                messageId: uuidv4(),
-                kind: "message",
-                taskId: context.taskId,
+            await context.publisher.onCancel(describe.update.canceled({
                 contextId: context.contextId,
+                taskId: context.taskId,
+                message: describe.message("service stopped"),
             }));
         }
         return;
     }
     async getTask(params, context, options) {
-        logger.info(`Service[getTask]:`, { taskId: params.id });
-        const task = await this.tasks.get(params.id);
+        const taskParams = await validateSchema(A2A.TaskQueryParamsSchema, params);
+        logger.info(`Service[getTask]:`, { taskId: taskParams.id });
+        const task = await this.tasks.get(taskParams.id);
         if (!task) {
-            throw TASK_NOT_FOUND({ taskId: params.id });
+            throw TASK_NOT_FOUND({ taskId: taskParams.id });
         }
-        return await this.methods.getTask(await validateSchema(A2A.TaskQueryParamsSchema, params), context ??
+        return await this.methods.getTask(taskParams, context ??
             (await this.contexts.create({
                 contextId: task.contextId,
                 service: this,
@@ -148,12 +143,13 @@ export class Service {
             })));
     }
     async cancelTask(params, context, options) {
-        logger.info(`Service[cancelTask]:`, { taskId: params.id });
-        const task = await this.tasks.get(params.id);
+        const taskParams = await validateSchema(A2A.TaskIdParamsSchema, params);
+        logger.info(`Service[cancelTask]:`, { taskId: taskParams.id });
+        const task = await this.tasks.get(taskParams.id);
         if (!task) {
-            throw TASK_NOT_FOUND({ taskId: params.id });
+            throw TASK_NOT_FOUND({ taskId: taskParams.id });
         }
-        return await this.methods.cancelTask(await validateSchema(A2A.TaskIdParamsSchema, params), context ??
+        return await this.methods.cancelTask(taskParams, context ??
             (await this.contexts.create({
                 contextId: task.contextId,
                 service: this,
@@ -164,89 +160,86 @@ export class Service {
             })));
     }
     async sendMessage(paramsOrMessage, context, options) {
-        const params = typeof paramsOrMessage === "string"
-            ? createMessageSendParams(paramsOrMessage)
-            : typeof paramsOrMessage === "object" && "message" in paramsOrMessage
-                ? paramsOrMessage
-                : createMessageSendParams({
-                    message: paramsOrMessage,
-                });
+        const params = describe.messageSendParams(paramsOrMessage);
         return await this._sendMessage(params, context, options);
     }
     async _sendMessage(params, context, options) {
+        const messageParams = await validateSchema(A2A.MessageSendParamsSchema, params);
         logger.info(`Service[sendMessage]:`, {
-            messageId: params.message.messageId,
+            messageId: messageParams.message.messageId,
+        });
+        logger.debug(`Service[sendMessage]:`, {
+            taskId: messageParams.message.taskId,
         });
-        logger.debug(`Service[sendMessage]:`, { taskId: params.message.taskId });
         logger.debug(`Service[sendMessage]:`, {
-            contextId: params.message.contextId,
+            contextId: messageParams.message.contextId,
         });
         const task = await this.tasks.create({
-            id: params.message.taskId,
-            contextId: params.message.contextId,
-            history: [params.message],
+            id: messageParams.message.taskId,
+            contextId: messageParams.message.contextId,
+            history: [messageParams.message],
             metadata: {
-                ...params.metadata,
+                ...messageParams.metadata,
             },
         });
-        return await this.methods.sendMessage(await validateSchema(A2A.MessageSendParamsSchema, params), context ??
+        return await this.methods.sendMessage(messageParams, context ??
             (await this.contexts.create({
                 contextId: task.contextId,
                 service: this,
                 abortSignal: options?.abortSignal,
                 task: task,
                 overrides: this.overrides,
-                messenger: Messenger.create(params),
-                references: await getReferences(this.tasks, params.message.referenceTaskIds),
-                extensions: await getExtensions(params.message.extensions),
+                messenger: Messenger.create(messageParams),
+                references: await getReferences(this.tasks, messageParams.message.referenceTaskIds),
+                extensions: await getExtensions(messageParams.message.extensions),
             })));
     }
     async *streamMessage(paramsOrMessage, context, options) {
-        const params = typeof paramsOrMessage === "string"
-            ? createMessageSendParams(paramsOrMessage)
-            : paramsOrMessage;
-        yield* this._streamMessage(params, context, options);
+        const params = describe.messageSendParams(paramsOrMessage);
+        yield* this.sendMessageStream(params, context, options);
     }
-    async *_streamMessage(params, context, options) {
+    async *sendMessageStream(params, context, options) {
+        const messageParams = await validateSchema(A2A.MessageSendParamsSchema, params);
         logger.info("Service[streamMessage]:", {
-            taskId: params.message.taskId,
-            contextId: params.message.contextId,
+            taskId: messageParams.message.taskId,
+            contextId: messageParams.message.contextId,
         });
         const task = await this.tasks.create({
-            id: params.message.taskId,
-            contextId: params.message.contextId,
-            history: [params.message],
+            id: messageParams.message.taskId,
+            contextId: messageParams.message.contextId,
+            history: [messageParams.message],
             metadata: {
-                ...params.metadata,
+                ...messageParams.metadata,
             },
         });
         logger.debug("Service[streamMessage]: task created", {
             taskId: task.id,
             contextId: task.contextId,
         });
-        yield* this.methods.streamMessage(await validateSchema(A2A.MessageSendParamsSchema, params), context ??
+        yield* this.methods.streamMessage(messageParams, context ??
             (await this.contexts.create({
                 contextId: task.contextId,
                 service: this,
                 abortSignal: options?.abortSignal,
                 task: task,
                 overrides: this.overrides,
-                messenger: Messenger.create(params),
-                references: await getReferences(this.tasks, params.message.referenceTaskIds),
-                extensions: await getExtensions(params.message.extensions),
+                messenger: Messenger.create(messageParams),
+                references: await getReferences(this.tasks, messageParams.message.referenceTaskIds),
+                extensions: await getExtensions(messageParams.message.extensions),
             })));
     }
     async *resubscribe(params, context, options) {
-        logger.info(`Service[resubscribe]:`, { taskId: params.id });
-        const task = await this.tasks.get(params.id);
+        const taskParams = await validateSchema(A2A.TaskIdParamsSchema, params);
+        logger.info(`Service[resubscribe]:`, { taskId: taskParams.id });
+        const task = await this.tasks.get(taskParams.id);
         if (!task) {
-            throw TASK_NOT_FOUND({ taskId: params.id });
+            throw TASK_NOT_FOUND({ taskId: taskParams.id });
         }
         logger.debug("Service[resubscribe]:", {
             taskId: task.id,
             contextId: task.contextId,
         });
-        yield* this.methods.resubscribe(await validateSchema(A2A.TaskIdParamsSchema, params), context ??
+        yield* this.methods.resubscribe(taskParams, context ??
             (await this.contexts.create({
                 contextId: task.contextId,
                 service: this,

package/dist/services/a2a/state-machine.d.ts

@@ -3,16 +3,16 @@ import { A2A } from "../../types/index.js";
 export declare class StateMachine extends EventEmitter<A2A.Emissions> implements A2A.EventPublisher {
     readonly _contextId: string;
     private readonly _consumer;
-    private _currentTask?;
+    private _currentTask;
     onStart: (context: A2A.Context) => Promise<A2A.Task>;
     onCancel: (update: A2A.Update) => Promise<void>;
     onUpdate: (update: A2A.Update) => Promise<A2A.Task>;
     onError: (error: any) => Promise<void>;
     onComplete: () => Promise<void>;
-    constructor(_contextId: string, _consumer: A2A.EventConsumer, _currentTask?: A2A.Task | undefined);
+    constructor(_contextId: string, _consumer: A2A.EventConsumer, _currentTask: A2A.Task);
     get currentTask(): A2A.Task;
     private set currentTask(value);
     get consumer(): A2A.EventConsumer;
     get contextId(): string;
-    static create(contextId: string, service: A2A.Service, task?: A2A.Task, overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>): StateMachine;
+    static create(contextId: string, service: A2A.Service, task: A2A.Task, overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>): StateMachine;
 }

package/dist/services/a2a/state-machine.js

@@ -34,6 +34,8 @@ export class StateMachine extends EventEmitter {
         if (this.consumer.onError) {
             await this.consumer.onError(error, this.currentTask);
         }
+        if (!this.listenerCount("error"))
+            return;
         this.emit("error", error, this.currentTask);
     };
     onComplete = async () => {

package/dist/transport/rpc/parser.d.ts

@@ -12,4 +12,4 @@ import { MCP } from "../../types/index.js";
  * @returns The parsed and validated response object
  * @throws A2AError if the response contains an error or is invalid
  */
-export declare function parseResponse<Res extends MCP.JSONRPCResponse | MCP.JSONRPCError>(data: string): Res;
+export declare function parseResponse<Res extends MCP.JSONRPCResponse | MCP.JSONRPCErrorResponse>(data: string): Res;

package/dist/transport/rpc/parser.js

@@ -21,7 +21,8 @@ export function parseResponse(data) {
     try {
         const parsed = JSON.parse(data); //todo: leverage safe parse
         if (parsed.error) {
-            const parsedError = MCP.JSONRPCErrorSchema.safeParse(parsed);
+            //MCP Error defs may be a wee bit restrictive
+            const parsedError = MCP.JSONRPCErrorResponseSchema.safeParse(parsed);
             if (!parsedError.success) {
                 throw PARSE_ERROR(parsedError.error);
             }

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

@@ -256,10 +256,14 @@ export declare const UpdateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     lastChunk: z.ZodOptional<z.ZodBoolean>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>]>;
-export type Update = z.infer<typeof UpdateSchema>;
+export type Update = z.output<typeof UpdateSchema>;
 export type Engine = (context: Context) => AsyncGenerator<Update, void, unknown>;
 export interface BaseContext extends core.Context<Task> {
     readonly service: Service;
+    /**
+     * Considering ommit OnStart & OnComplete from Context consumers.
+     * That way the user cannot inadvertently trigger a start/completion out of band.
+     */
     readonly publisher: EventPublisher;
 }
 export interface Context extends BaseContext {
@@ -270,9 +274,9 @@ export interface Context extends BaseContext {
     references?: Task[];
     getTask: () => Promise<Task>;
 }
-export type ContextParams = Omit<BaseContext, "publisher" | "isCancelled" | "getState" | "abortSignal"> & Omit<Partial<Context>, "userMessage"> & {
+export type ContextParams = Omit<BaseContext, "publisher" | "isCancelled" | "getState" | "abortSignal"> & Omit<Partial<Context>, "userMessage" | "taskId"> & {
     messenger: MessageConsumerProxy;
-    task?: Task;
+    task: Task;
     overrides?: Partial<Omit<EventConsumer, "contextId">>;
     abortSignal?: AbortSignal;
 };

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

@@ -1,3 +1,5 @@
-export * from "./builder.js";
 export * as A2A from "./a2a.js";
+/**
+ * @deprecated Use {@link A2A.Engine} instead.
+ */
 export type { Engine as AgentEngine } from "./a2a.js";

package/dist/types/a2a/index.js

@@ -1,2 +1 @@
-export * from "./builder.js";
 export * as A2A from "./a2a.js";

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

@@ -3,9 +3,4 @@
  * 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/utils/common/constants.js

@@ -3,33 +3,6 @@
  * 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,

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

@@ -3,22 +3,78 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A, MCP } from "../../types/index.js";
-export declare class SystemError<T extends MCP.JSONRPCError> extends Error {
+/**
+ * @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"]);
 }
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @deprecated Use {@link describe.update.failed} instead
+ * @since 0.6.0
+ */
 export declare const FAILED_UPDATE: (taskId: string, contextId: string, messageId: string | undefined, errMessage: string) => A2A.TaskStatusUpdateEvent;

package/dist/utils/common/errors.js

@@ -3,43 +3,96 @@
  * 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 {
     message;
     code;
     data;
     constructor(message, code, data) {
-        super(message);
+        super(message + " " + formatJson({ cause: data }));
         // this.name = "RpcError";
         this.message = message;
         this.code = code;
         this.data = data;
     }
 }
-// Factory methods for common errors
+/**
+ * @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);
-export const FAILED_UPDATE = (taskId, contextId, messageId = "failed-update", errMessage) => ({
-    taskId,
-    contextId,
-    kind: "status-update",
-    final: true,
-    status: {
-        state: A2A.TaskState.failed,
-        message: {
+/**
+ * @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,
-            role: "agent",
             parts: [{ kind: "text", text: errMessage }],
-            kind: "message",
-        },
-    },
-});
+        }),
+    });
+};

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

@@ -4,4 +4,4 @@
  */
 import { z } from "zod/v4";
 export declare function safeParse<T = any>(json: string): T;
-export declare function safeParseSchema<T extends z.ZodSchema>(json: string, schema: T): Promise<z.infer<T>>;
+export declare function safeParseSchema<T extends z.ZodSchema>(json: string, schema: T): Promise<z.output<T>>;

package/dist/utils/common/schema-validation.d.ts

@@ -1,2 +1,2 @@
 import { z } from "zod/v4";
-export declare function validateSchema<T extends z.ZodSchema>(schema: T, data: unknown): Promise<z.infer<T>>;
+export declare function validateSchema<T extends z.ZodSchema>(schema: T, data: unknown): Promise<z.output<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artinet/sdk",
-  "version": "0.6.0-preview.1",
+  "version": "0.6.0-preview.2",
   "description": "A TypeScript SDK for building collaborative AI agents.",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,22 +28,22 @@
       "default": "./dist/types/index.js"
     },
     "./pino": {
+      "types": "./dist/extensions/pino.d.ts",
       "node": {
-        "types": "./dist/extensions/pino.d.ts",
         "import": "./dist/extensions/pino.js",
         "default": "./dist/extensions/pino.js"
       }
     },
     "./winston": {
+      "types": "./dist/extensions/winston.d.ts",
       "node": {
-        "types": "./dist/extensions/winston.d.ts",
         "import": "./dist/extensions/winston.js",
         "default": "./dist/extensions/winston.js"
       }
     },
     "./otel": {
+      "types": "./dist/extensions/opentelemetry.d.ts",
       "node": {
-        "types": "./dist/extensions/opentelemetry.d.ts",
         "import": "./dist/extensions/opentelemetry.js",
         "default": "./dist/extensions/opentelemetry.js"
       }
@@ -130,6 +130,7 @@
     }
   },
   "devDependencies": {
+    "@a2a-js/sdk": "^0.3.7",
     "@cfworker/json-schema": "^4.1.1",
     "@eslint/js": "^9.25.1",
     "@opentelemetry/api": "^1.9.0",
@@ -143,11 +144,13 @@
     "globals": "^16.0.0",
     "jest": "^30.2.0",
     "msw": "^2.7.5",
+    "@modelcontextprotocol/sdk": "^1.24.3",
     "pino": "^10.1.0",
     "pino-caller": "^4.0.0",
     "pino-pretty": "^13.1.3",
     "rimraf": "^6.1.2",
     "supertest": "latest",
+    "@trpc/server": "^11.4.3",
     "ts-jest": "^29.3.2",
     "ts-node": "^10.9.1",
     "ts-patch": "^3.3.0",