@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
272 lines (249 loc) • 11.5 kB
text/typescript
// Based on Anthropic SDK's transformJSONSchema, preserving root $defs required by root $ref:
// https://github.com/anthropics/anthropic-sdk-typescript/blob/main/src/lib/transform-json-schema.ts
const SUPPORTED_STRING_FORMATS = new Set([
"date-time",
"time",
"date",
"duration",
"email",
"hostname",
"uri",
"ipv4",
"ipv6",
"uuid",
]);
function isRecord(value: unknown): value is Record<string, unknown> {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
function take(schema: Record<string, unknown>, key: string): unknown {
const value = schema[key];
delete schema[key];
return value;
}
function normalizeSubschema(value: unknown): unknown {
return isRecord(value) ? normalizeSchema(value) : value;
}
function normalizeSchema(schema: Record<string, unknown>): Record<string, unknown> {
const normalized: Record<string, unknown> = {};
const defs = take(schema, "$defs");
if (isRecord(defs)) {
normalized.$defs = Object.fromEntries(
Object.entries(defs).map(([name, definition]) => [name, normalizeSubschema(definition)]),
);
}
const ref = take(schema, "$ref");
if (ref !== undefined) {
normalized.$ref = ref;
return normalized;
}
const type = take(schema, "type");
const anyOf = schema.anyOf;
const oneOf = schema.oneOf;
const allOf = schema.allOf;
if (Array.isArray(anyOf)) {
take(schema, "anyOf");
normalized.anyOf = anyOf.map(normalizeSubschema);
} else if (Array.isArray(oneOf)) {
take(schema, "oneOf");
normalized.anyOf = oneOf.map(normalizeSubschema);
} else if (Array.isArray(allOf)) {
take(schema, "allOf");
normalized.allOf = allOf.map(normalizeSubschema);
} else {
if (type === undefined) {
throw new Error("JSON schema must have a type defined if anyOf/oneOf/allOf are not used");
}
normalized.type = type;
}
const description = take(schema, "description");
if (description !== undefined) {
normalized.description = description;
}
const title = take(schema, "title");
if (title !== undefined) {
normalized.title = title;
}
if (type === "object") {
const properties = take(schema, "properties");
normalized.properties = isRecord(properties)
? Object.fromEntries(
Object.entries(properties).map(([name, property]) => [name, normalizeSubschema(property)]),
)
: {};
take(schema, "additionalProperties");
normalized.additionalProperties = false;
const required = take(schema, "required");
if (required !== undefined) {
normalized.required = required;
}
} else if (type === "string") {
const format = take(schema, "format");
if (typeof format === "string" && SUPPORTED_STRING_FORMATS.has(format)) {
normalized.format = format;
} else if (format !== undefined) {
schema.format = format;
}
} else if (type === "array") {
const items = take(schema, "items");
if (items !== undefined) {
normalized.items = normalizeSubschema(items);
}
const minItems = take(schema, "minItems");
if (minItems === 0 || minItems === 1) {
normalized.minItems = minItems;
} else if (minItems !== undefined) {
schema.minItems = minItems;
}
}
const unsupported = Object.entries(schema);
if (unsupported.length > 0) {
const existingDescription =
typeof normalized.description === "string" ? `${normalized.description}\n\n` : "";
normalized.description = `${existingDescription}{${unsupported
.map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
.join(", ")}}`;
}
return normalized;
}
export function normalizeAnthropicOutputSchema(
schema: Record<string, unknown>,
): Record<string, unknown> {
return normalizeSchema(structuredClone(schema));
}
export function isAnthropicOutputSchema(schema: Record<string, unknown>): boolean {
try {
normalizeAnthropicOutputSchema(schema);
return true;
} catch {
return false;
}
}
// Anthropic accepts `uri`, but OpenAI strict Structured Outputs documents a narrower
// string-format set. Keep this separate from SUPPORTED_STRING_FORMATS: changing the Anthropic
// normalizer to satisfy the translated OpenAI route would silently remove native guidance.
const OPENAI_STRICT_STRING_FORMATS = new Set([
"date-time", "time", "date", "duration", "email", "hostname", "ipv4", "ipv6", "uuid",
]);
const OPENAI_STRICT_COMMON_KEYWORDS = new Set([
"$defs", "definitions", "$ref", "type", "title", "description", "enum", "const", "anyOf",
]);
const OPENAI_STRICT_OBJECT_KEYWORDS = new Set([
"properties", "patternProperties", "required", "additionalProperties",
]);
const OPENAI_STRICT_STRING_KEYWORDS = new Set(["pattern", "format"]);
const OPENAI_STRICT_NUMBER_KEYWORDS = new Set([
"multipleOf", "maximum", "exclusiveMaximum", "minimum", "exclusiveMinimum",
]);
const OPENAI_STRICT_ARRAY_KEYWORDS = new Set(["items", "minItems", "maxItems"]);
const OPENAI_STRICT_TYPES = new Set(["string", "number", "boolean", "integer", "object", "array", "null"]);
// Fine-tuned models implement a narrower documented Structured Outputs subset. Falling back to
// non-strict keeps the caller's schema intact; deleting these constraints would silently widen it.
const OPENAI_FINE_TUNED_UNSUPPORTED_KEYWORDS = new Set([
"patternProperties", "pattern", "format",
...OPENAI_STRICT_NUMBER_KEYWORDS,
"minItems", "maxItems",
]);
function openAiStrictSchemaTypes(value: unknown): Set<string> | null {
if (value === undefined) return new Set();
const values = typeof value === "string" ? [value] : value;
if (!Array.isArray(values) || values.length === 0
|| values.some(type => typeof type !== "string" || !OPENAI_STRICT_TYPES.has(type))) return null;
const types = new Set(values);
if (types.size !== values.length) return null;
// OpenAI documents unions through anyOf; the type-array shorthand is reserved for nullable fields.
if (types.size > 1 && (types.size !== 2 || !types.has("null"))) return null;
return types;
}
function hasOnlyOpenAiStrictKeywords(node: Record<string, unknown>, types: Set<string>): boolean {
for (const key of Object.keys(node)) {
if (OPENAI_STRICT_COMMON_KEYWORDS.has(key)) continue;
if (types.has("object") && OPENAI_STRICT_OBJECT_KEYWORDS.has(key)) continue;
if (types.has("string") && OPENAI_STRICT_STRING_KEYWORDS.has(key)) continue;
if ((types.has("number") || types.has("integer")) && OPENAI_STRICT_NUMBER_KEYWORDS.has(key)) continue;
if (types.has("array") && OPENAI_STRICT_ARRAY_KEYWORDS.has(key)) continue;
return false;
}
return true;
}
/**
* Can this schema preserve its object contract under OpenAI strict mode?
*
* OpenAI's structured-output strict mode demands exactly that, and rejects anything else with
* `'required' is required to be supplied and to be an array including every key in properties`.
* Anthropic has no such rule, so a caller's legal optional field makes an otherwise identical
* schema a 400 on one vendor and fine on the other.
*
* A caller that marks a field optional means it. Rewriting `required` to satisfy strict mode
* would silently change the contract the caller asked for, so the only honest answer is to stop
* claiming strict for these schemas -- the schema is still sent and still honoured as guidance.
*/
export function satisfiesOpenAiStrictSchema(value: unknown, fineTuned = false): boolean {
// Callers pass one schema node. Boolean/null/array schemas are outside the documented
// Structured Outputs subset; schema lists such as anyOf are validated explicitly below.
if (!isRecord(value)) return false;
const node = value;
// This is a compatibility proof, so it fails closed on unknown schema keywords instead of
// maintaining an inevitably incomplete denylist. The original schema is still forwarded.
const types = openAiStrictSchemaTypes(node.type);
if (!types || !hasOnlyOpenAiStrictKeywords(node, types)) return false;
if (fineTuned && Object.keys(node).some(key => OPENAI_FINE_TUNED_UNSUPPORTED_KEYWORDS.has(key))) {
return false;
}
if (Object.hasOwn(node, "$ref") && typeof node.$ref !== "string") return false;
if (Object.hasOwn(node, "title") && typeof node.title !== "string") return false;
if (Object.hasOwn(node, "description") && typeof node.description !== "string") return false;
if (Object.hasOwn(node, "enum") && (!Array.isArray(node.enum) || node.enum.length === 0)) return false;
if (Object.hasOwn(node, "format")) {
if (typeof node.format !== "string" || !OPENAI_STRICT_STRING_FORMATS.has(node.format)) {
return false;
}
}
if (Object.hasOwn(node, "pattern") && typeof node.pattern !== "string") return false;
for (const key of OPENAI_STRICT_NUMBER_KEYWORDS) {
const constraint = node[key];
if (Object.hasOwn(node, key) && (typeof constraint !== "number" || !Number.isFinite(constraint))) return false;
}
// JSON Schema requires a strictly positive divisor; a zero or negative one is a schema the
// destination rejects, so it cannot be certified strict.
if (Object.hasOwn(node, "multipleOf") && (node.multipleOf as number) <= 0) return false;
for (const key of ["minItems", "maxItems"]) {
const constraint = node[key];
if (Object.hasOwn(node, key)
&& (typeof constraint !== "number" || !Number.isInteger(constraint) || constraint < 0)) return false;
}
const properties = node.properties;
const objectType = types.has("object");
if (objectType || Object.hasOwn(node, "properties")) {
// An object node must list every property in `required` AND close itself to extras. The
// caller's schema is forwarded verbatim -- `isAnthropicOutputSchema` normalizes a CLONE for
// its own acceptance check -- so an object that never said `additionalProperties: false`
// reaches the wire without it and is refused, however complete its `required` is.
// Anthropic's acceptance probe fills a missing/malformed property map on its clone;
// that must not certify the unchanged bare object which actually reaches the wire.
if (!isRecord(properties) || node.additionalProperties !== false) return false;
// Strict mode also requires `required` to be supplied at all, even for an empty
// `properties` map, so a missing array is not the same as an empty one.
if (!Array.isArray(node.required)) return false;
const keys = Object.keys(properties);
const required: unknown[] = node.required;
const requiredKeys = new Set(required);
if (required.length !== keys.length || keys.some(key => !requiredKeys.has(key))) return false;
}
// Walk schema positions, not arbitrary JSON values: a property named `not` or an enum/const
// value containing `properties` is data, not another schema node to certify or reject.
for (const key of ["properties", "$defs", "definitions", "patternProperties"]) {
if (!Object.hasOwn(node, key)) continue;
const entries = node[key];
if (!isRecord(entries)
|| !Object.values(entries).every(entry => satisfiesOpenAiStrictSchema(entry, fineTuned))) return false;
}
if (Object.hasOwn(node, "items") && !satisfiesOpenAiStrictSchema(node.items, fineTuned)) return false;
if (Object.hasOwn(node, "anyOf")) {
const anyOf = node.anyOf;
if (!Array.isArray(anyOf) || anyOf.length === 0
|| !anyOf.every(entry => satisfiesOpenAiStrictSchema(entry, fineTuned))) {
return false;
}
}
return true;
}