UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

104 lines (93 loc) • 5.29 kB
/** * Tool-schema compatibility for Gemini models behind GetChatMessage. * * Measured live on gemini-3-8-flash-medium: any schema node whose `type` is a * JSON-Schema type array (`["string", "null"]`) is refused with an opaque * `invalid_argument` on every turn, while the same union spelled as * `anyOf: [{type: "string"}, {type: "null"}]` is accepted, as are `$schema`, * `additionalProperties: false`, `const`, and `$ref`/`$defs`. Claude models * accept type arrays, so only the Gemini family is rewritten, and only that one * keyword: the full Google subset sanitizer would strip keywords this backend * accepts. * * Claude models behind the same wire answer `invalid_argument` for a root * `oneOf` (#8302), as Anthropic rejects a root composition in any * `input_schema`. Claude uids get the same root flattening as Claude Chat * gateways; a schema without a root composition is passed through unchanged. */ import { flattenClaudeRootToolParameters } from '../../openai-chat/tool-schema.js'; export function isDevinGeminiModelUid(modelUid: string): boolean { return /^gemini-/i.test(modelUid) || /^MODEL_GOOGLE_GEMINI_/i.test(modelUid); } export function isDevinClaudeModelUid(modelUid: string): boolean { return /^claude-/i.test(modelUid) || /^MODEL_CLAUDE_/i.test(modelUid); } const ROOT_COMPOSITION_KEYS = ['oneOf', 'anyOf', 'allOf'] as const; function hasRootComposition(parameters: unknown): boolean { return isSchema(parameters) && ROOT_COMPOSITION_KEYS.some((key) => Array.isArray(parameters[key])); } /** Keys whose values are instance data, not subschemas. */ const DATA_KEYS = new Set(['enum', 'const', 'default', 'examples', 'example']); /** Keys whose values map arbitrary names (which may be "enum" or "default") to subschemas. */ const SCHEMA_MAP_KEYS = new Set(['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas', 'dependencies']); /** Keys that describe the whole node and stay on it rather than moving into each branch. */ const ANNOTATION_KEYS = new Set(['description', 'title', 'default', 'examples', 'example', '$comment', 'deprecated']); function rewriteMap(map: unknown): unknown { if (!map || typeof map !== 'object' || Array.isArray(map)) return map; // A draft-7 `dependencies` entry may be a list of property names, which is data. return Object.fromEntries(Object.entries(map).map(([name, schema]) => [name, Array.isArray(schema) ? schema : rewrite(schema)])); } type Schema = Record<string, unknown>; const isSchema = (value: unknown): value is Schema => !!value && typeof value === 'object' && !Array.isArray(value); /** * Replace a type array with an equivalent type-only union. Constraints remain on * the surrounding node so nested schemas are represented exactly once rather * than copied into every branch. */ function splitTypeArray(node: Schema, types: unknown[]): Schema { const annotations: Schema = {}; const rest: Schema = {}; for (const [key, value] of Object.entries(node)) { if (key === 'type' || key === 'anyOf') continue; Object.defineProperty(ANNOTATION_KEYS.has(key) ? annotations : rest, key, { value, enumerable: true, writable: true, configurable: true }); } const concrete = types.filter((type) => type !== 'null'); // An outer enum/const is still binding after the type array is split. const allowsNull = concrete.length < types.length && (!Array.isArray(rest.enum) || rest.enum.includes(null)) && (!Object.hasOwn(rest, 'const') || rest.const === null); const branches = concrete.map((type) => ({ type })); if (allowsNull || branches.length === 0) branches.push({ type: 'null' }); const typeConstraint: Schema = branches.length === 1 ? branches[0]! : { anyOf: branches }; const existing = Array.isArray(node.anyOf) ? node.anyOf : undefined; if (!existing) return { ...annotations, ...rest, ...typeConstraint }; // Keep existing applicators and constraints at their original JSON Pointer // locations. Appending only the type constraint also preserves allOf indices, // resource scopes, and the sibling annotations read by unevaluated* keywords. const allOf = Array.isArray(rest.allOf) ? rest.allOf : []; return { ...annotations, ...rest, anyOf: existing, allOf: [...allOf, typeConstraint] }; } function rewrite(node: unknown): unknown { if (Array.isArray(node)) return node.map(rewrite); if (!isSchema(node)) return node; // fromEntries defines own properties, so a "__proto__" key stays data. const out: Schema = Object.fromEntries( Object.entries(node).map(([key, value]) => [ key, DATA_KEYS.has(key) ? value : SCHEMA_MAP_KEYS.has(key) ? rewriteMap(value) : rewrite(value), ]), ); if (!Array.isArray(out.type)) return out; const types = out.type as unknown[]; if (types.length === 0) { delete out.type; return out; } return splitTypeArray(out, types); } /** Rewrite type arrays for Gemini uids and root compositions for Claude uids; others are unchanged. */ export function normalizeDevinToolParameters(modelUid: string, parameters: unknown): unknown { if (isDevinGeminiModelUid(modelUid)) return rewrite(parameters); if (isDevinClaudeModelUid(modelUid) && hasRootComposition(parameters)) return flattenClaudeRootToolParameters(parameters); return parameters; }