@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
192 lines (177 loc) • 7.6 kB
text/typescript
/**
* Lexeme-preserving JSON reading and exact decimal arithmetic for Kiro strict structured output.
*
* Strict validation has to judge the bytes it relays. `JSON.parse` rounds every number to a double,
* so `9007199254740993` would compare equal to a `const` of `9007199254740992` and
* `10.0000000000000001` would pass `maximum: 10`, while the client receives the original text.
* This reader keeps each number's lexeme, and the decimal helpers compare and divide those lexemes
* exactly, without converting them to doubles.
*/
/** One parsed JSON value with its byte span in the source text. */
export type KiroJsonValue = { start: number; end: number } & (
| { kind: "null" }
| { kind: "boolean"; value: boolean }
| { kind: "number"; lexeme: string }
| { kind: "string"; value: string }
| { kind: "array"; items: KiroJsonValue[] }
| { kind: "object"; entries: Map<string, KiroJsonValue> }
);
/** A parsed document and how many values it holds, which sizes the validation budget. */
export interface KiroJsonDocument {
value: KiroJsonValue;
nodes: number;
}
/** Deepest array/object nesting the reader accepts; deeper values are reported as non-conforming. */
export const KIRO_JSON_MAX_NESTING = 512;
const WHITESPACE = new Set([" ", "\t", "\n", "\r"]);
const NUMBER = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
/**
* Read `text` into a lexeme-preserving tree, or undefined when it is not JSON or nests deeper than
* {@link KIRO_JSON_MAX_NESTING}. Duplicate object keys keep the last value, as `JSON.parse` does.
*/
export function readKiroJson(text: string): KiroJsonDocument | undefined {
let pos = 0;
let nodes = 0;
const skip = (): void => {
while (pos < text.length && WHITESPACE.has(text[pos]!)) pos++;
};
const readString = (): string => {
const start = pos;
pos++;
while (pos < text.length && text[pos] !== '"') pos += text[pos] === "\\" ? 2 : 1;
if (pos >= text.length) throw new SyntaxError("unterminated string");
pos++;
return JSON.parse(text.slice(start, pos)) as string;
};
const read = (depth: number): KiroJsonValue => {
if (depth > KIRO_JSON_MAX_NESTING) throw new RangeError("nesting");
skip();
nodes++;
const start = pos;
const ch = text[pos];
if (ch === '"') {
const value = readString();
return { kind: "string", value, start, end: pos };
}
if (ch === "[" || ch === "{") {
pos++;
skip();
const close = ch === "[" ? "]" : "}";
const items: KiroJsonValue[] = [];
const entries = new Map<string, KiroJsonValue>();
if (text[pos] === close) pos++;
else {
for (;;) {
if (ch === "[") items.push(read(depth + 1));
else {
if (text[pos] !== '"') throw new SyntaxError("expected a key");
const key = readString();
skip();
if (text[pos++] !== ":") throw new SyntaxError("expected a colon");
entries.set(key, read(depth + 1));
}
skip();
const next = text[pos++];
if (next === close) break;
if (next !== ",") throw new SyntaxError("expected a comma");
skip();
}
}
return ch === "["
? { kind: "array", items, start, end: pos }
: { kind: "object", entries, start, end: pos };
}
for (const [word, value] of [["true", true], ["false", false], ["null", null]] as const) {
if (text.startsWith(word, pos)) {
pos += word.length;
return value === null ? { kind: "null", start, end: pos } : { kind: "boolean", value, start, end: pos };
}
}
NUMBER.lastIndex = pos;
const match = NUMBER.exec(text);
if (!match) throw new SyntaxError("unexpected token");
pos += match[0].length;
return { kind: "number", lexeme: match[0], start, end: pos };
};
try {
const value = read(0);
skip();
return pos === text.length ? { value, nodes } : undefined;
} catch {
return undefined;
}
}
/**
* An exact decimal: `sign × 0.digits × 10^exponent`, with `digits` free of leading and trailing
* zeros. Zero has sign 0 and empty digits. The exponent is a bigint because a lexeme such as
* `1e99999999999999999999` is valid JSON.
*/
export interface KiroDecimal {
sign: -1 | 0 | 1;
digits: string;
exponent: bigint;
}
const DECIMAL = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
/**
* Largest exponent magnitude kept exactly. A model-written exponent can be millions of digits long,
* and converting it to a bigint costs more than linear time, so a longer one saturates here. No
* lexeme within the answer size limits has as many digits, so a saturated value still compares,
* and tests as an integer, exactly as its true value would against any schema bound.
*/
const EXPONENT_LIMIT = 10n ** 15n;
/** The exponent text as a bigint, saturated at {@link EXPONENT_LIMIT}; linear in its length. */
function boundedExponent(exp: string): bigint {
const negative = exp.startsWith("-");
let start = exp.startsWith("-") || exp.startsWith("+") ? 1 : 0;
while (start < exp.length - 1 && exp.charCodeAt(start) === 48) start += 1;
const magnitude = exp.length - start > 15 ? EXPONENT_LIMIT : BigInt(exp.slice(start));
return negative ? -magnitude : magnitude;
}
/** The exact value of a JSON number lexeme (or of `String(n)` for a finite double). */
export function kiroDecimal(lexeme: string): KiroDecimal {
const match = DECIMAL.exec(lexeme);
if (!match) throw new Error(`not a JSON number: ${lexeme}`);
const [, minus, whole = "", fraction = "", exp = "0"] = match;
const all = whole + fraction;
const lead = all.search(/[1-9]/);
if (lead < 0) return { sign: 0, digits: "", exponent: 0n };
// One backward scan for trailing zeros: `/0+$/` retries a long zero run at every position.
let end = all.length;
while (end > lead && all.charCodeAt(end - 1) === 48) end -= 1;
return {
sign: minus ? -1 : 1,
digits: all.slice(lead, end),
exponent: BigInt(whole.length - lead) + boundedExponent(exp),
};
}
/** -1, 0 or 1 as `a` is below, equal to or above `b`. */
export function compareKiroDecimal(a: KiroDecimal, b: KiroDecimal): number {
if (a.sign !== b.sign) return a.sign < b.sign ? -1 : 1;
if (a.sign === 0) return 0;
let magnitude = 0;
if (a.exponent !== b.exponent) magnitude = a.exponent < b.exponent ? -1 : 1;
// Without trailing zeros, digit strings order as their fractions do: "12" < "123" < "13".
else if (a.digits !== b.digits) magnitude = a.digits < b.digits ? -1 : 1;
return magnitude * a.sign;
}
/** Whether the decimal is a whole number. */
export function isKiroDecimalInteger(value: KiroDecimal): boolean {
return value.sign === 0 || BigInt(value.digits.length) <= value.exponent;
}
/** `base^power mod modulus` by square-and-multiply, so a huge exponent costs only its bit length. */
function modPow(base: bigint, power: bigint, modulus: bigint): bigint {
let result = 1n % modulus;
let factor = base % modulus;
for (let rest = power; rest > 0n; rest >>= 1n) {
if (rest & 1n) result = (result * factor) % modulus;
factor = (factor * factor) % modulus;
}
return result;
}
/** Whether the decimal is an integer multiple of the positive integer `divisor`. */
export function isKiroDecimalMultipleOf(value: KiroDecimal, divisor: bigint): boolean {
if (value.sign === 0) return true;
if (!isKiroDecimalInteger(value)) return false;
const zeros = value.exponent - BigInt(value.digits.length);
return (BigInt(value.digits) % divisor) * modPow(10n, zeros, divisor) % divisor === 0n;
}