@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
87 lines (78 loc) • 3.92 kB
text/typescript
export function isSchemaObject(value: unknown): value is Record<string, unknown> {
return Boolean(value) && typeof value === "object" && !Array.isArray(value);
}
function decodeJsonPointerToken(token: string): string {
return token.replace(/~1/g, "/").replace(/~0/g, "~");
}
/** Resolve a local `#/`-rooted JSON Pointer against `root`; undefined when it does not resolve. */
export function lookupLocalJsonPointer(root: unknown, ref: string): unknown {
if (ref === "#" || ref === "#/") return root;
if (!ref.startsWith("#/")) return undefined;
let current: unknown = root;
for (const token of ref.slice(2).split("/").map(decodeJsonPointerToken)) {
if (!isSchemaObject(current) || !Object.hasOwn(current, token)) return undefined;
current = current[token];
}
return current;
}
/** Values a schema pins through `const`/`enum`, or undefined when it pins none. */
function xaiLiteralValues(schema: unknown): unknown[] | undefined {
if (!isSchemaObject(schema)) return undefined;
if (Object.hasOwn(schema, "const")) return [schema.const];
if (Array.isArray(schema.enum)) return schema.enum;
return undefined;
}
/** JSON type name for a literal, so it can be compared against a `type` keyword. */
function xaiJsonTypeOf(value: unknown): string {
if (value === null) return "null";
if (Array.isArray(value)) return "array";
if (typeof value === "string") return "string";
if (typeof value === "boolean") return "boolean";
if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
return "object";
}
/** Types a schema declares, or undefined when it constrains none. */
function xaiDeclaredTypes(schema: unknown): Set<string> | undefined {
if (!isSchemaObject(schema)) return undefined;
const type = schema.type;
if (typeof type === "string") return new Set([type]);
if (Array.isArray(type) && type.every(item => typeof item === "string")) return new Set(type as string[]);
return undefined;
}
/** `integer` is a subset of `number`, so those two names overlap rather than exclude. */
function xaiTypesOverlap(left: string, right: string): boolean {
if (left === right) return true;
return (left === "integer" && right === "number") || (left === "number" && right === "integer");
}
/**
* Conservative mutual-exclusion test: true only when no instance can satisfy both schemas.
* Proof comes from disjoint literal sets or disjoint declared types; anything it cannot prove
* is reported as overlapping so the caller refuses the merge instead of widening the schema.
*/
function xaiSchemasAreProvablyDisjoint(left: unknown, right: unknown): boolean {
const leftValues = xaiLiteralValues(left);
const rightValues = xaiLiteralValues(right);
if (leftValues && rightValues) {
const seen = new Set(rightValues.map(value => JSON.stringify(value)));
return leftValues.every(value => !seen.has(JSON.stringify(value)));
}
const leftTypes = xaiDeclaredTypes(left);
const rightTypes = xaiDeclaredTypes(right);
const literalsExcludedByTypes = (values: unknown[], types: Set<string>): boolean =>
values.every(value => ![...types].some(type => xaiTypesOverlap(xaiJsonTypeOf(value), type)));
if (leftValues && rightTypes) return literalsExcludedByTypes(leftValues, rightTypes);
if (rightValues && leftTypes) return literalsExcludedByTypes(rightValues, leftTypes);
if (leftTypes && rightTypes) {
return ![...leftTypes].some(leftType => [...rightTypes].some(rightType => xaiTypesOverlap(leftType, rightType)));
}
return false;
}
/** Every pair provably disjoint, so a union over them accepts each instance exactly once. */
export function xaiSchemasArePairwiseDisjoint(schemas: unknown[]): boolean {
for (let i = 0; i < schemas.length; i += 1) {
for (let j = i + 1; j < schemas.length; j += 1) {
if (!xaiSchemasAreProvablyDisjoint(schemas[i], schemas[j])) return false;
}
}
return true;
}