ghc-proxy 0.9.0 → 0.9.1

package/README.md

@@ -119,7 +119,7 @@ bunx ghc-proxy@latest selfcheck      # Probe the packaged bundle (loads every to
 | `--dump-failed-payloads` | `-D` | `false` | Dump failed `/responses` payloads on upstream 400 errors for debugging. Can also be enabled with `DUMP_FAILED_PAYLOADS=1`. |
 | `--proxy-env` | -- | `false` | Use `HTTP_PROXY`/`HTTPS_PROXY` from env (Node.js only; Bun reads proxy env natively) |
 | `--idle-timeout` | -- | `120` | Bun server idle timeout in seconds (`0` disables; Bun max is `255`; streaming routes disable idle timeout automatically) |
-| `--upstream-timeout` | -- | `1800` | Upstream request timeout in seconds (0 to disable) |
+| `--upstream-timeout` | -- | `1800` | Upstream request timeout in seconds (`0` disables). Enforced as a total-duration `AbortSignal`. Note both runtimes also apply their own ~300s **idle** timeout to `fetch` (Bun's built-in limit; Node's undici `headersTimeout`/`bodyTimeout`), which fires when no byte arrives for that long — a steadily streaming response is not capped by it, but a stalled one is rejected at ~300s and returned as a `504`. |
 | `--upstream-queue-concurrency` | -- | `10` | Maximum concurrent Copilot upstream requests |
 | `--upstream-queue-retries` | -- | `5` | Maximum retries for transient upstream responses. Completion requests (`/v1/messages`, `/chat/completions`, `/responses`) retry only `429`/`529`; effect-free requests also retry `408`, `500`, `502`, `503`, `504` |
 | `--upstream-queue-base-delay` | -- | `2` | Base delay in seconds for upstream retry backoff when `Retry-After` is absent |

package/dist/main.mjs

@@ -7419,7 +7419,7 @@ const checkUsage = defineCommand({
 });
 //#endregion
 //#region src/util/version.ts
-const VERSION = "0.9.0";
+const VERSION = "0.9.1";
 //#endregion
 //#region src/debug.ts
 function getRuntimeInfo() {
@@ -47868,6 +47868,61 @@ function logRequest(method, url, status, elapsed, modelInfo, requestId) {
 	console.log(`${line}${formatModelMapping(modelInfo)}${rid}`);
 }
 //#endregion
+//#region src/lib/timeout-error.ts
+/**
+* Whether an error represents a request that timed out or was aborted.
+*
+* The shape differs by runtime, so the check is structural rather than a
+* single `name` comparison:
+* - Bun rejects with a flat `DOMException` named `TimeoutError` (its ~300s
+*   `fetch` ceiling, `AbortSignal.timeout`) or `AbortError`.
+* - Node rejects with `TypeError('fetch failed' | 'terminated')` and puts the
+*   real undici error on `.cause` (`HeadersTimeoutError`, `BodyTimeoutError`,
+*   `ConnectTimeoutError`), so the top-level error carries no signal at all —
+*   `TypeError('fetch failed')` is also what `ECONNREFUSED` and DNS failures
+*   look like. The discriminator is the cause's `name`/`code`.
+*
+* Both runtimes enforce a ~300s upstream ceiling by default (Node's is
+* undici's `headersTimeout`/`bodyTimeout` default of `300e3`), which fires
+* long before the configured `--upstream-timeout` of 1800s.
+*
+* Kept in one place because the rule is checked on both sides of the stream
+* boundary: `src/server.ts` maps it to a 504 before the first byte, and the
+* Anthropic stream transducer maps it to an SSE error frame after. Two
+* implementations of "what counts as a timeout" is how one of them ends up
+* recognizing only half the errors.
+*/
+const TIMEOUT_ERROR_NAMES = new Set([
+	"AbortError",
+	"TimeoutError",
+	"ConnectTimeoutError",
+	"HeadersTimeoutError",
+	"BodyTimeoutError"
+]);
+const TIMEOUT_ERROR_CODES = new Set([
+	"UND_ERR_CONNECT_TIMEOUT",
+	"UND_ERR_HEADERS_TIMEOUT",
+	"UND_ERR_BODY_TIMEOUT",
+	"ETIMEDOUT"
+]);
+const MAX_CAUSE_DEPTH = 5;
+function matchesTimeoutShape(value, depth) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	if (typeof candidate.name === "string" && TIMEOUT_ERROR_NAMES.has(candidate.name)) return true;
+	if (typeof candidate.code === "string" && TIMEOUT_ERROR_CODES.has(candidate.code)) return true;
+	if (depth >= MAX_CAUSE_DEPTH) return false;
+	if (matchesTimeoutShape(candidate.cause, depth + 1)) return true;
+	return Array.isArray(candidate.errors) && candidate.errors.some((inner) => matchesTimeoutShape(inner, depth + 1));
+}
+function isTimeoutLikeError(error) {
+	try {
+		return matchesTimeoutShape(error, 0);
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/lib/sse-adapter.ts
 /**
 * Serializes Anthropic stream events into SSE output items
@@ -49418,6 +49473,14 @@ function createUpstreamSignal(clientSignal, timeoutMs = DEFAULT_TIMEOUT_MS) {
 }
 /**
 * Convenience wrapper that reads the upstream timeout from runtime config.
+*
+* This signal is a *total-duration* limit. Both runtimes separately apply an
+* ~300s **idle** timeout to `fetch` — Bun's is built in, Node's is undici's
+* `headersTimeout` / `bodyTimeout` default of `300e3` — which resets on every
+* byte received. A response that keeps streaming therefore runs past 300s and
+* is bounded only by this signal; a stalled one is rejected at ~300s by the
+* runtime instead. `isTimeoutLikeError` recognizes both runtimes' shapes so
+* every path maps to a 504.
 */
 function createUpstreamSignalFromConfig(clientSignal) {
 	return createUpstreamSignal(clientSignal, authStore.upstreamTimeoutSeconds !== void 0 ? authStore.upstreamTimeoutSeconds * 1e3 : void 0);
@@ -50465,14 +50528,9 @@ var AnthropicStreamTranslator = class {
 		this.state.messageStartSent = true;
 	}
 	getErrorMessage(error) {
-		if (this.isTimeoutError(error)) return "Upstream streaming request timed out. Please retry.";
+		if (isTimeoutLikeError(error)) return "Upstream streaming request timed out. Please retry.";
 		return "An unexpected error occurred during streaming.";
 	}
-	isTimeoutError(error) {
-		if (error instanceof DOMException) return error.name === "TimeoutError";
-		if (error instanceof Error) return error.name === "TimeoutError";
-		return false;
-	}
 	toConversationDeltas(chunk) {
 		if (chunk.choices.length === 0) return [];
 		const choice = chunk.choices.toSorted((left, right) => left.index - right.index)[0];
@@ -53344,6 +53402,33 @@ function createUsageRoute() {
 //#endregion
 //#region src/server.ts
 const isBun = typeof globalThis.Bun !== "undefined";
+/**
+* Maps a thrown error to a client response.
+*
+* `set.status` is written on every branch because `onError` returns a fresh
+* `Response` instead of falling through Elysia's normal path — `set.status`
+* would otherwise still hold whatever it was before the throw, and the access
+* log in `onAfterResponse` reads it. Without the write-back, a 504 is logged
+* as a 500.
+*
+* Exported so tests exercise this mapping rather than a copy of it.
+*/
+function handleRouteError({ code, error, set }) {
+	if (code === "HTTP") return;
+	if (isTimeoutLikeError(error)) {
+		set.status = 504;
+		return Response.json({ error: {
+			message: "Upstream request timed out before a response was received.",
+			type: "timeout_error"
+		} }, { status: 504 });
+	}
+	const message = error instanceof Error ? error.message : String(error);
+	set.status = 500;
+	return Response.json({ error: {
+		message,
+		type: "error"
+	} }, { status: 500 });
+}
 function createServer(options) {
 	return new Elysia({
 		adapter: isBun ? void 0 : node(),
@@ -53363,18 +53448,11 @@ function createServer(options) {
 		const elapsed = formatElapsed(requestStart);
 		const status = typeof set.status === "number" ? set.status : 200;
 		logRequest(request.method, request.url, status, elapsed, getRequestModelMapping(request), requestId);
-	}).onError(({ code, error }) => {
-		if (code === "HTTP") return;
-		if (error instanceof Error && error.name === "AbortError") return Response.json({ error: {
-			message: "Upstream request was aborted",
-			type: "timeout_error"
-		} }, { status: 504 });
-		const message = error instanceof Error ? error.message : String(error);
-		return Response.json({ error: {
-			message,
-			type: "error"
-		} }, { status: 500 });
-	}).get("/", () => "Server running").get("/health", () => ({
+	}).onError(({ code, error, set }) => handleRouteError({
+		code,
+		error,
+		set
+	})).get("/", () => "Server running").get("/health", () => ({
 		status: "ok",
 		copilotToken: !!authStore.copilotToken,
 		modelsLoaded: !!modelCache.getModels(),
@@ -53547,7 +53625,7 @@ const start = defineCommand({
 		"upstream-timeout": {
 			type: "string",
 			default: "1800",
-			description: "Upstream request timeout in seconds (0 to disable)"
+			description: "Upstream request timeout in seconds (0 to disable). Enforced as a total-duration limit; both runtimes additionally apply their own ~300s idle timeout to fetch, which a steadily streaming response does not trip."
 		},
 		"upstream-queue-concurrency": {
 			type: "string",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ghc-proxy",
   "type": "module",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "GitHub Copilot to OpenAI/Anthropic API proxy - Use Copilot with Claude Code, Cursor, and more",
   "author": "wxxb789 <wxxb789@outlook.com>",
   "homepage": "https://github.com/wxxb789/ghc-proxy",