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

package/dist/browser/create/task-builder.d.ts

@@ -0,0 +1,251 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../types/index.js";
+import { type MessageParams } from "./message-builder.js";
+import { Kindless } from "./base.js";
+export type BaseArtifactParams = Partial<Kindless<A2A.Artifact>>;
+export type ArtifactParams = BaseArtifactParams | string;
+export declare const isArtifactParams: (params: any) => params is ArtifactParams;
+export declare class Artifact {
+    private readonly _artifact;
+    constructor(artifact_params?: Partial<A2A.Artifact>);
+    get artifact(): A2A.Artifact;
+    static create(params?: ArtifactParams): A2A.Artifact;
+}
+export declare const artifact: typeof Artifact.create;
+export type StatusParams = Partial<Kindless<A2A.TaskStatus>> | A2A.TaskState | MessageParams;
+export declare const isStatusParams: (params: any) => params is StatusParams;
+export declare class TaskStatus {
+    private readonly _status;
+    constructor(params?: Partial<A2A.TaskStatus>);
+    get status(): A2A.TaskStatus;
+    static create(params?: StatusParams): A2A.TaskStatus;
+}
+/**
+ * Convenience factory function for creating a task status with default parameters.
+ *
+ * @returns New {@link A2A.TaskStatus} with default parameters
+ * @defaults {
+ *   state: "working",
+ *   timestamp: getCurrentTimestamp(),
+ * }
+ *
+ * @example
+ * ```typescript
+ * const status = status("working");
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export declare const status: typeof TaskStatus.create;
+export type TaskParams = Partial<Kindless<A2A.Task>> | StatusParams;
+export declare class Task {
+    private readonly _task;
+    constructor(params?: Partial<Kindless<A2A.Task>>);
+    get task(): A2A.Task;
+    static create(params?: TaskParams): A2A.Task;
+}
+/**
+ * Convenience factory function for creating a task with default parameters.
+ *
+ * @returns New {@link A2A.Task} with default parameters
+ * @defaults:
+ * - `id`: uuidv4()
+ * - `contextId`: id
+ * - `status`: { state: "working" }
+ * @example
+ * ```typescript
+ * const task = task({ status: { state: "working" } });
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export declare const task: typeof Task.create;
+export type StatusUpdateParams = (Partial<Kindless<A2A.TaskStatusUpdateEvent>> & {
+    status: StatusParams;
+}) | StatusParams;
+export declare class TaskStatusUpdateEvent {
+    private readonly _event;
+    constructor(params: Partial<Kindless<A2A.TaskStatusUpdateEvent>> & Required<Pick<Kindless<A2A.TaskStatusUpdateEvent>, "status">>);
+    get event(): A2A.TaskStatusUpdateEvent;
+    static create(params: StatusUpdateParams): A2A.TaskStatusUpdateEvent;
+}
+export type ArtifactUpdateParams = (Partial<Kindless<A2A.TaskArtifactUpdateEvent>> & {
+    artifact: ArtifactParams;
+}) | ArtifactParams;
+export declare class TaskArtifactUpdateEvent {
+    private readonly _event;
+    constructor(params: Partial<Kindless<A2A.TaskArtifactUpdateEvent>> & Required<Pick<Kindless<A2A.TaskArtifactUpdateEvent>, "artifact">>);
+    get event(): A2A.TaskArtifactUpdateEvent;
+    static create(params: ArtifactUpdateParams): A2A.TaskArtifactUpdateEvent;
+}
+type StrictUpdateParams = Partial<Kindless<A2A.TaskStatusUpdateEvent>> & Required<Pick<Kindless<A2A.TaskStatusUpdateEvent>, "taskId" | "contextId" | "status">>;
+export type BuildStatusParams = Omit<StrictUpdateParams, "status"> & Omit<A2A.TaskStatus, "state">;
+declare function _working(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _canceled(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _submitted(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _failed(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _completed(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _inputRequired(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _rejected(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _authRequired(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+declare function _unknown(params: BuildStatusParams): A2A.TaskStatusUpdateEvent;
+/**
+ * Convenience factory function for creating a task status and artifact update events with default parameters.
+ *
+ * @returns New {@link A2A.TaskStatusUpdateEvent} and {@link A2A.TaskArtifactUpdateEvent} with default parameters
+ *
+ * @example
+ * ```typescript
+ * const artifactEvent = update.artifact({
+ *   artifact: "result"
+ * });
+ * const statusEvent = update.status({
+ *   status: "working"
+ * });
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export declare const update: {
+    /**
+     * Convenience factory function for creating a task artifact update event.
+     * @returns New {@link A2A.TaskArtifactUpdateEvent}
+     * @example
+     * ```typescript
+     * const event = update.artifact({
+     *   artifact: "result"
+     * });
+     * ```
+     */
+    artifact: typeof TaskArtifactUpdateEvent.create;
+    /**
+     * Convenience factory function for creating a task status update event.
+     * @returns New {@link A2A.TaskStatusUpdateEvent}
+     * @example
+     * ```typescript
+     * const event = update.status({
+     *   message: "Working on the task"
+     * });
+     * ```
+     */
+    status: typeof TaskStatusUpdateEvent.create;
+    /**
+     * Convenience factory function for creating a task status update event with the working state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.working} state
+     * @example
+     * ```typescript
+     * const event = update.working({
+     *   message: "Working on the task"
+     * });
+     * ```
+     */
+    working: typeof _working;
+    /**
+     * Convenience factory function for creating a task status update event with the canceled state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.canceled} state
+     * @example
+     * ```typescript
+     * const event = update.canceled({
+     *   message: "Task canceled"
+     * });
+     * ```
+     */
+    canceled: typeof _canceled;
+    /**
+     * Convenience factory function for creating a task status update event with the submitted state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.submitted} state
+     * @example
+     * ```typescript
+     * const event = update.submitted({
+     *   message: "Task submitted"
+     * });
+     * ```
+     */
+    submitted: typeof _submitted;
+    /**
+     * Convenience factory function for creating a task status update event with the failed state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.failed} state
+     * @example
+     * ```typescript
+     * const event = update.failed({
+     *   message: "Task failed"
+     * });
+     * ```
+     */
+    failed: typeof _failed;
+    /**
+     * Convenience factory function for creating a task status update event with the completed state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.completed} state
+     * @example
+     * ```typescript
+     * const event = update.completed({
+     *   message: "Task completed"
+     * });
+     * ```
+     */
+    completed: typeof _completed;
+    /**
+     * Convenience factory function for creating a task status update event with the input required state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState["input-required"]} state
+     * @example
+     * ```typescript
+     * const event = update.inputRequired({
+     *   message: "Task input required"
+     * });
+     * ```
+     */
+    inputRequired: typeof _inputRequired;
+    /**
+     * Convenience factory function for creating a task status update event with the rejected state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.rejected} state
+     * @example
+     * ```typescript
+     * const event = update.rejected({
+     *   message: "Task rejected"
+     * });
+     * ```
+     */
+    rejected: typeof _rejected;
+    /**
+     * Convenience factory function for creating a task status update event with the auth required state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState["auth-required"]} state
+     * @example
+     * ```typescript
+     * const event = update.authRequired({
+     *   message: {
+     *   role: "agent"
+     *   parts: [
+     *     {
+     *       text: "Task auth required"
+     *     }
+     *   ]
+     *   kind: "message"
+     * });
+     * ```
+     */
+    authRequired: typeof _authRequired;
+    /**
+     * Convenience factory function for creating a task status update event with the unknown state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.unknown} state
+     * @example
+     * ```typescript
+     * const event = update.unknown({
+     *   message: "Task unknown"
+     * });
+     * ```
+     */
+    unknown: typeof _unknown;
+};
+/**
+ * @description A temporary compatibility function for updating a task status, purely for migration purposes.
+ * @deprecated Use {@link update.status} instead
+ * @since 0.6.0
+ */
+export declare const update_compat: (taskId: string, contextId: string, state: A2A.TaskState, message?: A2A.Message, timestamp?: string, final?: boolean) => A2A.TaskStatusUpdateEvent;
+export {};

package/dist/browser/create/task-builder.js

@@ -0,0 +1,379 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../types/index.js";
+import { v4 as uuidv4 } from "uuid";
+import { getCurrentTimestamp } from "../utils/common/utils.js";
+import { isMessageParams, Message,
+// type BuilderMessageParams,
+ } from "./message-builder.js";
+export const isArtifactParams = (params) => {
+    return (typeof params === "string" ||
+        (typeof params === "object" && params !== null && "parts" in params));
+};
+export class Artifact {
+    constructor(artifact_params = {}) {
+        this._artifact = {
+            artifactId: uuidv4(),
+            parts: [],
+            ...artifact_params,
+        };
+    }
+    get artifact() {
+        return this._artifact;
+    }
+    static create(params = {}) {
+        return new Artifact(typeof params === "string"
+            ? { parts: [{ text: params, kind: "text" }] }
+            : params).artifact;
+    }
+}
+export const artifact = Artifact.create;
+export const isStatusParams = (params) => {
+    return (typeof params === "string" ||
+        (typeof params === "object" &&
+            params !== null &&
+            "state" in params &&
+            params.state in A2A.TaskState) ||
+        (typeof params === "object" &&
+            params !== null &&
+            "message" in params &&
+            isMessageParams(params.message)));
+};
+export class TaskStatus {
+    constructor(params = {}) {
+        const timestamp = params.timestamp ?? getCurrentTimestamp();
+        this._status = {
+            ...params,
+            state: params.state ?? A2A.TaskState.working,
+            timestamp,
+        };
+    }
+    get status() {
+        return this._status;
+    }
+    static create(params = {}) {
+        if (typeof params === "string" && params in A2A.TaskState) {
+            return new TaskStatus({ state: params }).status;
+        }
+        else if (isMessageParams(params)) {
+            return new TaskStatus({
+                state: A2A.TaskState.working,
+                message: Message.create(params),
+            }).status;
+        }
+        return new TaskStatus(params).status;
+    }
+}
+/**
+ * Convenience factory function for creating a task status with default parameters.
+ *
+ * @returns New {@link A2A.TaskStatus} with default parameters
+ * @defaults {
+ *   state: "working",
+ *   timestamp: getCurrentTimestamp(),
+ * }
+ *
+ * @example
+ * ```typescript
+ * const status = status("working");
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export const status = TaskStatus.create;
+export class Task {
+    constructor(params = {}) {
+        const id = params.id ?? uuidv4();
+        this._task = {
+            ...params,
+            id,
+            contextId: params.contextId ?? id,
+            kind: A2A.Kind.task,
+            status: TaskStatus.create(params.status),
+        };
+    }
+    get task() {
+        return this._task;
+    }
+    static create(params = {}) {
+        if (isStatusParams(params)) {
+            return new Task({ status: TaskStatus.create(params) }).task;
+        }
+        return new Task(params).task;
+    }
+}
+/**
+ * Convenience factory function for creating a task with default parameters.
+ *
+ * @returns New {@link A2A.Task} with default parameters
+ * @defaults:
+ * - `id`: uuidv4()
+ * - `contextId`: id
+ * - `status`: { state: "working" }
+ * @example
+ * ```typescript
+ * const task = task({ status: { state: "working" } });
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export const task = Task.create;
+export class TaskStatusUpdateEvent {
+    constructor(params) {
+        const taskId = params.taskId ?? params.status.message?.taskId ?? uuidv4();
+        const contextId = params.contextId ?? params.status.message?.contextId ?? taskId;
+        this._event = {
+            ...params,
+            taskId,
+            contextId,
+            kind: A2A.Kind["status-update"],
+            final: params.final ?? false,
+        };
+    }
+    get event() {
+        return this._event;
+    }
+    static create(params) {
+        if (isStatusParams(params)) {
+            return new TaskStatusUpdateEvent({
+                /*allows for a mixture of Update & Status Params*/
+                ...(typeof params === "object" ? params : {}),
+                status: TaskStatus.create(params),
+            }).event;
+        }
+        return new TaskStatusUpdateEvent(params).event;
+    }
+}
+export class TaskArtifactUpdateEvent {
+    constructor(params) {
+        const taskId = params.taskId ?? uuidv4();
+        this._event = {
+            ...params,
+            taskId,
+            contextId: params.contextId ?? taskId,
+            kind: A2A.Kind["artifact-update"],
+        };
+    }
+    get event() {
+        return this._event;
+    }
+    static create(params) {
+        if (isArtifactParams(params)) {
+            return new TaskArtifactUpdateEvent({
+                artifact: Artifact.create(params),
+            }).event;
+        }
+        return new TaskArtifactUpdateEvent({
+            ...params,
+            artifact: Artifact.create(params.artifact),
+        }).event;
+    }
+}
+const strict_update = (params) => {
+    return TaskStatusUpdateEvent.create(params);
+};
+function _buildUpdate(state, params, final) {
+    return strict_update({
+        taskId: params.taskId,
+        contextId: params.contextId,
+        status: {
+            state: state,
+            message: params.message,
+            timestamp: params.timestamp,
+        },
+        final: final ?? params.final,
+        metadata: params.metadata,
+    });
+}
+function _working(params) {
+    return _buildUpdate(A2A.TaskState.working, params);
+}
+function _canceled(params) {
+    return _buildUpdate(A2A.TaskState.canceled, params, true);
+}
+function _submitted(params) {
+    return _buildUpdate(A2A.TaskState.submitted, params);
+}
+function _failed(params) {
+    return _buildUpdate(A2A.TaskState.failed, params, true);
+}
+function _completed(params) {
+    return _buildUpdate(A2A.TaskState.completed, params, true);
+}
+function _inputRequired(params) {
+    return _buildUpdate(A2A.TaskState["input-required"], params);
+}
+function _rejected(params) {
+    return _buildUpdate(A2A.TaskState.rejected, params);
+}
+function _authRequired(params) {
+    return _buildUpdate(A2A.TaskState["auth-required"], params);
+}
+function _unknown(params) {
+    return _buildUpdate(A2A.TaskState["unknown"], params);
+}
+/**
+ * Convenience factory function for creating a task status and artifact update events with default parameters.
+ *
+ * @returns New {@link A2A.TaskStatusUpdateEvent} and {@link A2A.TaskArtifactUpdateEvent} with default parameters
+ *
+ * @example
+ * ```typescript
+ * const artifactEvent = update.artifact({
+ *   artifact: "result"
+ * });
+ * const statusEvent = update.status({
+ *   status: "working"
+ * });
+ * ```
+ *
+ * @public
+ * @since 0.6.0
+ */
+export const update = {
+    /**
+     * Convenience factory function for creating a task artifact update event.
+     * @returns New {@link A2A.TaskArtifactUpdateEvent}
+     * @example
+     * ```typescript
+     * const event = update.artifact({
+     *   artifact: "result"
+     * });
+     * ```
+     */
+    artifact: TaskArtifactUpdateEvent.create,
+    /**
+     * Convenience factory function for creating a task status update event.
+     * @returns New {@link A2A.TaskStatusUpdateEvent}
+     * @example
+     * ```typescript
+     * const event = update.status({
+     *   message: "Working on the task"
+     * });
+     * ```
+     */
+    status: TaskStatusUpdateEvent.create,
+    /**
+     * Convenience factory function for creating a task status update event with the working state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.working} state
+     * @example
+     * ```typescript
+     * const event = update.working({
+     *   message: "Working on the task"
+     * });
+     * ```
+     */
+    working: _working,
+    /**
+     * Convenience factory function for creating a task status update event with the canceled state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.canceled} state
+     * @example
+     * ```typescript
+     * const event = update.canceled({
+     *   message: "Task canceled"
+     * });
+     * ```
+     */
+    canceled: _canceled,
+    /**
+     * Convenience factory function for creating a task status update event with the submitted state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.submitted} state
+     * @example
+     * ```typescript
+     * const event = update.submitted({
+     *   message: "Task submitted"
+     * });
+     * ```
+     */
+    submitted: _submitted,
+    /**
+     * Convenience factory function for creating a task status update event with the failed state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.failed} state
+     * @example
+     * ```typescript
+     * const event = update.failed({
+     *   message: "Task failed"
+     * });
+     * ```
+     */
+    failed: _failed,
+    /**
+     * Convenience factory function for creating a task status update event with the completed state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.completed} state
+     * @example
+     * ```typescript
+     * const event = update.completed({
+     *   message: "Task completed"
+     * });
+     * ```
+     */
+    completed: _completed,
+    /**
+     * Convenience factory function for creating a task status update event with the input required state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState["input-required"]} state
+     * @example
+     * ```typescript
+     * const event = update.inputRequired({
+     *   message: "Task input required"
+     * });
+     * ```
+     */
+    inputRequired: _inputRequired,
+    /**
+     * Convenience factory function for creating a task status update event with the rejected state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.rejected} state
+     * @example
+     * ```typescript
+     * const event = update.rejected({
+     *   message: "Task rejected"
+     * });
+     * ```
+     */
+    rejected: _rejected,
+    /**
+     * Convenience factory function for creating a task status update event with the auth required state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState["auth-required"]} state
+     * @example
+     * ```typescript
+     * const event = update.authRequired({
+     *   message: {
+     *   role: "agent"
+     *   parts: [
+     *     {
+     *       text: "Task auth required"
+     *     }
+     *   ]
+     *   kind: "message"
+     * });
+     * ```
+     */
+    authRequired: _authRequired,
+    /**
+     * Convenience factory function for creating a task status update event with the unknown state.
+     * @returns New {@link A2A.TaskStatusUpdateEvent} with the {@link A2A.TaskState.unknown} state
+     * @example
+     * ```typescript
+     * const event = update.unknown({
+     *   message: "Task unknown"
+     * });
+     * ```
+     */
+    unknown: _unknown,
+};
+/**
+ * @description A temporary compatibility function for updating a task status, purely for migration purposes.
+ * @deprecated Use {@link update.status} instead
+ * @since 0.6.0
+ */
+export const update_compat = (taskId, contextId, state, message, timestamp, final = false) => {
+    return _buildUpdate(state, {
+        taskId: taskId,
+        contextId: contextId,
+        message: message,
+        timestamp: timestamp,
+    }, final);
+};

package/dist/browser/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/browser/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/browser/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/browser/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/browser/types/a2a/index.js

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

package/dist/browser/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[];