ag-ui C++ SDK EUVD-2026-80708

Requires an application that uses the ag-ui C++ community SDK's SseParser to consume a Server-Sent Events stream, and an attacker able to control or influence that stream source (per the PR:L privilege). The specific trigger is a single SSE event whose data is never terminated by a blank line, fed as many small chunks so that consumed bytes are erased from m_buffer into the per-event accumulator m_currentData, which was excluded from the kMaxBufferSize check. Limiting factors: impact is availability-only (memory exhaustion of the parsing process, VA:L), it affects only the C++ SDK (not other-language SDKs), it needs the low-privilege/authorized stream position rather than anonymous access, and patched builds throw SseBufferExceededError before exhaustion.

This is a genuine but low-to-moderate priority denial-of-service issue, not a high-impact flaw. The CVSS 4.0 base score of 5.3 (AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:L) reflects reality well: the only impact is availability, and it is rated LOW (VA:L), meaning memory pressure/degradation of the application embedding the C++ SDK rather than confidentiality or integrity loss. There is no EPSS score, no CISA KEV listing, and no public exploit code identified at time of analysis, so this reflects a responsibly-disclosed bug (VulDB, GitHub issue #2440) with a merged fix rather than any observed exploitation. The exploitation-status signal is E:X (not defined) in the vector, consistent with 'no public exploit identified.' One nuance to verify: this is a client-side SSE stream parser, so the 'remote attacker' must control or influence the server-sent-events source the SDK consumes; the vendor-assigned PR:L suggests some privileged/authorized position rather than a fully anonymous internet attacker. The source-code diff strongly corroborates the mechanism (per-event accumulator m_currentData excluded from the buffer-size guard), so the technical claim is well-supported. Overall: real bug, real patch, but low real-world urgency given niche deployment and availability-only impact.

An attacker who controls or can inject into the Server-Sent Events stream that an application's ag-ui C++ SDK consumes sends a single SSE event whose data field is never terminated by a blank line, delivered as many small chunks. Because each chunk is drained from m_buffer into the per-event accumulator, the buffer-size limit never trips and memory grows without bound until the host process is exhausted. No public exploit code exists; the attack is simple (AC:L) but requires an attacker-influenced stream source (PR:L).