@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
162 lines (153 loc) • 8.09 kB
text/typescript
import { jsonResponse } from "../auth-cors";
import { jevDecisionEndpointUrl } from "../../combos/jev-decision-contract";
import type { ManagementContext } from "./context";
import { readManagementJsonBody, rethrowManagementBodyTooLarge } from "./body";
import { isPlainRecord } from "./shared";
import { systemOneEndpoint, uniqueDiscoveryCandidates, type DiscoveryModelRow } from "./decision-discovery";
const PROBE_TASK = "Verify the configured decision method with a two-option probe.";
const PROBE_CANDIDATE = {
key: "probe/decision",
provider: "probe",
model: "decision",
reasoningEfforts: ["low", "high"],
} as const;
const MAX_DECISION_MODEL_CHARS = 512;
function optionalString(body: Record<string, unknown>, key: string): string | null | undefined | false {
const value = body[key];
if (value === undefined || value === null) return undefined;
if (typeof value !== "string") return false;
const trimmed = value.trim();
return trimmed ? trimmed : null;
}
type DecisionRow = import("../../types").OcxProviderConfig;
/** Why a decision-service row cannot answer, shared by discovery and the probe. */
function decisionServiceIssue(
id: string,
provider: DecisionRow,
isSystemOneEndpoint: (url: string) => boolean,
): { url: string; model: string; issue?: "disabled" | "endpoint" | "model" } {
const url = typeof provider.baseUrl === "string" ? jevDecisionEndpointUrl(provider.baseUrl) : "";
const model = provider.defaultModel?.trim() || provider.models?.[0]?.trim() || "";
const issue = provider.disabled === true
? "disabled"
: id === "jev"
? undefined
: !isSystemOneEndpoint(url)
? "endpoint"
: !model ? "model" : undefined;
return { url, model, ...(issue ? { issue } : {}) };
}
/**
* Decision-method management surfaces for JEV combos.
*
* - POST /api/combos/decision-test runs one bounded decision with a synthetic two-option probe
* through the same backend a combo would use, saved or not. It may spend a decision call.
* - GET /api/combos/decision-discovery lists configured System One rows and catalog models whose
* names look like decision services, with the System One endpoint their provider would serve.
* Nothing is probed and nothing is written.
*
* The probe selects its method only from the body's `decisionProvider` / `decisionModel`; none
* means TypeSafe. `comboId` names the combo for the recursion rules and never loads its saved
* method, because the dashboard probes an unsaved TypeSafe draft by sending `comboId` alone.
* `ocx combo test --combo` resolves the saved method on the client before calling this.
*/
export async function handleDecisionRoutes(ctx: ManagementContext): Promise<Response | null> {
const { req, url, config } = ctx;
if (url.pathname === "/api/combos/decision-test" && req.method === "POST") {
let rawBody: unknown;
try { rawBody = await readManagementJsonBody(req); } catch (error) { rethrowManagementBodyTooLarge(error); return jsonResponse({ error: "invalid JSON body" }, 400); }
if (!isPlainRecord(rawBody)) return jsonResponse({ error: "request body must be an object" }, 400);
const decisionProvider = optionalString(rawBody, "decisionProvider");
const decisionModel = optionalString(rawBody, "decisionModel");
const comboId = optionalString(rawBody, "comboId");
if (decisionProvider === false || decisionModel === false || comboId === false) {
return jsonResponse({ error: "decisionProvider, decisionModel and comboId must be strings" }, 400);
}
if (decisionProvider && decisionModel) {
return jsonResponse({ error: "choose either decisionProvider or decisionModel, not both" }, 400);
}
const timeout = rawBody.decisionTimeoutMs;
const { JEV_DECISION_TIMEOUT_MAX_MS, JEV_DECISION_TIMEOUT_MIN_MS } = await import("../../combos/types");
if (timeout !== undefined && timeout !== null && (typeof timeout !== "number" || !Number.isInteger(timeout)
|| timeout < JEV_DECISION_TIMEOUT_MIN_MS || timeout > JEV_DECISION_TIMEOUT_MAX_MS)) {
return jsonResponse({
error: `decisionTimeoutMs must be an integer from ${JEV_DECISION_TIMEOUT_MIN_MS} to ${JEV_DECISION_TIMEOUT_MAX_MS}`,
}, 400);
}
if (decisionProvider && decisionProvider !== "jev") {
const row = Object.hasOwn(config.providers, decisionProvider) ? config.providers[decisionProvider] : undefined;
if (row?.adapter !== "jev-decision") {
return jsonResponse({ error: `decisionProvider "${decisionProvider}" is not a configured decision service` }, 400);
}
// Match the combo PUT: a disabled or model-less row is refused by name, not probed into a
// generic fail-open gate.
const { isSystemOneEndpoint } = await import("../../combos/types");
const { issue } = decisionServiceIssue(decisionProvider, row, isSystemOneEndpoint);
if (issue) {
return jsonResponse({ error: `decisionProvider "${decisionProvider}" is not usable (${issue})`, issue }, 400);
}
}
if (decisionModel) {
if (decisionModel.length > MAX_DECISION_MODEL_CHARS) {
return jsonResponse({ error: "decisionModel is too long" }, 400);
}
const { decisionModelRouteError } = await import("./decision-model-validation");
const routeError = decisionModelRouteError(config, comboId || undefined, decisionModel);
if (routeError) return jsonResponse({ error: routeError }, 400);
}
const { resolveJevComboDecision } = await import("../../combos/jev-dispatch");
let invokeModel: import("../../combos/jev-model-backend").JevModelInvoke | undefined;
if (decisionModel) {
const [{ createJevModelInvoker }, { handleResponses }] = await Promise.all([
import("../responses/jev-model-invoke"),
import("../responses/core"),
]);
invokeModel = createJevModelInvoker({
req: new Request("http://localhost/api/combos/decision-test"),
config,
options: {},
handleResponses,
});
}
const fallback = { targetKey: PROBE_CANDIDATE.key, effort: null };
const decision = await resolveJevComboDecision({
body: { input: PROBE_TASK },
candidates: [{ ...PROBE_CANDIDATE, reasoningEfforts: [...PROBE_CANDIDATE.reasoningEfforts] }],
fallback,
config,
...(decisionProvider ? { decisionProvider } : {}),
...(decisionModel && invokeModel ? { decisionModel, invokeModel } : {}),
...(typeof timeout === "number" ? { timeoutMs: timeout } : {}),
signal: req.signal,
});
return jsonResponse({
ok: decision.gate === "apply",
backend: decision.backend,
gate: decision.gate,
latencyMs: decision.latencyMs,
...(decision.gate === "apply" && decision.effort ? { effort: decision.effort } : {}),
});
}
if (url.pathname === "/api/combos/decision-discovery" && req.method === "GET") {
const query = (url.searchParams.get("q") ?? "").slice(0, 128);
const { isSystemOneEndpoint } = await import("../../combos/types");
const configured = Object.entries(config.providers)
.filter(([, provider]) => provider.adapter === "jev-decision")
.map(([id, provider]) => {
const { url, model, issue } = decisionServiceIssue(id, provider, isSystemOneEndpoint);
return { id, url, ...(model ? { model } : {}), usable: issue === undefined, ...(issue ? { issue } : {}) };
});
const { listManagementModelRows } = await import("./model-rows");
const rows = (await listManagementModelRows(config)) as unknown as DiscoveryModelRow[];
const discovered = uniqueDiscoveryCandidates(rows, query)
.flatMap(row => {
const provider = config.providers[row.provider!];
if (!provider || provider.disabled === true || provider.adapter === "jev-decision") return [];
const endpoint = systemOneEndpoint(provider.baseUrl);
return endpoint ? [{ provider: row.provider!, model: row.id, endpoint }] : [];
})
.slice(0, 50);
return jsonResponse({ configured, discovered });
}
return null;
}