perf(a2a): bound task route capture parsing to O(n) with a balance scan

[mkoushni]

Summary

try_capture_from_buffer in filters/src/agentic/a2a/mod.rs (the
non-streaming A2A task-route capture path) runs on every
on_response_body chunk while capture is enabled. Each invocation
hex-decodes the entire accumulated buffer and attempts a full
serde_json::from_slice parse over it, discarding the result whenever
the JSON is still incomplete. For a body delivered in k chunks, this
repeats full decode+parse work over an ever-growing buffer on every
chunk, producing O(n²) total work in response body bytes rather than
O(n).

Parsing only at end_of_stream is not viable: Pingora may not deliver
a separate EOS callback after the final data chunk, so the route must
be captured opportunistically as soon as the JSON body is complete.

Fix

Add a JsonBalanceState scanner that tracks {}/[] depth
incrementally, skipping bytes inside string literals (respecting
backslash escapes). It is updated only with the bytes in each new
chunk and persisted via filter_metadata between calls, so total scan
work across all chunks is O(n) rather than O(buffer²):

fn scan_json_balance(state: &mut JsonBalanceState, chunk: &[u8]) {
    if state.is_complete() {
        return;
    }
    for &byte in chunk {
        // track in_string / escaped / depth incrementally
        // ...
    }
}

The expensive hex-decode + JSON parse in try_capture_from_buffer is
now only attempted once the scanner reports the buffer holds a
balanced top-level value, or at end_of_stream as before:

if balance.is_complete() || end_of_stream {
    try_capture_from_buffer(ctx, store, &self.config.task_routing, end_of_stream);
}

This preserves the existing opportunistic, pre-EOS capture guarantee
while bounding total per-response scan work to O(n). clear_capture_metadata
is extended to also clear the new scanner scratch keys, and reused in
accumulate_response_hex's overflow path to remove the previous
duplicated inline .remove() calls.

Scoped to the non-streaming capture path only — the SSE capture path
(process_sse_response_chunk) already scans incrementally and is
unaffected. No change to the hex-encoding scheme used for multibyte
UTF-8 chunk-boundary safety.

Implements the proposal in #396.

Test plan

• Unit tests for JsonBalanceState/scan_json_balance: minimal
  object, no-object-seen, nested objects/arrays, structural bytes
  inside strings, escaped quotes inside strings, no-op once complete,
  byte-by-byte accumulation matching a single-shot scan
• New regression test many_single_byte_chunks_still_capture_route_before_eos
  covering capture before end_of_stream when a body arrives as many
  single-byte chunks
• Existing A2A response-body unit test coverage passes unmodified
• make test — full workspace suite passes (0 failed)
• make lint — clippy, nightly fmt-check, separator/filter-docs
  lints all pass

Fixes #353

[mkoushni]

@aslakknutsen the doc proposal for this fix is #396

[praxis-bot]

Review: perf(a2a): bound task route capture parsing to O(n) with a balance scan

Well-structured performance fix. The JsonBalanceState scanner correctly reduces total per-response work from O(n²) to O(n) by scanning only new bytes in each chunk. The bracket-type matching (stack of expected closers rather than a simple depth counter), string-literal tracking, and escape handling are all correct. The is_done() early-exit guard ensures the O(n) bound holds.

The refactoring of try_capture_from_buffer to unconditionally clear capture state is a sound simplification — the doc comment correctly justifies why a failed parse after a balanced scan is always terminal.

The deduplication of the inline .remove() calls in accumulate_response_hex’s overflow path into clear_capture_metadata is a clean win.

Findings

Severity	Count
Medium	2

Details in inline comments.