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

package/dist/server/express/middeware.js

@@ -2,9 +2,9 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-import { A2A } from "../../types/index.js";
-import { PUSH_NOTIFICATION_NOT_SUPPORTED, INVALID_REQUEST, INVALID_PARAMS, METHOD_NOT_FOUND, AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED, } from "../../utils/index.js";
 import { logger } from "../../config/index.js";
+import { formatJson } from "../../utils/common/utils.js";
+import { A2AError } from "@a2a-js/sdk/server";
 const isValidMethod = (method) => {
     return (method &&
         method !== "" &&
@@ -14,41 +14,35 @@ const isValidMethod = (method) => {
 };
 const checkParams = (params, method) => {
     if (!params || (typeof params !== "object" && !Array.isArray(params))) {
-        throw INVALID_PARAMS({
-            data: {
-                message: "Invalid params",
-                method,
-            },
+        throw A2AError.invalidParams("Invalid Parameters", {
+            params,
+            method,
         });
     }
     else if (typeof params === "object" && Object.keys(params).length === 0) {
-        throw INVALID_PARAMS({
-            data: {
-                message: "No params provided",
-                method,
-            },
+        throw A2AError.invalidParams("Params Required", {
+            params,
+            method,
         });
     }
 };
 export async function jsonRPCMiddleware(service, req, res, next, extendedAgentCard) {
     const { method, params, id, jsonrpc } = req.body;
     if (jsonrpc !== "2.0" ||
-        (id && typeof id !== "string" && typeof id !== "number" && id !== null)) {
+        (typeof id !== "string" &&
+            typeof id === "number" &&
+            !Number.isInteger(id) &&
+            id !== null)) {
         res.json({
             jsonrpc: "2.0",
             id: id || null,
-            error: { code: A2A.ErrorCodeInvalidRequest, message: "Invalid Request" },
+            error: A2AError.invalidRequest(`Invalid JSONRPC info: ${formatJson({ method, params, id, jsonrpc })}`).toJSONRPCError(),
         });
         return;
     }
     try {
         if (!isValidMethod(method)) {
-            throw INVALID_REQUEST({
-                data: {
-                    message: "No method provided",
-                    method,
-                },
-            });
+            throw A2AError.invalidRequest("No method provided");
         }
         let result;
         switch (method) {
@@ -101,34 +95,19 @@ export async function jsonRPCMiddleware(service, req, res, next, extendedAgentCa
             case "tasks/pushNotificationConfig/get":
             case "tasks/pushNotificationConfig/delete":
             case "task/pushNotificationConfig/list": {
-                throw PUSH_NOTIFICATION_NOT_SUPPORTED({
-                    data: {
-                        message: "Push notifications not supported",
-                        method,
-                    },
-                });
+                throw A2AError.pushNotificationNotSupported();
             }
             case "agent/getAuthenticatedExtendedCard": {
                 if (!extendedAgentCard ||
                     (await service.getAgentCard()).supportsAuthenticatedExtendedCard !==
                         true) {
-                    throw AUTHENTICATED_EXTENDED_CARD_NOT_CONFIGURED({
-                        data: {
-                            message: "Authenticated Extended Card is not configured",
-                            method,
-                        },
-                    });
+                    throw A2AError.authenticatedExtendedCardNotConfigured();
                 }
                 result = extendedAgentCard;
                 break;
             }
             default:
-                throw METHOD_NOT_FOUND({
-                    data: {
-                        message: "Method not found",
-                        method,
-                    },
-                });
+                throw A2AError.methodNotFound(method);
         }
         res.json({ jsonrpc: "2.0", id, result });
     }

package/dist/server/express/server.d.ts

@@ -11,14 +11,33 @@ export interface ServerParams {
     app?: express.Express;
     corsOptions?: CorsOptions;
     basePath?: string;
+    port?: number;
+    /**
+     * Your agentCard must have supportsAuthenticatedExtendedCard set to true
+     */
     extendedAgentCard?: A2A.AgentCard;
     agent: Agent | CreateAgentParams;
     agentCardPath?: string;
     register?: boolean;
 }
 export declare function rpcParser(req: express.Request, res: express.Response, next: express.NextFunction): void;
-export declare function createAgentServer({ app, basePath, agentCardPath, agent, corsOptions, extendedAgentCard, }: ServerParams): {
+/**
+ * @note Best used with the `cr8` builder.
+ * @param {ServerParams} params - The server parameters
+ * @returns {ExpressAgentServer} - The express agent server
+ * @example
+ * ```typescript
+ * const { app, agent, start } = createAgentServer({
+ *   agent: cr8("MyAgent")
+ *     .text("Hello, world!")
+ *     .agent,
+ *   basePath: "/a2a",
+ * });
+ * ```
+ */
+export declare function createAgentServer({ app, basePath, agentCardPath, agent, corsOptions, extendedAgentCard, register, port, }: ServerParams): {
     app: express.Express;
     agent: Agent;
+    start: (_port?: number) => import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
 };
 export type ExpressAgentServer = ReturnType<typeof createAgentServer>;

package/dist/server/express/server.js

@@ -3,26 +3,24 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import express from "express";
-import { INVALID_REQUEST, PARSE_ERROR } from "../../utils/index.js";
 import { createAgent, Service, } from "../../services/index.js";
 import cors from "cors";
 import { jsonRPCMiddleware } from "./middeware.js";
 import { errorHandler } from "./errors.js";
+import { logger } from "../../config/index.js";
+import { A2AError } from "@a2a-js/sdk/server";
+import { formatJson } from "../../utils/common/utils.js";
 export function rpcParser(req, res, next) {
     express.json()(req, res, (err) => {
         if (!req.body || typeof req.body !== "object") {
-            return next(PARSE_ERROR({
-                data: { message: "Invalid request body" },
-            }));
+            return next(A2AError.parseError(`Invalid request body: ${formatJson(req.body)}`));
         }
         if (err) {
             if (err instanceof SyntaxError &&
                 "status" in err &&
                 err.status === 400 &&
                 "body" in err) {
-                return next(PARSE_ERROR({
-                    data: err.message,
-                }));
+                return next(A2AError.parseError(`Invalid request body: ${formatJson(req.body)}`));
             }
             return next(err);
         }
@@ -46,7 +44,25 @@ const ensureAgent = (agentOrParams) => {
     }
     throw new Error("invalid agent or params");
 };
-export function createAgentServer({ app = express(), basePath = "/", agentCardPath = "/.well-known/agent-card.json", agent, corsOptions, extendedAgentCard, }) {
+const registerAgent = async (agentCard) => {
+    logger.debug("registerAgent: not implemented", { agentCard });
+    return Promise.resolve(agentCard);
+};
+/**
+ * @note Best used with the `cr8` builder.
+ * @param {ServerParams} params - The server parameters
+ * @returns {ExpressAgentServer} - The express agent server
+ * @example
+ * ```typescript
+ * const { app, agent, start } = createAgentServer({
+ *   agent: cr8("MyAgent")
+ *     .text("Hello, world!")
+ *     .agent,
+ *   basePath: "/a2a",
+ * });
+ * ```
+ */
+export function createAgentServer({ app = express(), basePath = "/", agentCardPath = "/.well-known/agent-card.json", agent, corsOptions, extendedAgentCard, register = false, port, }) {
     const agentInstance = ensureAgent(agent);
     app.use(cors(corsOptions));
     if (agentCardPath !== "/.well-known/agent-card.json") {
@@ -72,10 +88,10 @@ export function createAgentServer({ app = express(), basePath = "/", agentCardPa
     //a standard express middleware to handle json-rpc requests
     app.post(basePath, rpcParser, async (req, res, next) => {
         const { jsonrpc } = req.body;
-        if (jsonrpc === "2.0") {
-            return await jsonRPCMiddleware(agentInstance, req, res, next, extendedAgentCard);
+        if (jsonrpc !== "2.0") {
+            return next(A2AError.invalidRequest("Invalid JSON-RPC request"));
         }
-        next(INVALID_REQUEST({ data: { message: "Invalid JSON-RPC request" } }));
+        return await jsonRPCMiddleware(agentInstance, req, res, next, extendedAgentCard);
     });
     app.use(errorHandler);
     /** this is an example of using trpc as express middleware
@@ -94,5 +110,21 @@ export function createAgentServer({ app = express(), basePath = "/", agentCardPa
       );
      * we could also use trpc directly or any other transport layer
      */
-    return { app, agent: agentInstance };
+    const start = (_port) => {
+        try {
+            const listenPort = _port ?? port;
+            const server = app.listen(listenPort, () => {
+                logger.info(`Agent server started on port ${listenPort}`);
+            });
+            if (register) {
+                registerAgent(agentInstance.agentCard);
+            }
+            return server;
+        }
+        catch (error) {
+            logger.error(`Failed to start agent server`, error);
+            throw error;
+        }
+    };
+    return { app, agent: agentInstance, start };
 }

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

@@ -3,4 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../../types/index.js";
+/**
+ * Our universal executor for {@link A2A.Engine}.
+ * @param engine - {@link A2A.Engine} to execute.
+ * @param context - {@link A2A.Context} provided to the engine.
+ */
 export declare const execute: (engine: A2A.Engine, context: A2A.Context) => Promise<void>;

package/dist/services/a2a/execute.js

@@ -2,6 +2,11 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * Our universal executor for {@link A2A.Engine}.
+ * @param engine - {@link A2A.Engine} to execute.
+ * @param context - {@link A2A.Context} provided to the engine.
+ */
 export const execute = async (engine, context) => {
     try {
         if (context.publisher.onStart) {
@@ -16,7 +21,9 @@ export const execute = async (engine, context) => {
         }
     }
     catch (error) {
+        /* onError triggers completion internally */
         await context.publisher.onError(error);
+        /* rethrow the error to be handled by the caller */
         throw error;
     }
     finally {

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

@@ -6,7 +6,7 @@ import { A2A } from "../../../types/index.js";
 export declare function createBaseContext({ contextId, service, task, overrides, abortSignal, }: {
     contextId: string;
     service: A2A.Service;
-    task?: A2A.Task;
+    task: A2A.Task;
     overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>;
     abortSignal?: AbortSignal;
 }): A2A.BaseContext;

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

@@ -17,8 +17,7 @@
 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 isCancelled = async () => (await service.cancellations.has(task.id)) || abortSignal.aborted;
     const getState = async (args) => args ? await service.tasks.get(args) : task;
     const context = {
         contextId: contextId,
@@ -34,7 +33,7 @@ export function createContext({ baseContext, taskId, messenger, extensions, refe
     const getTask = async () => baseContext.publisher.currentTask;
     const context = {
         ...baseContext,
-        taskId: baseContext.publisher.currentTask.id ?? taskId,
+        taskId,
         userMessage: messenger.message,
         messages: messenger,
         getTask,

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

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

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

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

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

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

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

@@ -1,8 +1,8 @@
+import * as describe from "../../../create/agentcard-builder.js";
 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;
+    agentCard: describe.AgentCardParams;
     engine: A2A.Engine;
     contexts?: A2A.Contexts;
     streams?: A2A.Streams;

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

@@ -3,10 +3,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { createHandler } from "./handler.js";
-import { createAgentCard } from "../helpers/agentcard-builder.js";
+import * as describe from "../../../create/agentcard-builder.js";
 import { Service } from "../service.js";
 import { Contexts, Streams, Connections, Cancellations, Tasks, } from "../managers.js";
 export function createService(params) {
-    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);
+    return new Service(describe.card(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

@@ -6,6 +6,6 @@ import { A2A } from "../../../types/index.js";
 export declare function createStateMachine({ contextId, service, task: currentTask, overrides, }: {
     contextId: string;
     service: A2A.Service;
-    task?: A2A.Task;
+    task: A2A.Task;
     overrides?: Partial<Omit<A2A.EventConsumer, "contextId">>;
 }): A2A.EventPublisher;

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

@@ -4,7 +4,8 @@
  */
 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 * as describe from "../../../create/describe.js";
+import { TASK_NOT_FOUND } from "../../../utils/index.js";
 import assert from "assert";
 export function createStateMachine({ contextId, service, task: currentTask, overrides, }) {
     const handler = {
@@ -25,7 +26,11 @@ export function createStateMachine({ contextId, service, task: currentTask, over
             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);
+            const cancellation = describe.update.canceled({
+                taskId: task.id,
+                contextId: task.contextId,
+                message: update.status?.message,
+            });
             await service.tasks.update((await service.contexts.get(contextId)), cancellation);
         },
         onUpdate: async (update, task) => {
@@ -43,17 +48,34 @@ export function createStateMachine({ contextId, service, task: currentTask, over
                 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) => {
+            const errorUpdate = describe.update.failed({
+                taskId: task.id,
+                contextId,
+                message: describe.message({
+                    messageId: "failed-update",
+                    parts: [
+                        {
+                            kind: "text",
+                            text: error instanceof Error ? error.message : String(error),
+                        },
+                    ],
+                }),
+            });
+            const context = await service.contexts.get(contextId);
+            if (!context) {
+                logger.error(`onError[ctx:${contextId}]:`, new Error("context not found"));
+                return;
+            }
+            await service.tasks.update(context, errorUpdate).catch((error) => {
                 //we capture errors thrown during error handling to ensure we trigger completion gracefully
-                logger.error(`onError[ctx:${contextId}]:`, error);
+                logger.error(`onError: task update error[ctx:${contextId}]:`, error);
             });
+            // we trigger completion here to ensure the context is cleaned up
+            await context.publisher.onComplete();
         },
         onComplete: async (task) => {
             assert(task.contextId === contextId, "context mismatch");
-            logger.info(`onComplete[ctx:${contextId}]:`, { taskId: task.id });
+            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);

package/dist/services/a2a/handlers/artifact.d.ts

@@ -3,8 +3,5 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 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: A2A.Artifact[], artifactUpdate: A2A.Artifact): A2A.Artifact[];
+export declare function updateArtifact(_artifact: A2A.Artifact, update: A2A.TaskArtifactUpdateEvent): A2A.Artifact;
+export declare function upsertArtifact(artifacts: A2A.Artifact[], update: A2A.TaskArtifactUpdateEvent): A2A.Artifact[];

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

@@ -2,38 +2,27 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-export function updateByIndex(append, artifacts, index, artifactUpdate) {
-    if (append) {
-        const existingArtifact = artifacts[index];
-        existingArtifact.parts.push(...artifactUpdate.parts);
-        if (artifactUpdate.metadata) {
-            existingArtifact.metadata = {
-                ...(existingArtifact.metadata || {}),
-                ...artifactUpdate.metadata,
-            };
-        }
-        if (artifactUpdate.description) {
-            existingArtifact.description = artifactUpdate.description;
-        }
-        if (artifactUpdate.name) {
-            existingArtifact.name = artifactUpdate.name;
-        }
-        artifacts[index] = existingArtifact;
-    }
-    else {
-        artifacts[index] = { ...artifactUpdate };
-    }
-    return { artifacts, replaced: true };
+export function updateArtifact(_artifact, update) {
+    if (!update.append)
+        return update.artifact;
+    const artifactUpdate = update.artifact;
+    const artifact = _artifact;
+    artifact.metadata = {
+        ...(artifact.metadata || {}),
+        ...artifactUpdate.metadata,
+    };
+    artifact.description = artifactUpdate.description;
+    artifact.name = artifactUpdate.name;
+    artifact.parts.push(...artifactUpdate.parts);
+    return artifact;
 }
-export function processArtifactUpdate(append, artifacts, artifactUpdate) {
-    const existingIndex = artifacts.findIndex((a) => a.artifactId === artifactUpdate.artifactId);
-    let replaced = false;
-    let newArtifacts = artifacts;
-    if (existingIndex !== -1) {
-        ({ artifacts: newArtifacts, replaced } = updateByIndex(append, artifacts, existingIndex, artifactUpdate));
-    }
-    if (!replaced) {
-        newArtifacts.push({ ...artifactUpdate });
+export function upsertArtifact(artifacts, update) {
+    const updateId = update.artifact.artifactId;
+    const index = artifacts.findIndex((a) => a.artifactId === updateId);
+    if (index === -1) {
+        artifacts.push({ ...update.artifact });
+        return artifacts;
     }
-    return newArtifacts;
+    artifacts[index] = updateArtifact(artifacts[index], update);
+    return artifacts;
 }

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

@@ -16,7 +16,13 @@ export const cancelTask = async ({ id: taskId }, context) => {
     if (FINAL_STATES.includes(task.status.state)) {
         throw TASK_NOT_CANCELABLE("Task is in a final state: " + task.status.state);
     }
-    service.cancellations.set(taskId);
+    /**
+     * By triggering onCancel, we're guaranteed that:
+     *  - No further updates will be processed other than errors
+     *  - The task will be cancelled
+     *  - The task will be completed
+     *  - The cancellations will be cleaned up
+     */
     const cancelledTask = {
         ...task,
         status: {
@@ -24,10 +30,6 @@ export const cancelTask = async ({ id: taskId }, context) => {
             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/resubscribe-task.d.ts

@@ -3,9 +3,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { A2A } from "../../../types/index.js";
-export declare const resubscribe: A2A.RequestHandler["resubscribe"];
+export declare const subscribeToTask: A2A.RequestHandler["resubscribe"];
+export type SubscribeToTaskHandler = typeof subscribeToTask;
+/**
+ * @deprecated Use SubscribeToTaskHandler instead
+ */
+export declare const resubscribe: (input: A2A.TaskIdParams, context?: A2A.Context, options?: A2A.ServiceOptions) => AsyncGenerator<A2A.Update>;
+/**
+ * @deprecated Use SubscribeToTaskHandler instead
+ */
 export type TaskResubscribeHandler = typeof resubscribe;
 /**
- * @deprecated Use ResubscribeTaskHandler instead
+ * @deprecated Use SubscribeToTaskHandler instead
  */
 export type ResubscribeTaskMethod = TaskResubscribeHandler;

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

@@ -5,22 +5,22 @@
 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();
-        }
+    if (!task.artifacts || task.artifacts.length === 0)
+        return;
+    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) {
+export const subscribeToTask = async function* ({ id: taskId }, context) {
     if (!context) {
         throw INTERNAL_ERROR({ error: { message: "Context is required" } });
     }
@@ -33,9 +33,7 @@ export const resubscribe = async function* ({ id: taskId }, context) {
             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
+    // onStart no longer inserts a new task, so we can safely push the update and continue
     context.publisher.on("start", async (_, task) => {
         stream.updates.push({
             kind: "status-update",
@@ -46,7 +44,8 @@ export const resubscribe = async function* ({ id: taskId }, context) {
             metadata: task.metadata,
         });
         if (FINAL_STATES.includes(task.status.state)) {
-            flush(task, stream);
+            /* We create a new task object to avoid mutating the original task */
+            flush({ ...task }, stream);
             await stream.kill();
         }
     });
@@ -54,3 +53,7 @@ export const resubscribe = async function* ({ id: taskId }, context) {
         service: service,
     });
 };
+/**
+ * @deprecated Use SubscribeToTaskHandler instead
+ */
+export const resubscribe = subscribeToTask;

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

@@ -8,15 +8,10 @@ export const sendMessage = async ({ configuration }, context) => {
     if (!context) {
         throw INTERNAL_ERROR({ error: { message: "Context is required" } });
     }
-    context.publisher.on("complete", () => {
-        context.service.contexts.delete(context.contextId);
-    });
-    context.publisher.on("error", () => {
-        context.publisher.onComplete();
-    });
     const service = context.service;
+    let task;
     if (configuration?.blocking === false) {
-        const result = await Promise.race([
+        task = await Promise.race([
             service.execute({ engine: service.engine, context }).then(async () => {
                 return await context.getTask();
             }),
@@ -26,10 +21,11 @@ export const sendMessage = async ({ configuration }, context) => {
                 });
             }),
         ]);
-        return result;
     }
-    await service.execute({ engine: service.engine, context });
-    const task = await context.getTask();
+    else {
+        await service.execute({ engine: service.engine, context });
+        task = await context.getTask();
+    }
     task.history = getLatestHistory(task, configuration?.historyLength);
     return task;
 };