From 366f1b8eefc4ce45021f4181d941bb071cd1d1da Mon Sep 17 00:00:00 2001 From: Mohammad Hossein Khoshechin Jorshari Date: Sun, 22 Nov 2026 02:24:16 +0100 Subject: [PATCH] fix(server-common): begin message/stream with the Task object When the agent opens a task with a status or artifact update (e.g. AgentEmitter.startWork()), onMessageSendStream relayed that update as the first stream item, so the client received an update of a task it was never sent. A2A spec 3.1.2 requires: "If the agent returns a Task, the stream MUST begin with the Task object." Emit the task's Task (for a new task, the Task the TaskStore creates for it; for an existing task, the task as the request updated it) before a first status or artifact update. A first Task or Message is unchanged. This fixes #1352 --- .../AbstractA2AServerServerTest_v0_3.java | 7 +- .../server/events/MainEventBusProcessor.java | 37 ++- .../DefaultRequestHandler.java | 69 +++++ .../DefaultRequestHandlerTest.java | 269 +++++++++++++++++- .../apps/common/AbstractA2AServerTest.java | 8 +- .../grpc/handler/GrpcHandlerTest.java | 12 +- .../jsonrpc/handler/JSONRPCHandlerTest.java | 9 +- 7 files changed, 397 insertions(+), 14 deletions(-) diff --git a/compat-0.3/server-conversion/src/test/java/org/a2aproject/sdk/compat03/conversion/AbstractA2AServerServerTest_v0_3.java b/compat-0.3/server-conversion/src/test/java/org/a2aproject/sdk/compat03/conversion/AbstractA2AServerServerTest_v0_3.java index f35a24e6f..684d3fae4 100644 --- a/compat-0.3/server-conversion/src/test/java/org/a2aproject/sdk/compat03/conversion/AbstractA2AServerServerTest_v0_3.java +++ b/compat-0.3/server-conversion/src/test/java/org/a2aproject/sdk/compat03/conversion/AbstractA2AServerServerTest_v0_3.java @@ -1108,9 +1108,13 @@ public void testNonBlockingWithMultipleMessages() throws Exception { CountDownLatch streamEventLatch = new CountDownLatch(2); // artifact-2 + completion List streamReceivedEvents = new CopyOnWriteArrayList<>(); AtomicBoolean streamUnexpectedEvent = new AtomicBoolean(false); + AtomicBoolean streamReceivedInitialTask = new AtomicBoolean(false); BiConsumer streamConsumer = (event, agentCard) -> { - if (event instanceof TaskUpdateEvent_v0_3 tue) { + // Per A2A spec 3.1.2, the stream begins with the Task, then its updates + if (event instanceof TaskEvent_v0_3 && !streamReceivedInitialTask.get() && streamReceivedEvents.isEmpty()) { + streamReceivedInitialTask.set(true); + } else if (event instanceof TaskUpdateEvent_v0_3 tue) { streamReceivedEvents.add(tue.getUpdateEvent()); streamEventLatch.countDown(); } else { @@ -1139,6 +1143,7 @@ public void testNonBlockingWithMultipleMessages() throws Exception { assertFalse(resubUnexpectedEvent.get()); assertFalse(streamUnexpectedEvent.get()); + assertTrue(streamReceivedInitialTask.get(), "The send stream must begin with the Task"); assertNull(resubErrorRef.get()); // Both should have received 2 events: artifact-2 and completion diff --git a/server-common/src/main/java/org/a2aproject/sdk/server/events/MainEventBusProcessor.java b/server-common/src/main/java/org/a2aproject/sdk/server/events/MainEventBusProcessor.java index 5e6869b35..d4f3e4470 100644 --- a/server-common/src/main/java/org/a2aproject/sdk/server/events/MainEventBusProcessor.java +++ b/server-common/src/main/java/org/a2aproject/sdk/server/events/MainEventBusProcessor.java @@ -97,6 +97,13 @@ private record UpdateResult(boolean isFinal, @Nullable Task taskSnapshot) {} */ private final ConcurrentHashMap initialMessages = new ConcurrentHashMap<>(); + /** + * Initial Tasks for new streaming tasks that have not emitted their first event yet. When that + * first event is a status or artifact update, this Task is what the TaskStore creates for the + * task, so the streaming response can begin with the same Task object. + */ + private final ConcurrentHashMap initialTasks = new ConcurrentHashMap<>(); + private MainEventBus eventBus; private TaskStore taskStore; @@ -148,9 +155,24 @@ public void registerInitialMessage(String taskId, Message message) { initialMessages.put(taskId, message); } + /** + * Registers the Task that a new task's first event creates in the TaskStore when that event is a + * status or artifact update, until its first event is persisted. Without a registration, the + * TaskManager creates it. + * + * @param taskId the new task identifier + * @param initialTask the Task to create: SUBMITTED, with the opening message as its history + */ + public void registerInitialTask(String taskId, Task initialTask) { + initialTasks.put(taskId, initialTask); + } + /** Remove a registration after all events already submitted by the agent are processed. */ public void clearInitialMessageAfterEvents(String taskId) { - eventBus.submit(() -> initialMessages.remove(taskId)); + eventBus.submit(() -> { + initialMessages.remove(taskId); + initialTasks.remove(taskId); + }); } /** @@ -258,10 +280,12 @@ private void processEvent(MainEventBusContext context) { try { Message initialMessage = initialMessages.get(taskId); - updateResult = updateTaskStore(taskId, event, isReplicated, initialMessage); + Task initialTask = initialTasks.get(taskId); + updateResult = updateTaskStore(taskId, event, isReplicated, initialMessage, initialTask); if (event instanceof Task || event instanceof TaskStatusUpdateEvent || event instanceof TaskArtifactUpdateEvent || event instanceof A2AError) { initialMessages.remove(taskId); + initialTasks.remove(taskId); } boolean isFinal = updateResult.isFinal(); @@ -365,8 +389,15 @@ private void processEvent(MainEventBusContext context) { * @throws InternalError if persistence fails */ private UpdateResult updateTaskStore(String taskId, Event event, boolean isReplicated, - @Nullable Message initialMessage) throws InternalError { + @Nullable Message initialMessage, @Nullable Task initialTask) throws InternalError { try { + // A new task opened by a status or artifact update: create it as registered (see + // registerInitialTask); TaskManager then finds it in the TaskStore and applies the update + if (initialTask != null && (event instanceof TaskStatusUpdateEvent + || event instanceof TaskArtifactUpdateEvent) && taskStore.get(taskId) == null) { + taskStore.save(initialTask, false); + } + // Extract contextId from event (all relevant events have it) String contextId = extractContextId(event); diff --git a/server-common/src/main/java/org/a2aproject/sdk/server/requesthandlers/DefaultRequestHandler.java b/server-common/src/main/java/org/a2aproject/sdk/server/requesthandlers/DefaultRequestHandler.java index ea05ad87a..8c68165b9 100644 --- a/server-common/src/main/java/org/a2aproject/sdk/server/requesthandlers/DefaultRequestHandler.java +++ b/server-common/src/main/java/org/a2aproject/sdk/server/requesthandlers/DefaultRequestHandler.java @@ -27,6 +27,8 @@ import jakarta.enterprise.inject.Instance; import jakarta.inject.Inject; +import mutiny.zero.ZeroPublisher; + import org.a2aproject.sdk.jsonrpc.common.wrappers.ListTasksResult; import org.a2aproject.sdk.server.EffectiveAgentCard; import org.a2aproject.sdk.server.ServerCallContext; @@ -76,6 +78,7 @@ import org.a2aproject.sdk.spec.TaskPushNotificationConfig; import org.a2aproject.sdk.spec.TaskQueryParams; import org.a2aproject.sdk.spec.TaskState; +import org.a2aproject.sdk.spec.TaskStatus; import org.a2aproject.sdk.spec.TaskStatusUpdateEvent; import org.a2aproject.sdk.spec.UnsupportedOperationError; import org.a2aproject.sdk.util.Assert; @@ -1056,6 +1059,16 @@ public Flow.Publisher onMessageSendStream( mss.requestContext.getTaskId(), "TaskId must be non-null after RequestContext.build()"); final AtomicReference<@NonNull String> taskId = new AtomicReference<>(queueTaskId); + // The Task this stream begins with if the agent's first event is a status or artifact update + // (see prependTaskBeforeFirstUpdate). For an existing task it is the task as this request updated + // it; for a new task it is registered below as the Task that the first event creates. + Task initialTask = mss.task() != null ? mss.task() : Task.builder() + .id(queueTaskId) + .contextId(mss.requestContext.getContextId()) + .status(new TaskStatus(TaskState.TASK_STATE_SUBMITTED)) + .history(List.of(params.message())) + .build(); + boolean agentStarted = false; EventQueue queue; ResultAggregator resultAggregator; @@ -1063,6 +1076,7 @@ public Flow.Publisher onMessageSendStream( try { if (mss.task() == null) { mainEventBusProcessor.registerInitialMessage(queueTaskId, params.message()); + mainEventBusProcessor.registerInitialTask(queueTaskId, initialTask); } // Create queue with real taskId (no tempId parameter needed) queue = queueManager.createOrTap(queueTaskId); @@ -1125,6 +1139,8 @@ public Flow.Publisher onMessageSendStream( // Then convert EventQueueItem -> Event Flow.Publisher eventPublisher = convertingProcessor(processed, EventQueueItem::getEvent); + eventPublisher = prependTaskBeforeFirstUpdate(eventPublisher, initialTask); + Flow.Publisher finalPublisher = convertingProcessor(eventPublisher, event -> (StreamingEventKind) event); // Wrap publisher to detect client disconnect and immediately close ChildQueue @@ -1213,6 +1229,59 @@ public void onComplete() { } } + /** + * Per A2A Protocol Spec 3.1.2 (Send Streaming Message): + * "If the agent returns a Task, the stream MUST begin with the Task object." + *

+ * An agent may begin with a status or artifact update (e.g. {@link AgentEmitter#startWork()}); the + * client would then receive an update of a Task it was never sent. This emits {@code initialTask} + * before such a first event. A first Task or Message passes unchanged. + *

+ *

+ * {@code initialTask} is fixed before the agent runs (the existing task as this request updated it, or + * the Task that a new task's first event creates), not read back from the TaskStore when the first + * event is relayed: by then the TaskStore may already hold later events, whose status and artifacts + * would reach the client ahead of, and again in, the updates that follow. + *

+ * + * @param source the stream's events + * @param initialTask the Task to emit before a first status or artifact update + * @return the events, with {@code initialTask} before a first status or artifact update + */ + private static Flow.Publisher prependTaskBeforeFirstUpdate(Flow.Publisher source, Task initialTask) { + return ZeroPublisher.create(createTubeConfig(), tube -> { + source.subscribe(new Flow.Subscriber() { + private boolean firstEventSeen = false; + + @Override + public void onSubscribe(Flow.Subscription subscription) { + subscription.request(Long.MAX_VALUE); + } + + @Override + public void onNext(Event event) { + if (!firstEventSeen) { + firstEventSeen = true; + if (event instanceof TaskStatusUpdateEvent || event instanceof TaskArtifactUpdateEvent) { + tube.send(initialTask); + } + } + tube.send(event); + } + + @Override + public void onError(Throwable throwable) { + tube.fail(throwable); + } + + @Override + public void onComplete() { + tube.complete(); + } + }); + }); + } + @Override public TaskPushNotificationConfig onCreateTaskPushNotificationConfig( TaskPushNotificationConfig params, ServerCallContext context) throws A2AError { diff --git a/server-common/src/test/java/org/a2aproject/sdk/server/requesthandlers/DefaultRequestHandlerTest.java b/server-common/src/test/java/org/a2aproject/sdk/server/requesthandlers/DefaultRequestHandlerTest.java index 9136cf16d..758dcfe29 100644 --- a/server-common/src/test/java/org/a2aproject/sdk/server/requesthandlers/DefaultRequestHandlerTest.java +++ b/server-common/src/test/java/org/a2aproject/sdk/server/requesthandlers/DefaultRequestHandlerTest.java @@ -17,6 +17,7 @@ import java.util.List; import java.util.Map; import java.util.Set; +import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executor; @@ -1062,6 +1063,233 @@ public void onNext(StreamingEventKind event) { assertEquals(taskStore.get(task.id()), task); } + /** + * A2A spec 3.1.2: "If the agent returns a Task, the stream MUST begin with the Task object." + * An agent that opens a new task with a status update (the AgentExecutor javadoc pattern) gets the + * Task inserted before that update, as the TaskStore created it. + */ + @Test + void streamingNewTaskStatusFirstBeginsWithTask() throws Exception { + agentExecutorExecute = (context, emitter) -> { + emitter.startWork(); + emitter.complete(); + }; + + List events = drainStream(streamParams(openingMessage("status-first"), null)); + + assertEquals(3, events.size(), "Expected Task, WORKING, COMPLETED but got " + events); + Task first = assertInstanceOf(Task.class, events.get(0), "The stream must begin with the Task"); + TaskStatusUpdateEvent working = assertInstanceOf(TaskStatusUpdateEvent.class, events.get(1)); + TaskStatusUpdateEvent completed = assertInstanceOf(TaskStatusUpdateEvent.class, events.get(2)); + assertEquals(working.taskId(), first.id()); + assertEquals(working.contextId(), first.contextId()); + assertEquals(TaskState.TASK_STATE_SUBMITTED, first.status().state()); + assertFalse(first.status().timestamp().isAfter(working.status().timestamp()), + "The opening Task's status must not be later than the update that follows it"); + assertEquals(List.of("status-first"), first.history().stream().map(Message::messageId).toList()); + assertTrue(first.artifacts().isEmpty()); + assertEquals(TaskState.TASK_STATE_WORKING, working.status().state()); + assertEquals(TaskState.TASK_STATE_COMPLETED, completed.status().state()); + + Task stored = taskStore.get(first.id()); + assertNotNull(stored, "The task must be in the TaskStore"); + assertEquals(TaskState.TASK_STATE_COMPLETED, stored.status().state()); + } + + /** + * An agent that opens a new task with an artifact and an append delta, while the client has not yet + * subscribed: the TaskStore holds both updates before the stream relays the first one. The opening + * Task is the Task the TaskStore created (same status, same timestamp) and contains neither update; + * each update arrives once. + */ + @Test + void streamingNewTaskArtifactFirstBeginsWithTaskAsCreated() throws Exception { + CountDownLatch releaseAgent = new CountDownLatch(1); + AtomicReference taskId = new AtomicReference<>(); + agentExecutorExecute = (context, emitter) -> { + taskId.set(context.getTaskId()); + emitter.addArtifact(List.of(new TextPart("part-1")), "artifact-1", null, null, null, null); + emitter.addArtifact(List.of(new TextPart("part-2")), "artifact-1", null, null, true, null); + try { + releaseAgent.await(10, TimeUnit.SECONDS); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + return; + } + emitter.complete(); + }; + + Flow.Publisher publisher = requestHandler.onMessageSendStream( + streamParams(openingMessage("artifact-first"), null), contextWithEffectiveCard(true)); + + AtomicReference storedBeforeSubscribe = new AtomicReference<>(); + await().atMost(5, TimeUnit.SECONDS).untilAsserted(() -> { + assertNotNull(taskId.get()); + Task stored = taskStore.get(taskId.get()); + assertNotNull(stored); + assertEquals(1, stored.artifacts().size()); + assertEquals(2, stored.artifacts().get(0).parts().size()); + storedBeforeSubscribe.set(stored); + }); + + CountDownLatch done = new CountDownLatch(1); + AtomicReference error = new AtomicReference<>(); + List events = new CopyOnWriteArrayList<>(); + publisher.subscribe(collectingSubscriber(events, error, done)); + releaseAgent.countDown(); + assertTrue(done.await(5, TimeUnit.SECONDS), "Stream should complete"); + assertNull(error.get()); + + assertEquals(4, events.size(), "Expected Task, artifact, append delta, COMPLETED but got " + events); + Task first = assertInstanceOf(Task.class, events.get(0), "The stream must begin with the Task"); + TaskArtifactUpdateEvent artifact = assertInstanceOf(TaskArtifactUpdateEvent.class, events.get(1)); + TaskArtifactUpdateEvent delta = assertInstanceOf(TaskArtifactUpdateEvent.class, events.get(2)); + assertInstanceOf(TaskStatusUpdateEvent.class, events.get(3)); + assertEquals(storedBeforeSubscribe.get().id(), first.id()); + assertEquals(storedBeforeSubscribe.get().status(), first.status(), + "The opening Task must carry the status the TaskStore created, timestamp included"); + assertTrue(first.artifacts().isEmpty(), "The opening Task must contain neither artifact update"); + assertEquals("part-1", ((TextPart) artifact.artifact().parts().get(0)).text()); + assertEquals("part-2", ((TextPart) delta.artifact().parts().get(0)).text()); + assertEquals(Boolean.TRUE, delta.append()); + + Task stored = taskStore.get(first.id()); + assertNotNull(stored); + assertEquals(2, stored.artifacts().get(0).parts().size()); + } + + /** The opening Task honours historyLength like any other streamed Task. */ + @Test + void streamingNewTaskOpeningTaskHonoursHistoryLength() throws Exception { + agentExecutorExecute = (context, emitter) -> { + emitter.startWork(); + emitter.complete(); + }; + + List events = drainStream(streamParams(openingMessage("history-zero"), + MessageSendConfiguration.builder().historyLength(0).build())); + + Task first = assertInstanceOf(Task.class, events.get(0), "The stream must begin with the Task"); + assertTrue(first.history().isEmpty(), "historyLength=0 must strip the opening Task's history"); + assertEquals(List.of("history-zero"), + taskStore.get(first.id()).history().stream().map(Message::messageId).toList()); + } + + /** An agent whose first event is the Task: the stream is relayed unchanged, with one Task. */ + @Test + void streamingNewTaskTaskFirstIsUnchanged() throws Exception { + agentExecutorExecute = (context, emitter) -> { + emitter.addTask(emitter.taskBuilder().status(new TaskStatus(TaskState.TASK_STATE_WORKING)).build()); + emitter.complete(); + }; + + List events = drainStream(streamParams(openingMessage("task-first"), null)); + + assertEquals(2, events.size(), "Expected Task, COMPLETED but got " + events); + Task first = assertInstanceOf(Task.class, events.get(0)); + assertEquals(TaskState.TASK_STATE_WORKING, first.status().state()); + TaskStatusUpdateEvent completed = assertInstanceOf(TaskStatusUpdateEvent.class, events.get(1)); + assertEquals(TaskState.TASK_STATE_COMPLETED, completed.status().state()); + } + + /** An agent that answers with a Message: the stream is relayed unchanged, with no Task. */ + @Test + void streamingNewTaskMessageIsUnchanged() throws Exception { + agentExecutorExecute = (context, emitter) -> emitter.sendMessage("reply"); + + List events = drainStream(streamParams(openingMessage("message-answer"), null)); + + assertEquals(1, events.size(), "Expected only the Message but got " + events); + assertInstanceOf(Message.class, events.get(0)); + } + + /** + * A message to an existing task: the stream also begins with the Task, as this request updated it + * before the agent ran (stored status and timestamp, the new message in its history). + */ + @Test + void streamingExistingTaskBeginsWithTask() throws Exception { + Task existing = Task.builder() + .id("existing-task") + .contextId("existing-context") + .status(new TaskStatus(TaskState.TASK_STATE_INPUT_REQUIRED)) + .build(); + taskStore.save(existing, false); + agentExecutorExecute = (context, emitter) -> { + emitter.startWork(); + emitter.complete(); + }; + Message followUp = Message.builder(openingMessage("second-turn")) + .taskId(existing.id()) + .contextId(existing.contextId()) + .build(); + + List events = drainStream(streamParams(followUp, null)); + + assertEquals(3, events.size(), "Expected Task, WORKING, COMPLETED but got " + events); + Task first = assertInstanceOf(Task.class, events.get(0), "The stream must begin with the Task"); + assertEquals(existing.id(), first.id()); + assertEquals(existing.status(), first.status(), + "The opening Task must carry the stored status, timestamp included"); + assertEquals(List.of("second-turn"), first.history().stream().map(Message::messageId).toList()); + TaskStatusUpdateEvent working = assertInstanceOf(TaskStatusUpdateEvent.class, events.get(1)); + assertEquals(TaskState.TASK_STATE_WORKING, working.status().state()); + TaskStatusUpdateEvent completed = assertInstanceOf(TaskStatusUpdateEvent.class, events.get(2)); + assertEquals(TaskState.TASK_STATE_COMPLETED, completed.status().state()); + } + + private static Message openingMessage(String messageId) { + return Message.builder() + .messageId(messageId) + .role(Message.Role.ROLE_USER) + .parts(new TextPart("hello")) + .build(); + } + + private static MessageSendParams streamParams(Message message, MessageSendConfiguration configuration) { + return MessageSendParams.builder() + .message(message) + .configuration(configuration) + .build(); + } + + private List drainStream(MessageSendParams params) throws Exception { + CountDownLatch done = new CountDownLatch(1); + AtomicReference error = new AtomicReference<>(); + List events = new CopyOnWriteArrayList<>(); + requestHandler.onMessageSendStream(params, contextWithEffectiveCard(true)) + .subscribe(collectingSubscriber(events, error, done)); + assertTrue(done.await(5, TimeUnit.SECONDS), "Stream should complete"); + assertNull(error.get()); + return events; + } + + private static Flow.Subscriber collectingSubscriber(List events, + AtomicReference error, CountDownLatch done) { + return new Flow.Subscriber<>() { + @Override + public void onSubscribe(Flow.Subscription subscription) { + subscription.request(Long.MAX_VALUE); + } + + @Override + public void onNext(StreamingEventKind event) { + events.add(event); + } + + @Override + public void onError(Throwable throwable) { + error.set(throwable); + done.countDown(); + } + + @Override + public void onComplete() { + done.countDown(); + } + }; + } + @Test void initialMessageIsClearedWhenAgentEmitsNothing() throws Exception { CountDownLatch finished = new CountDownLatch(1); @@ -1083,12 +1311,45 @@ void initialMessageIsClearedWhenExecutorSetupFails() throws Exception { assertInitialMessagesEventuallyEmpty(); } + @Test + void initialRegistrationsAreClearedWhenAgentAnswersWithMessage() throws Exception { + CountDownLatch finished = new CountDownLatch(1); + agentExecutorExecute = (context, emitter) -> { + emitter.sendMessage("reply"); + finished.countDown(); + }; + requestHandler.onMessageSendStream(streamParams(openingMessage("message-cleanup"), null), + contextWithEffectiveCard(true)); + assertTrue(finished.await(5, TimeUnit.SECONDS)); + assertInitialMessagesEventuallyEmpty(); + } + + @Test + void initialRegistrationsAreClearedWhenAgentFailsWithError() throws Exception { + CountDownLatch finished = new CountDownLatch(1); + agentExecutorExecute = (context, emitter) -> { + emitter.fail(new InternalError("agent failed")); + finished.countDown(); + }; + requestHandler.onMessageSendStream(streamParams(openingMessage("error-cleanup"), null), + contextWithEffectiveCard(true)); + assertTrue(finished.await(5, TimeUnit.SECONDS)); + assertInitialMessagesEventuallyEmpty(); + } + private void assertInitialMessagesEventuallyEmpty() throws Exception { - var field = MainEventBusProcessor.class.getDeclaredField("initialMessages"); + Map pendingMessages = mainEventBusProcessorMap("initialMessages"); + Map pendingTasks = mainEventBusProcessorMap("initialTasks"); + await().atMost(5, TimeUnit.SECONDS).untilAsserted(() -> { + assertTrue(pendingMessages.isEmpty(), "opening messages should be cleared"); + assertTrue(pendingTasks.isEmpty(), "initial tasks should be cleared"); + }); + } + + private Map mainEventBusProcessorMap(String fieldName) throws Exception { + var field = MainEventBusProcessor.class.getDeclaredField(fieldName); field.setAccessible(true); - Map pending = (Map) field.get(mainEventBusProcessor); - await().atMost(5, TimeUnit.SECONDS) - .untilAsserted(() -> assertTrue(pending.isEmpty(), "opening messages should be cleared")); + return (Map) field.get(mainEventBusProcessor); } /** diff --git a/tests/server-common/src/test/java/org/a2aproject/sdk/server/apps/common/AbstractA2AServerTest.java b/tests/server-common/src/test/java/org/a2aproject/sdk/server/apps/common/AbstractA2AServerTest.java index 12c55df4a..4cd91c86a 100644 --- a/tests/server-common/src/test/java/org/a2aproject/sdk/server/apps/common/AbstractA2AServerTest.java +++ b/tests/server-common/src/test/java/org/a2aproject/sdk/server/apps/common/AbstractA2AServerTest.java @@ -2014,10 +2014,13 @@ public void testNonBlockingWithMultipleMessages() throws Exception { CountDownLatch streamConsumerReadyLatch = new CountDownLatch(1); List streamReceivedEvents = new CopyOnWriteArrayList<>(); AtomicBoolean streamUnexpectedEvent = new AtomicBoolean(false); + AtomicBoolean streamReceivedInitialTask = new AtomicBoolean(false); BiConsumer streamConsumer = (event, agentCard) -> { - // This consumer is for sendMessage() (not subscribe), so it doesn't get initial TaskEvent - if (event instanceof TaskUpdateEvent tue) { + // Per A2A spec 3.1.2, the stream begins with the Task, then its updates + if (event instanceof TaskEvent && !streamReceivedInitialTask.get() && streamReceivedEvents.isEmpty()) { + streamReceivedInitialTask.set(true); + } else if (event instanceof TaskUpdateEvent tue) { streamReceivedEvents.add(tue.getUpdateEvent()); streamEventLatch.countDown(); streamConsumerReadyLatch.countDown(); // Signal that consumer is receiving events @@ -2048,6 +2051,7 @@ public void testNonBlockingWithMultipleMessages() throws Exception { assertFalse(resubUnexpectedEvent.get()); assertFalse(streamUnexpectedEvent.get()); + assertTrue(streamReceivedInitialTask.get(), "The send stream must begin with the Task"); assertNull(resubErrorRef.get()); // Both should have received 2 events: artifact-2 and completion diff --git a/transport/grpc/src/test/java/org/a2aproject/sdk/transport/grpc/handler/GrpcHandlerTest.java b/transport/grpc/src/test/java/org/a2aproject/sdk/transport/grpc/handler/GrpcHandlerTest.java index 4c1911eb8..1bb6d344e 100644 --- a/transport/grpc/src/test/java/org/a2aproject/sdk/transport/grpc/handler/GrpcHandlerTest.java +++ b/transport/grpc/src/test/java/org/a2aproject/sdk/transport/grpc/handler/GrpcHandlerTest.java @@ -446,15 +446,21 @@ public void testOnMessageStreamNewMessageExistingTaskSuccessMocks() throws Excep } Assertions.assertNull(streamRecorder.getError()); List result = streamRecorder.getValues(); - Assertions.assertEquals(2, result.size()); - StreamResponse first = result.get(0); + // Per A2A spec 3.1.2 the stream begins with the Task (as this request updated it), then the events + Assertions.assertEquals(3, result.size()); + StreamResponse initial = result.get(0); + Assertions.assertTrue(initial.hasTask(), "The stream must begin with the Task"); + assertEquals(task.id(), initial.getTask().getId()); + assertEquals(task.contextId(), initial.getTask().getContextId()); + assertEquals(0, initial.getTask().getArtifactsCount()); + StreamResponse first = result.get(1); Assertions.assertTrue(first.hasArtifactUpdate()); org.a2aproject.sdk.grpc.TaskArtifactUpdateEvent taskArtifactUpdateEvent = first.getArtifactUpdate(); assertEquals(task.id(), taskArtifactUpdateEvent.getTaskId()); assertEquals(task.contextId(), taskArtifactUpdateEvent.getContextId()); assertEquals("11", taskArtifactUpdateEvent.getArtifact().getArtifactId()); assertEquals("text", taskArtifactUpdateEvent.getArtifact().getParts(0).getText()); - StreamResponse second = result.get(1); + StreamResponse second = result.get(2); Assertions.assertTrue(second.hasStatusUpdate()); org.a2aproject.sdk.grpc.TaskStatusUpdateEvent taskStatusUpdateEvent = second.getStatusUpdate(); assertEquals(task.id(), taskStatusUpdateEvent.getTaskId()); diff --git a/transport/jsonrpc/src/test/java/org/a2aproject/sdk/transport/jsonrpc/handler/JSONRPCHandlerTest.java b/transport/jsonrpc/src/test/java/org/a2aproject/sdk/transport/jsonrpc/handler/JSONRPCHandlerTest.java index acd3a3204..e95383d16 100644 --- a/transport/jsonrpc/src/test/java/org/a2aproject/sdk/transport/jsonrpc/handler/JSONRPCHandlerTest.java +++ b/transport/jsonrpc/src/test/java/org/a2aproject/sdk/transport/jsonrpc/handler/JSONRPCHandlerTest.java @@ -858,7 +858,14 @@ public void onComplete() { future.join(); - Assertions.assertEquals(events, results); + // Per A2A spec 3.1.2 the stream begins with the Task (as this request updated it), then the events + assertEquals(events.size() + 1, results.size()); + Task first = assertInstanceOf(Task.class, results.get(0), "The stream must begin with the Task"); + assertEquals(task.id(), first.id()); + assertEquals(task.contextId(), first.contextId()); + assertEquals(task.status(), first.status()); + assertEquals(List.of(message.messageId()), first.history().stream().map(Message::messageId).toList()); + Assertions.assertEquals(events, results.subList(1, results.size())); } @Test