diff --git a/docs-site/src/content/docs/guides/providers.md b/docs-site/src/content/docs/guides/providers.md
index 7af39e32b3..8d6814db2c 100644
--- a/docs-site/src/content/docs/guides/providers.md
+++ b/docs-site/src/content/docs/guides/providers.md
@@ -116,7 +116,7 @@ ocx logout <provider>
 | `nous` | `openai-chat` | `https://inference-api.nousresearch.com/v1` | Nous Research subscription gateway (same backend Hermes Agent uses). Device-grant login against `portal.nousresearch.com`; the access token is the per-request inference JWT. Mixed paid + `:free` model catalog (`tencent/hy3:free`, `stepfun/step-3.7-flash:free`, ...) discovered live from the signed-in account. Refresh tokens are single-use and rotated on every refresh. |
 | `kiro` | `kiro` | `https://runtime.us-east-1.kiro.dev` | Initial login imports the installed, signed-in `kiro-cli` session (on Unix, install with `curl -fsSL https://cli.kiro.dev/install` &#124; `bash`; on Windows PowerShell, use `irm 'https://cli.kiro.dev/install.ps1'` &#124; `iex`; then run `kiro-cli login`). **Add account** logs `kiro-cli` out, starts a fresh browser login that switches the account used by `kiro-cli`, and stores account-scoped profile metadata. Existing OpenCodex accounts are preserved, and cancellation or failure restores the previous `kiro-cli` session. |
 | `google-antigravity` | `google` | `https://daily-cloudcode-pa.googleapis.com` | Google OAuth over the Cloud Code Assist wire. Live discovery uses CCA's authenticated `v1internal:fetchAvailableModels` endpoint and publishes the agent models available to the signed-in account; the maintained catalog remains the fallback. |
-| `cursor` | `cursor` | `https://api2.cursor.sh` | Experimental PKCE login, live HTTP/2 transport, and account-filtered model discovery. |
+| `cursor` | `cursor` | `https://api2.cursor.sh` | Experimental PKCE login, live HTTP/2 transport with an opt-in HTTP/1.1 compatibility path, and account-filtered model discovery. |
 | `github-copilot` | `openai-chat` | `https://api.githubcopilot.com` | Experimental. GitHub device flow + `copilot_internal` exchange (VS Code OAuth client). Requires an active Copilot subscription; not an official third-party API. |
 
 After a terminal Nous refresh failure, run `ocx login nous` to reauthenticate.
@@ -511,7 +511,9 @@ provider-wide adapter. To opt a model without a built-in default (for example
 Cursor is tracked separately as an experimental adapter. `adapter: "cursor"` appears in `ocx init`
 and the dashboard Add Provider picker as an experimental local config entry with Cursor's static
 fallback model catalog metadata. When a Cursor access token is configured, opencodex uses Cursor's
-live HTTP/2 transport. Its bundled fallback seed includes `gpt-5.6-sol` / `terra` / `luna` (1M context),
+live HTTP/2 transport. Set `upstreamHttpVersion: "http1.1"` when a proxy requires Cursor's HTTP/1.1
+compatibility path; the setting covers both inference and live model discovery and is exposed at
+**Providers → Cursor → Settings → Cursor transport**. Its bundled fallback seed includes `gpt-5.6-sol` / `terra` / `luna` (1M context),
 regular/Fast rows for Grok 4.5 and 4.6 (500K), and `kimi-k3` (262K); live discovery decides which
 remain visible for the account. Grok 4.6 exposes `low` / `medium` / `high` / `xhigh` in both forms,
 while 4.5 stops at `high`. Fast requests send the matching base Grok model with separate `effort`
diff --git a/docs-site/src/content/docs/reference/adapters.md b/docs-site/src/content/docs/reference/adapters.md
index 93a1c42f63..8a9bd05c45 100644
--- a/docs-site/src/content/docs/reference/adapters.md
+++ b/docs-site/src/content/docs/reference/adapters.md
@@ -186,7 +186,10 @@ advertised effort control on those models as proof of upstream-native reasoning
 
 ## `cursor`
 
-**Targets:** Cursor's `agent.v1.AgentService/Run` over HTTP/2 Connect streaming at `api2.cursor.sh`.
+**Targets:** Cursor's `agent.v1.AgentService/Run` over HTTP/2 Connect streaming at `api2.cursor.sh`
+by default. With `upstreamHttpVersion: "http1.1"` (or `"h1"`), uses Cursor's HTTP/1.1
+compatibility pair: `agent.v1.AgentService/RunSSE` for server output and
+`aiserver.v1.BidiService/BidiAppend` for client messages.
 **Auth:** Cursor OAuth/access token from `provider.apiKey` or the forwarded authorization header.
 
 - Uses `runTurn` rather than the ordinary fetch/parse path. Requests, server events, tool arguments,
@@ -195,6 +198,8 @@ advertised effort control on those models as proof of upstream-native reasoning
 - Replays conversation state through content-addressed blobs, maps server tool calls back to Codex,
   discovers live Cursor models through the protobuf `GetUsableModels` RPC, and retries only before a
   run request is committed to the wire.
+- Honors `upstreamHttpVersion` for both live model discovery and inference. `auto`, `http2`, and `h2`
+  preserve the existing HTTP/2 transport; only `http1.1` and `h1` select compatibility mode.
 - Exposes Cursor Router as `cursor/auto` plus explicit `cursor/auto-cost`,
   `cursor/auto-balance`, and `cursor/auto-intelligence` entries. Explicit levels are encoded in
   `requested_model.parameters` while the legacy `cursor/auto` entry retains the account/team default.
diff --git a/docs-site/src/content/docs/reference/configuration/providers.md b/docs-site/src/content/docs/reference/configuration/providers.md
index 2c1d2e3eef..d467b5cb5f 100644
--- a/docs-site/src/content/docs/reference/configuration/providers.md
+++ b/docs-site/src/content/docs/reference/configuration/providers.md
@@ -67,7 +67,7 @@ differing backup and rewrites known legacy namespaced selected ids to bare ids.
 | `adapter` | `string` | One of `openai-chat`, `openai-responses`, `anthropic`, `google`, `kiro`, `cursor`, `azure-openai` (or alias `azure`). |
 | `baseUrl` | `string` | Upstream API base URL. Most built-in fixed endpoints ignore a mismatch; collision-safe key presets preserve an older same-named custom destination. |
 | `requestPacing?` | `{ enabled, requestsPerMinute?, minIntervalMs?, models? }` | Optional client-side outbound request-start pacing, separate from upstream usage, billing, and rate-limit indicators. RPM is converted to an even interval; `minIntervalMs` may impose a longer interval. Provider limits apply across all models, while `models` entries use exact upstream model IDs (for example `nvidia/llama-3.1-nemotron-ultra-253b-v1`) and can only add delay. Queue waits do not consume the upstream response-header timeout. HTTP, Responses WebSocket, and explicit adapter `fetchResponse`/`runTurn` dispatches are covered. |
-| `upstreamHttpVersion?` | `"auto" \| "http1.1" \| "h1" \| "http2" \| "h2"` | Pin the HTTP version used for upstream requests to this provider. Defaults to `auto`, which lets Bun negotiate. Set `http1.1` when a provider's HTTP/2 SSE stream stalls instead of delivering events — the symptom is a long-running streaming request that produces nothing and eventually times out. Management `POST`/`PATCH` accept `null` to clear it back to `auto`. |
+| `upstreamHttpVersion?` | `"auto" \| "http1.1" \| "h1" \| "http2" \| "h2"` | Pin the HTTP version used for upstream requests to this provider. Defaults to `auto`, which lets Bun negotiate. An explicit pin requires an HTTPS target and fails locally when it cannot be honored. Set `http1.1` when a provider's HTTP/2 SSE stream stalls instead of delivering events — the symptom is a long-running streaming request that produces nothing and eventually times out. For Cursor, `http1.1`/`h1` selects its `RunSSE` + `BidiAppend` compatibility transport for inference and also pins live model discovery. Management `POST`/`PATCH` accept `null` to clear it back to `auto`. |
 | `responsesPath?` | `string` | Relative resource path for key-auth `openai-responses` requests. It must start with `/` and contain no scheme, query, or fragment. |
 | `supportsServiceTier?` | `boolean` | Tri-state canonical Fast capability fallback. `true` publishes Fast in the catalog, satisfies service-tier routing requirements, contributes a supported fingerprint, and lets fast mode inject the provider's canonical wire value on a compatible final adapter. `false` strips the field and never injects, and exact model declarations cannot reopen it. Absent leaves the provider unclassified: fast mode does not inject or normalize a canonical caller value, and caller values obey the final wire's forwarding permission (`chatServiceTier` on Chat; passthrough on Responses). The registry classifies canonical OpenAI (`true`), DeepSeek, and Volcengine Ark (`false`); set it explicitly only for custom gateways that genuinely support tiers. |
 | `modelSupportsServiceTier?` | `Record<string, boolean>` | Exact upstream model capability overrides. Exact `true` enables canonical Fast for that model; exact `false` narrows provider defaults. An explicit provider-level `supportsServiceTier: false` remains fail-closed and cannot be reopened. Exact `true` does not authorize foreign caller-tier forwarding on Chat. Undeclared models fall back to provider-wide behavior. Management `PATCH /api/providers` merges entries and accepts `null` to clear one. |
@@ -294,6 +294,14 @@ so passthrough stays byte-for-byte identical.
 ## Cursor provider (`adapter: "cursor"`)
 
 The Cursor bridge is experimental. After `ocx login cursor`, add or edit `providers.cursor`.
+
+If a proxy cannot carry Cursor's default HTTP/2 stream, set `upstreamHttpVersion` to `"http1.1"`
+or its `"h1"` alias.
+This switches inference to Cursor's `RunSSE` + `BidiAppend` compatibility transport and uses
+HTTP/1.1 for `GetUsableModels` discovery as well. The value requires an HTTPS `baseUrl`. Leave it
+unset or use `"auto"` for the existing HTTP/2 behavior. In the dashboard choose
+**Providers → Cursor → Settings → Cursor transport**.
+
 Cursor Router's optimization ladder is exposed as separate Codex ids because the picker cannot render
 Cursor-specific model parameters:
 
@@ -330,8 +338,8 @@ Cursor server-driven local tools are disabled by default. Codex continues using
 }
 ```
 
-Set the field on `providers.cursor`, not at the top level. In the dashboard use **Providers → Cursor
-→ Edit JSON**, save, then restart. Legacy `unsafeAllowNativeLocalExec: true` equals
+Set `nativeLocalExec` on `providers.cursor`, not at the top level. In the dashboard use **Providers
+→ Cursor → Edit JSON**, save, then restart. Legacy `unsafeAllowNativeLocalExec: true` equals
 `nativeLocalExec: "on"` only when `nativeLocalExec` is unset. MCP, screen recording, and computer use
 are controlled separately by `mcpServers` and `desktopExecutor`.
 
diff --git a/docs-site/src/content/docs/zh-cn/guides/providers.md b/docs-site/src/content/docs/zh-cn/guides/providers.md
index b65ab443f3..4e924458ee 100644
--- a/docs-site/src/content/docs/zh-cn/guides/providers.md
+++ b/docs-site/src/content/docs/zh-cn/guides/providers.md
@@ -101,7 +101,7 @@ ocx logout <provider>
 | `nous` | `openai-chat` | `https://inference-api.nousresearch.com/v1` | Nous Research 订阅网关（与 Hermes Agent 使用同一后端）。通过设备授权登录 `portal.nousresearch.com`；access 令牌是每个请求的 inference JWT。付费 + `:free` 模型混合目录（`tencent/hy3:free`、`stepfun/step-3.7-flash:free` 等）会从已登录账户实时发现。Refresh 令牌是单次使用，每次刷新都会轮换。 |
 | `kiro` | `kiro` | `https://runtime.us-east-1.kiro.dev` | 首次登录会导入已安装并已登录的 Kiro CLI 会话（Unix 使用 `curl -fsSL https://cli.kiro.dev/install` &#124; `bash`；Windows PowerShell 使用 `irm 'https://cli.kiro.dev/install.ps1'` &#124; `iex`；然后运行 `kiro-cli login`）。**添加账户**会先退出 `kiro-cli`，再启动新的浏览器登录，从而切换 `kiro-cli` 自身使用的账户，并保存账户范围的配置文件元数据。现有 OpenCodex 账户会保留；如果取消或失败，则恢复之前的 `kiro-cli` 会话。 |
 | `google-antigravity` | `google` | `https://daily-cloudcode-pa.googleapis.com` | 通过 Cloud Code Assist 协议使用 Google OAuth。实时发现调用已认证的 CCA `v1internal:fetchAvailableModels` 端点，并仅发布当前登录账户可用的 agent 模型；维护中的目录仍作为回退。 |
-| `cursor` | `cursor` | `https://api2.cursor.sh` | 实验性 PKCE 登录、HTTP/2 传输和按账号筛选的模型发现。 |
+| `cursor` | `cursor` | `https://api2.cursor.sh` | 实验性 PKCE 登录、带可选 HTTP/1.1 兼容路径的 HTTP/2 传输，以及按账号筛选的模型发现。 |
 | `github-copilot` | `openai-chat` | `https://api.githubcopilot.com` | 实验性。GitHub 设备流 + `copilot_internal` 交换（VS Code OAuth 客户端）。需要有效的 Copilot 订阅；不是官方第三方 API。 |
 
 Nous refresh 发生终止性失败后，请运行 `ocx login nous` 重新认证。
@@ -365,7 +365,9 @@ adapter。若要将没有内置默认值的模型（例如 `gpt-5.4-nano`）接
 
 Cursor 作为单独的实验性 adapter 进行跟踪。`adapter: "cursor"` 会作为实验性本地配置出现在
 `ocx init` 和 dashboard Add Provider picker 中，并保存 Cursor 的静态回退模型目录 metadata。配置
-Cursor access token 后，opencodex 会使用 Cursor live HTTP/2 transport。内置回退列表包含上下文为
+Cursor access token 后，opencodex 会使用 Cursor live HTTP/2 transport。代理要求 Cursor 的
+HTTP/1.1 兼容路径时，可设置 `upstreamHttpVersion: "http1.1"`；该设置同时覆盖推理与实时模型发现，
+并可在 **Providers → Cursor → 设置 → Cursor 传输协议** 中选择。内置回退列表包含上下文为
 1M 的 `gpt-5.6-sol` / `terra` / `luna`、上下文为 500K 的 Grok 4.5/4.6 普通与 Fast 条目，以及上下文为
 262K 的 `kimi-k3`；最终显示哪些模型由账号的实时发现结果决定。Grok 4.6 的两种形式均提供
 `low` / `medium` / `high` / `xhigh`，而 4.5 最高为 `high`。Fast 请求会发送对应的 Grok 基础模型，
diff --git a/docs-site/src/content/docs/zh-cn/reference/adapters.md b/docs-site/src/content/docs/zh-cn/reference/adapters.md
index dc39d307b7..07dbfcf441 100644
--- a/docs-site/src/content/docs/zh-cn/reference/adapters.md
+++ b/docs-site/src/content/docs/zh-cn/reference/adapters.md
@@ -123,8 +123,10 @@ Kiro 的 assistant 文本本身没有可靠的回合结束标记，但终止的
 
 ## `cursor`
 
-**目标：** `api2.cursor.sh` 上采用 HTTP/2 Connect streaming 的
-`agent.v1.AgentService/Run`。
+**目标：** 默认使用 `api2.cursor.sh` 上采用 HTTP/2 Connect streaming 的
+`agent.v1.AgentService/Run`。配置 `upstreamHttpVersion: "http1.1"`（或 `"h1"`）后，改用
+Cursor 的 HTTP/1.1 兼容传输：通过 `agent.v1.AgentService/RunSSE` 接收 server output，并通过
+`aiserver.v1.BidiService/BidiAppend` 发送 client message。
 **认证：** `provider.apiKey` 或转发 authorization header 中的 Cursor OAuth/access token。
 
 - 使用 `runTurn`，而不是常规 fetch/parse 路径。请求、server event、工具参数、usage checkpoint
@@ -132,6 +134,8 @@ Kiro 的 assistant 文本本身没有可靠的回合结束标记，但终止的
   Connect message。
 - 经 content-addressed blob 重放对话状态，把 server tool call 映射回 Codex，用 protobuf
   `GetUsableModels` RPC 发现实时 Cursor 模型，并且只在 run request 尚未 commit 到 wire 前重试。
+- 模型实时发现和推理都会遵守 `upstreamHttpVersion`。`auto`、`http2` 与 `h2` 保持原有 HTTP/2
+  transport；只有 `http1.1` 与 `h1` 会选择兼容模式。
 - 保留 `cursor/grok-4.5-fast` 作为可选模型，但向 Cursor 发送规范的 `grok-4.5` 模型，并将独立的
   `effort` 和 `fast=true` 值放入 `requested_model.parameters`。
 - Cursor 原生本地 filesystem/shell/network 执行默认被拒绝。显式 `mcpServers` 与
diff --git a/docs-site/src/content/docs/zh-cn/reference/configuration/providers.md b/docs-site/src/content/docs/zh-cn/reference/configuration/providers.md
index 0393dcc569..f37f372cfd 100644
--- a/docs-site/src/content/docs/zh-cn/reference/configuration/providers.md
+++ b/docs-site/src/content/docs/zh-cn/reference/configuration/providers.md
@@ -220,7 +220,15 @@ affinity。这些策略不能规避 provider enforcement。
 
 ## Cursor 提供者（`adapter: "cursor"`）
 
-Cursor 桥接是实验性的。执行 `ocx login cursor` 之后，添加或编辑 `providers.cursor`。Cursor Router 的优化层级会作为独立的 Codex id 暴露，因为选择器无法渲染 Cursor 特定的模型参数：
+Cursor 桥接是实验性的。执行 `ocx login cursor` 之后，添加或编辑 `providers.cursor`。
+
+如果代理无法承载 Cursor 默认的 HTTP/2 stream，请将 `upstreamHttpVersion` 设置为
+`"http1.1"` 或其别名 `"h1"`。推理会切换到 Cursor 的 `RunSSE` + `BidiAppend` 兼容传输，`GetUsableModels`
+实时发现也会使用 HTTP/1.1。该配置要求 `baseUrl` 使用 HTTPS。保持未设置或使用 `"auto"`，
+则继续使用现有 HTTP/2 行为。
+在仪表板中，可通过 **Providers → Cursor → 设置 → Cursor 传输协议** 进行选择。
+
+Cursor Router 的优化层级会作为独立的 Codex id 暴露，因为选择器无法渲染 Cursor 特定的模型参数：
 
 | Codex model | Cursor Router mode |
 | --- | --- |
@@ -251,7 +259,7 @@ Cursor 由服务端驱动的本地工具默认是禁用的。Codex 继续使用
 }
 ```
 
-请将该字段设置在 `providers.cursor` 上，而不是顶层。在仪表板中，使用 **Providers → Cursor → Edit JSON**，保存，然后重启。旧的 `unsafeAllowNativeLocalExec: true` 仅在未设置 `nativeLocalExec` 时，才等同于 `nativeLocalExec: "on"`。MCP、屏幕录制和 computer use 由 `mcpServers` 和 `desktopExecutor` 单独控制。
+请将 `nativeLocalExec` 设置在 `providers.cursor` 上，而不是顶层。在仪表板中，使用 **Providers → Cursor → Edit JSON**，保存，然后重启。旧的 `unsafeAllowNativeLocalExec: true` 仅在未设置 `nativeLocalExec` 时，才等同于 `nativeLocalExec: "on"`。MCP、屏幕录制和 computer use 由 `mcpServers` 和 `desktopExecutor` 单独控制。
 
 每个 `mcpServers.<name>` 都可以接受 `command`（stdio）或 `url`（Streamable HTTP）。stdio 还接受 `args`、`env` 和 `cwd`；HTTP 接受 `headers`。两者都支持 `enabled`（默认 true）和 `toolPrefix`。`desktopExecutor` 接受 `computerUseCommand`、`recordScreenCommand`、`cwd`、`env` 和 `timeoutMs`（默认 `30000`）。命令通过 `sh -c` 执行，从 stdin 读取一个 JSON 请求，并且必须向 stdout 写入一个 JSON 结果。
 
diff --git a/gui/src/components/provider-workspace/ProviderSettings.tsx b/gui/src/components/provider-workspace/ProviderSettings.tsx
index fe9725e6a5..1509e13a14 100644
--- a/gui/src/components/provider-workspace/ProviderSettings.tsx
+++ b/gui/src/components/provider-workspace/ProviderSettings.tsx
@@ -27,6 +27,11 @@ const EMPTY_MODELS: string[] = [];
 type ChoicesStatus = "idle" | "loading" | "ready" | "error";
 type PacingRule = { requestsPerMinute?: number; minIntervalMs?: number };
 type PacingStatus = { enabled: boolean; queued: number; nextSlotInMs: number; lastStartedAt?: number; lastModelId?: string };
+type CursorHttpVersion = "http2" | "http1.1";
+
+function effectiveCursorHttpVersion(value: WorkspaceItem["upstreamHttpVersion"]): CursorHttpVersion {
+  return value === "http1.1" || value === "h1" ? "http1.1" : "http2";
+}
 
 function numberDraft(value: number | undefined): string { return value === undefined ? "" : String(value); }
 function positiveRpm(value: string): number | undefined {
@@ -67,6 +72,7 @@ export default function ProviderSettings({
   const initialAuth = String(item.authMode ?? (item.keyOptional ? "local" : "key"));
   const liveModelDiscoverySupported = providerSupportsLiveModelDiscovery(item.name, item);
   const savedLiveModels = liveModelDiscoverySupported ? item.liveModels !== false : false;
+  const savedCursorHttpVersion = effectiveCursorHttpVersion(item.upstreamHttpVersion);
   const [adapter, setAdapter] = useState(item.adapter);
   const [baseUrl, setBaseUrl] = useState(item.baseUrl);
   const [defaultModel, setDefaultModel] = useState(item.defaultModel ?? "");
@@ -75,6 +81,7 @@ export default function ProviderSettings({
   const [note, setNote] = useState(item.note ?? "");
   const [allowPrivateNetwork, setAllowPrivateNetwork] = useState(item.allowPrivateNetwork ?? false);
   const [liveModels, setLiveModels] = useState(savedLiveModels);
+  const [cursorHttpVersion, setCursorHttpVersion] = useState<CursorHttpVersion>(savedCursorHttpVersion);
   const [saving, setSaving] = useState(false);
   const [msg, setMsg] = useState<{ ok: boolean; text: string } | null>(null);
   const [accountMode, setAccountMode] = useState<"pool" | "direct">(item.codexAccountMode ?? "pool");
@@ -102,6 +109,7 @@ export default function ProviderSettings({
     setNote(item.note ?? "");
     setAllowPrivateNetwork(item.allowPrivateNetwork ?? false);
     setLiveModels(savedLiveModels);
+    setCursorHttpVersion(savedCursorHttpVersion);
     setPacingEnabled(item.requestPacing?.enabled === true);
     setPacingRpm(numberDraft(item.requestPacing?.requestsPerMinute));
     setPacingDelay(numberDraft(item.requestPacing?.minIntervalMs));
@@ -109,7 +117,7 @@ export default function ProviderSettings({
     setMsg(null);
     setModeMsg(null);
     queueMicrotask(() => setEndpointChoice(matchChoiceId(baseUrlChoices, item.baseUrl)));
-  }, [item.adapter, item.baseUrl, item.defaultModel, item.authMode, item.apiKeyTransport, item.keyOptional, item.note, item.allowPrivateNetwork, savedLiveModels, item.requestPacing, baseUrlChoices]);
+  }, [item.adapter, item.baseUrl, item.defaultModel, item.authMode, item.apiKeyTransport, item.keyOptional, item.note, item.allowPrivateNetwork, savedLiveModels, savedCursorHttpVersion, item.requestPacing, baseUrlChoices]);
   /* eslint-enable react-hooks/set-state-in-effect */
 
   // Account mode syncs on its own: a mode PATCH refresh must not reset an in-progress
@@ -185,7 +193,8 @@ export default function ProviderSettings({
     || (adapter.trim() === "anthropic" && authMode === "key" && apiKeyTransport !== (item.apiKeyTransport ?? "x-api-key"))
     || note.trim() !== (item.note ?? "")
     || allowPrivateNetwork !== (item.allowPrivateNetwork ?? false)
-    || liveModels !== savedLiveModels;
+    || liveModels !== savedLiveModels
+    || (adapter.trim() === "cursor" && cursorHttpVersion !== savedCursorHttpVersion);
   const pacingDirty = pacingSignature(pacingDraft) !== pacingSignature(item.requestPacing);
   const formDirty = dirty || pacingDirty;
 
@@ -242,6 +251,9 @@ export default function ProviderSettings({
         // Keep omitted legacy values omitted unless the user actually changes this toggle.
         // Otherwise an unrelated settings save manufactures `liveModels: true` provenance.
         if (liveModelDiscoverySupported && liveModels !== (item.liveModels !== false)) patch.liveModels = liveModels;
+        if (adapter.trim() === "cursor" && cursorHttpVersion !== savedCursorHttpVersion) {
+          patch.upstreamHttpVersion = cursorHttpVersion === "http1.1" ? "http1.1" : null;
+        }
         if (supportsApiKeyTransport) patch.apiKeyTransport = apiKeyTransport;
         else if (item.apiKeyTransport !== undefined) patch.apiKeyTransport = "";
       }
@@ -287,7 +299,8 @@ export default function ProviderSettings({
     setAdapter(item.adapter); setBaseUrl(item.baseUrl);
     setDefaultModel(item.defaultModel ?? ""); setAuthMode(initialAuth);
     setApiKeyTransport(item.apiKeyTransport ?? "x-api-key");
-    setNote(item.note ?? ""); setAllowPrivateNetwork(item.allowPrivateNetwork ?? false); setLiveModels(savedLiveModels); setMsg(null);
+    setNote(item.note ?? ""); setAllowPrivateNetwork(item.allowPrivateNetwork ?? false); setLiveModels(savedLiveModels);
+    setCursorHttpVersion(savedCursorHttpVersion); setMsg(null);
     setPacingEnabled(item.requestPacing?.enabled === true); setPacingRpm(numberDraft(item.requestPacing?.requestsPerMinute));
     setPacingDelay(numberDraft(item.requestPacing?.minIntervalMs)); setPacingModels({ ...(item.requestPacing?.models ?? {}) });
     setEndpointChoice(matchChoiceId(baseUrlChoices, item.baseUrl));
@@ -356,6 +369,20 @@ export default function ProviderSettings({
           <input className="input" value={baseUrl} onChange={e => setBaseUrl(e.target.value)} readOnly={plainBaseUrlLocked} disabled={plainBaseUrlLocked} />
         </label>
       )}
+      {adapter.trim() === "cursor" && (
+        <label className="pwi-settings-field">
+          <span className="pwi-settings-label">{t("pws.cursorTransport")}</span>
+          <select
+            className="input"
+            value={cursorHttpVersion}
+            onChange={e => setCursorHttpVersion(e.target.value as CursorHttpVersion)}
+          >
+            <option value="http2">{t("pws.cursorTransportHttp2")}</option>
+            <option value="http1.1">{t("pws.cursorTransportHttp1")}</option>
+          </select>
+          <span className="pwi-settings-hint">{t("pws.cursorTransportDesc")}</span>
+        </label>
+      )}
       <label className="pwi-settings-field">
         <span className="pwi-settings-label">{t("pws.cell.defaultModel")}</span>
         {modelOptions.length > 0 ? (
diff --git a/gui/src/components/provider-workspace/types.ts b/gui/src/components/provider-workspace/types.ts
index b5757d06eb..24dd218f3b 100644
--- a/gui/src/components/provider-workspace/types.ts
+++ b/gui/src/components/provider-workspace/types.ts
@@ -98,6 +98,7 @@ export type ProviderUpdatePatch = {
   disabled?: boolean;
   allowPrivateNetwork?: boolean;
   liveModels?: boolean;
+  upstreamHttpVersion?: "auto" | "http1.1" | "h1" | "http2" | "h2" | null;
   requestPacing?: WorkspaceItem["requestPacing"] | null;
   /** Dedicated field: the API PATCHes it alone for the canonical `openai` provider. */
   codexAccountMode?: "direct" | "pool";
diff --git a/gui/src/hooks/useJsonConfigEditor.ts b/gui/src/hooks/useJsonConfigEditor.ts
index b2f53a3b4a..c53a17a496 100644
--- a/gui/src/hooks/useJsonConfigEditor.ts
+++ b/gui/src/hooks/useJsonConfigEditor.ts
@@ -3,7 +3,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 export interface Config {
   port: number;
   defaultProvider: string;
-  providers: Record<string, { adapter: string; baseUrl: string; hasApiKey?: boolean; hasHeaders?: boolean; defaultModel?: string; models?: string[]; liveModels?: boolean; reasoningWireFormat?: "gateway-object"; authMode?: string; keyOptional?: boolean; disabled?: boolean; note?: string; codexAccountMode?: "direct" | "pool" }>;
+  providers: Record<string, { adapter: string; baseUrl: string; hasApiKey?: boolean; hasHeaders?: boolean; defaultModel?: string; models?: string[]; liveModels?: boolean; upstreamHttpVersion?: "auto" | "http1.1" | "h1" | "http2" | "h2"; reasoningWireFormat?: "gateway-object"; authMode?: string; keyOptional?: boolean; disabled?: boolean; note?: string; codexAccountMode?: "direct" | "pool" }>;
 }
 
 export function useJsonConfigEditor(deps: {
diff --git a/gui/src/hooks/useProviderAccountPools.ts b/gui/src/hooks/useProviderAccountPools.ts
index bfddc06111..317f4bffb9 100644
--- a/gui/src/hooks/useProviderAccountPools.ts
+++ b/gui/src/hooks/useProviderAccountPools.ts
@@ -7,7 +7,7 @@ import { oauthAccountDisplayLabel } from "../provider-workspace/auth";
 export interface Config {
   port: number;
   defaultProvider: string;
-  providers: Record<string, { adapter: string; baseUrl: string; hasApiKey?: boolean; hasHeaders?: boolean; defaultModel?: string; models?: string[]; liveModels?: boolean; authMode?: string; keyOptional?: boolean; disabled?: boolean; note?: string; codexAccountMode?: "direct" | "pool" }>;
+  providers: Record<string, { adapter: string; baseUrl: string; hasApiKey?: boolean; hasHeaders?: boolean; defaultModel?: string; models?: string[]; liveModels?: boolean; upstreamHttpVersion?: "auto" | "http1.1" | "h1" | "http2" | "h2"; authMode?: string; keyOptional?: boolean; disabled?: boolean; note?: string; codexAccountMode?: "direct" | "pool" }>;
 }
 
 export interface OAuthStatus { loggedIn: boolean; email?: string; error?: string; done?: boolean; needsReauth?: boolean; activeAccountId?: string | null }
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index 976d81c702..cc2d4d39d2 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -1681,6 +1681,10 @@ export const de: Record<TKey, string> = {
   "pws.allowPrivateNetwork": "Lokales/privates Netzwerk erlauben",
   "pws.liveModels": "Modelle beim Anbieter erkennen",
   "pws.liveModelsDesc": "Lädt den Live-Modellkatalog des Anbieters. Ausschalten, um nur konfigurierte statische Modelle zu verwenden.",
+  "pws.cursorTransport": "Cursor-Transport",
+  "pws.cursorTransportHttp2": "HTTP/2 (Standard)",
+  "pws.cursorTransportHttp1": "HTTP/1.1 (Proxy-Kompatibilität)",
+  "pws.cursorTransportDesc": "Verwenden Sie HTTP/1.1, wenn Ihr Proxy den HTTP/2-Stream von Cursor nicht zuverlässig überträgt.",
   "pws.optionalPlaceholder": "Optional",
   "pws.providerId": "Anbieter-ID",
   "pws.reauth": "Erneute Anmeldung erforderlich",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index 9ed230f6dc..8acf2aa05c 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -1186,6 +1186,10 @@ export const en = {
   "pws.allowPrivateNetwork": "Allow local/private network",
   "pws.liveModels": "Discover models from provider",
   "pws.liveModelsDesc": "Fetch the provider's live model catalog. Turn this off to use only configured/static models.",
+  "pws.cursorTransport": "Cursor transport",
+  "pws.cursorTransportHttp2": "HTTP/2 (default)",
+  "pws.cursorTransportHttp1": "HTTP/1.1 (proxy compatibility)",
+  "pws.cursorTransportDesc": "Use HTTP/1.1 when your proxy cannot reliably carry Cursor's HTTP/2 stream.",
   "pws.optionalPlaceholder": "Optional",
   "pws.providerId": "Provider ID",
   "pws.reauth": "Needs re-auth",
diff --git a/gui/src/i18n/fr.ts b/gui/src/i18n/fr.ts
index 20e9311cb9..9b6886e929 100644
--- a/gui/src/i18n/fr.ts
+++ b/gui/src/i18n/fr.ts
@@ -1159,6 +1159,10 @@ export const fr: Record<TKey, string> = {
   "pws.allowPrivateNetwork": "Autoriser le réseau local/privé",
   "pws.liveModels": "Détecter les modèles auprès du fournisseur",
   "pws.liveModelsDesc": "Récupérez le catalogue de modèles en direct du fournisseur. Désactivez cette option pour utiliser uniquement les modèles configurés/statiques.",
+  "pws.cursorTransport": "Transport Cursor",
+  "pws.cursorTransportHttp2": "HTTP/2 (par défaut)",
+  "pws.cursorTransportHttp1": "HTTP/1.1 (compatibilité proxy)",
+  "pws.cursorTransportDesc": "Utilisez HTTP/1.1 si votre proxy ne transporte pas de façon fiable le flux HTTP/2 de Cursor.",
   "pws.optionalPlaceholder": "Facultatif",
   "pws.pacingTitle": "Cadencement des requêtes",
   "pws.pacingDesc": "Répartissez uniformément le démarrage des requêtes sortantes pour ce fournisseur. Les réponses diffusées peuvent se chevaucher.",
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index ce7f4d1642..f5e915c32e 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -1119,6 +1119,10 @@ export const ja: Record<TKey, string> = {
   "pws.allowPrivateNetwork": "ローカル/プライベートネットワークを許可",
   "pws.liveModels": "プロバイダーからモデルを検出",
   "pws.liveModelsDesc": "プロバイダーのライブモデルカタログを取得します。オフにすると設定済みの静的モデルのみを使用します。",
+  "pws.cursorTransport": "Cursor トランスポート",
+  "pws.cursorTransportHttp2": "HTTP/2（デフォルト）",
+  "pws.cursorTransportHttp1": "HTTP/1.1（プロキシ互換）",
+  "pws.cursorTransportDesc": "プロキシが Cursor の HTTP/2 ストリームを安定して転送できない場合は HTTP/1.1 を使用します。",
   "pws.optionalPlaceholder": "任意",
   "pws.providerId": "プロバイダー ID",
   "pws.reauth": "再認証が必要",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index 2909a498c1..a6ec756097 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -1708,6 +1708,10 @@ export const ko: Record<TKey, string> = {
   "pws.allowPrivateNetwork": "로컬/사설 네트워크 허용",
   "pws.liveModels": "프로바이더에서 모델 검색",
   "pws.liveModelsDesc": "프로바이더의 실시간 모델 카탈로그를 가져옵니다. 끄면 설정된 정적 모델만 사용합니다.",
+  "pws.cursorTransport": "Cursor 전송",
+  "pws.cursorTransportHttp2": "HTTP/2 (기본값)",
+  "pws.cursorTransportHttp1": "HTTP/1.1 (프록시 호환)",
+  "pws.cursorTransportDesc": "프록시가 Cursor의 HTTP/2 스트림을 안정적으로 전달하지 못할 때 HTTP/1.1을 사용하세요.",
   "pws.optionalPlaceholder": "선택사항",
   "pws.providerId": "프로바이더 ID",
   "pws.reauth": "재인증 필요",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index 6bf8dca072..75902a6f29 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -1170,6 +1170,10 @@ export const ru: Record<TKey, string> = {
   "pws.allowPrivateNetwork": "Разрешить локальную/частную сеть",
   "pws.liveModels": "Обнаруживать модели провайдера",
   "pws.liveModelsDesc": "Загружать актуальный каталог моделей провайдера. Выключите, чтобы использовать только настроенные статические модели.",
+  "pws.cursorTransport": "Транспорт Cursor",
+  "pws.cursorTransportHttp2": "HTTP/2 (по умолчанию)",
+  "pws.cursorTransportHttp1": "HTTP/1.1 (совместимость с прокси)",
+  "pws.cursorTransportDesc": "Используйте HTTP/1.1, если прокси нестабильно передаёт поток Cursor по HTTP/2.",
   "pws.optionalPlaceholder": "Необязательно",
   "pws.providerId": "ID провайдера",
   "pws.reauth": "Нужна переавторизация",
diff --git a/gui/src/i18n/tr.ts b/gui/src/i18n/tr.ts
index 3abaaaef6c..759624ceef 100644
--- a/gui/src/i18n/tr.ts
+++ b/gui/src/i18n/tr.ts
@@ -1177,6 +1177,10 @@ export const tr: Record<TKey, string> = {
   "pws.allowPrivateNetwork": "Yerel/özel ağa izin ver",
   "pws.liveModels": "Sağlayıcıdan canlı model keşfet",
   "pws.liveModelsDesc": "Sağlayıcının canlı model kataloğunu çekin.",
+  "pws.cursorTransport": "Cursor aktarımı",
+  "pws.cursorTransportHttp2": "HTTP/2 (varsayılan)",
+  "pws.cursorTransportHttp1": "HTTP/1.1 (proxy uyumluluğu)",
+  "pws.cursorTransportDesc": "Proxy'niz Cursor'ın HTTP/2 akışını güvenilir biçimde taşıyamıyorsa HTTP/1.1 kullanın.",
   "pws.optionalPlaceholder": "İsteğe bağlı",
   "pws.providerId": "Sağlayıcı ID",
   "pws.reauth": "Yeniden doğrulama gerekiyor",
diff --git a/gui/src/i18n/zh-TW.ts b/gui/src/i18n/zh-TW.ts
index 869b863370..d7d000d222 100644
--- a/gui/src/i18n/zh-TW.ts
+++ b/gui/src/i18n/zh-TW.ts
@@ -966,6 +966,10 @@ export const zhTW: Record<TKey, string> = {
   "pws.allowPrivateNetwork": "允許本地/私有網路",
   "pws.liveModels": "從供應商發現模型",
   "pws.liveModelsDesc": "取得供應商的即時模型目錄。關閉後僅使用已配置的靜態模型。",
+  "pws.cursorTransport": "Cursor 傳輸協定",
+  "pws.cursorTransportHttp2": "HTTP/2（預設）",
+  "pws.cursorTransportHttp1": "HTTP/1.1（代理相容）",
+  "pws.cursorTransportDesc": "當代理無法穩定承載 Cursor 的 HTTP/2 串流時，請使用 HTTP/1.1。",
   "pws.optionalPlaceholder": "可選",
   "pws.providerId": "供應商 ID",
   "pws.reauth": "需要重新認證",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index de6897e351..be8aec6236 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -1701,6 +1701,10 @@ export const zh: Record<TKey, string> = {
   "pws.allowPrivateNetwork": "允许本地/私有网络",
   "pws.liveModels": "从提供方发现模型",
   "pws.liveModelsDesc": "获取提供方的实时模型目录。关闭后仅使用已配置的静态模型。",
+  "pws.cursorTransport": "Cursor 传输协议",
+  "pws.cursorTransportHttp2": "HTTP/2（默认）",
+  "pws.cursorTransportHttp1": "HTTP/1.1（代理兼容）",
+  "pws.cursorTransportDesc": "当代理无法稳定承载 Cursor 的 HTTP/2 流时，请使用 HTTP/1.1。",
   "pws.optionalPlaceholder": "可选",
   "pws.providerId": "提供商 ID",
   "pws.reauth": "需要重新认证",
diff --git a/gui/src/pages/providers-shared.ts b/gui/src/pages/providers-shared.ts
index fb64a56a86..b87b66bd9e 100644
--- a/gui/src/pages/providers-shared.ts
+++ b/gui/src/pages/providers-shared.ts
@@ -9,6 +9,7 @@ export interface ProvidersConfig {
     defaultModel?: string;
     models?: string[];
     liveModels?: boolean;
+    upstreamHttpVersion?: "auto" | "http1.1" | "h1" | "http2" | "h2";
     reasoningWireFormat?: "gateway-object";
     authMode?: string;
     keyOptional?: boolean;
diff --git a/gui/src/provider-workspace/catalog.ts b/gui/src/provider-workspace/catalog.ts
index 53b680cc09..d4e4a5e674 100644
--- a/gui/src/provider-workspace/catalog.ts
+++ b/gui/src/provider-workspace/catalog.ts
@@ -38,6 +38,8 @@ export interface WorkspaceProvider {
   models?: string[];
   /** Whether the proxy fetches the provider's live model catalog (default true). */
   liveModels?: boolean;
+  /** Optional upstream HTTP version pin. Cursor defaults to HTTP/2 when omitted. */
+  upstreamHttpVersion?: "auto" | "http1.1" | "h1" | "http2" | "h2";
   authMode?: "key" | "forward" | "oauth" | "local" | string;
   keyOptional?: boolean;
   /** Free pricing (may still require an API key). */
diff --git a/gui/tests/provider-settings-cursor-transport.test.tsx b/gui/tests/provider-settings-cursor-transport.test.tsx
new file mode 100644
index 0000000000..f58bf0ad86
--- /dev/null
+++ b/gui/tests/provider-settings-cursor-transport.test.tsx
@@ -0,0 +1,152 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { Window } from "happy-dom";
+import { act } from "react";
+import type { Root } from "react-dom/client";
+import ProviderSettings from "../src/components/provider-workspace/ProviderSettings";
+import type { ProviderUpdatePatch } from "../src/components/provider-workspace/types";
+import { LanguageProvider } from "../src/i18n/provider";
+import type { WorkspaceItem } from "../src/provider-workspace/catalog";
+
+const globals = ["document", "window", "navigator", "localStorage", "IS_REACT_ACT_ENVIRONMENT"] as const;
+let previousGlobals: Record<(typeof globals)[number], unknown>;
+let testWindow: Window;
+
+beforeEach(() => {
+  previousGlobals = Object.fromEntries(globals.map(key => [key, Reflect.get(globalThis, key)])) as typeof previousGlobals;
+  testWindow = new Window({ url: "http://localhost/#providers/workspace" });
+  Object.defineProperty(testWindow.navigator, "language", { configurable: true, value: "en-US" });
+  Object.defineProperties(globalThis, {
+    document: { configurable: true, value: testWindow.document },
+    window: { configurable: true, value: testWindow },
+    navigator: { configurable: true, value: testWindow.navigator },
+    localStorage: { configurable: true, value: testWindow.localStorage },
+  });
+  (globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+});
+
+afterEach(() => {
+  testWindow.close();
+  for (const key of globals) {
+    Object.defineProperty(globalThis, key, { configurable: true, value: previousGlobals[key] });
+  }
+});
+
+function cursor(upstreamHttpVersion?: WorkspaceItem["upstreamHttpVersion"]): WorkspaceItem {
+  return {
+    name: "cursor",
+    adapter: "cursor",
+    baseUrl: "https://api2.cursor.sh",
+    authMode: "oauth",
+    note: "before",
+    ...(upstreamHttpVersion === undefined ? {} : { upstreamHttpVersion }),
+  };
+}
+
+async function mountSettings(item: WorkspaceItem): Promise<{
+  root: Root;
+  container: HTMLElement;
+  patches: ProviderUpdatePatch[];
+}> {
+  const patches: ProviderUpdatePatch[] = [];
+  const container = document.createElement("div");
+  document.body.append(container);
+  const { createRoot } = await import("react-dom/client");
+  let root!: Root;
+  await act(async () => {
+    root = createRoot(container);
+    root.render(
+      <LanguageProvider>
+        <ProviderSettings
+          item={item}
+          onUpdateProvider={async (_name, patch) => {
+            patches.push(patch);
+            return { ok: true };
+          }}
+        />
+      </LanguageProvider>,
+    );
+  });
+  return { root, container, patches };
+}
+
+function transportSelect(container: HTMLElement): HTMLSelectElement | null {
+  return Array.from(container.querySelectorAll<HTMLSelectElement>("select.input"))
+    .find(select => Array.from(select.options).some(option => option.value === "http1.1")) ?? null;
+}
+
+async function choose(select: HTMLSelectElement, value: "http2" | "http1.1"): Promise<void> {
+  await act(async () => {
+    Object.getOwnPropertyDescriptor(testWindow.HTMLSelectElement.prototype, "value")!.set!.call(select, value);
+    select.dispatchEvent(new testWindow.Event("change", { bubbles: true }));
+  });
+}
+
+async function save(container: HTMLElement): Promise<void> {
+  const button = container.querySelector<HTMLButtonElement>(".pwi-settings-sticky-bar .btn-primary");
+  expect(button).toBeTruthy();
+  await act(async () => {
+    button!.click();
+    await Promise.resolve();
+  });
+}
+
+test("Cursor settings expose HTTP/2 as the default without materializing a config pin", async () => {
+  const { root, container, patches } = await mountSettings(cursor());
+  const select = transportSelect(container);
+
+  expect(select?.value).toBe("http2");
+  expect(select?.options[0]?.textContent).toContain("default");
+  expect(container.textContent).toContain("proxy cannot reliably carry");
+  expect(container.querySelector(".pwi-settings-sticky-bar")).toBeNull();
+  expect(patches).toEqual([]);
+  await act(async () => { root.unmount(); });
+});
+
+test("the Cursor transport control is hidden for non-Cursor adapters", async () => {
+  const { root, container } = await mountSettings({
+    name: "custom",
+    adapter: "openai-chat",
+    baseUrl: "https://example.test/v1",
+    authMode: "key",
+  });
+
+  expect(transportSelect(container)).toBeNull();
+  await act(async () => { root.unmount(); });
+});
+
+test("selecting HTTP/1.1 persists the compatibility transport", async () => {
+  const { root, container, patches } = await mountSettings(cursor());
+  await choose(transportSelect(container)!, "http1.1");
+  await save(container);
+
+  expect(patches).toHaveLength(1);
+  expect(patches[0]?.upstreamHttpVersion).toBe("http1.1");
+  await act(async () => { root.unmount(); });
+});
+
+test("selecting the default HTTP/2 clears an existing HTTP/1.1 pin", async () => {
+  const { root, container, patches } = await mountSettings(cursor("h1"));
+  const select = transportSelect(container)!;
+  expect(select.value).toBe("http1.1");
+
+  await choose(select, "http2");
+  await save(container);
+
+  expect(patches).toHaveLength(1);
+  expect(patches[0]?.upstreamHttpVersion).toBeNull();
+  await act(async () => { root.unmount(); });
+});
+
+test("an unrelated Cursor settings save leaves the omitted HTTP/2 default omitted", async () => {
+  const { root, container, patches } = await mountSettings(cursor());
+  const note = container.querySelector<HTMLTextAreaElement>(".pwi-settings-textarea")!;
+  await act(async () => {
+    Object.getOwnPropertyDescriptor(testWindow.HTMLTextAreaElement.prototype, "value")!.set!.call(note, "after");
+    note.dispatchEvent(new testWindow.Event("input", { bubbles: true }));
+  });
+  await save(container);
+
+  expect(patches).toHaveLength(1);
+  expect(Object.hasOwn(patches[0]!, "upstreamHttpVersion")).toBe(false);
+  await act(async () => { root.unmount(); });
+});
diff --git a/src/adapters/base.ts b/src/adapters/base.ts
index 06b5f6f087..bcdd657344 100644
--- a/src/adapters/base.ts
+++ b/src/adapters/base.ts
@@ -7,6 +7,12 @@ export interface IncomingMeta {
   headers: Headers;
   translatorBudget: TranslatorBudget;
   abortSignal?: AbortSignal;
+  /**
+   * Provider-scoped fetch prepared by the Responses router. Stateful transports that emit more
+   * than one physical HTTP request per logical turn must reuse it so every request participates in
+   * the same pacing queue and custom provider fetch seam.
+   */
+  providerFetch?: typeof globalThis.fetch;
   /**
    * Image-normalization ladder bias for upstream-413 tightened retries: every image
    * starts one tier lower (devlog/260714_image_normalization_pipeline/030). Only the
diff --git a/src/adapters/cursor.ts b/src/adapters/cursor.ts
index 6f66004ea8..cbecba8b72 100644
--- a/src/adapters/cursor.ts
+++ b/src/adapters/cursor.ts
@@ -122,6 +122,7 @@ export function createCursorAdapter(provider: OcxProviderConfig, deps: CursorAda
               translatorBudget: incoming.translatorBudget,
               requestDeclaresFullAccess: cursorRequestDeclaresFullAccess(activeRequest),
               sessionId: activeRequest.conversationId,
+              ...(incoming.providerFetch ? { fetch: incoming.providerFetch } : {}),
             },
             activeRequest,
             incoming.abortSignal,
diff --git a/src/adapters/cursor/http1-bidi.ts b/src/adapters/cursor/http1-bidi.ts
new file mode 100644
index 0000000000..2dc7678cf2
--- /dev/null
+++ b/src/adapters/cursor/http1-bidi.ts
@@ -0,0 +1,361 @@
+import { create, toBinary } from "@bufbuild/protobuf";
+import type { TranslatorBudget } from "../../lib/translator-budget";
+import { CURSOR_MAX_EFFECTIVE_CONNECT_PAYLOAD_BYTES } from "../../lib/translator-budget";
+import { readBoundedResponseBytes } from "../../lib/bounded-body";
+import { withUpstreamHttpVersionValue } from "../../lib/upstream-http-version";
+import { isPreConnectReachabilityError } from "../../lib/upstream-reachability";
+import { BidiRequestIdSchema } from "./gen/agent_pb";
+import { consumeConnectFrames, encodeConnectFrame } from "./framing";
+
+const CURSOR_RUN_SSE_PATH = "/agent.v1.AgentService/RunSSE";
+const CURSOR_BIDI_APPEND_PATH = "/aiserver.v1.BidiService/BidiAppend";
+const CURSOR_HTTP1_APPEND_TIMEOUT_MS = 30_000;
+const CURSOR_HTTP1_APPEND_RESPONSE_MAX_BYTES = 64 * 1024;
+const HEX = "0123456789abcdef";
+
+export interface CursorHttp1BidiCallbacks {
+  onCommitted(): void;
+  onData(chunk: Uint8Array): void;
+  onEnd(): void;
+  onError(error: Error): void;
+}
+
+export interface CursorHttp1BidiOptions {
+  baseUrl: string;
+  token: string;
+  clientVersion: string;
+  sessionId: string;
+  requestId: string;
+  translatorBudget: TranslatorBudget;
+  callbacks: CursorHttp1BidiCallbacks;
+  fetch?: typeof globalThis.fetch;
+}
+
+interface PendingAppend {
+  payload: Uint8Array;
+  seqno: bigint;
+  rawBytesCharged: boolean;
+}
+
+function varintLength(value: bigint): number {
+  let length = 1;
+  for (let current = value; current >= 0x80n; current >>= 7n) length += 1;
+  return length;
+}
+
+function writeVarint(target: Uint8Array, offset: number, value: bigint): number {
+  let current = value;
+  while (current >= 0x80n) {
+    target[offset++] = Number(current & 0x7fn) | 0x80;
+    current >>= 7n;
+  }
+  target[offset++] = Number(current);
+  return offset;
+}
+
+function requestIdMessageBytes(requestId: string): Uint8Array {
+  const value = new TextEncoder().encode(requestId);
+  const message = new Uint8Array(1 + varintLength(BigInt(value.byteLength)) + value.byteLength);
+  let offset = 0;
+  message[offset++] = 0x0a; // field 1, string request_id
+  offset = writeVarint(message, offset, BigInt(value.byteLength));
+  message.set(value, offset);
+  return message;
+}
+
+/** Exact encoded size of Cursor's aiserver.v1.BidiAppendRequest hex fallback shape. */
+export function cursorBidiAppendRequestSize(payloadBytes: number, requestId: string, seqno: bigint): number {
+  const hexBytes = payloadBytes * 2;
+  const requestIdBytes = requestIdMessageBytes(requestId).byteLength;
+  return (hexBytes > 0 ? 1 + varintLength(BigInt(hexBytes)) + hexBytes : 0)
+    + 1 + varintLength(BigInt(requestIdBytes)) + requestIdBytes
+    + (seqno > 0n ? 1 + varintLength(seqno) : 0);
+}
+
+/**
+ * Encode the compatibility request used by Cursor when HTTP/2 is disabled.
+ * The public client defaults to field 1's hexadecimal data when its binary-append
+ * feature gate is unavailable, so OpenCodex uses that backwards-compatible shape.
+ */
+export function encodeCursorBidiAppendRequest(
+  payload: Uint8Array,
+  requestId: string,
+  seqno: bigint,
+): Uint8Array {
+  const requestIdBytes = requestIdMessageBytes(requestId);
+  const output = new Uint8Array(cursorBidiAppendRequestSize(payload.byteLength, requestId, seqno));
+  let offset = 0;
+  if (payload.byteLength > 0) {
+    const hexBytes = payload.byteLength * 2;
+    output[offset++] = 0x0a; // field 1, string data
+    offset = writeVarint(output, offset, BigInt(hexBytes));
+    for (const byte of payload) {
+      output[offset++] = HEX.charCodeAt(byte >>> 4);
+      output[offset++] = HEX.charCodeAt(byte & 0x0f);
+    }
+  }
+  output[offset++] = 0x12; // field 2, BidiRequestId request_id
+  offset = writeVarint(output, offset, BigInt(requestIdBytes.byteLength));
+  output.set(requestIdBytes, offset);
+  offset += requestIdBytes.byteLength;
+  if (seqno > 0n) {
+    output[offset++] = 0x18; // field 3, int64 append_seqno
+    offset = writeVarint(output, offset, seqno);
+  }
+  return output;
+}
+
+function cursorHttp1Error(operation: "RunSSE" | "BidiAppend", status: number): Error {
+  return new Error(`Cursor HTTP/1.1 ${operation} failed with HTTP ${status || "unknown"}`);
+}
+
+function asError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+/** Bun accepts Uint8Array request bodies; TypeScript's DOM BodyInit omits that runtime shape. */
+function bunFetchBody(bytes: Uint8Array): BodyInit {
+  return bytes as unknown as BodyInit;
+}
+
+/**
+ * Cursor's HTTP/1.1 compatibility bridge: a server-streaming RunSSE request carries
+ * output, while each client message is posted separately through BidiAppend.
+ */
+export class CursorHttp1BidiConnection {
+  private readonly abortController = new AbortController();
+  private readonly fetchImpl: typeof globalThis.fetch;
+  private readonly runSseReady: Promise<void>;
+  private resolveRunSseReady!: () => void;
+  private rejectRunSseReady!: (reason?: unknown) => void;
+  private appendChain: Promise<void> = Promise.resolve();
+  private nextAppendSeqno = 0n;
+  private committed = false;
+  private paused = false;
+  private resumeWaiters: Array<() => void> = [];
+  private terminal = false;
+  private closed = false;
+  destroyed = false;
+
+  constructor(private readonly options: CursorHttp1BidiOptions) {
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.runSseReady = new Promise<void>((resolve, reject) => {
+      this.resolveRunSseReady = resolve;
+      this.rejectRunSseReady = reject;
+    });
+    // A RunSSE failure can happen before the first append reaches its await; observe it here so
+    // the readiness promise never becomes an unhandled rejection.
+    void this.runSseReady.catch(() => undefined);
+  }
+
+  start(): void {
+    void this.runSse().catch(error => {
+      this.rejectRunSseReady(error);
+      this.fail(asError(error));
+    });
+  }
+
+  write(frameBytes: Uint8Array): boolean {
+    if (this.closed || this.terminal) return false;
+    let frame;
+    try {
+      const decoded = consumeConnectFrames(frameBytes, CURSOR_MAX_EFFECTIVE_CONNECT_PAYLOAD_BYTES, 2);
+      if (decoded.frames.length !== 1 || decoded.consumedBytes !== frameBytes.byteLength) {
+        throw new Error("Cursor HTTP/1.1 append requires exactly one complete Connect frame");
+      }
+      frame = decoded.frames[0]!;
+      if (frame.flags !== 0) throw new Error(`Cursor HTTP/1.1 append does not support Connect flags ${frame.flags}`);
+      this.options.translatorBudget.chargeRetained(frame.payload.byteLength, { kind: "request_copies" });
+    } catch (error) {
+      this.fail(asError(error));
+      return false;
+    }
+
+    const pending: PendingAppend = {
+      payload: frame.payload,
+      seqno: this.nextAppendSeqno++,
+      rawBytesCharged: true,
+    };
+    this.appendChain = this.appendChain
+      .then(() => this.postAppend(pending))
+      .catch(error => this.fail(asError(error)))
+      .finally(() => {
+        if (!pending.rawBytesCharged) return;
+        pending.rawBytesCharged = false;
+        this.options.translatorBudget.releaseRetained(pending.payload.byteLength, { kind: "request_copies" });
+      });
+    return true;
+  }
+
+  pause(): void {
+    this.paused = true;
+  }
+
+  resume(): void {
+    if (!this.paused) return;
+    this.paused = false;
+    const waiters = this.resumeWaiters;
+    this.resumeWaiters = [];
+    for (const resume of waiters) resume();
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    this.destroyed = true;
+    this.resume();
+    const reason = new DOMException("Cursor HTTP/1.1 connection closed", "AbortError");
+    this.rejectRunSseReady(reason);
+    this.abortController.abort(reason);
+    queueMicrotask(() => this.finish());
+  }
+
+  destroy(): void {
+    this.close();
+  }
+
+  private commonHeaders(contentType: string): Headers {
+    return new Headers({
+      "content-type": contentType,
+      "connect-protocol-version": "1",
+      authorization: `Bearer ${this.options.token}`,
+      "x-ghost-mode": "true",
+      "x-cursor-client-version": this.options.clientVersion,
+      "x-cursor-client-type": "cli",
+      "x-request-id": this.options.requestId,
+      "x-session-id": this.options.sessionId,
+    });
+  }
+
+  private requestUrl(path: string): string {
+    const url = new URL(path, this.options.baseUrl);
+    if (url.protocol !== "https:") {
+      throw new Error("Cursor HTTP/1.1 transport requires an HTTPS base URL");
+    }
+    return url.toString();
+  }
+
+  private http1Init(url: string, init: RequestInit): RequestInit {
+    return withUpstreamHttpVersionValue(url, init, "http1.1") ?? init;
+  }
+
+  private markCommitted(): void {
+    if (this.committed) return;
+    this.committed = true;
+    this.options.callbacks.onCommitted();
+  }
+
+  private async runSse(): Promise<void> {
+    const url = this.requestUrl(CURSOR_RUN_SSE_PATH);
+    const requestId = toBinary(BidiRequestIdSchema, create(BidiRequestIdSchema, {
+      requestId: this.options.requestId,
+    }));
+    const response = await this.fetchImpl(url, this.http1Init(url, {
+      method: "POST",
+      headers: this.commonHeaders("application/connect+proto"),
+      body: bunFetchBody(encodeConnectFrame(requestId)),
+      redirect: "manual",
+      signal: this.abortController.signal,
+    }));
+    if (response.status !== 200) {
+      void response.body?.cancel().catch(() => undefined);
+      throw cursorHttp1Error("RunSSE", response.status);
+    }
+    if (!response.body) throw new Error("Cursor HTTP/1.1 RunSSE returned no response body");
+    // Cursor has accepted the request id once RunSSE returns successful headers. Do not race the
+    // first BidiAppend ahead of that registration.
+    this.resolveRunSseReady();
+    const reader = response.body.getReader();
+    try {
+      while (!this.closed && !this.terminal) {
+        await this.waitWhilePaused();
+        if (this.closed || this.terminal) break;
+        const { value, done } = await reader.read();
+        if (done) break;
+        if (value && value.byteLength > 0) this.options.callbacks.onData(value);
+      }
+      this.finish();
+    } finally {
+      try { reader.releaseLock(); } catch { /* a pending abort may still own it */ }
+    }
+  }
+
+  private async postAppend(pending: PendingAppend): Promise<void> {
+    if (this.closed || this.terminal) return;
+    await this.runSseReady;
+    if (this.closed || this.terminal) return;
+    const encodedBytes = cursorBidiAppendRequestSize(
+      pending.payload.byteLength,
+      this.options.requestId,
+      pending.seqno,
+    );
+    const reservation = this.options.translatorBudget.reserveTransient(encodedBytes, { kind: "request_copies" });
+    let body: Uint8Array;
+    try {
+      body = encodeCursorBidiAppendRequest(pending.payload, this.options.requestId, pending.seqno);
+    } catch (error) {
+      reservation.release();
+      throw error;
+    }
+    if (pending.rawBytesCharged) {
+      pending.rawBytesCharged = false;
+      this.options.translatorBudget.releaseRetained(pending.payload.byteLength, { kind: "request_copies" });
+    }
+    try {
+      const url = this.requestUrl(CURSOR_BIDI_APPEND_PATH);
+      const timeout = AbortSignal.timeout(CURSOR_HTTP1_APPEND_TIMEOUT_MS);
+      const signal = AbortSignal.any([this.abortController.signal, timeout]);
+      let response: Response;
+      try {
+        response = await this.fetchImpl(url, this.http1Init(url, {
+          method: "POST",
+          headers: this.commonHeaders("application/proto"),
+          body: bunFetchBody(body),
+          redirect: "manual",
+          signal,
+        }));
+      } catch (error) {
+        // A proven DNS/TCP pre-connect failure means no append bytes reached Cursor and replay is
+        // safe. Every ambiguous rejection stays conservative: the server may have accepted the
+        // append before the response path failed, so suppress replay exactly as the h2 path does.
+        if (!isPreConnectReachabilityError(error)) this.markCommitted();
+        throw error;
+      }
+      this.markCommitted();
+      if (response.status !== 200) {
+        void response.body?.cancel().catch(() => undefined);
+        throw cursorHttp1Error("BidiAppend", response.status);
+      }
+      const result = await readBoundedResponseBytes(response, {
+        maxBytes: CURSOR_HTTP1_APPEND_RESPONSE_MAX_BYTES,
+        signal,
+      });
+      if (result.oversized) throw new Error("Cursor HTTP/1.1 BidiAppend response exceeds 64 KiB");
+    } finally {
+      reservation.release();
+    }
+  }
+
+  private waitWhilePaused(): Promise<void> {
+    if (!this.paused) return Promise.resolve();
+    return new Promise(resolve => this.resumeWaiters.push(resolve));
+  }
+
+  private fail(error: Error): void {
+    if (this.terminal) return;
+    this.terminal = true;
+    this.destroyed = true;
+    this.resume();
+    this.rejectRunSseReady(error);
+    if (!this.abortController.signal.aborted) this.abortController.abort(error);
+    this.options.callbacks.onError(error);
+  }
+
+  private finish(): void {
+    if (this.terminal) return;
+    this.terminal = true;
+    this.destroyed = true;
+    this.resume();
+    this.options.callbacks.onEnd();
+  }
+}
diff --git a/src/adapters/cursor/live-models.ts b/src/adapters/cursor/live-models.ts
index 00831f84c2..f79fe27398 100644
--- a/src/adapters/cursor/live-models.ts
+++ b/src/adapters/cursor/live-models.ts
@@ -1,5 +1,6 @@
 /**
- * Live Cursor model discovery via the `GetUsableModels` RPC (HTTP/2 + Connect-unary protobuf).
+ * Live Cursor model discovery via the `GetUsableModels` Connect-unary protobuf RPC.
+ * HTTP/2 remains the default; an explicit HTTP/1.1 provider pin uses Bun fetch instead.
  *
  * Returns the account's actually-usable model ids (the full effort-suffixed variants Cursor offers
  * for THIS plan), so the routed catalog reflects reality instead of a static superset. Failures are
@@ -14,6 +15,14 @@
  */
 import http2 from "node:http2";
 import { fromBinary } from "@bufbuild/protobuf";
+import type { UpstreamHttpVersion } from "../../types";
+import { readBoundedResponseBytes } from "../../lib/bounded-body";
+import {
+  isPinnedHttp1,
+  UpstreamHttpVersionTargetError,
+  withUpstreamHttpVersionValue,
+} from "../../lib/upstream-http-version";
+import { isValidModelDiscoveryModelId } from "../../providers/model-discovery-limits";
 import { GetUsableModelsResponseSchema } from "./gen/agent_pb";
 
 const CURSOR_GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
@@ -27,11 +36,14 @@ export interface CursorUsableModelsOptions {
   baseUrl?: string;
   clientVersion?: string;
   timeoutMs?: number;
+  upstreamHttpVersion?: UpstreamHttpVersion;
+  /** Test/embedding seam. Production discovery uses Bun's global fetch in HTTP/1.1 mode. */
+  fetch?: typeof globalThis.fetch;
 }
 
 export type CursorUsableModelsResult =
   | { ok: true; models: string[] }
-  | { ok: false; error: "auth" | "http" | "transport" | "timeout" | "decode" | "empty" | "too_large"; detail?: string };
+  | { ok: false; error: "auth" | "http" | "policy" | "transport" | "timeout" | "decode" | "empty" | "too_large"; detail?: string };
 
 /** Test-only seam for management connectivity probes; production callers retain the HTTP/2 path. */
 export function setFetchCursorUsableModelsForTests(next: CursorUsableModelsFetcher | null): void {
@@ -40,10 +52,11 @@ export function setFetchCursorUsableModelsForTests(next: CursorUsableModelsFetch
 
 const RETRYABLE_DISCOVERY_ERRORS = new Set(["timeout", "transport"]);
 const DISCOVERY_RETRY_TIMEOUT_MS = 3_000;
+const CURSOR_MAX_DISCOVERED_MODELS = 500;
 
 /**
- * Live discovery with ONE bounded retry for transient pre-response failures (fresh HTTP/2
- * session each attempt). Completed non-2xx responses ("http"), auth, decode, and empty are
+ * Live discovery with ONE bounded retry for transient pre-response failures (a fresh transport
+ * attempt each time). Completed non-2xx responses ("http"), auth, decode, and empty are
  * deterministic and never retried. The retry attempt's deadline is capped so a cache-miss
  * catalog poll cannot stall much past the primary timeout (~11.5s worst case, accepted in
  * devlog 260723_cursor_context_continuity/030).
@@ -83,6 +96,104 @@ function resolveCursorDiscoveryBaseUrl(raw: string): { ok: true; baseUrl: string
 }
 
 async function fetchCursorUsableModelsOnce(opts: CursorUsableModelsOptions): Promise<CursorUsableModelsResult> {
+  if (isPinnedHttp1(opts.upstreamHttpVersion)) return fetchCursorUsableModelsHttp1Once(opts);
+  return fetchCursorUsableModelsHttp2Once(opts);
+}
+
+function cursorDiscoveryHeaders(opts: CursorUsableModelsOptions): Record<string, string> {
+  return {
+    "content-type": "application/proto",
+    "connect-protocol-version": "1",
+    authorization: `Bearer ${opts.apiKey}`,
+    "x-ghost-mode": "true",
+    "x-cursor-client-version": opts.clientVersion ?? CURSOR_DISCOVERY_CLIENT_VERSION,
+    "x-cursor-client-type": "cli",
+    "x-session-id": crypto.randomUUID(),
+  };
+}
+
+function decodeCursorUsableModels(bytes: Uint8Array): CursorUsableModelsResult {
+  try {
+    const response = fromBinary(GetUsableModelsResponseSchema, bytes);
+    // Account filtering uses wire `model_id` values only. Aliases like `composer-2-5` must not
+    // make stale configured ids such as `composer-2` look activated.
+    const ids: string[] = [];
+    const seenIds = new Set<string>();
+    for (const model of response.models ?? []) {
+      const rawId = (model as { modelId?: string }).modelId;
+      if (typeof rawId !== "string") continue;
+      const id = rawId.trim();
+      if (!isValidModelDiscoveryModelId(id) || seenIds.has(id)) continue;
+      seenIds.add(id);
+      ids.push(id);
+      if (ids.length >= CURSOR_MAX_DISCOVERED_MODELS) break;
+    }
+    return ids.length > 0 ? { ok: true, models: ids } : { ok: false, error: "empty" };
+  } catch {
+    return { ok: false, error: "decode", detail: "Invalid GetUsableModels protobuf response" };
+  }
+}
+
+async function fetchCursorUsableModelsHttp1Once(opts: CursorUsableModelsOptions): Promise<CursorUsableModelsResult> {
+  let requestUrl: string;
+  try {
+    const parsed = new URL(CURSOR_GET_USABLE_MODELS_PATH, opts.baseUrl ?? "https://api2.cursor.sh");
+    if (parsed.protocol !== "https:") {
+      return { ok: false, error: "policy", detail: "Cursor HTTP/1.1 discovery requires HTTPS" };
+    }
+    requestUrl = parsed.toString();
+  } catch {
+    return { ok: false, error: "transport", detail: "Cursor HTTP/1.1 discovery base URL is invalid" };
+  }
+  const timeoutMs = opts.timeoutMs ?? 8000;
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort(new DOMException(`No response within ${timeoutMs}ms`, "TimeoutError"));
+  }, timeoutMs);
+  try {
+    const init = withUpstreamHttpVersionValue(requestUrl, {
+      method: "POST",
+      headers: cursorDiscoveryHeaders(opts),
+      redirect: "manual",
+      signal: controller.signal,
+    }, opts.upstreamHttpVersion);
+    const response = await (opts.fetch ?? globalThis.fetch)(requestUrl, init);
+    if (response.status === 401 || response.status === 403) {
+      void response.body?.cancel().catch(() => undefined);
+      return { ok: false, error: "auth", detail: `HTTP ${response.status}` };
+    }
+    if (response.status !== 200) {
+      void response.body?.cancel().catch(() => undefined);
+      return { ok: false, error: "http", detail: `HTTP ${response.status || "unknown"}` };
+    }
+    const contentLength = Number(response.headers.get("content-length") ?? 0);
+    if (Number.isFinite(contentLength) && contentLength > CURSOR_MODEL_DISCOVERY_MAX_BYTES) {
+      void response.body?.cancel().catch(() => undefined);
+      return { ok: false, error: "too_large", detail: "GetUsableModels response exceeds 4 MiB" };
+    }
+    const body = await readBoundedResponseBytes(response, {
+      maxBytes: CURSOR_MODEL_DISCOVERY_MAX_BYTES,
+      signal: controller.signal,
+    });
+    if (body.oversized) {
+      return { ok: false, error: "too_large", detail: "GetUsableModels response exceeds 4 MiB" };
+    }
+    return decodeCursorUsableModels(body.bytes);
+  } catch (error) {
+    if (error instanceof UpstreamHttpVersionTargetError) {
+      return { ok: false, error: "policy", detail: error.message };
+    }
+    return timedOut
+      ? { ok: false, error: "timeout", detail: `No response within ${timeoutMs}ms` }
+      : { ok: false, error: "transport", detail: "HTTP/1.1 request failed" };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function fetchCursorUsableModelsHttp2Once(opts: CursorUsableModelsOptions): Promise<CursorUsableModelsResult> {
   const baseUrl = (opts.baseUrl ?? "https://api2.cursor.sh").replace(/\/+$/, "");
   const timeoutMs = opts.timeoutMs ?? 8000;
 
@@ -118,13 +229,7 @@ async function fetchCursorUsableModelsOnce(opts: CursorUsableModelsOptions): Pro
       req = client.request({
         ":method": "POST",
         ":path": CURSOR_GET_USABLE_MODELS_PATH,
-        "content-type": "application/proto",
-        "connect-protocol-version": "1",
-        authorization: `Bearer ${opts.apiKey}`,
-        "x-ghost-mode": "true",
-        "x-cursor-client-version": opts.clientVersion ?? CURSOR_DISCOVERY_CLIENT_VERSION,
-        "x-cursor-client-type": "cli",
-        "x-session-id": crypto.randomUUID(),
+        ...cursorDiscoveryHeaders(opts),
       });
     } catch {
       return close({ ok: false, error: "transport", detail: "HTTP/2 request setup failed" });
@@ -161,25 +266,7 @@ async function fetchCursorUsableModelsOnce(opts: CursorUsableModelsOptions): Pro
         return close({ ok: false, error: "auth", detail: `HTTP ${status}` });
       }
       if (status !== 200) return close({ ok: false, error: "http", detail: `HTTP ${status || "unknown"}` });
-      try {
-        const response = fromBinary(GetUsableModelsResponseSchema, new Uint8Array(Buffer.concat(chunks)));
-        // Account filtering uses wire `model_id` values only. Aliases like `composer-2-5` must not
-        // make stale configured ids such as `composer-2` look activated.
-        const ids: string[] = [];
-        const seenIds = new Set<string>();
-        for (const model of response.models ?? []) {
-          const rawId = (model as { modelId?: string }).modelId;
-          if (typeof rawId !== "string") continue;
-          const id = rawId.trim();
-          if (id.length === 0 || /[\x00-\x1f]/.test(id) || seenIds.has(id)) continue;
-          seenIds.add(id);
-          ids.push(id);
-          if (ids.length === 500) break;
-        }
-        close(ids.length > 0 ? { ok: true, models: ids } : { ok: false, error: "empty" });
-      } catch {
-        close({ ok: false, error: "decode", detail: "Invalid GetUsableModels protobuf response" });
-      }
+      close(decodeCursorUsableModels(new Uint8Array(Buffer.concat(chunks))));
     });
 
     req.end(); // CRITICAL: no body argument (empty Buffer breaks Bun's HTTP/2 framing).
diff --git a/src/adapters/cursor/live-transport.ts b/src/adapters/cursor/live-transport.ts
index 0d32b94b5b..3f8ce957a9 100644
--- a/src/adapters/cursor/live-transport.ts
+++ b/src/adapters/cursor/live-transport.ts
@@ -81,6 +81,8 @@ import {
 } from "./native-exec-shell";
 import type { CursorClientMessage, CursorRunRequest, CursorServerMessage } from "./types";
 import type { CursorTransport, CursorTransportFactoryInput } from "./transport";
+import { CursorHttp1BidiConnection } from "./http1-bidi";
+import { isPinnedHttp1 } from "../../lib/upstream-http-version";
 
 const CURSOR_RUN_PATH = "/agent.v1.AgentService/Run";
 const CURSOR_CLIENT_VERSION = "cli-2026.07.08-0c04a8a";
@@ -406,6 +408,7 @@ export function clientToolFinalizeGraceMsForRequest(request: CursorRunRequest, b
 class LiveCursorTransport implements CursorTransport {
   private session?: http2.ClientHttp2Session;
   private stream?: http2.ClientHttp2Stream;
+  private http1Connection?: CursorHttp1BidiConnection;
   private heartbeat?: ReturnType<typeof setInterval>;
   private firstFrameTimer?: ReturnType<typeof setTimeout>;
   private committed = false;
@@ -683,12 +686,24 @@ class LiveCursorTransport implements CursorTransport {
       || this.pendingTransportFrames >= CURSOR_MAX_PENDING_FRAMES
     ) {
       this.stream?.pause();
+      this.http1Connection?.pause();
       return;
     }
     if (
       this.transportBufferedBytes <= CURSOR_TRANSPORT_RESUME_BYTES
       && this.pendingTransportFrames <= CURSOR_PENDING_FRAMES_RESUME
-    ) this.stream?.resume();
+    ) {
+      this.stream?.resume();
+      this.http1Connection?.resume();
+    }
+  }
+
+  private writeConnectFrame(frame: Uint8Array): void {
+    if (this.http1Connection) {
+      this.http1Connection.write(frame);
+      return;
+    }
+    this.stream?.write(frame);
   }
 
   requestCommitted(): boolean {
@@ -712,6 +727,7 @@ class LiveCursorTransport implements CursorTransport {
     this.clearFirstFrameTimer();
     this.stream?.close();
     this.session?.close();
+    this.http1Connection?.close();
     this.releaseBlobRequestScope();
     this.releaseMcpObservation?.();
     this.releaseMcpObservation = undefined;
@@ -724,12 +740,16 @@ class LiveCursorTransport implements CursorTransport {
     this.clearPendingFinalize();
     if (this.heartbeat) clearInterval(this.heartbeat);
     this.clearFirstFrameTimer();
-    try {
-      this.stream?.close(http2.constants.NGHTTP2_CANCEL);
-    } catch {
-      this.stream?.destroy();
+    if (this.http1Connection) {
+      this.http1Connection.close();
+    } else {
+      try {
+        this.stream?.close(http2.constants.NGHTTP2_CANCEL);
+      } catch {
+        this.stream?.destroy();
+      }
+      this.session?.close();
     }
-    this.session?.close();
     this.releaseBlobRequestScope();
     this.releaseMcpObservation?.();
     this.releaseMcpObservation = undefined;
@@ -794,35 +814,52 @@ class LiveCursorTransport implements CursorTransport {
     fail: (error: Error) => void,
     finish: () => void,
   ): void {
+    if (signal?.aborted) {
+      fail(signal.reason instanceof Error ? signal.reason : new Error("Cursor request was aborted"));
+      return;
+    }
     this.turnStartedAt = Date.now();
     this.framesReceived = 0;
     this.sawAssistantText = false;
     this.emittedTerminal = false;
     this.firstFrameAt = undefined;
     this.firstFrameLogged = false;
-    const dialHost = cursorHostLabel(this.input.provider.baseUrl || "https://api2.cursor.sh");
-    debugProviderDiagnostic("cursor", "dial", { host: dialHost });
-    this.session = http2.connect(this.input.provider.baseUrl || "https://api2.cursor.sh");
-    // The run request is buffered until the HTTP/2 session connects. Failures before `connect`
-    // (DNS, ECONNREFUSED, TLS, connect timeout) mean the server never received the request, so they
-    // are safe to retry. Once connected, bytes flush to the server and the turn must not be replayed.
-    this.session.on("connect", () => {
-      this.committed = true;
-      debugProviderDiagnostic("cursor", "connected", { connectMs: Date.now() - this.turnStartedAt });
-    });
-    this.stream = this.session.request({
-      ":method": "POST",
-      ":path": CURSOR_RUN_PATH,
-      "content-type": "application/connect+proto",
-      "connect-protocol-version": "1",
-      te: "trailers",
-      authorization: `Bearer ${this.token}`,
-      "x-ghost-mode": "true",
-      "x-cursor-client-version": CURSOR_CLIENT_VERSION,
-      "x-cursor-client-type": "cli",
-      "x-request-id": crypto.randomUUID(),
-      "x-session-id": this.sessionId,
-    });
+    const baseUrl = this.input.provider.baseUrl || "https://api2.cursor.sh";
+    const useHttp1 = isPinnedHttp1(this.input.provider.upstreamHttpVersion);
+    const requestId = crypto.randomUUID();
+    const dialHost = cursorHostLabel(baseUrl);
+    debugProviderDiagnostic("cursor", "dial", { host: dialHost, transport: useHttp1 ? "http1.1" : "http2" });
+
+    let session: http2.ClientHttp2Session | undefined;
+    let stream: http2.ClientHttp2Stream | undefined;
+    if (!useHttp1) {
+      session = http2.connect(baseUrl);
+      this.session = session;
+      // The run request is buffered until the HTTP/2 session connects. Failures before `connect`
+      // (DNS, ECONNREFUSED, TLS, connect timeout) mean the server never received the request, so they
+      // are safe to retry. Once connected, bytes flush to the server and the turn must not be replayed.
+      session.on("connect", () => {
+        this.committed = true;
+        debugProviderDiagnostic("cursor", "connected", {
+          transport: "http2",
+          connectMs: Date.now() - this.turnStartedAt,
+        });
+      });
+      stream = session.request({
+        ":method": "POST",
+        ":path": CURSOR_RUN_PATH,
+        "content-type": "application/connect+proto",
+        "connect-protocol-version": "1",
+        te: "trailers",
+        authorization: `Bearer ${this.token}`,
+        "x-ghost-mode": "true",
+        "x-cursor-client-version": CURSOR_CLIENT_VERSION,
+        "x-cursor-client-type": "cli",
+        "x-request-id": requestId,
+        "x-session-id": this.sessionId,
+      });
+      this.stream = stream;
+    }
 
     // Single-shot terminal owner for this turn (createTerminalSettler): stream error, session
     // error, trailers, end, abort, and the first-frame timeout all race into it, and only the
@@ -848,11 +885,9 @@ class LiveCursorTransport implements CursorTransport {
       }
       settler.settleFail(error);
     };
-    const session = this.session;
-    const stream = this.stream;
     // Session-level errors (TLS/socket/GOAWAY) do not always propagate to the stream listener;
     // without this handler they could bypass orderly failure reporting entirely.
-    session.on("error", err => {
+    const onSessionError = (err: unknown) => {
       const realErr = err instanceof Error ? err : new Error(String(err));
       debugProviderDiagnostic("cursor", "session-error", {
         code: String((realErr as { code?: unknown }).code ?? ""),
@@ -860,15 +895,18 @@ class LiveCursorTransport implements CursorTransport {
         elapsedMs: Date.now() - this.turnStartedAt,
       });
       failAndClear(realErr);
-    });
+    };
     this.firstFrameTimer = setTimeout(() => {
       this.firstFrameTimer = undefined;
       debugProviderDiagnostic("cursor", "first-frame-timeout", { timeoutMs: this.input.firstFrameTimeoutMs ?? CURSOR_FIRST_FRAME_TIMEOUT_MS });
-      try { stream.close(); } catch { /* already closing */ }
-      try { session.close(); } catch { /* already closing */ }
-      // close() waits for in-flight frames; a dead socket can ignore it — force-destroy shortly
-      // after so a stalled TLS session cannot linger past the timeout.
-      armTimeoutDestroyFallback(stream, session, this.input.timeoutDestroyGraceMs ?? CURSOR_TIMEOUT_DESTROY_GRACE_MS);
+      try { stream?.close(); } catch { /* already closing */ }
+      try { session?.close(); } catch { /* already closing */ }
+      this.http1Connection?.close();
+      if (stream && session) {
+        // close() waits for in-flight frames; a dead socket can ignore it — force-destroy shortly
+        // after so a stalled TLS session cannot linger past the timeout.
+        armTimeoutDestroyFallback(stream, session, this.input.timeoutDestroyGraceMs ?? CURSOR_TIMEOUT_DESTROY_GRACE_MS);
+      }
       releaseBacklogLease();
       settler.settleFail(new Error("Cursor transport timed out before first response"));
     }, this.input.firstFrameTimeoutMs ?? CURSOR_FIRST_FRAME_TIMEOUT_MS);
@@ -966,7 +1004,7 @@ class LiveCursorTransport implements CursorTransport {
           });
       }
     };
-    this.stream.on("data", chunk => {
+    const onData = (chunk: string | Uint8Array) => {
       this.clearFirstFrameTimer();
       // Once the turn has settled, late network bytes must never be charged —
       // the backlog lease is already released and nobody would own these.
@@ -995,13 +1033,13 @@ class LiveCursorTransport implements CursorTransport {
         if (charged && !appended) this.releaseTransportBytes(bytes.byteLength);
         failAndClear(err instanceof Error ? err : new Error(String(err)));
       }
-    });
-    this.stream.on("trailers", trailers => {
+    };
+    const onTrailers = (trailers: http2.IncomingHttpHeaders) => {
       const status = trailers["grpc-status"];
       if (status !== undefined) debugProviderDiagnostic("cursor", "trailers", { grpcStatus: String(status) });
       if (status && status !== "0") failAndClear(new Error(`Cursor gRPC error ${status}`));
-    });
-    this.stream.on("error", err => {
+    };
+    const onStreamError = (err: unknown) => {
       const realErr = err instanceof Error ? err : new Error(String(err));
       if (this.expectedClose) {
         failAndClear(realErr);
@@ -1019,8 +1057,8 @@ class LiveCursorTransport implements CursorTransport {
         elapsedMs: Date.now() - this.turnStartedAt,
       });
       failAndClear(realErr);
-    });
-    this.stream.on("end", () => {
+    };
+    const onStreamEnd = () => {
       this.clearFirstFrameTimer();
       debugProviderDiagnostic("cursor", "stream-end", {
         committed: this.committed,
@@ -1081,16 +1119,56 @@ class LiveCursorTransport implements CursorTransport {
       }, (err) => {
         failAndClear(err instanceof Error ? err : new Error(String(err)));
       });
-    });
+    };
+
+    if (useHttp1) {
+      const providerFetch = this.input.fetch
+        ?? (this.input.provider as OcxProviderConfig & { fetch?: typeof globalThis.fetch }).fetch;
+      this.http1Connection = new CursorHttp1BidiConnection({
+        baseUrl,
+        token: this.token,
+        clientVersion: CURSOR_CLIENT_VERSION,
+        sessionId: this.sessionId,
+        requestId,
+        translatorBudget: this.translatorBudget,
+        callbacks: {
+          onCommitted: () => {
+            this.committed = true;
+            debugProviderDiagnostic("cursor", "connected", {
+              transport: "http1.1",
+              connectMs: Date.now() - this.turnStartedAt,
+            });
+          },
+          onData,
+          onEnd: onStreamEnd,
+          onError: onStreamError,
+        },
+        ...(providerFetch ? { fetch: providerFetch } : {}),
+      });
+      this.http1Connection.start();
+    } else {
+      session!.on("error", onSessionError);
+      stream!.on("data", onData);
+      stream!.on("trailers", onTrailers);
+      stream!.on("error", onStreamError);
+      stream!.on("end", onStreamEnd);
+    }
 
     signal?.addEventListener("abort", () => {
       this.close();
       failAndClear(new Error("Cursor request was aborted"));
     }, { once: true });
+    // Close the race between the preflight above and listener installation. No request payload is
+    // written until after this check.
+    if (signal?.aborted) {
+      this.close();
+      failAndClear(signal.reason instanceof Error ? signal.reason : new Error("Cursor request was aborted"));
+      return;
+    }
 
-    this.stream.write(encodeConnectFrame(encodedRequest));
+    this.writeConnectFrame(encodeConnectFrame(encodedRequest));
     this.heartbeat = setInterval(() => {
-      this.stream?.write(encodeClientMessage({
+      this.writeConnectFrame(encodeClientMessage({
         message: { case: "clientHeartbeat", value: create(ClientHeartbeatSchema, {}) },
       }));
     }, HEARTBEAT_MS);
@@ -1101,10 +1179,10 @@ class LiveCursorTransport implements CursorTransport {
     state: ReturnType<typeof createCursorProtobufEventState>,
     push: (message: CursorServerMessage) => void,
   ): Promise<void> {
-    if (!this.stream) return;
+    if (!this.stream && !this.http1Connection) return;
     debugProviderDiagnostic("cursor", "frame", describeCursorServerFrame(message));
     if (message.message.case === "kvServerMessage") {
-      this.stream.write(encodeConnectFrame(handleCursorNativeKv(message.message.value, this.blobRequestScope)));
+      this.writeConnectFrame(encodeConnectFrame(handleCursorNativeKv(message.message.value, this.blobRequestScope)));
       return;
     }
     if (message.message.case === "execServerMessage") {
@@ -1125,7 +1203,7 @@ class LiveCursorTransport implements CursorTransport {
       // run the same local action twice.
       push({ type: "local_side_effect" });
       const replies = await handleCursorNativeExec(message.message.value, this.execContext);
-      for (const reply of replies) this.stream.write(encodeConnectFrame(reply));
+      for (const reply of replies) this.writeConnectFrame(encodeConnectFrame(reply));
       return;
     }
     if (message.message.case === "interactionQuery") {
@@ -1135,7 +1213,7 @@ class LiveCursorTransport implements CursorTransport {
       const query = message.message.value;
       const plan = planInteractionQueryReply(query);
       debugProviderDiagnostic("cursor", "interaction-query", { id: query.id, queryCase: query.query.case ?? "unknown", reply: plan.replyCase });
-      this.stream.write(encodeClientMessage({ message: { case: "interactionResponse", value: plan.response } }));
+      this.writeConnectFrame(encodeClientMessage({ message: { case: "interactionResponse", value: plan.response } }));
       if (!state.terminated) {
         if (plan.planText) {
           this.sawAssistantText = true;
diff --git a/src/adapters/cursor/transport.ts b/src/adapters/cursor/transport.ts
index ce18fbd5be..e212615d6e 100644
--- a/src/adapters/cursor/transport.ts
+++ b/src/adapters/cursor/transport.ts
@@ -18,6 +18,8 @@ export interface CursorTransportFactoryInput {
   provider: OcxProviderConfig;
   translatorBudget: TranslatorBudget;
   headers?: Headers;
+  /** Router-prepared fetch that preserves provider overrides and per-request pacing. */
+  fetch?: typeof globalThis.fetch;
   /** Pre-first-frame deadline (dial + first server frame). Defaults to 30s when omitted. */
   firstFrameTimeoutMs?: number;
   /** Grace (ms) between close() and the force-destroy fallback after a first-frame timeout. Defaults to 1s. */
diff --git a/src/codex/catalog/provider-fetch.ts b/src/codex/catalog/provider-fetch.ts
index 69203c8940..93d36ac8ae 100644
--- a/src/codex/catalog/provider-fetch.ts
+++ b/src/codex/catalog/provider-fetch.ts
@@ -1214,7 +1214,13 @@ async function fetchProviderModelsWithAuth(
         "degraded",
       );
     }
-    const liveResult = await fetchCursorUsableModels({ apiKey, baseUrl: prov.baseUrl });
+    const cursorFetch = (prov as OcxProviderConfig & { fetch?: typeof globalThis.fetch }).fetch;
+    const liveResult = await fetchCursorUsableModels({
+      apiKey,
+      baseUrl: prov.baseUrl,
+      upstreamHttpVersion: prov.upstreamHttpVersion,
+      ...(cursorFetch ? { fetch: cursorFetch } : {}),
+    });
     if (liveResult.ok) {
       const available = filterCursorConfiguredModelsByLiveDiscovery(configured, liveResult.models);
       const result = available.length > 0 ? available : configured;
diff --git a/src/lib/upstream-http-version.ts b/src/lib/upstream-http-version.ts
new file mode 100644
index 0000000000..200a69e983
--- /dev/null
+++ b/src/lib/upstream-http-version.ts
@@ -0,0 +1,57 @@
+import type { OcxProviderConfig, UpstreamHttpVersion } from "../types";
+
+/** True when a provider explicitly selected the HTTP/1.1 compatibility path. */
+export function isPinnedHttp1(version: UpstreamHttpVersion | undefined): boolean {
+  return version === "http1.1" || version === "h1";
+}
+
+/**
+ * Bun's fetch accepts a non-standard `protocol` init to pin the HTTP version
+ * (BunFetchRequestInit.protocol). The DOM lib types do not include it, so the
+ * value is represented through a RequestInit cast at this shared boundary.
+ */
+const UPSTREAM_HTTP_VERSION_PROTOCOL: Record<Exclude<UpstreamHttpVersion, "auto">, string> = {
+  "http1.1": "http1.1",
+  h1: "h1",
+  http2: "http2",
+  h2: "h2",
+};
+
+/** Raised before I/O when a fixed Bun HTTP-version pin cannot apply to the target URL. */
+export class UpstreamHttpVersionTargetError extends Error {
+  readonly code = "upstream_http_version_target";
+
+  constructor(readonly observedProtocol: string) {
+    super(`upstream HTTP version pin requires an HTTPS target (received ${observedProtocol})`);
+    this.name = "UpstreamHttpVersionTargetError";
+  }
+}
+
+/** Attach Bun's `protocol` pin for one explicit version value. */
+export function withUpstreamHttpVersionValue(
+  input: Parameters<typeof globalThis.fetch>[0],
+  init: RequestInit | undefined,
+  version: UpstreamHttpVersion | undefined,
+): RequestInit | undefined {
+  if (!version || version === "auto") return init;
+  // Bun's protocol pin requires an https: target. An explicit fixed-version request must fail
+  // locally when the pin cannot be honored instead of silently negotiating another transport.
+  const target = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+  let targetUrl: URL;
+  try {
+    targetUrl = new URL(target);
+  } catch {
+    throw new UpstreamHttpVersionTargetError("unparseable");
+  }
+  if (targetUrl.protocol !== "https:") throw new UpstreamHttpVersionTargetError(targetUrl.protocol);
+  return { ...(init ?? {}), protocol: UPSTREAM_HTTP_VERSION_PROTOCOL[version] } as RequestInit;
+}
+
+/** Attach Bun's `protocol` pin when the provider opted into a fixed HTTP version. */
+export function withUpstreamHttpVersion(
+  input: Parameters<typeof globalThis.fetch>[0],
+  init: RequestInit | undefined,
+  provider: Pick<OcxProviderConfig, "upstreamHttpVersion">,
+): RequestInit | undefined {
+  return withUpstreamHttpVersionValue(input, init, provider.upstreamHttpVersion);
+}
diff --git a/src/server/responses/core.ts b/src/server/responses/core.ts
index cda4108adc..052e4b412e 100644
--- a/src/server/responses/core.ts
+++ b/src/server/responses/core.ts
@@ -3444,9 +3444,26 @@ async function handleResponsesInner(
           await waitForProviderRequestSlot(route.providerName, route.provider, route.modelId, runTurnAbort.signal);
         }
         noteAttemptSend(logCtx.activeAttempt, logCtx.usageLogInputTokens, recovery);
+        const runTurnProviderFetch = providerFetch(
+          route.provider,
+          options.codexWsRuntimeIdentity,
+          {
+            providerName: route.providerName,
+            modelId: route.modelId,
+            // runTurnAttempt acquired this logical turn's first physical-request slot above.
+            // Cursor HTTP/1.1 consumes it for RunSSE; every BidiAppend and redial then waits on
+            // the same provider queue through this stateful wrapper.
+            pacingSlotAcquired: true,
+          },
+        );
         await adapter.runTurn?.(
           parsed,
-          { headers: selectedForwardHeaders, abortSignal: runTurnAbort.signal, translatorBudget },
+          {
+            headers: selectedForwardHeaders,
+            abortSignal: runTurnAbort.signal,
+            translatorBudget,
+            providerFetch: runTurnProviderFetch,
+          },
           targetQueue.push,
         );
       } catch (err) {
diff --git a/src/server/responses/fetch-helpers.ts b/src/server/responses/fetch-helpers.ts
index 21652a5345..1a296b4037 100644
--- a/src/server/responses/fetch-helpers.ts
+++ b/src/server/responses/fetch-helpers.ts
@@ -33,7 +33,7 @@ import {
 import { isInjectionDebugEnabled } from "../../lib/debug-settings";
 import { injectionDebugLog } from "../../lib/injection-debug-log";
 import { modelInList, namespacedToolName } from "../../types";
-import type { AdapterEvent, OcxConfig, OcxParsedRequest, OcxProviderConfig, OcxProviderContinuationState, OcxUsage, UpstreamHttpVersion } from "../../types";
+import type { AdapterEvent, OcxConfig, OcxParsedRequest, OcxProviderConfig, OcxProviderContinuationState, OcxUsage } from "../../types";
 import {
   forceRefreshOAuthAccessSnapshot,
   getOAuthCredentialApiBaseUrl,
@@ -103,7 +103,9 @@ import {
 import { hasResponsesItemIdRepair, relaySseWithResponsesItemIdRepair } from "../responses-item-id-repair";
 import type { EffectiveSubagentRoster, SpawnAgentSurface } from "../../codex/catalog";
 import { waitForProviderRequestSlot } from "../../providers/request-pacing";
+import { withUpstreamHttpVersion } from "../../lib/upstream-http-version";
 
+export { withUpstreamHttpVersion } from "../../lib/upstream-http-version";
 
 export function disableResponsesRequestTimeout(req: Request, server: Pick<Server<WsData>, "timeout"> | undefined): boolean {
   if (!server) return false;
@@ -147,38 +149,8 @@ export type ProviderFetch = typeof globalThis.fetch & PaceAwareFetch;
 export interface ProviderFetchOptions {
   providerName?: string;
   modelId?: string;
-}
-
-/**
- * Bun's fetch accepts a non-standard `protocol` init to pin the HTTP version
- * (BunFetchRequestInit.protocol). The DOM lib types do not include it, so the
- * value is carried on an intersection and stripped before non-Bun callers.
- * The accepted values are the shared UPSTREAM_HTTP_VERSION_VALUES enum from types.
- */
-const UPSTREAM_HTTP_VERSION_PROTOCOL: Record<Exclude<UpstreamHttpVersion, "auto">, string> = {
-  "http1.1": "http1.1",
-  h1: "h1",
-  http2: "http2",
-  h2: "h2",
-};
-
-/** Attach Bun's `protocol` pin when the provider opted into a fixed HTTP version. */
-export function withUpstreamHttpVersion(
-  input: Parameters<typeof globalThis.fetch>[0],
-  init: RequestInit | undefined,
-  provider: OcxProviderConfig,
-): RequestInit | undefined {
-  const version = provider.upstreamHttpVersion;
-  if (!version || version === "auto") return init;
-  // Bun's protocol pin requires an https: target; local/plaintext upstreams keep
-  // their existing transport untouched.
-  const target = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-  try {
-    if (new URL(target).protocol !== "https:") return init;
-  } catch {
-    return init;
-  }
-  return { ...(init ?? {}), protocol: UPSTREAM_HTTP_VERSION_PROTOCOL[version] } as RequestInit;
+  /** One pacing slot was acquired immediately before this fetch wrapper was created. */
+  pacingSlotAcquired?: boolean;
 }
 
 export function providerFetch(
@@ -196,9 +168,16 @@ export function providerFetch(
     }
     return base(input, withUpstreamHttpVersion(input, init, provider));
   };
-  const waitForPacing = (signal?: AbortSignal) => options.providerName
-    ? waitForProviderRequestSlot(options.providerName, provider, options.modelId, signal)
-    : Promise.resolve();
+  let pacingSlotAcquired = options.pacingSlotAcquired === true;
+  const waitForPacing = (signal?: AbortSignal) => {
+    if (pacingSlotAcquired) {
+      pacingSlotAcquired = false;
+      return Promise.resolve();
+    }
+    return options.providerName
+      ? waitForProviderRequestSlot(options.providerName, provider, options.modelId, signal)
+      : Promise.resolve();
+  };
   const wrapped = async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit) => {
     await waitForPacing(init?.signal ?? undefined);
     return unpaced(input, init);
diff --git a/src/types.ts b/src/types.ts
index ecf375f265..4abda9912d 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -1450,8 +1450,10 @@ export interface OcxProviderConfig {
    * HTTP/2 via TLS ALPN by default; some Cloudflare-fronted SSE endpoints hang on
    * HTTP/2 streaming responses (issue #1668). "http1.1" / "h1" forces HTTP/1.1,
    * "http2" / "h2" forces HTTP/2. Absent or "auto" keeps Bun's default negotiation
-   * (current behavior unchanged). Only meaningful for https: base URLs.
-  */
+   * (current behavior unchanged). Explicit pins require an https: target and fail locally when the
+   * pin cannot be honored. Cursor additionally maps an HTTP/1.1 pin onto its RunSSE + BidiAppend
+   * compatibility transport.
+   */
   upstreamHttpVersion?: UpstreamHttpVersion;
   /**
    * Google only. When `false`, the AI Studio (direct) path sends Gemini Flash ids
diff --git a/structure/04_transports-and-sidecars.md b/structure/04_transports-and-sidecars.md
index 717edc2a01..9b16bacbeb 100644
--- a/structure/04_transports-and-sidecars.md
+++ b/structure/04_transports-and-sidecars.md
@@ -859,7 +859,7 @@ surface is listed here so a maintainer can find the owner without grepping:
 | Mimo Free | `src/adapters/mimo-free.ts` | Client identity and JWT handling are transport-local; the per-install client id lives in the opencodex state root. |
 | Anthropic image ingress | `src/adapters/anthropic-image-guard.ts`, `src/adapters/anthropic-image-normalize.ts` | Oversized or unsupported images are normalized or rejected before reaching upstream. |
 | Adapter execution support | `src/adapters/run-turn-queue.ts`, `src/adapters/tool-catalog-nudge.ts`, `src/adapters/identity.ts`, `src/adapters/image.ts`, `src/adapters/upstream-http-error.ts` | Shared machinery: turn ordering, tool-catalog nudging, client fingerprinting, image conversion, upstream error normalization. |
-| Cursor (beyond the sections above) | `src/adapters/cursor/live-transport.ts`, `src/adapters/cursor/transport-retry.ts`, `src/adapters/cursor/mcp-manager.ts`, `src/adapters/cursor/thread-continuity.ts` | Thread continuity is the point: a retry must not start a new Cursor thread. |
+| Cursor (beyond the sections above) | `src/adapters/cursor/live-transport.ts`, `src/adapters/cursor/http1-bidi.ts`, `src/adapters/cursor/live-models.ts`, `src/adapters/cursor/transport-retry.ts`, `src/adapters/cursor/mcp-manager.ts`, `src/adapters/cursor/thread-continuity.ts` | Thread continuity is the point: a retry must not start a new Cursor thread. HTTP/2 remains the default; an explicit `http1.1`/`h1` pin maps the bidi run onto Cursor's `RunSSE` receive stream plus sequenced `BidiAppend` sends, and applies to live discovery too. |
 | Claude Messages | `src/server/claude-messages.ts` | Routed translation, a native Anthropic passthrough branch, and `count_tokens`. |
 | Chat Completions inbound | `src/server/chat-completions.ts`, `src/chat/` | Inbound translation onto the same routing pipeline. |
 | Hosted search relay | `src/server/search.ts` | Direct relay; distinct from the web-search sidecar loop below. |
diff --git a/tests/cursor-adapter.test.ts b/tests/cursor-adapter.test.ts
index 83f4b77263..ff7d6935ad 100644
--- a/tests/cursor-adapter.test.ts
+++ b/tests/cursor-adapter.test.ts
@@ -92,6 +92,29 @@ describe("Cursor adapter live transport", () => {
     ]);
   });
 
+  test("runTurn forwards the router-prepared provider fetch to the live transport", async () => {
+    const inputs: CursorTransportFactoryInput[] = [];
+    const pacedFetch = (async () => new Response()) as typeof fetch;
+    const adapter = createCursorAdapter({ ...provider, apiKey: "cursor-token" }, {
+      createTransport(input) {
+        inputs.push(input);
+        return {
+          async *run() { yield { type: "done" } satisfies CursorServerMessage; },
+          writeClient() {},
+        };
+      },
+    });
+
+    await adapter.runTurn?.(
+      { ...parsed, context: { messages: [{ role: "user", content: "hi", timestamp: 1 }] } },
+      { headers: new Headers(), providerFetch: pacedFetch },
+      () => {},
+    );
+
+    expect(inputs).toHaveLength(1);
+    expect(inputs[0]?.fetch).toBe(pacedFetch);
+  });
+
   test("runTurn preserves explicit Cursor Router optimization levels", async () => {
     const requests: CursorRunRequest[] = [];
     const adapter = createCursorAdapter(provider, {
diff --git a/tests/cursor-hardening.test.ts b/tests/cursor-hardening.test.ts
index 438ac2bc04..1de86d9738 100644
--- a/tests/cursor-hardening.test.ts
+++ b/tests/cursor-hardening.test.ts
@@ -85,6 +85,21 @@ describe("Cursor live-model discovery hardening", () => {
     expect(result).toEqual({ ok: true, models: ["gpt-5.5-high"] });
   });
 
+  test("filters every shared model-id control-character class", async () => {
+    const body = toBinary(GetUsableModelsResponseSchema, create(GetUsableModelsResponseSchema, {
+      models: [
+        create(ModelDetailsSchema, { modelId: "good-model" }),
+        create(ModelDetailsSchema, { modelId: "bad-del\u007f" }),
+        create(ModelDetailsSchema, { modelId: "bad-c1\u0085" }),
+        create(ModelDetailsSchema, { modelId: "bad-line\u2028separator" }),
+      ],
+    }));
+    const result = await withDiscoveryServer(respond(200, body), baseUrl =>
+      fetchCursorUsableModels({ apiKey: "test-token", baseUrl }));
+
+    expect(result).toEqual({ ok: true, models: ["good-model"] });
+  });
+
   test("rejects a cleartext non-loopback discovery URL before connecting", async () => {
     const result = await fetchCursorUsableModels({
       apiKey: "test-token",
@@ -98,6 +113,142 @@ describe("Cursor live-model discovery hardening", () => {
     });
   });
 
+  test("HTTP/1.1 discovery uses fetch with Bun's protocol pin", async () => {
+    const body = toBinary(GetUsableModelsResponseSchema, create(GetUsableModelsResponseSchema, {
+      models: [create(ModelDetailsSchema, { modelId: "claude-opus-5" })],
+    }));
+    let seenUrl = "";
+    let seenInit: RequestInit | undefined;
+    const fetchImpl = (async (input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+      seenUrl = String(input);
+      seenInit = init;
+      return new Response(body, { status: 200, headers: { "content-type": "application/proto" } });
+    }) as typeof fetch;
+
+    const result = await fetchCursorUsableModels({
+      apiKey: "test-token",
+      baseUrl: "https://api2.cursor.sh",
+      upstreamHttpVersion: "http1.1",
+      fetch: fetchImpl,
+    });
+
+    expect(result).toEqual({ ok: true, models: ["claude-opus-5"] });
+    expect(seenUrl).toBe("https://api2.cursor.sh/agent.v1.AgentService/GetUsableModels");
+    expect(seenInit?.method).toBe("POST");
+    expect(seenInit?.redirect).toBe("manual");
+    expect((seenInit as RequestInit & { protocol?: string }).protocol).toBe("http1.1");
+    expect(new Headers(seenInit?.headers).get("authorization")).toBe("Bearer test-token");
+  });
+
+  test("HTTP/1.1 discovery rejects announced and streamed 4 MiB overflow before decode", async () => {
+    let announcedCalls = 0;
+    const announced = await fetchCursorUsableModels({
+      apiKey: "test-token",
+      baseUrl: "https://api2.cursor.sh",
+      upstreamHttpVersion: "http1.1",
+      fetch: (async () => {
+        announcedCalls += 1;
+        return new Response(new Uint8Array(), {
+          status: 200,
+          headers: { "content-length": String(4 * 1024 * 1024 + 1) },
+        });
+      }) as typeof fetch,
+    });
+    expect(announced).toMatchObject({ ok: false, error: "too_large" });
+    expect(announcedCalls).toBe(1);
+
+    let streamedCalls = 0;
+    const streamed = await fetchCursorUsableModels({
+      apiKey: "test-token",
+      baseUrl: "https://api2.cursor.sh",
+      upstreamHttpVersion: "http1.1",
+      fetch: (async () => {
+        streamedCalls += 1;
+        return new Response(new ReadableStream<Uint8Array>({
+          start(controller) {
+            controller.enqueue(new Uint8Array(4 * 1024 * 1024));
+            controller.enqueue(Uint8Array.of(0));
+            controller.close();
+          },
+        }), { status: 200 });
+      }) as typeof fetch,
+    });
+    expect(streamed).toMatchObject({ ok: false, error: "too_large" });
+    expect(streamedCalls).toBe(1);
+  });
+
+  test("discovery rejects a cleartext non-loopback URL before exposing the token, even with an HTTP/1.1 pin", async () => {
+    let fetchCalls = 0;
+    const fetchImpl = (async () => {
+      fetchCalls += 1;
+      return new Response(new Uint8Array(), { status: 200 });
+    }) as typeof fetch;
+
+    const result = await fetchCursorUsableModels({
+      apiKey: "must-not-leave-process",
+      baseUrl: "http://api2.cursor.sh",
+      upstreamHttpVersion: "http1.1",
+      fetch: fetchImpl,
+    });
+
+    expect(result).toEqual({ ok: false, error: "transport", detail: "Cursor discovery URL must use HTTPS" });
+    expect(fetchCalls).toBe(0);
+  });
+
+  test("HTTP/1.1 discovery rejects an admitted loopback URL without retrying or invoking fetch", async () => {
+    let fetchCalls = 0;
+    const fetchImpl = (async () => {
+      fetchCalls += 1;
+      return new Response(new Uint8Array(), { status: 200 });
+    }) as typeof fetch;
+
+    const result = await fetchCursorUsableModels({
+      apiKey: "must-not-leave-process",
+      baseUrl: "http://127.0.0.1:1",
+      upstreamHttpVersion: "http1.1",
+      fetch: fetchImpl,
+    });
+
+    expect(result).toEqual({
+      ok: false,
+      error: "policy",
+      detail: "Cursor HTTP/1.1 discovery requires HTTPS",
+    });
+    expect(fetchCalls).toBe(0);
+  });
+
+  test("Cursor catalog propagates the provider HTTP/1.1 pin to discovery", async () => {
+    const providerName = "cursor-http1-discovery";
+    const body = toBinary(GetUsableModelsResponseSchema, create(GetUsableModelsResponseSchema, {
+      models: [create(ModelDetailsSchema, { modelId: "claude-opus-5" })],
+    }));
+    let seenProtocol: string | undefined;
+    const fetchImpl = (async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+      seenProtocol = (init as RequestInit & { protocol?: string } | undefined)?.protocol;
+      return new Response(body, { status: 200, headers: { "content-type": "application/proto" } });
+    }) as typeof fetch;
+
+    try {
+      const models = await gatherRoutedModels({
+        providers: {
+          [providerName]: {
+            adapter: "cursor",
+            baseUrl: "https://api2.cursor.sh",
+            apiKey: "test-token",
+            upstreamHttpVersion: "http1.1",
+            models: ["claude-opus-5"],
+            fetch: fetchImpl,
+          } as Parameters<typeof gatherRoutedModels>[0]["providers"][string] & { fetch: typeof fetch },
+        },
+      });
+
+      expect(models.map(model => `${model.provider}/${model.id}`)).toContain(`${providerName}/claude-opus-5`);
+      expect(seenProtocol).toBe("http1.1");
+    } finally {
+      clearModelCache(providerName);
+    }
+  });
+
   test("classifies authentication failures", async () => {
     const result = await withDiscoveryServer(respond(401), baseUrl =>
       fetchCursorUsableModels({ apiKey: "bad-token", baseUrl }));
diff --git a/tests/cursor-http1-transport.test.ts b/tests/cursor-http1-transport.test.ts
new file mode 100644
index 0000000000..10ebd6c422
--- /dev/null
+++ b/tests/cursor-http1-transport.test.ts
@@ -0,0 +1,514 @@
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+import { describe, expect, test } from "bun:test";
+import {
+  AgentClientMessageSchema,
+  AgentServerMessageSchema,
+  BidiRequestIdSchema,
+  CreatePlanArgsSchema,
+  CreatePlanRequestQuerySchema,
+  InteractionQuerySchema,
+  InteractionUpdateSchema,
+  McpArgsSchema,
+  McpToolCallSchema,
+  TextDeltaUpdateSchema,
+  ToolCallSchema,
+  ToolCallStartedUpdateSchema,
+} from "../src/adapters/cursor/gen/agent_pb";
+import { decodeConnectFrame, encodeConnectFrame } from "../src/adapters/cursor/framing";
+import {
+  cursorBidiAppendRequestSize,
+  encodeCursorBidiAppendRequest,
+} from "../src/adapters/cursor/http1-bidi";
+import { createLiveCursorTransport } from "../src/adapters/cursor/live-transport";
+import type { CursorRunRequest, CursorServerMessage } from "../src/adapters/cursor/types";
+import type { OcxProviderConfig } from "../src/types";
+import { createTestTranslatorBudget } from "./helpers/translator-budget";
+
+interface DecodedAppend {
+  data: string;
+  requestId: string;
+  appendSeqno: bigint;
+}
+
+function readVarint(bytes: Uint8Array, offset: number): { value: bigint; offset: number } {
+  let value = 0n;
+  let shift = 0n;
+  while (offset < bytes.byteLength) {
+    const byte = bytes[offset++]!;
+    value |= BigInt(byte & 0x7f) << shift;
+    if ((byte & 0x80) === 0) return { value, offset };
+    shift += 7n;
+    if (shift > 63n) throw new Error("fixture varint is too large");
+  }
+  throw new Error("fixture varint is incomplete");
+}
+
+function decodeAppend(bytes: Uint8Array): DecodedAppend {
+  let offset = 0;
+  let data = "";
+  let requestId = "";
+  let appendSeqno = 0n;
+  while (offset < bytes.byteLength) {
+    const tag = readVarint(bytes, offset);
+    offset = tag.offset;
+    const field = Number(tag.value >> 3n);
+    const wireType = Number(tag.value & 7n);
+    if (wireType === 2) {
+      const length = readVarint(bytes, offset);
+      offset = length.offset;
+      const end = offset + Number(length.value);
+      const value = bytes.subarray(offset, end);
+      offset = end;
+      if (field === 1) data = new TextDecoder().decode(value);
+      if (field === 2) requestId = fromBinary(BidiRequestIdSchema, value).requestId;
+      continue;
+    }
+    if (wireType === 0) {
+      const value = readVarint(bytes, offset);
+      offset = value.offset;
+      if (field === 3) appendSeqno = value.value;
+      continue;
+    }
+    throw new Error(`unsupported fixture wire type ${wireType}`);
+  }
+  return { data, requestId, appendSeqno };
+}
+
+function bodyBytes(body: BodyInit | null | undefined): Uint8Array {
+  if (body instanceof Uint8Array) return body;
+  if (body instanceof ArrayBuffer) return new Uint8Array(body);
+  throw new Error(`unexpected request body ${Object.prototype.toString.call(body)}`);
+}
+
+function hexBytes(value: string): Uint8Array {
+  if (value.length % 2 !== 0) throw new Error("fixture hex payload has an odd length");
+  return Uint8Array.from({ length: value.length / 2 }, (_, index) =>
+    Number.parseInt(value.slice(index * 2, index * 2 + 2), 16));
+}
+
+function cursorProvider(
+  fetchImpl: typeof fetch,
+  baseUrl = "https://api2.cursor.sh",
+): OcxProviderConfig & { fetch: typeof fetch } {
+  return {
+    adapter: "cursor",
+    baseUrl,
+    apiKey: "test-token",
+    upstreamHttpVersion: "http1.1",
+    fetch: fetchImpl,
+  };
+}
+
+function heldRunSseResponse(signal: AbortSignal | null | undefined): Response {
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      const abort = () => controller.error(signal?.reason ?? new DOMException("aborted", "AbortError"));
+      if (signal?.aborted) abort();
+      else signal?.addEventListener("abort", abort, { once: true });
+    },
+  });
+  return new Response(body, {
+    status: 200,
+    headers: { "content-type": "application/connect+proto" },
+  });
+}
+
+function connectEndFrame(): Uint8Array {
+  return encodeConnectFrame(new TextEncoder().encode("{}"), { endStream: true });
+}
+
+function scriptedHttp1Fetch(frames: Uint8Array[]): typeof fetch {
+  let runController!: ReadableStreamDefaultController<Uint8Array>;
+  let delivered = false;
+  return (async (input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+    const url = new URL(String(input));
+    if (url.pathname === "/agent.v1.AgentService/RunSSE") {
+      const body = new ReadableStream<Uint8Array>({
+        start(controller) {
+          runController = controller;
+          const abort = () => {
+            try { controller.error(init?.signal?.reason ?? new DOMException("aborted", "AbortError")); } catch { /* closed */ }
+          };
+          if (init?.signal?.aborted) abort();
+          else init?.signal?.addEventListener("abort", abort, { once: true });
+        },
+      });
+      return new Response(body, {
+        status: 200,
+        headers: { "content-type": "application/connect+proto" },
+      });
+    }
+    if (url.pathname === "/aiserver.v1.BidiService/BidiAppend") {
+      if (!delivered) {
+        delivered = true;
+        queueMicrotask(() => {
+          for (const frame of frames) runController.enqueue(frame);
+          runController.close();
+        });
+      }
+      return new Response(new Uint8Array(), { status: 200 });
+    }
+    throw new Error(`unexpected Cursor compatibility endpoint ${url.pathname}`);
+  }) as typeof fetch;
+}
+
+async function runHttp1Turn(
+  fetchImpl: typeof fetch,
+  conversationId: string,
+  overrides: Partial<CursorRunRequest> = {},
+): Promise<{ messages: CursorServerMessage[]; failure?: Error }> {
+  const transport = createLiveCursorTransport({
+    provider: cursorProvider(fetchImpl),
+    translatorBudget: createTestTranslatorBudget(),
+    firstFrameTimeoutMs: 2_000,
+  });
+  const messages: CursorServerMessage[] = [];
+  let failure: Error | undefined;
+  try {
+    for await (const message of transport.run({
+      modelId: "claude-opus-5",
+      conversationId,
+      system: [],
+      messages: [{ role: "user", content: "hello" }],
+      ...overrides,
+    })) messages.push(message);
+  } catch (error) {
+    failure = error instanceof Error ? error : new Error(String(error));
+  } finally {
+    await transport.close?.();
+  }
+  return { messages, ...(failure ? { failure } : {}) };
+}
+
+describe("Cursor HTTP/1.1 compatibility transport", () => {
+  test("encodes the Cursor BidiAppend hex fallback wire shape", () => {
+    const payload = Uint8Array.of(0xde, 0xad, 0xbe, 0xef);
+    const encoded = encodeCursorBidiAppendRequest(payload, "request-123", 300n);
+
+    expect(encoded.byteLength).toBe(cursorBidiAppendRequestSize(payload.byteLength, "request-123", 300n));
+    expect(decodeAppend(encoded)).toEqual({
+      data: "deadbeef",
+      requestId: "request-123",
+      appendSeqno: 300n,
+    });
+  });
+
+  test("uses RunSSE for output and BidiAppend for the initial client message", async () => {
+    let runController!: ReadableStreamDefaultController<Uint8Array>;
+    let runRequestId = "";
+    const appends: DecodedAppend[] = [];
+    const paths: string[] = [];
+    const protocols: Array<string | undefined> = [];
+
+    const fetchImpl = (async (input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+      const url = new URL(String(input));
+      paths.push(url.pathname);
+      protocols.push((init as RequestInit & { protocol?: string } | undefined)?.protocol);
+      expect(new Headers(init?.headers).get("authorization")).toBe("Bearer test-token");
+
+      if (url.pathname === "/agent.v1.AgentService/RunSSE") {
+        const frame = decodeConnectFrame(bodyBytes(init?.body)).frame;
+        runRequestId = fromBinary(BidiRequestIdSchema, frame.payload).requestId;
+        const body = new ReadableStream<Uint8Array>({
+          start(controller) { runController = controller; },
+        });
+        return new Response(body, {
+          status: 200,
+          headers: { "content-type": "application/connect+proto" },
+        });
+      }
+
+      if (url.pathname === "/aiserver.v1.BidiService/BidiAppend") {
+        const append = decodeAppend(bodyBytes(init?.body));
+        appends.push(append);
+        queueMicrotask(() => {
+          runController.enqueue(encodeConnectFrame(new TextEncoder().encode("{}"), { endStream: true }));
+          runController.close();
+        });
+        return new Response(new Uint8Array(), { status: 200 });
+      }
+
+      throw new Error(`unexpected Cursor compatibility endpoint ${url.pathname}`);
+    }) as typeof fetch;
+
+    const transport = createLiveCursorTransport({
+      provider: cursorProvider(fetchImpl),
+      translatorBudget: createTestTranslatorBudget(),
+      firstFrameTimeoutMs: 2_000,
+    });
+
+    const output = [];
+    try {
+      for await (const message of transport.run({
+        modelId: "claude-opus-5",
+        conversationId: "cursor_http1_test",
+        system: [],
+        messages: [{ role: "user", content: "hello" }],
+      })) output.push(message);
+    } finally {
+      await transport.close?.();
+    }
+
+    expect(output).toEqual([]);
+    expect(paths).toEqual([
+      "/agent.v1.AgentService/RunSSE",
+      "/aiserver.v1.BidiService/BidiAppend",
+    ]);
+    expect(protocols).toEqual(["http1.1", "http1.1"]);
+    expect(runRequestId).not.toBe("");
+    expect(appends).toHaveLength(1);
+    expect(appends[0]?.requestId).toBe(runRequestId);
+    expect(appends[0]?.appendSeqno).toBe(0n);
+    expect(appends[0]?.data).not.toBe("");
+    expect(fromBinary(AgentClientMessageSchema, hexBytes(appends[0]!.data)).message.case).toBe("runRequest");
+    expect(transport.requestCommitted?.()).toBe(true);
+  });
+
+  test("waits for successful RunSSE registration before the first BidiAppend", async () => {
+    let releaseRunSse!: (response: Response) => void;
+    const runSseGate = new Promise<Response>(resolve => { releaseRunSse = resolve; });
+    let runController!: ReadableStreamDefaultController<Uint8Array>;
+    const paths: string[] = [];
+    const fetchImpl = (async (input: Parameters<typeof fetch>[0]) => {
+      const url = new URL(String(input));
+      paths.push(url.pathname);
+      if (url.pathname === "/agent.v1.AgentService/RunSSE") return runSseGate;
+      if (url.pathname === "/aiserver.v1.BidiService/BidiAppend") {
+        queueMicrotask(() => {
+          runController.enqueue(connectEndFrame());
+          runController.close();
+        });
+        return new Response(new Uint8Array(), { status: 200 });
+      }
+      throw new Error(`unexpected endpoint ${url.pathname}`);
+    }) as typeof fetch;
+
+    const pending = runHttp1Turn(fetchImpl, "cursor_http1_ready_order");
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(paths).toEqual(["/agent.v1.AgentService/RunSSE"]);
+
+    releaseRunSse(new Response(new ReadableStream<Uint8Array>({
+      start(controller) { runController = controller; },
+    }), {
+      status: 200,
+      headers: { "content-type": "application/connect+proto" },
+    }));
+    const result = await pending;
+
+    expect(result.failure).toBeUndefined();
+    expect(paths.slice(0, 2)).toEqual([
+      "/agent.v1.AgentService/RunSSE",
+      "/aiserver.v1.BidiService/BidiAppend",
+    ]);
+  });
+
+  test("a pre-aborted turn performs no HTTP/1.1 I/O", async () => {
+    let fetchCalls = 0;
+    const fetchImpl = (async () => {
+      fetchCalls += 1;
+      throw new Error("fetch must not run");
+    }) as typeof fetch;
+    const transport = createLiveCursorTransport({
+      provider: cursorProvider(fetchImpl),
+      translatorBudget: createTestTranslatorBudget(),
+      firstFrameTimeoutMs: 2_000,
+    });
+    const controller = new AbortController();
+    controller.abort(new Error("fixture pre-aborted"));
+
+    try {
+      await expect((async () => {
+        for await (const _message of transport.run({
+          modelId: "claude-opus-5",
+          conversationId: "cursor_http1_preaborted",
+          system: [],
+          messages: [{ role: "user", content: "hello" }],
+        }, controller.signal)) { /* drain */ }
+      })()).rejects.toThrow("fixture pre-aborted");
+      expect(fetchCalls).toBe(0);
+      expect(transport.requestCommitted?.()).toBe(false);
+    } finally {
+      await transport.close?.();
+    }
+  });
+
+  test("synthesizes done after assistant text on clean HTTP/1.1 EOF", async () => {
+    const textFrame = encodeConnectFrame(toBinary(AgentServerMessageSchema, create(AgentServerMessageSchema, {
+      message: {
+        case: "interactionUpdate",
+        value: create(InteractionUpdateSchema, {
+          message: { case: "textDelta", value: create(TextDeltaUpdateSchema, { text: "hello" }) },
+        }),
+      },
+    })));
+    const result = await runHttp1Turn(
+      scriptedHttp1Fetch([textFrame, connectEndFrame()]),
+      "cursor_http1_text_eof",
+    );
+
+    expect(result.failure).toBeUndefined();
+    expect(result.messages).toContainEqual({ type: "text", text: "hello" });
+    expect(result.messages.at(-1)).toMatchObject({ type: "done" });
+  });
+
+  test("synthesizes done after createPlanRequestQuery text on clean HTTP/1.1 EOF", async () => {
+    const planFrame = encodeConnectFrame(toBinary(AgentServerMessageSchema, create(AgentServerMessageSchema, {
+      message: {
+        case: "interactionQuery",
+        value: create(InteractionQuerySchema, {
+          id: 7,
+          query: {
+            case: "createPlanRequestQuery",
+            value: create(CreatePlanRequestQuerySchema, {
+              args: create(CreatePlanArgsSchema, {
+                name: "Fix bridge",
+                overview: "Two steps.",
+                plan: "1. read\n2. patch",
+              }),
+            }),
+          },
+        }),
+      },
+    })));
+    const result = await runHttp1Turn(
+      scriptedHttp1Fetch([planFrame, connectEndFrame()]),
+      "cursor_http1_plan_eof",
+    );
+
+    expect(result.failure).toBeUndefined();
+    expect(result.messages.some(message => message.type === "text" && message.text?.includes("Fix bridge"))).toBe(true);
+    expect(result.messages.at(-1)).toMatchObject({ type: "done" });
+  });
+
+  test("open tool call plus clean HTTP/1.1 EOF emits a truncation event", async () => {
+    const startedFrame = encodeConnectFrame(toBinary(AgentServerMessageSchema, create(AgentServerMessageSchema, {
+      message: {
+        case: "interactionUpdate",
+        value: create(InteractionUpdateSchema, {
+          message: {
+            case: "toolCallStarted",
+            value: create(ToolCallStartedUpdateSchema, {
+              callId: "call_1",
+              modelCallId: "model_1",
+              toolCall: create(ToolCallSchema, {
+                tool: {
+                  case: "mcpToolCall",
+                  value: create(McpToolCallSchema, {
+                    args: create(McpArgsSchema, {
+                      name: "get_time",
+                      toolName: "get_time",
+                      toolCallId: "call_1",
+                      providerIdentifier: "opencodex-responses",
+                    }),
+                  }),
+                },
+              }),
+            }),
+          },
+        }),
+      },
+    })));
+    const result = await runHttp1Turn(
+      scriptedHttp1Fetch([startedFrame, connectEndFrame()]),
+      "cursor_http1_open_tool_eof",
+      { tools: [{ name: "get_time", description: "t", parameters: { type: "object", properties: {} } }] },
+    );
+
+    expect(result.failure).toBeUndefined();
+    expect(result.messages.at(-1)).toMatchObject({
+      type: "error",
+      message: expect.stringContaining("incomplete tool call"),
+    });
+  });
+
+  test("keeps a proven pre-connect BidiAppend failure uncommitted", async () => {
+    const fetchImpl = (async (input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+      const url = new URL(String(input));
+      if (url.pathname === "/agent.v1.AgentService/RunSSE") return heldRunSseResponse(init?.signal);
+      throw Object.assign(new Error("fixture append connect failed"), { code: "ECONNREFUSED" });
+    }) as typeof fetch;
+    const translatorBudget = createTestTranslatorBudget();
+    const transport = createLiveCursorTransport({
+      provider: cursorProvider(fetchImpl),
+      translatorBudget,
+      firstFrameTimeoutMs: 2_000,
+    });
+
+    try {
+      await expect((async () => {
+        for await (const _message of transport.run({
+          modelId: "claude-opus-5",
+          conversationId: "cursor_http1_preconnect_failure",
+          system: [],
+          messages: [{ role: "user", content: "hello" }],
+        })) { /* drain */ }
+      })()).rejects.toThrow("fixture append connect failed");
+      expect(transport.requestCommitted?.()).toBe(false);
+    } finally {
+      await transport.close?.();
+    }
+    expect(translatorBudget.snapshot().currentBytes).toBe(0);
+  });
+
+  test("keeps ambiguous BidiAppend failures committed to prevent replay", async () => {
+    const fetchImpl = (async (input: Parameters<typeof fetch>[0], init?: RequestInit) => {
+      const url = new URL(String(input));
+      if (url.pathname === "/agent.v1.AgentService/RunSSE") return heldRunSseResponse(init?.signal);
+      throw new Error("fixture ambiguous append failure");
+    }) as typeof fetch;
+    const transport = createLiveCursorTransport({
+      provider: cursorProvider(fetchImpl),
+      translatorBudget: createTestTranslatorBudget(),
+      firstFrameTimeoutMs: 2_000,
+    });
+
+    try {
+      await expect((async () => {
+        for await (const _message of transport.run({
+          modelId: "claude-opus-5",
+          conversationId: "cursor_http1_ambiguous_failure",
+          system: [],
+          messages: [{ role: "user", content: "hello" }],
+        })) { /* drain */ }
+      })()).rejects.toThrow("fixture ambiguous append failure");
+      expect(transport.requestCommitted?.()).toBe(true);
+    } finally {
+      await transport.close?.();
+    }
+  });
+
+  test("rejects a cleartext HTTP/1.1 transport before invoking fetch", async () => {
+    let fetchCalls = 0;
+    const fetchImpl = (async () => {
+      fetchCalls += 1;
+      throw new Error("fetch must not run");
+    }) as typeof fetch;
+    const transport = createLiveCursorTransport({
+      provider: cursorProvider(fetchImpl, "http://api2.cursor.sh"),
+      translatorBudget: createTestTranslatorBudget(),
+      firstFrameTimeoutMs: 2_000,
+    });
+
+    try {
+      await expect((async () => {
+        for await (const _message of transport.run({
+          modelId: "claude-opus-5",
+          conversationId: "cursor_http1_cleartext",
+          system: [],
+          messages: [{ role: "user", content: "hello" }],
+        })) { /* drain */ }
+      })()).rejects.toThrow("requires an HTTPS base URL");
+      expect(fetchCalls).toBe(0);
+      expect(transport.requestCommitted?.()).toBe(false);
+    } finally {
+      await transport.close?.();
+    }
+  });
+
+  test("preserves the proto3 zero and later append sequence values", () => {
+    const payload = Uint8Array.of(1, 2, 3);
+    expect(decodeAppend(encodeCursorBidiAppendRequest(payload, "req", 0n)).appendSeqno).toBe(0n);
+    expect(decodeAppend(encodeCursorBidiAppendRequest(payload, "req", 1n)).appendSeqno).toBe(1n);
+  });
+});
diff --git a/tests/request-pacing.test.ts b/tests/request-pacing.test.ts
index 7df4c59c3a..c2be3e5b8e 100644
--- a/tests/request-pacing.test.ts
+++ b/tests/request-pacing.test.ts
@@ -107,6 +107,35 @@ describe("provider request pacing queue", () => {
     expect(status.lastModelId).toBe("model-a");
   });
 
+  test("a runTurn fetch consumes its pre-acquired slot once, then paces internal requests", async () => {
+    const clock = fakePacingClock();
+    setProviderRequestPacingRuntimeForTest(clock.runtime);
+    const starts: number[] = [];
+    const fetchImpl = Object.assign(async () => {
+      starts.push(clock.now());
+      return new Response("ok");
+    }, { preconnect() {} }) as typeof globalThis.fetch;
+    const configured = {
+      ...provider({ enabled: true, minIntervalMs: 100 }),
+      fetch: fetchImpl,
+    } as OcxProviderConfig & { fetch: typeof globalThis.fetch };
+
+    await waitForProviderRequestSlot("cursor", configured, "model-a");
+    const send = providerFetch(configured, undefined, {
+      providerName: "cursor",
+      modelId: "model-a",
+      pacingSlotAcquired: true,
+    });
+    await send("https://example.test/run-sse");
+    const append = send("https://example.test/bidi-append");
+
+    expect(starts).toHaveLength(1);
+    expect(providerRequestPacingStatus("cursor", configured).queued).toBe(1);
+    clock.advanceBy(100);
+    await append;
+    expect(starts).toEqual([0, 100]);
+  });
+
   test("aborted queued requests leave immediately and never consume a start", async () => {
     const configured = provider({ enabled: true, minIntervalMs: 1_000 });
     await waitForProviderRequestSlot("demo", configured, "first");
diff --git a/tests/upstream-http-version.test.ts b/tests/upstream-http-version.test.ts
index 34d555fa0b..8c99d8fbb8 100644
--- a/tests/upstream-http-version.test.ts
+++ b/tests/upstream-http-version.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { providerFetch, withUpstreamHttpVersion } from "../src/server/responses/fetch-helpers";
+import { UpstreamHttpVersionTargetError } from "../src/lib/upstream-http-version";
 import type { OcxProviderConfig } from "../src/types";
 
 const HTTPS_URL = "https://opencode.ai/zen/go/v1/chat/completions";
@@ -33,6 +34,14 @@ describe("withUpstreamHttpVersion", () => {
     expect(withUpstreamHttpVersion(HTTPS_URL, undefined, provider({ upstreamHttpVersion: "auto" }))).toBeUndefined();
   });
 
+  test("absent and auto pins leave plaintext and unparseable targets untouched", () => {
+    const init = { method: "POST", headers: {} };
+    expect(withUpstreamHttpVersion(HTTP_URL, init, provider())).toBe(init);
+    expect(withUpstreamHttpVersion(HTTP_URL, init, provider({ upstreamHttpVersion: "auto" }))).toBe(init);
+    expect(withUpstreamHttpVersion("not a url", init, provider())).toBe(init);
+    expect(withUpstreamHttpVersion("not a url", init, provider({ upstreamHttpVersion: "auto" }))).toBe(init);
+  });
+
   test("http1.1 pins the protocol on https targets", () => {
     const init = { method: "POST", headers: {} };
     const out = withUpstreamHttpVersion(HTTPS_URL, init, provider({ upstreamHttpVersion: "http1.1" }))!;
@@ -55,9 +64,17 @@ describe("withUpstreamHttpVersion", () => {
     }
   });
 
-  test("plain-http targets are left untouched (Bun protocol requires https)", () => {
+  test("plain-http targets fail clearly when an explicit pin cannot be honored", () => {
     const init = { method: "POST", headers: {} };
-    expect(withUpstreamHttpVersion(HTTP_URL, init, provider({ upstreamHttpVersion: "http1.1" }))).toBe(init);
+    let failure: unknown;
+    try {
+      withUpstreamHttpVersion(HTTP_URL, init, provider({ upstreamHttpVersion: "http1.1" }));
+    } catch (error) {
+      failure = error;
+    }
+    expect(failure).toBeInstanceOf(UpstreamHttpVersionTargetError);
+    expect((failure as UpstreamHttpVersionTargetError).observedProtocol).toBe("http:");
+    expect((failure as Error).message).toContain("received http:");
   });
 
   test("Request objects resolve their url for the https guard", () => {
@@ -67,9 +84,16 @@ describe("withUpstreamHttpVersion", () => {
     expect((out as RequestInit & { protocol?: string }).protocol).toBe("http1.1");
   });
 
-  test("unparseable targets degrade to the untouched init", () => {
+  test("unparseable targets fail clearly when a pin is configured", () => {
     const init = { method: "POST" };
-    expect(withUpstreamHttpVersion("not a url", init, provider({ upstreamHttpVersion: "http1.1" }))).toBe(init);
+    let failure: unknown;
+    try {
+      withUpstreamHttpVersion("not a url", init, provider({ upstreamHttpVersion: "http1.1" }));
+    } catch (error) {
+      failure = error;
+    }
+    expect(failure).toBeInstanceOf(UpstreamHttpVersionTargetError);
+    expect((failure as UpstreamHttpVersionTargetError).observedProtocol).toBe("unparseable");
   });
 
   test("absent init still applies the pin (providerFetch without init)", () => {
@@ -134,4 +158,19 @@ describe("providerFetch upstreamHttpVersion propagation", () => {
     expect(seen).toHaveLength(1);
     expect((seen[0] as RequestInit & { protocol?: string }).protocol).toBe("http1.1");
   });
+
+  test("a plaintext target with an explicit pin fails before the provider fetch runs", async () => {
+    let fetchCalls = 0;
+    const fetcher = providerFetch(provider({
+      upstreamHttpVersion: "http1.1",
+      fetch: (async () => {
+        fetchCalls += 1;
+        return new Response("must not run");
+      }) as typeof fetch,
+    }));
+
+    await expect(fetcher(HTTP_URL, { method: "POST" }))
+      .rejects.toThrow("upstream HTTP version pin requires an HTTPS target");
+    expect(fetchCalls).toBe(0);
+  });
 });