@a2a-js/sdk 0.2.1 → 0.2.2

package/build/src/server/request_handler/default_request_handler.d.ts

@@ -12,6 +12,7 @@ export declare class DefaultRequestHandler implements A2ARequestHandler {
     constructor(agentCard: AgentCard, taskStore: TaskStore, agentExecutor: AgentExecutor, eventBusManager?: ExecutionEventBusManager);
     getAgentCard(): Promise<AgentCard>;
     private _createRequestContext;
+    private _processEvents;
     sendMessage(params: MessageSendParams): Promise<Message | Task>;
     sendMessageStream(params: MessageSendParams): AsyncGenerator<Message | Task | TaskStatusUpdateEvent | TaskArtifactUpdateEvent, void, undefined>;
     getTask(params: TaskQueryParams): Promise<Task>;

package/build/src/server/request_handler/default_request_handler.js

@@ -4,6 +4,7 @@ import { A2AError } from "../error.js";
 import { DefaultExecutionEventBusManager } from "../events/execution_event_bus_manager.js";
 import { ExecutionEventQueue } from "../events/execution_event_queue.js";
 import { ResultManager } from "../result_manager.js";
+const terminalStates = ["completed", "failed", "canceled", "rejected"];
 export class DefaultRequestHandler {
     agentCard;
     taskStore;
@@ -29,6 +30,10 @@ export class DefaultRequestHandler {
             if (!task) {
                 throw A2AError.taskNotFound(incomingMessage.taskId);
             }
+            if (terminalStates.includes(task.status.state)) {
+                // Throw an error that conforms to the JSON-RPC Invalid Request error specification.
+                throw A2AError.invalidRequest(`Task ${task.id} is in a terminal state (${task.status.state}) and cannot be modified.`);
+            }
         }
         if (incomingMessage.referenceTaskIds && incomingMessage.referenceTaskIds.length > 0) {
             referenceTasks = [];
@@ -51,11 +56,41 @@ export class DefaultRequestHandler {
         const contextId = incomingMessage.contextId || uuidv4();
         return new RequestContext(messageForContext, taskId, contextId, task, referenceTasks);
     }
+    async _processEvents(taskId, resultManager, eventQueue, options) {
+        let firstResultSent = false;
+        try {
+            for await (const event of eventQueue.events()) {
+                await resultManager.processEvent(event);
+                if (options?.firstResultResolver && !firstResultSent) {
+                    if (event.kind === 'message' || event.kind === 'task') {
+                        options.firstResultResolver(event);
+                        firstResultSent = true;
+                    }
+                }
+            }
+            if (options?.firstResultRejector && !firstResultSent) {
+                options.firstResultRejector(A2AError.internalError('Execution finished before a message or task was produced.'));
+            }
+        }
+        catch (error) {
+            console.error(`Event processing loop failed for task ${taskId}:`, error);
+            if (options?.firstResultRejector && !firstResultSent) {
+                options.firstResultRejector(error);
+            }
+            // re-throw error for blocking case to catch
+            throw error;
+        }
+        finally {
+            this.eventBusManager.cleanupByTaskId(taskId);
+        }
+    }
     async sendMessage(params) {
         const incomingMessage = params.message;
         if (!incomingMessage.messageId) {
             throw A2AError.invalidParams('message.messageId is required.');
         }
+        // Default to blocking behavior if 'blocking' is not explicitly false.
+        const isBlocking = params.configuration?.blocking !== false;
         const taskId = incomingMessage.taskId || uuidv4();
         // Instantiate ResultManager before creating RequestContext
         const resultManager = new ResultManager(this.taskStore);
@@ -64,12 +99,14 @@ export class DefaultRequestHandler {
         // Use the (potentially updated) contextId from requestContext
         const finalMessageForAgent = requestContext.userMessage;
         const eventBus = this.eventBusManager.createOrGetByTaskId(taskId);
+        // EventQueue should be attached to the bus, before the agent execution begins.
         const eventQueue = new ExecutionEventQueue(eventBus);
-        // Start agent execution (non-blocking)
+        // Start agent execution (non-blocking).
+        // It runs in the background and publishes events to the eventBus.
         this.agentExecutor.execute(requestContext, eventBus).catch(err => {
             console.error(`Agent execution failed for message ${finalMessageForAgent.messageId}:`, err);
-            // Publish a synthetic error event if needed, or handle error reporting
-            // For example, create a Task with a failed status
+            // Publish a synthetic error event, which will be handled by the ResultManager
+            // and will also settle the firstResultPromise for non-blocking calls.
             const errorTask = {
                 id: requestContext.task?.id || uuidv4(), // Use existing task ID or generate new
                 contextId: finalMessageForAgent.contextId,
@@ -93,7 +130,7 @@ export class DefaultRequestHandler {
                     errorTask.history?.push(finalMessageForAgent);
                 }
             }
-            eventBus.publish(errorTask); // This will update the task store via ResultManager
+            eventBus.publish(errorTask);
             eventBus.publish({
                 kind: "status-update",
                 taskId: errorTask.id,
@@ -103,17 +140,24 @@ export class DefaultRequestHandler {
             });
             eventBus.finished();
         });
-        for await (const event of eventQueue.events()) {
-            // lastEvent is no longer needed here as ResultManager tracks the final result type
-            await resultManager.processEvent(event);
+        if (isBlocking) {
+            // In blocking mode, wait for the full processing to complete.
+            await this._processEvents(taskId, resultManager, eventQueue);
+            const finalResult = resultManager.getFinalResult();
+            if (!finalResult) {
+                throw A2AError.internalError('Agent execution finished without a result, and no task context found.');
+            }
+            return finalResult;
         }
-        const finalResult = resultManager.getFinalResult();
-        if (!finalResult) {
-            throw A2AError.internalError('Agent execution finished without a result, and no task context found.');
+        else {
+            // In non-blocking mode, return a promise that will be settled by fullProcessing.
+            return new Promise((resolve, reject) => {
+                this._processEvents(taskId, resultManager, eventQueue, {
+                    firstResultResolver: resolve,
+                    firstResultRejector: reject,
+                });
+            });
         }
-        // Cleanup after processing is complete for taskId
-        this.eventBusManager.cleanupByTaskId(taskId);
-        return finalResult;
     }
     async *sendMessageStream(params) {
         const incomingMessage = params.message;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@a2a-js/sdk",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Server & Client SDK for Agent2Agent protocol",
-  "repository":"google-a2a/a2a-js.git",
+  "repository": "google-a2a/a2a-js.git",
   "engines": {
     "node": ">=18"
   },