@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
213 lines (197 loc) • 11.1 kB
text/typescript
/**
* `GET|PUT /api/combo-suggestions`: the providers left out of the Combos page's suggested
* combos (`comboSuggestionExcludedProviders`). Suggestions are computed in the dashboard; this
* persists the exclusion list and saves suggested targets against current config policy.
*/
import { clearComboSelectionState, clearComboTargetCooldowns, comboPublicModelId } from "../../combos";
import { comboConfigIssues } from "../../combos/types";
import { channelTier, TIER_RANK } from "../../combos/suggestion-channel";
import { codexAccountNamespaceForModel } from "../../codex/account-namespace-match";
import { reconcileLiveStateStores } from "../../lib/state-store-registrations";
import type { OcxComboConfig, OcxConfig } from "../../types";
import { normalizeDecisionModelSelector, decisionModelRouteError } from "./decision-model-validation";
import type { ManagementContext } from "./context";
import { jsonResponse } from "../auth-cors";
import { readConfigFileSnapshot } from "../../config/diagnostics";
import { mutatePersistedConfig } from "../../config";
import { managementBodyTooLargeResponse, readManagementJsonBody } from "./body";
import { hasHumanDashboardSession } from "./consent-session";
import { isPlainRecord } from "./shared";
const MAX_PROVIDERS = 256;
const MAX_NAME_LENGTH = 256;
/** Trimmed, deduplicated, in the order given; null when the value is not a list of names. */
export function parseExcludedProviders(value: unknown): string[] | null {
if (!Array.isArray(value) || value.length > MAX_PROVIDERS) return null;
const out: string[] = [];
for (const entry of value) {
if (typeof entry !== "string") return null;
const name = entry.trim();
if (!name || name.length > MAX_NAME_LENGTH) return null;
if (!out.includes(name)) out.push(name);
}
return out;
}
function suggestionPolicy(config: OcxConfig) {
return {
excludedProviders: config.comboSuggestionExcludedProviders ?? [],
meteredComboIds: Object.entries(config.combos ?? {})
.filter(([, combo]) => combo.allowMeteredTargets === true)
.map(([id]) => id),
};
}
function view(ctx: ManagementContext, policy: ReturnType<typeof suggestionPolicy>): Response {
const response = jsonResponse(policy, 200, ctx.req, ctx.config);
response.headers.set("cache-control", "no-store");
return response;
}
export async function handleComboSuggestionRoutes(ctx: ManagementContext): Promise<Response | null> {
const { req, url } = ctx;
const allowed = hasHumanDashboardSession(ctx);
const denied = () => jsonResponse({ error: "dashboard session required" }, 403, req, ctx.config);
if (url.pathname === "/api/combo-suggestions/save" && req.method === "POST") {
return allowed ? await saveSuggestion(ctx) : denied();
}
if (url.pathname === "/api/combo-suggestions" && req.method === "GET") {
if (!allowed) return denied();
const { diagnostics } = readConfigFileSnapshot();
return diagnostics.source === "file"
? view(ctx, suggestionPolicy(diagnostics.config))
: jsonResponse({ error: "suggestion policy unavailable", code: "config_unavailable" }, 409, req, ctx.config);
}
if (url.pathname === "/api/combo-suggestions" && req.method === "PUT") {
return allowed ? await writeExcluded(ctx) : denied();
}
return null;
}
async function writeExcluded(ctx: ManagementContext): Promise<Response> {
const { req, config } = ctx;
let body: unknown;
try {
body = await readManagementJsonBody(req);
} catch (error) {
return managementBodyTooLargeResponse(error, req, config)
?? jsonResponse({ error: "invalid JSON body", code: "invalid_request" }, 400, req, config);
}
if (!isPlainRecord(body) || Object.keys(body).some(key => key !== "provider" && key !== "excluded")
|| typeof body.excluded !== "boolean") {
return jsonResponse({ error: "expected a provider and exclusion state", code: "invalid_request" }, 400, req, config);
}
const provider = parseExcludedProviders([body.provider])?.[0];
if (!provider) return jsonResponse({ error: "invalid provider name", code: "invalid_request" }, 400, req, config);
const { excluded } = body;
const outcome = mutatePersistedConfig(persisted => {
const before = persisted.comboSuggestionExcludedProviders ?? [];
if (before.includes(provider) === excluded) return { changed: false, value: suggestionPolicy(persisted) };
const next = excluded ? [...before, provider] : before.filter(name => name !== provider);
if (next.length > MAX_PROVIDERS) return { changed: false, value: null };
if (next.length === 0) delete persisted.comboSuggestionExcludedProviders;
else persisted.comboSuggestionExcludedProviders = next;
return { changed: true, value: suggestionPolicy(persisted) };
});
if (outcome.status === "unavailable") {
return jsonResponse({ error: `config.json is ${outcome.reason}; excluded providers were not saved`, code: "config_unavailable" }, 409, req, config);
}
if (!outcome.value) return jsonResponse({ error: "too many excluded providers", code: "invalid_request" }, 400, req, config);
const { excludedProviders } = outcome.value;
if (excludedProviders.length === 0) delete config.comboSuggestionExcludedProviders;
else config.comboSuggestionExcludedProviders = excludedProviders;
return view(ctx, outcome.value);
}
type Target = Pick<OcxComboConfig["targets"][number], "provider" | "model">;
function parseTargets(value: unknown): Target[] | null {
if (!Array.isArray(value) || !value.length || value.length > MAX_PROVIDERS) return null;
const targets: Target[] = [];
for (const entry of value) {
if (!isPlainRecord(entry) || Object.keys(entry).some(key => key !== "provider" && key !== "model")
|| typeof entry.provider !== "string" || typeof entry.model !== "string") return null;
const provider = entry.provider.trim();
const model = entry.model.trim();
if (!provider || provider.length > MAX_NAME_LENGTH || !model) return null;
if (!targets.some(target => target.provider === provider && target.model === model)) {
targets.push({ provider, model });
}
}
return targets;
}
type SuggestionSaveResult =
| { code: string; status: number }
| { combos: NonNullable<OcxConfig["combos"]> };
async function saveSuggestion(ctx: ManagementContext): Promise<Response> {
const { req, config } = ctx;
let body: unknown;
try {
body = await readManagementJsonBody(req);
} catch (error) {
return managementBodyTooLargeResponse(error, req, config)
?? jsonResponse({ error: "invalid JSON body", code: "invalid_request" }, 400, req, config);
}
const invalid = () => jsonResponse({ error: "invalid suggested combo", code: "invalid_request" }, 400, req, config);
if (!isPlainRecord(body) || Object.keys(body).some(key => key !== "id" && key !== "mode" && key !== "targets" && key !== "allowMeteredTargets")
|| typeof body.id !== "string" || (body.mode !== "create" && body.mode !== "append")) return invalid();
const id = body.id.trim();
const targets = parseTargets(body.targets);
if (!targets || !id) return invalid();
const create = body.mode === "create";
const consent = body.allowMeteredTargets;
if (!create && Object.hasOwn(body, "allowMeteredTargets")) return invalid();
const outcome = mutatePersistedConfig<SuggestionSaveResult>(persisted => {
const previous = Object.hasOwn(persisted.combos ?? {}, id) ? persisted.combos![id] : undefined;
const rejected = (code: string, status = 409) => ({ changed: false, value: { code, status } });
if (create ? previous : !previous) return rejected("suggestion_combo_changed");
if (create && consent !== undefined && typeof consent !== "boolean") return rejected("invalid_request", 400);
if ((create ? consent : previous?.allowMeteredTargets) !== true) return rejected("suggestion_consent_required");
const nextTargets = [...(previous?.targets ?? [])];
const providerFor = (snapshot: OcxConfig, name: string) =>
Object.hasOwn(snapshot.providers, name) ? snapshot.providers[name] : undefined;
const tierOf = (snapshot: OcxConfig, { provider, model }: Target) => {
const current = providerFor(snapshot, provider);
return current ? channelTier({ ...current, name: provider }, model) : "metered";
};
// Use the lower placement preference when live and persisted channel classifications differ.
const rankOf = (target: Target) => Math.max(TIER_RANK[tierOf(persisted, target)], TIER_RANK[tierOf(config, target)]);
const inserted = new Set<OcxComboConfig["targets"][number]>();
for (const target of targets) {
if (nextTargets.some(({ provider, model }) => provider.trim() === target.provider && model.trim() === target.model)) continue;
const provider = providerFor(persisted, target.provider);
if (!provider || provider.disabled || provider.adapter === "jev-decision") {
return rejected("suggestion_provider_unavailable");
}
if (persisted.comboSuggestionExcludedProviders?.includes(target.provider)) return rejected("suggestion_provider_excluded");
const rank = rankOf(target);
const at = create ? -1 : nextTargets.findIndex(existing =>
(existing.metered === true && !inserted.has(existing) ? TIER_RANK.metered : rankOf(existing)) > rank);
const added = { ...target, metered: true };
inserted.add(added);
nextTargets.splice(at < 0 ? nextTargets.length : at, 0, added);
}
const combo: OcxComboConfig = { strategy: "failover", ...previous, allowMeteredTargets: true, targets: nextTargets };
const combos = { ...persisted.combos, [id]: combo };
const prospective = { ...persisted, combos };
if (comboConfigIssues(id, combo, persisted.providers, {
requireEnabledTarget: true,
requireUsableDecisionService: true,
combos,
excludeComboId: id,
normalizeDecisionModel: model => normalizeDecisionModelSelector(prospective, model),
}).length) return rejected("invalid_request", 400);
if (codexAccountNamespaceForModel(persisted.codexAccountNamespaces, comboPublicModelId(id, combo))) {
return rejected("suggestion_combo_changed");
}
if (Object.entries(combos).some(([comboId, row]) => row.decisionModel
&& decisionModelRouteError(prospective, comboId, row.decisionModel))) return rejected("invalid_request", 400);
persisted.combos = combos;
return { changed: nextTargets.length !== (previous?.targets.length ?? 0), value: { combos } };
});
if (outcome.status === "unavailable") {
return jsonResponse({ error: "suggestion could not be saved", code: "config_unavailable" }, 409, req, config);
}
if ("code" in outcome.value) {
return jsonResponse({ error: "suggestion could not be saved", code: outcome.value.code }, outcome.value.status, req, config);
}
config.combos = outcome.value.combos;
reconcileLiveStateStores();
clearComboSelectionState(id);
clearComboTargetCooldowns(id);
const catalogRefresh = await ctx.convergeCodexCatalog();
return jsonResponse({ success: true, catalogRefresh }, 200, req, config);
}