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

package/dist/services/a2a/handlers/stream-message.d.ts

@@ -3,8 +3,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../../../types/index.js";
-export declare const streamMessage: A2A.RequestHandler["streamMessage"];
-export type StreamMessageHandler = typeof streamMessage;
+export declare const sendMessageStream: A2A.RequestHandler["streamMessage"];
+export type SendMessageStreamHandler = typeof sendMessageStream;
+/**
+ * @deprecated Use sendMessageStream instead
+ */
+export declare const streamMessage: (message: A2A.MessageSendParams, context?: A2A.Context, options?: A2A.ServiceOptions) => AsyncGenerator<A2A.Update>;
+/**
+ * @deprecated Use SendMessageStreamHandler instead
+ */
+export type StreamMessageHandler = SendMessageStreamHandler;
 /**
  * @deprecated Use StreamMessageHandler instead
  */

package/dist/services/a2a/handlers/stream-message.js

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { INTERNAL_ERROR } from "../../../utils/index.js";
-export const streamMessage = async function* (_, context) {
+export const sendMessageStream = async function* (_, context) {
     if (!context) {
         throw INTERNAL_ERROR({ error: { message: "Context is required" } });
     }
@@ -17,3 +17,7 @@ export const streamMessage = async function* (_, context) {
     });
     yield* stream.run({ service });
 };
+/**
+ * @deprecated Use sendMessageStream instead
+ */
+export const streamMessage = sendMessageStream;

package/dist/services/a2a/handlers/update.js

@@ -2,8 +2,9 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getCurrentTimestamp, validateSchema } from "../../../utils/index.js";
-import { processArtifactUpdate } from "./artifact.js";
+import { getCurrentTimestamp, formatJson } from "../../../utils/common/utils.js";
+import { validateSchema } from "../../../utils/common/schema-validation.js";
+import { upsertArtifact } from "./artifact.js";
 import { A2A } from "../../../types/index.js";
 import { logger } from "../../../config/index.js";
 const isMessageInHistory = (task, message) => {
@@ -17,9 +18,13 @@ const updateHistory = (task, updateMessage) => {
 export const handleMessageUpdate = async ({ task, update, }) => {
     const validated = await validateSchema(A2A.MessageSchema, update);
     if (validated.taskId && task.id !== validated.taskId) {
-        throw new Error(`updateMessage: Invalid task id: ${validated.taskId}`, {
-            cause: validated,
-        });
+        throw new Error(`updateMessage: Invalid task id: incoming: ${validated.taskId} expected: ${task.id} ${formatJson({
+            cause: {
+                validated,
+                actual: task.id,
+                task,
+            },
+        })}`);
     }
     updateHistory(task, validated);
     return task;
@@ -27,7 +32,7 @@ export const handleMessageUpdate = async ({ task, update, }) => {
 export const handleTaskUpdate = async ({ context, task, update, }) => {
     const validated = await validateSchema(A2A.TaskSchema, update);
     if (task.id !== validated.id) {
-        throw new Error(`updateTask: Invalid task id: ${validated.id}`, {
+        throw new Error(`updateTask: Invalid task id: incoming: ${validated.id} expected: ${task.id}`, {
             cause: validated,
         });
     }
@@ -40,7 +45,7 @@ export const handleTaskUpdate = async ({ context, task, update, }) => {
 export const handleStatusUpdate = async ({ task, update, }) => {
     const validated = await validateSchema(A2A.TaskStatusUpdateEventSchema, update);
     if (validated.taskId && task.id !== validated.taskId) {
-        throw new Error(`updateTaskStatusUpdate: Invalid task id: ${validated.taskId}`, { cause: validated });
+        throw new Error(`updateTaskStatusUpdate: Invalid task id: incoming: ${validated.taskId} expected: ${task.id}`, { cause: validated });
     }
     task.status = validated.status;
     task.status.timestamp = getCurrentTimestamp();
@@ -52,14 +57,12 @@ export const handleStatusUpdate = async ({ task, update, }) => {
 export const handleArtifactUpdate = async ({ task, update }) => {
     const validated = await validateSchema(A2A.TaskArtifactUpdateEventSchema, update);
     if (validated.taskId && task.id !== validated.taskId) {
-        throw new Error(`updateTaskArtifactUpdate: Invalid task id: ${validated.taskId}`, {
+        throw new Error(`updateTaskArtifactUpdate: Invalid task id: incoming: ${validated.taskId} expected: ${task.id}`, {
             cause: validated,
         });
     }
-    else {
-        validated.taskId = task.id;
-    }
-    task.artifacts = processArtifactUpdate(update.append ?? false, task.artifacts ?? [], update.artifact);
+    validated.taskId = task.id;
+    task.artifacts = upsertArtifact(task.artifacts ?? [], validated);
     return task;
 };
 // The onus is now on the caller to handle errors when processing updates

package/dist/services/a2a/helpers/content.d.ts

@@ -8,4 +8,8 @@ import { A2A } from "../../../types/index.js";
  * @param input - The input event.
  * @returns The content of the input event.
  */
-export declare function getContent(input: A2A.Update): string | undefined;
+export declare function extractTextContent(input: A2A.Update): string | undefined;
+/**
+ * @deprecated Use extractTextContent instead.
+ */
+export declare const getContent: typeof extractTextContent;

package/dist/services/a2a/helpers/content.js

@@ -8,7 +8,7 @@ import { getParts } from "./part.js";
  * @param input - The input event.
  * @returns The content of the input event.
  */
-export function getContent(input) {
+export function extractTextContent(input) {
     const parts = getParts(input?.parts ??
         input?.status?.message?.parts ??
         input?.status?.message?.parts ??
@@ -20,3 +20,7 @@ export function getContent(input) {
         parts.data.map((data) => JSON.stringify(data)).join("\n") ??
         undefined);
 }
+/**
+ * @deprecated Use extractTextContent instead.
+ */
+export const getContent = extractTextContent;

package/dist/services/a2a/helpers/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./part.js";
 export * from "./content.js";
-export * from "./agentcard-builder.js";
-export * from "./message-builder.js";
+export { AgentCardBuilder } from "../../../create/agentcard-builder.js";
+export { MessageBuilder, MessageSendConfigurationBuilder, } from "../../../create/message-builder.js";
 export * from "./history.js";
 export * from "./references.js";

package/dist/services/a2a/helpers/index.js

@@ -1,6 +1,6 @@
 export * from "./part.js";
 export * from "./content.js";
-export * from "./agentcard-builder.js";
-export * from "./message-builder.js";
+export { AgentCardBuilder } from "../../../create/agentcard-builder.js";
+export { MessageBuilder, MessageSendConfigurationBuilder, } from "../../../create/message-builder.js";
 export * from "./history.js";
 export * from "./references.js";

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

@@ -1,4 +1,4 @@
-export * from "./factory/builder.js";
+export * from "../../create/create.js";
 export * from "./factory/service.js";
 export * from "./managers.js";
 export * from "./messenger.js";

package/dist/services/a2a/index.js

@@ -1,4 +1,4 @@
-export * from "./factory/builder.js";
+export * from "../../create/create.js";
 export * from "./factory/service.js";
 export * from "./managers.js";
 export * from "./messenger.js";

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";
@@ -33,10 +31,14 @@ const createMessageParams = (task) => {
 /**
  * @note Comprehensive Extension system coming in a future release
  */
-const getExtensions = async (extensions) => {
-    logger.warn("getExtensions: not implemented", { extensions });
+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/transport/trpc/a2a/routes/message/route.js

@@ -3,7 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { router, A2AProcedure } from "../../trpc.js";
-import { INVALID_PARAMS, zAsyncIterable } from "../../../../../utils/index.js";
+import { INVALID_PARAMS } from "../../../../../utils/common/errors.js";
+import { zAsyncIterable } from "../../../../../utils/common/zAsyncIterable.js";
 import { A2A } from "../../../../../types/index.js";
 const sendMessageRoute = A2AProcedure.input(A2A.MessageSendParamsSchema)
     .output(A2A.SendMessageSuccessResultSchema)

package/dist/transport/trpc/a2a/routes/tasks/route.js

@@ -5,7 +5,8 @@
 import { z } from "zod/v4";
 import { router, A2AProcedure } from "../../trpc.js";
 import { A2A } from "../../../../../types/index.js";
-import { INVALID_REQUEST, PUSH_NOTIFICATION_NOT_SUPPORTED, zAsyncIterable, } from "../../../../../utils/index.js";
+import { INVALID_REQUEST, PUSH_NOTIFICATION_NOT_SUPPORTED, } from "../../../../../utils/common/errors.js";
+import { zAsyncIterable } from "../../../../../utils/common/zAsyncIterable.js";
 const pushNotificationConfigRouter = router({
     set: A2AProcedure.input(A2A.TaskPushNotificationConfigSchema)
         .output(A2A.TaskPushNotificationConfigSchema)

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,