@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
264 lines (247 loc) • 12.2 kB
text/typescript
/**
* The read-only half of role auto-assign: size every Codex agent role with one model call, map
* each size to a concrete model and effort, and return the proposals. Nothing is written here;
* the dashboard and "ocx agent roles suggest --apply" apply a proposal through the ordinary
* PUT /api/codex-agent-roles/{role}.
*/
import { readFileSync } from "node:fs";
import { join } from "node:path";
import type { OcxConfig } from "../../types";
import type { CatalogModel } from "../../codex/catalog";
import type { RoleModelCandidate } from "../../codex/role-auto-assign";
import type { LoadCapability } from "../../codex/role-capability";
import type { SizingDomain } from "../../codex/role-sizing";
export interface RoleSizingCall {
readonly model: string;
readonly system: string;
readonly user: string;
}
export type CompleteRoleSizing = (call: RoleSizingCall, config: OcxConfig) => Promise<{ text: string; error?: string }>;
const SIZING_TIMEOUT_MS = 180_000;
const MAX_SIZING_RESPONSE_BYTES = 1024 * 1024;
/**
* The completion error can carry upstream response text and exception messages, which may
* include paths, account identifiers or secrets the redactor does not recognise. Only a fixed
* category, plus a bare HTTP status, leaves the management response and the CLI.
*/
export function publicSizingError(error: string): string {
const http = /^[\w .-]* HTTP (\d{3}):/.exec(error);
if (http) return `HTTP ${http[1]}`;
if (error.endsWith("response exceeded byte bound")) return "the response was too large";
if (error.endsWith("returned non-JSON")) return "the response was not JSON";
if (error.endsWith("returned no text")) return "the response had no text";
return "the request could not be completed";
}
async function completeThroughProxy(call: RoleSizingCall, config: OcxConfig) {
const { postLocalChatCompletion } = await import("../../lib/local-chat-completion");
return postLocalChatCompletion({
config,
label: "role sizing",
logTag: "role-sizing",
timeoutMs: SIZING_TIMEOUT_MS,
maxResponseBytes: MAX_SIZING_RESPONSE_BYTES,
boundWhileStreaming: true,
body: {
model: call.model,
messages: [{ role: "system", content: call.system }, { role: "user", content: call.user }],
},
});
}
async function modelCandidates(slugs: readonly string[], models: readonly CatalogModel[]): Promise<RoleModelCandidate[]> {
const [catalog, { resolveMatchedPrice }] = await Promise.all([
import("../../codex/catalog"),
import("../../usage/cost"),
]);
const nativeSlugs = catalog.listCatalogNativeSlugs();
const routed = new Map(models.map(model => [catalog.catalogModelSlug(model), model]));
// A routed model that declares no levels still gets the ladder Codex shows for it, the same one
// the Models page lists, so its proposal carries an effort instead of none. An explicit empty
// ladder means the model takes no effort control, and the written catalog lists none for it.
const written = catalog.catalogModelLadders(slugs);
const unitPrice = (provider: string, modelId: string): number | null => {
const cost = resolveMatchedPrice(provider, modelId)?.cost4;
return cost ? cost.input + cost.output : null;
};
return slugs.map(slug => {
const row = routed.get(slug);
if (row) {
const ladder = written.get(slug);
const efforts = Array.isArray(row.reasoningEfforts) ? row.reasoningEfforts : ladder?.efforts ?? [];
// A row without its own default keeps the one Codex shows, when that rung is on the ladder.
const shownDefault = ladder?.defaultEffort !== undefined && efforts.includes(ladder.defaultEffort)
? ladder.defaultEffort
: undefined;
const defaultEffort = row.defaultReasoningEffort ?? shownDefault;
return {
model: slug,
unitPrice: unitPrice(row.provider, row.id),
efforts,
...(defaultEffort ? { defaultEffort } : {}),
};
}
if (nativeSlugs.includes(slug)) {
const defaultEffort = catalog.nativeDefaultReasoningEffort(slug);
return {
model: slug,
unitPrice: unitPrice("openai", slug),
efforts: catalog.nativeReasoningEfforts(slug),
...(defaultEffort ? { defaultEffort } : {}),
};
}
return { model: slug, unitPrice: null, efforts: [] };
});
}
async function roleModelCandidates(config: OcxConfig, models: readonly CatalogModel[]): Promise<RoleModelCandidate[]> {
const [{ listCatalogNativeSlugs }, { subagentSelectableModels }] = await Promise.all([
import("../../codex/catalog"),
import("../../codex/subagent-selectable-models"),
]);
return modelCandidates(subagentSelectableModels(config, models, listCatalogNativeSlugs()), models);
}
export class NoSizingModelError extends Error {}
function resolveSizingModel(sizingModel: string | undefined, readConfiguredDefaultModel: () => string | null): string {
const model = sizingModel?.trim() || readConfiguredDefaultModel();
if (!model) throw new NoSizingModelError("no default model is set in Codex config.toml; pass a sizing model");
return model;
}
export async function proposeCodexRoleModels(options: {
config: OcxConfig;
codexHome: string;
sizingModel?: string;
fetchAllModels: (config: OcxConfig) => Promise<CatalogModel[]>;
completeRoleSizing?: CompleteRoleSizing;
loadCapability?: LoadCapability;
}) {
const [roles, sizing, assign, capability, { readConfiguredDefaultModel }] = await Promise.all([
import("../../codex/agent-role-models"),
import("../../codex/role-sizing"),
import("../../codex/role-auto-assign"),
import("../../codex/role-capability"),
import("../../codex/catalog/parsing"),
]);
const sizingModel = resolveSizingModel(options.sizingModel, readConfiguredDefaultModel);
const roleRows = roles.listCodexAgentRoleModels(options.codexHome).map(row => ({
role: row.role,
model: row.model,
effort: roles.readCodexAgentRoleEffort(row.role, options.codexHome),
}));
const inputs: { role: string; instructions: string }[] = [];
const outcomes = new Map<string, import("../../codex/role-sizing").RoleSizingOutcome>();
for (const row of roleRows) {
let excerpt: string | null = null;
try {
excerpt = sizing.roleInstructionsExcerpt(readFileSync(join(options.codexHome, "agents", `${row.role}.toml`), "utf8"));
} catch { /* an unreadable role is reported unsized below */ }
if (excerpt === null) outcomes.set(row.role, { unsized: "the role file has no description or developer_instructions to size from" });
else inputs.push({ role: row.role, instructions: excerpt });
}
let sizingError: string | null = null;
if (inputs.length > 0) {
const answer = await (options.completeRoleSizing ?? completeThroughProxy)({
model: sizingModel,
system: sizing.ROLE_SIZING_SYSTEM_PROMPT,
user: sizing.buildRoleSizingUserMessage(inputs),
}, options.config);
const names = inputs.map(input => input.role);
if (answer.error) {
sizingError = publicSizingError(answer.error);
for (const role of names) outcomes.set(role, { unsized: `the sizing call failed: ${sizingError}` });
} else {
for (const [role, outcome] of sizing.parseRoleSizingResponse(answer.text, names)) outcomes.set(role, outcome);
}
}
const candidates = await roleModelCandidates(options.config, await options.fetchAllModels(options.config));
const classified = assign.classifyRoleModelCandidates(candidates, options.config.codexRoleTiers);
// Measured capability is a better tier signal than price, and its absence is not an error: a
// failed read leaves every role on price rank and says so.
const domains = new Set([...outcomes.values()].flatMap(outcome => "sizing" in outcome ? [outcome.sizing.domain] : []));
let table: import("../../codex/role-capability").CapabilityTable | null = null;
let capabilityError: string | null = null;
if (domains.size > 0) {
try {
table = await (options.loadCapability ?? capability.loadCapabilityTable)(options.config);
} catch {
capabilityError = "the measured capability source could not be read";
}
}
const classifiedByDomain = new Map<SizingDomain, ReturnType<typeof assign.classifyRoleModelCandidates>>();
for (const domain of domains) {
const scores = table?.domains[domain];
if (!scores) continue;
const measured = new Map(candidates.flatMap(candidate => {
const score = scores.get(capability.candidateModelKey(candidate.model));
return score === undefined ? [] : [[candidate.model, score] as const];
}));
classifiedByDomain.set(domain, assign.classifyRoleModelCandidates(candidates, options.config.codexRoleTiers, measured));
}
return {
sizingModel,
sizingError,
proposals: assign.buildRoleProposals(roleRows, outcomes, classified, classifiedByDomain),
candidates: classified.map(({ model, tier, tierSource, unitPrice }) => ({ model, tier, tierSource, unitPrice })),
capability: capabilityReport(table?.source ?? null, table, capabilityError, classifiedByDomain),
};
}
/** The attribution and per-domain tiers; raw scores only from a source whose terms allow it. */
function capabilityReport(
source: import("../../codex/role-capability").CapabilitySource | null,
table: import("../../codex/role-capability").CapabilityTable | null,
error: string | null,
classifiedByDomain: ReadonlyMap<SizingDomain, ReturnType<typeof import("../../codex/role-auto-assign").classifyRoleModelCandidates>>,
) {
return {
name: source?.name ?? null,
url: source?.url ?? null,
license: source?.license ?? null,
publishedAt: table?.publishedAt ?? null,
error: error ?? table?.fallbackReason ?? null,
domains: Object.fromEntries([...classifiedByDomain].map(([domain, list]) => [domain,
list.filter(candidate => candidate.tierSource === "measured")
.map(({ model, tier, score }) => (source?.redistributable ? { model, tier, score } : { model, tier }))])),
};
}
export const DELEGATED_WORK_ROLE = "delegated-work";
/**
* The same sizing for the Subagents page's delegation default: the work a parent hands its
* preferred subagent is sized as one standing role, and the pick comes from the models that page
* offers. Effort is always proposed, restricted to the Codex levels the page can save.
*/
export async function proposeDelegationModel(options: {
config: OcxConfig;
work: string;
offered: readonly string[];
sizingModel?: string;
models: readonly CatalogModel[];
completeRoleSizing?: CompleteRoleSizing;
}) {
const [sizing, assign, { readConfiguredDefaultModel }, { isCodexReasoningEffort }] = await Promise.all([
import("../../codex/role-sizing"),
import("../../codex/role-auto-assign"),
import("../../codex/catalog/parsing"),
import("../../reasoning-effort"),
]);
const sizingModel = resolveSizingModel(options.sizingModel, readConfiguredDefaultModel);
const answer = await (options.completeRoleSizing ?? completeThroughProxy)({
model: sizingModel,
system: sizing.DELEGATED_WORK_SIZING_SYSTEM_PROMPT,
user: sizing.buildRoleSizingUserMessage([{ role: DELEGATED_WORK_ROLE, instructions: options.work }]),
}, options.config);
const sizingError = answer.error ? publicSizingError(answer.error) : null;
const outcomes = sizingError
? new Map([[DELEGATED_WORK_ROLE, { unsized: `the sizing call failed: ${sizingError}` }]])
: sizing.parseRoleSizingResponse(answer.text, [DELEGATED_WORK_ROLE]);
const candidates = (await modelCandidates(options.offered, options.models))
.map(candidate => ({ ...candidate, efforts: candidate.efforts.filter(isCodexReasoningEffort) }));
const classified = assign.classifyRoleModelCandidates(candidates, options.config.codexRoleTiers);
const [proposal] = assign.buildRoleProposals([{
role: DELEGATED_WORK_ROLE,
model: options.config.injectionModel ?? null,
effort: options.config.injectionEffort ?? null,
}], outcomes, classified);
return {
sizingModel,
sizingError,
proposal: proposal!,
candidates: classified.map(({ model, tier, tierSource, unitPrice }) => ({ model, tier, tierSource, unitPrice })),
};
}