Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

retry cursor resource network errors

Raine Virtad8389c59fd30
diff --git a/src/providers/cursor/client.test.ts b/src/providers/cursor/client.test.ts
index 48adc0e..5a409ba 100644
--- a/src/providers/cursor/client.test.ts
+++ b/src/providers/cursor/client.test.ts
@@ -2,7 +2,13 @@ import { describe, expect, it } from "bun:test";
import { mkdtemp, readFile, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
-import { decodeCursorStream, encodeConnectFrame, runCursorAgent } from "./client.ts";
+import {
+ CursorError,
+ decodeCursorStream,
+ encodeConnectFrame,
+ isRetryableCursorNetworkResourceError,
+ runCursorAgent,
+} from "./client.ts";
import {
decodeFrameJson,
fakeProtoMerged as fakeProto,
@@ -91,6 +97,24 @@ function assertStreamCloseMessage(messages: CursorClientMessage[], index: number
});
}
+describe("CursorError retry classification", () => {
+ it("retries resource_exhausted network errors", () => {
+ expect(
+ isRetryableCursorNetworkResourceError(
+ new CursorError(429, "Cursor Run failed: resource_exhausted: Network Error"),
+ ),
+ ).toBe(true);
+ });
+
+ it("does not retry quota resource_exhausted errors", () => {
+ expect(
+ isRetryableCursorNetworkResourceError(
+ new CursorError(429, "Cursor Run failed: resource_exhausted: You've hit your free requests limit."),
+ ),
+ ).toBe(false);
+ });
+});
+
async function runCursorAgentWithFrames(
serverFrames: Uint8Array[],
runOptions: Partial<CursorRunOptions> = {},
diff --git a/src/providers/cursor/client.ts b/src/providers/cursor/client.ts
index 19e5c57..99eea29 100644
--- a/src/providers/cursor/client.ts
+++ b/src/providers/cursor/client.ts
@@ -126,6 +126,12 @@ export class CursorError extends Error {
}
}
+export function isRetryableCursorNetworkResourceError(err: unknown): boolean {
+ if (!(err instanceof CursorError) || err.status !== 429) return false;
+ const text = `${err.message} ${err.detail ?? ""}`.toLowerCase();
+ return text.includes("resource_exhausted") && text.includes("network error");
+}
+
const HEARTBEAT_INTERVAL_MS = 5_000;
export const CURSOR_OUTPUT_IDLE_TIMEOUT_MS = 30_000;
diff --git a/src/providers/cursor/cursor-test-helpers.ts b/src/providers/cursor/cursor-test-helpers.ts
index 81d1829..30dd86f 100644
--- a/src/providers/cursor/cursor-test-helpers.ts
+++ b/src/providers/cursor/cursor-test-helpers.ts
@@ -140,3 +140,15 @@ export function resourceExhaustedFrame(): Uint8Array {
2,
);
}
+
+export function resourceExhaustedNetworkFrame(): Uint8Array {
+ return encodeConnectFrame(
+ jsonBytes({
+ error: {
+ code: "resource_exhausted",
+ message: "Network Error",
+ },
+ }),
+ 2,
+ );
+}
diff --git a/src/providers/cursor/index.test.ts b/src/providers/cursor/index.test.ts
index 33d3376..9131952 100644
--- a/src/providers/cursor/index.test.ts
+++ b/src/providers/cursor/index.test.ts
@@ -10,6 +10,7 @@ import {
jsonBytes,
jwt,
resourceExhaustedFrame,
+ resourceExhaustedNetworkFrame,
streamFromChunks,
} from "./cursor-test-helpers.ts";
import { mkdir, mkdtemp, stat, writeFile } from "node:fs/promises";
@@ -177,6 +178,35 @@ describe("Cursor provider messages", () => {
expect(body.content).toEqual([{ type: "text", text: "hello" }]);
});
+ it("retries Cursor resource_exhausted network errors for non-streaming requests", async () => {
+ let attempts = 0;
+ const provider = createCursorTestProvider(
+ async () => {
+ attempts++;
+ if (attempts === 1) return streamFromChunks([resourceExhaustedNetworkFrame()]);
+ return streamFromChunks([
+ frame({ interactionUpdate: { textDelta: { text: "recovered" } } }),
+ frame({ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "1" } } }),
+ encodeConnectFrame(jsonBytes({}), 2),
+ ]);
+ },
+ { computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }) },
+ );
+
+ const response = await provider.handleMessages(
+ {
+ model: "cursor",
+ messages: [{ role: "user", content: "hello" }],
+ },
+ fakeCursorCtx({ sessionId: "session" }),
+ );
+ const body = (await response.json()) as { content: Array<{ type: string; text?: string }> };
+
+ expect(attempts).toBe(2);
+ expect(response.status).toBe(200);
+ expect(body.content).toEqual([{ type: "text", text: "recovered" }]);
+ });
+
it("returns valid Anthropic SSE for streaming requests", async () => {
const provider = createCursorTestProvider(async () => {
return streamFromChunks([
@@ -202,6 +232,37 @@ describe("Cursor provider messages", () => {
expectMessageStop(events);
});
+ it("retries Cursor resource_exhausted network errors for bridged streaming requests", async () => {
+ let attempts = 0;
+ const provider = createCursorTestProvider(
+ async () => {
+ attempts++;
+ if (attempts === 1) return streamFromChunks([resourceExhaustedNetworkFrame()]);
+ return streamFromChunks([
+ frame({ interactionUpdate: { textDelta: { text: "bridge recovered" } } }),
+ frame({ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "1" } } }),
+ ]);
+ },
+ { computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }) },
+ );
+
+ const response = await provider.handleMessages(
+ {
+ model: "cursor",
+ stream: true,
+ tools: [{ name: "Read", input_schema: { type: "object" } }],
+ messages: [{ role: "user", content: "hello" }],
+ },
+ fakeCursorCtx({ sessionId: "session" }),
+ );
+ const events = await collectCursorSse(response);
+
+ expect(attempts).toBe(2);
+ expect(events.some((event) => event.event === "error")).toBe(false);
+ expect(getTextDeltaEvent(events)?.data.delta.text).toBe("bridge recovered");
+ expectMessageStop(events);
+ });
+
it("preserves Cursor Connect end error status for non-streaming requests", async () => {
const provider = createCursorTestProvider(async () => {
return streamFromChunks([
diff --git a/src/providers/cursor/index.ts b/src/providers/cursor/index.ts
index 0fd63d4..e407730 100644
--- a/src/providers/cursor/index.ts
+++ b/src/providers/cursor/index.ts
@@ -2,9 +2,12 @@ import type { AnthropicRequest } from "../../anthropic/schema.ts";
import { wantsDownstreamStream } from "../../anthropic/stream.ts";
import { jsonError, jsonResponse, sseResponse } from "../../anthropic/response.ts";
import { logVerbose } from "../../config.ts";
+import type { Logger } from "../../log.ts";
+import { computeBackoffDelay, MAX_RATE_LIMIT_RETRIES, sleep, type BackoffOutcome } from "../retry.ts";
import type { Provider, RequestContext } from "../types.ts";
import {
CursorError,
+ isRetryableCursorNetworkResourceError,
runCursorAgent,
type CursorRunOptions,
} from "./client.ts";
@@ -47,6 +50,7 @@ export interface CursorProviderDeps {
runAgent: (opts: CursorRunOptions) => Promise<ReadableStream<Uint8Array>>;
proto?: CursorProto;
bridgeOutputIdleTimeoutMs?: number;
+ computeRetryDelay?: (attempt: number) => BackoffOutcome;
}
const defaultDeps: CursorProviderDeps = {
@@ -119,32 +123,41 @@ async function handleMessages(
const bridgeWrite = canBridgeCursorWriteTool(body);
const denyUnadvertisedNativeTools = Boolean(wantStream && ctx.sessionId);
+ const runOptions: CursorRunOptions = {
+ prompt,
+ mode: selection.mode,
+ conversationId,
+ model: selection.requestedModel,
+ selectedImages,
+ auth,
+ ctx,
+ readHandler: bridgeRead
+ ? nativeToolBridge?.readHandler
+ : denyUnadvertisedNativeTools
+ ? denyCursorReadTool
+ : undefined,
+ shellStreamHandler: bridgeBash
+ ? nativeToolBridge?.shellStreamHandler
+ : denyUnadvertisedNativeTools
+ ? denyCursorBashTool
+ : undefined,
+ writeHandler: bridgeWrite
+ ? nativeToolBridge?.writeHandler
+ : denyUnadvertisedNativeTools
+ ? denyCursorWriteTool
+ : undefined,
+ };
+ const runAgent = () => deps.runAgent(runOptions);
+ const retryRunAgent = () =>
+ retryCursorNetworkResourceError(runAgent, {
+ log,
+ signal: ctx.signal,
+ computeRetryDelay: deps.computeRetryDelay,
+ });
+
let upstream: ReadableStream<Uint8Array>;
try {
- upstream = await deps.runAgent({
- prompt,
- mode: selection.mode,
- conversationId,
- model: selection.requestedModel,
- selectedImages,
- auth,
- ctx,
- readHandler: bridgeRead
- ? nativeToolBridge?.readHandler
- : denyUnadvertisedNativeTools
- ? denyCursorReadTool
- : undefined,
- shellStreamHandler: bridgeBash
- ? nativeToolBridge?.shellStreamHandler
- : denyUnadvertisedNativeTools
- ? denyCursorBashTool
- : undefined,
- writeHandler: bridgeWrite
- ? nativeToolBridge?.writeHandler
- : denyUnadvertisedNativeTools
- ? denyCursorWriteTool
- : undefined,
- });
+ upstream = await retryRunAgent();
} catch (err) {
if (err instanceof CursorError) {
log.warn("cursor upstream error", {
@@ -159,7 +172,10 @@ async function handleMessages(
}
if (wantStream) {
- const stream = nativeToolBridge?.stream(upstream, ctx.signal) ?? translateCursorStream(upstream, {
+ const stream = nativeToolBridge?.stream(upstream, ctx.signal, {
+ retryUpstream: retryRunAgent,
+ computeRetryDelay: deps.computeRetryDelay,
+ }) ?? translateCursorStream(upstream, {
messageId,
model: body.model,
log: ctx.childLogger("cursor.stream"),
@@ -169,21 +185,36 @@ async function handleMessages(
onSession,
allowedToolNames,
inputTokens,
+ retryUpstream: retryRunAgent,
+ computeRetryDelay: deps.computeRetryDelay,
});
return sseResponse(stream);
}
try {
- const result = await accumulateCursorResponse(upstream, {
- messageId,
- model: body.model,
- log: ctx.childLogger("cursor.accumulate"),
- traffic: ctx.traffic,
- proto: deps.proto,
- onSession,
- allowedToolNames,
- inputTokens,
- });
+ const accumulateLog = ctx.childLogger("cursor.accumulate");
+ let nextUpstream: ReadableStream<Uint8Array> | undefined = upstream;
+ const result = await retryCursorNetworkResourceError(
+ async () => {
+ const currentUpstream = nextUpstream ?? await runAgent();
+ nextUpstream = undefined;
+ return accumulateCursorResponse(currentUpstream, {
+ messageId,
+ model: body.model,
+ log: accumulateLog,
+ traffic: ctx.traffic,
+ proto: deps.proto,
+ onSession,
+ allowedToolNames,
+ inputTokens,
+ });
+ },
+ {
+ log: accumulateLog,
+ signal: ctx.signal,
+ computeRetryDelay: deps.computeRetryDelay,
+ },
+ );
return jsonResponse(result.response);
} catch (err) {
log.warn("cursor accumulate error", { err: String(err) });
@@ -206,3 +237,38 @@ export function createCursorProvider(deps: CursorProviderDeps = defaultDeps): Pr
}
export const cursorProvider: Provider = createCursorProvider();
+
+async function retryCursorNetworkResourceError<T>(
+ run: () => Promise<T>,
+ opts: {
+ log: Logger;
+ signal?: AbortSignal;
+ computeRetryDelay?: (attempt: number) => BackoffOutcome;
+ },
+): Promise<T> {
+ const retryDelay = opts.computeRetryDelay ?? computeBackoffDelay;
+ for (let attempt = 0; ; attempt++) {
+ try {
+ return await run();
+ } catch (err) {
+ if (!isRetryableCursorNetworkResourceError(err) || attempt >= MAX_RATE_LIMIT_RETRIES) {
+ throw err;
+ }
+ const { waitMs, exceedsBudget } = retryDelay(attempt);
+ if (exceedsBudget) {
+ opts.log.warn("cursor resource_exhausted network retry delay exceeds budget; giving up", {
+ maxDelayMs: waitMs,
+ err: String(err),
+ });
+ throw err;
+ }
+ opts.log.warn("cursor resource_exhausted network error, retrying", {
+ attempt: attempt + 1,
+ maxRetries: MAX_RATE_LIMIT_RETRIES,
+ waitMs,
+ err: String(err),
+ });
+ await sleep(waitMs, opts.signal);
+ }
+ }
+}
diff --git a/src/providers/cursor/tool-bridge.ts b/src/providers/cursor/tool-bridge.ts
index 58a45e5..04b78d6 100644
--- a/src/providers/cursor/tool-bridge.ts
+++ b/src/providers/cursor/tool-bridge.ts
@@ -1,6 +1,7 @@
import { encodeSseEvent } from "../../sse.ts";
import type { AnthropicRequest, AnthropicToolResultBlock } from "../../anthropic/schema.ts";
import type { Logger } from "../../log.ts";
+import { computeBackoffDelay, MAX_RATE_LIMIT_RETRIES, sleep, type BackoffOutcome } from "../retry.ts";
import type { RequestContext } from "../types.ts";
import { countCursorTokens } from "./count-tokens.ts";
import {
@@ -16,6 +17,7 @@ import {
cursorWriteArgs,
type CursorNativeToolResult,
decodeCursorStream,
+ isRetryableCursorNetworkResourceError,
type CursorAppendMessage,
type CursorReadExec,
type CursorShellStreamExec,
@@ -73,10 +75,14 @@ interface CursorBridgeState {
waiters: Array<(tool: PendingNativeTool) => void>;
log: Logger;
traffic?: RequestContext["traffic"];
+ proto?: CursorProto;
onSession?: (sessionId: string) => void;
allowedToolNames?: ReadonlySet<string>;
outputSeen: boolean;
+ downstreamStarted: boolean;
outputIdleTimeoutMs: number;
+ retryUpstream?: () => Promise<ReadableStream<Uint8Array>>;
+ computeRetryDelay?: (attempt: number) => BackoffOutcome;
}
const bridgeStates = new Map<string, CursorBridgeState>();
@@ -151,7 +157,14 @@ export function createCursorShellToolBridge(opts: {
readHandler: (exec: CursorReadExec, append: CursorAppendMessage) => Promise<void>;
shellStreamHandler: (exec: CursorShellStreamExec, append: CursorAppendMessage) => Promise<void>;
writeHandler: (exec: CursorWriteExec, append: CursorAppendMessage) => Promise<void>;
- stream: (upstream: ReadableStream<Uint8Array>, signal?: AbortSignal) => ReadableStream<Uint8Array>;
+ stream: (
+ upstream: ReadableStream<Uint8Array>,
+ signal?: AbortSignal,
+ retryOpts?: {
+ retryUpstream?: () => Promise<ReadableStream<Uint8Array>>;
+ computeRetryDelay?: (attempt: number) => BackoffOutcome;
+ },
+ ) => ReadableStream<Uint8Array>;
} {
const state: CursorBridgeState = {
sessionId: opts.sessionId,
@@ -162,9 +175,11 @@ export function createCursorShellToolBridge(opts: {
waiters: [],
log: opts.log,
traffic: opts.traffic,
+ proto: opts.proto,
onSession: opts.onSession,
allowedToolNames: opts.allowedToolNames,
outputSeen: false,
+ downstreamStarted: false,
outputIdleTimeoutMs: opts.outputIdleTimeoutMs ?? CURSOR_OUTPUT_IDLE_TIMEOUT_MS,
};
@@ -285,12 +300,17 @@ export function createCursorShellToolBridge(opts: {
contentChars: writeResult.content.length,
});
},
- stream(upstream, signal) {
+ stream(upstream, signal, retryOpts) {
state.iterator = decodeCursorStream(upstream, opts.proto, {
traffic: opts.traffic,
log: opts.log,
outputIdleTimeoutMs: 0,
});
+ state.pendingNext = undefined;
+ state.outputSeen = false;
+ state.downstreamStarted = false;
+ state.retryUpstream = retryOpts?.retryUpstream;
+ state.computeRetryDelay = retryOpts?.computeRetryDelay;
bridgeStates.set(opts.sessionId, state);
return streamBridgeUntilToolOrEnd(state, signal);
},
@@ -337,162 +357,198 @@ function streamBridgeUntilToolOrEnd(
return new ReadableStream<Uint8Array>({
async start(controller) {
let closed = false;
+ let retryAttempt = 0;
const emit = (event: string, data: unknown) => {
if (closed || signal?.aborted || controller.desiredSize === null) return false;
state.traffic?.writeJsonEvent("050-downstream-event", { event, data });
controller.enqueue(encoder.encode(encodeSseEvent(event, data)));
+ state.downstreamStarted = true;
return true;
};
- const framing = createCursorSseFramer({
- messageId: state.messageId,
- model: state.model,
- emit,
- mapUsage: (usage) => cursorUsageToAnthropic(usage, { inputTokens: state.inputTokens }),
- initialUsage: cursorUsageToAnthropic(undefined, { inputTokens: state.inputTokens }),
- });
- const toolUseXml = new CursorToolUseXmlParser({ allowedToolNames: state.allowedToolNames });
-
- const emitToolUseAndPause = (tool: PendingNativeTool) => {
- framing.emitToolPauseMessage((index) => {
- const input = toolUseInput(tool);
- emit("content_block_start", {
- type: "content_block_start",
- index,
- content_block: {
- type: "tool_use",
- id: tool.toolUseId,
- name: tool.kind,
- input: {},
- },
- });
- emit("content_block_delta", {
- type: "content_block_delta",
- index,
- delta: { type: "input_json_delta", partial_json: input },
- });
- emit("content_block_stop", { type: "content_block_stop", index });
- });
- };
-
- const emitRecoveredToolUse = (tool: RecoveredCursorToolUse) => {
- state.traffic?.writeJsonEvent("041-cursor-xml-tool-use", {
- id: tool.id,
- originalId: tool.originalId,
- name: tool.name,
- inputChars: JSON.stringify(tool.input).length,
- });
- framing.closeOpenBlocks();
- framing.ensureStart();
- const index = framing.nextContentBlockIndex();
- emit("content_block_start", {
- type: "content_block_start",
- index,
- content_block: {
- type: "tool_use",
- id: tool.id,
- name: tool.name,
- input: {},
- },
- });
- emit("content_block_delta", {
- type: "content_block_delta",
- index,
- delta: { type: "input_json_delta", partial_json: JSON.stringify(tool.input) },
- });
- emit("content_block_stop", { type: "content_block_stop", index });
- };
-
- const applyRecoveredEvent = (event: RecoveredCursorTextEvent) => {
- if (event.type === "text") {
- framing.emitTextDelta(event.text);
- return;
- }
- emitRecoveredToolUse(event);
- };
-
- const emitMessageEnd = () => {
- framing.emitFinalMessage(toolUseXml.sawToolUse ? "tool_use" : "end_turn");
- };
-
- const emitStreamError = (err: unknown) => {
- framing.emitError(err);
- };
-
try {
- while (!signal?.aborted) {
- const next = state.pendingNext ?? state.iterator.next();
- state.pendingNext = next;
- let idleTimer: ReturnType<typeof setTimeout> | undefined;
- const race: Array<Promise<
- | { type: "event"; value: IteratorResult<CursorStreamEvent> }
- | { type: "tool"; tool: PendingNativeTool }
- | { type: "idle" }
- >> = [
- next.then((value) => ({ type: "event" as const, value })),
- waitForPendingTool(state).then((tool) => ({ type: "tool" as const, tool })),
- ];
- if (state.outputSeen && state.outputIdleTimeoutMs > 0) {
- race.push(new Promise<{ type: "idle" }>((resolve) => {
- idleTimer = setTimeout(() => resolve({ type: "idle" }), state.outputIdleTimeoutMs);
- }));
- }
- const result = await Promise.race(race).finally(() => {
- if (idleTimer) clearTimeout(idleTimer);
+ while (true) {
+ const framing = createCursorSseFramer({
+ messageId: state.messageId,
+ model: state.model,
+ emit,
+ mapUsage: (usage) => cursorUsageToAnthropic(usage, { inputTokens: state.inputTokens }),
+ initialUsage: cursorUsageToAnthropic(undefined, { inputTokens: state.inputTokens }),
});
-
- if (result.type === "tool") {
- emitToolUseAndPause(result.tool);
- return;
- }
-
- if (result.type === "idle") {
- state.log.warn("cursor bridge stream idle after output", {
- idleMs: state.outputIdleTimeoutMs,
+ const toolUseXml = new CursorToolUseXmlParser({ allowedToolNames: state.allowedToolNames });
+
+ const emitToolUseAndPause = (tool: PendingNativeTool) => {
+ framing.emitToolPauseMessage((index) => {
+ const input = toolUseInput(tool);
+ emit("content_block_start", {
+ type: "content_block_start",
+ index,
+ content_block: {
+ type: "tool_use",
+ id: tool.toolUseId,
+ name: tool.kind,
+ input: {},
+ },
+ });
+ emit("content_block_delta", {
+ type: "content_block_delta",
+ index,
+ delta: { type: "input_json_delta", partial_json: input },
+ });
+ emit("content_block_stop", { type: "content_block_stop", index });
});
- state.traffic?.writeJsonEvent("040-cursor-event", {
- type: "end",
- reason: "output_idle_timeout",
- idleMs: state.outputIdleTimeoutMs,
+ };
+
+ const emitRecoveredToolUse = (tool: RecoveredCursorToolUse) => {
+ state.traffic?.writeJsonEvent("041-cursor-xml-tool-use", {
+ id: tool.id,
+ originalId: tool.originalId,
+ name: tool.name,
+ inputChars: JSON.stringify(tool.input).length,
});
- state.pendingNext = undefined;
- await state.iterator.return?.(undefined);
- break;
- }
-
- state.pendingNext = undefined;
- if (result.value.done) break;
- const event = result.value.value;
- state.traffic?.writeJsonEvent("040-cursor-event", event);
- if (event.type === "thinking_delta" || event.type === "text_delta" || event.type === "usage") {
- state.outputSeen = true;
- }
- switch (event.type) {
- case "session":
- state.onSession?.(event.sessionId);
- break;
- case "thinking_delta":
- framing.emitThinkingDelta(event.text);
- break;
- case "text_delta":
- for (const recovered of toolUseXml.push(event.text)) applyRecoveredEvent(recovered);
- break;
- case "usage":
- framing.recordUsage(event.usage);
- break;
- case "end":
- break;
+ framing.closeOpenBlocks();
+ framing.ensureStart();
+ const index = framing.nextContentBlockIndex();
+ emit("content_block_start", {
+ type: "content_block_start",
+ index,
+ content_block: {
+ type: "tool_use",
+ id: tool.id,
+ name: tool.name,
+ input: {},
+ },
+ });
+ emit("content_block_delta", {
+ type: "content_block_delta",
+ index,
+ delta: { type: "input_json_delta", partial_json: JSON.stringify(tool.input) },
+ });
+ emit("content_block_stop", { type: "content_block_stop", index });
+ };
+
+ const applyRecoveredEvent = (event: RecoveredCursorTextEvent) => {
+ if (event.type === "text") {
+ framing.emitTextDelta(event.text);
+ return;
+ }
+ emitRecoveredToolUse(event);
+ };
+
+ try {
+ while (!signal?.aborted) {
+ const next = state.pendingNext ?? state.iterator.next();
+ state.pendingNext = next;
+ let idleTimer: ReturnType<typeof setTimeout> | undefined;
+ const race: Array<Promise<
+ | { type: "event"; value: IteratorResult<CursorStreamEvent> }
+ | { type: "tool"; tool: PendingNativeTool }
+ | { type: "idle" }
+ >> = [
+ next.then((value) => ({ type: "event" as const, value })),
+ waitForPendingTool(state).then((tool) => ({ type: "tool" as const, tool })),
+ ];
+ if (state.outputSeen && state.outputIdleTimeoutMs > 0) {
+ race.push(new Promise<{ type: "idle" }>((resolve) => {
+ idleTimer = setTimeout(() => resolve({ type: "idle" }), state.outputIdleTimeoutMs);
+ }));
+ }
+ const result = await Promise.race(race).finally(() => {
+ if (idleTimer) clearTimeout(idleTimer);
+ });
+
+ if (result.type === "tool") {
+ emitToolUseAndPause(result.tool);
+ return;
+ }
+
+ if (result.type === "idle") {
+ state.log.warn("cursor bridge stream idle after output", {
+ idleMs: state.outputIdleTimeoutMs,
+ });
+ state.traffic?.writeJsonEvent("040-cursor-event", {
+ type: "end",
+ reason: "output_idle_timeout",
+ idleMs: state.outputIdleTimeoutMs,
+ });
+ state.pendingNext = undefined;
+ await state.iterator.return?.(undefined);
+ break;
+ }
+
+ state.pendingNext = undefined;
+ if (result.value.done) break;
+ const event = result.value.value;
+ state.traffic?.writeJsonEvent("040-cursor-event", event);
+ if (event.type === "thinking_delta" || event.type === "text_delta" || event.type === "usage") {
+ state.outputSeen = true;
+ }
+ switch (event.type) {
+ case "session":
+ state.onSession?.(event.sessionId);
+ break;
+ case "thinking_delta":
+ framing.emitThinkingDelta(event.text);
+ break;
+ case "text_delta":
+ for (const recovered of toolUseXml.push(event.text)) applyRecoveredEvent(recovered);
+ break;
+ case "usage":
+ framing.recordUsage(event.usage);
+ break;
+ case "end":
+ break;
+ }
+ }
+ for (const recovered of toolUseXml.flush()) applyRecoveredEvent(recovered);
+
+ framing.emitFinalMessage(toolUseXml.sawToolUse ? "tool_use" : "end_turn");
+ bridgeStates.delete(state.sessionId);
+ return;
+ } catch (caught) {
+ let err: unknown = caught;
+ if (!state.downstreamStarted && state.retryUpstream && isRetryableCursorNetworkResourceError(err)) {
+ if (retryAttempt < MAX_RATE_LIMIT_RETRIES && !signal?.aborted) {
+ const retryDelay = state.computeRetryDelay ?? computeBackoffDelay;
+ const { waitMs, exceedsBudget } = retryDelay(retryAttempt);
+ if (exceedsBudget) {
+ state.log.warn("cursor bridge retry delay exceeds budget; giving up", {
+ maxDelayMs: waitMs,
+ err: String(err),
+ });
+ } else {
+ const nextAttempt = retryAttempt + 1;
+ state.log.warn("cursor bridge stream error before downstream output, retrying", {
+ attempt: nextAttempt,
+ maxRetries: MAX_RATE_LIMIT_RETRIES,
+ waitMs,
+ err: String(err),
+ });
+ retryAttempt = nextAttempt;
+ try {
+ await sleep(waitMs, signal);
+ const retryUpstream = await state.retryUpstream();
+ state.iterator = decodeCursorStream(retryUpstream, state.proto, {
+ traffic: state.traffic,
+ log: state.log,
+ outputIdleTimeoutMs: 0,
+ });
+ state.pendingNext = undefined;
+ state.outputSeen = false;
+ continue;
+ } catch (retryErr) {
+ err = retryErr;
+ }
+ }
+ }
+ }
+ state.log.warn("cursor bridge stream error", { err: String(err) });
+ framing.emitError(err);
+ bridgeStates.delete(state.sessionId);
+ return;
}
}
- for (const recovered of toolUseXml.flush()) applyRecoveredEvent(recovered);
-
- emitMessageEnd();
- bridgeStates.delete(state.sessionId);
- } catch (err) {
- state.log.warn("cursor bridge stream error", { err: String(err) });
- emitStreamError(err);
- bridgeStates.delete(state.sessionId);
} finally {
closed = true;
try {
diff --git a/src/providers/cursor/translate/response.test.ts b/src/providers/cursor/translate/response.test.ts
index 2a80327..9f0c390 100644
--- a/src/providers/cursor/translate/response.test.ts
+++ b/src/providers/cursor/translate/response.test.ts
@@ -7,6 +7,7 @@ import {
fakeProto,
frame,
jsonBytes,
+ resourceExhaustedNetworkFrame,
streamFromChunks,
} from "../cursor-test-helpers.ts";
import {
@@ -366,4 +367,31 @@ describe("Cursor response translation", () => {
expect(events[2]?.data.error.message).toContain("resource_exhausted");
expect(events[2]?.data.error.message).toContain("free requests limit");
});
+
+ it("retries Cursor resource_exhausted network errors before downstream output starts", async () => {
+ let retryCalls = 0;
+ const downstream = translateCursorStream(
+ streamFromChunks([resourceExhaustedNetworkFrame()]),
+ {
+ messageId: "msg_retry",
+ model: "cursor-plan",
+ log: createLogger("cursor.response.test"),
+ proto: fakeProto,
+ retryUpstream: async () => {
+ retryCalls++;
+ return streamFromChunks([
+ frame({ interactionUpdate: { textDelta: { text: "recovered" } } }),
+ frame({ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "1" } } }),
+ ]);
+ },
+ computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }),
+ },
+ );
+ const events = await collectCursorSse(downstream);
+
+ expect(retryCalls).toBe(1);
+ expect(events.map((event) => event.event)).toContain("message_stop");
+ expect(events.some((event) => event.event === "error")).toBe(false);
+ expect(events.some((event) => event.data.delta?.text === "recovered")).toBe(true);
+ });
});
diff --git a/src/providers/cursor/translate/response.ts b/src/providers/cursor/translate/response.ts
index 5aeff8f..4e8516b 100644
--- a/src/providers/cursor/translate/response.ts
+++ b/src/providers/cursor/translate/response.ts
@@ -1,7 +1,13 @@
import { encodeSseEvent } from "../../../sse.ts";
import type { Logger } from "../../../log.ts";
+import { computeBackoffDelay, MAX_RATE_LIMIT_RETRIES, sleep, type BackoffOutcome } from "../../retry.ts";
import type { TrafficCapture } from "../../types.ts";
-import { decodeCursorStream, type CursorStreamEvent, type CursorUsage } from "../client.ts";
+import {
+ decodeCursorStream,
+ isRetryableCursorNetworkResourceError,
+ type CursorStreamEvent,
+ type CursorUsage,
+} from "../client.ts";
import type { CursorProto } from "../proto-loader.ts";
import { createCursorSseFramer } from "../sse-framing.ts";
import {
@@ -162,91 +168,139 @@ export function translateCursorStream(
onSession?: (sessionId: string) => void;
allowedToolNames?: ReadonlySet<string>;
inputTokens?: number;
+ retryUpstream?: () => Promise<ReadableStream<Uint8Array>>;
+ computeRetryDelay?: (attempt: number) => BackoffOutcome;
+ maxRetryableStreamRetries?: number;
},
): ReadableStream<Uint8Array> {
const encoder = new TextEncoder();
return new ReadableStream<Uint8Array>({
async start(controller) {
let closed = false;
+ let currentUpstream = upstream;
+ let downstreamStarted = false;
+ let retryAttempt = 0;
const emit = (event: string, data: unknown) => {
if (closed || opts.signal?.aborted || controller.desiredSize === null) return false;
opts.traffic?.writeJsonEvent("050-downstream-event", { event, data });
controller.enqueue(encoder.encode(encodeSseEvent(event, data)));
+ downstreamStarted = true;
return true;
};
- const framing = createCursorSseFramer({
- messageId: opts.messageId,
- model: opts.model,
- emit,
- mapUsage: (usage) => cursorUsageToAnthropic(usage, { inputTokens: opts.inputTokens }),
- initialUsage: cursorUsageToAnthropic(undefined, { inputTokens: opts.inputTokens }),
- });
- const toolUseXml = new CursorToolUseXmlParser({ allowedToolNames: opts.allowedToolNames });
+ try {
+ while (true) {
+ const framing = createCursorSseFramer({
+ messageId: opts.messageId,
+ model: opts.model,
+ emit,
+ mapUsage: (usage) => cursorUsageToAnthropic(usage, { inputTokens: opts.inputTokens }),
+ initialUsage: cursorUsageToAnthropic(undefined, { inputTokens: opts.inputTokens }),
+ });
+ const toolUseXml = new CursorToolUseXmlParser({ allowedToolNames: opts.allowedToolNames });
- const emitRecoveredToolUse = (tool: RecoveredCursorToolUse) => {
- opts.traffic?.writeJsonEvent("041-cursor-xml-tool-use", {
- id: tool.id,
- originalId: tool.originalId,
- name: tool.name,
- inputChars: JSON.stringify(tool.input).length,
- });
- framing.closeOpenBlocks();
- framing.ensureStart();
- const index = framing.nextContentBlockIndex();
- emit("content_block_start", {
- type: "content_block_start",
- index,
- content_block: {
- type: "tool_use",
- id: tool.id,
- name: tool.name,
- input: {},
- },
- });
- emit("content_block_delta", {
- type: "content_block_delta",
- index,
- delta: { type: "input_json_delta", partial_json: JSON.stringify(tool.input) },
- });
- emit("content_block_stop", { type: "content_block_stop", index });
- };
+ const emitRecoveredToolUse = (tool: RecoveredCursorToolUse) => {
+ opts.traffic?.writeJsonEvent("041-cursor-xml-tool-use", {
+ id: tool.id,
+ originalId: tool.originalId,
+ name: tool.name,
+ inputChars: JSON.stringify(tool.input).length,
+ });
+ framing.closeOpenBlocks();
+ framing.ensureStart();
+ const index = framing.nextContentBlockIndex();
+ emit("content_block_start", {
+ type: "content_block_start",
+ index,
+ content_block: {
+ type: "tool_use",
+ id: tool.id,
+ name: tool.name,
+ input: {},
+ },
+ });
+ emit("content_block_delta", {
+ type: "content_block_delta",
+ index,
+ delta: { type: "input_json_delta", partial_json: JSON.stringify(tool.input) },
+ });
+ emit("content_block_stop", { type: "content_block_stop", index });
+ };
- const applyRecoveredEvent = (event: RecoveredCursorTextEvent) => {
- if (event.type === "text") {
- framing.emitTextDelta(event.text);
- return;
- }
- emitRecoveredToolUse(event);
- };
+ const applyRecoveredEvent = (event: RecoveredCursorTextEvent) => {
+ if (event.type === "text") {
+ framing.emitTextDelta(event.text);
+ return;
+ }
+ emitRecoveredToolUse(event);
+ };
- try {
- for await (const event of decodeCursorStream(upstream, opts.proto, { traffic: opts.traffic, log: opts.log })) {
- opts.traffic?.writeJsonEvent("040-cursor-event", event);
- if (opts.signal?.aborted) return;
- switch (event.type) {
- case "session":
- opts.onSession?.(event.sessionId);
- break;
- case "thinking_delta":
- framing.emitThinkingDelta(event.text);
- break;
- case "text_delta":
- for (const recovered of toolUseXml.push(event.text)) applyRecoveredEvent(recovered);
- break;
- case "usage":
- framing.recordUsage(event.usage);
- break;
- case "end":
- break;
+ try {
+ for await (
+ const event of decodeCursorStream(currentUpstream, opts.proto, {
+ traffic: opts.traffic,
+ log: opts.log,
+ })
+ ) {
+ opts.traffic?.writeJsonEvent("040-cursor-event", event);
+ if (opts.signal?.aborted) return;
+ switch (event.type) {
+ case "session":
+ opts.onSession?.(event.sessionId);
+ break;
+ case "thinking_delta":
+ framing.emitThinkingDelta(event.text);
+ break;
+ case "text_delta":
+ for (const recovered of toolUseXml.push(event.text)) applyRecoveredEvent(recovered);
+ break;
+ case "usage":
+ framing.recordUsage(event.usage);
+ break;
+ case "end":
+ break;
+ }
+ }
+ for (const recovered of toolUseXml.flush()) applyRecoveredEvent(recovered);
+ framing.emitFinalMessage(toolUseXml.sawToolUse ? "tool_use" : "end_turn");
+ return;
+ } catch (caught) {
+ let err: unknown = caught;
+ if (!downstreamStarted && opts.retryUpstream && isRetryableCursorNetworkResourceError(err)) {
+ const maxRetries = opts.maxRetryableStreamRetries ?? MAX_RATE_LIMIT_RETRIES;
+ if (retryAttempt < maxRetries && !opts.signal?.aborted) {
+ const retryDelay = opts.computeRetryDelay ?? computeBackoffDelay;
+ const { waitMs, exceedsBudget } = retryDelay(retryAttempt);
+ if (exceedsBudget) {
+ opts.log.warn("cursor stream retry delay exceeds budget; giving up", {
+ maxDelayMs: waitMs,
+ err: String(err),
+ });
+ } else {
+ const nextAttempt = retryAttempt + 1;
+ opts.log.warn("cursor stream error before downstream output, retrying", {
+ attempt: nextAttempt,
+ maxRetries,
+ waitMs,
+ err: String(err),
+ });
+ retryAttempt = nextAttempt;
+ try {
+ await sleep(waitMs, opts.signal);
+ currentUpstream = await opts.retryUpstream();
+ continue;
+ } catch (retryErr) {
+ err = retryErr;
+ }
+ }
+ }
+ }
+ opts.log.warn("cursor stream error", { err: String(err) });
+ framing.emitError(err);
+ return;
}
}
- for (const recovered of toolUseXml.flush()) applyRecoveredEvent(recovered);
- framing.emitFinalMessage(toolUseXml.sawToolUse ? "tool_use" : "end_turn");
- } catch (err) {
- opts.log.warn("cursor stream error", { err: String(err) });
- framing.emitError(err);
} finally {
closed = true;
try {