ampcode-connector 0.1.4 → 0.1.6

package/src/routing/cooldown.ts

@@ -11,8 +11,6 @@ interface CooldownEntry {
   consecutive429: number;
 }
 
-/** Consecutive 429s within this window count toward exhaustion detection. */
-const CONSECUTIVE_WINDOW_MS = 2 * 60_000;
 /** When detected as exhausted, cooldown for this long. */
 const EXHAUSTED_COOLDOWN_MS = 2 * 3600_000;
 /** Retry-After threshold (seconds) above which we consider quota exhausted. */
@@ -29,20 +27,22 @@ function key(pool: QuotaPool, account: number): string {
 }
 
 export function isCoolingDown(pool: QuotaPool, account: number): boolean {
-  const entry = entries.get(key(pool, account));
+  const k = key(pool, account);
+  const entry = entries.get(k);
   if (!entry) return false;
   if (Date.now() >= entry.until) {
-    entries.delete(key(pool, account));
+    entries.delete(k);
     return false;
   }
   return true;
 }
 
 export function isExhausted(pool: QuotaPool, account: number): boolean {
-  const entry = entries.get(key(pool, account));
+  const k = key(pool, account);
+  const entry = entries.get(k);
   if (!entry) return false;
   if (Date.now() >= entry.until) {
-    entries.delete(key(pool, account));
+    entries.delete(k);
     return false;
   }
   return entry.exhausted;

package/src/routing/retry.ts

@@ -0,0 +1,83 @@
+/** Retry logic: cache-preserving wait + reroute after 429. */
+
+import type { ProxyConfig } from "../config/config.ts";
+import type { ParsedBody } from "../server/body.ts";
+import { logger } from "../utils/logger.ts";
+import { parseRetryAfter, record429 } from "./cooldown.ts";
+import { type RouteResult, recordSuccess, rerouteAfter429 } from "./router.ts";
+
+/** Max 429-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. */
+export async function tryWithCachePreserve(
+  route: RouteResult,
+  sub: string,
+  body: ParsedBody,
+  headers: Headers,
+  rewrite: ((data: string) => string) | undefined,
+  initialResponse: Response,
+): Promise<Response | null> {
+  const retryAfter = parseRetryAfter(initialResponse.headers.get("retry-after"));
+  if (retryAfter === undefined || retryAfter > CACHE_PRESERVE_WAIT_MAX_S) return null;
+
+  logger.debug(`Waiting ${retryAfter}s to preserve prompt cache on account=${route.account}`);
+  await Bun.sleep(retryAfter * 1000);
+  const response = await route.handler!.forward(sub, body, headers, rewrite, route.account);
+
+  if (response.status !== 429 && response.status !== 401) {
+    recordSuccess(route.pool!, route.account);
+    return response;
+  }
+  if (response.status === 429) {
+    const nextRetryAfter = parseRetryAfter(response.headers.get("retry-after"));
+    record429(route.pool!, route.account, nextRetryAfter);
+  }
+  return null;
+}
+
+/** Reroute to different accounts/pools after 429 (cache loss accepted). */
+export async function tryReroute(
+  providerName: string,
+  ampModel: string | null,
+  config: ProxyConfig,
+  initialRoute: RouteResult,
+  sub: string,
+  body: ParsedBody,
+  headers: Headers,
+  rewrite: ((data: string) => string) | undefined,
+  initialResponse: Response,
+  threadId?: string,
+): Promise<Response | null> {
+  const retryAfter = parseRetryAfter(initialResponse.headers.get("retry-after"));
+  logger.warn(`429 from ${initialRoute.decision} account=${initialRoute.account}`, { retryAfter });
+
+  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;
+
+    logger.info(`REROUTE -> ${next.decision} account=${next.account}`);
+    const response = await next.handler!.forward(sub, body, headers, rewrite, next.account);
+
+    if (response.status === 429 && next.pool) {
+      const nextRetryAfter = parseRetryAfter(response.headers.get("retry-after"));
+      record429(next.pool, next.account, nextRetryAfter);
+      currentPool = next.pool;
+      currentAccount = next.account;
+      continue;
+    }
+
+    if (response.status !== 401) {
+      if (next.pool) recordSuccess(next.pool, next.account);
+      return response;
+    }
+    break;
+  }
+
+  return null;
+}

package/src/routing/router.ts

@@ -21,6 +21,48 @@ import * as affinity from "./affinity.ts";
 import type { QuotaPool } from "./cooldown.ts";
 import * as cooldown from "./cooldown.ts";
 
+interface ProviderEntry {
+  provider: Provider;
+  pool: QuotaPool;
+  credentialName: ProviderName;
+}
+
+/** Maps ampProvider name → list of provider entries (checked against config at lookup time). */
+const PROVIDER_REGISTRY = new Map<string, { configKey: keyof ProxyConfig["providers"]; entries: ProviderEntry[] }>([
+  [
+    "anthropic",
+    {
+      configKey: "anthropic",
+      entries: [{ provider: anthropic, pool: "anthropic", credentialName: "anthropic" }],
+    },
+  ],
+  [
+    "openai",
+    {
+      configKey: "codex",
+      entries: [{ provider: codex, pool: "codex", credentialName: "codex" }],
+    },
+  ],
+  [
+    "google",
+    {
+      configKey: "google",
+      entries: [
+        { provider: gemini, pool: "gemini", credentialName: "google" },
+        { provider: antigravity, pool: "antigravity", credentialName: "google" },
+      ],
+    },
+  ],
+]);
+
+/** Reverse map: QuotaPool → Provider (built once at module init). */
+const POOL_TO_PROVIDER = new Map<QuotaPool, Provider>();
+for (const [, { entries }] of PROVIDER_REGISTRY) {
+  for (const entry of entries) {
+    POOL_TO_PROVIDER.set(entry.pool, entry.provider);
+  }
+}
+
 export interface RouteResult {
   decision: RouteDecision;
   provider: string;
@@ -49,7 +91,7 @@ export function routeRequest(
     const pinned = affinity.get(threadId, ampProvider);
     if (pinned && !cooldown.isExhausted(pinned.pool, pinned.account)) {
       const handler = providerForPool(pinned.pool);
-      if (handler && handler.isAvailable(pinned.account)) {
+      if (handler?.isAvailable(pinned.account)) {
         if (!cooldown.isCoolingDown(pinned.pool, pinned.account)) {
           logger.route(handler.routeDecision, ampProvider, modelStr);
           return result(handler, ampProvider, modelStr, pinned.account, pinned.pool);
@@ -116,30 +158,13 @@ export function recordSuccess(pool: QuotaPool, account: number): void {
 }
 
 function buildCandidates(ampProvider: string, config: ProxyConfig): Candidate[] {
-  const candidates: Candidate[] = [];
+  const reg = PROVIDER_REGISTRY.get(ampProvider);
+  if (!reg || !config.providers[reg.configKey]) return [];
 
-  switch (ampProvider) {
-    case "anthropic":
-      if (config.providers.anthropic) {
-        addAccountCandidates(candidates, anthropic, "anthropic", "anthropic");
-      }
-      break;
-
-    case "openai":
-      if (config.providers.codex) {
-        addAccountCandidates(candidates, codex, "codex", "codex");
-      }
-      break;
-
-    case "google":
-      if (config.providers.google) {
-        // Both gemini and antigravity use "google" credentials — separate quota pools
-        addAccountCandidates(candidates, gemini, "gemini", "google");
-        addAccountCandidates(candidates, antigravity, "antigravity", "google");
-      }
-      break;
+  const candidates: Candidate[] = [];
+  for (const entry of reg.entries) {
+    addAccountCandidates(candidates, entry.provider, entry.pool, entry.credentialName);
   }
-
   return candidates;
 }
 
@@ -177,16 +202,7 @@ function pickCandidate(candidates: Candidate[]): Candidate | null {
 }
 
 function providerForPool(pool: QuotaPool): Provider | null {
-  switch (pool) {
-    case "anthropic":
-      return anthropic;
-    case "codex":
-      return codex;
-    case "gemini":
-      return gemini;
-    case "antigravity":
-      return antigravity;
-  }
+  return POOL_TO_PROVIDER.get(pool) ?? null;
 }
 
 function result(

package/src/server/body.ts

@@ -1,7 +1,7 @@
-/** Request body — parsed once, carried through the entire pipeline.
+/** Request body — lazy parsing with regex fast path.
  *  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). */
+ *  Slow path: full JSON.parse only when .parsed or .forwardBody is accessed
+ *  (e.g. Google CCA wrapping, model rewrite). */
 
 import { resolveModel, rewriteBodyModel } from "../routing/models.ts";
 import * as path from "../utils/path.ts";
@@ -19,12 +19,19 @@ export interface ParsedBody {
   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. */
+/** Fast-path regex to extract "model" and "stream" without JSON.parse. */
+const MODEL_RE = /"model"\s*:\s*"([^"]+)"/;
+const STREAM_RE = /"stream"\s*:\s*true\b/;
+
 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 };
 
+  const ampModel = raw.match(MODEL_RE)?.[1] ?? fallbackModel;
+  const stream = STREAM_RE.test(raw);
+  const providerModel = ampModel ? resolveModel(ampModel) : null;
+  const needsRewrite = !!(ampModel && providerModel && providerModel !== ampModel);
+
   let _parsed: Record<string, unknown> | null | undefined;
   function ensureParsed(): Record<string, unknown> | null {
     if (_parsed === undefined) {
@@ -37,12 +44,6 @@ export function parseBody(raw: string, sub: string): ParsedBody {
     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) {

package/src/server/server.ts

@@ -3,17 +3,14 @@
 import type { ProxyConfig } from "../config/config.ts";
 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 { startCleanup } from "../routing/affinity.ts";
+import { tryReroute, tryWithCachePreserve } from "../routing/retry.ts";
+import { recordSuccess, 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;
-/** Max seconds to wait-and-retry on the same account (preserves prompt cache). */
-const CACHE_PRESERVE_WAIT_MAX_S = 10;
+import { record, snapshot } from "../utils/stats.ts";
+import { type ParsedBody, parseBody } from "./body.ts";
 
 export function startServer(config: ProxyConfig): ReturnType<typeof Bun.serve> {
   const server = Bun.serve({
@@ -22,43 +19,51 @@ export function startServer(config: ProxyConfig): ReturnType<typeof Bun.serve> {
 
     async fetch(req) {
       const startTime = Date.now();
+      const url = new URL(req.url);
+      let status = 500;
       try {
-        const response = await handle(req, config);
-        logRequest(req, startTime, response.status);
+        const response = await handle(req, url, config);
+        status = response.status;
         return response;
       } catch (err) {
-        logRequest(req, startTime, 500);
         logger.error("Unhandled server error", { error: String(err) });
-        return new Response(JSON.stringify({ error: "Internal proxy error" }), {
-          status: 500,
-          headers: { "Content-Type": "application/json" },
-        });
+        return Response.json({ error: "Internal proxy error" }, { status });
+      } finally {
+        logger.info(`${req.method} ${url.pathname} ${status}`, { duration: Date.now() - startTime });
       }
     },
   });
 
+  startCleanup();
   logger.info(`ampcode-connector listening on http://localhost:${config.port}`);
+
+  const shutdown = () => {
+    logger.info("Shutting down...");
+    server.stop();
+    process.exit(0);
+  };
+
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+
   return server;
 }
 
-async function handle(req: Request, config: ProxyConfig): Promise<Response> {
-  const { pathname } = new URL(req.url);
+async function handle(req: Request, url: URL, config: ProxyConfig): Promise<Response> {
+  const { pathname, search } = url;
 
   if ((pathname === "/" || pathname === "/status") && req.method === "GET") {
     return healthCheck(config);
   }
 
   if (path.browser(pathname)) {
-    const target = new URL(pathname + new URL(req.url).search, config.ampUpstreamUrl);
+    const target = new URL(pathname + search, config.ampUpstreamUrl);
     return Response.redirect(target.toString(), 302);
   }
 
   if (path.passthrough(pathname)) {
-    if (pathname.startsWith("/api/internal")) {
-      const search = new URL(req.url).search;
-      if (isLocalMethod(search)) {
-        return handleInternal(req, search, config);
-      }
+    if (pathname.startsWith("/api/internal") && isLocalMethod(search)) {
+      return handleInternal(req, search, config);
     }
     return upstream.forward(req, config.ampUpstreamUrl, config.ampApiKey);
   }
@@ -75,75 +80,69 @@ async function handleProvider(
   pathname: string,
   config: ProxyConfig,
 ): Promise<Response> {
+  const startTime = Date.now();
   const sub = path.subpath(pathname);
   const threadId = req.headers.get("x-amp-thread-id") ?? undefined;
 
   const rawBody = req.method === "POST" ? await req.text() : "";
   const body = parseBody(rawBody, sub);
   const ampModel = body.ampModel;
-  let route = routeRequest(providerName, ampModel, config, threadId);
+  const route = routeRequest(providerName, ampModel, config, threadId);
 
   logger.info(
     `ROUTE ${route.decision} provider=${providerName} model=${ampModel ?? "?"} account=${route.account} sub=${sub}`,
   );
 
+  let response: Response;
+
   if (route.handler) {
     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,
-    // then fall back to rerouting to a different account/pool.
-    if (response.status === 429 && route.pool) {
-      const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
-      logger.warn(`429 from ${route.decision} account=${route.account}`, { retryAfter });
-
-      // Short burst: wait and retry same account to preserve prompt cache
-      if (retryAfter !== undefined && retryAfter <= CACHE_PRESERVE_WAIT_MAX_S) {
-        logger.debug(`Waiting ${retryAfter}s to preserve prompt cache on account=${route.account}`);
-        await Bun.sleep(retryAfter * 1000);
-        const retryResponse = await route.handler.forward(sub, body, req.headers, rewrite, route.account);
-        if (retryResponse.status !== 429 && retryResponse.status !== 401) {
-          recordSuccess(route.pool, route.account);
-          return retryResponse;
-        }
-        // Still failing — fall through to reroute
-        if (retryResponse.status === 429) {
-          const nextRetryAfter = parseRetryAfter(retryResponse.headers.get("retry-after"));
-          record429(route.pool, route.account, nextRetryAfter);
-        }
-      }
-
-      // Reroute to different account/pool (cache loss accepted)
-      for (let attempt = 0; attempt < MAX_REROUTE_ATTEMPTS; attempt++) {
-        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}`);
-        const retryResponse = await route.handler!.forward(sub, body, req.headers, rewrite, route.account);
-
-        if (retryResponse.status === 429 && route.pool) {
-          const nextRetryAfter = parseRetryAfter(retryResponse.headers.get("retry-after"));
-          record429(route.pool, route.account, nextRetryAfter);
-          continue;
-        }
-
-        if (retryResponse.status !== 401) {
-          if (route.pool) recordSuccess(route.pool, route.account);
-          return retryResponse;
-        }
-        break;
+    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 (cached) {
+        response = cached;
+      } else {
+        const rerouted = await tryReroute(
+          providerName,
+          ampModel,
+          config,
+          route,
+          sub,
+          body,
+          req.headers,
+          rewrite,
+          handlerResponse,
+          threadId,
+        );
+        response = rerouted ?? (await fallbackUpstream(req, body, config));
       }
-
-      // All reroutes failed — fall through to upstream
-    } else if (response.status === 401) {
+    } else if (handlerResponse.status === 401) {
       logger.debug("Local provider denied, falling back to upstream");
+      response = await fallbackUpstream(req, body, config);
     } else {
       if (route.pool) recordSuccess(route.pool, route.account);
-      return response;
+      response = handlerResponse;
     }
+  } else {
+    response = await fallbackUpstream(req, body, config);
   }
 
+  record({
+    timestamp: new Date().toISOString(),
+    route: route.decision,
+    provider: providerName,
+    model: ampModel ?? "unknown",
+    statusCode: response.status,
+    durationMs: Date.now() - startTime,
+  });
+
+  return response;
+}
+
+/** Fall back to Amp upstream when local providers fail. */
+function fallbackUpstream(req: Request, body: ParsedBody, config: ProxyConfig): Promise<Response> {
   const upstreamReq = new Request(req.url, {
     method: req.method,
     headers: req.headers,
@@ -153,24 +152,12 @@ async function handleProvider(
 }
 
 function healthCheck(config: ProxyConfig): Response {
-  return new Response(
-    JSON.stringify(
-      {
-        status: "ok",
-        service: "ampcode-connector",
-        port: config.port,
-        upstream: config.ampUpstreamUrl,
-        providers: config.providers,
-      },
-      null,
-      2,
-    ),
-    { status: 200, headers: { "Content-Type": "application/json" } },
-  );
-}
-
-function logRequest(req: Request, startTime: number, statusCode: number): void {
-  const duration = Date.now() - startTime;
-  const { pathname } = new URL(req.url);
-  logger.info(`${req.method} ${pathname}`, { duration });
+  return Response.json({
+    status: "ok",
+    service: "ampcode-connector",
+    port: config.port,
+    upstream: config.ampUpstreamUrl,
+    providers: config.providers,
+    stats: snapshot(),
+  });
 }

package/src/tools/internal.ts

@@ -3,70 +3,93 @@
 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 { handleWebRead } from "./web-read.ts";
 import { handleSearch } from "./web-search.ts";
 
-/** Methods handled locally instead of forwarding to Amp upstream. */
-const LOCAL_METHODS = new Set(["extractWebPageContent", "webSearch2"]);
+interface HandlerContext {
+  params: Record<string, unknown>;
+  config: ProxyConfig;
+  forward: () => Promise<Response>;
+}
+
+type Handler = (ctx: HandlerContext) => Promise<Response>;
+
+const handlers: Record<string, Handler> = {
+  extractWebPageContent: async ({ params }) => {
+    const url = str(params, "url");
+    if (!url) return error("invalid-params", "missing 'url'");
+    return json(
+      await handleWebRead({ url, objective: str(params, "objective"), forceRefetch: bool(params, "forceRefetch") }),
+    );
+  },
+
+  webSearch2: async ({ params, config, forward }) => {
+    if (!config.exaApiKey) {
+      logger.warn("webSearch2: no exaApiKey configured, forwarding upstream");
+      return forward();
+    }
+    const objective = str(params, "objective");
+    if (!objective) return error("invalid-params", "missing 'objective'");
+    return handleSearch(
+      { objective, searchQueries: strArray(params, "searchQueries"), maxResults: num(params, "maxResults") },
+      config.exaApiKey,
+    ).then(json, (err) => {
+      logger.warn("webSearch2 local failed, falling back to upstream", { error: String(err) });
+      return forward();
+    });
+  },
+};
 
-/** Check if an internal method should be handled locally. */
 export function isLocalMethod(search: string): boolean {
-  const method = search.replace("?", "");
-  return LOCAL_METHODS.has(method);
+  return search.replace("?", "") in handlers;
 }
 
-/** 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> = {};
+  let params: Record<string, unknown>;
   try {
-    const parsed = JSON.parse(body);
-    params = parsed.params ?? {};
+    params = JSON.parse(body).params ?? {};
   } catch {
-    return jsonResponse({ ok: false, error: { code: "invalid-body", message: "Invalid JSON body" } });
+    return error("invalid-body", "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);
-  }
+  const forward = () => {
+    const rebuilt = new Request(req.url, { method: req.method, headers: req.headers, body: body || undefined });
+    return upstream.forward(rebuilt, config.ampUpstreamUrl, config.ampApiKey);
+  };
+
+  const handler = handlers[method];
+  return handler ? handler({ params, config, forward }) : forward();
+}
+
+function str(p: Record<string, unknown>, k: string): string | undefined {
+  const v = p[k];
+  return typeof v === "string" ? v : undefined;
+}
+
+function num(p: Record<string, unknown>, k: string): number | undefined {
+  const v = p[k];
+  return typeof v === "number" ? v : undefined;
+}
+
+function bool(p: Record<string, unknown>, k: string): boolean | undefined {
+  const v = p[k];
+  return typeof v === "boolean" ? v : undefined;
+}
+
+function strArray(p: Record<string, unknown>, k: string): string[] | undefined {
+  const v = p[k];
+  return Array.isArray(v) && v.every((i: unknown) => typeof i === "string") ? (v as string[]) : undefined;
 }
 
-/** 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 json(data: unknown): Response {
+  return Response.json(data);
 }
 
-function jsonResponse(data: unknown, status = 200): Response {
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json" },
-  });
+function error(code: string, message: string): Response {
+  return Response.json({ ok: false, error: { code, message } });
 }