fix: ensure user messages are added to existing tasks (#138)

Ensured user messages are added to existing tasks, inline with the
Python package:
- Added the latest user message to an existing `Task`'s history in the
`RequestContext`
- Added the test "should return second task with full history if message
is sent to an existing, non-terminal task"
- Updated `README.md` to check if a `Task` exists before publishing to
the `eventBus`

# Description

Thank you for opening a Pull Request!
Before submitting your PR, there are a few things you can do to make
sure it goes smoothly:

- [x] Follow the [`CONTRIBUTING`
Guide](https://github.com/google-a2a/a2a-js/blob/main/CONTRIBUTING.md).
- [x] Make your Pull Request title in the
<https://www.conventionalcommits.org/> specification.
- Important Prefixes for
[release-please](https://github.com/googleapis/release-please):
- `fix:` which represents bug fixes, and correlates to a
[SemVer](https://semver.org/) patch.
- `feat:` represents a new feature, and correlates to a SemVer minor.
- `feat!:`, or `fix!:`, `refactor!:`, etc., which represent a breaking
change (indicated by the `!`) and will result in a SemVer major.
- [x] Ensure the tests and linter pass
- [x] Appropriate docs were updated (if necessary)

Fixes #136 🦕

Author: benclarkegithub

README.md

@@ -163,19 +163,22 @@ class TaskExecutor implements AgentExecutor {
     requestContext: RequestContext,
     eventBus: ExecutionEventBus
   ): Promise<void> {
-    const { taskId, contextId } = requestContext;
-
-    // 1. Create and publish the initial task object.
-    const initialTask: Task = {
-      kind: "task",
-      id: taskId,
-      contextId: contextId,
-      status: {
-        state: "submitted",
-        timestamp: new Date().toISOString(),
-      },
-    };
-    eventBus.publish(initialTask);
+    const { taskId, contextId, userMessage, task } = requestContext;
+
+    // 1. Create and publish the initial task object if it doesn't exist.
+    if (!task) {
+      const initialTask: Task = {
+        kind: "task",
+        id: taskId,
+        contextId: contextId,
+        status: {
+          state: "submitted",
+          timestamp: new Date().toISOString(),
+        },
+        history: [userMessage]
+      };
+      eventBus.publish(initialTask);
+    }
 
     // 2. Create and publish an artifact.
     const artifactUpdate: TaskArtifactUpdateEvent = {
@@ -354,15 +357,22 @@ class StreamingExecutor implements AgentExecutor {
     requestContext: RequestContext,
     eventBus: ExecutionEventBus
   ): Promise<void> {
-    const { taskId, contextId } = requestContext;
-
-    // 1. Publish initial 'submitted' state.
-    eventBus.publish({
-      kind: "task",
-      id: taskId,
-      contextId,
-      status: { state: "submitted", timestamp: new Date().toISOString() },
-    });
+    const { taskId, contextId, userMessage, task } = requestContext;
+
+    // 1. Create and publish the initial task object if it doesn't exist.
+    if (!task) {
+      const initialTask: Task = {
+        kind: "task",
+        id: taskId,
+        contextId: contextId,
+        status: {
+          state: "submitted",
+          timestamp: new Date().toISOString(),
+        },
+        history: [userMessage]
+      };
+      eventBus.publish(initialTask);
+    }
 
     // 2. Publish 'working' state.
     eventBus.publish({

src/server/request_handler/default_request_handler.ts

@@ -80,6 +80,10 @@ export class DefaultRequestHandler implements A2ARequestHandler {
                 // 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.`)
             }
+
+            // Add incomingMessage to history and save the task.
+            task.history = [...(task.history || []), incomingMessage];
+            await this.taskStore.save(task);
         }
 
         if (incomingMessage.referenceTaskIds && incomingMessage.referenceTaskIds.length > 0) {

test/server/default_request_handler.spec.ts

@@ -242,6 +242,162 @@ describe('DefaultRequestHandler as A2ARequestHandler', () => {
         assert.include((nonBlockingTask.status.message?.parts[0] as any).text, errorMessage, 'Error message should be in the status');
     });
 
+    it('sendMessage: should return second task with full history if message is sent to an existing, non-terminal task', async () => {
+        const contextId = 'ctx-history-abc';
+        
+        // First message
+        const firstMessage = createTestMessage('msg-1', 'Message 1');
+        firstMessage.contextId = contextId;
+        const firstParams: MessageSendParams = {
+            message: firstMessage
+        };
+
+        let taskId: string;
+
+        (mockAgentExecutor as MockAgentExecutor).execute.callsFake(async (ctx, bus) => {
+            taskId = ctx.taskId;
+            
+            // Publish task creation
+            bus.publish({
+                id: taskId,
+                contextId,
+                status: { state: "submitted" },
+                kind: 'task'
+            });
+
+            // Publish working status
+            bus.publish({
+                taskId,
+                contextId,
+                kind: 'status-update',
+                status: { state: "working" },
+                final: false
+            });
+
+            // Mark as input-required with agent response message
+            bus.publish({
+                taskId,
+                contextId,
+                kind: 'status-update',
+                status: { 
+                    state: "input-required",
+                    message: {
+                        messageId: 'agent-msg-1',
+                        role: 'agent',
+                        parts: [{ kind: 'text', text: 'Response to message 1' }],
+                        kind: 'message',
+                        taskId,
+                        contextId
+                    }
+                },
+                final: true
+            });
+            bus.finished();
+        });
+
+        const firstResult = await handler.sendMessage(firstParams);
+        const firstTask = firstResult as Task;
+        
+        // Check the first result is a task with `input-required` status
+        assert.equal(firstTask.kind, 'task');
+        assert.equal(firstTask.status.state, 'input-required');
+
+        // Check the history
+        assert.isDefined(firstTask.history, 'First task should have history');
+        assert.lengthOf(firstTask.history!, 2, 'First task history should contain user message and agent message');
+        assert.equal(firstTask.history![0].messageId, 'msg-1', 'First history item should be user message');
+        assert.equal(firstTask.history![1].messageId, 'agent-msg-1', 'Second history item should be agent message');
+
+        // Second message
+        const secondMessage = createTestMessage('msg-2', 'Message 2');
+        secondMessage.contextId = contextId;
+        secondMessage.taskId = firstTask.id;
+
+        const secondParams: MessageSendParams = {
+            message: secondMessage
+        };
+
+        (mockAgentExecutor as MockAgentExecutor).execute.callsFake(async (ctx, bus) => {
+            // Publish a status update with working state
+            bus.publish({
+                taskId,
+                contextId,
+                kind: 'status-update',
+                status: { state: "working" },
+                final: false
+            });
+
+            // Publish a status update with working state and message
+            bus.publish({
+                taskId,
+                contextId,
+                kind: 'status-update',
+                status: {
+                    state: "working",
+                    message: {
+                        messageId: 'agent-msg-2',
+                        role: 'agent',
+                        parts: [{ kind: 'text', text: 'Response to message 2' }],
+                        kind: 'message',
+                        taskId,
+                        contextId
+                    }
+                },
+                final: false
+            });
+
+            // Publish an artifact update
+            bus.publish({
+                taskId,
+                contextId,
+                kind: 'artifact-update',
+                artifact: {
+                    artifactId: 'artifact-1',
+                    name: 'Test Document',
+                    description: 'A test artifact.',
+                    parts: [{ kind: 'text', text: 'This is the content of the artifact.' }]
+                }
+            });
+
+            // Mark as completed
+            bus.publish({
+                taskId,
+                contextId,
+                kind: 'status-update',
+                status: {
+                    state: "completed"
+                },
+                final: true
+            });
+            
+            bus.finished();
+        });
+
+        const secondResult = await handler.sendMessage(secondParams);
+        const secondTask = secondResult as Task;
+
+        // Check the second result is a task with `completed` status
+        assert.equal(secondTask.kind, 'task');
+        assert.equal(secondTask.id, taskId, 'Should be the same task');
+        assert.equal(secondTask.status.state, 'completed');
+        
+        // Check the history
+        assert.isDefined(secondTask.history, 'Second task should have history');
+        assert.lengthOf(secondTask.history!, 4, 'Second task history should contain all 4 messages (user1, agent1, user2, agent2)');
+        assert.equal(secondTask.history![0].messageId, 'msg-1', 'First message should be first user message');
+        assert.equal((secondTask.history![0].parts[0] as any).text, 'Message 1');
+        assert.equal(secondTask.history![1].messageId, 'agent-msg-1', 'Second message should be first agent message');
+        assert.equal((secondTask.history![1].parts[0] as any).text, 'Response to message 1');
+        assert.equal(secondTask.history![2].messageId, 'msg-2', 'Third message should be second user message');
+        assert.equal((secondTask.history![2].parts[0] as any).text, 'Message 2');
+        assert.equal(secondTask.history![3].messageId, 'agent-msg-2', 'Fourth message should be second agent message');
+        assert.equal((secondTask.history![3].parts[0] as any).text, 'Response to message 2');
+        assert.equal(secondTask.artifacts![0].artifactId, 'artifact-1', 'Artifact should be the same');
+        assert.equal(secondTask.artifacts![0].name, 'Test Document', 'Artifact name should be the same');
+        assert.equal(secondTask.artifacts![0].description, 'A test artifact.', 'Artifact description should be the same');
+        assert.equal((secondTask.artifacts![0].parts[0] as any).text, 'This is the content of the artifact.', 'Artifact content should be the same');
+    });
+
     it('sendMessageStream: should stream submitted, working, and completed events', async () => {
         const params: MessageSendParams = { 
             message: createTestMessage('msg-3', 'Stream a task')