Skip to content

Commit dc54cf9

Browse files
committed
fix(compat-0.3): cancel the SSE stream once its future is published
JSONRPCTransport_v0_3 stores the future returned by postAsyncSSE only after that call returns, so a terminal event delivered while the request is still in flight reached the listener with a null future, and the completed-task path called cancel(true) on it. The listener now records the close request and replays it from onStreamFuturePublished, which the transport calls right after publishing the future. onError and the invalid-message path go through the same helper, as they receive ref.get() as well. Covered at both levels: SSEEventListener_v0_3_Test exercises a terminal event arriving before publication and checks that publishing the future is not itself a close request; JSONRPCTransportStreamingCancel_v0_3_Test drives sendMessageStreaming and resubscribe with a client that delivers the event before postAsyncSSE returns.
1 parent 3b153ee commit dc54cf9

4 files changed

Lines changed: 299 additions & 7 deletions

File tree

‎compat-0.3/client/transport/jsonrpc/src/main/java/org/a2aproject/sdk/compat03/client/transport/jsonrpc/JSONRPCTransport_v0_3.java‎

Lines changed: 12 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -135,13 +135,18 @@ public void sendMessageStreaming(MessageSendParams_v0_3 request, Consumer<Stream
135135

136136
try {
137137
A2AHttpClient.PostBuilder builder = createPostBuilder(payloadAndHeaders);
138-
ref.set(builder.postAsyncSSE(
138+
CompletableFuture<Void> streamFuture = builder.postAsyncSSE(
139139
event -> sseEventListener.onMessage(event.data(), ref.get()),
140140
throwable -> sseEventListener.onError(throwable, ref.get()),
141141
() -> {
142142
// Signal normal stream completion to error handler (null error means success)
143143
sseEventListener.onComplete();
144-
}));
144+
});
145+
ref.set(streamFuture);
146+
// A terminal event can be delivered before postAsyncSSE returns, i.e. before the future
147+
// above is available to the listener. Handing it over lets the listener close the
148+
// channel the event asked for.
149+
sseEventListener.onStreamFuturePublished(streamFuture);
145150
} catch (IOException e) {
146151
throw new A2AClientException_v0_3("Failed to send streaming message request: " + e, e);
147152
} catch (InterruptedException e) {
@@ -316,13 +321,16 @@ public void resubscribe(TaskIdParams_v0_3 request, Consumer<StreamingEventKind_v
316321

317322
try {
318323
A2AHttpClient.PostBuilder builder = createPostBuilder(payloadAndHeaders);
319-
ref.set(builder.postAsyncSSE(
324+
CompletableFuture<Void> streamFuture = builder.postAsyncSSE(
320325
event -> sseEventListener.onMessage(event.data(), ref.get()),
321326
throwable -> sseEventListener.onError(throwable, ref.get()),
322327
() -> {
323328
// Signal normal stream completion to error handler (null error means success)
324329
sseEventListener.onComplete();
325-
}));
330+
});
331+
ref.set(streamFuture);
332+
// Same as sendMessageStreaming: replay a close request raised before the future existed.
333+
sseEventListener.onStreamFuturePublished(streamFuture);
326334
} catch (IOException e) {
327335
throw new A2AClientException_v0_3("Failed to send task resubscription request: " + e, e);
328336
} catch (InterruptedException e) {

‎compat-0.3/client/transport/jsonrpc/src/main/java/org/a2aproject/sdk/compat03/client/transport/jsonrpc/sse/SSEEventListener_v0_3.java‎

Lines changed: 47 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@
1212

1313
import java.util.concurrent.Future;
1414
import java.util.concurrent.atomic.AtomicBoolean;
15+
import java.util.concurrent.atomic.AtomicReference;
1516
import java.util.function.Consumer;
1617
import java.util.logging.Logger;
1718

@@ -20,13 +21,24 @@ public class SSEEventListener_v0_3 {
2021
private final Consumer<StreamingEventKind_v0_3> eventHandler;
2122
private final Consumer<Throwable> errorHandler;
2223
private final AtomicBoolean terminalSignaled = new AtomicBoolean(false);
24+
/**
25+
* Set as soon as this listener decides the stream is over, which can happen before the future
26+
* returned by {@code postAsyncSSE} exists; {@link #onStreamFuturePublished} replays it then.
27+
*/
28+
private final AtomicBoolean closeRequested = new AtomicBoolean(false);
29+
/** The future returned by {@code postAsyncSSE}, published by the transport after that call returns. */
30+
private final AtomicReference<Future<Void>> streamFuture = new AtomicReference<>();
2331

2432
public SSEEventListener_v0_3(Consumer<StreamingEventKind_v0_3> eventHandler,
2533
Consumer<Throwable> errorHandler) {
2634
this.eventHandler = eventHandler;
2735
this.errorHandler = errorHandler;
2836
}
2937

38+
/**
39+
* @param completableFuture the streaming future, or {@code null} while {@code postAsyncSSE} has
40+
* not returned yet
41+
*/
3042
public void onMessage(String message, Future<Void> completableFuture) {
3143
try {
3244
handleMessage(JsonParser.parseString(message).getAsJsonObject(), completableFuture);
@@ -37,13 +49,45 @@ public void onMessage(String message, Future<Void> completableFuture) {
3749
} catch (IllegalArgumentException e) {
3850
LOGGER.warning("Invalid message format: " + message);
3951
signalTerminal(e);
40-
completableFuture.cancel(true); // close SSE channel
52+
requestClose(completableFuture);
4153
}
4254
}
4355

56+
/**
57+
* @param future the streaming future, or {@code null} while {@code postAsyncSSE} has not
58+
* returned yet
59+
*/
4460
public void onError(Throwable throwable, Future<Void> future) {
4561
signalTerminal(throwable);
46-
future.cancel(true); // close SSE channel
62+
requestClose(future);
63+
}
64+
65+
/**
66+
* Hands this listener the future returned by {@code postAsyncSSE}.
67+
*
68+
* <p>That future does not exist while the call is still in flight, so a terminal event that
69+
* arrives early cannot close the channel from {@link #onMessage} or {@link #onError}. The
70+
* close request recorded in that case is honoured here.
71+
*
72+
* @param future the streaming future, or {@code null} if the client did not return one
73+
*/
74+
public void onStreamFuturePublished(Future<Void> future) {
75+
// Publish first, then read the flag: a concurrent requestClose either sees the future
76+
// here or is seen below, so the close request is never lost.
77+
streamFuture.set(future);
78+
if (closeRequested.get() && future != null) {
79+
future.cancel(true); // close SSE channel
80+
}
81+
}
82+
83+
private void requestClose(Future<Void> future) {
84+
// Set the flag before reading the future, mirroring onStreamFuturePublished.
85+
closeRequested.set(true);
86+
Future<Void> published = streamFuture.get();
87+
Future<Void> target = published != null ? published : future;
88+
if (target != null) {
89+
target.cancel(true); // close SSE channel
90+
}
4791
}
4892

4993
private void signalTerminal(Throwable error) {
@@ -74,7 +118,7 @@ private void handleMessage(JsonObject jsonObject, Future<Void> future) throws Js
74118
eventHandler.accept(event);
75119
if (shouldAutoClose(event)) {
76120
signalTerminal(null);
77-
future.cancel(true); // close SSE channel
121+
requestClose(future);
78122
}
79123
} else {
80124
throw new IllegalArgumentException("Unknown message type");
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,175 @@
1+
package org.a2aproject.sdk.compat03.client.transport.jsonrpc;
2+
3+
import static org.junit.jupiter.api.Assertions.assertEquals;
4+
import static org.junit.jupiter.api.Assertions.assertFalse;
5+
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
6+
import static org.junit.jupiter.api.Assertions.assertNull;
7+
import static org.junit.jupiter.api.Assertions.assertTrue;
8+
9+
import java.util.Collections;
10+
import java.util.List;
11+
import java.util.Map;
12+
import java.util.concurrent.CompletableFuture;
13+
import java.util.concurrent.atomic.AtomicInteger;
14+
import java.util.concurrent.atomic.AtomicReference;
15+
import java.util.function.Consumer;
16+
17+
import org.a2aproject.sdk.client.http.A2AHttpClient;
18+
import org.a2aproject.sdk.client.http.A2AHttpResponse;
19+
import org.a2aproject.sdk.client.http.ServerSentEvent;
20+
import org.a2aproject.sdk.compat03.spec.MessageSendConfiguration_v0_3;
21+
import org.a2aproject.sdk.compat03.spec.MessageSendParams_v0_3;
22+
import org.a2aproject.sdk.compat03.spec.Message_v0_3;
23+
import org.a2aproject.sdk.compat03.spec.StreamingEventKind_v0_3;
24+
import org.a2aproject.sdk.compat03.spec.TaskIdParams_v0_3;
25+
import org.a2aproject.sdk.compat03.spec.TaskStatusUpdateEvent_v0_3;
26+
import org.a2aproject.sdk.compat03.spec.TextPart_v0_3;
27+
import org.junit.jupiter.api.Test;
28+
29+
/**
30+
* Covers the ordering the JSON-RPC SSE transport has to survive: {@code postAsyncSSE} may deliver
31+
* events before it returns, so the listener can see a terminal event while the streaming future is
32+
* still unpublished.
33+
*/
34+
public class JSONRPCTransportStreamingCancel_v0_3_Test {
35+
36+
@Test
37+
public void testFinalEventDeliveredBeforePostAsyncSseReturns() throws Exception {
38+
SynchronousSseHttpClient httpClient = new SynchronousSseHttpClient(
39+
eventJson(JsonStreamingMessages_v0_3.STREAMING_STATUS_UPDATE_EVENT_FINAL));
40+
JSONRPCTransport_v0_3 transport = transport(httpClient);
41+
42+
AtomicReference<StreamingEventKind_v0_3> receivedEvent = new AtomicReference<>();
43+
AtomicReference<Throwable> receivedError = new AtomicReference<>();
44+
transport.sendMessageStreaming(streamingParams(), receivedEvent::set, receivedError::set, null);
45+
46+
TaskStatusUpdateEvent_v0_3 event =
47+
assertInstanceOf(TaskStatusUpdateEvent_v0_3.class, receivedEvent.get());
48+
assertTrue(event.isFinal());
49+
assertNull(receivedError.get(), "A final status update ends the stream normally");
50+
assertTrue(httpClient.streamFuture.isCancelled(),
51+
"A stream whose final event arrives before the future is published still has to be closed");
52+
}
53+
54+
@Test
55+
public void testResubscribeOfFinalTaskDeliveredBeforePostAsyncSseReturns() throws Exception {
56+
SynchronousSseHttpClient httpClient = new SynchronousSseHttpClient(
57+
eventJson(JsonStreamingMessages_v0_3.STREAMING_STATUS_UPDATE_EVENT_FINAL));
58+
JSONRPCTransport_v0_3 transport = transport(httpClient);
59+
60+
AtomicInteger events = new AtomicInteger();
61+
AtomicReference<Throwable> receivedError = new AtomicReference<>();
62+
transport.resubscribe(new TaskIdParams_v0_3("task-1234"), event -> events.incrementAndGet(),
63+
receivedError::set, null);
64+
65+
assertEquals(1, events.get());
66+
assertNull(receivedError.get(), "A final status update ends the stream normally");
67+
assertTrue(httpClient.streamFuture.isCancelled(),
68+
"Resubscription closes the channel the same way as a new streaming message");
69+
}
70+
71+
@Test
72+
public void testNonFinalEventDeliveredBeforePostAsyncSseReturnsKeepsTheStreamOpen() throws Exception {
73+
SynchronousSseHttpClient httpClient = new SynchronousSseHttpClient(
74+
eventJson(JsonStreamingMessages_v0_3.STREAMING_STATUS_UPDATE_EVENT));
75+
JSONRPCTransport_v0_3 transport = transport(httpClient);
76+
77+
AtomicReference<StreamingEventKind_v0_3> receivedEvent = new AtomicReference<>();
78+
AtomicReference<Throwable> receivedError = new AtomicReference<>();
79+
transport.sendMessageStreaming(streamingParams(), receivedEvent::set, receivedError::set, null);
80+
81+
TaskStatusUpdateEvent_v0_3 event =
82+
assertInstanceOf(TaskStatusUpdateEvent_v0_3.class, receivedEvent.get());
83+
assertFalse(event.isFinal());
84+
assertNull(receivedError.get());
85+
assertFalse(httpClient.streamFuture.isCancelled(),
86+
"A stream that is still running must not be closed");
87+
}
88+
89+
private static JSONRPCTransport_v0_3 transport(A2AHttpClient httpClient) {
90+
return new JSONRPCTransport_v0_3(httpClient, null, "http://localhost:4001", null);
91+
}
92+
93+
private static String eventJson(String ssePayload) {
94+
return ssePayload.substring(ssePayload.indexOf("{"));
95+
}
96+
97+
private static MessageSendParams_v0_3 streamingParams() {
98+
Message_v0_3 message = new Message_v0_3.Builder()
99+
.role(Message_v0_3.Role.USER)
100+
.parts(Collections.singletonList(new TextPart_v0_3("tell me some jokes")))
101+
.contextId("context-1234")
102+
.messageId("message-1234")
103+
.build();
104+
MessageSendConfiguration_v0_3 configuration = new MessageSendConfiguration_v0_3.Builder()
105+
.acceptedOutputModes(List.of("text"))
106+
.blocking(false)
107+
.build();
108+
return new MessageSendParams_v0_3.Builder()
109+
.message(message)
110+
.configuration(configuration)
111+
.build();
112+
}
113+
114+
/**
115+
* Delivers the single SSE event synchronously from {@code postAsyncSSE}, so the caller has no
116+
* chance to publish the returned future before the listener sees it.
117+
*/
118+
private static final class SynchronousSseHttpClient implements A2AHttpClient {
119+
120+
private final String eventJson;
121+
private final CompletableFuture<Void> streamFuture = new CompletableFuture<>();
122+
123+
private SynchronousSseHttpClient(String eventJson) {
124+
this.eventJson = eventJson;
125+
}
126+
127+
@Override
128+
public GetBuilder createGet() {
129+
throw new UnsupportedOperationException("This test client only streams POST requests");
130+
}
131+
132+
@Override
133+
public PostBuilder createPost() {
134+
return new PostBuilder() {
135+
@Override
136+
public PostBuilder body(String body) {
137+
return this;
138+
}
139+
140+
@Override
141+
public PostBuilder url(String s) {
142+
return this;
143+
}
144+
145+
@Override
146+
public PostBuilder addHeaders(Map<String, String> headers) {
147+
return this;
148+
}
149+
150+
@Override
151+
public PostBuilder addHeader(String name, String value) {
152+
return this;
153+
}
154+
155+
@Override
156+
public A2AHttpResponse post() {
157+
throw new UnsupportedOperationException("This test client only streams POST requests");
158+
}
159+
160+
@Override
161+
public CompletableFuture<Void> postAsyncSSE(Consumer<ServerSentEvent> messageConsumer,
162+
Consumer<Throwable> errorConsumer,
163+
Runnable completeRunnable) {
164+
messageConsumer.accept(new ServerSentEvent(eventJson));
165+
return streamFuture;
166+
}
167+
};
168+
}
169+
170+
@Override
171+
public DeleteBuilder createDelete() {
172+
throw new UnsupportedOperationException("This test client only streams POST requests");
173+
}
174+
}
175+
}

‎compat-0.3/client/transport/jsonrpc/src/test/java/org/a2aproject/sdk/compat03/client/transport/jsonrpc/sse/SSEEventListener_v0_3_Test.java‎

Lines changed: 65 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -267,6 +267,71 @@ public void testRunningTaskSnapshotKeepsTheConnectionOpen() throws Exception {
267267
assertEquals(0, terminalCalls.get(), "A stream that is still running has no terminal outcome yet");
268268
}
269269

270+
/**
271+
* The transport publishes the streaming future only after {@code postAsyncSSE} returns, so a
272+
* terminal event delivered while the request is still in flight reaches the listener without
273+
* one. The listener must record the close request instead of dereferencing a missing future,
274+
* and honour it once the transport hands the future over.
275+
*/
276+
@Test
277+
public void testTerminalTaskSnapshotArrivingBeforeTheFutureIsPublished() throws Exception {
278+
Task_v0_3 task = new Task_v0_3.Builder()
279+
.id("1234")
280+
.contextId("xyz")
281+
.status(new TaskStatus_v0_3(TaskState_v0_3.COMPLETED))
282+
.build();
283+
284+
AtomicReference<StreamingEventKind_v0_3> receivedEvent = new AtomicReference<>();
285+
AtomicInteger terminalCalls = new AtomicInteger();
286+
AtomicReference<Throwable> terminalError = new AtomicReference<>(new Throwable("not invoked"));
287+
SSEEventListener_v0_3 listener = new SSEEventListener_v0_3(
288+
event -> receivedEvent.set(event),
289+
error -> {
290+
terminalCalls.incrementAndGet();
291+
terminalError.set(error);
292+
});
293+
294+
// The future does not exist yet: this is the call that used to throw a NullPointerException.
295+
listener.onMessage(resultPayload(task), null);
296+
297+
assertInstanceOf(Task_v0_3.class, receivedEvent.get());
298+
assertEquals(1, terminalCalls.get());
299+
assertNull(terminalError.get(), "Reaching the end of the task is a normal completion");
300+
301+
CancelCapturingFuture future = new CancelCapturingFuture();
302+
listener.onStreamFuturePublished(future);
303+
304+
assertTrue(future.cancelHandlerCalled,
305+
"The close request raised before the future existed has to be honoured once it does");
306+
}
307+
308+
/**
309+
* Publishing the future is not itself a close request: a stream that is still running must stay
310+
* open, and a terminal event arriving afterwards still has to close it.
311+
*/
312+
@Test
313+
public void testPublishingTheFutureIsNotACloseRequest() throws Exception {
314+
Task_v0_3 task = new Task_v0_3.Builder()
315+
.id("1234")
316+
.contextId("xyz")
317+
.status(new TaskStatus_v0_3(TaskState_v0_3.COMPLETED))
318+
.build();
319+
320+
AtomicReference<StreamingEventKind_v0_3> receivedEvent = new AtomicReference<>();
321+
SSEEventListener_v0_3 listener = new SSEEventListener_v0_3(
322+
event -> receivedEvent.set(event),
323+
error -> {});
324+
325+
CancelCapturingFuture future = new CancelCapturingFuture();
326+
listener.onStreamFuturePublished(future);
327+
assertFalse(future.cancelHandlerCalled, "Publishing the future is not a reason to close the stream");
328+
329+
listener.onMessage(resultPayload(task), future);
330+
331+
assertInstanceOf(Task_v0_3.class, receivedEvent.get());
332+
assertTrue(future.cancelHandlerCalled, "A task already in a final state still has to close the channel");
333+
}
334+
270335
@Test
271336
public void testOnEventWithFinalTaskStatusUpdateEventEventCancels() throws Exception {
272337
// Set up event handler

0 commit comments

Comments
 (0)