…1281)

…ort (a2aproject#1279)

The 0.3 REST transport never reported a normally finished stream back to the
caller: both completion callbacks handed to postAsyncSSE were empty lambdas and
RestSSEEventListener_v0_3 had no onComplete() at all, so a client could not tell
a finished stream apart from one that is still running.

Do what the native REST transport already does since a2aproject#1236, and what the 0.3
JSON-RPC transport has always done: turn the connection-end callback into a
single terminal errorHandler(null) call. signalTerminal() keeps that to exactly
one terminal outcome, so a completion that arrives after a parsing error is
dropped instead of producing a second callback.

The listener contract is covered directly, including error-then-completion,
repeated completion and concurrent terminal signals, all of which fail when the
atomic guard is removed. The errorConsumer Javadoc in ClientTransport_v0_3 now
spells out the null-on-success convention, matching the native interface.

Fixes a2aproject#1194

* docs: announce 1.5.0.Final

* docs: fix PR link labels

* docs: explain escaped PR links

* docs: restore original announcement

Add regression coverage for text and data metadata conversion and defensive copying. The runtime fix is already in a2aproject#1261.

Related to a2aproject#1275.

Signed-off-by: Japneet Singh <[email protected]>

…kslashes (a2aproject#1293)

removeHtmlEscaping replaced every HTML escape it could match in the printed
protobuf JSON, without looking at whether the sequence was itself escaped.
A message text holding a literal backslash followed by the characters
"u003c" is printed by JsonFormat as "\\u003c"; the replacement started at
the second backslash, so the body carried "\<", which is not valid JSON:

  MalformedJsonException: Invalid escape sequence at line 7 column 22
  path $.message.parts[0].text

The scan now copies an escaped backslash as it is and rewrites a
six-character escape only when no backslash precedes it, so both the value
and the escape removal survive.

Fixes 1292

Co-authored-by: WMK666666 <[email protected]>

Use a generic exception when reading v0.3 JSON-RPC error data. Add regression coverage for class initialization and constructor invocation. Based on a fix and test proposed by Chaitanya Pawar.

This fixes a2aproject#1291

…ct#1286)

toJsonRPCRequest() serialised with alwaysPrintFieldsWithNoPresence(), so
proto3 scalars the caller never set went out as "" (tenant, taskId,
contextId, filename, mediaType) and repeated fields as []. A peer cannot
tell "not supplied" from "supplied but empty" any more: in a2aproject#770 the .NET
agent was told the task id was present but empty, answered with an empty
task.id, and the client then failed to deserialise it.

Requests now use a plain printer, which is what the REST client already
does. Responses keep alwaysPrintFieldsWithNoPresence() to match the REST
server handler, so clients still see the full payload shape. Both
printers are static fields now instead of being rebuilt per call, and
both still go through ProtoJsonUtils.toJson so the HTML-unescaping from
a2aproject#892 is preserved.

Adds two unit tests: one asserting the request omits those fields, one
pinning that the response printer still prints them.

Fixes a2aproject#770

…t#1288)

This fixes a2aproject#81

Signed-off-by: Andrea Cosentino <[email protected]>

…) (a2aproject#1297)

…1285)

* fix(compat-0.3): close the SSE stream on terminal events

The 0.3 SSE listeners only stop reading a stream when the server tears the
connection down. The native listeners close it themselves as soon as the event
that ends the task arrives, and that difference is visible on a late
resubscription to a task that already finished.

- RestSSEEventListener_v0_3 took the cancellation future in onMessage and then
  dropped it: handleMessage() never received it, so neither a final status
  update nor a terminal task snapshot closed the connection. The listener now
  passes the future to an auto-close check, the same way
  AbstractSSEEventListener.handleEvent does.
- SSEEventListener_v0_3 cancelled on a final status update only, and treated a
  task snapshot that is already in a final state as a still running stream,
  although that snapshot is what a resubscription to a finished task receives.

Both listeners now use the same predicate as
AbstractSSEEventListener.shouldAutoClose: a final status update, or a task whose
state is final. The terminal callback keeps going through signalTerminal(), so a
completion that arrives after the auto-close is still dropped.

* 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.

* fix(compat-0.3): defer the REST SSE close until the future is published

The REST listener only closed the stream when the future was already
available: `shouldAutoClose(event) && future != null`. postAsyncSSE publishes
that future after it returns, so a terminal event delivered during the call
skipped both the terminal callback and the cancellation. REST never replays
the request, so the caller waited on a stream that had already finished.

The listener now records the close intent and replays it from
onStreamFuturePublished, the same way the JSON-RPC listener does, and the
terminal callback no longer depends on the future being published. onError
goes through the same path, so an early failure closes the channel too.

…ct#1300)

Extend HTML-unescaping regressions across supported escape encodings and representative backslash parity cases. Verify a streaming artifact DataPart round-trips through JSON-RPC response serialization without changing the merged implementation.

Co-authored-by: Copilot <[email protected]>

Parse response buffers incrementally with the shared SSE parser and enforce the default line and event limits. Preserve framing across UTF-8 and line-ending boundaries, recover after oversized events, and complete futures when callbacks fail.

Add coverage for fragmented GET and POST streams, parser limits, and callback failures.