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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 {