@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
271 lines (249 loc) • 12.2 kB
text/typescript
import { stripResponsesOnlyEncryptedMarker } from "./responses-tool-schema";
/**
* Anthropic rejects a root-level missing `type` and root-level `oneOf`/`anyOf`/`allOf` in
* `input_schema`. Normalize the root only: ensure `type:"object"` + `properties`, flatten root
* composition while preserving nested schemas, and inline local `#/...` refs (RFC 6901: the
* fragment is percent-decoded, numeric tokens index arrays) before flattening so a referenced
* branch keeps its parameters and required members. A `$ref` with siblings merges both property
* maps, unions `required`, and keeps a property declared on both sides conjunctive under
* `allOf`; composition on both sides is kept, not replaced. A property met twice on an all-`allOf`
* path is conjoined the same way. Composition branches and direct alias hops share one 4096-step
* budget. Shared by the anthropic and command-code adapters; Command Code's text-call recovery
* matches markup against the normalized schema and validates it against the declared one too.
*
* Flattening root alternatives is lossy: later branches win for a same-named property, and
* `oneOf`/`anyOf` branch `required` members are not promoted because no branch is guaranteed.
* A root `oneOf` whose branches declare `action.enum: ["read"]` and `action.enum: ["write"]`
* yields a schema that permits only `"write"`. Covered by
* tests/providers/command-code-tool-schema.test.ts and
* tests/adapters/anthropic/anthropic-tool-schema.test.ts.
*/
const LOCAL_REF_PREFIX = "#/";
const COMPOSITION_KEYS = ["oneOf", "anyOf", "allOf"] as const;
/** Branch visits allowed while expanding root composition; shared ref graphs multiply. */
const ROOT_COMPOSITION_EXPANSION_LIMIT = 4096;
const ROOT_COMPOSITION_LIMIT_MESSAGE =
"tool input schema reference expansion exceeded the supported limit";
/** Shared work budget: composition branches and direct `$ref` alias hops both count against it. */
interface ExpansionBudget { count: number }
function spend(budget: ExpansionBudget): void {
budget.count += 1;
if (budget.count > ROOT_COMPOSITION_EXPANSION_LIMIT) throw new Error(ROOT_COMPOSITION_LIMIT_MESSAGE);
}
function decodePointerSegment(segment: string): string {
return segment.replace(/~1/g, "/").replace(/~0/g, "~");
}
/**
* RFC 6901: a URI fragment is percent-decoded before it is split into tokens, each token then
* undoes `~1`/`~0`, and a canonical decimal token selects an array element. A malformed escape
* or a path that does not resolve leaves the reference unresolved.
*/
function resolveLocalPointer(root: Record<string, unknown>, pointer: string): Record<string, unknown> | undefined {
if (!pointer.startsWith(LOCAL_REF_PREFIX)) return undefined;
let decoded: string;
try {
decoded = decodeURIComponent(pointer.slice(2));
} catch {
return undefined;
}
let node: unknown = root;
for (const segment of decoded.split("/")) {
const token = decodePointerSegment(segment);
if (Array.isArray(node)) {
if (!/^(?:0|[1-9]\d*)$/.test(token)) return undefined;
node = node[Number(token)];
continue;
}
if (!node || typeof node !== "object" || !Object.hasOwn(node, token)) return undefined;
node = (node as Record<string, unknown>)[token];
}
return node && typeof node === "object" && !Array.isArray(node)
? node as Record<string, unknown>
: undefined;
}
function asSchemaMap(value: unknown): Record<string, unknown> | undefined {
return value && typeof value === "object" && !Array.isArray(value)
? value as Record<string, unknown>
: undefined;
}
/** Conjunctions this module built, so a later collision extends them instead of nesting. */
const builtConjunctions = new WeakSet<object>();
/**
* Both schemas apply. A conjunction built here gains one more member; a caller's own `allOf`
* schema stays a single member so its meaning is not spliced into ours.
*/
function conjoin(existing: unknown, schema: unknown): Record<string, unknown> {
const members = existing && typeof existing === "object" && builtConjunctions.has(existing)
? [...((existing as { allOf: unknown[] }).allOf)]
: [existing];
if (!members.includes(schema)) members.push(schema);
const conjunction = { allOf: members };
builtConjunctions.add(conjunction);
return conjunction;
}
/**
* JSON Schema applies a `$ref` sibling's keywords alongside the referenced schema rather than
* replacing them. Spread would let a sibling that adds one parameter drop the referenced ones, so
* merge both `properties` maps, union `required`, and keep both constraints under `allOf` when a
* property appears on both sides.
*/
function mergeRefSiblings(
resolved: Record<string, unknown>,
siblings: Record<string, unknown>,
): Record<string, unknown> {
const merged: Record<string, unknown> = { ...resolved, ...siblings };
const resolvedProperties = asSchemaMap(resolved.properties);
const siblingProperties = asSchemaMap(siblings.properties);
if (resolvedProperties || siblingProperties) {
// Null prototype keeps a parameter named "__proto__" as data instead of replacing the prototype.
const properties: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
for (const [name, schema] of Object.entries(resolvedProperties ?? {})) properties[name] = schema;
for (const [name, schema] of Object.entries(siblingProperties ?? {})) {
const existing = properties[name];
properties[name] = existing === undefined ? schema : conjoin(existing, schema);
}
merged.properties = properties;
}
const required = new Set<string>();
for (const source of [resolved.required, siblings.required]) {
if (!Array.isArray(source)) continue;
for (const item of source) if (typeof item === "string") required.add(item);
}
if (required.size > 0) merged.required = [...required];
else delete merged.required;
// The spread above lets a sibling's composition replace the referenced schema's. Both sides
// apply, so concatenate `allOf` and keep each side's `oneOf`/`anyOf` as its own `allOf` entry.
const allOf: unknown[] = [];
for (const source of [resolved, siblings]) if (Array.isArray(source.allOf)) allOf.push(...source.allOf);
for (const key of ["oneOf", "anyOf"] as const) {
if (Array.isArray(resolved[key]) && Array.isArray(siblings[key])) {
allOf.push({ [key]: resolved[key] }, { [key]: siblings[key] });
delete merged[key];
}
}
if (allOf.length > 0) merged.allOf = allOf;
return merged;
}
/**
* Inline a local `#/...` reference so root-composition branches keep their definitions. Each
* alias hop spends the shared budget, so a long direct chain fails explicitly instead of
* recursing until the stack or allocation gives out.
*/
function dereferenceLocal(
node: unknown,
root: Record<string, unknown>,
seen: ReadonlySet<string>,
budget: ExpansionBudget,
): Record<string, unknown> | undefined {
if (!node || typeof node !== "object" || Array.isArray(node)) return undefined;
const record = node as Record<string, unknown>;
const ref = record.$ref;
if (typeof ref !== "string" || !ref.startsWith(LOCAL_REF_PREFIX) || seen.has(ref)) return record;
spend(budget);
const target = resolveLocalPointer(root, ref);
if (!target) return record;
const nextSeen = new Set(seen);
nextSeen.add(ref);
const resolved = dereferenceLocal(target, root, nextSeen, budget) ?? target;
const { $ref: _ignored, ...siblings } = record;
return mergeRefSiblings(resolved, siblings);
}
/**
* `allOf` applies every branch, so a property met twice on an all-`allOf` path keeps both
* schemas under `allOf`. On a path through `oneOf`/`anyOf` the documented last-branch-wins
* flattening still applies. The same schema object reached twice (a shared `$ref`) is kept once.
*/
function collectProperty(
properties: Record<string, unknown>,
name: string,
schema: unknown,
conjunctive: boolean,
): void {
const existing = properties[name];
if (existing === schema) return;
properties[name] = conjunctive && existing !== undefined ? conjoin(existing, schema) : schema;
}
/**
* Flatten root-equivalent composition, including composition that a resolved `$ref` branch
* carries. Only a node standing where the root composition stands contributes; `properties`
* and nested property schemas are never traversed. `chain` holds the refs already inlined on
* this path, so a self- or mutually-recursive definition stops instead of recursing forever.
* `visits` bounds the total expansion so a shared acyclic graph cannot multiply work; exceeding
* it throws, and the adapter build then fails as an explicit invalid request.
*/
function collectRootComposition(
node: Record<string, unknown>,
root: Record<string, unknown>,
chain: ReadonlySet<string>,
mergeRequired: boolean,
properties: Record<string, unknown>,
required: Set<string>,
budget: ExpansionBudget,
): void {
for (const key of COMPOSITION_KEYS) {
const variants = node[key];
if (!Array.isArray(variants)) continue;
const branchMergesRequired = mergeRequired && key === "allOf";
for (const variant of variants) {
const record = asSchemaMap(variant);
if (!record) continue;
const ref = typeof record.$ref === "string" ? record.$ref : undefined;
if (ref && chain.has(ref)) continue;
spend(budget);
const resolved = dereferenceLocal(variant, root, chain, budget);
if (!resolved) continue;
const nextChain = ref ? new Set(chain).add(ref) : chain;
const branchProperties = asSchemaMap(resolved.properties);
if (branchProperties) {
for (const [name, schema] of Object.entries(branchProperties)) {
collectProperty(properties, name, schema, branchMergesRequired);
}
}
if (branchMergesRequired && Array.isArray(resolved.required)) {
for (const item of resolved.required) if (typeof item === "string") required.add(item);
}
collectRootComposition(resolved, root, nextChain, branchMergesRequired, properties, required, budget);
}
}
}
export function normalizeAnthropicInputSchema(schema: unknown): Record<string, unknown> {
const stripped = stripResponsesOnlyEncryptedMarker(schema);
const obj = stripped && typeof stripped === "object" && !Array.isArray(stripped)
? stripped as Record<string, unknown>
: {};
const budget: ExpansionBudget = { count: 0 };
const root = dereferenceLocal(obj, obj, new Set(), budget) ?? obj;
const hasRootComposition = COMPOSITION_KEYS.some(key => Array.isArray(root[key]));
const type = root.type;
const rootObjectType = type === "object" || (Array.isArray(type) && type.includes("object"));
if (!hasRootComposition) {
const normalized: Record<string, unknown> = rootObjectType && type === "object"
? { ...root }
: { ...root, type: "object" };
if (normalized.properties === undefined || normalized.properties === null) {
normalized.properties = {};
}
return normalized;
}
// Null prototype keeps a parameter literally named "__proto__" as data instead of letting
// Object.assign replace this object's prototype and drop the parameter from JSON output.
const properties: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
const required = new Set<string>();
if (root.properties && typeof root.properties === "object" && !Array.isArray(root.properties)) {
Object.assign(properties, root.properties as Record<string, unknown>);
}
if (Array.isArray(root.required)) {
for (const item of root.required) if (typeof item === "string") required.add(item);
}
collectRootComposition(root, root, new Set(), true, properties, required, budget);
const normalized: Record<string, unknown> = {};
for (const [key, value] of Object.entries(root)) {
if (key === "oneOf" || key === "anyOf" || key === "allOf") continue;
if (key === "type" || key === "properties" || key === "required") continue;
normalized[key] = value;
}
normalized.type = "object";
normalized.properties = properties;
if (required.size > 0) normalized.required = [...required];
return normalized;
}