UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

158 lines (150 loc) • 7.03 kB
/** * Same-target retry of an explicit, pre-output 429 refusal with a stated * recovery delay. No event-producing attempt is ever automatically replayed. * This is a refusal-specific policy, not a claim that every eventless POST * is idempotent; ambiguous transport failures still propagate unchanged. */ import { parseRetryAfterFromMessage } from '../../../lib/retry-delay.js'; import type { AdapterFetchContext } from '../../base.js'; import { createAdapterPhysicalSend } from '../../physical-send.js'; import { abortError, SendBudgetExhaustedError, sleepWithAbort } from '../../../lib/upstream-retry.js'; import { CloudChatError, streamChatEvents, type CloudChatEvent, type CloudChatRequest } from './chat.js'; /** 1 initial attempt plus at most 2 replays. */ export const STATED_RESET_MAX_REPLAYS = 2; /** Default cumulative wait allowance for one invocation (30 minutes). */ export const STATED_RESET_MAX_WAIT_MS = 1_800_000; /** Absolute maximum cumulative allowance, including explicit overrides. */ export const STATED_RESET_WAIT_CEILING_MS = 3_600_000; function statedResetMaxWaitMs(defaultMs = STATED_RESET_MAX_WAIT_MS): number { const raw = process.env.OPENCODEX_DEVIN_STATED_RESET_WAIT_MS?.trim(); if (!raw) return defaultMs; const parsed = Number(raw); if (!Number.isFinite(parsed) || parsed < 0) return defaultMs; // Zero explicitly disables local waiting. Values above one hour are capped. return Math.min(Math.floor(parsed), STATED_RESET_WAIT_CEILING_MS); } export const statedResetMaxWaitMsForTests = statedResetMaxWaitMs; export function devinStatedResetWaitMs(): number { return statedResetMaxWaitMs(0); } export interface StatedResetRetryOptions { /** Test seam: defaults to the real cloud stream. */ stream?: (req: CloudChatRequest) => AsyncGenerator<CloudChatEvent>; /** Test seam: must either honour the whole delay or reject on cancellation. */ sleep?: (ms: number, signal?: AbortSignal) => Promise<void>; onWaitHeartbeat?: () => void; maxReplays?: number; /** CUMULATIVE wait allowance, not a fresh allowance on every failure. */ maxWaitMs?: number; /** Request-wide execution authority. Absent preserves context-free callers' unlimited fetch. */ execution?: Pick< AdapterFetchContext, "executor" | "sendBudget" | "onPhysicalSend" | "onRecoveryWithheld" >; } function replayLimit(value: number | undefined): number { if (value === undefined) return STATED_RESET_MAX_REPLAYS; if (!Number.isInteger(value) || value < 0 || value > STATED_RESET_MAX_REPLAYS) { throw new RangeError('maxReplays must be an integer from 0 to 2'); } return value; } function waitLimit(value: number | undefined): number { if (value === undefined) return statedResetMaxWaitMs(); if (!Number.isFinite(value) || value < 0) { throw new RangeError('maxWaitMs must be a finite non-negative number'); } return Math.min(Math.floor(value), STATED_RESET_WAIT_CEILING_MS); } export async function* streamChatEventsWithResetRetry( req: CloudChatRequest, options?: StatedResetRetryOptions, ): AsyncGenerator<CloudChatEvent> { const stream = options?.stream ?? streamChatEvents; const sleep = options?.sleep ?? sleepWithAbort; const maxReplays = replayLimit(options?.maxReplays); const maxWaitMs = waitLimit(options?.maxWaitMs); const execution = options?.execution; // One sender owns the whole invocation so ordinals span the initial POST and both replays. // Its executor remains lazy: replay admission happens after the provider-stated wait, never // while a reservation could be held for up to an hour. const send = execution ? createAdapterPhysicalSend({ ...execution, abortSignal: req.signal }) : undefined; let replays = 0; let waitedMs = 0; let replaySourceError: CloudChatError | undefined; while (true) { // Check again after sleeping: cancellation can race with timer completion. // A pre-aborted request must not even enter a custom transport. if (req.signal?.aborted) throw abortError(req.signal); let yielded = false; try { const recovery = replays > 0 ? "rate-limit-429" as const : undefined; const attemptRequest = send ? { ...req, executor: ((input, init) => send({ url: typeof input === "string" ? input : input instanceof URL ? input.href : input.url, ...(recovery ? { sendClass: "auth-recovery" as const, recovery } : {}), dispatch: executor => executor(input, init), })) as typeof globalThis.fetch, } : req; for await (const event of stream(attemptRequest)) { // Latch before yielding, so a consumer-injected error is post-output. yielded = true; yield event; } return; } catch (error) { if (req.signal?.aborted) throw abortError(req.signal); if (!yielded && error instanceof SendBudgetExhaustedError && replaySourceError) { // The provider's refusal is the real upstream answer. A local cap can withhold its // recovery, but replacing the 429 would erase the status and stated reset metadata. execution?.onRecoveryWithheld?.({ reason: "retry-send-budget" }); throw replaySourceError; } const retryableError = !yielded && error instanceof CloudChatError && error.status === 429 ? error : undefined; // Prefer the typed field: trailer-derived errors are content-free now, // so the parser preserved the stated delay there. The message scrape // remains for errors whose text still carries a hint. const waitSec = retryableError ? retryableError.retryAfterSeconds ?? parseRetryAfterFromMessage(retryableError.message) : undefined; const waitMs = waitSec === undefined ? undefined : waitSec * 1000; if ( retryableError === undefined || waitMs === undefined || replays >= maxReplays || waitMs > maxWaitMs - waitedMs ) { // Never shorten a provider's minimum delay to fit the local budget. // Keep the original refusal so outer policy can preserve its metadata. throw error; } replays += 1; replaySourceError = retryableError; // Charge the complete scheduled wait once, before sleeping. This is a // sleep allowance, not a wall-clock deadline on generation or timer // scheduling: waking a few milliseconds late must not reject an already // approved one-hour retry. No later wait can spend this allowance again. waitedMs += waitMs; const heartbeat = options?.onWaitHeartbeat; if (waitMs > 0) heartbeat?.(); const beat = heartbeat && waitMs > 0 ? setInterval(heartbeat, Math.min(500, Math.max(100, Math.floor(waitMs / 2)))) : undefined; try { await sleep(waitMs, req.signal); } finally { if (beat !== undefined) clearInterval(beat); } if (req.signal?.aborted) throw abortError(req.signal); } } }