@artinet/sdk 0.5.18 → 0.6.0-preview.1

package/dist/services/a2a/factory/context.d.ts

@@ -2,131 +2,18 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * @fileoverview A2A Context Factory Functions
- *
- * This module provides factory functions for creating A2A execution contexts
- * and command channels. It handles the composition of various context components
- * including command proxies, event managers, and cancellation mechanisms.
- *
- * @module A2AContextFactory
- * @version 0.5.7
- * @since 0.5.6
- * @author The Artinet Project
- */
-import { Command, ReceiveCommandProxyInterface, State, Update, Context, A2AServiceInterface, ContextManagerInterface, EventManagerOptions } from "../../../types/index.js";
-/**
- * Creates a command channel proxy for the given command.
- *
- * This function wraps a command in a proxy interface that provides
- * controlled access to command data and may add additional functionality
- * such as validation, logging, or transformation.
- *
- * @template TCommand - The command type, must extend Command
- * @param request - The command to wrap in a proxy
- * @returns Command proxy interface for the request
- *
- * @example
- * ```typescript
- * const command: MessageSendParams = {
- *   message: {
- *     content: 'Hello, world!',
- *     recipient: 'agent-123'
- *   }
- * };
- *
- * const commandProxy = createCommandChannel(command);
- * // Use commandProxy to access command data safely
- * ```
- *
- * @public
- * @since 0.5.6
- */
-export declare function createCommandChannel<TCommand extends Command = Command>(request: TCommand): ReceiveCommandProxyInterface<TCommand>;
-/**
- * Creates a complete A2A execution context for command processing.
- *
- * This is the main factory function for creating execution contexts in the A2A
- * framework. It assembles all the necessary components including command proxy,
- * event management, cancellation handling, and state management into a cohesive
- * execution environment.
- *
- * The context serves as the primary execution environment passed to execution
- * engines and provides access to all the resources and capabilities needed
- * for command processing.
- *
- * @template TCommand - The command type, must extend Command
- * @template TState - The state type, must extend State
- * @template TUpdate - The update type, must extend Update
- *
- * @param request - The command to execute
- * @param service - The A2A service instance
- * @param contextManager - Manager for context lifecycle
- * @param abortSignal - Optional abort signal for cancellation
- * @param contextId - Optional context ID (generates UUID if not provided)
- * @param eventOverrides - Optional event manager configuration overrides
- * @returns Fully configured execution context
- *
- * @example
- * ```typescript
- * // Basic context creation
- * const context = createContext(
- *   messageCommand,
- *   a2aService,
- *   contextManager
- * );
- *
- * // Execute with the context
- * for await (const update of engine(context)) {
- *   console.log('Update:', update);
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Context creation with custom options
- * const abortController = new AbortController();
- * const customEventOptions = {
- *   onStart: async (ctx) => {
- *     console.log('Custom start handler');
- *     return initialState;
- *   }
- * };
- *
- * const context = createContext(
- *   command,
- *   service,
- *   contextManager,
- *   abortController.signal,
- *   'custom-context-id',
- *   customEventOptions
- * );
- *
- * // Cancel after 30 seconds
- * setTimeout(() => abortController.abort(), 30000);
- * ```
- *
- * @remarks
- * **Context Lifecycle:**
- * 1. Command proxy is created to wrap the incoming request
- * 2. Event manager is instantiated with service and override options
- * 3. Cancellation mechanisms are configured (abort signal + service cancellation)
- * 4. State accessor is bound to the event manager
- * 5. Complete context is registered with the context manager
- *
- * **Cancellation Handling:**
- * The context provides multiple cancellation mechanisms:
- * - AbortSignal for standard cancellation patterns
- * - Service-level cancellation tracking
- * - Combined cancellation status through isCancelled()
- *
- * **Event Management:**
- * The context includes an event manager that handles:
- * - Execution lifecycle events (start, update, complete, error)
- * - State transitions and persistence
- * - Custom event handling through overrides
- *
- * @public
- * @since 0.5.6
- */
-export declare function createContext<TCommand extends Command = Command, TState extends State = State, TUpdate extends Update = Update>(request: TCommand, service: A2AServiceInterface<TCommand, TState, TUpdate>, contextManager: ContextManagerInterface<TCommand, TState, TUpdate>, abortSignal?: AbortSignal, contextId?: string, eventOverrides?: EventManagerOptions<TCommand, TState, TUpdate>): Context<TCommand, TState, TUpdate>;
+import { A2A } from "../../../types/index.js";
+export declare function createBaseContext({ contextId, service, task, overrides, abortSignal, }: {
+    contextId: string;
+    service: A2A.Service;
+    task?: A2A.Task;
+    overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>;
+    abortSignal?: AbortSignal;
+}): A2A.BaseContext;
+export declare function createContext({ baseContext, taskId, messenger, extensions, references, }: {
+    baseContext: A2A.BaseContext;
+    taskId: string;
+    messenger: A2A.MessageConsumerProxy;
+    extensions?: A2A.AgentExtension[];
+    references?: A2A.Task[];
+}): A2A.Context;

package/dist/services/a2a/factory/context.js

@@ -2,149 +2,44 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createEventManager } from "./event.js";
-import { v4 as uuidv4 } from "uuid";
-import { CommandChannel } from "../../core/managers/command.js";
 /**
- * Creates a command channel proxy for the given command.
- *
- * This function wraps a command in a proxy interface that provides
- * controlled access to command data and may add additional functionality
- * such as validation, logging, or transformation.
- *
- * @template TCommand - The command type, must extend Command
- * @param request - The command to wrap in a proxy
- * @returns Command proxy interface for the request
- *
- * @example
- * ```typescript
- * const command: MessageSendParams = {
- *   message: {
- *     content: 'Hello, world!',
- *     recipient: 'agent-123'
- *   }
- * };
- *
- * const commandProxy = createCommandChannel(command);
- * // Use commandProxy to access command data safely
- * ```
- *
- * @public
- * @since 0.5.6
- */
-export function createCommandChannel(request) {
-    return CommandChannel.create(request);
-}
-/**
- * Creates a complete A2A execution context for command processing.
- *
- * This is the main factory function for creating execution contexts in the A2A
- * framework. It assembles all the necessary components including command proxy,
- * event management, cancellation handling, and state management into a cohesive
- * execution environment.
- *
- * The context serves as the primary execution environment passed to execution
- * engines and provides access to all the resources and capabilities needed
- * for command processing.
- *
- * @template TCommand - The command type, must extend Command
- * @template TState - The state type, must extend State
- * @template TUpdate - The update type, must extend Update
+ * @fileoverview A2A Context Factory Functions
  *
- * @param request - The command to execute
- * @param service - The A2A service instance
- * @param contextManager - Manager for context lifecycle
- * @param abortSignal - Optional abort signal for cancellation
- * @param contextId - Optional context ID (generates UUID if not provided)
- * @param eventOverrides - Optional event manager configuration overrides
- * @returns Fully configured execution context
+ * This module provides factory functions for creating A2A execution contexts
+ * and command channels. It handles the composition of various context components
+ * including command proxies, event managers, and cancellation mechanisms.
  *
- * @example
- * ```typescript
- * // Basic context creation
- * const context = createContext(
- *   messageCommand,
- *   a2aService,
- *   contextManager
- * );
- *
- * // Execute with the context
- * for await (const update of engine(context)) {
- *   console.log('Update:', update);
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Context creation with custom options
- * const abortController = new AbortController();
- * const customEventOptions = {
- *   onStart: async (ctx) => {
- *     console.log('Custom start handler');
- *     return initialState;
- *   }
- * };
- *
- * const context = createContext(
- *   command,
- *   service,
- *   contextManager,
- *   abortController.signal,
- *   'custom-context-id',
- *   customEventOptions
- * );
- *
- * // Cancel after 30 seconds
- * setTimeout(() => abortController.abort(), 30000);
- * ```
- *
- * @remarks
- * **Context Lifecycle:**
- * 1. Command proxy is created to wrap the incoming request
- * 2. Event manager is instantiated with service and override options
- * 3. Cancellation mechanisms are configured (abort signal + service cancellation)
- * 4. State accessor is bound to the event manager
- * 5. Complete context is registered with the context manager
- *
- * **Cancellation Handling:**
- * The context provides multiple cancellation mechanisms:
- * - AbortSignal for standard cancellation patterns
- * - Service-level cancellation tracking
- * - Combined cancellation status through isCancelled()
- *
- * **Event Management:**
- * The context includes an event manager that handles:
- * - Execution lifecycle events (start, update, complete, error)
- * - State transitions and persistence
- * - Custom event handling through overrides
- *
- * @public
+ * @module A2AContextFactory
+ * @version 0.6.0-preview
  * @since 0.5.6
+ * @author The Artinet Project
  */
-export function createContext(request, service, contextManager, abortSignal = new AbortController().signal, contextId = uuidv4(), eventOverrides) {
-    // Note: Context reuse logic is currently disabled for testing
-    // Future versions may re-enable context reuse for performance optimization
-    //   if (contextId && contextId.length > 0) {
-    //     //disable for testing
-    //     const context = contextManager.getContext(contextId);
-    //     if (!context) {
-    //       console.error("createExecutionContext", contextId, "Context not found");
-    //       throw new TRPCError({
-    //         code: "NOT_FOUND",
-    //         message: "Context not found",
-    //       });
-    //     }
-    //     return context;
-    //   }
-    let newEventManager;
+import { createStateMachine } from "./state-machine.js";
+import { v4 as uuidv4 } from "uuid";
+export function createBaseContext({ contextId = uuidv4(), service, task, overrides, abortSignal = new AbortController().signal, }) {
+    const isCancelled = async () => (await service.cancellations.has(task?.id ?? contextId)) ||
+        abortSignal.aborted;
+    const getState = async (args) => args ? await service.tasks.get(args) : task;
     const context = {
         contextId: contextId,
-        command: createCommandChannel(request),
-        events: (newEventManager = createEventManager(service, contextId, eventOverrides)),
-        signal: abortSignal,
-        isCancelled: () => abortSignal?.aborted || service.isCancelled(contextId),
-        State: () => newEventManager.getState(),
+        service: service,
+        publisher: createStateMachine({ contextId, service, task, overrides }),
+        isCancelled,
+        abortSignal: abortSignal,
+        getState,
+    };
+    return context;
+}
+export function createContext({ baseContext, taskId, messenger, extensions, references, }) {
+    const getTask = async () => baseContext.publisher.currentTask;
+    const context = {
+        ...baseContext,
+        taskId: baseContext.publisher.currentTask.id ?? taskId,
+        userMessage: messenger.message,
+        messages: messenger,
+        getTask,
+        extensions: extensions,
+        references: references,
     };
-    contextManager.setContext(contextId, context);
     return context;
 }

package/dist/services/a2a/factory/handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare function createHandler(methods?: Omit<Partial<A2A.RequestHandler>, "getAgentCard">): Omit<A2A.RequestHandler, "getAgentCard">;

package/dist/services/a2a/factory/{method.js → handler.js}

@@ -2,8 +2,8 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { getTask, cancelTask, sendMessage, streamMessage, resubscribe, } from "../methods/index.js";
-export function createMethods(methods) {
+import { getTask, cancelTask, sendMessage, streamMessage, resubscribe, } from "../handlers/index.js";
+export function createHandler(methods) {
     return {
         getTask: methods?.getTask ?? getTask,
         cancelTask: methods?.cancelTask ?? cancelTask,

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

@@ -1,5 +1,4 @@
 export * from "./context.js";
 export * from "./builder.js";
-export * from "./event.js";
-export * from "./method.js";
+export * from "./state-machine.js";
 export * from "./service.js";

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

@@ -1,5 +1,4 @@
 export * from "./context.js";
 export * from "./builder.js";
-export * from "./event.js";
-export * from "./method.js";
+export * from "./state-machine.js";
 export * from "./service.js";

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

@@ -1,9 +1,22 @@
+import { A2A } from "../../../types/index.js";
+import { Service } from "../service.js";
+export type AgentCardParams = (Partial<A2A.AgentCard> & Required<Pick<A2A.AgentCard, "name">>) | string;
+export interface ServiceParams {
+    agentCard: AgentCardParams;
+    engine: A2A.Engine;
+    contexts?: A2A.Contexts;
+    streams?: A2A.Streams;
+    connections?: A2A.Connections;
+    cancellations?: A2A.Cancellations;
+    tasks?: A2A.Tasks;
+    methods?: Omit<A2A.RequestHandler, "getAgentCard">;
+    overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>;
+}
+export type CreateAgentParams = ServiceParams;
+export declare function createService(params: ServiceParams): Service;
+export declare const createAgent: typeof createService;
+export type AgentHandler = ReturnType<typeof createService>;
 /**
- * Copyright 2025 The Artinet Project
- * SPDX-License-Identifier: Apache-2.0
+ * @deprecated Use AgentHandler instead
  */
-import { FactoryParams } from "../../../types/index.js";
-import { A2AService } from "../service.js";
-export declare function createService(params: FactoryParams): A2AService;
-export declare const createAgent: typeof createService;
-export type AgentImpl = ReturnType<typeof createAgent>;
+export type AgentImpl = AgentHandler;

package/dist/services/a2a/factory/service.js

@@ -2,11 +2,11 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { A2AService } from "../service.js";
-import { ContextManager, ConnectionManager, CancellationManager, TaskManager, } from "../managers/index.js";
-import { createMethods } from "./method.js";
+import { createHandler } from "./handler.js";
 import { createAgentCard } from "../helpers/agentcard-builder.js";
+import { Service } from "../service.js";
+import { Contexts, Streams, Connections, Cancellations, Tasks, } from "../managers.js";
 export function createService(params) {
-    return new A2AService(createAgentCard(params.agentCard), params.engine, params.contexts ?? new ContextManager(), params.connections ?? new ConnectionManager(), params.cancellations ?? new CancellationManager(), params.tasks ?? new TaskManager(), createMethods(params.methods), params.events, params.enforceParamValidation ?? false);
+    return new Service(createAgentCard(params.agentCard), params.engine, params.connections ?? new Connections(), params.cancellations ?? new Cancellations(), params.tasks ?? new Tasks(), params.contexts ?? new Contexts(), params.streams ?? new Streams(), createHandler(params.methods), params.overrides);
 }
 export const createAgent = createService;

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

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare function createStateMachine({ contextId, service, task: currentTask, overrides, }: {
+    contextId: string;
+    service: A2A.Service;
+    task?: A2A.Task;
+    overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>;
+}): A2A.EventPublisher;

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

@@ -0,0 +1,66 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { StateMachine } from "../state-machine.js";
+import { logger } from "../../../config/index.js";
+import { TASK_NOT_FOUND, CANCEL_UPDATE, FAILED_UPDATE } from "../../../utils/index.js";
+import assert from "assert";
+export function createStateMachine({ contextId, service, task: currentTask, overrides, }) {
+    const handler = {
+        contextId: contextId,
+        onStart: async (context) => {
+            assert(context.contextId === contextId, "context mismatch");
+            logger.info(`onStart[ctx:${contextId}]:`, { taskId: context.taskId });
+            await service.connections.set(context.contextId);
+            const task = await service.tasks.get(context.taskId);
+            // we now expect the task to be created by the service
+            // so if it's not found we throw an error
+            if (!task) {
+                throw TASK_NOT_FOUND({ taskId: context.taskId, contextId: contextId });
+            }
+            return task;
+        },
+        onCancel: async (update, task) => {
+            logger.info(`onCancel[ctx:${contextId}]:`, "cancellation triggered");
+            logger.debug(`onCancel[ctx:${contextId}]:`, "arguments", update, task);
+            await service.cancellations.set(task.id);
+            const cancellation = CANCEL_UPDATE(task.id, task.contextId, update.status?.message);
+            await service.tasks.update((await service.contexts.get(contextId)), cancellation);
+        },
+        onUpdate: async (update, task) => {
+            logger.info(`onUpdate[ctx:${contextId}]:`);
+            logger.debug(`onUpdate[ctx:${contextId}]:`, { taskId: task.id });
+            if (await service.cancellations.has(task.id)) {
+                logger.warn(`onUpdate[ctx:${contextId}]:`, { taskId: task.id }, "task is cancelled, no longer processing updates");
+                return task;
+            }
+            return await service.tasks.update((await service.contexts.get(contextId)), update);
+        },
+        onError: async (error, task) => {
+            logger.error(`onError[ctx:${contextId}]:`, error);
+            if (!task) {
+                logger.error(`onError[ctx:${contextId}]:`, new Error("task not found"));
+                return;
+            }
+            const errorUpdate = FAILED_UPDATE(task.id, contextId, undefined, error instanceof Error ? error.message : String(error));
+            await service.tasks
+                .update((await service.contexts.get(contextId)), errorUpdate)
+                .catch((error) => {
+                //we capture errors thrown during error handling to ensure we trigger completion gracefully
+                logger.error(`onError[ctx:${contextId}]:`, error);
+            });
+        },
+        onComplete: async (task) => {
+            assert(task.contextId === contextId, "context mismatch");
+            logger.info(`onComplete[ctx:${contextId}]:`, { taskId: task.id });
+            await service.cancellations.delete(task.id);
+            await service.connections.delete(task.contextId);
+            await service.contexts.delete(task.contextId);
+        },
+    };
+    return new StateMachine(contextId, {
+        ...handler,
+        ...overrides,
+    }, currentTask);
+}

package/dist/services/a2a/{state/update → handlers}/artifact.d.ts

@@ -2,9 +2,9 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { Artifact } from "../../../../types/index.js";
-export declare function updateByIndex(append: boolean, artifacts: Artifact[], index: number, artifactUpdate: Artifact): {
-    artifacts: Artifact[];
+import { A2A } from "../../../types/index.js";
+export declare function updateByIndex(append: boolean, artifacts: A2A.Artifact[], index: number, artifactUpdate: A2A.Artifact): {
+    artifacts: A2A.Artifact[];
     replaced: boolean;
 };
-export declare function processArtifactUpdate(append: boolean, artifacts: Artifact[], artifactUpdate: Artifact): Artifact[];
+export declare function processArtifactUpdate(append: boolean, artifacts: A2A.Artifact[], artifactUpdate: A2A.Artifact): A2A.Artifact[];

package/dist/services/a2a/handlers/cancel-task.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare const cancelTask: A2A.RequestHandler["cancelTask"];
+export type CancelTaskHandler = typeof cancelTask;
+/**
+ * @deprecated Use CancelTaskHandler instead
+ */
+export type CancelTaskMethod = CancelTaskHandler;

package/dist/services/a2a/handlers/cancel-task.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+import { FINAL_STATES, TASK_NOT_FOUND, TASK_NOT_CANCELABLE, INTERNAL_ERROR, } from "../../../utils/index.js";
+export const cancelTask = async ({ id: taskId }, context) => {
+    if (!context) {
+        throw INTERNAL_ERROR({ error: { message: "Context is required" } });
+    }
+    const service = context.service;
+    const task = await service.tasks.get(taskId);
+    if (!task) {
+        throw TASK_NOT_FOUND({ taskId });
+    }
+    if (FINAL_STATES.includes(task.status.state)) {
+        throw TASK_NOT_CANCELABLE("Task is in a final state: " + task.status.state);
+    }
+    service.cancellations.set(taskId);
+    const cancelledTask = {
+        ...task,
+        status: {
+            ...task.status,
+            state: A2A.TaskState.canceled,
+        },
+    };
+    context.publisher?.on("complete", async () => {
+        await service.cancellations.delete(taskId);
+        await service.contexts.delete(context.contextId);
+    });
+    await context.publisher.onCancel(cancelledTask);
+    return cancelledTask;
+};

package/dist/services/a2a/handlers/get-task.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare const getTask: A2A.RequestHandler["getTask"];
+export type GetTaskHandler = typeof getTask;
+/**
+ * @deprecated Use GetTaskHandler instead
+ */
+export type GetTaskMethod = GetTaskHandler;

package/dist/services/a2a/handlers/get-task.js

@@ -0,0 +1,13 @@
+import { TASK_NOT_FOUND, INTERNAL_ERROR } from "../../../utils/index.js";
+import { getLatestHistory } from "../helpers/index.js";
+export const getTask = async ({ id: taskId, historyLength }, context) => {
+    if (!context) {
+        throw INTERNAL_ERROR({ error: { message: "Context is required" } });
+    }
+    const task = await context.service.tasks.get(taskId);
+    if (!task) {
+        throw TASK_NOT_FOUND({ taskId });
+    }
+    task.history = getLatestHistory(task, historyLength);
+    return task;
+};

package/dist/services/a2a/handlers/resubscribe-task.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare const resubscribe: A2A.RequestHandler["resubscribe"];
+export type TaskResubscribeHandler = typeof resubscribe;
+/**
+ * @deprecated Use ResubscribeTaskHandler instead
+ */
+export type ResubscribeTaskMethod = TaskResubscribeHandler;

package/dist/services/a2a/handlers/resubscribe-task.js

@@ -0,0 +1,56 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+import { FINAL_STATES, INTERNAL_ERROR, TASK_NOT_FOUND } from "../../../utils/index.js";
+const flush = (task, stream) => {
+    if (task.artifacts && task.artifacts.length > 0) {
+        for (const artifact of task.artifacts) {
+            const artifactUpdate = {
+                kind: A2A.Kind["artifact-update"],
+                taskId: task.id,
+                contextId: task.contextId,
+                artifact,
+                lastChunk: task.artifacts.length === 1,
+                metadata: task.metadata,
+            };
+            stream.updates.push(artifactUpdate);
+            task.artifacts.shift();
+        }
+    }
+};
+export const resubscribe = async function* ({ id: taskId }, context) {
+    if (!context) {
+        throw INTERNAL_ERROR({ error: { message: "Context is required" } });
+    }
+    const service = context.service;
+    if (!(await service.tasks.has(taskId))) {
+        throw TASK_NOT_FOUND({ taskId });
+    }
+    const stream = (await service.streams.get(context.contextId)) ??
+        (await service.streams.create({
+            contextId: context.contextId,
+            context,
+        }));
+    // since we already checked if the task exists
+    // then we dont care about the upsert in onStart
+    // so we can just push the update and continue
+    context.publisher.on("start", async (_, task) => {
+        stream.updates.push({
+            kind: "status-update",
+            taskId: task.id,
+            contextId: task.contextId,
+            status: task.status,
+            final: false,
+            metadata: task.metadata,
+        });
+        if (FINAL_STATES.includes(task.status.state)) {
+            flush(task, stream);
+            await stream.kill();
+        }
+    });
+    yield* stream.run({
+        service: service,
+    });
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../../../types/index.js";
+export declare const sendMessage: A2A.RequestHandler["sendMessage"];
+export type SendMessageHandler = typeof sendMessage;
+/**
+ * @deprecated Use SendMessageHandler instead
+ */
+export type SendMessageMethod = SendMessageHandler;