Skip to main content

ag-ui EUVDEUVD-2026-114860

| CVE-2026-120234 LOW
Uncontrolled Resource Consumption (CWE-400)
2026-11-01 VulDB GHSA-vf2p-gqc3-r3jh
2.1
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Lure or configure client to attacker-influenced HTTP endpoint
  2. Exploit
    Return oversized non-success error body
  3. Execution
    Client reads full body via e.text unbounded
  4. Impact
    Memory/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.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

ag-ui 0.0.36
ag-ui 0.0.43
ag-ui 0.0.27
ag-ui 0.0.47
ag-ui 0.0.14
ag-ui 0.0.25
ag-ui 0.0.53
ag-ui 0.0.33
ag-ui 0.0.51
ag-ui 0.0.55
ag-ui 0.0.9
ag-ui 0.0.4
ag-ui 0.0.5
ag-ui 0.0.30
ag-ui 0.0.10
ag-ui 0.0.13
ag-ui 0.0.1
ag-ui 0.0.32
ag-ui 0.0.15
ag-ui 0.0.37
ag-ui 0.0.31
ag-ui 0.0.2
ag-ui 0.0.3
ag-ui 0.0.24
ag-ui 0.0.7
ag-ui 0.0.20
ag-ui 0.0.22
ag-ui 0.0.41
ag-ui 0.0.12
ag-ui 0.0.6
ag-ui 0.0.34
ag-ui 0.0.28
ag-ui 0.0.52
ag-ui 0.0.48
ag-ui 0.0.40
ag-ui 0.0.23
ag-ui 0.0.42
ag-ui 0.0.44
ag-ui 0.0.18
ag-ui 0.0.29
ag-ui 0.0.45
ag-ui 0.0.57
ag-ui 0.0.39
ag-ui 0.0.19
ag-ui 0.0.21
ag-ui 0.0.8
ag-ui 0.0.58
ag-ui 0.0.38
ag-ui 0.0.35
ag-ui 0.0.26
ag-ui 0.0.56
ag-ui 0.0.54
ag-ui 0.0.11
ag-ui 0.0.50
ag-ui 0.0.16
ag-ui 0.0.49
ag-ui 0.0.17
ag-ui 0.0.46

Affected Packages

euvd ag_ui no fix

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

Vendor (VulDB) PRIMARY 2.1 MEDIUM
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
vuln.today AI 5.3 MEDIUM

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (VulDB).

CVSS VectorVendor: VulDB

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

3
Severity Changed
Nov 01, 2026 - 16:22 NVD
MEDIUM LOW
CVSS changed
Nov 01, 2026 - 16:22 NVD
5.3 (MEDIUM) 2.1 (LOW)
CVE Published
Nov 01, 2026 - 15:30 cve.org
MEDIUM 5.3

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

EPSS Score
0.3%
Top 77% exploitable
Prevalence
Low
niche, early-stage agent-UI protocol SDK; limited production footprint
Exploit
POC
Public exploit code exists
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity LOW
CISA KEV No
Public POC Yes
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Low

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +10
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in Ag Ui

View all
CVE-2026-120233 MEDIUM POC
5.5 Nov 01

Cross-origin information disclosure in the ag-ui TypeScript client: HttpAgent builds the POST run request with the conve

CVE-2026-92362 MEDIUM
6.9 Sep 16

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

CVE-2026-120237 LOW POC
2.1 Nov 01

Denial of service in the ag-ui TypeScript client SDK (versions up to and including 0.0.58) allows a party that controls

CVE-2026-120235 LOW POC
2.1 Nov 01

Denial of service in the ag-ui TypeScript client SDK (versions up to 0.0.58) where the SSE/protobuf stream parser fails

CVE-2026-120236 LOW POC
2.1 Nov 01

Improper input validation in the AG-UI protocol SDK transport decoder path affects ag-ui versions up to and including 0.

CVE-2026-101099 MEDIUM
5.3 Sep 28

Unbounded buffering in the Server-Sent Events parser of the AG-UI Community SDK (Kotlin/Java) lets a malicious or man-in

CVE-2026-92361 MEDIUM
5.3 Sep 16

Memory exhaustion in the AG-UI Go community SDK's SSE client allows a remote attacker who controls or can intercept an S

CVE-2026-92360 MEDIUM
5.3 Sep 16

Origin validation errors in the AG-UI TypeScript client SDK (ag-ui 1.0) allow remote, low-privileged attackers who can i

CVE-2026-101101 MEDIUM
5.3 Sep 28

Uncaught exception handling in the A2A middleware of ag-ui-protocol ag-ui (all versions up to 2026-09-07) allows an atta

CVE-2026-101100 MEDIUM
5.3 Sep 28

Incomplete cleanup of per-run state in the ag-ui TypeScript client SDK's FilterToolCallsMiddleware allows disallowed too

CVE-2026-101098 MEDIUM
5.3 Sep 28

Unbounded request-body reads in the ag-ui Java community server SDK (JdkAgentHttpHandler, used by applications that inst

CVE-2026-92363 MEDIUM
5.3 Sep 16

Unbounded memory growth in the ag-ui (AG-UI protocol) C++ community SDK's Server-Sent Events parser lets an attacker who

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy