ampcode-connector 0.1.16 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ampcode-connector",
-  "version": "0.1.16",
+  "version": "0.1.19",
   "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,11 @@ export const claudeCodeBetas = [
   "claude-code-20250219",
   "oauth-2025-04-20",
   "interleaved-thinking-2025-05-14",
+  "context-management-2025-06-27",
   "prompt-caching-scope-2026-01-05",
 ] 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 = {
@@ -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 "";
@@ -337,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;
@@ -347,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;
           }
@@ -411,18 +430,21 @@ 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;
         }
         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;
           }

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";
 
@@ -136,10 +136,12 @@ function transformForCodex(
   }
 
   // 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, (existingReasoning.effort as string) ?? "high"),
+    effort: clampReasoningEffort(model, topLevelEffort ?? (existingReasoning.effort as string) ?? "medium"),
     summary: existingReasoning.summary ?? "auto",
   };
 
@@ -157,6 +159,7 @@ function transformForCodex(
   }
 
   // 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;

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 });
 }