@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
216 lines (207 loc) • 10.3 kB
text/typescript
/**
* Per-role model for omo (Codex / LazyCodex): `$CODEX_HOME/agents/<role>.toml` plus LazyCodex's
* `"[codex]".agents.<role>` model and reasoning mirror in omo.jsonc. Both halves exist only when LazyCodex is
* detected; Pi-based and OpenCode-based omo are never read here.
*
* Loaded on demand from `src/server/management-api.ts`, like the quota-reset handler, so a
* dashboard request that never opens the omo tab loads neither writer.
*/
import { jsonResponse } from "../auth-cors";
import { readManagementJsonBody, rethrowManagementBodyTooLarge } from "./body";
import type { ManagementContext } from "./context";
const ROLE_PATH_PREFIX = "/api/codex-agent-roles/";
const AUTO_ASSIGN_PATH = "/api/codex-agent-roles/auto-assign";
function lazycodexNotDetected(ctx: ManagementContext): Response {
return jsonResponse({
error: "omo (Codex / LazyCodex) is not installed in this CODEX_HOME",
code: "lazycodex_not_detected",
}, 409, ctx.req, ctx.config);
}
export async function handleCodexAgentRoleRoutes(ctx: ManagementContext): Promise<Response | null> {
const { req, url, config, deps } = ctx;
const [{ getCodexHome }, roles, omo, { detectLazyCodex }, history] = await Promise.all([
import("../../codex/paths"),
import("../../codex/agent-role-models"),
import("../../clients/omo-role-models"),
import("../../clients/lazycodex"),
import("../../codex/role-model-history"),
]);
if (url.pathname === "/api/codex-agent-roles" && req.method === "GET") {
const codexHome = getCodexHome();
const lazycodex = detectLazyCodex(codexHome);
if (!lazycodex.detected) return jsonResponse({ lazycodex, omoJsonc: null, roles: [] }, 200, req, config);
const omoState = omo.readOmoRoleModels(omo.omoJsoncPath());
const omoModels = omoState.state === "present" ? omoState.models : {};
// History is optional: a file that cannot be read costs the Restore list, never role editing.
let changes: import("../../codex/role-model-history").RoleModelChange[] = [];
let historyUnavailable = false;
try {
changes = history.listRoleModelChanges(codexHome);
} catch (error) {
console.error(`[codex-agent-roles] could not read the change history: ${String(error)}`);
historyUnavailable = true;
}
return jsonResponse({
lazycodex,
omoJsonc: { state: omoState.state },
roles: roles.listCodexAgentRoleModels(codexHome).map(entry => ({
...entry,
effort: roles.readCodexAgentRoleEffort(entry.role, codexHome),
omoJsoncModel: omoModels[entry.role] ?? null,
})),
history: changes,
...(historyUnavailable ? { historyUnavailable } : {}),
}, 200, req, config);
}
if (url.pathname === AUTO_ASSIGN_PATH && req.method === "POST") {
const codexHome = getCodexHome();
if (!detectLazyCodex(codexHome).detected) return lazycodexNotDetected(ctx);
let body: { model?: unknown };
try {
body = await readManagementJsonBody(req);
} catch (error) {
rethrowManagementBodyTooLarge(error);
return jsonResponse({ error: "invalid JSON body" }, 400, req, config);
}
if (body?.model !== undefined && typeof body.model !== "string") {
return jsonResponse({ error: "model must be a string", code: "invalid_model" }, 400, req, config);
}
const [{ proposeCodexRoleModels, NoSizingModelError }, { fetchAllModels }] = await Promise.all([
import("./codex-role-auto-assign"),
import("./shared"),
]);
try {
return jsonResponse(await proposeCodexRoleModels({
config,
codexHome,
...(typeof body?.model === "string" ? { sizingModel: body.model } : {}),
fetchAllModels: deps.fetchAllModels ?? fetchAllModels,
...(deps.completeCodexRoleSizing ? { completeRoleSizing: deps.completeCodexRoleSizing } : {}),
...(deps.loadCodexRoleCapability ? { loadCapability: deps.loadCodexRoleCapability } : {}),
}), 200, req, config);
} catch (error) {
if (error instanceof NoSizingModelError) {
return jsonResponse({ error: error.message, code: "no_sizing_model" }, 409, req, config);
}
throw error;
}
}
if (!url.pathname.startsWith(ROLE_PATH_PREFIX) || req.method !== "PUT") return null;
const codexHome = getCodexHome();
if (!detectLazyCodex(codexHome).detected) return lazycodexNotDetected(ctx);
let role: string;
try {
role = decodeURIComponent(url.pathname.slice(ROLE_PATH_PREFIX.length));
} catch {
return jsonResponse({ error: "role must be URL-encoded", code: "invalid_role" }, 400, req, config);
}
let body: { model?: unknown; effort?: unknown; batch?: unknown; restores?: unknown };
try {
body = await readManagementJsonBody(req);
} catch (error) {
rethrowManagementBodyTooLarge(error);
return jsonResponse({ error: "invalid JSON body" }, 400, req, config);
}
// An omitted model leaves the role's model pin (or its inheritance) alone, an omitted effort
// keeps the effort, and an effort of null clears it. A body with neither changes nothing, which
// is a client mistake rather than a save, so it is refused before any role file is read.
if (body?.model === undefined && body?.effort === undefined) {
return jsonResponse({ error: "send a model, an effort, or both", code: "empty_update" }, 400, req, config);
}
if (body.batch !== undefined && !history.isRoleHistoryBatch(body.batch)) {
return jsonResponse({ error: "batch must be 1 to 64 letters, digits or dashes", code: "invalid_batch" }, 400, req, config);
}
if (body.restores !== undefined && !history.isRoleHistoryBatch(body.restores)) {
return jsonResponse({ error: "restores must be 1 to 64 letters, digits or dashes", code: "invalid_restores" }, 400, req, config);
}
// A write without `batch` starts a batch and the response names it; a later write joins it only
// while it is this home's newest batch, up to the listing size. History is optional: a file that
// cannot be read does not block saves, and such a save is simply not recorded.
let slot: import("../../codex/role-model-history").BatchSlot | null = null;
try {
const claimed = history.claimBatchRow(codexHome, body.batch);
if (claimed === "batch_closed") {
return jsonResponse({ error: "this batch takes no more changes; leave batch out to start a new one", code: "batch_closed" }, 409, req, config);
}
if (claimed === "batch_full") {
return jsonResponse({ error: `a batch holds at most ${history.ROLE_HISTORY_LIMIT} changes`, code: "batch_full" }, 409, req, config);
}
slot = claimed;
} catch (error) {
console.error(`[codex-agent-roles] could not read the change history: ${String(error)}`);
}
let model: string | undefined;
let effort: string | null | undefined;
let toml: { status: "written" | "unchanged" };
let before: import("../../codex/role-model-history").RoleSetting = { model: null, effort: null };
try {
model = body?.model === undefined ? undefined : roles.validateAgentRoleModel(body.model);
effort = body?.effort === undefined ? undefined : body.effort === null ? null : roles.validateAgentRoleEffort(body.effort);
} catch (error) {
if (error instanceof roles.AgentRoleModelError) return jsonResponse({ error: error.message, code: error.code }, 400, req, config);
throw error;
}
// A Restore names the batch it puts back, and only this Codex home's history can vouch for it: the
// write must be that role's earliest `before` in the batch, so a stale page cannot carry models
// across homes. A role that had no model pin is restored without a model, since a save keeps a pin.
if (typeof body.restores === "string") {
let allowed: import("../../codex/role-model-history").RoleSetting | null;
try {
allowed = history.restorableSetting(codexHome, body.restores, role);
} catch {
allowed = null;
}
if (!allowed || model !== (allowed.model ?? undefined) || effort !== allowed.effort) {
return jsonResponse({ error: "this Codex home's change history has no such change to restore", code: "restore_not_in_history" }, 409, req, config);
}
}
try {
before = {
model: roles.listCodexAgentRoleModels(codexHome).find(entry => entry.role === role)?.model ?? null,
effort: roles.readCodexAgentRoleEffort(role, codexHome),
};
toml = roles.writeCodexAgentRoleModel(role, model, codexHome, effort);
} catch (error) {
if (error instanceof roles.AgentRoleModelError) {
const status = error.code === "unknown_role" ? 404 : error.code === "invalid_model" || error.code === "invalid_effort" ? 400 : 409;
return jsonResponse({ error: error.message, code: error.code }, status, req, config);
}
// Filesystem and ownership errors carry absolute paths and UIDs; keep them out of the response.
return jsonResponse({ error: "could not write the role file", code: "write_failed" }, 500, req, config);
}
let recorded: string | undefined;
if (toml.status === "written" && slot) {
try {
history.recordRoleModelChange(codexHome, {
at: new Date().toISOString(),
batch: slot.batch,
n: slot.n,
role,
before,
after: { model: model ?? before.model, effort: effort === undefined ? before.effort : effort },
...(typeof body.restores === "string" ? { restores: body.restores } : {}),
});
recorded = slot.batch;
} catch (error) {
// The write already stands; a lost history row only costs the Restore button for it.
console.error(`[codex-agent-roles] could not record the change: ${String(error)}`);
}
}
// The role TOML is what Codex obeys, so its write stands even when the omo mirror cannot follow.
let omoStatus: ReturnType<typeof omo.writeOmoRoleModel> | "write_failed";
try {
const reasoning = effort === undefined ? undefined : effort === null ? null : omo.omoReasoningFor(effort);
omoStatus = omo.writeOmoRoleModel(role, model, omo.omoJsoncPath(), reasoning);
} catch {
omoStatus = "write_failed";
}
return jsonResponse({
ok: true,
role,
...(model !== undefined ? { model } : {}),
...(effort !== undefined ? { effort } : {}),
toml,
omoJsonc: { status: omoStatus },
...(recorded ? { batch: recorded } : {}),
}, 200, req, config);
}