fix: final-review follow-ups — legacy SIDECAR=0 http1 under Bun, variant collision loop, abort parity, docs

Author: justin-carper

CHANGELOG.md

@@ -4,7 +4,7 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
-## [0.5.0] — 2026-07-23
+## [0.5.0-next.0] — 2026-07-23
 
 Native-experience overhaul: in-process HTTP/1.1 transport under Bun, typed-error
 reliability, and full streaming fidelity.

README.md

@@ -156,6 +156,7 @@ See [SECURITY.md](./SECURITY.md) for the full threat model.
 | `OPENCODE_CURSOR_TRANSPORT` | — | Force a transport: `http1` \| `http2-direct` \| `sidecar` — see [Transport](#transport) |
 | `OPENCODE_CURSOR_STALL_MS` | `60000` | Stream watchdog timeout (ms); `0` disables — see [Reliability](#reliability) |
 | `OPENCODE_CURSOR_SIDECAR` | — | Legacy: `1` maps to `sidecar`, `0` maps to `http2-direct` (superseded by `OPENCODE_CURSOR_TRANSPORT`) |
+| `OPENCODE_CURSOR_TOOL_INPUT_STREAM` | on | Set to `0` to disable live tool-input streaming (`tool-input-start`/`-delta`/`-end` parts) |
 
 ### Session reuse (`session`)
 

src/model-variants.ts

@@ -72,7 +72,9 @@ export function buildModelVariants(item: ModelListItem): Record<string, CursorVa
       const params: Record<string, string> = { ...defaults };
       for (const p of v.params ?? []) params[p.id] = p.value;
       const key = variantKey(v.displayName);
-      out[out[key] === undefined ? key : `${key}-2`] = { params };
+      let candidate = key;
+      for (let n = 2; out[candidate] !== undefined; n++) candidate = `${key}-${n}`;
+      out[candidate] = { params };
     }
     return out;
   }

src/provider/agent-backend.ts

@@ -75,7 +75,7 @@ export function resolveTransport(env: BackendEnvironment): TransportKind {
   if (legacy === "1" || legacy === "true") {
     return env.nodePath ? "sidecar" : env.isBun ? "http1" : "http2-direct";
   }
-  if (legacy === "0" || legacy === "false") return "http2-direct";
+  if (legacy === "0" || legacy === "false") return env.isBun ? "http1" : "http2-direct";
   return env.isBun ? DEFAULT_BUN_TRANSPORT : "http2-direct";
 }
 

src/provider/agent-events.ts

@@ -197,6 +197,9 @@ export async function* streamAgentTurn(
     )
       .then(async (run) => {
         runHolder.run = run;
+        // The signal may have fired while send() was in flight (before runHolder
+        // was populated, so onAbort had nothing to cancel); cancel now.
+        if (options.abortSignal?.aborted) void Promise.resolve(run.cancel()).catch(() => {});
         const result = await run.wait();
         if (debug) {
           console.error(

src/provider/index.ts

@@ -93,7 +93,7 @@ export interface CursorProviderOptions {
 	/**
 	 * Transport for Cursor agent traffic: "http1" (in-process, Bun-safe),
 	 * "http2-direct" (in-process, Node only), "sidecar" (Node child, rollback).
-	 * Beats OPENCODE_CURSOR_TRANSPORT. Process-global: first provider wins.
+	 * Beats OPENCODE_CURSOR_TRANSPORT. Process-global: last provider to set it wins.
 	 */
 	transport?: "http1" | "http2-direct" | "sidecar";
 }

src/provider/language-model.ts

@@ -369,6 +369,7 @@ export class CursorLanguageModel implements LanguageModelV3 {
 							{
 								mode,
 								abortSignal: options.abortSignal,
+								// Key intentionally diverges from the single-turn key: the multi-replay and single-turn branches are mutually exclusive.
 								idempotencyKey: sendIdempotencyKey(
 									sessionID,
 									{

test/agent-events.test.ts

@@ -252,6 +252,47 @@ describe("sendAgentTurnSilently", () => {
 		await promise;
 		expect(cancelled).toBe(true);
 	});
+
+	it("streamAgentTurn cancels the run when abort fires during the in-flight send", async () => {
+		// Abort lands after send() is called but before runHolder.run is
+		// populated (onAbort has nothing to cancel). The post-assignment guard
+		// in startRun must still cancel the resolved run.
+		let cancelled = false;
+		const controller = new AbortController();
+		let releaseSend: (() => void) | undefined;
+		const agent = {
+			agentId: "agent-inflight-abort",
+			send: async (
+				_message: SDKUserMessage,
+				_sendOptions?: Record<string, unknown>,
+			) => {
+				// Hold send() in flight until the caller releases it (post-abort).
+				await new Promise<void>((resolve) => {
+					releaseSend = resolve;
+				});
+				const run: Partial<Run> = {
+					wait: async () => ({ status: "cancelled" }) as never,
+					cancel: async () => {
+						cancelled = true;
+					},
+				};
+				return run as Run;
+			},
+		} as unknown as AgentLike;
+
+		const promise = collect(
+			streamAgentTurn(agent, MESSAGE, {
+				mode: "agent",
+				abortSignal: controller.signal,
+			}),
+		);
+		// Abort while send() is still in flight, then let send() resolve.
+		await new Promise((r) => setTimeout(r, 5));
+		controller.abort();
+		releaseSend?.();
+		await promise;
+		expect(cancelled).toBe(true);
+	});
 });
 
 describe("streamAgentTurn MCP error surfacing", () => {

test/model-variants.test.ts

@@ -259,6 +259,22 @@ describe("buildModelVariants", () => {
     expect(variants["turbo"]?.params).toEqual({ fast: "true", thinking: "high" });
   });
 
+  it("assigns distinct keys when three SDK variants slug to the same key", () => {
+    // Three displayNames that slugify identically must yield three distinct
+    // keys (key, key-2, key-3) via the collision counter — no variant lost.
+    const item = {
+      id: "m", displayName: "m",
+      parameters: [{ id: "thinking", values: [{ value: "low" }, { value: "high" }] }],
+      variants: [
+        { params: [{ id: "thinking", value: "low" }], displayName: "Deep Think" },
+        { params: [{ id: "thinking", value: "high" }], displayName: "Deep-Think" },
+        { params: [{ id: "thinking", value: "low" }], displayName: "Deep  Think!" },
+      ],
+    } as unknown as ModelListItem;
+    const variants = buildModelVariants(item);
+    expect(Object.keys(variants).sort()).toEqual(["deep-think", "deep-think-2", "deep-think-3"]);
+  });
+
   it("falls back to generated variants when SDK variants absent", () => {
     const item = {
       id: "m", displayName: "m",

test/stream-map.test.ts

@@ -486,6 +486,7 @@ describe("cursorEventsToStream", () => {
 		expect(types(parts)).toContain("text-end");
 		const finish = parts.find((p) => p.type === "finish");
 		expect(finish).toMatchObject({ finishReason: { unified: "error" } });
+		expect(parts.filter((p) => p.type === "finish")).toHaveLength(1);
 	});
 
 	it("uses empty usage when no usage event arrives", async () => {