Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLure or configure client to attacker-influenced HTTP endpoint
-
ExploitReturn oversized non-success error body
-
ExecutionClient reads full body via e.text unbounded
-
ImpactMemory/resource exhaustion in client process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The flaw is in the ag-ui TypeScript client's HTTP Transport error path (runHttpRequest / the e.text error-body read), which, per the PR diff, previously read a non-success HTTP response body in full with no size limit. Exploitation requires that the client connect to a server the attacker controls, has compromised, or can MITM, and that this server return a non-success status with an oversized or unbounded response body, which the client then buffers entirely. Limiting factors: the impact is confined to availability (memory/resource consumption) of a single client process, with no data disclosure or modification; the victim must initiate a request to an attacker-influenced endpoint, so a purely passive target is not affected. Affected versions are ag-ui up to 0.0.58. |
| Impact | This is a medium-severity, availability-only issue, not a top-priority emergency. The CVSS 4.0 vector (5.3) shows network reach and low complexity but only limited availability impact (VA:L) with no confidentiality or integrity effect (VC:N/VI:N), consistent with the CWE-400 resource-consumption nature of the flaw. The PR diff confirms the mechanism: the TypeScript client's HTTP error path read an entire non-success response body into memory with no size bound, so a malicious or compromised server can return an oversized body and exhaust client memory. Exploit maturity is Proof-of-Concept (E:P) and the input states the PoC is a reference only, not verified working exploit code, so this is below confirmed active exploitation. No EPSS score was provided and the vulnerability is not in CISA KEV, so there is no signal of widespread or confirmed in-the-wild use. The input CVSS 4.0 vector sets PR:L, but this is a client-side flaw triggered by a server response - no privileges on the victim client are actually required - so PR:N is more defensible; verify the intended threat model with the vendor. The vuln.today decision label is 'this_month', aligning with a plan-and-patch cadence rather than immediate action. |
| Exploit ScenarioDerived | An ag-ui TypeScript client issues an HTTP request to an agent backend the attacker controls or has compromised (or can MITM on an unprotected channel). The server responds with a non-success status and a very large or effectively unbounded error body; the client buffers the whole body in memory via the error-path text read, consuming resources and potentially exhausting memory. A public PoC reference exists (GitHub issue #2521) but is not verified as working exploit code; the low attack complexity means a single oversized chunk is enough to trigger the condition. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 01, 2026
Resource exhaustion in the ag-ui Protocol TypeScript client SDK (versions up to and including 0.0.58) allows a hostile or compromised HTTP endpoint to force the client process to buffer an unbounded error-response body, degrading availability of that client. The flaw sits in the HTTP Transport error path of runHttpRequest, which read non-success response bodies in full with no size limit, so an attacker who controls, has compromised, or can man-in-the-middle the server the client talks to can return an oversized or never-ending body on a non-2xx status and exhaust process memory. Impact is availability-only for the initiating client - no data disclosure or modification - and a public PoC reference exists (GitHub issue 2521); it is not verified as working exploit code. An upstream fix is proposed in pull request 2698 but is not yet merged or released, and the current assessment rates this as a medium-severity, availability-only issue rather than a top-priority emergency.
RemediationAI
Vendor-released patch is not yet confirmed: the fix exists only as upstream pull request 2698 (adding a 64 KiB response-body byte budget, reader cancellation on limit, and a 4,096-character cap on the error message detail), which awaits acceptance, so there is no tagged release to pin to and operators should track https://github.com/ag-ui-protocol/ag-ui/pull/2698 and upgrade to the first published version containing it rather than assuming 0.0.58 is fixed. In the interim, the practical control is to constrain which endpoints the client will talk to: point it only at trusted, controlled agent servers and avoid user- or config-supplied base URLs, since the attack requires the client to request a non-success response from an attacker-influenced server. Where traffic must cross less-trusted networks, front the client with an egress/reverse proxy that enforces a hard maximum response body size and terminates over-long responses, accepting the trade-off that legitimate large error payloads will be truncated and the proxy adds a hop; TLS pinning to the legitimate server also blocks the machine-in-the-middle variant but does not help against a genuinely compromised or hostile endpoint. Memory or process-level limits on the client runtime act as a last-resort blast-radius control at the cost of killing the client process on overflow.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
ag-ui is an agent-user-interaction protocol with a TypeScript client SDK under sdks/typescript/packages/client, where the HTTP Transport layer issues requests via runHttpRequest and, on a non-success status, reads the response body to build a diagnostic error (status, payload, message). Per the PR 2698 diff, the previous implementation consumed the error body with a plain Response.text()-style full read, meaning the entire body was accumulated in memory before UTF-8 decoding and, for JSON content types, parsing into error.payload. This is CWE-400 (Uncontrolled Resource Consumption): the size of an input is not bounded by any policy, so the amount of memory retained is dictated entirely by the remote peer. The proposed fix introduces a 64 KiB byte budget over the streamed body, cancels the reader once the budget is reached rather than waiting for another chunk or EOF, drops an incomplete UTF-8 character at the boundary, appends a ' [truncated]' marker, keeps oversized JSON as a marked string instead of parsing a partial document, and separately caps the body detail embedded in error.message at 4,096 characters. Because the trigger is a client-initiated request to an attacker-influenced endpoint, the deployment model matters: clients pinned to trusted, controlled agent servers are largely unaffected, while clients that follow user- or config-supplied URLs to third-party or untrusted servers are exposed.
Know when Ag Ui gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N/E:P
Remote and low-complexity against the client, no privileges on the victim client are required (the attacker is the responding server), and impact is limited availability only with no confidentiality or integrity effect.
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
Lifecycle Timeline
3DescriptionCVE.org
A weakness has been identified in ag-ui-protocol ag-ui up to 0.0.58. This impacts the function e.text of the component HTTP Transport. Executing a manipulation can lead to resource consumption. The attack can be launched remotely. The exploit has been made available to the public and could be used for attacks. The pull request to fix this issue awaits acceptance.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Cross-origin information disclosure in the ag-ui TypeScript client: HttpAgent builds the POST run request with the conve
Unbounded memory growth in the AG-UI Rust client's SSE frame parser (crates/ag-ui-client/src/sse.rs, shipped in the ag-u
Denial of service in the ag-ui TypeScript client SDK (versions up to and including 0.0.58) allows a party that controls
Denial of service in the ag-ui TypeScript client SDK (versions up to 0.0.58) where the SSE/protobuf stream parser fails
Improper input validation in the AG-UI protocol SDK transport decoder path affects ag-ui versions up to and including 0.
Unbounded buffering in the Server-Sent Events parser of the AG-UI Community SDK (Kotlin/Java) lets a malicious or man-in
Memory exhaustion in the AG-UI Go community SDK's SSE client allows a remote attacker who controls or can intercept an S
Origin validation errors in the AG-UI TypeScript client SDK (ag-ui 1.0) allow remote, low-privileged attackers who can i
Uncaught exception handling in the A2A middleware of ag-ui-protocol ag-ui (all versions up to 2026-09-07) allows an atta
Incomplete cleanup of per-run state in the ag-ui TypeScript client SDK's FilterToolCallsMiddleware allows disallowed too
Unbounded request-body reads in the ag-ui Java community server SDK (JdkAgentHttpHandler, used by applications that inst
Unbounded memory growth in the ag-ui (AG-UI protocol) C++ community SDK's Server-Sent Events parser lets an attacker who
EUVD-2026-114860
GHSA-vf2p-gqc3-r3jh
NVD
CVE.org
EPSS
VulDB
Exploit-DB