@ar-ai/brink-cli 0.0.0-stage → 1.0.6

package/support/proxy.js

@@ -0,0 +1,480 @@
+"use strict";
+
+const http = require("http");
+const { bridgeResponses } = require("./chat-bridge");
+const { bridgeMessages } = require("./messages-bridge");
+const { adaptModelCatalog } = require("./model-catalog");
+const { createMonitor } = require("./monitor");
+const { startTerminalUI } = require("./terminal-ui");
+const { createUsageObserver } = require("./usage");
+const {
+  cleanHeaders,
+  createUpstreamAgent,
+  requestWithRetries,
+  upstreamFailure,
+} = require("./transport");
+
+const LISTEN_HOST = "127.0.0.1";
+const LISTEN_PORT = Number(process.env.AGENTROUTER_PROXY_PORT || 8787);
+const UPSTREAM_ORIGIN = "https://agentrouter.org";
+const UPSTREAM_API_PREFIX = "/v1";
+const MAX_REQUEST_BYTES = 32 * 1024 * 1024;
+const MAX_CATALOG_BYTES = 8 * 1024 * 1024;
+const agent = createUpstreamAgent();
+const monitor = createMonitor({ port: LISTEN_PORT });
+let terminalUI;
+
+function sanitizeRequest(payload) {
+  let removedIds = 0;
+  let removedEncryptedContent = 0;
+  let removedReferences = 0;
+  let input;
+  if (Array.isArray(payload.input)) {
+    for (let index = 0; index < payload.input.length; index++) {
+      const item = payload.input[index];
+      if (!item || typeof item !== "object") {
+        if (input) input.push(item);
+        continue;
+      }
+      // References must be checked before removing their IDs. Tool call_id
+      // fields remain untouched: they link coding tool calls and results.
+      if (
+        item.type === "item_reference" &&
+        typeof item.id === "string" &&
+        item.id.startsWith("rs_")
+      ) {
+        if (!input) input = payload.input.slice(0, index);
+        removedReferences++;
+        continue;
+      }
+      const removeId = typeof item.id === "string" && item.id.length > 0;
+      const removeEncrypted =
+        item.type === "reasoning" &&
+        Object.prototype.hasOwnProperty.call(item, "encrypted_content");
+      if (!removeId && !removeEncrypted) {
+        if (input) input.push(item);
+        continue;
+      }
+      if (!input) input = payload.input.slice(0, index);
+      const cleaned = { ...item };
+      if (removeId) {
+        delete cleaned.id;
+        removedIds++;
+      }
+      if (removeEncrypted) {
+        delete cleaned.encrypted_content;
+        removedEncryptedContent++;
+      }
+      input.push(cleaned);
+    }
+  }
+  return {
+    payload: input ? { ...payload, input } : payload,
+    removedIds,
+    removedEncryptedContent,
+    removedReferences,
+  };
+}
+
+// AgentRouter's GLM channel rejects reasoning efforts outside low/high/max
+// ("this model always thinks; disabling thinking is not supported"). T3 sends
+// medium by default, so map disallowed efforts to the nearest allowed value
+// instead of letting the request fail and trigger client-side paid retries.
+const GLM_ALLOWED_EFFORTS = new Set(["low", "high", "max"]);
+const GLM_EFFORT_FALLBACK = {
+  none: "low",
+  minimal: "low",
+  medium: "high",
+  xhigh: "max",
+  ultra: "max",
+  persistent: "max",
+};
+
+function normalizeReasoningEffort(payload) {
+  if (typeof payload?.model !== "string" || !payload.model.startsWith("glm-"))
+    return null;
+  const reasoning = payload.reasoning;
+  if (
+    !reasoning ||
+    typeof reasoning !== "object" ||
+    typeof reasoning.effort !== "string" ||
+    GLM_ALLOWED_EFFORTS.has(reasoning.effort)
+  )
+    return null;
+  return {
+    from: reasoning.effort,
+    to: GLM_EFFORT_FALLBACK[reasoning.effort] ?? "high",
+  };
+}
+
+function getUpstreamPath(clientPath) {
+  if (typeof clientPath !== "string" || clientPath.length === 0)
+    return `${UPSTREAM_API_PREFIX}/responses`;
+  if (clientPath === "/v1" || clientPath.startsWith("/v1/")) return clientPath;
+  if (clientPath === "/") return `${UPSTREAM_API_PREFIX}/`;
+  return `${UPSTREAM_API_PREFIX}${clientPath}`;
+}
+
+function sendError(res, status, message, close = false) {
+  if (res.destroyed || res.writableEnded) return;
+  if (res.headersSent) {
+    res.destroy();
+    return;
+  }
+  const headers = { "content-type": "application/json" };
+  if (close) {
+    headers.connection = "close";
+    res.shouldKeepAlive = false;
+  }
+  res.writeHead(status, headers);
+  res.end(JSON.stringify({ error: message }));
+}
+
+async function sendUpstream(req, res, target, body, tracker) {
+  const codexCatalog =
+    req.method === "GET" &&
+    target.pathname === "/v1/models" &&
+    target.searchParams.has("client_version");
+  const backgroundLabel =
+    target.pathname === "/v1/models"
+      ? "model discovery GET /v1/models"
+      : "background GET (other endpoint)";
+  const authPresent = Boolean(req.headers.authorization || req.headers["x-api-key"]);
+  const clientLabel = String(req.headers.originator || "unspecified")
+    .replace(/[^A-Za-z0-9_.-]/g, "")
+    .slice(0, 64);
+  const backgroundError = (message, status) =>
+    monitor.log(
+      "error",
+      `${backgroundLabel} · HTTP ${status} · ${message} · authorization ${authPresent ? "present" : "missing"} · client ${clientLabel}; generation status is tracked separately`,
+    );
+  const headers = cleanHeaders(req.headers);
+  if (!headers.authorization && typeof headers["x-api-key"] === "string")
+    headers.authorization = `Bearer ${headers["x-api-key"]}`;
+  delete headers["x-api-key"];
+  delete headers.host;
+  delete headers["content-length"];
+  headers.host = target.host;
+  if (req.method === "POST")
+    headers["content-length"] = Buffer.byteLength(body);
+  if (tracker) headers["accept-encoding"] = "identity";
+  if (codexCatalog) {
+    headers.accept = "application/json";
+    headers["accept-encoding"] = "identity";
+  }
+
+  let upstreamRequest;
+  let upstreamResponse;
+  let usageObserver;
+  let upstreamStream;
+  const controller = new AbortController();
+  let cancelled = false;
+  let failed = false;
+  const fail = (message, status = 502) => {
+    if (cancelled || failed || res.writableFinished) return;
+    failed = true;
+    if (tracker) tracker.fail(message);
+    else backgroundError(message, status);
+    usageObserver?.destroy();
+    controller.abort();
+    upstreamStream?.destroy();
+    upstreamResponse?.destroy();
+    upstreamRequest?.destroy();
+    sendError(res, status, message);
+  };
+  const cancel = () => {
+    if (res.writableFinished) return;
+    cancelled = true;
+    usageObserver?.destroy();
+    controller.abort();
+    upstreamStream?.destroy();
+    upstreamResponse?.destroy();
+    upstreamRequest?.destroy();
+  };
+  req.once("aborted", cancel);
+  res.once("close", cancel);
+  res.once("error", cancel);
+  if (req.aborted || res.destroyed) return;
+
+  try {
+    const result = await requestWithRetries(
+      target,
+      { method: req.method, headers, agent },
+      body,
+      {
+        signal: controller.signal,
+        tracker,
+        clientOwnsRetries: req.headers["x-agentrouter-retry-owner"] === "client",
+      },
+    );
+    upstreamRequest = result.request;
+    upstreamResponse = result.response;
+    upstreamStream = result.stream;
+    const upstream = upstreamResponse;
+    if (cancelled) {
+      upstreamStream.destroy();
+      upstream.destroy();
+      return;
+    }
+    const status = upstream.statusCode || 502;
+    tracker?.upstream(status);
+    if (result.retryReason && status < 400)
+      tracker?.fail(upstreamFailure(null, { code: result.retryReason }));
+        if (status >= 400) {
+          const message = upstreamFailure(status);
+          if (tracker) tracker.fail(message);
+          else backgroundError(message, status);
+        }
+        // Install failure handling before piping, so telemetry sees transport
+        // failures before the downstream close event finalizes the request.
+        upstreamStream.on("error", (error) =>
+          fail(upstreamFailure(null, error), error.status || 502),
+        );
+
+        if (codexCatalog && status === 200) {
+          const chunks = [];
+          let bytes = 0;
+          const declaredLength = Number(upstream.headers["content-length"]);
+          if (declaredLength > MAX_CATALOG_BYTES) {
+            fail("AgentRouter model catalog exceeds the size limit");
+            return;
+          }
+          upstreamStream.on("data", (chunk) => {
+            if (failed || cancelled) return;
+            bytes += chunk.length;
+            if (bytes > MAX_CATALOG_BYTES) {
+              chunks.length = 0;
+              fail("AgentRouter model catalog exceeds the size limit");
+              return;
+            }
+            chunks.push(chunk);
+          });
+          upstreamStream.once("end", () => {
+            if (failed || cancelled || res.destroyed) return;
+            let catalog;
+            try {
+              catalog = adaptModelCatalog(
+                JSON.parse(Buffer.concat(chunks, bytes).toString("utf8")),
+              );
+            } catch {
+              fail("AgentRouter returned an invalid model catalog");
+              return;
+            }
+            res.writeHead(200, {
+              "content-type": "application/json",
+              "cache-control": "no-store",
+            });
+            res.end(JSON.stringify(catalog));
+          });
+          return;
+        }
+        const responseHeaders = cleanHeaders(upstream.headers);
+        responseHeaders["cache-control"] = "no-cache";
+        responseHeaders["x-accel-buffering"] = "no";
+        res.writeHead(status, responseHeaders);
+        res.flushHeaders();
+        // The bounded observer reads usage metadata only; original bytes and
+        // pipe backpressure are preserved for native Responses and JSON.
+        usageObserver =
+          tracker && status >= 200 && status < 300
+            ? createUsageObserver(upstream.headers, tracker)
+            : null;
+        if (usageObserver) upstreamStream.pipe(usageObserver).pipe(res);
+        else upstreamStream.pipe(res);
+  } catch (error) {
+    fail(upstreamFailure(null, error), error.status || 502);
+  }
+}
+
+const server = http.createServer((req, res) => {
+  if (req.method === "GET" && (req.url === "/health" || req.url?.startsWith("/health?"))) {
+    res.writeHead(200, {
+      "content-type": "application/json",
+      "cache-control": "no-store",
+    });
+    res.end(JSON.stringify({
+      service: "brink",
+      status: "ready",
+      port: server.address()?.port || LISTEN_PORT,
+    }));
+    return;
+  }
+  let target;
+  try {
+    target = new URL(getUpstreamPath(req.url), UPSTREAM_ORIGIN);
+  } catch {
+    sendError(res, 400, "Invalid request path");
+    return;
+  }
+  if (req.method === "GET") {
+    sendUpstream(req, res, target, "");
+    return;
+  }
+  if (req.method !== "POST") {
+    sendError(res, 405, "Only GET and POST requests are supported");
+    return;
+  }
+
+  const chunks = [];
+  let bytes = 0;
+  let rejected = false;
+  const rejectBody = (status, message) => {
+    if (rejected) return;
+    rejected = true;
+    chunks.length = 0;
+    monitor.log("warn", message);
+    sendError(res, status, message, true);
+    req.resume();
+  };
+  req.once("error", () => rejectBody(400, "Could not read request body"));
+  if (Number(req.headers["content-length"]) > MAX_REQUEST_BYTES) {
+    rejectBody(413, "Request body exceeds the 32 MiB limit");
+    return;
+  }
+  req.on("data", (chunk) => {
+    if (rejected) return;
+    bytes += chunk.length;
+    if (bytes > MAX_REQUEST_BYTES) {
+      rejectBody(413, "Request body exceeds the 32 MiB limit");
+      return;
+    }
+    chunks.push(chunk);
+  });
+  req.once("end", () => {
+    if (rejected || req.aborted || res.destroyed) return;
+    const rawBody = Buffer.concat(chunks, bytes);
+    chunks.length = 0;
+    let parsed;
+    try {
+      parsed = JSON.parse(rawBody.toString("utf8"));
+    } catch {
+      rejectBody(400, "Request body is not valid JSON");
+      return;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      rejectBody(400, "Request body must be a JSON object");
+      return;
+    }
+    const bridged =
+      target.pathname === "/v1/responses" &&
+      typeof parsed.model === "string" &&
+      parsed.model.startsWith("claude-");
+    const messagesBridged = target.pathname === "/v1/messages" &&
+      typeof parsed.model === "string" && /^(?:gpt-|o[134](?:-|$))/i.test(parsed.model);
+    const nativeMessages = target.pathname === "/v1/messages" ||
+      target.pathname === "/v1/messages/count_tokens";
+    const tracker = monitor.begin(req, res, {
+      model: typeof parsed.model === "string" ? parsed.model : null,
+      route: bridged ? "claude-bridge" : messagesBridged ? "messages-bridge" : nativeMessages ? "native-messages" : "native",
+      path: target.pathname,
+    });
+    if (messagesBridged) {
+      bridgeMessages(req, res, parsed, { agent, tracker }).catch(() => {
+        if (res.destroyed || res.writableEnded) return;
+        tracker.fail("Messages bridge could not complete the response");
+        sendError(res, 502, "Messages bridge could not complete the response");
+      });
+      return;
+    }
+    if (bridged) {
+      bridgeResponses(req, res, parsed, { agent, tracker }).catch(() => {
+        if (res.destroyed || res.writableEnded) return;
+        tracker.fail("Claude bridge could not complete the response");
+        sendError(res, 502, "Claude bridge could not complete the response");
+      });
+      return;
+    }
+    // Other Messages models and token counting retain their native endpoint.
+    if (target.pathname !== "/v1/responses") {
+      sendUpstream(req, res, target, rawBody, tracker);
+      return;
+    }
+    const effortFix = normalizeReasoningEffort(parsed);
+    if (effortFix) {
+      parsed = {
+        ...parsed,
+        reasoning: { ...parsed.reasoning, effort: effortFix.to },
+      };
+      tracker.note(
+        "warn",
+        `AgentRouter GLM accepts only low/high/max reasoning effort; mapped ${effortFix.from} to ${effortFix.to}`,
+      );
+    }
+    const cleaned = sanitizeRequest(parsed);
+    if (cleaned.payload !== parsed) {
+      tracker.note(
+        "info",
+        `Sanitized history: removed ${cleaned.removedIds} item IDs, ${cleaned.removedEncryptedContent} encrypted reasoning fields, ${cleaned.removedReferences} reasoning references`,
+      );
+    }
+    const changedBody = effortFix != null || cleaned.payload !== parsed;
+    const outgoingBody = changedBody
+      ? JSON.stringify(cleaned.payload)
+      : rawBody;
+    sendUpstream(req, res, target, outgoingBody, tracker);
+  });
+});
+
+// Reasoning has no total request deadline. Shared transport enforces connection,
+// header and inactivity deadlines independently for every attempt.
+server.requestTimeout = 0;
+server.headersTimeout = 30_000;
+server.on("clientError", (error, socket) => {
+  if (socket.writable && !socket.destroyed)
+    socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+});
+
+let shuttingDown = false;
+function shutdown(exitCode = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  const finish = () => {
+    clearTimeout(grace);
+    agent.destroy();
+    terminalUI?.close();
+    monitor.close();
+    process.exit(exitCode);
+  };
+  const grace = setTimeout(() => {
+    server.closeAllConnections();
+    finish();
+  }, 5_000);
+  monitor.log(
+    "info",
+    "Proxy shutting down; allowing up to 5 seconds for active requests",
+  );
+  server.close(finish);
+  server.closeIdleConnections();
+}
+process.once("SIGINT", () => shutdown());
+process.once("SIGTERM", () => shutdown());
+server.on("error", (error) => {
+  const message =
+    error.code === "EADDRINUSE"
+      ? `Brink cannot use port ${LISTEN_PORT}: it is already in use. Run brink to check for an existing Brink proxy or choose another port; do not kill an unrelated process.`
+      : "Brink could not start its local listener; run brink to try again";
+  monitor.log("error", message);
+  agent.destroy();
+  monitor.close();
+  process.exitCode = 1;
+});
+server.listen(LISTEN_PORT, LISTEN_HOST, () => {
+  if (
+    process.stdin.isTTY &&
+    process.stdout.isTTY &&
+    process.env.TERM !== "dumb" &&
+    process.env.AGENTROUTER_PROXY_PLAIN !== "1"
+  ) {
+    terminalUI = startTerminalUI(monitor, {
+      clients: process.env.BRINK_CLIENTS?.split(","),
+    });
+  }
+  monitor.log(
+    "info",
+    `Brink listening on http://${LISTEN_HOST}:${LISTEN_PORT}; keep this terminal open`, 
+  );
+  monitor.log(
+    "info",
+    "AgentRouter upstream: https://agentrouter.org/v1; transient-failure retry waits 1/2/3/4/5 seconds before output (client-owned retries bypassed); no model or credential substitution",
+  );
+});