ampcode-connector 0.1.2 → 0.1.4

package/README.md

@@ -1,96 +1,14 @@
 # ampcode-connector
 
-Stop burning AmpCode credits. Route [AmpCode](https://ampcode.com) through your **existing** Claude Code, Codex CLI & Gemini CLI subscriptions — for free.
-
-![demo](demo.gif)
-
-```
-AmpCode → ampcode-connector → Claude Code      (free)
-                             → OpenAI Codex CLI (free)
-                             → Gemini CLI       (free)
-                             → AmpCode upstream (paid, last resort)
-```
-
-## Supported Providers
-
-| Provider | Models | How |
-|----------|--------|-----|
-| **Claude Code** | Opus 4, Sonnet 4, Haiku | Anthropic OAuth |
-| **OpenAI Codex CLI** | GPT-5, o3, Codex | OpenAI OAuth |
-| **Gemini CLI** | Gemini Pro, Flash | Google OAuth (dual: Gemini + Vertex pools) |
-
-> **Multi-account** — log in multiple times per provider to multiply your quota.
-
-## Quick Start
-
-Three commands. That's it.
+Route [AmpCode](https://ampcode.com) through your existing Claude Code, Codex CLI & Gemini CLI subscriptions.
 
 ```bash
 bunx ampcode-connector setup    # point AmpCode → proxy
-bunx ampcode-connector login    # authenticate providers (browser OAuth)
-bunx ampcode-connector          # start proxy
+bunx ampcode-connector login    # authenticate providers
+bunx ampcode-connector          # start
 ```
 
-<details>
-<summary>Or clone & run locally</summary>
-
-```bash
-git clone https://github.com/nghyane/ampcode-connector.git
-cd ampcode-connector
-bun install
-
-bun run setup
-bun run login
-bun start
-```
-
-</details>
-
-Requires [Bun](https://bun.sh) 1.3+.
-
-### Provider Login
-
-```bash
-bunx ampcode-connector login              # interactive TUI (↑↓ navigate, enter to login, d to disconnect)
-bunx ampcode-connector login anthropic    # Claude Code
-bunx ampcode-connector login codex        # OpenAI Codex CLI
-bunx ampcode-connector login google       # Gemini CLI + Antigravity
-```
-
-Each login opens your browser. Log in multiple times to stack accounts.
-
-## How It Works
-
-```
-Request in → local OAuth available? → yes → forward to provider API (free)
-                                    → no  → forward to ampcode.com  (paid)
-
-On 429 → retry with different account/pool
-On 401 → fallback to AmpCode upstream
-```
-
-Non-AI routes (auth, threads, telemetry) pass through to `ampcode.com` transparently — the proxy is invisible to AmpCode.
-
-### Smart Routing
-
-- **Thread affinity** — same thread sticks to the same account for consistency
-- **Least-connections** — new threads go to the least-loaded account
-- **Cooldown** — rate-limited accounts are temporarily skipped
-- **Google cascade** — Gemini → Antigravity (separate quota pools, double the free tier)
-
-## Configuration
-
-Edit [`config.yaml`](config.yaml) to change port, log level, or toggle providers.
-
-Amp API key resolution: `config.yaml` → `AMP_API_KEY` env → `~/.local/share/amp/secrets.json`.
-
-## Development
-
-```bash
-bun run dev        # --watch mode
-bun test           # run tests
-bun run check      # lint + typecheck + test
-```
+Requires [Bun](https://bun.sh) 1.3+. Config at `./config.yaml` or `~/.config/ampcode-connector/config.yaml` — see [`config.example.yaml`](config.example.yaml).
 
 ## License
 

package/config.yaml

@@ -1,20 +1,11 @@
 # ampcode-connector configuration
-# ================================
+# Copy to ./config.yaml or ~/.config/ampcode-connector/config.yaml
 
-# Port the proxy server listens on
 port: 7860
-
-# Amp upstream URL (fallback for non-intercepted requests)
-# ampUpstreamUrl: https://ampcode.com
-
-# Amp API key (optional - also reads from AMP_API_KEY env or ~/.local/share/amp/secrets.json)
-# ampApiKey: your-amp-api-key
-
-# Log level: debug, info, warn, error
 logLevel: info
+exaApiKey: d633d146-e67d-42af-8e18-a16a527d3ff2
 
-# Enable/disable individual providers
 providers:
-  anthropic: true      # Claude Code OAuth -> api.anthropic.com
-  codex: true          # OpenAI Codex OAuth -> api.openai.com
-  google: true         # Google OAuth -> Gemini CLI + Antigravity dual quota
+  anthropic: true
+  codex: true
+  google: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ampcode-connector",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Proxy AmpCode through local OAuth subscriptions (Claude Code, Codex, Gemini CLI, Antigravity)",
   "license": "MIT",
   "repository": {
@@ -40,12 +40,14 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.0",
-    "@types/bun": "latest"
+    "@types/bun": "^1.3.9"
   },
   "peerDependencies": {
     "typescript": "^5"
   },
   "dependencies": {
-    "@google/genai": "^1.41.0"
+    "@google/genai": "^1.41.0",
+    "@kreuzberg/html-to-markdown": "^2.25.0",
+    "exa-js": "^2.4.0"
   }
 }

package/src/cli/setup.ts

@@ -135,7 +135,10 @@ export async function setup(): Promise<void> {
 
     if (connected.length > 0) {
       hasAny = true;
-      const emails = connected.map((a) => a.email).filter(Boolean).join(", ");
+      const emails = connected
+        .map((a) => a.email)
+        .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}`);
     } else if (total.length > 0) {

package/src/config/config.ts

@@ -10,6 +10,7 @@ export interface ProxyConfig {
   port: number;
   ampUpstreamUrl: string;
   ampApiKey?: string;
+  exaApiKey?: string;
   logLevel: LogLevel;
   providers: {
     anthropic: boolean;
@@ -25,7 +26,11 @@ const DEFAULTS: ProxyConfig = {
   providers: { anthropic: true, codex: true, google: true },
 };
 
-const CONFIG_PATH = join(process.cwd(), "config.yaml");
+/** Config search order: cwd → ~/.config/ampcode-connector */
+const CONFIG_PATHS = [
+  join(process.cwd(), "config.yaml"),
+  join(homedir(), ".config", "ampcode-connector", "config.yaml"),
+];
 const SECRETS_PATH = join(homedir(), ".local", "share", "amp", "secrets.json");
 
 export async function loadConfig(): Promise<ProxyConfig> {
@@ -37,6 +42,7 @@ export async function loadConfig(): Promise<ProxyConfig> {
     port: asNumber(file?.["port"]) ?? DEFAULTS.port,
     ampUpstreamUrl: asString(file?.["ampUpstreamUrl"]) ?? DEFAULTS.ampUpstreamUrl,
     ampApiKey: apiKey,
+    exaApiKey: asString(file?.["exaApiKey"]) ?? process.env["EXA_API_KEY"],
     logLevel: asLogLevel(file?.["logLevel"]) ?? DEFAULTS.logLevel,
     providers: {
       anthropic: asBool(providers?.["anthropic"]) ?? DEFAULTS.providers.anthropic,
@@ -47,14 +53,19 @@ export async function loadConfig(): Promise<ProxyConfig> {
 }
 
 async function readConfigFile(): Promise<Record<string, unknown> | null> {
-  const file = Bun.file(CONFIG_PATH);
-  if (!(await file.exists())) return null;
-  try {
-    const text = await file.text();
-    return Bun.YAML.parse(text) as Record<string, unknown>;
-  } catch (err) {
-    throw new Error(`Invalid config.yaml: ${err}`);
+  for (const configPath of CONFIG_PATHS) {
+    const file = Bun.file(configPath);
+    if (await file.exists()) {
+      try {
+        const text = await file.text();
+        logger.info(`Loaded config from ${configPath}`);
+        return Bun.YAML.parse(text) as Record<string, unknown>;
+      } catch (err) {
+        throw new Error(`Invalid config at ${configPath}: ${err}`);
+      }
+    }
   }
+  return null;
 }
 
 /** Amp API key resolution: config file → AMP_API_KEY env → secrets.json */

package/src/constants.ts

@@ -7,6 +7,28 @@ export const DEFAULT_ANTIGRAVITY_PROJECT = "rising-fact-p41fc";
 
 export const ANTHROPIC_API_URL = "https://api.anthropic.com";
 export const OPENAI_API_URL = "https://api.openai.com";
+export const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+
+/** Codex-specific headers required by the ChatGPT backend. */
+export const codexHeaders = {
+  BETA: "OpenAI-Beta",
+  ACCOUNT_ID: "chatgpt-account-id",
+  ORIGINATOR: "originator",
+  SESSION_ID: "session_id",
+  CONVERSATION_ID: "conversation_id",
+} as const;
+
+export const codexHeaderValues = {
+  BETA_RESPONSES: "responses=experimental",
+  ORIGINATOR: "codex_cli_rs",
+  VERSION: "0.101.0",
+  USER_AGENT: `codex_cli_rs/0.101.0 (${process.platform} ${process.arch})`,
+} as const;
+
+/** Map /v1/responses → /codex/responses for the ChatGPT backend. */
+export const codexPathMap: Record<string, string> = {
+  "/v1/responses": "/codex/responses",
+} as const;
 export const DEFAULT_AMP_UPSTREAM_URL = "https://ampcode.com";
 
 export const ANTHROPIC_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
@@ -56,6 +78,7 @@ export const passthroughPrefixes = [
   "/api/threads",
   "/api/otel",
   "/api/tab",
+  "/api/durable-thread-workers",
 ] as const;
 
 /** Browser routes — redirect to ampcode.com (auth cookies need correct domain). */

package/src/providers/anthropic.ts

@@ -10,7 +10,6 @@ import {
   filteredBetaFeatures,
   stainlessHeaders,
 } from "../constants.ts";
-import * as path from "../utils/path.ts";
 import type { Provider } from "./base.ts";
 import { denied, forward } from "./base.ts";
 
@@ -29,12 +28,13 @@ export const provider: Provider = {
 
     return forward({
       url: `${ANTHROPIC_API_URL}${sub}`,
-      body,
+      body: body.forwardBody,
+      streaming: body.stream,
       providerName: "Anthropic",
       rewrite,
       headers: {
         ...stainlessHeaders,
-        Accept: path.streaming(body) ? "text/event-stream" : "application/json",
+        Accept: body.stream ? "text/event-stream" : "application/json",
         "Accept-Encoding": "br, gzip, deflate",
         Connection: "keep-alive",
         "Content-Type": "application/json",

package/src/providers/antigravity.ts

@@ -6,7 +6,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 * as codeAssist from "../utils/code-assist.ts";
+import { buildUrl, maybeWrap, withUnwrap } from "../utils/code-assist.ts";
 import { logger } from "../utils/logger.ts";
 import * as path from "../utils/path.ts";
 import type { Provider } from "./base.ts";
@@ -53,37 +53,20 @@ export const provider: Provider = {
     const gemini = path.gemini(sub);
     const action = gemini?.action ?? "generateContent";
     const model = gemini?.model ?? "";
-    const requestBody = maybeWrap(body, projectId, model);
-    const unwrapThenRewrite = withUnwrap(rewrite);
-
-    return tryEndpoints(requestBody, headers, action, unwrapThenRewrite);
-  },
-};
-
-function withUnwrap(rewrite?: (d: string) => string): (d: string) => string {
-  return rewrite ? (d: string) => rewrite(codeAssist.unwrap(d)) : codeAssist.unwrap;
-}
-
-function maybeWrap(body: string, projectId: string, model: string): string {
-  try {
-    const parsed = JSON.parse(body) as Record<string, unknown>;
-    if (parsed["project"]) return body;
-    return codeAssist.wrapRequest({
-      projectId,
-      model,
-      body: parsed,
+    const requestBody = maybeWrap(body.parsed, body.forwardBody, projectId, model, {
       userAgent: "antigravity",
       requestIdPrefix: "agent",
       requestType: "agent",
     });
-  } catch (err) {
-    logger.debug("Body parse failed, forwarding as-is", { error: String(err) });
-    return body;
-  }
-}
+    const unwrapThenRewrite = withUnwrap(rewrite);
+
+    return tryEndpoints(requestBody, body.stream, headers, action, unwrapThenRewrite);
+  },
+};
 
 async function tryEndpoints(
   body: string,
+  streaming: boolean,
   headers: Record<string, string>,
   action: string,
   rewrite?: (data: string) => string,
@@ -91,9 +74,9 @@ async function tryEndpoints(
   let lastError: Error | null = null;
 
   for (const endpoint of endpoints) {
-    const url = codeAssist.buildUrl(endpoint, action);
+    const url = buildUrl(endpoint, action);
     try {
-      const response = await forward({ url, body, headers, providerName: "Antigravity", rewrite });
+      const response = await forward({ url, body, streaming, headers, providerName: "Antigravity", rewrite });
       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

@@ -1,8 +1,8 @@
 /** Provider interface and shared request forwarding. */
 
+import type { ParsedBody } from "../server/body.ts";
 import type { RouteDecision } from "../utils/logger.ts";
 import { logger } from "../utils/logger.ts";
-import * as path from "../utils/path.ts";
 import * as sse from "../utils/streaming.ts";
 
 export interface Provider {
@@ -12,7 +12,7 @@ export interface Provider {
   accountCount(): number;
   forward(
     path: string,
-    body: string,
+    body: ParsedBody,
     headers: Headers,
     rewrite?: (data: string) => string,
     account?: number,
@@ -22,6 +22,7 @@ export interface Provider {
 interface ForwardOptions {
   url: string;
   body: string;
+  streaming: boolean;
   headers: Record<string, string>;
   providerName: string;
   rewrite?: (data: string) => string;
@@ -34,30 +35,23 @@ export async function forward(opts: ForwardOptions): Promise<Response> {
     body: opts.body,
   });
 
-  const isSSE = response.headers.get("Content-Type")?.includes("text/event-stream") || path.streaming(opts.body);
-  if (isSSE) return sse.proxy(response, opts.rewrite);
+  const contentType = response.headers.get("Content-Type") ?? "application/json";
 
   if (!response.ok) {
     const text = await response.text();
-    logger.error(`${opts.providerName} API error`, { error: text.slice(0, 200) });
-    return new Response(text, {
-      status: response.status,
-      headers: { "Content-Type": response.headers.get("Content-Type") ?? "application/json" },
-    });
+    logger.error(`${opts.providerName} API error (${response.status})`, { 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);
+
   if (opts.rewrite) {
     const text = await response.text();
-    return new Response(opts.rewrite(text), {
-      status: response.status,
-      headers: { "Content-Type": response.headers.get("Content-Type") ?? "application/json" },
-    });
+    return new Response(opts.rewrite(text), { status: response.status, headers: { "Content-Type": contentType } });
   }
 
-  return new Response(response.body, {
-    status: response.status,
-    headers: { "Content-Type": response.headers.get("Content-Type") ?? "application/json" },
-  });
+  return new Response(response.body, { status: response.status, headers: { "Content-Type": contentType } });
 }
 
 export function denied(providerName: string): Response {

package/src/providers/codex.ts

@@ -1,10 +1,13 @@
-/** Forwards requests to api.openai.com with Codex CLI OAuth token. */
+/** Forwards requests to chatgpt.com/backend-api/codex with Codex CLI OAuth token.
+ *
+ *  The ChatGPT backend requires specific headers (account-id from JWT, originator,
+ *  OpenAI-Beta) and a different URL path (/codex/responses) than api.openai.com. */
 
 import { codex as config } from "../auth/configs.ts";
 import * as oauth from "../auth/oauth.ts";
 import * as store from "../auth/store.ts";
-import { OPENAI_API_URL } from "../constants.ts";
-import * as path from "../utils/path.ts";
+import { CODEX_BASE_URL, codexHeaders, codexHeaderValues, codexPathMap } from "../constants.ts";
+import { fromBase64url } from "../utils/encoding.ts";
 import type { Provider } from "./base.ts";
 import { denied, forward } from "./base.ts";
 
@@ -21,16 +24,42 @@ export const provider: Provider = {
     const accessToken = await oauth.token(config, account);
     if (!accessToken) return denied("OpenAI Codex");
 
+    const accountId = getAccountId(accessToken, account);
+    const codexPath = codexPathMap[sub] ?? sub;
+
     return forward({
-      url: `${OPENAI_API_URL}${sub}`,
-      body,
+      url: `${CODEX_BASE_URL}${codexPath}`,
+      body: body.forwardBody,
+      streaming: body.stream,
       providerName: "OpenAI Codex",
       rewrite,
       headers: {
         "Content-Type": "application/json",
         Authorization: `Bearer ${accessToken}`,
-        Accept: path.streaming(body) ? "text/event-stream" : "application/json",
+        Accept: body.stream ? "text/event-stream" : "application/json",
+        Connection: "Keep-Alive",
+        [codexHeaders.BETA]: codexHeaderValues.BETA_RESPONSES,
+        [codexHeaders.ORIGINATOR]: codexHeaderValues.ORIGINATOR,
+        "User-Agent": codexHeaderValues.USER_AGENT,
+        Version: codexHeaderValues.VERSION,
+        ...(accountId ? { [codexHeaders.ACCOUNT_ID]: accountId } : {}),
       },
     });
   },
 };
+
+/** 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);
+  if (creds?.accountId) return creds.accountId;
+
+  try {
+    const parts = accessToken.split(".");
+    if (parts.length < 2 || !parts[1]) return undefined;
+    const payload = JSON.parse(new TextDecoder().decode(fromBase64url(parts[1]))) as Record<string, unknown>;
+    const auth = payload["https://api.openai.com/auth"] as Record<string, unknown> | undefined;
+    return (auth?.["chatgpt_account_id"] as string) ?? undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/providers/gemini.ts

@@ -8,7 +8,7 @@ import { google as config } from "../auth/configs.ts";
 import * as oauth from "../auth/oauth.ts";
 import * as store from "../auth/store.ts";
 import { CODE_ASSIST_ENDPOINT } from "../constants.ts";
-import * as codeAssist from "../utils/code-assist.ts";
+import { buildUrl, maybeWrap, withUnwrap } from "../utils/code-assist.ts";
 import { logger } from "../utils/logger.ts";
 import * as path from "../utils/path.ts";
 import type { Provider } from "./base.ts";
@@ -53,31 +53,20 @@ export const provider: Provider = {
       return denied("Gemini CLI (unsupported path)");
     }
 
-    const url = codeAssist.buildUrl(CODE_ASSIST_ENDPOINT, gemini.action);
-    const requestBody = maybeWrap(body, projectId, gemini.model);
+    const url = buildUrl(CODE_ASSIST_ENDPOINT, gemini.action);
+    const requestBody = maybeWrap(body.parsed, body.forwardBody, projectId, gemini.model, {
+      userAgent: "pi-coding-agent",
+      requestIdPrefix: "pi",
+    });
     const unwrapThenRewrite = withUnwrap(rewrite);
 
-    return forward({ url, body: requestBody, headers, providerName: "Gemini CLI", rewrite: unwrapThenRewrite });
+    return forward({
+      url,
+      body: requestBody,
+      streaming: body.stream,
+      headers,
+      providerName: "Gemini CLI",
+      rewrite: unwrapThenRewrite,
+    });
   },
 };
-
-function withUnwrap(rewrite?: (d: string) => string): (d: string) => string {
-  return rewrite ? (d: string) => rewrite(codeAssist.unwrap(d)) : codeAssist.unwrap;
-}
-
-function maybeWrap(body: string, projectId: string, model: string): string {
-  try {
-    const parsed = JSON.parse(body) as Record<string, unknown>;
-    if (parsed["project"]) return body;
-    return codeAssist.wrapRequest({
-      projectId,
-      model,
-      body: parsed,
-      userAgent: "pi-coding-agent",
-      requestIdPrefix: "pi",
-    });
-  } catch (err) {
-    logger.debug("Body parse failed, forwarding as-is", { error: String(err) });
-    return body;
-  }
-}

package/src/routing/models.ts

@@ -0,0 +1,21 @@
+/** Centralized model name mapping: Amp CLI model → provider API model.
+ *  Amp's proxy may use aliased model names that differ from the provider's API.
+ *  This module resolves the correct model name and provides the serialized body. */
+
+/** Suffix patterns stripped when forwarding to the real provider API. */
+const STRIP_SUFFIXES = ["-api-preview"] as const;
+
+/** Resolve the model name the provider API expects.
+ *  Returns the original if no mapping applies. */
+export function resolveModel(ampModel: string): string {
+  for (const suffix of STRIP_SUFFIXES) {
+    if (ampModel.endsWith(suffix)) return ampModel.slice(0, -suffix.length);
+  }
+  return ampModel;
+}
+
+/** Return body string with provider model name substituted.
+ *  Shallow-copies parsed to avoid mutating the shared ParsedBody.parsed reference. */
+export function rewriteBodyModel(parsed: Record<string, unknown>, providerModel: string): string {
+  return JSON.stringify({ ...parsed, model: providerModel });
+}

package/src/server/body.ts

@@ -0,0 +1,70 @@
+/** Request body — parsed once, carried through the entire pipeline.
+ *  Fast path: regex extracts model + stream flag without JSON.parse.
+ *  Slow path: full parse only when Google providers need the parsed object (CCA wrapping)
+ *  or when model rewrite is needed (-api-preview). */
+
+import { resolveModel, rewriteBodyModel } from "../routing/models.ts";
+import * as path from "../utils/path.ts";
+
+export interface ParsedBody {
+  /** Original raw body string (for upstream fallback). */
+  readonly raw: string;
+  /** Amp model name from body.model (before mapping). */
+  readonly ampModel: string | null;
+  /** Whether body.stream === true. */
+  readonly stream: boolean;
+  /** Body string to send to provider (re-serialized only if model was remapped). */
+  readonly forwardBody: string;
+  /** Parsed JSON object — lazy, only materialized when accessed (Google CCA wrapping). */
+  readonly parsed: Record<string, unknown> | null;
+}
+
+/** Parse request body — JSON.parse for reliable model + stream extraction.
+ *  Parsed object is cached and reused by forwardBody and Google CCA wrapping. */
+export function parseBody(raw: string, sub: string): ParsedBody {
+  const fallbackModel = path.modelFromUrl(sub);
+  if (!raw) return { raw, parsed: null, ampModel: fallbackModel, stream: false, forwardBody: raw };
+
+  let _parsed: Record<string, unknown> | null | undefined;
+  function ensureParsed(): Record<string, unknown> | null {
+    if (_parsed === undefined) {
+      try {
+        _parsed = JSON.parse(raw) as Record<string, unknown>;
+      } catch {
+        _parsed = null;
+      }
+    }
+    return _parsed;
+  }
+
+  const parsed = ensureParsed();
+  const ampModel = (typeof parsed?.model === "string" ? parsed.model : null) ?? fallbackModel;
+  const stream = parsed?.stream === true;
+  const providerModel = ampModel ? resolveModel(ampModel) : null;
+  const needsRewrite = !!(ampModel && providerModel && providerModel !== ampModel);
+
+  let _forwardBody: string | undefined;
+  function ensureForwardBody(): string {
+    if (_forwardBody === undefined) {
+      if (needsRewrite) {
+        const p = ensureParsed();
+        _forwardBody = p ? rewriteBodyModel(p, providerModel!) : raw;
+      } else {
+        _forwardBody = raw;
+      }
+    }
+    return _forwardBody;
+  }
+
+  return {
+    raw,
+    ampModel,
+    stream,
+    get parsed() {
+      return ensureParsed();
+    },
+    get forwardBody() {
+      return ensureForwardBody();
+    },
+  };
+}

package/src/server/server.ts

@@ -5,8 +5,10 @@ import * as rewriter from "../proxy/rewriter.ts";
 import * as upstream from "../proxy/upstream.ts";
 import { parseRetryAfter, record429 } from "../routing/cooldown.ts";
 import { recordSuccess, rerouteAfter429, routeRequest } from "../routing/router.ts";
+import { handleInternal, isLocalMethod } from "../tools/internal.ts";
 import { logger } from "../utils/logger.ts";
 import * as path from "../utils/path.ts";
+import { parseBody } from "./body.ts";
 
 /** Max 429-reroute attempts before falling back to upstream. */
 const MAX_REROUTE_ATTEMPTS = 4;
@@ -52,6 +54,12 @@ async function handle(req: Request, config: ProxyConfig): Promise<Response> {
   }
 
   if (path.passthrough(pathname)) {
+    if (pathname.startsWith("/api/internal")) {
+      const search = new URL(req.url).search;
+      if (isLocalMethod(search)) {
+        return handleInternal(req, search, config);
+      }
+    }
     return upstream.forward(req, config.ampUpstreamUrl, config.ampApiKey);
   }
 
@@ -70,21 +78,20 @@ async function handleProvider(
   const sub = path.subpath(pathname);
   const threadId = req.headers.get("x-amp-thread-id") ?? undefined;
 
-  let body = "";
-  if (req.method === "POST") body = await req.text();
-
-  const model = path.model(body) ?? path.modelFromUrl(sub);
-  let route = routeRequest(providerName, model, config, threadId);
+  const rawBody = req.method === "POST" ? await req.text() : "";
+  const body = parseBody(rawBody, sub);
+  const ampModel = body.ampModel;
+  let route = routeRequest(providerName, ampModel, config, threadId);
 
   logger.info(
-    `ROUTE ${route.decision} provider=${providerName} model=${model ?? "?"} account=${route.account} sub=${sub}`,
+    `ROUTE ${route.decision} provider=${providerName} model=${ampModel ?? "?"} account=${route.account} sub=${sub}`,
   );
 
   if (route.handler) {
-    const rewrite = model ? rewriter.rewrite(model) : undefined;
+    const rewrite = ampModel ? rewriter.rewrite(ampModel) : undefined;
     const response = await route.handler.forward(sub, body, req.headers, rewrite, route.account);
 
-    // 429 → try to preserve prompt cache by waiting briefly on same account,
+    // 429 — try to preserve prompt cache by waiting briefly on same account,
     // then fall back to rerouting to a different account/pool.
     if (response.status === 429 && route.pool) {
       const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
@@ -108,11 +115,11 @@ async function handleProvider(
 
       // Reroute to different account/pool (cache loss accepted)
       for (let attempt = 0; attempt < MAX_REROUTE_ATTEMPTS; attempt++) {
-        const next = rerouteAfter429(providerName, model, config, route.pool, route.account, retryAfter, threadId);
+        const next = rerouteAfter429(providerName, ampModel, config, route.pool, route.account, retryAfter, threadId);
         if (!next) break;
 
         route = next;
-        logger.info(`REROUTE → ${route.decision} account=${route.account}`);
+        logger.info(`REROUTE -> ${route.decision} account=${route.account}`);
         const retryResponse = await route.handler!.forward(sub, body, req.headers, rewrite, route.account);
 
         if (retryResponse.status === 429 && route.pool) {
@@ -140,7 +147,7 @@ async function handleProvider(
   const upstreamReq = new Request(req.url, {
     method: req.method,
     headers: req.headers,
-    body: body || undefined,
+    body: body.raw || undefined,
   });
   return upstream.forward(upstreamReq, config.ampUpstreamUrl, config.ampApiKey);
 }

package/src/tools/internal.ts

@@ -0,0 +1,72 @@
+/** Dispatcher for /api/internal?{method} — routes to local handlers or upstream. */
+
+import type { ProxyConfig } from "../config/config.ts";
+import * as upstream from "../proxy/upstream.ts";
+import { logger } from "../utils/logger.ts";
+import { handleExtract } from "./web-extract.ts";
+import { handleSearch } from "./web-search.ts";
+
+/** Methods handled locally instead of forwarding to Amp upstream. */
+const LOCAL_METHODS = new Set(["extractWebPageContent", "webSearch2"]);
+
+/** Check if an internal method should be handled locally. */
+export function isLocalMethod(search: string): boolean {
+  const method = search.replace("?", "");
+  return LOCAL_METHODS.has(method);
+}
+
+/** Handle an internal RPC call locally. Returns null if method is unknown. */
+export async function handleInternal(req: Request, search: string, config: ProxyConfig): Promise<Response> {
+  const method = search.replace("?", "");
+  const body = req.method === "POST" ? await req.text() : "";
+
+  let params: Record<string, unknown> = {};
+  try {
+    const parsed = JSON.parse(body);
+    params = parsed.params ?? {};
+  } catch {
+    return jsonResponse({ ok: false, error: { code: "invalid-body", message: "Invalid JSON body" } });
+  }
+
+  logger.info(`[INTERNAL] ${method} params=${JSON.stringify(params).slice(0, 200)}`);
+
+  switch (method) {
+    case "extractWebPageContent": {
+      const result = await handleExtract({
+        url: params.url as string,
+        objective: params.objective as string | undefined,
+        forceRefetch: params.forceRefetch as boolean | undefined,
+      });
+      return jsonResponse(result);
+    }
+    case "webSearch2": {
+      if (!config.exaApiKey) {
+        logger.warn("webSearch2 called but no exaApiKey configured, forwarding upstream");
+        return upstream.forward(rebuildRequest(req, body), config.ampUpstreamUrl, config.ampApiKey);
+      }
+      const result = await handleSearch(
+        {
+          objective: params.objective as string,
+          searchQueries: params.searchQueries as string[] | undefined,
+          maxResults: params.maxResults as number | undefined,
+        },
+        config.exaApiKey,
+      );
+      return jsonResponse(result);
+    }
+    default:
+      return upstream.forward(req, config.ampUpstreamUrl, config.ampApiKey);
+  }
+}
+
+/** Rebuild request with already-consumed body for upstream forwarding. */
+function rebuildRequest(req: Request, body: string): Request {
+  return new Request(req.url, { method: req.method, headers: req.headers, body: body || undefined });
+}
+
+function jsonResponse(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}

package/src/tools/web-extract.ts

@@ -0,0 +1,137 @@
+/** Local handler for extractWebPageContent — fetches a URL and converts HTML to Markdown. */
+
+import type { JsPreprocessingPreset } from "@kreuzberg/html-to-markdown";
+import { convertWithOptionsHandle, createConversionOptionsHandle } from "@kreuzberg/html-to-markdown";
+import { logger } from "../utils/logger.ts";
+
+const FETCH_TIMEOUT_MS = 30_000;
+const MAX_CONTENT_BYTES = 262_144; // 256 KB — matches CLI truncation limit
+
+const conversionHandle = createConversionOptionsHandle({
+  skipImages: true,
+  preprocessing: { enabled: true, preset: "Aggressive" as JsPreprocessingPreset },
+});
+
+export interface ExtractParams {
+  url: string;
+  objective?: string;
+  forceRefetch?: boolean;
+}
+
+type ExtractResult =
+  | { ok: true; result: { excerpts: string[] } }
+  | { ok: true; result: { fullContent: string } }
+  | { ok: false; error: { code: string; message: string } };
+
+export async function handleExtract(params: ExtractParams): Promise<ExtractResult> {
+  const { url, objective } = params;
+
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      redirect: "follow",
+      headers: { "User-Agent": "Mozilla/5.0 (compatible; AmpBot/1.0)" },
+    });
+  } catch (err) {
+    logger.warn("extractWebPageContent fetch failed", { url, error: String(err) });
+    return { ok: false, error: { code: "fetch-error", message: `Failed to fetch ${url}: ${String(err)}` } };
+  }
+
+  if (!response.ok) {
+    return {
+      ok: false,
+      error: { code: "fetch-error", message: `HTTP ${response.status} from ${url}` },
+    };
+  }
+
+  const raw = await response.text();
+  const contentType = response.headers.get("content-type") ?? "";
+  const markdown = toMarkdown(raw, contentType);
+
+  if (objective) {
+    const excerpts = extractExcerpts(markdown, objective);
+    return { ok: true, result: { excerpts } };
+  }
+
+  return { ok: true, result: { fullContent: truncate(markdown) } };
+}
+
+/** Convert raw response body to Markdown based on content type. */
+function toMarkdown(raw: string, contentType: string): string {
+  if (contentType.includes("text/html") || contentType.includes("application/xhtml")) {
+    return convertWithOptionsHandle(raw, conversionHandle);
+  }
+  if (contentType.includes("application/json")) {
+    try {
+      return `\`\`\`json\n${JSON.stringify(JSON.parse(raw), null, 2)}\n\`\`\``;
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+
+/** Split markdown into paragraphs, score by keyword overlap with objective, return top excerpts. */
+function extractExcerpts(markdown: string, objective: string): string[] {
+  const paragraphs = markdown
+    .split(/\n{2,}/)
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0);
+
+  if (paragraphs.length === 0) return [truncate(markdown)];
+
+  const keywords = objective
+    .toLowerCase()
+    .split(/\W+/)
+    .filter((w) => w.length > 2);
+
+  if (keywords.length === 0) return [truncate(markdown)];
+
+  const scored = paragraphs.map((p, index) => {
+    const lower = p.toLowerCase();
+    const score = keywords.reduce((s, kw) => s + (lower.includes(kw) ? 1 : 0), 0);
+    return { text: p, score, index };
+  });
+
+  const matched = scored.filter((s) => s.score > 0);
+
+  // If nothing matched, return full content as single excerpt
+  if (matched.length === 0) return [truncate(markdown)];
+
+  // Sort by score desc, take top entries, then restore original order
+  matched.sort((a, b) => b.score - a.score || a.index - b.index);
+  const top = matched.slice(0, 20);
+  top.sort((a, b) => a.index - b.index);
+
+  const joined = top.map((s) => s.text);
+  return truncateExcerpts(joined);
+}
+
+/** Truncate a string to MAX_CONTENT_BYTES. */
+function truncate(text: string): string {
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(text);
+  if (bytes.length <= MAX_CONTENT_BYTES) return text;
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  return decoder.decode(bytes.slice(0, MAX_CONTENT_BYTES));
+}
+
+/** Truncate excerpt array so total joined size stays within limit. */
+function truncateExcerpts(excerpts: string[]): string[] {
+  const encoder = new TextEncoder();
+  let total = 0;
+  const result: string[] = [];
+  for (const e of excerpts) {
+    const len = encoder.encode(e).length + 2; // +2 for \n\n join
+    if (total + len > MAX_CONTENT_BYTES) {
+      // Add truncated last excerpt if there's room
+      const remaining = MAX_CONTENT_BYTES - total;
+      if (remaining > 100) result.push(truncate(e));
+      break;
+    }
+    result.push(e);
+    total += len;
+  }
+  return result.length > 0 ? result : [truncate(excerpts[0]!)];
+}

package/src/tools/web-search.ts

@@ -0,0 +1,48 @@
+/** Local handler for webSearch2 — searches via Exa API. */
+
+import Exa from "exa-js";
+import { logger } from "../utils/logger.ts";
+
+export interface SearchParams {
+  objective: string;
+  searchQueries?: string[];
+  maxResults?: number;
+}
+
+interface SearchResultItem {
+  title: string;
+  url: string;
+  excerpts: string[];
+}
+
+type SearchResult =
+  | { ok: true; result: { results: SearchResultItem[]; showParallelAttribution: boolean } }
+  | { ok: false; error: { code: string; message: string } };
+
+export async function handleSearch(params: SearchParams, exaApiKey: string): Promise<SearchResult> {
+  const { objective, searchQueries, maxResults = 5 } = params;
+  const query = searchQueries?.length ? searchQueries.join(" ") : objective;
+
+  try {
+    const exa = new Exa(exaApiKey);
+    const response = await exa.search(query, {
+      numResults: maxResults,
+      type: "auto",
+      contents: {
+        highlights: { query: objective },
+      },
+    });
+
+    const results: SearchResultItem[] = response.results.map((r) => ({
+      title: r.title ?? "",
+      url: r.url,
+      excerpts: r.highlights?.length ? r.highlights : [],
+    }));
+
+    logger.info(`[SEARCH] Exa returned ${results.length} results for "${query.slice(0, 80)}"`);
+    return { ok: true, result: { results, showParallelAttribution: false } };
+  } catch (err) {
+    logger.error("webSearch2 Exa error", { error: String(err) });
+    return { ok: false, error: { code: "search-error", message: String(err) } };
+  }
+}

package/src/utils/code-assist.ts

@@ -40,3 +40,21 @@ export function unwrap(data: string): string {
     return data;
   }
 }
+
+/** Chain CCA unwrap with an optional rewrite function. */
+export function withUnwrap(rewrite?: (d: string) => string): (d: string) => string {
+  return rewrite ? (d: string) => rewrite(unwrap(d)) : unwrap;
+}
+
+/** Wrap body in CCA envelope if not already wrapped. */
+export function maybeWrap(
+  parsed: Record<string, unknown> | null,
+  raw: string,
+  projectId: string,
+  model: string,
+  opts: { userAgent: "antigravity" | "pi-coding-agent"; requestIdPrefix: "agent" | "pi"; requestType?: "agent" },
+): string {
+  if (!parsed) return raw;
+  if (parsed["project"]) return raw;
+  return wrapRequest({ projectId, model, body: parsed, ...opts });
+}

package/src/utils/logger.ts

@@ -13,6 +13,7 @@ interface LogEntry {
   model?: string;
   duration?: number;
   error?: string;
+  [key: string]: unknown;
 }
 
 const LOG_LEVELS: Record<LogLevel, number> = {

package/src/utils/path.ts

@@ -22,15 +22,6 @@ export function subpath(pathname: string): string {
   return match?.[1] ?? pathname;
 }
 
-export function model(body: string): string | null {
-  try {
-    const parsed = JSON.parse(body) as { model?: string };
-    return parsed.model ?? null;
-  } catch {
-    return null;
-  }
-}
-
 export function modelFromUrl(url: string): string | null {
   const match = url.match(/models\/([^/:]+)/);
   return match?.[1] ?? null;
@@ -41,12 +32,3 @@ export function gemini(url: string): { model: string; action: string } | null {
   if (!match) return null;
   return { model: match[1]!, action: match[2]! };
 }
-
-export function streaming(body: string): boolean {
-  try {
-    const parsed = JSON.parse(body) as { stream?: boolean };
-    return parsed.stream === true;
-  } catch {
-    return false;
-  }
-}

package/src/utils/update-check.ts

@@ -1,6 +1,6 @@
 /** Check npm registry for newer versions on startup. */
 
-import { s, line } from "../cli/ansi.ts";
+import { line, s } from "../cli/ansi.ts";
 
 const PACKAGE_NAME = "ampcode-connector";
 const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
@@ -27,8 +27,8 @@ async function fetchLatestVersion(): Promise<string | null> {
 
 function isNewer(latest: string, current: string): boolean {
   const parse = (v: string) => v.split(".").map(Number);
-  const [la, lb, lc] = parse(latest);
-  const [ca, cb, cc] = parse(current);
+  const [la = 0, lb = 0, lc = 0] = parse(latest);
+  const [ca = 0, cb = 0, cc = 0] = parse(current);
   return la > ca || (la === ca && lb > cb) || (la === ca && lb === cb && lc > cc);
 }