anygate 0.6.2 → 0.6.3

package/dist/{chunk-EMBABL33.js → chunk-NU4KMZIM.js}

@@ -10,10 +10,11 @@ import {
   OPENCODE_CACHE_PATH,
   RATE_LIMIT_MAX_REQUESTS,
   RATE_LIMIT_WINDOW_MS,
+  REQUEST_TIMEOUT_MS,
   VERSION,
   VERTEX_ANTHROPIC_NPM,
   classifyModelFormat
-} from "./chunk-S5WL3M5G.js";
+} from "./chunk-RNW2MGKL.js";
 import {
   getTemplateById,
   listAddableTemplates
@@ -164,7 +165,18 @@ async function pollOpenAiDeviceCodeToken(deviceData, opts) {
       const tokens = await tokenResponse.json();
       return { tokens, accountId: extractOpenAiAccountId(tokens) };
     }
-    if (response.status !== 403 && response.status !== 404) {
+    if (response.status === 403) {
+      const detail = await response.text().catch(() => "");
+      try {
+        const parsed = JSON.parse(detail);
+        if (parsed.error?.code === "deviceauth_authorization_pending") break;
+      } catch {
+      }
+      if (detail.trim()) {
+        const msg = detail.replace(/\s+/g, " ").trim().slice(0, 300);
+        throw new Error(`OpenAI device authorization failed (403): ${msg}`);
+      }
+    } else if (response.status !== 404) {
       const detail = await response.text().catch(() => "");
       throw new Error(
         `OpenAI device authorization failed (${response.status})${detail.trim() ? `: ${detail.replace(/\s+/g, " ").trim().slice(0, 200)}` : ""}`
@@ -174,7 +186,9 @@ async function pollOpenAiDeviceCodeToken(deviceData, opts) {
       Math.min(intervalMs + OAUTH_POLLING_SAFETY_MARGIN_MS, Math.max(0, deadline - now()))
     );
   }
-  throw new Error("OpenAI device authorization timed out");
+  throw new Error(
+    "OpenAI device authorization timed out \u2014 your account may not have device code authorization enabled. Enable it in ChatGPT Security Settings and try again, or use the CLI: anygate providers auth openai"
+  );
 }
 async function refreshOpenAiAccessToken(refreshToken) {
   return postOAuthRefresh(
@@ -196,6 +210,47 @@ async function runOpenAiDeviceCodeFlow(onDeviceCode, opts) {
   onDeviceCode({ url: openAiDeviceCodeUrl(), userCode: deviceData.user_code });
   return pollOpenAiDeviceCodeToken(deviceData, opts);
 }
+async function buildOpenAiBrowserAuthUrl(redirectUri) {
+  const { verifier, challenge } = await generatePkce();
+  const state = generateOAuthState();
+  const params = new URLSearchParams({
+    client_id: CLIENT_ID,
+    response_type: "code",
+    redirect_uri: redirectUri,
+    scope: "openid profile email",
+    state,
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    // Prompt to force fresh sign-in if needed
+    prompt: "login"
+  });
+  return {
+    authUrl: `${ISSUER}/v1/authorize?${params}`,
+    codeVerifier: verifier,
+    oauthState: state
+  };
+}
+async function exchangeOpenAiBrowserToken(code, codeVerifier) {
+  const tokenResponse = await fetch(`${ISSUER}/auth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: `${ISSUER}/deviceauth/callback`,
+      client_id: CLIENT_ID,
+      code_verifier: codeVerifier
+    }).toString()
+  });
+  if (!tokenResponse.ok) {
+    const detail = await tokenResponse.text().catch(() => "");
+    throw new Error(
+      `OpenAI token exchange failed (${tokenResponse.status})${detail.trim() ? `: ${detail.replace(/\s+/g, " ").trim().slice(0, 200)}` : ""}`
+    );
+  }
+  const tokens = await tokenResponse.json();
+  return { tokens, accountId: extractOpenAiAccountId(tokens) };
+}
 
 // src/auth/responses-websocket.ts
 var RESPONSES_LITE_HEADER = "x-openai-internal-codex-responses-lite";
@@ -474,6 +529,178 @@ function injectClaudeIdentity(body, providerData, seed) {
   return { sessionId, userId };
 }
 
+// src/gateway/providers/stream-sanitizer.ts
+function createNullChunkStripper() {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buffer = "";
+  const isNullDataLine = (line) => {
+    const trimmed = line.trimStart();
+    if (!trimmed.startsWith("data:")) return false;
+    return trimmed.slice(5).trim() === "null";
+  };
+  return new TransformStream({
+    transform(chunk, controller) {
+      buffer += decoder.decode(chunk, { stream: true });
+      const newlineIdx = buffer.lastIndexOf("\n");
+      if (newlineIdx === -1) return;
+      const complete = buffer.slice(0, newlineIdx + 1);
+      buffer = buffer.slice(newlineIdx + 1);
+      const kept = complete.split("\n").filter((line) => !isNullDataLine(line)).join("\n");
+      if (kept) controller.enqueue(encoder.encode(kept));
+    },
+    flush(controller) {
+      const tail = buffer + decoder.decode();
+      if (tail && !isNullDataLine(tail)) controller.enqueue(encoder.encode(tail));
+    }
+  });
+}
+function flattenContent(content) {
+  const text4 = [];
+  const reasoning = [];
+  const blocks = Array.isArray(content) ? content : [content];
+  for (const block of blocks) {
+    if (block == null) continue;
+    if (typeof block === "string") {
+      text4.push(block);
+      continue;
+    }
+    if (typeof block !== "object") {
+      text4.push(String(block));
+      continue;
+    }
+    const b = block;
+    const isReasoning = b.type === "thinking" || b.type === "reasoning" || b.thinking != null;
+    if (isReasoning) {
+      const t = b.thinking;
+      if (Array.isArray(t)) {
+        for (const item of t) {
+          if (typeof item === "string") reasoning.push(item);
+          else if (item && typeof item.text === "string") reasoning.push(item.text);
+        }
+      } else if (typeof t === "string") {
+        reasoning.push(t);
+      }
+      if (typeof b.text === "string") reasoning.push(b.text);
+    } else if (typeof b.text === "string") {
+      text4.push(b.text);
+    } else if (typeof b.content === "string") {
+      text4.push(b.content);
+    }
+  }
+  return { text: text4.join(""), reasoning: reasoning.join("") };
+}
+function normalizePart(part, idMap, preserveThinking = false) {
+  if (!part || typeof part !== "object") return;
+  if (Array.isArray(part.content) && !preserveThinking) {
+    const { text: text4, reasoning } = flattenContent(part.content);
+    part.content = text4;
+    if (reasoning) {
+      part.reasoning_content = (typeof part.reasoning_content === "string" ? part.reasoning_content : "") + reasoning;
+    }
+  }
+  if (Array.isArray(part.tool_calls)) {
+    part.tool_calls.forEach((tc, i) => {
+      if (!tc || typeof tc !== "object") return;
+      const tcIdx = typeof tc.index === "number" ? tc.index : i;
+      if (typeof tc.id !== "string" || tc.id === "") {
+        let existing = idMap.get(tcIdx);
+        if (!existing) {
+          existing = `call_${tcIdx}_${Math.random().toString(36).slice(2, 10)}`;
+          idMap.set(tcIdx, existing);
+        }
+        tc.id = existing;
+      }
+      if (!tc.function || typeof tc.function !== "object") tc.function = {};
+      if (typeof tc.function.name !== "string") tc.function.name = "";
+      if (typeof tc.function.arguments !== "string") tc.function.arguments = "";
+    });
+  }
+}
+function normalizeChunk(raw, ids, preserveThinking = false) {
+  if (!raw || typeof raw !== "object" || !Array.isArray(raw.choices)) return raw;
+  for (const choice of raw.choices) {
+    if (!choice || typeof choice !== "object") continue;
+    const choiceIdx = typeof choice.index === "number" ? choice.index : 0;
+    let idMap = ids.get(choiceIdx);
+    if (!idMap) {
+      idMap = /* @__PURE__ */ new Map();
+      ids.set(choiceIdx, idMap);
+    }
+    normalizePart(choice.delta, idMap, preserveThinking);
+    normalizePart(choice.message, idMap, preserveThinking);
+  }
+  return raw;
+}
+function createGlmChunkSanitizer(preserveThinking = false) {
+  const dec = new TextDecoder();
+  const enc = new TextEncoder();
+  let buffer = "";
+  const ids = /* @__PURE__ */ new Map();
+  const normalizeLine = (line) => {
+    if (!line.startsWith("data:")) return line;
+    const payload = line.slice(5).replace(/^\s+/, "");
+    if (payload === "" || payload === "[DONE]" || payload === "null") return line;
+    try {
+      const parsed = JSON.parse(payload);
+      if (parsed && typeof parsed === "object") {
+        return `data: ${JSON.stringify(normalizeChunk(parsed, ids, preserveThinking))}`;
+      }
+    } catch {
+    }
+    return line;
+  };
+  return new TransformStream({
+    transform(chunk, controller) {
+      buffer += dec.decode(chunk, { stream: true });
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        controller.enqueue(enc.encode(normalizeLine(line) + "\n"));
+      }
+    },
+    flush(controller) {
+      const tail = buffer + dec.decode();
+      if (tail.length > 0) controller.enqueue(enc.encode(normalizeLine(tail)));
+    }
+  });
+}
+async function sanitizeJsonResponse(resp, preserveThinking = false) {
+  const text4 = await resp.clone().text();
+  try {
+    const parsed = JSON.parse(text4);
+    if (parsed && typeof parsed === "object") {
+      const fixed = normalizeChunk(parsed, /* @__PURE__ */ new Map(), preserveThinking);
+      return new Response(JSON.stringify(fixed), {
+        status: resp.status,
+        statusText: resp.statusText,
+        headers: resp.headers
+      });
+    }
+  } catch {
+  }
+  return resp;
+}
+function makeSanitizingFetch(upstream = fetch, preserveThinking = false) {
+  return (async (input, init) => {
+    const resp = await upstream(input, init);
+    const contentType = resp.headers.get("content-type") ?? "";
+    if (resp.body && contentType.includes("text/event-stream")) {
+      const sanitized = resp.body.pipeThrough(createNullChunkStripper()).pipeThrough(createGlmChunkSanitizer(preserveThinking));
+      return new Response(sanitized, {
+        status: resp.status,
+        statusText: resp.statusText,
+        headers: resp.headers
+      });
+    }
+    if (resp.body && contentType.includes("application/json")) {
+      return sanitizeJsonResponse(resp);
+    }
+    return resp;
+  });
+}
+
 // src/gateway/providers/provider-reasoning.ts
 var ANTHROPIC_EFFORT_LEVELS = ["low", "medium", "high"];
 var OPENAI_EFFORT_LEVELS = ["low", "medium", "high", "xhigh"];
@@ -954,37 +1181,49 @@ function thinkingProviderOptions(npm) {
       }
     };
   }
+  if (npm === "@ai-sdk/mistral") {
+    return { mistral: { reasoningEffort: "high" } };
+  }
   return void 0;
 }
 
 // src/gateway/providers/provider-factory.ts
-var RESPONSES_ONLY_PREFIXES = ["gpt-5-codex", "gpt-5-pro", "gpt-5.2-pro", "o3", "o4"];
-function createNullChunkStripper() {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let buffer = "";
-  const isNullDataLine = (line) => {
-    const trimmed = line.trimStart();
-    if (!trimmed.startsWith("data:")) return false;
-    return trimmed.slice(5).trim() === "null";
-  };
-  return new TransformStream({
-    transform(chunk, controller) {
-      buffer += decoder.decode(chunk, { stream: true });
-      const newlineIdx = buffer.lastIndexOf("\n");
-      if (newlineIdx === -1) return;
-      const complete = buffer.slice(0, newlineIdx + 1);
-      buffer = buffer.slice(newlineIdx + 1);
-      const kept = complete.split("\n").filter((line) => !isNullDataLine(line)).join("\n");
-      if (kept) controller.enqueue(encoder.encode(kept));
+function buildUpstreamFetch(spec, preserveThinking = false) {
+  return makeSanitizingFetch(
+    async (input, init) => {
+      const url = typeof input === "string" ? input : input?.url ?? String(input);
+      const hdrs = new Headers(init?.headers ?? {});
+      if (spec.headers) {
+        for (const [k, v] of Object.entries(spec.headers)) hdrs.set(k, v);
+      }
+      const nextInit = { ...init, headers: hdrs };
+      if (process.env.ANYGATE_TRACE === "1") {
+        const shown = [];
+        hdrs.forEach((v, k) => {
+          shown.push(`${k}: ${/authorization|api-key/i.test(k) ? v.slice(0, 12) + "\u2026" : v}`);
+        });
+        spec.onDebug?.(`[sdk-fetch] POST ${url}
+[sdk-fetch] headers:
+  ${shown.join("\n  ")}`);
+        if (typeof init?.body === "string") {
+          spec.onDebug?.(`[sdk-fetch] \u2192 body: ${init.body.slice(0, 8e3)}`);
+        }
+      }
+      const resp = await fetch(input, nextInit);
+      if (process.env.ANYGATE_TRACE === "1") {
+        spec.onDebug?.(`[sdk-fetch] \u2190 HTTP ${resp.status}`);
+        if (resp.status >= 400) {
+          const body = await resp.clone().text().catch(() => "");
+          spec.onDebug?.(`[sdk-fetch] \u2190 body: ${body.slice(0, 500)}`);
+        }
+      }
+      return resp;
     },
-    flush(controller) {
-      const tail = buffer + decoder.decode();
-      if (tail && !isNullDataLine(tail)) controller.enqueue(encoder.encode(tail));
-    }
-  });
+    preserveThinking
+  );
 }
 var factoryCache = /* @__PURE__ */ new Map();
+var RESPONSES_ONLY_PREFIXES = ["gpt-5-codex", "gpt-5-pro", "gpt-5.2-pro", "o3", "o4"];
 function modelPrefersResponsesApi(modelId) {
   const lower = modelId.toLowerCase();
   if (RESPONSES_ONLY_PREFIXES.some((prefix) => lower === prefix || lower.startsWith(`${prefix}-`))) {
@@ -1118,51 +1357,10 @@ async function createLanguageModel(spec) {
       // Custom headers like User-Agent must be forced at the fetch layer: the AI
       // SDK builds its own User-Agent and overwrites a header-option value on some
       // call paths (streaming vs non-streaming differ), which breaks providers that
-      // gate on client identity. This wrapper pins spec.headers onto every request
-      // regardless of path, and (when tracing) logs the exact wire headers + any
-      // error-response body so failures can be diagnosed from ground truth.
-      ...spec.headers || process.env.ANYGATE_TRACE === "1" ? {
-        fetch: (async (input, init) => {
-          const url = typeof input === "string" ? input : input?.url ?? String(input);
-          const hdrs = new Headers(init?.headers ?? {});
-          if (spec.headers) {
-            for (const [k, v] of Object.entries(spec.headers)) hdrs.set(k, v);
-          }
-          const nextInit = { ...init, headers: hdrs };
-          if (process.env.ANYGATE_TRACE === "1") {
-            const shown = [];
-            hdrs.forEach((v, k) => {
-              shown.push(`${k}: ${/authorization|api-key/i.test(k) ? v.slice(0, 12) + "\u2026" : v}`);
-            });
-            spec.onDebug?.(
-              `[sdk-fetch] POST ${url}
-[sdk-fetch] headers:
-  ${shown.join("\n  ")}`
-            );
-            if (typeof init?.body === "string") {
-              spec.onDebug?.(`[sdk-fetch] \u2192 body: ${init.body.slice(0, 8e3)}`);
-            }
-          }
-          const resp = await fetch(input, nextInit);
-          if (process.env.ANYGATE_TRACE === "1") {
-            spec.onDebug?.(`[sdk-fetch] \u2190 HTTP ${resp.status}`);
-            if (resp.status >= 400) {
-              const body = await resp.clone().text().catch(() => "");
-              spec.onDebug?.(`[sdk-fetch] \u2190 body: ${body.slice(0, 500)}`);
-            }
-          }
-          const contentType = resp.headers.get("content-type") ?? "";
-          if (resp.body && contentType.includes("text/event-stream")) {
-            const sanitized = resp.body.pipeThrough(createNullChunkStripper());
-            return new Response(sanitized, {
-              status: resp.status,
-              statusText: resp.statusText,
-              headers: resp.headers
-            });
-          }
-          return resp;
-        })
-      } : {}
+      // gate on client identity. This wrapper also normalizes non-spec-compliant
+      // upstream streams (array `content`, missing tool-call `id`, `data: null`
+      // keepalives) so third-party models such as GLM-5.2 stream through cleanly.
+      fetch: buildUpstreamFetch(spec)
     };
     model = createOpenAICompatible({
       ...options
@@ -1179,11 +1377,12 @@ async function createLanguageModel(spec) {
     const provider = create({
       apiKey,
       ...baseURL ? { baseURL } : {},
-      ...spec.headers ? { headers: spec.headers } : {}
+      ...spec.headers ? { headers: spec.headers } : {},
+      fetch: buildUpstreamFetch(spec, npm === "@ai-sdk/mistral")
     });
     model = provider(modelId);
   }
-  const isReasoning = modelId.toLowerCase().match(/deepseek-r1|think|reasoning|qwq/);
+  const isReasoning = modelId.toLowerCase().match(/deepseek-(?:r1|v4)|think|reasoning|qwq/);
   if (isReasoning) {
     return wrapLanguageModel({
       model,
@@ -2398,6 +2597,12 @@ function shouldHideByModelsDevCapabilities(entry) {
   if (entry.interactions === true && entry.chat === false) return true;
   return false;
 }
+function resolveReasoning(providerId, modelId, cache = loadModelsDevCache()) {
+  const entry = findModelsDevModel(providerId, modelId, cache);
+  if (!entry) return void 0;
+  if (typeof entry.reasoning === "boolean") return entry.reasoning;
+  return void 0;
+}
 
 // src/apps/shared/trace-log.ts
 import { chmodSync as chmodSync5, existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
@@ -2649,46 +2854,33 @@ async function getServerPasswordKeyring() {
   }
 }
 async function getSavedServerPassword() {
-  const config = readConfig();
-  if (config.server?.savedPassword) {
-    const pwd = config.server.savedPassword;
-    const keyring2 = await getServerPasswordKeyring();
-    if (keyring2) {
-      try {
-        await keyring2.setPassword(pwd);
-        delete config.server.savedPassword;
-        if (Object.keys(config.server).length === 0) delete config.server;
-        writeConfig(config);
-      } catch {
-      }
-    }
-    return pwd;
-  }
   const keyring = await getServerPasswordKeyring();
-  if (keyring) {
+  const config = readConfig();
+  const legacy = config.server?.savedPassword;
+  if (legacy && keyring) {
     try {
-      return await keyring.getPassword();
+      await keyring.setPassword(legacy);
+      delete config.server.savedPassword;
+      if (Object.keys(config.server).length === 0) delete config.server;
+      writeConfig(config);
     } catch {
-      return null;
     }
   }
-  return null;
+  if (!keyring) return null;
+  try {
+    return await keyring.getPassword();
+  } catch {
+    return null;
+  }
 }
 async function setSavedServerPassword(password) {
   const keyring = await getServerPasswordKeyring();
-  if (keyring) {
-    try {
-      await keyring.setPassword(password);
-      return;
-    } catch {
-    }
+  if (!keyring) {
+    throw new Error(
+      "Network-mode server password requires OS keychain support (@napi-rs/keyring). Install the optional dependency or start the server with `--password <value>` for this run only."
+    );
   }
-  const config = readConfig();
-  config.server = {
-    ...config.server ?? {},
-    savedPassword: password
-  };
-  writeConfig(config);
+  await keyring.setPassword(password);
 }
 function getServerExposedProviders() {
   const list = readConfig().server?.exposedProviders;
@@ -2746,6 +2938,9 @@ function setServerListenMode(listenMode) {
   };
   writeConfig(config);
 }
+function getServerBudget() {
+  return readConfig().server?.budget ?? {};
+}
 
 // src/apps/shared/context-window.ts
 import { readFileSync as readFileSync7 } from "fs";
@@ -3345,12 +3540,6 @@ function guiCallbackRedirectUri(host) {
   return `http://${host}/auth/callback`;
 }
 
-// src/auth/antigravity-oauth.ts
-import open2 from "open";
-import { readFileSync as readFileSync8 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as pathJoin } from "path";
-
 // src/auth/callback-server.ts
 import http from "http";
 var SUCCESS_HTML = `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Authorized</title></head>
@@ -3405,6 +3594,10 @@ function startCallbackServer() {
 }
 
 // src/auth/antigravity-oauth.ts
+import open2 from "open";
+import { readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as pathJoin } from "path";
 var DEFAULT_ANTIGRAVITY_CLIENT_ID = [
   "107100606059",
   "1-tmhssin2h2",
@@ -5054,6 +5247,16 @@ function parseModelList(body, npm, providerId) {
     const freeStatus = classifyFreeStatus({
       model: { cost, isFree: row.isFree }
     });
+    let reasoning;
+    const caps = row.capabilities;
+    if (caps && typeof caps === "object") {
+      const capsObj = caps;
+      const r = capsObj.reasoning;
+      if (typeof r === "boolean") reasoning = r;
+    }
+    if (reasoning === void 0 && typeof row.reasoning === "boolean") {
+      reasoning = row.reasoning;
+    }
     const contextWindow = row.context_length ?? row.contextWindow ?? row.context_window ?? resolveContextWindow(id, void 0, providerId);
     models.push({
       id,
@@ -5070,7 +5273,8 @@ function parseModelList(body, npm, providerId) {
       providerId,
       supportedParameters: Array.isArray(row.supported_parameters) ? row.supported_parameters : void 0,
       useResponsesLite: typeof row.use_responses_lite === "boolean" ? row.use_responses_lite : void 0,
-      preferWebSockets: typeof row.prefer_websockets === "boolean" ? row.prefer_websockets : void 0
+      preferWebSockets: typeof row.prefer_websockets === "boolean" ? row.prefer_websockets : void 0,
+      reasoning: reasoning === void 0 ? void 0 : reasoning
     });
   }
   return models;
@@ -5321,47 +5525,102 @@ async function addProviderFromTemplate(template, apiKey, opts) {
 
 // src/shared/http.ts
 import * as zlib from "zlib";
-function decodeRequestBody(raw, encoding) {
-  const enc = (Array.isArray(encoding) ? encoding.join(",") : encoding ?? "").toLowerCase().trim();
-  if (!enc || enc === "identity") return raw.toString();
-  switch (enc) {
+var RequestBodyTooLargeError = class extends Error {
+  constructor(context) {
+    super(`Request body too large (${context}, limit ${MAX_REQUEST_BODY_BYTES} bytes)`);
+    this.name = "RequestBodyTooLargeError";
+  }
+};
+function decodeBoundedChunk(createTransform, chunk, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const transform = createTransform();
+    const outChunks = [];
+    let total = 0;
+    let settled = false;
+    const finish = (err) => {
+      if (settled) return;
+      settled = true;
+      if (err) reject(err);
+      else resolve(Buffer.concat(outChunks).toString());
+    };
+    transform.on("data", (out) => {
+      total += out.length;
+      if (total > maxBytes) {
+        finish(new RequestBodyTooLargeError("decompressed"));
+        transform.destroy();
+        return;
+      }
+      outChunks.push(out);
+    });
+    transform.on("error", (err) => finish(err));
+    transform.on("end", () => finish(null));
+    transform.end(chunk);
+  });
+}
+function decoderFor(encoding) {
+  switch (encoding) {
     case "gzip":
     case "x-gzip":
-      return zlib.gunzipSync(raw).toString();
+      return { label: encoding, createTransform: () => zlib.createGunzip() };
     case "deflate":
-      return zlib.inflateSync(raw).toString();
+      return { label: encoding, createTransform: () => zlib.createInflate() };
     case "br":
-      return zlib.brotliDecompressSync(raw).toString();
+      return { label: encoding, createTransform: () => zlib.createBrotliDecompress() };
     case "zstd":
-      if (typeof zlib.zstdDecompressSync !== "function") {
+      if (typeof zlib.createZstdDecompress !== "function") {
         throw new Error("zstd request encoding requires Node >= 22.15");
       }
-      return zlib.zstdDecompressSync(raw).toString();
+      return { label: encoding, createTransform: () => zlib.createZstdDecompress() };
     default:
-      return raw.toString();
+      return { label: `${encoding || "identity"} (passthrough)` };
+  }
+}
+async function inflateBounded(raw, spec, maxBytes) {
+  if (!spec.createTransform) return raw.toString();
+  const SLICE = 64 * 1024;
+  let text4 = "";
+  for (let offset = 0; offset < raw.length || offset === 0; offset += SLICE) {
+    const slice = raw.subarray(offset, Math.min(offset + SLICE, raw.length));
+    const part = await decodeBoundedChunk(spec.createTransform, slice, maxBytes - Buffer.byteLength(text4));
+    text4 += part;
+    if (Buffer.byteLength(text4) > maxBytes) {
+      throw new RequestBodyTooLargeError(`decompressed (${spec.label})`);
+    }
+    if (offset + SLICE >= raw.length) break;
   }
+  return text4;
+}
+async function decodeRequestBody(raw, encoding) {
+  const enc = (Array.isArray(encoding) ? encoding.join(",") : encoding ?? "").toLowerCase().trim();
+  if (!enc || enc === "identity") return raw.toString();
+  const spec = decoderFor(enc);
+  return inflateBounded(raw, spec, MAX_REQUEST_BODY_BYTES);
 }
 function readBody(req) {
   return new Promise((resolve, reject) => {
     const chunks = [];
     let totalSize = 0;
+    let settled = false;
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+      req.destroy();
+    };
     req.on("data", (c) => {
       totalSize += c.length;
-      if (totalSize > 50 * 1024 * 1024) {
-        reject(new Error("Request body too large"));
-        req.destroy();
+      if (totalSize > MAX_REQUEST_BODY_BYTES) {
+        fail(new RequestBodyTooLargeError("compressed"));
         return;
       }
       chunks.push(c);
     });
     req.on("end", () => {
-      try {
-        resolve(decodeRequestBody(Buffer.concat(chunks), req.headers["content-encoding"]));
-      } catch (err) {
-        reject(err);
-      }
+      if (settled) return;
+      settled = true;
+      decodeRequestBody(Buffer.concat(chunks), req.headers["content-encoding"]).then(resolve, reject);
     });
-    req.on("error", reject);
+    req.on("error", fail);
   });
 }
 function extractApiKey(req) {
@@ -5384,7 +5643,22 @@ function sendJson(res, status, body, extraHeaders) {
   res.end(json);
 }
 var rateLimitStore = /* @__PURE__ */ new Map();
+var RATE_LIMIT_PRUNE_THRESHOLD = 1e4;
+function pruneRateLimits(now = Date.now()) {
+  const staleBefore = now - 2 * RATE_LIMIT_WINDOW_MS;
+  let pruned = 0;
+  for (const [key, entry] of rateLimitStore) {
+    if (entry.resetAt < staleBefore) {
+      rateLimitStore.delete(key);
+      pruned++;
+    }
+  }
+  return pruned;
+}
 function checkRateLimit(clientId) {
+  if (rateLimitStore.size > RATE_LIMIT_PRUNE_THRESHOLD) {
+    pruneRateLimits();
+  }
   const now = Date.now();
   const entry = rateLimitStore.get(clientId);
   if (!entry || now > entry.resetAt) {
@@ -5410,16 +5684,24 @@ import { appendFileSync as appendFileSync2, openSync as openSync4, writeSync as
 import { Readable } from "stream";
 
 // src/gateway/server/auth.ts
+import { timingSafeEqual } from "crypto";
+import { createHash as createHash2 } from "crypto";
 function sanitizeCredential(value) {
   if (!value) return null;
   const firstLine = value.trim().split(/\r?\n/)[0]?.trim();
   return firstLine || null;
 }
+function timingSafeEqualStrings(a, b) {
+  const da = createHash2("sha256").update(a, "utf8").digest();
+  const db = createHash2("sha256").update(b, "utf8").digest();
+  return timingSafeEqual(da, db);
+}
 function isAuthorized(request, serverPassword) {
   if (serverPassword === null) return true;
   const bearerToken = extractBearerToken(request.headers.get("authorization"));
-  if (bearerToken === serverPassword) return true;
-  return sanitizeCredential(request.headers.get("x-api-key")) === serverPassword;
+  if (bearerToken !== null && timingSafeEqualStrings(bearerToken, serverPassword)) return true;
+  const apiKey = sanitizeCredential(request.headers.get("x-api-key"));
+  return apiKey !== null && timingSafeEqualStrings(apiKey, serverPassword);
 }
 function extractBearerToken(value) {
   if (!value) return null;
@@ -5584,73 +5866,169 @@ async function fetchWithOAuthRetry(apiKey, request, refreshToken) {
   response = await request(refreshed);
   return { response, apiKey: refreshed, refreshed: true };
 }
-async function forwardAnthropicMessages(res, messagesUrl, body, apiKey, clientWantsStream, inboundBeta, authType, log6, claudeCodeSessionId, extraHeaders, refreshToken, onTokenRefreshed) {
-  const doFetch = (key) => fetch(messagesUrl, {
-    method: "POST",
-    headers: anthropicUpstreamHeaders(
-      key,
-      clientWantsStream,
-      inboundBeta,
-      authType,
-      claudeCodeSessionId,
-      extraHeaders
-    ),
-    body: JSON.stringify(body)
-  });
-  let upstreamRes;
-  try {
-    const retryResult = await fetchWithOAuthRetry(apiKey, doFetch, refreshToken);
-    upstreamRes = retryResult.response;
-    if (retryResult.refreshed) onTokenRefreshed?.(retryResult.apiKey);
-  } catch (err) {
-    throw new UpstreamUnreachableError(err);
+function scanAnthropicSseUsage(chunkText, usage) {
+  for (const line of chunkText.split("\n")) {
+    const t = line.startsWith("data:") ? line.slice(5).trim() : line.trim();
+    if (!t || t === "[DONE]") continue;
+    try {
+      const obj = JSON.parse(t);
+      const startUsage = obj.message?.usage;
+      if (startUsage) {
+        usage.inputTokens = startUsage.input_tokens ?? usage.inputTokens;
+        if (typeof startUsage.output_tokens === "number")
+          usage.outputTokens = startUsage.output_tokens;
+        continue;
+      }
+      const deltaUsage = obj.usage;
+      if (deltaUsage && typeof deltaUsage.output_tokens === "number") {
+        usage.outputTokens = deltaUsage.output_tokens;
+      }
+    } catch {
+    }
   }
-  if (!upstreamRes.ok) {
-    const errBody = await upstreamRes.text();
-    log6?.(`anthropic upstream ${upstreamRes.status}: ${errBody}`);
-    res.writeHead(upstreamRes.status, {
-      "Content-Type": upstreamRes.headers.get("content-type") || "application/json"
+}
+async function forwardAnthropicMessages(res, messagesUrl, body, apiKey, clientWantsStream, inboundBeta, authType, log6, claudeCodeSessionId, extraHeaders, refreshToken, onTokenRefreshed, timeoutMs = REQUEST_TIMEOUT_MS) {
+  const usage = { inputTokens: 0, outputTokens: 0 };
+  const disconnectController = new AbortController();
+  const onClientGone = () => disconnectController.abort();
+  res.on("close", onClientGone);
+  res.on("error", onClientGone);
+  const timeoutController = new AbortController();
+  const timer = setTimeout(() => timeoutController.abort(), timeoutMs);
+  const combinedSignal = disconnectController.signal.aborted ? disconnectController.signal : connectAbortSignals(disconnectController.signal, timeoutController.signal);
+  try {
+    return await forwardInner(combinedSignal);
+  } finally {
+    clearTimeout(timer);
+    res.off("close", onClientGone);
+    res.off("error", onClientGone);
+  }
+  function connectAbortSignals(a, b) {
+    const merged = new AbortController();
+    const relay = () => merged.abort();
+    if (a.aborted || b.aborted) {
+      merged.abort();
+      return merged.signal;
+    }
+    a.addEventListener("abort", relay, { once: true });
+    b.addEventListener("abort", relay, { once: true });
+    return merged.signal;
+  }
+  async function forwardInner(signal) {
+    const doFetch = (key) => fetch(messagesUrl, {
+      method: "POST",
+      headers: anthropicUpstreamHeaders(
+        key,
+        clientWantsStream,
+        inboundBeta,
+        authType,
+        claudeCodeSessionId,
+        extraHeaders
+      ),
+      body: JSON.stringify(body),
+      signal
     });
-    res.end(errBody);
-    return;
-  }
-  if (clientWantsStream && upstreamRes.body) {
+    let upstreamRes;
+    try {
+      const retryResult = await fetchWithOAuthRetry(apiKey, doFetch, refreshToken);
+      upstreamRes = retryResult.response;
+      if (retryResult.refreshed) onTokenRefreshed?.(retryResult.apiKey);
+    } catch (err) {
+      if (signal.aborted) {
+        emitAborted(res, clientWantsStream);
+        return usage;
+      }
+      throw new UpstreamUnreachableError(err);
+    }
+    if (!upstreamRes.ok) {
+      const errBody = await upstreamRes.text();
+      log6?.(`anthropic upstream ${upstreamRes.status}: ${errBody}`);
+      res.writeHead(upstreamRes.status, {
+        "Content-Type": upstreamRes.headers.get("content-type") || "application/json"
+      });
+      res.end(errBody);
+      return usage;
+    }
+    if (clientWantsStream && upstreamRes.body) {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      await new Promise((resolve, reject) => {
+        Readable.fromWeb(upstreamRes.body).on("data", (chunk) => scanAnthropicSseUsage(chunk.toString("utf8"), usage)).on("error", (err) => {
+          res.destroy();
+          reject(err);
+        }).on("end", () => resolve()).pipe(res);
+      }).catch(() => {
+      });
+      return usage;
+    }
+    if (!upstreamRes.body) {
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          type: "error",
+          error: { type: "api_error", message: "Upstream returned empty response body" }
+        })
+      );
+      return usage;
+    }
+    let text4;
+    try {
+      text4 = await upstreamRes.text();
+    } catch {
+      emitAborted(res, clientWantsStream);
+      return usage;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text4);
+    } catch {
+      res.writeHead(502, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          type: "error",
+          error: { type: "api_error", message: "Upstream response was not valid JSON" }
+        })
+      );
+      return usage;
+    }
+    const parsedUsage = parsed.usage;
+    if (parsedUsage) {
+      usage.inputTokens = parsedUsage.input_tokens ?? 0;
+      usage.outputTokens = parsedUsage.output_tokens ?? 0;
+    }
     res.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(text4).toString()
     });
-    Readable.fromWeb(upstreamRes.body).on("error", () => res.destroy()).pipe(res);
-    return;
+    res.end(text4);
+    return usage;
   }
-  if (!upstreamRes.body) {
-    res.writeHead(502, { "Content-Type": "application/json" });
-    res.end(
-      JSON.stringify({
-        type: "error",
-        error: { type: "api_error", message: "Upstream returned empty response body" }
-      })
-    );
+}
+function emitAborted(res, clientWantsStream) {
+  if (res.headersSent || res.writableEnded || res.destroyed) {
+    res.destroy();
     return;
   }
-  const text4 = await upstreamRes.text();
-  try {
-    JSON.parse(text4);
-  } catch {
-    res.writeHead(502, { "Content-Type": "application/json" });
+  if (clientWantsStream) {
+    res.writeHead(504, { "Content-Type": "application/json" });
     res.end(
       JSON.stringify({
         type: "error",
-        error: { type: "api_error", message: "Upstream response was not valid JSON" }
+        error: { type: "timeout", message: "Upstream request timed out or was aborted." }
       })
     );
     return;
   }
-  res.writeHead(200, {
-    "Content-Type": "application/json",
-    "Content-Length": Buffer.byteLength(text4).toString()
-  });
-  res.end(text4);
+  res.writeHead(504, { "Content-Type": "application/json" });
+  res.end(
+    JSON.stringify({
+      type: "error",
+      error: { type: "timeout", message: "Upstream request timed out or was aborted." }
+    })
+  );
 }
 
 // src/gateway/antigravity/anthropic-to-cloudcode.ts
@@ -6443,7 +6821,7 @@ async function collectCloudCodeToAnthropic(upstreamRes, model, log6) {
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/gateway/adapters/sdk-adapter.ts
-import { streamText, generateText, tool as tool3, jsonSchema as jsonSchema3, stepCountIs } from "ai";
+import { streamText, tool as tool3, jsonSchema as jsonSchema3, stepCountIs } from "ai";
 
 // src/apps/shared/tool-search.ts
 var TOOL_SEARCH_TYPE_PREFIX = "tool_search_tool";
@@ -6832,15 +7210,21 @@ function annotateToolNames(messages) {
 }
 function thinkingToSdkPart(block, npm) {
   const text4 = block.thinking ?? "";
-  if (npm === "@ai-sdk/openai" && !block.signature && !text4.trim()) return null;
+  if ((npm === "@ai-sdk/openai" || npm === "@ai-sdk/openai-compatible") && !block.signature && !text4.trim())
+    return null;
   const part = { type: "reasoning", text: text4 };
   if (block.signature) {
     if (npm === "@ai-sdk/google") {
       part.providerOptions = { google: { thoughtSignature: block.signature } };
-    } else if (npm === "@ai-sdk/openai" || npm === "@ai-sdk/openai-compatible") {
+    } else if (npm === "@ai-sdk/openai") {
       part.providerOptions = { openai: { reasoningEncryptedContent: block.signature } };
+    } else if (npm === "@ai-sdk/openai-compatible") {
+      part.providerOptions = { openaiCompatible: { reasoningEncryptedContent: block.signature } };
     }
   }
+  if (npm === "@ai-sdk/openai-compatible" && text4) {
+    part.reasoning_content = text4;
+  }
   return part;
 }
 function translateMessages(messages, npm) {
@@ -7103,14 +7487,18 @@ async function writeAnthropicStream(fullStream, modelId, write, log6, hiddenTool
           hiddenIds.add(part.id ?? "");
           break;
         }
+        const toolKey = part.id ?? "";
+        if (idToBlock.has(toolKey)) {
+          break;
+        }
         const sig = grabRoundTripSignature(part);
         openBlock("tool", {
           type: "tool_use",
-          id: encodeToolUseId(part.id ?? "", sig),
+          id: encodeToolUseId(toolKey, sig),
           name: part.toolName,
           input: {}
         });
-        idToBlock.set(part.id ?? "", blockIndex);
+        idToBlock.set(toolKey, blockIndex);
         break;
       }
       case "tool-input-delta":
@@ -7216,29 +7604,32 @@ async function generateAnthropicResponse(model, params, modelId, options) {
   let toolCalls;
   let finishReason;
   let usage;
+  let reasoningText = "";
   const { webSearchToolName, ...callParams } = params;
   const stopWhen = webSearchToolName ? stepCountIs(MAX_WEB_SEARCH_STEPS) : void 0;
-  if (options?.forceStream) {
-    const r = streamText({ model, ...callParams, stopWhen, onError: () => {
-    } });
-    Promise.resolve(r.toolResults).catch(() => {
-    });
-    [text4, toolCalls, finishReason, usage] = await Promise.all([
-      r.text,
-      r.toolCalls,
-      r.finishReason,
-      r.usage
-    ]);
-  } else {
-    const r = await generateText({ model, ...callParams, stopWhen });
-    ({ text: text4, toolCalls, finishReason, usage } = r);
+  const r = streamText({ model, ...callParams, stopWhen, onError: () => {
+  } });
+  Promise.resolve(r.toolResults).catch(() => {
+  });
+  for await (const part of r.fullStream) {
+    if (part.type === "reasoning-delta") {
+      reasoningText += part.text ?? "";
+    }
   }
+  ;
+  [text4, toolCalls, finishReason, usage] = await Promise.all([
+    r.text,
+    r.toolCalls,
+    r.finishReason,
+    r.usage
+  ]);
   return {
     id: "msg_" + Date.now(),
     type: "message",
     role: "assistant",
     model: modelId,
     content: [
+      ...reasoningText ? [{ type: "thinking", thinking: reasoningText, signature: "" }] : [],
       ...text4 ? [{ type: "text", text: text4 }] : [],
       ...toolCalls.filter((tc) => tc.toolName !== webSearchToolName).map((tc) => ({
         type: "tool_use",
@@ -7673,10 +8064,10 @@ function startProxyCatalog(routes, defaultAliasId, debug = false, opts) {
       const originalModel = anthropicBody.model;
       const clientWantsStream = Boolean(anthropicBody.stream);
       const route = resolveRoute(byAlias, originalModel, defaultRoute, plog);
+      let aliasWarning = null;
       if (route === defaultRoute && originalModel !== defaultRoute.aliasId) {
-        quietErrorLog(
-          `POST /v1/messages - model alias '${originalModel}' not found, falling back to default route '${defaultRoute.aliasId}'`
-        );
+        aliasWarning = `model alias '${originalModel}' not found; using '${defaultRoute.aliasId}'`;
+        quietErrorLog(`POST /v1/messages - ${aliasWarning}`);
       }
       const apiKey = route.apiKey;
       const upstreamUrl = route.upstreamUrl;
@@ -7772,8 +8163,12 @@ function startProxyCatalog(routes, defaultAliasId, debug = false, opts) {
             res.writeHead(200, {
               "Content-Type": "text/event-stream",
               "Cache-Control": "no-cache",
-              Connection: "keep-alive"
+              Connection: "keep-alive",
+              ...aliasWarning ? { "anthropic-warning": aliasWarning } : {}
             });
+            if (aliasWarning) res.write(`: ${aliasWarning}
+
+`);
             const usage = await streamAnthropicResponse(
               model,
               params,
@@ -7808,7 +8203,12 @@ function startProxyCatalog(routes, defaultAliasId, debug = false, opts) {
               inputTokens: u?.inputTokens ?? 0,
               outputTokens: u?.outputTokens ?? 0
             });
-            sendJson(res, 200, anthropicResponse);
+            sendJson(
+              res,
+              200,
+              anthropicResponse,
+              aliasWarning ? { "anthropic-warning": aliasWarning } : void 0
+            );
           }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -10913,6 +11313,206 @@ async function streamOpenAiResponse(model, params, responseModelId, onChunk) {
   return usage;
 }
 
+// src/gateway/server/budget.ts
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, openSync as openSync5, readFileSync as readFileSync14, writeSync as writeSync5, closeSync as closeSync5 } from "fs";
+import { dirname as dirname7, join as join14 } from "path";
+var STATE_FILENAME = "budget-state.json";
+function utcDayKey(now = /* @__PURE__ */ new Date()) {
+  return now.toISOString().slice(0, 10);
+}
+function utcMonthKey(now = /* @__PURE__ */ new Date()) {
+  return now.toISOString().slice(0, 7);
+}
+function statePath() {
+  return join14(getAppHome(), STATE_FILENAME);
+}
+function emptyState(now = /* @__PURE__ */ new Date()) {
+  return { day: utcDayKey(now), dayTokens: 0, month: utcMonthKey(now), monthTokens: 0 };
+}
+function readStateFile() {
+  const path = statePath();
+  if (!existsSync15(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync14(path, "utf8"));
+    if (typeof raw.day !== "string" || typeof raw.month !== "string" || typeof raw.dayTokens !== "number" || typeof raw.monthTokens !== "number") {
+      return null;
+    }
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function writeState(state) {
+  const path = statePath();
+  try {
+    mkdirSync9(dirname7(path), { recursive: true, mode: 448 });
+  } catch {
+  }
+  try {
+    const json = `${JSON.stringify(state)}
+`;
+    const fd = openSync5(path, "w", 384);
+    try {
+      writeSync5(fd, json);
+    } finally {
+      closeSync5(fd);
+    }
+  } catch {
+  }
+}
+var BudgetTracker = class {
+  constructor(config, now = /* @__PURE__ */ new Date()) {
+    this.config = config;
+    this.state = this.loadRollover(now);
+  }
+  config;
+  state;
+  loadRollover(now) {
+    const persisted = readStateFile();
+    const day = utcDayKey(now);
+    const month = utcMonthKey(now);
+    if (!persisted) return emptyState(now);
+    return {
+      day,
+      // Day/month rollover: stale periods reset to zero automatically.
+      dayTokens: persisted.day === day ? persisted.dayTokens : 0,
+      month,
+      monthTokens: persisted.month === month ? persisted.monthTokens : 0
+    };
+  }
+  get enabled() {
+    return this.config.enabled === true;
+  }
+  dayExceeded() {
+    const max = this.config.maxTokensPerDay;
+    return typeof max === "number" && max > 0 && this.state.dayTokens >= max;
+  }
+  monthExceeded() {
+    const max = this.config.maxTokensPerMonth;
+    return typeof max === "number" && max > 0 && this.state.monthTokens >= max;
+  }
+  /** Check whether requests may proceed under the configured budgets. */
+  check() {
+    if (!this.enabled) return { allowed: true };
+    const now = /* @__PURE__ */ new Date();
+    if (this.state.day !== utcDayKey(now)) this.state.dayTokens = 0;
+    if (this.state.month !== utcMonthKey(now)) this.state.monthTokens = 0;
+    if (this.dayExceeded()) {
+      return {
+        allowed: false,
+        reason: `Daily token budget exceeded (${this.state.dayTokens}/${this.config.maxTokensPerDay}).`
+      };
+    }
+    if (this.monthExceeded()) {
+      return {
+        allowed: false,
+        reason: `Monthly token budget exceeded (${this.state.monthTokens}/${this.config.maxTokensPerMonth}).`
+      };
+    }
+    return { allowed: true };
+  }
+  /** Record actual usage after a completed response. */
+  add(inputTokens, outputTokens) {
+    const total = Math.max(0, inputTokens) + Math.max(0, outputTokens);
+    if (total === 0) return;
+    const now = /* @__PURE__ */ new Date();
+    if (this.state.day !== utcDayKey(now)) {
+      this.state.day = utcDayKey(now);
+      this.state.dayTokens = 0;
+    }
+    if (this.state.month !== utcMonthKey(now)) {
+      this.state.month = utcMonthKey(now);
+      this.state.monthTokens = 0;
+    }
+    this.state.dayTokens += total;
+    this.state.monthTokens += total;
+    writeState(this.state);
+  }
+  /** Current counters (for dashboards/tests). */
+  snapshot() {
+    return { ...this.state };
+  }
+};
+
+// src/services/provider-health.ts
+var healthMap = /* @__PURE__ */ new Map();
+function updateProviderHealth(status) {
+  healthMap.set(status.providerId, status);
+}
+
+// src/gateway/server/upstream-resilience.ts
+var MAX_UPSTREAM_RETRIES = 2;
+var UNHEALTHY_WINDOW_MS = 6e4;
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function isRetryableUpstreamError(err) {
+  if (!err || typeof err !== "object") return false;
+  const rec = err;
+  for (const candidate of [rec.statusCode, rec.httpStatus]) {
+    if (typeof candidate === "number" && RETRYABLE_STATUS.has(candidate)) return true;
+  }
+  return false;
+}
+function backoffDelayMs(attempt, retryAfterMs) {
+  if (retryAfterMs != null) return retryAfterMs;
+  return 500 * 2 ** attempt;
+}
+async function withUpstreamRetry(fn, onRetry, sleep = defaultSleep) {
+  let lastErr;
+  for (let attempt = 0; attempt <= MAX_UPSTREAM_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (attempt === MAX_UPSTREAM_RETRIES || !isRetryableUpstreamError(err)) throw err;
+      const delay = backoffDelayMs(attempt);
+      await onRetry?.(attempt + 1, delay, err);
+      await sleep(delay);
+    }
+  }
+  throw lastErr;
+}
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var unhealthyUntil = /* @__PURE__ */ new Map();
+function recordProviderFailure(providerId, now = Date.now()) {
+  const existing = failCounts.get(providerId) ?? { count: 0, firstAt: now };
+  const count = now - existing.firstAt > UNHEALTHY_WINDOW_MS ? 1 : existing.count + 1;
+  failCounts.set(providerId, { count, firstAt: count === 1 ? now : existing.firstAt });
+  if (count >= 2) {
+    unhealthyUntil.set(providerId, now + UNHEALTHY_WINDOW_MS);
+    updateProviderHealthSafe(providerId, false, now);
+  }
+}
+function recordProviderSuccess(providerId, now = Date.now()) {
+  failCounts.delete(providerId);
+  unhealthyUntil.delete(providerId);
+  updateProviderHealthSafe(providerId, true, now);
+}
+function isProviderUnavailable(providerId, now = Date.now()) {
+  const until = unhealthyUntil.get(providerId);
+  if (until === void 0) return false;
+  if (now >= until) {
+    unhealthyUntil.delete(providerId);
+    failCounts.delete(providerId);
+    updateProviderHealthSafe(providerId, true, now);
+    return false;
+  }
+  return true;
+}
+var failCounts = /* @__PURE__ */ new Map();
+function updateProviderHealthSafe(providerId, healthy, now) {
+  try {
+    updateProviderHealth({
+      providerId,
+      healthy,
+      lastChecked: now,
+      ...healthy ? {} : { error: "repeated upstream failures" }
+    });
+  } catch {
+  }
+}
+
 // src/gateway/server/router.ts
 function makeServerLog(debugLogPath) {
   if (!debugLogPath) return () => {
@@ -10924,8 +11524,10 @@ async function startServer(options) {
   silenceSdkWarnings();
   const languageModelCache = /* @__PURE__ */ new Map();
   const plog = makeServerLog(options.debugLogPath);
+  const budgetConfig = options.budget ?? getServerBudget();
+  const budget = new BudgetTracker(budgetConfig);
   const server = createServer2((req, res) => {
-    void routeRequest(req, res, options, languageModelCache, plog);
+    void routeRequest(req, res, options, languageModelCache, plog, budget);
   });
   await new Promise((resolve, reject) => {
     server.once("error", reject);
@@ -10948,7 +11550,7 @@ async function startServer(options) {
     })
   };
 }
-async function routeRequest(req, res, options, modelCache, plog) {
+async function routeRequest(req, res, options, modelCache, plog, budget) {
   try {
     const pathname = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`).pathname;
     plog(`${req.method} ${pathname}`);
@@ -10960,7 +11562,7 @@ async function routeRequest(req, res, options, modelCache, plog) {
       sendJson(res, 401, { error: { message: "Unauthorized" } });
       return;
     }
-    const clientId = req.headers["x-api-key"] ?? req.socket.remoteAddress ?? "unknown";
+    const clientId = req.socket.remoteAddress ?? "unknown";
     const rateLimit = checkRateLimit(String(clientId));
     if (!rateLimit.allowed) {
       sendJson(
@@ -10988,11 +11590,11 @@ async function routeRequest(req, res, options, modelCache, plog) {
       return;
     }
     if (req.method === "POST" && pathname === "/anthropic/v1/messages") {
-      await handleAnthropicMessages(req, res, options, modelCache, plog);
+      await handleAnthropicMessages(req, res, options, modelCache, plog, budget);
       return;
     }
     if (req.method === "POST" && pathname === "/openai/v1/chat/completions") {
-      await handleOpenAIChatCompletions(req, res, options, modelCache, plog);
+      await handleOpenAIChatCompletions(req, res, options, modelCache, plog, budget);
       return;
     }
     sendJson(res, 404, { error: { message: "Not found" } });
@@ -11007,12 +11609,19 @@ async function routeRequest(req, res, options, modelCache, plog) {
     }
   }
 }
-async function handleAnthropicMessages(req, res, options, modelCache, plog) {
+async function handleAnthropicMessages(req, res, options, modelCache, plog, budget) {
   const body = await readJson(req);
   if (!body) {
     sendJson(res, 400, { error: { message: "Invalid JSON body" } });
     return;
   }
+  const budgetCheck = budget.check();
+  if (!budgetCheck.allowed) {
+    sendJson(res, 429, {
+      error: { type: "budget_exceeded", message: budgetCheck.reason ?? "Token budget exceeded" }
+    });
+    return;
+  }
   const model = lookupModel(res, options.catalog, body.model, plog);
   if (!model) {
     plog(`model not found: ${body.model}`);
@@ -11048,7 +11657,7 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
     plog(
       () => `anthropic-passthrough \u2192 ${messagesUrl} oauth=${isOAuth} stream=${clientWantsStream}`
     );
-    await forwardAnthropicMessages(
+    const usage = await forwardAnthropicMessages(
       res,
       messagesUrl,
       forwardBody,
@@ -11064,6 +11673,16 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
         model.apiKey = refreshed;
       }
     );
+    recordUsage({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      modelId: getResponseModelId(body.model, model, options),
+      npm: void 0,
+      providerId: model.providerId,
+      app: options.app ?? "gateway",
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens
+    });
+    budget.add(usage.inputTokens, usage.outputTokens);
     return;
   }
   if (model.modelFormat === "openai") {
@@ -11083,8 +11702,10 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
     );
     const npmMaxTools = maxToolsForNpm(model.npm);
     const toolCount = Array.isArray(body.tools) ? body.tools.length : 0;
+    let toolTruncationWarning = null;
     if (npmMaxTools !== void 0 && toolCount > npmMaxTools) {
-      plog(`tools truncated: ${toolCount} \u2192 ${npmMaxTools} (provider limit)`);
+      toolTruncationWarning = `tools truncated: ${toolCount} \u2192 ${npmMaxTools} (provider limit)`;
+      plog(toolTruncationWarning);
     }
     const params = translateRequest2(body, model.npm, {
       defaultEffort: anthropicEffortFromRequest(body) ? void 0 : model.defaultEffort,
@@ -11105,13 +11726,25 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
     plog(
       () => `sdk npm=${model.npm} upstream=${upstreamModelId(model)} responseModel=${responseModelId} stream=${clientWantsStream}`
     );
+    if (!clientWantsStream && model.providerId && isProviderUnavailable(model.providerId)) {
+      sendJson(res, 502, {
+        error: {
+          message: `Provider ${model.providerId} temporarily unavailable (recent failures) \u2014 retry shortly.`
+        }
+      });
+      return;
+    }
     try {
       if (clientWantsStream) {
         res.writeHead(200, {
           "Content-Type": "text/event-stream",
           "Cache-Control": "no-cache",
-          Connection: "keep-alive"
+          Connection: "keep-alive",
+          ...toolTruncationWarning ? { "anthropic-warning": toolTruncationWarning } : {}
         });
+        if (toolTruncationWarning) res.write(`: ${toolTruncationWarning}
+
+`);
         const usage = await streamAnthropicResponse(
           languageModel,
           params,
@@ -11127,32 +11760,46 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
           inputTokens: usage.inputTokens,
           outputTokens: usage.outputTokens
         });
+        budget.add(usage.inputTokens, usage.outputTokens);
         res.end();
       } else {
-        const anthropicResponse = await generateAnthropicResponse(
-          languageModel,
-          params,
-          responseModelId
+        const anthropicResponse = await withUpstreamRetry(
+          () => generateAnthropicResponse(languageModel, params, responseModelId)
         );
+        recordProviderSuccess(model.providerId ?? upstreamModelId(model));
+        const genUsage = anthropicResponse._usage ?? {
+          inputTokens: 0,
+          outputTokens: 0
+        };
         recordUsage({
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           modelId: responseModelId,
           npm: model.npm,
           providerId: model.providerId,
           app: options.app ?? "gateway",
-          inputTokens: anthropicResponse._usage?.inputTokens ?? 0,
-          outputTokens: anthropicResponse._usage?.outputTokens ?? 0
+          inputTokens: genUsage.inputTokens ?? 0,
+          outputTokens: genUsage.outputTokens ?? 0
         });
-        sendJson(res, 200, anthropicResponse);
+        budget.add(genUsage.inputTokens ?? 0, genUsage.outputTokens ?? 0);
+        sendJson(
+          res,
+          200,
+          anthropicResponse,
+          toolTruncationWarning ? { "anthropic-warning": toolTruncationWarning } : void 0
+        );
       }
     } catch (err) {
       const message = formatUpstreamError(err);
       plog(`sdk error npm=${model.npm} upstream=${upstreamModelId(model)}: ${message}`);
+      const status = upstreamHttpStatus(err);
+      if ((status === 429 || status >= 500) && model.providerId) {
+        recordProviderFailure(model.providerId);
+        plog(`provider ${model.providerId} failure recorded (status ${status})`);
+      }
       if (!res.headersSent) {
-        const status = upstreamHttpStatus(err);
         sendJson(res, status === 500 ? 502 : status, { error: { message } });
       } else {
-        const errorType = anthropicErrorType(upstreamHttpStatus(err));
+        const errorType = anthropicErrorType(status);
         res.write(
           `event: error
 data: ${JSON.stringify({ type: "error", error: { type: errorType, message } })}
@@ -11166,12 +11813,19 @@ data: ${JSON.stringify({ type: "error", error: { type: errorType, message } })}
   }
   sendJson(res, 400, { error: { message: `Unsupported model format: ${model.modelFormat}` } });
 }
-async function handleOpenAIChatCompletions(req, res, options, modelCache, plog) {
+async function handleOpenAIChatCompletions(req, res, options, modelCache, plog, budget) {
   const body = await readJson(req);
   if (!body) {
     sendJson(res, 400, { error: { message: "Invalid JSON body" } });
     return;
   }
+  const budgetCheck = budget.check();
+  if (!budgetCheck.allowed) {
+    sendJson(res, 429, {
+      error: { type: "budget_exceeded", message: budgetCheck.reason ?? "Token budget exceeded" }
+    });
+    return;
+  }
   const model = lookupModel(res, options.catalog, body.model, plog);
   if (!model) return;
   if (supportsDirectOpenAIChatCompletions(model)) {
@@ -11207,6 +11861,14 @@ async function handleOpenAIChatCompletions(req, res, options, modelCache, plog)
   plog(
     () => `sdk-openai npm=${npm} upstream=${upstreamModelId(model)} responseModel=${responseModelId} stream=${clientWantsStream}`
   );
+  if (!clientWantsStream && model.providerId && isProviderUnavailable(model.providerId)) {
+    sendJson(res, 502, {
+      error: {
+        message: `Provider ${model.providerId} temporarily unavailable (recent failures) \u2014 retry shortly.`
+      }
+    });
+    return;
+  }
   try {
     if (clientWantsStream) {
       res.writeHead(200, {
@@ -11229,13 +11891,13 @@ async function handleOpenAIChatCompletions(req, res, options, modelCache, plog)
         inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens
       });
+      budget.add(usage.inputTokens, usage.outputTokens);
       res.end();
     } else {
-      const { response, usage } = await generateOpenAiResponse(
-        languageModel,
-        params,
-        responseModelId
+      const { response, usage } = await withUpstreamRetry(
+        () => generateOpenAiResponse(languageModel, params, responseModelId)
       );
+      recordProviderSuccess(model.providerId ?? upstreamModelId(model));
       recordUsage({
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         modelId: responseModelId,
@@ -11245,16 +11907,21 @@ async function handleOpenAIChatCompletions(req, res, options, modelCache, plog)
         inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens
       });
+      budget.add(usage.inputTokens, usage.outputTokens);
       sendJson(res, 200, response);
     }
   } catch (err) {
     const message = formatUpstreamError(err);
-    plog(`sdk error npm=${model.npm} upstream=${upstreamModelId(model)}: ${message}`);
+    plog(`sdk error npm=${npm} upstream=${upstreamModelId(model)}: ${message}`);
+    const status = upstreamHttpStatus(err);
+    if ((status === 429 || status >= 500) && model.providerId) {
+      recordProviderFailure(model.providerId);
+      plog(`provider ${model.providerId} failure recorded (status ${status})`);
+    }
     if (!res.headersSent) {
-      const status = upstreamHttpStatus(err);
       sendJson(res, status === 500 ? 502 : status, { error: { message } });
     } else {
-      const errorType = anthropicErrorType(upstreamHttpStatus(err));
+      const errorType = anthropicErrorType(status);
       res.write(
         `event: error
 data: ${JSON.stringify({ type: "error", error: { type: errorType, message } })}
@@ -11375,7 +12042,7 @@ function summarizeServerProviders(models) {
 }
 
 // src/apps/claude/desktop-launch.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 var CLAUDE_BUNDLE_ID = "com.anthropic.claudefordesktop";
 var ClaudeAppLauncher = class extends AppLauncher {
   appName = "Claude Desktop";
@@ -11390,7 +12057,7 @@ var ClaudeAppLauncher = class extends AppLauncher {
     try {
       const out = this.run(`mdfind "kMDItemCFBundleIdentifier == '${CLAUDE_BUNDLE_ID}'"`);
       const first = out.split("\n").map((l) => l.trim()).find(Boolean);
-      return first && existsSync15(first) ? first : null;
+      return first && existsSync16(first) ? first : null;
     } catch {
       return null;
     }
@@ -12098,9 +12765,12 @@ function favoriteProviderDisplayName(provider) {
 }
 
 export {
+  ISSUER,
   requestOpenAiDeviceCode,
   openAiDeviceCodeUrl,
   pollOpenAiDeviceCodeToken,
+  buildOpenAiBrowserAuthUrl,
+  exchangeOpenAiBrowserToken,
   buildClaudeCodeBillingSystemLine,
   selectBetaFlags,
   injectClaudeIdentity,
@@ -12163,6 +12833,7 @@ export {
   freeStatusLabel,
   refreshModelsDevCacheAsync,
   resolveInputTypes,
+  resolveReasoning,
   loadPreferences,
   savePreferences,
   loadLaunchPresets,
@@ -12194,6 +12865,7 @@ export {
   requestXaiDeviceCode,
   pollXaiDeviceCodeToken,
   guiCallbackRedirectUri,
+  startCallbackServer,
   ANTIGRAVITY_BASE_URLS,
   buildAntigravityAuthUrl,
   completeAntigravityExchange,
@@ -12315,4 +12987,4 @@ export {
   runServerCommand,
   favoriteProviderDisplayName
 };
-//# sourceMappingURL=chunk-EMBABL33.js.map
+//# sourceMappingURL=chunk-NU4KMZIM.js.map