Skip to content

Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors

7.3 KB
Raw Blame
import { NextResponse } from "next/server";
export const dynamic = "force-dynamic";
import { requireManagementAuth } from "@/lib/api/requireManagementAuth";
import { createErrorResponse } from "@/lib/api/errorResponse";
import { getProxyById, getScopePoolEgressRows, getScopeRotationStrategy } from "@/lib/db/proxies";
import { isScopeIdMissing } from "@/lib/db/proxies/mappers";
import { rankPoolCandidates } from "@/lib/db/proxies/rotation";
import { isProxySkipRecentlyFailedEnabled } from "@/shared/utils/featureFlags";
import {
  countTransportEvidenceFor,
  getRefusalStoreInstance,
  isProxyAvoided,
  isSelectorMemberAvoided,
  listEntryMembers,
  proxyEgressKey,
  snapshotMemberSetAside,
  snapshotProxySetAside,
  TRANSPORT_EVIDENCE_WINDOW_MS,
} from "@omniroute/open-sse/utils/proxyRefusalMemory.ts";
import { listOpencodeFreeTierPauses } from "@omniroute/open-sse/services/opencodeFreeTierSkip.ts";

function freeTierPausesResponse(searchParams: URLSearchParams, now: number) {
  // Active free-tier pauses (in-process refusal memory, read-only): this
  // branch answers first and ignores proxyId/scope when combined with it.
  if (searchParams.get("freeTierPauses") !== "1") return null;
  const provider = searchParams.get("provider")?.trim();
  if (!provider) {
    return createErrorResponse({
      status: 400,
      message: "provider is required",
      type: "invalid_request",
    });
  }
  return NextResponse.json({
    provider,
    pauses: listOpencodeFreeTierPauses(provider, now),
    processMemory: true,
  });
}

// Read-only pool visibility: per-member set-aside state (motive, start, expected
// end, repeat count) plus the current preference order computed by the same
// rankPoolCandidates the selector uses. Never probes, never writes: only the
// in-process refusal memory and the registry are read.
//
//   GET ?scope=global|provider|account|combo|key&scopeId=
//     -> { scope, strategy, rankedBy, processMemory, members: [...] }
//   GET ?proxyId=
//     -> same shape for a single registry entry (unknown id -> opaque member)
//
// Masking: member rows may carry redacted credentials (includeSecrets: false),
// egress keys are server-side only, clients only see scheme://host:port plus a
// masked user marker. Opaque entries (relays, unusable rows) report opaque:true.

type MemberRow = Record<string, unknown>;

function normalizeScopeAlias(scope: string): string {
  return scope === "key" ? "account" : scope;
}

function textField(value: unknown): string {
  return typeof value === "string" ? value : "";
}

function displayEndpoint(row: MemberRow): string | null {
  const host = textField(row.host).trim();
  if (!host) return null;
  const type = textField(row.type || "http").toLowerCase() || "http";
  const port = Number(row.port);
  const portSuffix = Number.isInteger(port) && port >= 1 && port <= 65535 ? `:${port}` : "";
  const bracketed = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
  return `${type}://${bracketed}${portSuffix}`;
}

function toMemberView(row: MemberRow, rank: number, now: number = Date.now()) {
  const key = proxyEgressKey(row);
  const snapshot = snapshotProxySetAside(key, now);
  const display = displayEndpoint(row);
  const username = textField(row.username);
  const memberSetAside =
    key === null
      ? []
      : listEntryMembers(key).map((member) => {
          const memberSnapshot = snapshotMemberSetAside(key, member, now);
          return {
            member,
            avoided: isSelectorMemberAvoided(key, member, now),
            setAside: memberSnapshot
              ? {
                  kind: memberSnapshot.kind,
                  since: new Date(memberSnapshot.setAsideAt).toISOString(),
                  endsAt: new Date(memberSnapshot.endsAt).toISOString(),
                  streak: memberSnapshot.streak,
                }
              : null,
            storeInstance: getRefusalStoreInstance(),
          };
        });
  const evidence = countTransportEvidenceFor(key, now);
  return {
    id: typeof row.id === "string" ? row.id : null,
    name: typeof row.name === "string" ? row.name : null,
    display,
    userMasked: username ? "***" : null,
    opaque: display === null || key === null,
    rank,
    signal: key !== null && isProxyAvoided(key, now) ? "set-aside" : "position",
    setAside: snapshot
      ? {
          kind: snapshot.kind,
          since: new Date(snapshot.setAsideAt).toISOString(),
          endsAt: new Date(snapshot.endsAt).toISOString(),
          streak: snapshot.streak,
        }
      : null,
    memberSetAside,
    transportEvidence: {
      failures: evidence.failures,
      crossSuccesses: evidence.crossSuccesses,
      windowMs: TRANSPORT_EVIDENCE_WINDOW_MS,
    },
    storeInstance: getRefusalStoreInstance(),
  };
}

function rankRows(rows: MemberRow[]): { ordered: MemberRow[]; rankedBy: "health" | "position" } {
  if (rows.length < 2 || !isProxySkipRecentlyFailedEnabled()) {
    return { ordered: rows, rankedBy: "position" };
  }
  return { ordered: rankPoolCandidates(rows), rankedBy: "health" };
}

export async function GET(request: Request) {
  const authError = await requireManagementAuth(request);
  if (authError) return authError;
  try {
    const { searchParams } = new URL(request.url);
    const now = Date.now();
    const pauses = freeTierPausesResponse(searchParams, now);
    if (pauses) return pauses;
    const proxyId = searchParams.get("proxyId");
    if (proxyId?.trim()) {
      // Single-entry view for accounts bound to one proxy. Unknown ids answer
      // the same opaque shape (no enumeration oracle).
      const entry = await getProxyById(proxyId.trim(), { includeSecrets: false });
      const row = (entry ?? {}) as MemberRow;
      const { ordered, rankedBy } = rankRows(entry ? [row] : []);
      return NextResponse.json({
        scope: null,
        strategy: null,
        rankedBy,
        processMemory: true,
        members:
          ordered.length > 0 ? [toMemberView(ordered[0], 1, now)] : [toMemberView({}, 1, now)],
        total: 1,
      });
    }

    const rawScope = searchParams.get("scope");
    if (!rawScope) {
      return createErrorResponse({
        status: 400,
        message: "scope is required",
        type: "invalid_request",
      });
    }
    const scope = normalizeScopeAlias(rawScope);
    const scopeId = searchParams.get("scopeId");
    if (isScopeIdMissing(scope, scopeId)) {
      return createErrorResponse({
        status: 400,
        message: "scopeId is required for provider/account/combo/key scope",
        type: "invalid_request",
      });
    }
    const normalizedScopeId = scope === "global" ? null : scopeId;
    const [rows, strategy] = await Promise.all([
      getScopePoolEgressRows(scope, normalizedScopeId),
      getScopeRotationStrategy(scope, normalizedScopeId),
    ]);
    const { ordered, rankedBy } = rankRows(rows as MemberRow[]);
    return NextResponse.json({
      scope,
      strategy,
      rankedBy,
      processMemory: true,
      members: ordered.map((row, index) => {
        try {
          return toMemberView(row, index + 1, now);
        } catch {
          return toMemberView({}, index + 1, now);
        }
      }),
      total: ordered.length,
    });
  } catch {
    return createErrorResponse({
      status: 500,
      message: "Failed to load pool visibility",
      type: "server_error",
    });
  }
}