ampcode-connector 0.1.15 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ampcode-connector",
-  "version": "0.1.15",
+  "version": "0.1.18",
   "description": "Proxy AmpCode through local OAuth subscriptions (Claude Code, Codex, Gemini CLI, Antigravity)",
   "license": "MIT",
   "repository": {
@@ -49,6 +49,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "0.74.0",
     "exa-js": "^2.4.0",
     "turndown": "^7.2.2",
     "turndown-plugin-gfm": "^1.0.2"

package/src/auth/configs.ts

@@ -9,7 +9,7 @@ export const anthropic: OAuthConfig = {
   tokenUrl: ANTHROPIC_TOKEN_URL,
   callbackPort: 54545,
   callbackPath: "/callback",
-  scopes: "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers",
+  scopes: "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload",
   bodyFormat: "json",
   expiryBuffer: true,
   sendStateInExchange: true,

package/src/constants.ts

@@ -38,13 +38,13 @@ export const OPENAI_TOKEN_URL = "https://auth.openai.com/oauth/token";
 export const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
 
 export const TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1000;
-export const CLAUDE_CODE_VERSION = "2.1.39";
+export const CLAUDE_CODE_VERSION = "2.1.77";
 
 export const stainlessHeaders: Readonly<Record<string, string>> = {
   "X-Stainless-Helper-Method": "stream",
   "X-Stainless-Retry-Count": "0",
-  "X-Stainless-Runtime-Version": "v24.13.1",
-  "X-Stainless-Package-Version": "0.73.0",
+  "X-Stainless-Runtime-Version": "v24.3.0",
+  "X-Stainless-Package-Version": "0.74.0",
   "X-Stainless-Runtime": "node",
   "X-Stainless-Lang": "js",
   "X-Stainless-Arch": process.arch,
@@ -56,10 +56,14 @@ export const claudeCodeBetas = [
   "claude-code-20250219",
   "oauth-2025-04-20",
   "interleaved-thinking-2025-05-14",
+  "redact-thinking-2026-02-12",
+  "context-management-2025-06-27",
   "prompt-caching-scope-2026-01-05",
+  "advanced-tool-use-2025-11-20",
+  "effort-2025-11-24",
 ] as const;
 
-export const filteredBetaFeatures = ["context-1m-2025-08-07"] as const;
+export const filteredBetaFeatures = ["fast-mode-2026-02-01"] as const;
 
 export const modelFieldPaths = [
   "model",

package/src/providers/anthropic.ts

@@ -1,18 +1,29 @@
 /** Forwards requests to api.anthropic.com with Claude Code stealth headers. */
 
+import { createHash } from "node:crypto";
 import { anthropic as config } from "../auth/configs.ts";
 import * as oauth from "../auth/oauth.ts";
 import * as store from "../auth/store.ts";
-import {
-  ANTHROPIC_API_URL,
-  CLAUDE_CODE_VERSION,
-  claudeCodeBetas,
-  filteredBetaFeatures,
-  stainlessHeaders,
-} from "../constants.ts";
+import { ANTHROPIC_API_URL, CLAUDE_CODE_VERSION, claudeCodeBetas, filteredBetaFeatures } from "../constants.ts";
+import type { ParsedBody } from "../server/body.ts";
 import type { Provider } from "./base.ts";
 import { denied, forward } from "./forward.ts";
 
+/** Headers to drop from client request (replaced by connector or irrelevant). */
+const DROP_HEADERS = new Set(["host", "content-length", "connection", "x-api-key", "authorization", "anthropic-beta"]);
+
+/** Extract X-Stainless-* and other passthrough headers from the client request. */
+function passthroughHeaders(originalHeaders: Headers): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [k, v] of originalHeaders.entries()) {
+    if (DROP_HEADERS.has(k)) continue;
+    // Drop amp-specific headers
+    if (k.startsWith("x-amp-")) continue;
+    out[k] = v;
+  }
+  return out;
+}
+
 export const provider: Provider = {
   name: "Anthropic",
   routeDecision: "LOCAL_CLAUDE",
@@ -26,22 +37,23 @@ export const provider: Provider = {
     const accessToken = await oauth.token(config, account);
     if (!accessToken) return denied("Anthropic");
 
+    const fwdBody = prepareBody(body);
+    const betaHdr = betaHeader(originalHeaders.get("anthropic-beta"));
+    const clientHeaders = passthroughHeaders(originalHeaders);
+
     return forward({
       url: `${ANTHROPIC_API_URL}${sub}`,
-      body: body.forwardBody,
+      body: fwdBody,
       streaming: body.stream,
       providerName: "Anthropic",
       rewrite,
       email: store.get("anthropic", account)?.email,
       headers: {
-        ...stainlessHeaders,
-        Accept: body.stream ? "text/event-stream" : "application/json",
-        "Accept-Encoding": "br, gzip, deflate",
-        Connection: "keep-alive",
-        "Content-Type": "application/json",
-        "Anthropic-Version": "2023-06-01",
+        // Client headers first (stainless, accept, content-type, anthropic-version, etc.)
+        ...clientHeaders,
+        // Override auth + identity
         "Anthropic-Dangerous-Direct-Browser-Access": "true",
-        "Anthropic-Beta": betaHeader(originalHeaders.get("anthropic-beta")),
+        "Anthropic-Beta": betaHdr,
         "User-Agent": `claude-cli/${CLAUDE_CODE_VERSION} (external, cli)`,
         "X-App": "cli",
         Authorization: `Bearer ${accessToken}`,
@@ -50,6 +62,69 @@ export const provider: Provider = {
   },
 };
 
+const BILLING_SALT = "59cf53e54c78";
+
+/** Compute the cch checksum from the first user message text and version. */
+function computeCch(firstUserText: string, version: string): string {
+  const chars = [4, 7, 20].map((i) => firstUserText[i] || "0").join("");
+  return createHash("sha256").update(`${BILLING_SALT}${chars}${version}`).digest("hex").slice(0, 5);
+}
+
+/** Extract text from the first user message in the body. */
+function firstUserText(parsed: Record<string, unknown>): string {
+  const messages = parsed.messages as Array<{ role?: string; content?: unknown }> | undefined;
+  if (!Array.isArray(messages)) return "";
+  const userMsg = messages.find((m) => m.role === "user");
+  if (!userMsg) return "";
+  if (typeof userMsg.content === "string") return userMsg.content;
+  if (Array.isArray(userMsg.content)) {
+    const textBlock = userMsg.content.find((b: { type?: string }) => b.type === "text") as
+      | { text?: string }
+      | undefined;
+    return textBlock?.text ?? "";
+  }
+  return "";
+}
+
+/** Prepare body: inject billing header + strip speed field.
+ *  Always re-injects billing header because cch depends on per-request message content.
+ *  Shallow-copies parsed to avoid mutating the shared ParsedBody.parsed reference. */
+function prepareBody(body: ParsedBody): string {
+  const raw = body.forwardBody;
+
+  try {
+    const original = body.parsed;
+    if (!original) return raw;
+
+    const text = firstUserText(original);
+    const cch = computeCch(text, CLAUDE_CODE_VERSION);
+    const billingLine = `x-anthropic-billing-header: cc_version=${CLAUDE_CODE_VERSION}; cc_entrypoint=cli; cch=${cch};`;
+
+    const { speed: _, system: existingSystem, ...rest } = original;
+
+    return JSON.stringify({
+      ...rest,
+      system: injectBillingHeader(existingSystem, billingLine),
+    });
+  } catch {
+    return raw;
+  }
+}
+
+/** Prepend the billing header into the system prompt, handling both array and string formats. */
+function injectBillingHeader(system: unknown, billingLine: string): unknown {
+  if (Array.isArray(system)) {
+    const filtered = system.filter(
+      (s: { text?: string }) => !(typeof s.text === "string" && s.text.includes("x-anthropic-billing-header")),
+    );
+    return [{ type: "text", text: billingLine }, ...filtered];
+  }
+  if (typeof system === "string") {
+    return `${billingLine}\n${system.replace(/x-anthropic-billing-header:[^\n]*\n?/, "")}`;
+  }
+  return [{ type: "text", text: billingLine }];
+}
+
 function betaHeader(original: string | null): string {
   const features = new Set<string>(claudeCodeBetas);
 

package/src/providers/codex-sse.ts

@@ -51,6 +51,19 @@ interface TransformState {
   toolCallIds: Map<string, number>;
 }
 
+/** Resolve tool call index from item_id or call_id, falling back to 0. */
+function lookupToolIndex(state: TransformState, itemId?: string, callId?: string): number {
+  if (itemId) {
+    const idx = state.toolCallIds.get(itemId);
+    if (idx !== undefined) return idx;
+  }
+  if (callId) {
+    const idx = state.toolCallIds.get(callId);
+    if (idx !== undefined) return idx;
+  }
+  return 0;
+}
+
 /** Create a stateful SSE transformer: Responses API → Chat Completions. */
 function createResponseTransformer(ampModel: string): (data: string) => string {
   const state: TransformState = {
@@ -62,7 +75,7 @@ function createResponseTransformer(ampModel: string): (data: string) => string {
   };
 
   return (data: string): string => {
-    if (data === "[DONE]") return data;
+    if (data === "[DONE]") return "";
 
     let parsed: Record<string, unknown>;
     try {
@@ -93,9 +106,11 @@ function createResponseTransformer(ampModel: string): (data: string) => string {
         }
         if (item?.type === "function_call") {
           const callId = item.call_id as string;
+          const itemId = item.id as string | undefined;
           const name = item.name as string;
           const idx = state.toolCallIndex++;
           state.toolCallIds.set(callId, idx);
+          if (itemId) state.toolCallIds.set(itemId, idx);
           return serialize(state, {
             tool_calls: [{ index: idx, id: callId, type: "function", function: { name, arguments: "" } }],
           });
@@ -113,9 +128,10 @@ function createResponseTransformer(ampModel: string): (data: string) => string {
       // Function call arguments delta
       case "response.function_call_arguments.delta": {
         const delta = parsed.delta as string;
+        const itemId = parsed.item_id as string | undefined;
         const callId = parsed.call_id as string | undefined;
         if (delta) {
-          const idx = callId ? (state.toolCallIds.get(callId) ?? 0) : 0;
+          const idx = lookupToolIndex(state, itemId, callId);
           return serialize(state, { tool_calls: [{ index: idx, function: { arguments: delta } }] });
         }
         return "";
@@ -130,18 +146,26 @@ function createResponseTransformer(ampModel: string): (data: string) => string {
         return serializeFinish(state, finishReason, usage);
       }
 
-      // Response incomplete — emit finish_reason "length" + usage
+      // Response incomplete — inspect reason to determine finish_reason
       case "response.incomplete": {
         const resp = parsed.response as Record<string, unknown>;
         const usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
-        return serializeFinish(state, "length", usage);
+        const finishReason = incompleteReason(resp);
+        return serializeFinish(state, finishReason, usage);
       }
 
-      // Response failed — emit finish_reason "stop" (error)
+      // Response failed — emit error content so the client sees the failure
       case "response.failed": {
         const resp = parsed.response as Record<string, unknown>;
         const usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
-        return serializeFinish(state, "stop", usage);
+        const errorMsg = extractErrorMessage(resp);
+        let chunks = "";
+        if (errorMsg) {
+          chunks = serialize(state, { role: "assistant", content: `[Error] ${errorMsg}` });
+          chunks += "\n\n";
+        }
+        chunks += serializeFinish(state, "stop", usage);
+        return chunks;
       }
 
       // Reasoning/thinking delta — emit as reasoning_content (separate from content)
@@ -191,6 +215,28 @@ function serializeFinish(state: TransformState, finishReason: string, usage?: Us
   return JSON.stringify(chunk);
 }
 
+/** Map Responses API incomplete reason → Chat Completions finish_reason. */
+function incompleteReason(resp: Record<string, unknown> | undefined): string {
+  if (!resp) return "length";
+  const reason = resp.incomplete_details as Record<string, unknown> | undefined;
+  const type = reason?.reason as string | undefined;
+  if (type === "max_output_tokens" || type === "max_tokens") return "length";
+  if (type === "content_filter") return "content_filter";
+  return "length";
+}
+
+/** Extract a human-readable error message from a failed response. */
+function extractErrorMessage(resp: Record<string, unknown> | undefined): string | null {
+  if (!resp) return null;
+  const error = resp.error as Record<string, unknown> | undefined;
+  if (!error) return null;
+  const message = error.message as string | undefined;
+  const code = error.code as string | undefined;
+  if (message) return code ? `${code}: ${message}` : message;
+  if (code) return code;
+  return null;
+}
+
 function extractUsage(raw: Record<string, unknown> | undefined): Usage | undefined {
   if (!raw) return undefined;
   const input = (raw.input_tokens as number) ?? 0;
@@ -206,6 +252,15 @@ function extractUsage(raw: Record<string, unknown> | undefined): Usage | undefin
   };
 }
 
+const FORWARDED_HEADERS = [
+  "x-request-id",
+  "request-id",
+  "x-ratelimit-limit-requests",
+  "x-ratelimit-remaining-requests",
+  "x-ratelimit-limit-tokens",
+  "x-ratelimit-remaining-tokens",
+] as const;
+
 /** Wrap a Codex SSE response with the Responses → Chat Completions transformer.
  *  Strips Responses API event names so output looks like standard Chat Completions SSE. */
 export function transformCodexResponse(response: Response, ampModel: string): Response {
@@ -214,14 +269,17 @@ export function transformCodexResponse(response: Response, ampModel: string): Re
   const transformer = createResponseTransformer(ampModel);
   const body = transformStream(response.body, transformer);
 
-  return new Response(body, {
-    status: response.status,
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-    },
-  });
+  const headers: Record<string, string> = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+  };
+  for (const name of FORWARDED_HEADERS) {
+    const value = response.headers.get(name);
+    if (value) headers[name] = value;
+  }
+
+  return new Response(body, { status: response.status, headers });
 }
 
 /** Buffer a Codex SSE response into a single Chat Completions JSON response.
@@ -295,9 +353,11 @@ export async function bufferCodexResponse(response: Response, ampModel: string):
           const item = parsed.item as Record<string, unknown>;
           if (item?.type === "function_call") {
             const callId = item.call_id as string;
+            const itemId = item.id as string | undefined;
             const name = item.name as string;
             const idx = state.toolCallIndex++;
             state.toolCallIds.set(callId, idx);
+            if (itemId) state.toolCallIds.set(itemId, idx);
             toolCalls.set(idx, { id: callId, type: "function", function: { name, arguments: "" } });
           }
           break;
@@ -305,9 +365,10 @@ export async function bufferCodexResponse(response: Response, ampModel: string):
 
         case "response.function_call_arguments.delta": {
           const delta = parsed.delta as string;
+          const itemId = parsed.item_id as string | undefined;
           const callId = parsed.call_id as string | undefined;
           if (delta) {
-            const idx = callId ? (state.toolCallIds.get(callId) ?? 0) : 0;
+            const idx = lookupToolIndex(state, itemId, callId);
             const tc = toolCalls.get(idx);
             if (tc) tc.function.arguments += delta;
           }
@@ -324,32 +385,90 @@ export async function bufferCodexResponse(response: Response, ampModel: string):
         case "response.incomplete": {
           const resp = parsed.response as Record<string, unknown>;
           usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
-          finishReason = "length";
+          finishReason = incompleteReason(resp);
           break;
         }
 
         case "response.failed": {
           const resp = parsed.response as Record<string, unknown>;
           usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+          const errorMsg = extractErrorMessage(resp);
+          if (errorMsg) content += `[Error] ${errorMsg}`;
           break;
         }
       }
     }
   }
 
-  // Process remaining buffer
+  // Process remaining buffer — reuse the same event handling as main loop
   if (sseBuffer.trim()) {
     for (const chunk of sse.parse(sseBuffer)) {
       if (chunk.data === "[DONE]") continue;
+
+      let parsed: Record<string, unknown>;
       try {
-        const parsed = JSON.parse(chunk.data) as Record<string, unknown>;
-        if (parsed.type === "response.completed") {
+        parsed = JSON.parse(chunk.data) as Record<string, unknown>;
+      } catch {
+        continue;
+      }
+
+      const eventType = parsed.type as string | undefined;
+      if (!eventType) continue;
+
+      switch (eventType) {
+        case "response.output_text.delta": {
+          const delta = parsed.delta as string;
+          if (delta) content += delta;
+          break;
+        }
+        case "response.reasoning_summary_text.delta": {
+          const delta = parsed.delta as string;
+          if (delta) reasoningContent += delta;
+          break;
+        }
+        case "response.output_item.added": {
+          const item = parsed.item as Record<string, unknown>;
+          if (item?.type === "function_call") {
+            const callId = item.call_id as string;
+            const itemId = item.id as string | undefined;
+            const name = item.name as string;
+            const idx = state.toolCallIndex++;
+            state.toolCallIds.set(callId, idx);
+            if (itemId) state.toolCallIds.set(itemId, idx);
+            toolCalls.set(idx, { id: callId, type: "function", function: { name, arguments: "" } });
+          }
+          break;
+        }
+        case "response.function_call_arguments.delta": {
+          const delta = parsed.delta as string;
+          const itemId = parsed.item_id as string | undefined;
+          const callId = parsed.call_id as string | undefined;
+          if (delta) {
+            const idx = lookupToolIndex(state, itemId, callId);
+            const tc = toolCalls.get(idx);
+            if (tc) tc.function.arguments += delta;
+          }
+          break;
+        }
+        case "response.completed": {
           const resp = parsed.response as Record<string, unknown>;
           usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
           finishReason = state.toolCallIndex > 0 ? "tool_calls" : "stop";
+          break;
+        }
+        case "response.incomplete": {
+          const resp = parsed.response as Record<string, unknown>;
+          usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+          finishReason = incompleteReason(resp);
+          break;
+        }
+        case "response.failed": {
+          const resp = parsed.response as Record<string, unknown>;
+          usage = extractUsage(resp?.usage as Record<string, unknown> | undefined);
+          const errorMsg = extractErrorMessage(resp);
+          if (errorMsg) content += `[Error] ${errorMsg}`;
+          break;
         }
-      } catch {
-        // skip
       }
     }
   }

package/src/providers/codex.ts

@@ -30,7 +30,7 @@ export const provider: Provider = {
 
     const accountId = getAccountId(accessToken, account);
     const codexPath = codexPathMap[sub] ?? sub;
-    const promptCacheKey = originalHeaders.get("x-amp-thread-id") ?? undefined;
+    const promptCacheKey = originalHeaders.get("x-amp-thread-id") ?? originalHeaders.get("x-session-id") ?? undefined;
     const { body: codexBody, needsResponseTransform } = transformForCodex(body.forwardBody, promptCacheKey);
     const ampModel = body.ampModel ?? "gpt-5.2";
 
@@ -135,22 +135,31 @@ function transformForCodex(
     fixOrphanOutputs(parsed.input as Record<string, unknown>[]);
   }
 
-  // Reasoning config — defaults match reference behavior
+  // Reasoning config — merge with caller-provided values, defaults match reference behavior
+  // Chat Completions uses top-level "reasoning_effort"; Responses API uses "reasoning.effort"
   const model = (parsed.model as string) ?? "";
+  const existingReasoning = (parsed.reasoning as Record<string, unknown>) ?? {};
+  const topLevelEffort = parsed.reasoning_effort as string | undefined;
   parsed.reasoning = {
-    effort: clampReasoningEffort(model, "high"),
-    summary: "auto",
+    effort: clampReasoningEffort(model, topLevelEffort ?? (existingReasoning.effort as string) ?? "medium"),
+    summary: existingReasoning.summary ?? "auto",
   };
 
-  parsed.text = { verbosity: "medium" };
+  const existingText = (parsed.text as Record<string, unknown>) ?? {};
+  parsed.text = { ...existingText, verbosity: existingText.verbosity ?? "medium" };
 
-  parsed.include = ["reasoning.encrypted_content"];
+  const existingInclude = Array.isArray(parsed.include) ? (parsed.include as string[]) : [];
+  if (!existingInclude.includes("reasoning.encrypted_content")) {
+    existingInclude.push("reasoning.encrypted_content");
+  }
+  parsed.include = existingInclude;
 
   if (promptCacheKey) {
     parsed.prompt_cache_key = promptCacheKey;
   }
 
   // Remove fields the Codex backend doesn't accept
+  delete parsed.reasoning_effort; // Chat Completions field; already mapped to reasoning.effort above
   delete parsed.max_tokens;
   delete parsed.max_completion_tokens;
   delete parsed.max_output_tokens;
@@ -165,6 +174,23 @@ function transformForCodex(
   delete parsed.logit_bias;
   delete parsed.response_format;
 
+  // Normalize tools[] for Responses API: flatten function.{name,description,parameters,strict} to top-level
+  if (Array.isArray(parsed.tools)) {
+    parsed.tools = (parsed.tools as Record<string, unknown>[]).map((tool) => {
+      if (tool.type === "function" && tool.function && typeof tool.function === "object") {
+        const fn = tool.function as Record<string, unknown>;
+        return {
+          type: "function",
+          name: fn.name,
+          description: fn.description,
+          parameters: fn.parameters,
+          ...(fn.strict !== undefined ? { strict: fn.strict } : {}),
+        };
+      }
+      return tool;
+    });
+  }
+
   // Normalize tool_choice for Responses API
   if (parsed.tool_choice !== undefined && parsed.tool_choice !== null) {
     if (typeof parsed.tool_choice === "string") {
@@ -236,7 +262,7 @@ function convertMessages(messages: ChatMessage[]): { instructions: string | null
         input.push({
           type: "function_call_output",
           call_id: msg.tool_call_id,
-          output: textOf(msg.content) ?? "",
+          output: stringifyContent(msg.content),
         });
         break;
     }
@@ -265,6 +291,18 @@ function convertUserContent(content: unknown): unknown[] {
   return [{ type: "input_text", text: String(content) }];
 }
 
+/** Convert content to string, with JSON fallback for non-text values. */
+function stringifyContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  const text = textOf(content);
+  if (text !== null) return text;
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return String(content ?? "");
+  }
+}
+
 /** Extract text from content (string or array). */
 function textOf(content: unknown): string | null {
   if (typeof content === "string") return content;

package/src/providers/forward.ts

@@ -51,7 +51,29 @@ export async function forward(opts: ForwardOptions): Promise<Response> {
       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 } });
+
+      // Normalize non-standard error responses (e.g. {"detail":"..."}) to OpenAI format
+      // so Amp CLI can deserialize them (it expects {"error": {...}})
+      let errorBody = text;
+      try {
+        const parsed = JSON.parse(text) as Record<string, unknown>;
+        if (!parsed.error) {
+          const message = (parsed.detail as string) ?? (parsed.message as string) ?? text;
+          errorBody = JSON.stringify({
+            error: { message, type: "api_error", code: String(response.status) },
+          });
+        }
+      } catch {
+        // Not JSON — wrap raw text
+        errorBody = JSON.stringify({
+          error: { message: text, type: "api_error", code: String(response.status) },
+        });
+      }
+
+      return new Response(errorBody, {
+        status: response.status,
+        headers: { "Content-Type": "application/json" },
+      });
     }
 
     const isSSE = contentType.includes("text/event-stream") || opts.streaming;

package/src/routing/retry.ts

@@ -1,17 +1,31 @@
-/** Retry logic: cache-preserving wait + reroute after 429. */
+/** Retry logic: cache-preserving wait + reroute after retryable failures (429/403). */
 
 import type { ProxyConfig } from "../config/config.ts";
 import type { ParsedBody } from "../server/body.ts";
 import { logger } from "../utils/logger.ts";
-import { cooldown, parseRetryAfter } from "./cooldown.ts";
-import { type RouteResult, recordSuccess, rerouteAfter429 } from "./router.ts";
+import { cooldown, parseRetryAfter, type QuotaPool } from "./cooldown.ts";
+import { type RouteResult, recordSuccess, reroute } from "./router.ts";
 
-/** Max 429-reroute attempts before falling back to upstream. */
+/** Max reroute attempts before falling back to upstream. */
 const MAX_REROUTE_ATTEMPTS = 4;
 /** Max seconds to wait-and-retry on the same account (preserves prompt cache). */
 const CACHE_PRESERVE_WAIT_MAX_S = 10;
 
-/** Wait briefly and retry on the same account to preserve prompt cache. */
+/** Status codes that trigger rerouting to a different account/pool. */
+const REROUTABLE_STATUSES = new Set([429, 403]);
+
+interface RerouteContext {
+  providerName: string;
+  ampModel: string | null;
+  config: ProxyConfig;
+  sub: string;
+  body: ParsedBody;
+  headers: Headers;
+  rewrite: ((data: string) => string) | undefined;
+  threadId?: string;
+}
+
+/** Wait briefly and retry on the same account to preserve prompt cache (429 only). */
 export async function tryWithCachePreserve(
   route: RouteResult,
   sub: string,
@@ -38,35 +52,26 @@ export async function tryWithCachePreserve(
   return null;
 }
 
-/** Reroute to different accounts/pools after 429 (cache loss accepted). */
+/** Reroute to different accounts/pools after a retryable failure (429/403). */
 export async function tryReroute(
-  providerName: string,
-  ampModel: string | null,
-  config: ProxyConfig,
+  ctx: RerouteContext,
   initialRoute: RouteResult,
-  sub: string,
-  body: ParsedBody,
-  headers: Headers,
-  rewrite: ((data: string) => string) | undefined,
-  initialResponse: Response,
-  threadId?: string,
+  status: number,
 ): Promise<Response | null> {
-  const retryAfter = parseRetryAfter(initialResponse.headers.get("retry-after"));
-  logger.warn(`429 from ${initialRoute.decision} account=${initialRoute.account}`, { retryAfter });
+  recordFailure(initialRoute.pool!, initialRoute.account, status);
 
   let currentPool = initialRoute.pool!;
   let currentAccount = initialRoute.account;
 
   for (let attempt = 0; attempt < MAX_REROUTE_ATTEMPTS; attempt++) {
-    const next = rerouteAfter429(providerName, ampModel, config, currentPool, currentAccount, retryAfter, threadId);
-    if (!next) break;
+    const next = reroute(ctx.providerName, ctx.ampModel, ctx.config, currentPool, currentAccount, ctx.threadId);
+    if (!next?.handler) break;
 
-    logger.info(`REROUTE -> ${next.decision} account=${next.account}`);
-    const response = await next.handler!.forward(sub, body, headers, rewrite, next.account);
+    logger.info(`REROUTE (${status}) -> ${next.decision} account=${next.account}`);
+    const response = await next.handler.forward(ctx.sub, ctx.body, ctx.headers, ctx.rewrite, next.account);
 
-    if (response.status === 429 && next.pool) {
-      const nextRetryAfter = parseRetryAfter(response.headers.get("retry-after"));
-      cooldown.record429(next.pool, next.account, nextRetryAfter);
+    if (REROUTABLE_STATUSES.has(response.status) && next.pool) {
+      recordFailure(next.pool, next.account, response.status);
       currentPool = next.pool;
       currentAccount = next.account;
       continue;
@@ -81,3 +86,12 @@ export async function tryReroute(
 
   return null;
 }
+
+/** Record the appropriate cooldown based on status code. */
+function recordFailure(pool: QuotaPool, account: number, status: number): void {
+  if (status === 403) {
+    cooldown.record403(pool, account);
+  } else {
+    cooldown.record429(pool, account);
+  }
+}

package/src/routing/router.ts

@@ -123,19 +123,16 @@ export function routeRequest(
   return result(picked.provider, ampProvider, modelStr, picked.account, picked.pool);
 }
 
-/** Record a 429 response and attempt re-route. Returns a new RouteResult or null. */
-export function rerouteAfter429(
+/** Record a failure on the current account and pick the next candidate.
+ *  Caller is responsible for recording the failure (429/403) on cooldown before calling. */
+export function reroute(
   ampProvider: string,
   model: string | null,
   config: ProxyConfig,
   failedPool: QuotaPool,
   failedAccount: number,
-  retryAfterSeconds: number | undefined,
   threadId?: string,
 ): RouteResult | null {
-  cooldown.record429(failedPool, failedAccount, retryAfterSeconds);
-
-  // If exhausted, break thread affinity
   if (threadId && cooldown.isExhausted(failedPool, failedAccount)) {
     affinity.clear(threadId, ampProvider);
   }

package/src/server/server.ts

@@ -5,7 +5,6 @@ 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";
@@ -85,7 +84,7 @@ async function handleProvider(
 ): Promise<Response> {
   const startTime = Date.now();
   const sub = path.subpath(pathname);
-  const threadId = req.headers.get("x-amp-thread-id") ?? undefined;
+  const threadId = req.headers.get("x-amp-thread-id") ?? req.headers.get("x-session-id") ?? undefined;
 
   const rawBody = req.method === "POST" ? await req.text() : "";
   const body = parseBody(rawBody, sub);
@@ -102,29 +101,19 @@ async function handleProvider(
     const rewrite = ampModel ? rewriter.rewrite(ampModel) : undefined;
     const handlerResponse = await route.handler.forward(sub, body, req.headers, rewrite, route.account);
 
-    if (handlerResponse.status === 429 && route.pool) {
-      const cached = await tryWithCachePreserve(route, sub, body, req.headers, rewrite, handlerResponse);
+    if ((handlerResponse.status === 429 || handlerResponse.status === 403) && route.pool) {
+      const ctx = { providerName, ampModel, config, sub, body, headers: req.headers, rewrite, threadId };
+      // 429: try short wait to preserve prompt cache first
+      const cached =
+        handlerResponse.status === 429
+          ? await tryWithCachePreserve(route, sub, body, req.headers, rewrite, handlerResponse)
+          : null;
       if (cached) {
         response = cached;
       } else {
-        const rerouted = await tryReroute(
-          providerName,
-          ampModel,
-          config,
-          route,
-          sub,
-          body,
-          req.headers,
-          rewrite,
-          handlerResponse,
-          threadId,
-        );
+        const rerouted = await tryReroute(ctx, route, handlerResponse.status);
         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);

package/src/utils/code-assist.ts

@@ -46,6 +46,72 @@ export function withUnwrap(rewrite?: (d: string) => string): (d: string) => stri
   return rewrite ? (d: string) => rewrite(unwrap(d)) : unwrap;
 }
 
+/** Ensure every function_response part has a non-empty name.
+ *  Gemini API rejects requests where function_response.name is empty.
+ *  Uses two strategies:
+ *  1. Positional: a model turn with N functionCall parts is followed by a user turn
+ *     with N functionResponse parts in the same order — match by index.
+ *  2. ID-based fallback: match function_response.id → function_call.id.
+ *  Handles both camelCase (functionCall) and snake_case (function_call) keys. */
+function fixFunctionResponseNames(body: Record<string, unknown>): void {
+  const contents = body.contents;
+  if (!Array.isArray(contents)) return;
+
+  type Part = Record<string, unknown>;
+  type Content = { role?: string; parts?: Part[] };
+  const getFc = (p: Part) => (p.functionCall ?? p.function_call) as Record<string, unknown> | undefined;
+  const getFr = (p: Part) => (p.functionResponse ?? p.function_response) as Record<string, unknown> | undefined;
+
+  // Pass 1: positional matching — pair consecutive model/user turns
+  for (let i = 0; i < contents.length - 1; i++) {
+    const modelTurn = contents[i] as Content;
+    const userTurn = contents[i + 1] as Content;
+    if (modelTurn.role !== "model" || userTurn.role !== "user") continue;
+    if (!Array.isArray(modelTurn.parts) || !Array.isArray(userTurn.parts)) continue;
+
+    const fcParts = modelTurn.parts.filter((p) => getFc(p as Part));
+    const frParts = userTurn.parts.filter((p) => getFr(p as Part));
+    if (fcParts.length === 0 || fcParts.length !== frParts.length) continue;
+
+    for (let j = 0; j < frParts.length; j++) {
+      const fr = getFr(frParts[j] as Part)!;
+      if (typeof fr.name === "string" && fr.name) continue;
+      const fc = getFc(fcParts[j] as Part)!;
+      if (typeof fc.name === "string") {
+        fr.name = fc.name;
+      }
+    }
+  }
+
+  // Pass 2: ID-based fallback for any remaining empty names
+  const nameById = new Map<string, string>();
+  for (const content of contents) {
+    const parts = (content as Content)?.parts;
+    if (!Array.isArray(parts)) continue;
+    for (const part of parts) {
+      const fc = getFc(part as Part);
+      if (fc && typeof fc.name === "string" && typeof fc.id === "string") {
+        nameById.set(fc.id, fc.name);
+      }
+    }
+  }
+
+  if (nameById.size === 0) return;
+
+  for (const content of contents) {
+    const parts = (content as Content)?.parts;
+    if (!Array.isArray(parts)) continue;
+    for (const part of parts) {
+      const fr = getFr(part as Part);
+      if (!fr || (typeof fr.name === "string" && fr.name)) continue;
+      const resolved = typeof fr.id === "string" ? nameById.get(fr.id) : undefined;
+      if (resolved) {
+        fr.name = resolved;
+      }
+    }
+  }
+}
+
 /** Wrap body in CCA envelope if not already wrapped. */
 export function maybeWrap(
   parsed: Record<string, unknown> | null,
@@ -56,5 +122,6 @@ export function maybeWrap(
 ): string {
   if (!parsed) return raw;
   if (parsed.project) return raw;
+  fixFunctionResponseNames(parsed);
   return wrapRequest({ projectId, model, body: parsed, ...opts });
 }