@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
218 lines (213 loc) • 11.5 kB
text/typescript
import type { OcxConfig, OcxClaudeCodeConfig } from "../../types";
import { isAnthropicInstanceId, type AnthropicInstanceId } from "../../providers/anthropic-instance-id";
import { jsonResponse } from "../auth-cors";
function isPlainObject(value: unknown): value is Record<string, unknown> {
return value !== null && typeof value === "object" && !Array.isArray(value)
&& (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
}
/** Validate request shape and build only a candidate; callers rebuild within admission before publishing. */
export function prepareClaudeCodePatch(config: OcxConfig, body: Record<string, unknown>) {
for (const field of ["webSearchSidecar", "visionSidecar"] as const) {
const section = body[field];
if (section === undefined || section === null) continue;
if (!isPlainObject(section)) return jsonResponse({ error: `${field} must be an object or null` }, 400);
if (section.enabled !== undefined && typeof section.enabled !== "boolean") {
return jsonResponse({ error: `${field}.enabled must be a boolean` }, 400);
}
// Both overrides now speak their full unions (roadmap 060 web, 170
// vision revised). Vision's third arm is "routed" (loopback through the
// proxy's own router), never exa: exa is not an LLM, and accepting an
// unknown literal would persist a backend the vision resolver reads as
// unset (review F1's failure mode).
const allowedBackends = field === "webSearchSidecar"
? ["openai", "anthropic", "xai", "gemini", "exa"]
: ["openai", "anthropic", "routed"];
if (section.backend !== undefined && section.backend !== null
&& !allowedBackends.includes(section.backend as string)) {
return jsonResponse({ error: `${field}.backend must be ${allowedBackends.join(", ")}, or null` }, 400);
}
if (section.model !== undefined && typeof section.model !== "string") {
return jsonResponse({ error: `${field}.model must be a string` }, 400);
}
}
const next = { ...(config.claudeCode ?? {}) };
for (const field of ["webSearchSidecar", "visionSidecar"] as const) {
const section = body[field];
if (section === undefined) continue;
if (section === null || Object.keys(section as Record<string, unknown>).length === 0) {
delete next[field];
continue;
}
// The per-field validation above guarantees vision only ever carries the two-member
// union; the cast is the loop's shared-shape compromise, not a wider write path.
const requested = section as { enabled?: boolean; backend?: "openai" | "anthropic" | "xai" | "gemini" | "exa" | null; model?: string; anthropicInstance?: AnthropicInstanceId | null };
const override = { ...next[field] } as NonNullable<OcxClaudeCodeConfig[typeof field]>;
if (requested.enabled !== undefined) override.enabled = requested.enabled;
if (requested.anthropicInstance === null) delete override.anthropicInstance;
else if (isAnthropicInstanceId(requested.anthropicInstance)) override.anthropicInstance = requested.anthropicInstance;
if (requested.backend === null) delete override.backend;
else if (requested.backend !== undefined) override.backend = requested.backend as never;
if (requested.model === "") delete override.model;
else if (requested.model !== undefined) override.model = requested.model;
// Indexed write across the field union collapses to an intersection; runtime
// validation above already guarantees the per-field shape.
if (Object.keys(override).length > 0) next[field] = override as never;
else delete next[field];
}
if (body.enabled !== undefined) {
if (typeof body.enabled !== "boolean") return jsonResponse({ error: "enabled must be a boolean" }, 400);
next.enabled = body.enabled;
}
if (body.authMode !== undefined) {
// Three-state intent: "proxy" and "subscription" are stored literally and stick
// forever; "auto" DELETES the key so the mode is resolved from detected Claude
// auth on every launch. The 260720 round-trip contract survives as a superset —
// storing "subscription" literally is also backward-safe, since older readers
// only ever recognised "proxy".
if (body.authMode !== "proxy" && body.authMode !== "subscription" && body.authMode !== "auto") {
return jsonResponse({ error: "authMode must be \"auto\", \"proxy\", or \"subscription\"" }, 400);
}
if (body.authMode === "auto") delete next.authMode;
else next.authMode = body.authMode;
}
if (body.systemEnv !== undefined) {
if (typeof body.systemEnv !== "boolean") return jsonResponse({ error: "systemEnv must be a boolean" }, 400);
next.systemEnv = body.systemEnv;
}
if (body.alwaysEnableEffort !== undefined) {
if (typeof body.alwaysEnableEffort !== "boolean") return jsonResponse({ error: "alwaysEnableEffort must be a boolean" }, 400);
if (body.alwaysEnableEffort) next.alwaysEnableEffort = true;
else delete next.alwaysEnableEffort;
}
if (body.maxContextTokens !== undefined) {
// CONFIG-ONLY back-compat (GUI control removed — superseded by auto-context):
// null clears; otherwise a positive integer (devlog 136 B6).
if (body.maxContextTokens === null) {
delete next.maxContextTokens;
} else if (typeof body.maxContextTokens !== "number" || !Number.isInteger(body.maxContextTokens) || body.maxContextTokens <= 0) {
return jsonResponse({ error: "maxContextTokens must be a positive integer or null" }, 400);
} else {
next.maxContextTokens = body.maxContextTokens;
}
}
if (body.autoContext !== undefined) {
// Default-on boolean (devlog 260712 020): true = drop the key, false = store.
if (typeof body.autoContext !== "boolean") return jsonResponse({ error: "autoContext must be a boolean" }, 400);
if (body.autoContext) delete next.autoContext;
else next.autoContext = false;
}
if (body.contextAccounting !== undefined) {
// Sparse like autoContext (devlog/_plan/261009_claude_1m_default/030): "1m" is the default
// and drops the key; "200k" is the only stored value.
if (body.contextAccounting !== "1m" && body.contextAccounting !== "200k") {
return jsonResponse({ error: "contextAccounting must be \"1m\" or \"200k\"" }, 400);
}
if (body.contextAccounting === "200k") next.contextAccounting = "200k";
else delete next.contextAccounting;
}
if (body.injectAgents !== undefined) {
// Default-on boolean (devlog 260712 070): true = drop the key, false = store.
if (typeof body.injectAgents !== "boolean") return jsonResponse({ error: "injectAgents must be a boolean" }, 400);
if (body.injectAgents) delete next.injectAgents;
else next.injectAgents = false;
}
if (body.nativePassthrough !== undefined) {
// Default-on boolean: true = drop the key, false = store. Off routes bare Claude ids.
if (typeof body.nativePassthrough !== "boolean") return jsonResponse({ error: "nativePassthrough must be a boolean" }, 400);
if (body.nativePassthrough) delete next.nativePassthrough;
else next.nativePassthrough = false;
}
if (body.autoCompactWindow !== undefined) {
// null resets to the 350k default; otherwise the binary-accepted range
// 100_000..1_000_000 (2.1.207 pSo/yDs — audit 021 #1).
if (body.autoCompactWindow === null) {
delete next.autoCompactWindow;
} else if (typeof body.autoCompactWindow !== "number" || !Number.isInteger(body.autoCompactWindow) || body.autoCompactWindow < 100_000 || body.autoCompactWindow > 1_000_000) {
return jsonResponse({ error: "autoCompactWindow must be an integer between 100000 and 1000000, or null" }, 400);
} else {
next.autoCompactWindow = body.autoCompactWindow;
}
}
if (body.blockedSkills !== undefined) {
// null resets to the default (["claude-api"]); an array (possibly empty = off)
// must contain non-empty strings (devlog 060).
if (body.blockedSkills === null) {
delete next.blockedSkills;
} else if (!Array.isArray(body.blockedSkills) || body.blockedSkills.some(s => typeof s !== "string" || s.trim() === "")) {
return jsonResponse({ error: "blockedSkills must be an array of non-empty strings, or null" }, 400);
} else {
next.blockedSkills = (body.blockedSkills as string[]).map(s => s.trim());
}
}
if (body.tierModels !== undefined) {
// Family defaults also serve third-party callers that request native tier aliases.
if (body.tierModels === null) {
delete next.tierModels;
} else if (!isPlainObject(body.tierModels)) {
return jsonResponse({ error: "tierModels must be an object with string values, or null" }, 400);
} else {
for (const [tier, value] of Object.entries(body.tierModels)) {
if (typeof value !== "string") return jsonResponse({ error: `tierModels.${tier} must be a string` }, 400);
}
const tierModels = body.tierModels as Record<string, string>;
const tiers: Record<string, string> = {};
for (const tier of ["opus", "sonnet", "haiku", "fable"] as const) {
const value = tierModels[tier];
if (value !== undefined && value.trim() !== "") tiers[tier] = value.trim();
}
if (Object.keys(tiers).length > 0) next.tierModels = tiers;
else delete next.tierModels;
}
}
let nextFastMode = config.fastMode;
if (body.fastMode !== undefined) {
if (body.fastMode !== true && body.fastMode !== false && body.fastMode !== null) {
return jsonResponse({ error: "fastMode must be true, false, or null" }, 400);
}
nextFastMode = body.fastMode === null ? undefined : body.fastMode;
}
for (const field of ["model", "smallFastModel", "classifierModel"] as const) {
const value = body[field];
if (value === undefined) continue;
if (typeof value !== "string") return jsonResponse({ error: `${field} must be a string` }, 400);
if (value.trim() === "") delete next[field];
else next[field] = value.trim();
}
if (body.classifierFallbacks !== undefined) {
if (body.classifierFallbacks === null) {
delete next.classifierFallbacks;
} else {
if (!Array.isArray(body.classifierFallbacks)) {
return jsonResponse({ error: "classifierFallbacks must be an array of strings, or null" }, 400);
}
const list: string[] = [];
for (const entry of body.classifierFallbacks) {
if (typeof entry !== "string" || entry.trim() === "") {
return jsonResponse({ error: "classifierFallbacks entries must be non-empty strings" }, 400);
}
list.push(entry.trim());
}
if (list.length > 0) next.classifierFallbacks = list;
else delete next.classifierFallbacks;
}
}
if (body.modelMap !== undefined) {
if (body.modelMap === null) {
delete next.modelMap;
} else {
if (!isPlainObject(body.modelMap)) {
return jsonResponse({ error: "modelMap must be an object of string->string, or null" }, 400);
}
const map: Record<string, string> = {};
for (const [k, v] of Object.entries(body.modelMap)) {
if (typeof v !== "string" || k.trim() === "" || v.trim() === "") {
return jsonResponse({ error: "modelMap entries must be non-empty strings" }, 400);
}
map[k.trim()] = v.trim();
}
if (Object.keys(map).length > 0) next.modelMap = map;
else delete next.modelMap;
}
}
return { next, nextFastMode };
}