ampcode-connector 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ampcode-connector",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Proxy AmpCode through local OAuth subscriptions (Claude Code, Codex, Gemini CLI, Antigravity)",
   "license": "MIT",
   "repository": {
@@ -40,16 +40,16 @@
     "format": "biome check --write src/ tests/"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.0",
+    "@biomejs/biome": "^2.4.2",
+    "@google/genai": "^1.42.0",
     "@types/bun": "^1.3.9"
   },
   "peerDependencies": {
-    "typescript": "^5"
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@google/genai": "^1.41.0",
-    "@kreuzberg/html-to-markdown": "^2.25.0",
-    "ampcode-connector": "^0.1.5",
+    "@kreuzberg/html-to-markdown": "^2.25.1",
+    "ampcode-connector": "^0.1.8",
     "exa-js": "^2.4.0"
   }
 }

package/src/cli/setup.ts

@@ -131,6 +131,7 @@ export async function setup(): Promise<void> {
 
   for (const p of providers) {
     const connected = p.accounts.filter((a) => a.status === "connected");
+    const disabled = p.accounts.filter((a) => a.status === "disabled");
     const total = p.accounts.filter((a) => a.status !== "disconnected");
 
     if (connected.length > 0) {
@@ -140,7 +141,10 @@ export async function setup(): Promise<void> {
         .filter(Boolean)
         .join(", ");
       const info = emails ? `  ${s.dim}${emails}${s.reset}` : "";
-      line(`  ${p.label.padEnd(16)} ${s.green}${connected.length} account(s)${s.reset}${info}`);
+      const disabledInfo = disabled.length > 0 ? `  ${s.red}${disabled.length} disabled${s.reset}` : "";
+      line(`  ${p.label.padEnd(16)} ${s.green}${connected.length} account(s)${s.reset}${info}${disabledInfo}`);
+    } else if (disabled.length > 0) {
+      line(`  ${p.label.padEnd(16)} ${s.red}${disabled.length} disabled${s.reset}`);
     } else if (total.length > 0) {
       line(`  ${p.label.padEnd(16)} ${s.yellow}${total.length} expired${s.reset}`);
     } else {

package/src/cli/status.ts

@@ -1,7 +1,8 @@
 import type { Credentials, ProviderName } from "../auth/store.ts";
 import * as store from "../auth/store.ts";
+import { cooldown, type QuotaPool } from "../routing/cooldown.ts";
 
-export type ConnectionStatus = "connected" | "expired" | "disconnected";
+export type ConnectionStatus = "connected" | "expired" | "disabled" | "disconnected";
 
 export interface AccountStatus {
   account: number;
@@ -23,8 +24,16 @@ const PROVIDERS: { name: ProviderName; label: string; sublabel?: string }[] = [
   { name: "google", label: "Google", sublabel: "Gemini CLI + Antigravity" },
 ];
 
-function connectionOf(creds: Credentials): ConnectionStatus {
+const POOL_MAP: Record<ProviderName, QuotaPool[]> = {
+  anthropic: ["anthropic"],
+  codex: ["codex"],
+  google: ["gemini", "antigravity"],
+};
+
+function connectionOf(name: ProviderName, account: number, creds: Credentials): ConnectionStatus {
   if (!creds.refreshToken) return "disconnected";
+  const pools = POOL_MAP[name];
+  if (pools.some((p) => cooldown.isExhausted(p, account))) return "disabled";
   return store.fresh(creds) ? "connected" : "expired";
 }
 
@@ -35,7 +44,7 @@ export function all(): ProviderStatus[] {
     sublabel,
     accounts: store.getAll(name).map((e) => ({
       account: e.account,
-      status: connectionOf(e.credentials),
+      status: connectionOf(name, e.account, e.credentials),
       email: e.credentials.email,
       expiresAt: e.credentials.expiresAt,
     })),

package/src/cli/tui.ts

@@ -16,6 +16,7 @@ const oauthConfigs: Record<ProviderName, OAuthConfig> = {
 const ICON: Record<ConnectionStatus, string> = {
   connected: `${s.green}●${s.reset}`,
   expired: `${s.yellow}●${s.reset}`,
+  disabled: `${s.red}●${s.reset}`,
   disconnected: `${s.dim}○${s.reset}`,
 };
 
@@ -109,7 +110,9 @@ function formatInfo(a: AccountStatus): string {
   if (a.status === "disconnected") return `${s.dim}—${s.reset}`;
 
   const parts: string[] = [];
-  parts.push(a.status === "connected" ? `${s.green}connected${s.reset}` : `${s.yellow}expired${s.reset}`);
+  if (a.status === "connected") parts.push(`${s.green}connected${s.reset}`);
+  else if (a.status === "disabled") parts.push(`${s.red}disabled${s.reset}`);
+  else parts.push(`${s.yellow}expired${s.reset}`);
   if (a.expiresAt && a.status === "connected") parts.push(`${s.dim}${status.remaining(a.expiresAt)}${s.reset}`);
   if (a.email) parts.push(`${s.dim}${a.email}${s.reset}`);
   return parts.join(`${s.dim} · ${s.reset}`);

package/src/providers/anthropic.ts

@@ -32,6 +32,7 @@ export const provider: Provider = {
       streaming: body.stream,
       providerName: "Anthropic",
       rewrite,
+      email: store.get("anthropic", account)?.email,
       headers: {
         ...stainlessHeaders,
         Accept: body.stream ? "text/event-stream" : "application/json",

package/src/providers/antigravity.ts

@@ -52,7 +52,7 @@ export const provider: Provider = {
 
     const gemini = path.gemini(sub);
     const action = gemini?.action ?? "generateContent";
-    const model = gemini?.model ?? "";
+    const model = gemini?.model === "gemini-3-flash-preview" ? "gemini-3-flash" : (gemini?.model ?? "");
     const requestBody = maybeWrap(body.parsed, body.forwardBody, projectId, model, {
       userAgent: "antigravity",
       requestIdPrefix: "agent",
@@ -60,7 +60,7 @@ export const provider: Provider = {
     });
     const unwrapThenRewrite = withUnwrap(rewrite);
 
-    return tryEndpoints(requestBody, body.stream, headers, action, unwrapThenRewrite);
+    return tryEndpoints(requestBody, body.stream, headers, action, unwrapThenRewrite, creds?.email);
   },
 };
 
@@ -70,13 +70,14 @@ async function tryEndpoints(
   headers: Record<string, string>,
   action: string,
   rewrite?: (data: string) => string,
+  email?: string,
 ): Promise<Response> {
   let lastError: Error | null = null;
 
   for (const endpoint of endpoints) {
     const url = buildUrl(endpoint, action);
     try {
-      const response = await forward({ url, body, streaming, headers, providerName: "Antigravity", rewrite });
+      const response = await forward({ url, body, streaming, headers, providerName: "Antigravity", rewrite, email });
       if (response.status < 500) return response;
       lastError = new Error(`${endpoint} returned ${response.status}`);
       logger.debug("Endpoint 5xx, trying next", { provider: "Antigravity" });

package/src/providers/base.ts

@@ -26,32 +26,63 @@ interface ForwardOptions {
   headers: Record<string, string>;
   providerName: string;
   rewrite?: (data: string) => string;
+  email?: string;
 }
 
+const RETRYABLE_STATUS = new Set([408, 500, 502, 503, 504]);
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 500;
+
 export async function forward(opts: ForwardOptions): Promise<Response> {
-  const response = await fetch(opts.url, {
-    method: "POST",
-    headers: opts.headers,
-    body: opts.body,
-  });
-
-  const contentType = response.headers.get("Content-Type") ?? "application/json";
-
-  if (!response.ok) {
-    const text = await response.text();
-    logger.error(`${opts.providerName} API error (${response.status})`, { error: text.slice(0, 200) });
-    return new Response(text, { status: response.status, headers: { "Content-Type": contentType } });
-  }
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    let response: Response;
+    try {
+      response = await fetch(opts.url, {
+        method: "POST",
+        headers: opts.headers,
+        body: opts.body,
+      });
+    } catch (err) {
+      if (attempt < MAX_RETRIES) {
+        logger.debug(`${opts.providerName} fetch error, retry ${attempt + 1}/${MAX_RETRIES}`, {
+          error: String(err),
+        });
+        await Bun.sleep(RETRY_DELAY_MS * (attempt + 1));
+        continue;
+      }
+      throw err;
+    }
+
+    // Retry on server errors (429 handled at routing layer)
+    if (RETRYABLE_STATUS.has(response.status) && attempt < MAX_RETRIES) {
+      await response.text(); // consume body
+      logger.debug(`${opts.providerName} returned ${response.status}, retry ${attempt + 1}/${MAX_RETRIES}`);
+      await Bun.sleep(RETRY_DELAY_MS * (attempt + 1));
+      continue;
+    }
+
+    const contentType = response.headers.get("Content-Type") ?? "application/json";
+
+    if (!response.ok) {
+      const text = await response.text();
+      const ctx = opts.email ? ` account=${opts.email}` : "";
+      logger.error(`${opts.providerName} API error (${response.status})${ctx}`, { error: text.slice(0, 200) });
+      return new Response(text, { status: response.status, headers: { "Content-Type": contentType } });
+    }
+
+    const isSSE = contentType.includes("text/event-stream") || opts.streaming;
+    if (isSSE) return sse.proxy(response, opts.rewrite);
 
-  const isSSE = contentType.includes("text/event-stream") || opts.streaming;
-  if (isSSE) return sse.proxy(response, opts.rewrite);
+    if (opts.rewrite) {
+      const text = await response.text();
+      return new Response(opts.rewrite(text), { status: response.status, headers: { "Content-Type": contentType } });
+    }
 
-  if (opts.rewrite) {
-    const text = await response.text();
-    return new Response(opts.rewrite(text), { status: response.status, headers: { "Content-Type": contentType } });
+    return new Response(response.body, { status: response.status, headers: { "Content-Type": contentType } });
   }
 
-  return new Response(response.body, { status: response.status, headers: { "Content-Type": contentType } });
+  // Unreachable, but TypeScript needs it
+  throw new Error(`${opts.providerName}: all retries exhausted`);
 }
 
 export function denied(providerName: string): Response {

package/src/providers/codex.ts

@@ -24,13 +24,14 @@ export const provider: Provider = {
 
   accountCount: () => oauth.accountCount(config),
 
-  async forward(sub, body, _originalHeaders, rewrite, account = 0) {
+  async forward(sub, body, originalHeaders, rewrite, account = 0) {
     const accessToken = await oauth.token(config, account);
     if (!accessToken) return denied("OpenAI Codex");
 
     const accountId = getAccountId(accessToken, account);
     const codexPath = codexPathMap[sub] ?? sub;
-    const { body: codexBody, needsResponseTransform } = transformForCodex(body.forwardBody);
+    const promptCacheKey = originalHeaders.get("x-amp-thread-id") ?? undefined;
+    const { body: codexBody, needsResponseTransform } = transformForCodex(body.forwardBody, promptCacheKey);
     const ampModel = body.ampModel ?? "gpt-5.2";
 
     const response = await forward({
@@ -40,6 +41,7 @@ export const provider: Provider = {
       providerName: "OpenAI Codex",
       // Skip generic rewrite when we need full response transform
       rewrite: needsResponseTransform ? undefined : rewrite,
+      email: store.get("codex", account)?.email,
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${accessToken}`,
@@ -50,6 +52,9 @@ export const provider: Provider = {
         "User-Agent": codexHeaderValues.USER_AGENT,
         Version: codexHeaderValues.VERSION,
         ...(accountId ? { [codexHeaders.ACCOUNT_ID]: accountId } : {}),
+        ...(promptCacheKey
+          ? { [codexHeaders.SESSION_ID]: promptCacheKey, [codexHeaders.CONVERSATION_ID]: promptCacheKey }
+          : {}),
       },
     });
 
@@ -79,7 +84,20 @@ interface ToolCallItem {
   function: { name: string; arguments: string };
 }
 
-function transformForCodex(rawBody: string): { body: string; needsResponseTransform: boolean } {
+function clampReasoningEffort(model: string, effort: string): string {
+  const modelId = model.includes("/") ? model.split("/").pop()! : model;
+  if (modelId === "gpt-5.1" && effort === "xhigh") return "high";
+  if ((modelId.startsWith("gpt-5.2") || modelId.startsWith("gpt-5.3")) && effort === "minimal") return "low";
+  if (modelId === "gpt-5.1-codex-mini") {
+    return effort === "high" || effort === "xhigh" ? "high" : "medium";
+  }
+  return effort;
+}
+
+function transformForCodex(
+  rawBody: string,
+  promptCacheKey?: string,
+): { body: string; needsResponseTransform: boolean } {
   if (!rawBody) return { body: rawBody, needsResponseTransform: false };
 
   let parsed: Record<string, unknown>;
@@ -111,11 +129,28 @@ function transformForCodex(rawBody: string): { body: string; needsResponseTransf
   // Strip id fields from input items
   if (Array.isArray(parsed.input)) {
     stripInputIds(parsed.input as Record<string, unknown>[]);
+    fixOrphanOutputs(parsed.input as Record<string, unknown>[]);
+  }
+
+  // Reasoning config — defaults match reference behavior
+  const model = (parsed.model as string) ?? "";
+  parsed.reasoning = {
+    effort: clampReasoningEffort(model, "high"),
+    summary: "auto",
+  };
+
+  parsed.text = { verbosity: "medium" };
+
+  parsed.include = ["reasoning.encrypted_content"];
+
+  if (promptCacheKey) {
+    parsed.prompt_cache_key = promptCacheKey;
   }
 
   // Remove fields the Codex backend doesn't accept
   delete parsed.max_tokens;
   delete parsed.max_completion_tokens;
+  delete parsed.max_output_tokens;
   // Chat Completions fields not in Responses API
   delete parsed.frequency_penalty;
   delete parsed.logprobs;
@@ -127,6 +162,21 @@ function transformForCodex(rawBody: string): { body: string; needsResponseTransf
   delete parsed.logit_bias;
   delete parsed.response_format;
 
+  // Normalize tool_choice for Responses API
+  if (parsed.tool_choice !== undefined && parsed.tool_choice !== null) {
+    if (typeof parsed.tool_choice === "string") {
+      // "auto", "none", "required" pass through as-is
+    } else if (typeof parsed.tool_choice === "object") {
+      const tc = parsed.tool_choice as Record<string, unknown>;
+      if (tc.type === "function" && tc.function) {
+        const fn = tc.function as Record<string, unknown>;
+        parsed.tool_choice = { type: "function", name: fn.name };
+      } else if (tc.type === "tool" && tc.name) {
+        parsed.tool_choice = { type: "function", name: tc.name };
+      }
+    }
+  }
+
   return { body: JSON.stringify(parsed), needsResponseTransform };
 }
 
@@ -251,6 +301,40 @@ function stripInputIds(items: Record<string, unknown>[]): void {
   }
 }
 
+/** Convert orphan function_call_output items (no matching function_call) to assistant messages. */
+function fixOrphanOutputs(items: Record<string, unknown>[]): void {
+  const callIds = new Set(
+    items.filter((i) => i.type === "function_call" && typeof i.call_id === "string").map((i) => i.call_id as string),
+  );
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i]!;
+    if (item.type === "function_call_output" && typeof item.call_id === "string" && !callIds.has(item.call_id)) {
+      const toolName = typeof item.name === "string" ? (item.name as string) : "tool";
+      let text = "";
+      try {
+        text = typeof item.output === "string" ? (item.output as string) : JSON.stringify(item.output);
+      } catch {
+        text = String(item.output ?? "");
+      }
+      if (text.length > 16000) {
+        text = `${text.slice(0, 16000)}\n...[truncated]`;
+      }
+      items[i] = {
+        type: "message",
+        role: "assistant",
+        content: [
+          {
+            type: "output_text",
+            text: `[Previous ${toolName} result; call_id=${item.call_id}]: ${text}`,
+            annotations: [],
+          },
+        ],
+        status: "completed",
+      };
+    }
+  }
+}
+
 /** Extract chatgpt_account_id from JWT, falling back to stored credentials. */
 function getAccountId(accessToken: string, account: number): string | undefined {
   const creds = store.get("codex", account);

package/src/providers/gemini.ts

@@ -67,6 +67,7 @@ export const provider: Provider = {
       headers,
       providerName: "Gemini CLI",
       rewrite: unwrapThenRewrite,
+      email: store.get("google", account)?.email,
     });
   },
 };

package/src/routing/cooldown.ts

@@ -12,6 +12,8 @@ interface CooldownEntry {
 }
 
 /** When detected as exhausted, cooldown for this long. */
+/** 403 = account disabled/revoked — long cooldown. */
+const FORBIDDEN_COOLDOWN_MS = 24 * 3600_000;
 const EXHAUSTED_COOLDOWN_MS = 2 * 3600_000;
 /** Retry-After threshold (seconds) above which we consider quota exhausted. */
 const EXHAUSTED_THRESHOLD_S = 300;
@@ -65,6 +67,13 @@ export class CooldownTracker {
     this.entries.set(k, entry);
   }
 
+  /** 403 = account forbidden/revoked. Immediately disable for 24h. */
+  record403(pool: QuotaPool, account: number): void {
+    const k = this.key(pool, account);
+    this.entries.set(k, { until: Date.now() + FORBIDDEN_COOLDOWN_MS, exhausted: true, consecutive429: 0 });
+    logger.warn(`Account disabled (403): ${k}`, { cooldownHours: FORBIDDEN_COOLDOWN_MS / 3600_000 });
+  }
+
   recordSuccess(pool: QuotaPool, account: number): void {
     this.entries.delete(this.key(pool, account));
   }

package/src/server/server.ts

@@ -5,6 +5,7 @@ import type { ProxyConfig } from "../config/config.ts";
 import * as rewriter from "../proxy/rewriter.ts";
 import * as upstream from "../proxy/upstream.ts";
 import { affinity } from "../routing/affinity.ts";
+import { cooldown } from "../routing/cooldown.ts";
 import { tryReroute, tryWithCachePreserve } from "../routing/retry.ts";
 import { recordSuccess, routeRequest } from "../routing/router.ts";
 import { handleInternal, isLocalMethod } from "../tools/internal.ts";
@@ -17,6 +18,7 @@ export function startServer(config: ProxyConfig): ReturnType<typeof Bun.serve> {
   const server = Bun.serve({
     port: config.port,
     hostname: "localhost",
+    idleTimeout: 255, // seconds — LLM streaming responses can take minutes
 
     async fetch(req) {
       const startTime = Date.now();
@@ -30,7 +32,7 @@ export function startServer(config: ProxyConfig): ReturnType<typeof Bun.serve> {
         logger.error("Unhandled server error", { error: String(err) });
         return Response.json({ error: "Internal proxy error" }, { status });
       } finally {
-        logger.info(`${req.method} ${url.pathname} ${status}`, { duration: Date.now() - startTime });
+        logger.info(`${req.method} ${url.pathname}${url.search} ${status}`, { duration: Date.now() - startTime });
       }
     },
   });
@@ -119,6 +121,10 @@ async function handleProvider(
         );
         response = rerouted ?? (await fallbackUpstream(req, body, config));
       }
+    } else if (handlerResponse.status === 403 && route.pool) {
+      cooldown.record403(route.pool, route.account);
+      if (threadId) affinity.clear(threadId, providerName);
+      response = await fallbackUpstream(req, body, config);
     } else if (handlerResponse.status === 401) {
       logger.debug("Local provider denied, falling back to upstream");
       response = await fallbackUpstream(req, body, config);