Skip to content

Commit 7b2d9fb

Browse files
committed
refactor: extract shared SSE event handling into SPI module
Create client-transport-spi module with AbstractSSEEventListener to eliminate code duplication between jsonrpc and rest transport implementations. - Add AbstractSSEEventListener with common event/error handling logic - Refactor jsonrpc and rest SSEEventListener to extend base class - Add comprehensive test coverage for shared functionality fix: issue #623 Signed-off-by: Emmanuel Hugonnet <ehugonne@redhat.com>
1 parent 21c15d6 commit 7b2d9fb

10 files changed

Lines changed: 879 additions & 133 deletions

File tree

‎.gitignore‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -52,4 +52,5 @@ nbactions.xml
5252
# Private Claude config
5353
.claude/
5454
.serena/
55+
.bob/
5556
claudedocs

‎client/transport/jsonrpc/src/main/java/io/a2a/client/transport/jsonrpc/sse/SSEEventListener.java‎

Lines changed: 23 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -4,42 +4,32 @@
44
import java.util.function.Consumer;
55
import java.util.logging.Logger;
66

7+
import io.a2a.client.transport.spi.sse.AbstractSSEEventListener;
78
import io.a2a.grpc.StreamResponse;
89
import io.a2a.grpc.utils.JSONRPCUtils;
910
import io.a2a.grpc.utils.ProtoUtils;
1011
import io.a2a.jsonrpc.common.json.JsonProcessingException;
1112
import io.a2a.spec.A2AError;
1213
import io.a2a.spec.StreamingEventKind;
13-
import io.a2a.spec.Task;
14-
import io.a2a.spec.TaskState;
15-
import io.a2a.spec.TaskStatusUpdateEvent;
1614
import org.jspecify.annotations.Nullable;
1715

18-
public class SSEEventListener {
16+
/**
17+
* JSON-RPC transport implementation of SSE event listener.
18+
* Handles parsing of JSON-RPC formatted messages from SSE streams.
19+
*/
20+
public class SSEEventListener extends AbstractSSEEventListener {
1921

2022
private static final Logger log = Logger.getLogger(SSEEventListener.class.getName());
21-
private final Consumer<StreamingEventKind> eventHandler;
22-
private final @Nullable
23-
Consumer<Throwable> errorHandler;
2423
private volatile boolean completed = false;
2524

2625
public SSEEventListener(Consumer<StreamingEventKind> eventHandler,
2726
@Nullable Consumer<Throwable> errorHandler) {
28-
this.eventHandler = eventHandler;
29-
this.errorHandler = errorHandler;
27+
super(eventHandler, errorHandler);
3028
}
3129

30+
@Override
3231
public void onMessage(String message, @Nullable Future<Void> completableFuture) {
33-
handleMessage(message, completableFuture);
34-
}
35-
36-
public void onError(Throwable throwable, @Nullable Future<Void> future) {
37-
if (errorHandler != null) {
38-
errorHandler.accept(throwable);
39-
}
40-
if (future != null) {
41-
future.cancel(true); // close SSE channel
42-
}
32+
parseAndHandleMessage(message, completableFuture);
4333
}
4434

4535
public void onComplete() {
@@ -52,40 +42,30 @@ public void onComplete() {
5242

5343
// Signal normal stream completion (null error means successful completion)
5444
log.fine("SSEEventListener.onComplete() called - signaling successful stream completion");
55-
if (errorHandler != null) {
45+
if (getErrorHandler() != null) {
5646
log.fine("Calling errorHandler.accept(null) to signal successful completion");
57-
errorHandler.accept(null);
47+
getErrorHandler().accept(null);
5848
} else {
5949
log.warning("errorHandler is null, cannot signal completion");
6050
}
6151
}
6252

63-
private void handleMessage(String message, @Nullable Future<Void> future) {
53+
/**
54+
* Parses a JSON-RPC message and delegates to the base class for event handling.
55+
*
56+
* @param message The raw JSON-RPC message string
57+
* @param future Optional future for controlling the SSE connection
58+
*/
59+
private void parseAndHandleMessage(String message, @Nullable Future<Void> future) {
6460
try {
6561
StreamResponse response = JSONRPCUtils.parseResponseEvent(message);
66-
6762
StreamingEventKind event = ProtoUtils.FromProto.streamingEventKind(response);
68-
eventHandler.accept(event);
69-
70-
// Client-side auto-close on final events to prevent connection leaks
71-
// Handles both TaskStatusUpdateEvent and Task objects with final states
72-
// This covers late subscriptions to completed tasks and ensures no connection leaks
73-
boolean shouldClose = false;
74-
if (event instanceof TaskStatusUpdateEvent tue && tue.isFinal()) {
75-
shouldClose = true;
76-
} else if (event instanceof Task task) {
77-
TaskState state = task.status().state();
78-
if (state.isFinal()) {
79-
shouldClose = true;
80-
}
81-
}
82-
83-
if (shouldClose && future != null) {
84-
future.cancel(true); // close SSE channel
85-
}
63+
64+
// Delegate to base class for common event handling and auto-close logic
65+
handleEvent(event, future);
8666
} catch (A2AError error) {
87-
if (errorHandler != null) {
88-
errorHandler.accept(error);
67+
if (getErrorHandler() != null) {
68+
getErrorHandler().accept(error);
8969
}
9070
} catch (JsonProcessingException e) {
9171
throw new RuntimeException(e);

‎client/transport/jsonrpc/src/test/java/io/a2a/client/transport/jsonrpc/sse/SSEEventListenerTest.java‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -198,7 +198,22 @@ public void testFinalTaskStatusUpdateEventCancels() {
198198
error -> {}
199199
);
200200

201+
// Parse the message event JSON
202+
String eventData = JsonStreamingMessages.STREAMING_STATUS_UPDATE_EVENT_FINAL.substring(
203+
JsonStreamingMessages.STREAMING_STATUS_UPDATE_EVENT_FINAL.indexOf("{"));
204+
205+
// Call onMessage with a cancellable future
206+
CancelCapturingFuture future = new CancelCapturingFuture();
207+
listener.onMessage(eventData, future);
201208

209+
// Verify the event was received and processed
210+
assertNotNull(receivedEvent.get());
211+
assertTrue(receivedEvent.get() instanceof TaskStatusUpdateEvent);
212+
TaskStatusUpdateEvent received = (TaskStatusUpdateEvent) receivedEvent.get();
213+
assertTrue(received.isFinal());
214+
215+
// Verify the future was cancelled (auto-close on final event)
216+
assertTrue(future.cancelHandlerCalled);
202217
}
203218

204219
@Test

‎client/transport/rest/src/main/java/io/a2a/client/transport/rest/RestTransport.java‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@
3131
import io.a2a.client.http.A2AHttpClient;
3232
import io.a2a.client.http.A2AHttpClientFactory;
3333
import io.a2a.client.http.A2AHttpResponse;
34-
import io.a2a.client.transport.rest.sse.RestSSEEventListener;
34+
import io.a2a.client.transport.rest.sse.SSEEventListener;
3535
import io.a2a.client.transport.spi.ClientTransport;
3636
import io.a2a.client.transport.spi.interceptors.ClientCallContext;
3737
import io.a2a.client.transport.spi.interceptors.ClientCallInterceptor;
@@ -110,7 +110,7 @@ public void sendMessageStreaming(MessageSendParams messageSendParams, Consumer<S
110110
io.a2a.grpc.SendMessageRequest.Builder builder = io.a2a.grpc.SendMessageRequest.newBuilder(ProtoUtils.ToProto.sendMessageRequest(messageSendParams));
111111
PayloadAndHeaders payloadAndHeaders = applyInterceptors(SEND_STREAMING_MESSAGE_METHOD, builder, agentCard, context);
112112
AtomicReference<CompletableFuture<Void>> ref = new AtomicReference<>();
113-
RestSSEEventListener sseEventListener = new RestSSEEventListener(eventConsumer, errorConsumer);
113+
SSEEventListener sseEventListener = new SSEEventListener(eventConsumer, errorConsumer);
114114
try {
115115
A2AHttpClient.PostBuilder postBuilder = createPostBuilder(Utils.buildBaseUrl(agentInterface, messageSendParams.tenant()) + "/message:stream", payloadAndHeaders);
116116
ref.set(postBuilder.postAsyncSSE(
@@ -395,7 +395,7 @@ public void resubscribe(TaskIdParams request, Consumer<StreamingEventKind> event
395395
PayloadAndHeaders payloadAndHeaders = applyInterceptors(SUBSCRIBE_TO_TASK_METHOD, builder,
396396
agentCard, context);
397397
AtomicReference<CompletableFuture<Void>> ref = new AtomicReference<>();
398-
RestSSEEventListener sseEventListener = new RestSSEEventListener(eventConsumer, errorConsumer);
398+
SSEEventListener sseEventListener = new SSEEventListener(eventConsumer, errorConsumer);
399399
try {
400400
String url = Utils.buildBaseUrl(agentInterface, request.tenant()) + String.format("/tasks/%1s:subscribe", request.id());
401401
A2AHttpClient.PostBuilder postBuilder = createPostBuilder(url, payloadAndHeaders);

‎client/transport/rest/src/main/java/io/a2a/client/transport/rest/sse/RestSSEEventListener.java‎

Lines changed: 0 additions & 87 deletions
This file was deleted.
Lines changed: 73 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,73 @@
1+
package io.a2a.client.transport.rest.sse;
2+
3+
import java.util.concurrent.Future;
4+
import java.util.function.Consumer;
5+
import java.util.logging.Logger;
6+
7+
import com.google.protobuf.InvalidProtocolBufferException;
8+
import com.google.protobuf.util.JsonFormat;
9+
import io.a2a.client.transport.spi.sse.AbstractSSEEventListener;
10+
import io.a2a.client.transport.rest.RestErrorMapper;
11+
import io.a2a.grpc.StreamResponse;
12+
import io.a2a.grpc.utils.ProtoUtils;
13+
import io.a2a.spec.StreamingEventKind;
14+
import org.jspecify.annotations.Nullable;
15+
16+
/**
17+
* REST transport implementation of SSE event listener.
18+
* Handles parsing of JSON-formatted protobuf messages from REST SSE streams.
19+
*/
20+
public class SSEEventListener extends AbstractSSEEventListener {
21+
22+
private static final Logger log = Logger.getLogger(SSEEventListener.class.getName());
23+
24+
public SSEEventListener(Consumer<StreamingEventKind> eventHandler,
25+
Consumer<Throwable> errorHandler) {
26+
super(eventHandler, errorHandler);
27+
}
28+
29+
@Override
30+
public void onMessage(String message, @Nullable Future<Void> completableFuture) {
31+
try {
32+
log.fine("Streaming message received: " + message);
33+
io.a2a.grpc.StreamResponse.Builder builder = io.a2a.grpc.StreamResponse.newBuilder();
34+
JsonFormat.parser().merge(message, builder);
35+
parseAndHandleMessage(builder.build(), completableFuture);
36+
} catch (InvalidProtocolBufferException e) {
37+
if (getErrorHandler() != null) {
38+
getErrorHandler().accept(RestErrorMapper.mapRestError(message, 500));
39+
}
40+
}
41+
}
42+
43+
/**
44+
* Parses a StreamResponse protobuf message and delegates to the base class for event handling.
45+
*
46+
* @param response The parsed StreamResponse
47+
* @param future Optional future for controlling the SSE connection
48+
*/
49+
private void parseAndHandleMessage(StreamResponse response, @Nullable Future<Void> future) {
50+
StreamingEventKind event;
51+
switch (response.getPayloadCase()) {
52+
case MESSAGE ->
53+
event = ProtoUtils.FromProto.message(response.getMessage());
54+
case TASK ->
55+
event = ProtoUtils.FromProto.task(response.getTask());
56+
case STATUS_UPDATE ->
57+
event = ProtoUtils.FromProto.taskStatusUpdateEvent(response.getStatusUpdate());
58+
case ARTIFACT_UPDATE ->
59+
event = ProtoUtils.FromProto.taskArtifactUpdateEvent(response.getArtifactUpdate());
60+
default -> {
61+
log.warning("Invalid stream response " + response.getPayloadCase());
62+
if (getErrorHandler() != null) {
63+
getErrorHandler().accept(new IllegalStateException("Invalid stream response from server: " + response.getPayloadCase()));
64+
}
65+
return;
66+
}
67+
}
68+
69+
// Delegate to base class for common event handling and auto-close logic
70+
handleEvent(event, future);
71+
}
72+
73+
}

0 commit comments

Comments
 (0)