ampcode-connector 0.1.20 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ampcode-connector",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "Proxy AmpCode through local OAuth subscriptions (Claude Code, Codex, Gemini CLI, Antigravity)",
   "license": "MIT",
   "repository": {

package/src/constants.ts

@@ -1,7 +1,8 @@
 /** Single source of truth — no magic strings scattered across files. */
 
 export const CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
-export const ANTIGRAVITY_DAILY_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+export const ANTIGRAVITY_DAILY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+export const ANTIGRAVITY_DAILY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
 export const AUTOPUSH_ENDPOINT = "https://autopush-cloudcode-pa.sandbox.googleapis.com";
 export const DEFAULT_ANTIGRAVITY_PROJECT = "rising-fact-p41fc";
 

package/src/providers/forward.ts

@@ -53,7 +53,7 @@ export async function forward(opts: ForwardOptions): Promise<Response> {
         await Bun.sleep(RETRY_DELAY_MS * (attempt + 1));
         continue;
       }
-      throw err;
+      return transportErrorResponse(opts.providerName, err);
     }
 
     // Retry on server errors (429 handled at routing layer)
@@ -117,3 +117,30 @@ export async function forward(opts: ForwardOptions): Promise<Response> {
 export function denied(providerName: string): Response {
   return apiError(401, `No ${providerName} OAuth token available. Run login first.`);
 }
+
+function transportErrorResponse(providerName: string, err: unknown): Response {
+  const message = transportErrorMessage(providerName, err);
+  logger.error(`${providerName} transport error after retries exhausted`, { error: String(err) });
+  return apiError(502, message, "connection_error");
+}
+
+function transportErrorMessage(providerName: string, err: unknown): string {
+  const base = `${providerName} connection error after retries were exhausted.`;
+  const details = String(err);
+
+  if (providerName !== "Anthropic") {
+    return `${base} ${details}`;
+  }
+
+  const looksLikeReset =
+    details.includes("ECONNRESET") ||
+    details.includes("socket connection was closed unexpectedly") ||
+    details.includes("tls") ||
+    details.includes("network");
+
+  if (!looksLikeReset) {
+    return `${base} ${details}`;
+  }
+
+  return `${base} ${details} This is often a local network issue rather than an OAuth bug: check Wi-Fi MTU (1492 is a common fix), hotspot stability, and iPhone dual-SIM Cellular Data Switching if you are tethering.`;
+}

package/src/providers/google.ts

@@ -4,7 +4,7 @@
 import { google as config } from "../auth/configs.ts";
 import * as oauth from "../auth/oauth.ts";
 import * as store from "../auth/store.ts";
-import { ANTIGRAVITY_DAILY_ENDPOINT, AUTOPUSH_ENDPOINT, CODE_ASSIST_ENDPOINT } from "../constants.ts";
+import { ANTIGRAVITY_DAILY_ENDPOINT, ANTIGRAVITY_DAILY_SANDBOX_ENDPOINT, CODE_ASSIST_ENDPOINT } from "../constants.ts";
 import { buildUrl, maybeWrap, withUnwrap } from "../utils/code-assist.ts";
 import { logger } from "../utils/logger.ts";
 import * as path from "../utils/path.ts";
@@ -26,7 +26,7 @@ interface GoogleStrategy {
   wrapOpts: {
     userAgent: "antigravity" | "pi-coding-agent";
     requestIdPrefix: "agent" | "pi";
-    requestType?: "agent";
+    requestType?: "agent" | "image_gen";
   };
 }
 
@@ -44,15 +44,23 @@ const geminiStrategy: GoogleStrategy = {
   },
 };
 
+/** Antigravity uses different model names than what Amp CLI sends. */
+const antigravityModelMap: Record<string, string> = {
+  "gemini-3-flash-preview": "gemini-3-flash",
+  "gemini-3-pro-preview": "gemini-3-pro-high",
+  "gemini-3-pro-image-preview": "gemini-3.1-flash-image",
+  "gemini-3.1-flash-image-preview": "gemini-3.1-flash-image",
+};
+
 const antigravityStrategy: GoogleStrategy = {
   name: "antigravity",
   headers: {
-    "User-Agent": "antigravity/1.15.8 darwin/arm64",
+    "User-Agent": "antigravity/1.104.0 darwin/arm64",
     "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
     "Client-Metadata": GOOGLE_CLIENT_METADATA,
   },
-  endpoints: [ANTIGRAVITY_DAILY_ENDPOINT, AUTOPUSH_ENDPOINT, CODE_ASSIST_ENDPOINT],
-  modelMapper: (model: string) => (model === "gemini-3-flash-preview" ? "gemini-3-flash" : model),
+  endpoints: [ANTIGRAVITY_DAILY_ENDPOINT, ANTIGRAVITY_DAILY_SANDBOX_ENDPOINT, CODE_ASSIST_ENDPOINT],
+  modelMapper: (model: string) => antigravityModelMap[model] ?? model,
   wrapOpts: {
     userAgent: "antigravity",
     requestIdPrefix: "agent",
@@ -62,6 +70,9 @@ const antigravityStrategy: GoogleStrategy = {
 
 const strategies: readonly GoogleStrategy[] = [geminiStrategy, antigravityStrategy];
 
+/** Models that only work on the antigravity strategy. */
+const ANTIGRAVITY_ONLY_MODELS = new Set(["gemini-3-pro-image-preview", "gemini-3.1-flash-image-preview"]);
+
 const COOLDOWN_MS = 60_000;
 
 interface StrategyPreference {
@@ -78,8 +89,16 @@ function cooldownKey(account: number, strategy: GoogleStrategy): string {
   return `${account}:${strategy.name}`;
 }
 
-function getOrderedStrategies(account: number): GoogleStrategy[] {
+function getOrderedStrategies(account: number, model?: string): GoogleStrategy[] {
   const now = Date.now();
+
+  // Some models only work on antigravity — skip other strategies entirely
+  if (model && ANTIGRAVITY_ONLY_MODELS.has(model)) {
+    const cd = cooldowns.get(cooldownKey(account, antigravityStrategy));
+    if (cd && cd > now) return [];
+    return [antigravityStrategy];
+  }
+
   const pref = preferredStrategy.get(account);
   const ordered =
     pref && pref.until > now ? [pref.strategy, ...strategies.filter((s) => s !== pref.strategy)] : [...strategies];
@@ -103,6 +122,78 @@ function markFailure(account: number, strategy: GoogleStrategy): void {
   }
 }
 
+/** Buffer an SSE response and merge all chunks into a single JSON response.
+ *  Used when we force streamGenerateContent but the client expects non-streaming JSON.
+ *  Accumulates all candidate parts across chunks (image inlineData may be in earlier chunks). */
+async function bufferSSEToJSON(response: Response): Promise<Response | null> {
+  const text = await response.text();
+  const chunks: Record<string, unknown>[] = [];
+
+  for (const line of text.split("\n")) {
+    if (!line.startsWith("data: ")) continue;
+    const data = line.slice(6).trim();
+    if (!data || data === "[DONE]") continue;
+    try {
+      chunks.push(JSON.parse(data) as Record<string, unknown>);
+    } catch {
+      // skip non-JSON
+    }
+  }
+
+  if (chunks.length === 0) return null;
+  if (chunks.length === 1) {
+    return new Response(JSON.stringify(chunks[0]), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  // Merge: accumulate parts from all chunks into the first candidate
+  const merged = chunks[0]! as Record<string, unknown>;
+  const allParts: unknown[] = [];
+
+  for (const chunk of chunks) {
+    const candidates = chunk.candidates as { content?: { parts?: unknown[] } }[] | undefined;
+    if (!candidates) continue;
+    for (const candidate of candidates) {
+      if (candidate.content?.parts) {
+        allParts.push(...candidate.content.parts);
+      }
+    }
+  }
+
+  // Use last chunk's metadata (finishReason, usageMetadata)
+  const last = chunks[chunks.length - 1]! as Record<string, unknown>;
+  const lastCandidates = last.candidates as Record<string, unknown>[] | undefined;
+  const mergedCandidates = merged.candidates as Record<string, unknown>[] | undefined;
+
+  if (mergedCandidates?.[0] && allParts.length > 0) {
+    const content = (mergedCandidates[0] as Record<string, unknown>).content as Record<string, unknown> | undefined;
+    if (content) content.parts = allParts;
+    if (lastCandidates?.[0]) {
+      (mergedCandidates[0] as Record<string, unknown>).finishReason = (
+        lastCandidates[0] as Record<string, unknown>
+      ).finishReason;
+    }
+  }
+  if (last.usageMetadata) merged.usageMetadata = last.usageMetadata;
+
+  return new Response(JSON.stringify(merged), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+/** Generate a fallback project ID when none is stored (matches CLIProxyAPI behavior). */
+function generateProjectId(): string {
+  const adjectives = ["useful", "bright", "swift", "calm", "bold"];
+  const nouns = ["fuze", "wave", "spark", "flow", "core"];
+  const adj = adjectives[Math.floor(Math.random() * adjectives.length)]!;
+  const noun = nouns[Math.floor(Math.random() * nouns.length)]!;
+  const rand = crypto.randomUUID().slice(0, 5).toLowerCase();
+  return `${adj}-${noun}-${rand}`;
+}
+
 export const provider: Provider = {
   name: "Google",
   routeDecision: "LOCAL_GOOGLE",
@@ -117,7 +208,7 @@ export const provider: Provider = {
     if (!accessToken) return denied("Google");
 
     const creds = store.get("google", account);
-    const projectId = creds?.projectId ?? "";
+    const projectId = creds?.projectId || generateProjectId();
     const email = creds?.email;
 
     const modelAction = path.googleModel(sub);
@@ -127,7 +218,7 @@ export const provider: Provider = {
     }
 
     const unwrapThenRewrite = withUnwrap(rewrite);
-    const orderedStrategies = getOrderedStrategies(account);
+    const orderedStrategies = getOrderedStrategies(account, modelAction.model);
 
     if (orderedStrategies.length === 0) {
       const now = Date.now();
@@ -150,7 +241,9 @@ export const provider: Provider = {
 
     for (const strategy of orderedStrategies) {
       const model = strategy.modelMapper ? strategy.modelMapper(modelAction.model) : modelAction.model;
-      const requestBody = maybeWrap(body.parsed, body.forwardBody, projectId, model, strategy.wrapOpts);
+      const isImageModel = model.includes("image");
+      const wrapOpts = isImageModel ? { ...strategy.wrapOpts, requestType: "image_gen" as const } : strategy.wrapOpts;
+      const requestBody = maybeWrap(body.parsed, body.forwardBody, projectId, model, wrapOpts);
 
       const headers: Record<string, string> = {
         ...strategy.headers,
@@ -159,25 +252,45 @@ export const provider: Provider = {
         Accept: body.stream ? "text/event-stream" : "application/json",
       };
 
-      logger.info(`Google strategy=${strategy.name} account=${account}`);
+      logger.info(`Google strategy=${strategy.name} account=${account} model=${model}`);
+
+      // Antigravity forces streaming endpoint for gemini-3-pro* and image models (matches CLIProxyAPI behavior)
+      const forceStream = strategy.name === "antigravity" && (model.startsWith("gemini-3-pro") || isImageModel);
+      const action = forceStream ? "streamGenerateContent" : modelAction.action;
 
       for (const endpoint of strategy.endpoints) {
-        const url = buildUrl(endpoint, modelAction.action);
+        const url = buildUrl(endpoint, action);
         try {
+          const forceStreamNonStreaming = forceStream && !body.stream;
           const response = await forward({
             url,
             body: requestBody,
-            streaming: body.stream,
+            streaming: forceStreamNonStreaming ? true : body.stream,
             headers,
             providerName: `Google/${strategy.name}`,
             rewrite: unwrapThenRewrite,
             email,
           });
 
+          // When we forced streaming but client expects JSON, buffer SSE and return last chunk
+          if (forceStreamNonStreaming && response.ok && response.body) {
+            const merged = await bufferSSEToJSON(response);
+            if (merged) {
+              markSuccess(account, strategy);
+              return merged;
+            }
+          }
+
           if (response.status === 401 || response.status === 403) {
             return response;
           }
 
+          if (response.status === 404) {
+            lastResponse = response;
+            logger.debug(`Google strategy=${strategy.name} model not found (404), trying next endpoint`);
+            continue;
+          }
+
           if (response.status === 429) {
             saw429 = true;
             lastResponse = response;

package/src/server/server.ts

@@ -102,7 +102,10 @@ 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 || handlerResponse.status === 403) && route.pool) {
+    if (
+      (handlerResponse.status === 429 || handlerResponse.status === 403 || handlerResponse.status === 404) &&
+      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 =

package/src/utils/code-assist.ts

@@ -6,18 +6,23 @@ interface WrapOptions {
   body: Record<string, unknown>;
   userAgent: "antigravity" | "pi-coding-agent";
   requestIdPrefix: "agent" | "pi";
-  requestType?: "agent";
+  requestType?: "agent" | "image_gen";
 }
 
 /** Wrap a raw request body in the Cloud Code Assist envelope. */
 function wrapRequest(opts: WrapOptions): string {
+  const isImageGen = opts.requestType === "image_gen";
+  const requestId = isImageGen
+    ? `image_gen/${Date.now()}/${crypto.randomUUID()}/12`
+    : `${opts.requestIdPrefix}-${Date.now()}-${crypto.randomUUID().slice(0, 8)}`;
+
   return JSON.stringify({
     project: opts.projectId,
     model: opts.model,
     request: opts.body,
     ...(opts.requestType && { requestType: opts.requestType }),
     userAgent: opts.userAgent,
-    requestId: `${opts.requestIdPrefix}-${Date.now()}-${crypto.randomUUID().slice(0, 8)}`,
+    requestId,
   });
 }
 
@@ -118,7 +123,11 @@ export function maybeWrap(
   raw: string,
   projectId: string,
   model: string,
-  opts: { userAgent: "antigravity" | "pi-coding-agent"; requestIdPrefix: "agent" | "pi"; requestType?: "agent" },
+  opts: {
+    userAgent: "antigravity" | "pi-coding-agent";
+    requestIdPrefix: "agent" | "pi";
+    requestType?: "agent" | "image_gen";
+  },
 ): string {
   if (!parsed) return raw;
   if (parsed.project) return raw;