Skip to content

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

Rust

accumulate: surface rate_limits and response.failed as HTTP errors

Raine Virta27abb5276f6a
diff --git a/src/server.ts b/src/server.ts
index a544ab2..b766132 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -3,7 +3,7 @@ import type { AnthropicRequest } from "./anthropic/schema.ts"
import { assertAllowedModel, ModelNotAllowedError } from "./translate/model-allowlist.ts"
import { translateRequest } from "./translate/request.ts"
import { translateStream } from "./translate/stream.ts"
-import { accumulateResponse } from "./translate/accumulate.ts"
+import { accumulateResponse, UpstreamStreamError } from "./translate/accumulate.ts"
import { CodexError, postCodex } from "./codex/client.ts"
import { countTokens } from "./count-tokens.ts"
@@ -142,10 +142,33 @@ async function handleMessages(req: Request, reqId: string): Promise<Response> {
})
}
- const result = await accumulateResponse(upstream.body, { messageId, model: body.model })
- return new Response(JSON.stringify(result), {
- headers: { "content-type": "application/json" },
- })
+ try {
+ const result = await accumulateResponse(upstream.body, { messageId, model: body.model })
+ return new Response(JSON.stringify(result), {
+ headers: { "content-type": "application/json" },
+ })
+ } catch (err) {
+ if (err instanceof UpstreamStreamError) {
+ log.warn("upstream stream error (non-streaming)", {
+ reqId,
+ kind: err.kind,
+ message: err.message,
+ })
+ if (err.kind === "rate_limit") {
+ const headers: Record<string, string> = { "content-type": "application/json" }
+ if (err.retryAfterSeconds) headers["retry-after"] = String(err.retryAfterSeconds)
+ return new Response(
+ JSON.stringify({
+ type: "error",
+ error: { type: "rate_limit_error", message: err.message },
+ }),
+ { status: 429, headers },
+ )
+ }
+ return jsonError(502, "api_error", err.message)
+ }
+ throw err
+ }
}
function jsonError(status: number, type: string, message: string): Response {
diff --git a/src/translate/accumulate.ts b/src/translate/accumulate.ts
index 7cefc2c..f60a17b 100644
--- a/src/translate/accumulate.ts
+++ b/src/translate/accumulate.ts
@@ -1,5 +1,16 @@
import { parseSseStream } from "./sse.ts"
+export class UpstreamStreamError extends Error {
+ constructor(
+ public kind: "rate_limit" | "failed",
+ message: string,
+ public retryAfterSeconds?: number,
+ ) {
+ super(message)
+ this.name = "UpstreamStreamError"
+ }
+}
+
export interface AnthropicNonStreamResponse {
id: string
type: "message"
@@ -50,6 +61,20 @@ export async function accumulateResponse(
continue
}
const t = p.type || evt.event || ""
+ if (t === "codex.rate_limits") {
+ if (p.rate_limits?.limit_reached) {
+ throw new UpstreamStreamError(
+ "rate_limit",
+ "rate limit reached",
+ p.rate_limits?.primary?.reset_after_seconds,
+ )
+ }
+ continue
+ }
+ if (t === "response.failed" || t === "response.error" || t === "error") {
+ const message = p?.response?.error?.message || p?.error?.message || "Upstream error"
+ throw new UpstreamStreamError("failed", message)
+ }
if (t === "response.output_item.added") {
const item = p.item
const oi = p.output_index