Skip to content

fix(a2a-pb)!: reject a part with no content and a request with no message - #510

Merged
muscariello merged 1 commit into
a2aproject:mainfrom
gulldan:fix/empty-part-rejected
Nov 20, 2026
Merged

muscariello merged 1 commit into
a2aproject:mainfrom
gulldan:fix/empty-part-rejected

Conversation

@gulldan

@gulldan gulldan commented Nov 5, 2026 •

Copy link
Copy Markdown
Contributor

Fixes #509.

Problem

Part.content is a required oneof and SendMessageRequest.message a REQUIRED field in a2a.proto, but the conversion from proto turned a part that carries no content ({} on JSON-RPC and REST, an empty oneof on gRPC and SLIM RPC) into an empty text part, and a request without a message into an empty user message. Both were accepted and reached the executor. a2a-go refuses both at conversion (a2apb/v1/pbconv/from_proto.go:44-46 and :118-119 at ea739de), and the native Part deserializer refuses the first.

Fix

The converters in a2a_pb::pbconv that can meet such a field return Result<_, FieldViolation> (the existing a2a::FieldViolation). The violation names the field by its JSON path from the converted message, built with enumerate() at each repeated field: message.parts[0], tasks[1].history[0].parts[2], statusUpdate.status.message.parts[0].

It is deliberately not an A2AError, because what it means depends on the reader, and there is no From impl, so a call site has to say which it is:

  • A server that finds it in a request answers pbconv::invalid_request: -32602 on JSON-RPC, 400 with the path in BadRequest.fieldViolations[0].field on HTTP+JSON, INVALID_ARGUMENT on gRPC and SLIM RPC. The message is message.parts[0]: must have one of: text, raw, url, data or message: is required.
  • A client that finds it in a response reports pbconv::invalid_response: INTERNAL_ERROR with invalid response: <path>: <reason>, as the JSON-RPC and HTTP+JSON clients already report a response they cannot decode. The gRPC and SLIM RPC clients returned the conversion error as it was (INVALID_PARAMS), which blamed the caller's request; every conversion site in both clients (six in gRPC, seven in SLIM RPC, collaborate included) now goes through invalid_response.

Also in this change, from the review:

  • {"data": null} is a part whose content is JSON null, not a part without content. data is a google.protobuf.Value, for which null is a value: protobuf-go sets the field (encoding/protojson/decode.go:219-224). pbjson reads every null oneof member as unset, so build.rs patches that one arm next to the existing null patches. On main the same body silently became an empty text part.
  • A null member of any other oneof is not set, wherever it stands among the keys. The generated arm checked for a duplicate before it read the value, so {"text": "x", "raw": null} was accepted by from_value (sorted keys) and rejected by from_str, on main too. build.rs rewrites all 19 oneof arms (Part, SecurityScheme, OAuthFlows, SendMessageResponse, StreamResponse) to read first and check only a member that is not null. The members come from the descriptor, and the build fails if the number of patched arms differs from it.
  • register_collaborate logs one warning for an item it cannot deliver (a stream error, bytes that do not decode, a message that fails conversion) instead of dropping it silently. The reason is written with ? and cut at 256 characters, because the peer chooses the message id. This adds tracing to a2a-slimrpc, and tracing-subscriber as a dev-dependency.
  • SLIM RPC SendMessage and SendStreamingMessage both answer a rejected request through pbconv::invalid_request; register_unary_unary keeps its signature.
  • impl_protojson_payload! is one macro: a path for a converter that cannot fail, |value| expr for one that can, and optional trait items in braces. impl_protojson_payload_fallible!, impl_protojson_payload_optional! and the hand-written ListTasksResponse impl are gone.

Behaviour changes to check

  • A SendMessageRequest without message is rejected (message: is required); it used to reach the executor as an empty user message.
  • A part with "data": null next to another member, such as {"text": "x", "data": null}, is rejected as a duplicate oneof member, in either key order and through both from_str and from_value. On main the null was ignored and the part was read as text. protobuf-go rejects the same body (decode.go:238-242, "oneof … is already set").
  • A null member other than data next to the member that is set, such as {"text": "x", "raw": null}, is accepted in any key order. On main from_str rejected it when the null came second.

Not changed

A response is still read strictly: one part without content fails the task or the ListTasks page it is in, now as INTERNAL_ERROR naming the element. The other REQUIRED fields are left for a follow-up: an empty messageId and empty parts are tracked in #561, an unset Task.status, TaskStatusUpdateEvent.status and TaskArtifactUpdateEvent.artifact in #563.

Tests

  • a2a-pb: test_part_without_content_is_named_by_its_path (a part inside a message, a task's history, an artifact, a status message, a ListTasks page, both SendMessageResponse payloads and all four StreamResponse payloads), test_send_message_request_without_a_message_is_rejected, test_a_violation_is_invalid_params_in_a_request_and_internal_in_a_response, test_part_none_content flipped; tests/protojson.rs: send_message_request_rejects_part_without_content (asserts the message), a_null_data_part_round_trips, a_null_part_member_is_unset_in_any_key_order and a_null_data_member_next_to_another_member_is_rejected_in_any_key_order (each body through from_str and from_value), a_null_stream_response_member_is_unset.
  • a2a-server: test_send_message_rejects_a_missing_message_and_a_part_without_content in jsonrpc.rs (SendMessage and SendStreamingMessage) and in rest.rs (message:send and message:stream, asserting field and description, plus a body that does not decode at all).
  • a2a-grpc/tests/e2e.rs: grpc_server_rejects_a_missing_message_and_a_part_without_content (unary and streaming); grpc_transport_reports_a_part_without_content_in_a_response_as_internal against a raw service whose every response carries such a part (send_message, get_task, list_tasks, cancel_task, both streams).
  • a2a-slimrpc/tests/e2e.rs: slimrpc_server_rejects_a_missing_message_and_a_part_without_content (raw channel, unary and streaming); slimrpc_transport_reports_a_part_without_content_in_a_response_as_internal (the same six calls); slimrpc_collaborate_replies_are_attributed_to_their_sender now also gets a reply with such a part and expects INTERNAL_ERROR; slimrpc_collaborate_drops_a_message_it_cannot_deliver (a listen-only member drops a part without content and an undecodable payload, logs both with the message id escaped, and receives the next message); slimrpc_transport_end_to_end calls get_extended_agent_card, which no SLIM RPC test did. src/server.rs: collaborate_message_says_why_an_item_is_dropped, capped_cuts_on_a_character_boundary.

On main (e9b00bc) the 12 new or changed tests that compile against it fail: the five in protojson.rs, both gRPC tests, the JSON-RPC test and the four SLIM RPC tests; the others need the new signatures. CI steps on Linux, Rust 1.100.0: all green (991 tests). Patch coverage as coverage.yml builds it (measured on 1.99.1): 374 coverable added lines, 0 missed.

Overlap

One commit on main e9b00bc. It closes the first case of #561 (a request with no message); the empty messageId and parts cases there are not covered. #558 edits a2a-grpc/tests/e2e.rs, a2a-server/src/jsonrpc.rs and rest.rs as well, so whichever merges second needs a rebase. a2a-grpc/src/errors.rs is untouched, so no conflict with #515.

Breaking change

In a2a_pb::pbconv, from_proto_part, from_proto_message, from_proto_task_status, from_proto_artifact, from_proto_task, from_proto_send_message_request, from_proto_list_tasks_response, from_proto_task_status_update_event and from_proto_task_artifact_update_event return Result<T, FieldViolation> instead of T; from_proto_send_message_response and from_proto_stream_response return Result<Option<T>, FieldViolation> instead of Option<T>. ProtoJsonPayloadError gains the variant Invalid(FieldViolation) and is #[non_exhaustive]. The commit message carries the BREAKING CHANGE: footer.

🤖 Generated with Claude Code

@gulldan
gulldan requested a review from a team as a code owner November 5, 2026 10:28
@codecov

codecov Bot commented Nov 5, 2026 •

Copy link
Copy Markdown

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!

@muscariello

Copy link
Copy Markdown
Member

this needs fixing @gulldan

@gulldan
gulldan force-pushed the fix/empty-part-rejected branch from 1cc476f to c1d8f3e Compare November 7, 2026 06:04
@gulldan

gulldan commented Nov 7, 2026

Copy link
Copy Markdown
Contributor Author

Rebased on main 505dbad as one commit (c1d8f3e): the conflict was in a2a-grpc/tests/e2e.rs, where #508 added a test at the same place as the new grpc_server_rejects_part_without_content; both are kept, nothing else changed. CI mirror: 965 tests pass; patch coverage 126 lines, 0 uncovered.

@muscariello muscariello left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The fix is right: a part with no content is rejected at conversion, as the native Part deserializer already does. CI is green. I'd address 1–3 before merging; the rest are suggestions.

1. A bad response is reported as INVALID_PARAMS on gRPC and SLIM RPC. The gRPC client (client.rs#L90) and the SLIM RPC client (L101, L218, L233, L250, L262, L282) return the error as is when the server's response has a part without content. The caller's request was fine, and the JSON-RPC client already maps the same failure to A2AError::internal (jsonrpc.rs#L133, #L387). Anything that branches on INVALID_PARAMS (a gateway returning 400, a retry policy) now blames the caller, and the code depends on the transport. Wrapping it as internal on the client side keeps it consistent.

2. This is a breaking change but is marked as a fix. About 12 public pbconv::from_proto_* signatures change to Result, and ProtoJsonPayloadError gains a variant (L22) without #[non_exhaustive]. We mark these fix(a2a-pb)!: (6e3e032, a7bb51e, e488557), and the release changelog relies on it. The title is fix(pb):; please make it fix(a2a-pb)!: and add a BREAKING CHANGE: footer.

3. Tests cover one path. Only the gRPC server is tested over a transport. Not covered: the SLIM RPC server (request? and the streaming map_err), JSON-RPC SendStreamingMessage (jsonrpc.rs#L233), REST message:stream (rest.rs#L266), a part inside a task's history, an artifact or a status-update message, and the client-side rejection in gRPC and SLIM RPC.

Suggestions

  1. One part without content now fails a whole task (from_proto_task) or a whole list_tasks page (L582), so a client reading from a lenient peer gets nothing. Strict is right for requests; for responses consider skipping and reporting the bad task.
  2. A request with no message still becomes an empty user message (L512) and reaches the executor, so {"message": {"parts": [{}]}} is rejected but {} is not. You note this in the description; it leaves the goal half met. Task.status and the update event's artifact have the same silent default.
  3. A Part::data holding JSON null serializes as {"data": null}, which the decoder now reads as an unset oneof, so a part our own server can emit is rejected by our own client. Worth distinguishing an explicit null from an absent oneof, or documenting the limit.
  4. register_collaborate now drops a message with an invalid part silently (L190); a log line would help.
  5. register_unary_unary passes the fallible decode through ReqNative (L218) and unwraps it in one closure (L43), while the streaming handler maps the error before dispatch. Letting DecodeReq return a Result would handle both the same way. impl_protojson_payload_fallible! (L115) also duplicates impl_protojson_payload! apart from one call, and ListTasksResponse repeats it by hand.
  6. "part content is required" names no part, and the REST FieldViolation.field is empty (rest.rs#L658). Adding parts[i] via enumerate() makes the 400/-32602 actionable on large messages.

@gulldan
gulldan force-pushed the fix/empty-part-rejected branch from d1f1320 to 057f8d4 Compare November 10, 2026 18:24
@gulldan gulldan changed the title fix(pb): reject a Part with no content fix(a2a-pb)!: reject a part with no content and a request with no message Nov 10, 2026
@gulldan

gulldan commented Nov 10, 2026

Copy link
Copy Markdown
Contributor Author

Thanks for the review. 1–3 are in, and so are 5 (for the request), 6, 7, 8 and 9. I left 4 and the second half of 5 as they are and ask about them at the end. One commit, rebased on main 5a25b04; the description is rewritten to match.

1. A bad response is INTERNAL_ERROR on every transport. The cause was that pbconv returned an A2AError with the code already chosen, so a bare ? in a client compiled and blamed the caller. The converters now return Result<_, FieldViolation> (the existing a2a::FieldViolation), which is not an A2AError and has no From impl: a server maps it with pbconv::invalid_request, a client with pbconv::invalid_response, and a new call site cannot skip the choice. Every conversion site in both clients uses invalid_response (six in gRPC, seven in SLIM RPC, collaborate included).

2. Breaking change. The title is fix(a2a-pb)!: and the commit has a BREAKING CHANGE: footer with the changed signatures, the new ProtoJsonPayloadError::Invalid(FieldViolation) variant and the request without message. I did not add #[non_exhaustive] to the enum; say if you want it while the break is open.

3. Tests. Each path you listed has one: the SLIM RPC server over a raw channel (unary and streaming), JSON-RPC SendStreamingMessage, REST message:stream, a part inside a task's history, an artifact and a status message (and the ListTasks, SendMessageResponse and StreamResponse wrappers), and the client side of gRPC and SLIM RPC against a peer whose responses carry such a part. The list with names is in the description.

5. message is required. {} is rejected like {"message": {"parts": [{}]}}, with message: is required. The field is REQUIRED in a2a.proto and a2a-go refuses it (a2apb/v1/pbconv/from_proto.go:44-46 at ea739de).

6. {"data": null} is a data part. For google.protobuf.Value JSON null is a value, and protobuf-go sets the field (encoding/protojson/decode.go:219-224). build.rs patches that one arm of the generated deserializer. Worth knowing: on main this body silently became an empty text part, and {"text": "x", "data": null} was read as text because from_value visits members in key order and ignored the null. That body is now a duplicate oneof member, as in protobuf-go (decode.go:238-242). If you would rather keep accepting it, I will drop the patch and document the limit.

7. register_collaborate logs a warning with the message id, the field and the reason. That adds tracing to a2a-slimrpc.

8. DecodeReq returns Result<_, FieldViolation> and both handlers map it through one invalid_request. impl_protojson_payload! is one macro now (a path for an infallible converter, |value| expr for a fallible one, optional trait items in braces); the two variants and the hand-written ListTasksResponse impl are gone.

9. The violation carries the JSON path, e.g. message.parts[1] or tasks[1].history[0].parts[0]. REST puts it in FieldViolation.field; JSON-RPC, gRPC and SLIM RPC have it in the message.

4 and the rest of 5: how lenient should a client be with a response? I kept responses strict and left the defaults for Task.status, the status update's status and the artifact update's artifact, because these are one decision and I would rather it be yours:

  • Strict is what a2a-go does: a bad part fails the task and a bad task fails ListTasks (from_proto.go:275-281), and a missing status is an error (:434-437). A missing artifact is not (:457-460).
  • The error is now INTERNAL_ERROR and names the element (tasks[3].history[0].parts[1]), so a caller sees which task a lenient peer got wrong.
  • Skipping needs choices I did not want to make in this PR: drop the part, the message or the task; what pageSize and totalSize mean on a page with a task missing; and where the report goes, since Transport returns only the value and the rest is a log line.

If you want lenient reads, or status and artifact rejected like message, tell me which and whether here or as a follow-up.

Mirror of ci.yml: 984 tests pass; patch coverage 341 lines, 0 missed. On main the nine new tests that compile against it fail.

@muscariello muscariello left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks for the update. The three items from my earlier review are in: a bad response is INTERNAL_ERROR on every transport, the title and footer mark the break, and each path I listed has a test. Making the server choose invalid_request and the client invalid_response is a good shape. CI is green and a trial merge against current main has no conflicts. I'd settle 1–3 before merging; the rest are suggestions.

1. Null handling depends on key order. I probed protojson_conv::from_value::<SendMessageRequest>, the path the JSON-RPC and REST servers use, on 5a25b04 and on this head:

body 5a25b04 this head
{"text":"x","data":null} text duplicate field text
{"url":"http://a","text":null,"raw":null,"data":null} url duplicate field raw
{"text":"x","raw":null} text text

The first is the change the description lists, and both new rejections agree with protobuf-go (a null Value sets the oneof), so this is a compatibility note, not a conformance bug. What I would look at is the cause: the generated oneof arms run the duplicate check before they read the value, so {"text":"x","raw":null} is accepted by from_value (sorted keys put raw first) but rejected by from_str (duplicate field raw), on main and here, while protobuf-go accepts it in either order. The data patch carries the same order dependence to data, and a preserve_order feature enabled anywhere in a dependent's build changes the from_value order as well. Patching the arms to skip a null before the duplicate check, and keeping only data: null as a value, would make acceptance order-independent. Or drop the patch and document the limit, as you offered. Either way a test that pins {"text":"x","data":null} in both key orders and through from_str is missing; the only null test is the round trip of a lone {"data": null} (L355).

2. Rebase so CI runs on Rust 1.100. The base 5a25b04 predates the 1.100 break and the fix for it (#553), so the 22 green checks ran on 1.99.1. One rebase, then the Build and test jobs show whether anything else is hiding.

3. #[non_exhaustive] on ProtoJsonPayloadError (L18). You asked whether to; the release is already breaking, so now is free and the next variant is not another break.

Suggestions

  1. Required-field enforcement is half done. {"message": {}} still converts to a user message with an empty id, an unspecified role and no parts (test_send_message_request_minimal asserts it), and all three are REQUIRED in a2a.proto (L563). An unset status or artifact still defaults silently (L878). Fine as a follow-up if it is tracked.
  2. The new register_collaborate warning logs the peer-chosen message_id with %, uncapped, once per message (L193). ? escapes control characters, and a length cap bounds the line. Undecodable bytes and stream errors at L187 are still dropped without a log, which the description reads as covered.
  3. slimrpc_collaborate_drops_a_message_with_a_part_without_content waits a fixed 200 ms and 300 ms (L1231). Polling received with a timeout avoids a flaky run on a loaded runner, and the test does not assert the warning.
  4. One bad part gives three messages: the JSON-RPC client says failed to deserialize result: …, the REST client failed to deserialize response as ProtoJSON: …, gRPC and SLIM RPC invalid response: …. The doc on invalid_response says it matches the ProtoJSON clients, which holds for the code only.
  5. Boilerplate in a2a-slimrpc/src/server.rs: nine |request| Ok(pbconv::from_proto_…(request)) closures only to fit the new signature, and a private invalid_request that shares its name with pbconv::invalid_request but returns an RpcError. The gRPC server also repeats the same map_err twice (L83, L103).

I checked the probes in item 1 on a local checkout of this head with temporary tests, since removed. Empty-valued parts (text(""), raw([]), data(0) and so on) round-trip through both ProtoJSON and protobuf, so the new strictness does not reject anything a native Part can produce.

…sage

`Part.content` is a required oneof and `SendMessageRequest.message` a
REQUIRED field in a2a.proto, but the conversion from proto turned a part
that carries no content into an empty text part and a request without a
message into an empty user message, so both reached the executor. a2a-go
refuses both at conversion, and the native `Part` deserializer refuses
the first.

The converters in `pbconv` that can meet such a field now return
`Result<_, FieldViolation>`. The violation names the field by its JSON
path from the converted message (`message.parts[0]`,
`tasks[1].history[0].parts[2]`) and is not an `A2AError`, because what it
means depends on the reader:

- a server that finds it in a request answers `pbconv::invalid_request`:
  INVALID_PARAMS over JSON-RPC, 400 with the field in `BadRequest` over
  HTTP+JSON, INVALID_ARGUMENT over gRPC and SLIM RPC;
- a client that finds it in a response reports `pbconv::invalid_response`:
  INTERNAL_ERROR, as the JSON-RPC and HTTP+JSON clients already report a
  response they cannot decode. The gRPC and SLIM RPC clients returned the
  conversion error as it was, which blamed the caller's request.

`{"data": null}` is a part whose content is JSON null, as
`google.protobuf.Value` defines it and protobuf-go reads it, not a part
without content: the generated ProtoJSON deserializer read it as an unset
oneof, so a part this server can send was rejected by its own client.

A null member of any other oneof is not set, wherever it stands among the
keys. The generated deserializer checked for a duplicate before it read
the value, so `{"text": "x", "raw": null}` parsed or failed with the key
order, which differs between `from_str` and `from_value`. `build.rs` makes
every oneof arm read first; the members come from the descriptor and a
miss fails the build.

A `Collaborate` item a listen-only member cannot deliver is dropped with
a warning instead of silently. The reason is escaped and capped, because
the peer chooses the message id.

BREAKING CHANGE: in `a2a_pb::pbconv`, `from_proto_part`,
`from_proto_message`, `from_proto_task_status`, `from_proto_artifact`,
`from_proto_task`, `from_proto_send_message_request`,
`from_proto_list_tasks_response`, `from_proto_task_status_update_event`
and `from_proto_task_artifact_update_event` return
`Result<T, FieldViolation>` instead of `T`, and
`from_proto_send_message_response` and `from_proto_stream_response`
return `Result<Option<T>, FieldViolation>` instead of `Option<T>`.
`ProtoJsonPayloadError` gains the variant `Invalid(FieldViolation)` and
is `#[non_exhaustive]`, so a match on it needs a wildcard arm. A
`SendMessageRequest` without `message` is rejected instead of becoming an
empty user message.

Co-Authored-By: Claude Mythos 5.2 <noreply@anthropic.com>
Signed-off-by: gulldan <5641375+gulldan@users.noreply.github.com>
@gulldan

gulldan commented Nov 19, 2026

Copy link
Copy Markdown
Contributor Author

Thanks. 1–3 are in, and so are 5–8. 4 is left for a follow-up; where it is tracked is below. It is one commit on main e9b00bc (your merge commit is folded into the rebase), so the checks run on Rust 1.100.

1. Null handling no longer depends on key order. The cause is the one you named: the generated arm checked for a duplicate before it read the value. build.rs now rewrites every oneof arm to read first and to check only when the member is not null. That is 19 arms: Part (3), SecurityScheme (5), OAuthFlows (5), SendMessageResponse (2), StreamResponse (4). The members come from the descriptor and the build fails if the number of patched arms differs from it, so a pbjson upgrade cannot bring the order dependence back silently. A google.protobuf.Value member is left out, because null is its value: data: null still sets the oneof.

Your probes and their reverse orders, each through from_str and from_value:

part result
{"text":"x","raw":null}, {"raw":null,"text":"x"} text
{"url":null,"text":"x","raw":null} text
{"text":"x","data":null}, {"data":null,"text":"x"} duplicate field
{"data":null} data part

That is protobuf-go's rule (decode.go:219-224, then :238-242). Acceptance no longer depends on the order, so preserve_order cannot change it; I did not build with that feature to confirm. Tests: a_null_part_member_is_unset_in_any_key_order, a_null_data_member_next_to_another_member_is_rejected_in_any_key_order and, for a second oneof, a_null_stream_response_member_is_unset. The first and the third fail with the new patch disabled.

2. Rebased on e9b00bc. I ran the ci.yml steps on Rust 1.100.0 before pushing: 991 tests pass.

3. #[non_exhaustive] is on ProtoJsonPayloadError and in the BREAKING CHANGE: footer.

4. Required fields: follow-up. I would rather not widen this PR a third time. #561 already tracks the Message half (an empty messageId, empty parts), and this PR closes its first case, a request with no message. For that follow-up: a2a-go rejects an empty id and an unspecified role but accepts empty parts (a2apb/v1/pbconv/from_proto.go:71-76 at ea739de), so parts needs your call. The unset status and artifact were not tracked anywhere, so I opened #563 for them.

5. Collaborate log. There is one warning for anything the member cannot deliver: a stream error, bytes that do not decode, or a message that fails conversion. The reason is written with ? and cut at 256 characters. The conversion error comes first and the message id last, so a long id cannot push the reason out of the line. 256 is my choice (room for a field path and a UUID), not a value taken from elsewhere; say if the project has one. It is still one line per dropped item: I did not add rate limiting.

6. Test. slimrpc_collaborate_drops_a_message_it_cannot_deliver polls received with a 5 s timeout instead of sleeping 300 ms. It also sends an undecodable payload and asserts both warnings from a captured log, including that a newline in the message id arrives escaped. The stream-error case has no end-to-end trigger, so collaborate_message_says_why_an_item_is_dropped covers it as a unit test. This adds tracing-subscriber, already in the workspace, as a dev-dependency. The 200 ms wait for the server to start is still there, as in the two Collaborate tests next to it: slim_rpc::Server 3.4 exposes serve and shutdown and nothing to poll for readiness.

7. The doc now says that only the code is shared and each client words its own message. I left the three messages alone: aligning them changes a2a-client's text, which this PR does not touch.

8. register_unary_unary is back to its signature on main and the nine closures are gone. SendMessage passes the conversion result through as the native request, and the call rejects a violation (request.map_err(pbconv::invalid_request)?). The private invalid_request is gone too. The gRPC server has one send_message_request helper for both handlers.

Patch coverage as coverage.yml builds it (measured on 1.99.1): 374 coverable added lines, 0 missed. On main e9b00bc the 12 new or changed tests that compile against it fail.

@muscariello muscariello left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

All of it is in or tracked: the required-field follow-up is #561 and #563. I checked the null cases in both key orders through from_str and from_value, also with serde_json's preserve_order on, and ran the Collaborate tests repeatedly; CI is green on the rebased head.

@muscariello
muscariello added this pull request to the merge queue Nov 20, 2026
Merged via the queue into a2aproject:main with commit 32b3f4d Nov 20, 2026
22 checks passed
@github-actions github-actions Bot mentioned this pull request Nov 20, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

[Bug]: a Part with no content is accepted as an empty text part

2 participants