| import { createHash } from "node:crypto"; |
|
|
| export function canonicalize(value) { |
| if (Array.isArray(value)) { |
| return value.map(canonicalize); |
| } |
|
|
| if (value && typeof value === "object") { |
| return Object.fromEntries( |
| Object.keys(value) |
| .sort() |
| .map((key) => [key, canonicalize(value[key])]), |
| ); |
| } |
|
|
| return value; |
| } |
|
|
| export function canonicalJson(value) { |
| return JSON.stringify(canonicalize(value)); |
| } |
|
|
| export function contentHash(value) { |
| return createHash("sha256").update(canonicalJson(value)).digest("hex"); |
| } |
|
|
| export function cloneJson(value) { |
| return structuredClone(value); |
| } |
|
|
| function repairInvalidStringEscapes(text) { |
| let repaired = ""; |
| let inString = false; |
|
|
| for (let index = 0; index < text.length; index += 1) { |
| const char = text[index]; |
| if (char === '"') { |
| inString = !inString; |
| repaired += char; |
| continue; |
| } |
| if (!inString || char !== "\\") { |
| repaired += char; |
| continue; |
| } |
|
|
| const next = text[index + 1]; |
| if ('"\\/bfnrt'.includes(next)) { |
| repaired += `${char}${next}`; |
| index += 1; |
| continue; |
| } |
| if ( |
| next === "u" && |
| /^[0-9a-fA-F]{4}$/.test(text.slice(index + 2, index + 6)) |
| ) { |
| repaired += text.slice(index, index + 6); |
| index += 5; |
| continue; |
| } |
| repaired += "\\\\"; |
| } |
|
|
| return repaired; |
| } |
|
|
| function parseModelJson(text) { |
| try { |
| return JSON.parse(text); |
| } catch (error) { |
| const repaired = repairInvalidStringEscapes(text); |
| if (repaired === text) throw error; |
| return JSON.parse(repaired); |
| } |
| } |
|
|
| function balancedJsonCandidates(text) { |
| const candidates = []; |
|
|
| for (let start = 0; start < text.length; start += 1) { |
| if (!"{[".includes(text[start])) continue; |
|
|
| const stack = [text[start]]; |
| let inString = false; |
| let escaped = false; |
|
|
| for ( |
| let index = start + 1; |
| index < text.length; |
| index += 1 |
| ) { |
| const char = text[index]; |
|
|
| if (inString) { |
| if (escaped) escaped = false; |
| else if (char === "\\") escaped = true; |
| else if (char === '"') inString = false; |
| continue; |
| } |
|
|
| if (char === '"') { |
| inString = true; |
| continue; |
| } |
|
|
| if (char === "{" || char === "[") { |
| stack.push(char); |
| continue; |
| } |
|
|
| if (char !== "}" && char !== "]") continue; |
|
|
| const opening = stack.at(-1); |
| const expected = char === "}" ? "{" : "["; |
| if (opening !== expected) break; |
|
|
| stack.pop(); |
| if (stack.length === 0) { |
| candidates.push(text.slice(start, index + 1)); |
| break; |
| } |
| } |
| } |
|
|
| return candidates; |
| } |
|
|
| function jsonCandidateTexts(text) { |
| const trimmed = text.trim(); |
| if (!trimmed) { |
| throw new Error("Model returned an empty response."); |
| } |
|
|
| const candidates = []; |
| try { |
| candidates.push(trimmed); |
| } catch { |
| |
| } |
|
|
| const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i); |
| if (fenced) { |
| candidates.push(fenced[1].trim()); |
| } |
|
|
| const firstObject = trimmed.indexOf("{"); |
| const firstArray = trimmed.indexOf("["); |
| const starts = [firstObject, firstArray].filter((index) => index >= 0); |
| if (starts.length === 0) { |
| throw new Error("Model response did not contain JSON."); |
| } |
|
|
| candidates.push(...balancedJsonCandidates(trimmed)); |
| return candidates; |
| } |
|
|
| export function extractJsonCandidates(text) { |
| const candidates = jsonCandidateTexts(text); |
| const values = []; |
| let lastError = null; |
|
|
| for (const candidate of candidates) { |
| try { |
| values.push(parseModelJson(candidate)); |
| } catch (error) { |
| lastError = error; |
| } |
| } |
|
|
| if (values.length > 0) return values; |
| if (lastError) throw lastError; |
| throw new Error("Model response contained incomplete JSON."); |
| } |
|
|
| export function extractJson(text) { |
| return extractJsonCandidates(text)[0]; |
| } |
|
|
