UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

166 lines (156 loc) • 8.49 kB
import { parseUpstreamJsonPayload } from "../../adapters/upstream-http-error"; import { maskedAccountLabel } from "../../lib/privacy"; import { peekAuthStore } from "../../oauth/store"; import type { ProviderAccount } from "../../oauth/types"; import type { ProviderQuota } from "../quota-types"; import { fetchAntigravityQuotaSummaryOnce, type AntigravitySummaryOnceResult } from "./antigravity"; /** * Per-account probe verdicts. `paused` and `token_expired` are decided locally and send nothing; * every other value is derived from the single upstream answer. */ export const ACCOUNT_PROBE_STATUSES = [ "ok", "paused", "token_expired", "suspended", "verification_required", "rate_limited", "permission_denied", "error", ] as const; export type AccountProbeStatus = typeof ACCOUNT_PROBE_STATUSES[number]; export interface AccountProbeResult { accountId: string; maskedLabel?: string; active: boolean; paused: boolean; needsReauth: boolean; status: AccountProbeStatus; /** Upstream HTTP status; null when no request was sent or no response arrived. */ httpStatus: number | null; /** Closed upstream or local reason code. Unknown upstream strings are omitted. */ reason: string | null; /** Optional local diagnostic. */ message: string | null; /** Stored access-token expiry (epoch ms); null when the credential has none. */ expiresAt: number | null; latencyMs: number; quota: ProviderQuota | null; } const PROVIDER = "google-antigravity"; const PROBE_CONCURRENCY = 4; const SAFE_REASONS = new Set(["VALIDATION_REQUIRED", "SERVICE_DISABLED", "PERMISSION_DENIED", "RESOURCE_EXHAUSTED", "UNAUTHENTICATED"]); const SUSPENDED_PATTERN = /suspend|account (?:has been |is |was )?disabled|user_disabled|account_disabled|terms of service|tos_violation|banned/; const VERIFICATION_PATTERN = /validation_required|validation required|verify your account|account verification/; interface GoogleErrorEnvelope { enumStatus?: string; message?: string; reasons: string[] } function readGoogleError(bodyText: string): GoogleErrorEnvelope { const parsed = parseUpstreamJsonPayload(bodyText); const root = Array.isArray(parsed) ? parsed[0] : parsed; const error = root && typeof root === "object" ? (root as { error?: unknown }).error : undefined; if (!error || typeof error !== "object" || Array.isArray(error)) { const text = bodyText.trim(); return { reasons: [], ...(text && !text.startsWith("{") && !text.startsWith("[") ? { message: text } : {}) }; } const record = error as { status?: unknown; message?: unknown; details?: unknown }; const reasons = Array.isArray(record.details) ? record.details.flatMap(detail => detail?.["@type"] === "type.googleapis.com/google.rpc.ErrorInfo" && typeof detail.reason === "string" ? [detail.reason] : []) : []; return { reasons, ...(typeof record.status === "string" && record.status ? { enumStatus: record.status } : {}), ...(typeof record.message === "string" && record.message.trim() ? { message: record.message.trim() } : {}), }; } /** Map one upstream answer to a verdict. Pure; exported for tests. */ export function classifyAntigravityProbeResponse(httpStatus: number, bodyText: string): Pick<AccountProbeResult, "status" | "reason" | "message"> { if (httpStatus >= 200 && httpStatus < 300) return { status: "ok", reason: null, message: null }; const envelope = readGoogleError(bodyText); const reason = [...envelope.reasons, envelope.enumStatus].find(code => code !== undefined && SAFE_REASONS.has(code)) ?? null; const message = null; const haystack = `${envelope.reasons.join(" ")} ${envelope.enumStatus ?? ""} ${envelope.message ?? ""}`.toLowerCase(); if (envelope.reasons.includes("VALIDATION_REQUIRED") || (httpStatus === 403 && VERIFICATION_PATTERN.test(haystack))) { return { status: "verification_required", reason: "VALIDATION_REQUIRED", message }; } if (httpStatus === 429 || envelope.enumStatus === "RESOURCE_EXHAUSTED") return { status: "rate_limited", reason, message }; if (httpStatus === 403) { // A disabled *API/service* on the project is a project-setup fault, not a suspended account. if (!envelope.reasons.includes("SERVICE_DISABLED") && SUSPENDED_PATTERN.test(haystack)) { return { status: "suspended", reason, message }; } return { status: "permission_denied", reason: reason ?? "PERMISSION_DENIED", message }; } return { status: "error", reason, message }; } function verdictFromRaw(raw: AntigravitySummaryOnceResult): Pick<AccountProbeResult, "status" | "httpStatus" | "reason" | "message" | "quota"> { if (raw.kind === "transport") return { status: "error", httpStatus: null, reason: raw.failure, message: null, quota: null }; if (raw.kind === "redirect") return { status: "error", httpStatus: null, reason: "redirect_blocked", message: null, quota: null }; const verdict = classifyAntigravityProbeResponse(raw.status, raw.bodyText); return { ...verdict, httpStatus: raw.status, quota: raw.quota, ...(verdict.status === "ok" && !raw.quota ? { message: "no quota groups in response" } : {}), }; } async function probeOneAntigravityAccount( account: ProviderAccount, activeAccountId: string | undefined, now: number, signal?: AbortSignal, ): Promise<AccountProbeResult> { const credential = account.credential; const maskedLabel = maskedAccountLabel(credential?.email); const expiresAt = typeof credential?.expires === "number" && Number.isFinite(credential.expires) ? credential.expires : null; const base = { accountId: account.id, ...(maskedLabel ? { maskedLabel } : {}), active: account.id === activeAccountId, paused: account.paused === true, needsReauth: account.needsReauth === true, expiresAt, }; const local = (status: AccountProbeStatus, reason: string | null): AccountProbeResult => ({ ...base, status, httpStatus: null, reason, message: null, latencyMs: 0, quota: null, }); // A paused account is left alone: no request, so probing never touches an account the operator parked. if (account.paused === true) return local("paused", null); if (!credential?.access) return local("error", "missing_token"); // Read-only contract: an expired token is reported, never refreshed. if (expiresAt !== null && expiresAt <= now) return local("token_expired", null); if (!credential.projectId) return local("error", "missing_project"); const started = Date.now(); const raw = await fetchAntigravityQuotaSummaryOnce(credential.access, credential.projectId, signal, () => { const current = peekAuthStore()[PROVIDER]?.accounts.find(row => row.id === account.id); return current !== undefined && current.paused !== true && current.credential.access === credential.access && current.credential.projectId === credential.projectId && current.credential.expires === credential.expires && (expiresAt === null || expiresAt > Date.now()); }); return { ...base, ...verdictFromRaw(raw), latencyMs: Date.now() - started }; } /** * Probe stored Google Antigravity accounts with their own stored access tokens. * * Uses passive store reads and never changes the credential, active account or health. * Returns null when `accountId` names no stored account. */ export async function probeAntigravityAccounts(options: { accountId?: string; now?: number; signal?: AbortSignal; } = {}): Promise<AccountProbeResult[] | null> { const accountIds = [...new Set(peekAuthStore()[PROVIDER]?.accounts.map(account => account.id))]; const targets = options.accountId === undefined ? accountIds : [options.accountId]; if (options.accountId !== undefined && !accountIds.includes(options.accountId)) return null; const results = new Array<AccountProbeResult | undefined>(targets.length); let next = 0; const worker = async () => { while (next < targets.length && !options.signal?.aborted) { const index = next++; // Re-read the roster as each probe starts: a pause made after the snapshot must suppress the request. const latest = peekAuthStore()[PROVIDER]; const current = latest?.accounts.find(account => account.id === targets[index]); if (current) results[index] = await probeOneAntigravityAccount(current, latest?.activeAccountId, options.now ?? Date.now(), options.signal); } }; await Promise.all(Array.from({ length: Math.min(PROBE_CONCURRENCY, targets.length) }, worker)); return results.filter(result => result !== undefined); }