Why AI-Generated JSON Is Always Broken — and How to Fix Every Error

# Prompt template that minimizes AI JSON errors:

"Generate a JSON object representing a user profile.
IMPORTANT JSON RULES — follow these exactly:
- All keys must be double-quoted strings
- All string values must use double quotes (not single quotes)
- No trailing commas after the last element in arrays or objects
- Use lowercase true, false, null (NOT True/False/None/undefined/NaN)
- No // comments or /* */ comments
- No leading zeros in numbers, no + prefix on positive numbers

Return ONLY the raw JSON object with no explanation, no markdown
code fences, and no surrounding text."

# Even better — provide an example of the shape:
"Follow this exact structure:
{
  "id": 1,
  "name": "example",
  "active": true,
  "tags": ["a", "b"]
}
Your JSON must be parseable by JSON.parse() without any modification."

// Step 1: Strip markdown code fences (AI often wraps JSON in ```json...```)
function stripMarkdownFences(text) {
  return text
    .replace(/^```(?:json)?s*/i, '')  // remove opening fence
    .replace(/s*```s*$/i, '')          // remove closing fence
    .trim();
}

// Step 2: Strip JavaScript comments
function stripComments(text) {
  return text
    .replace(///[^
]*/g, '')
    .replace(//*[sS]*?*//g, '');
}

// Step 3: Fix Python-style literals
function fixPythonLiterals(text) {
  return text
    .replace(/(?<!["w])(True)(?!["w])/g, 'true')
    .replace(/(?<!["w])(False)(?!["w])/g, 'false')
    .replace(/(?<!["w])(None)(?!["w])/g, 'null');
}

// Step 4: Fix JS-only values
function fixJsValues(text) {
  return text
    .replace(/:s*undefined/g, ': null')
    .replace(/:s*NaN/g, ': null')
    .replace(/:s*-?Infinity/g, ': null');
}

// Step 5: Remove trailing commas
function fixTrailingCommas(text) {
  let prev;
  do { prev = text; text = text.replace(/,(s*[}]])/g, '$1'); }
  while (prev !== text);
  return text;
}

// Combined repair function
function repairAiJson(raw) {
  let text = stripMarkdownFences(raw);
  text = stripComments(text);
  text = fixPythonLiterals(text);
  text = fixJsValues(text);
  text = fixTrailingCommas(text);
  try {
    return { data: JSON.parse(text), error: null, fixed: text };
  } catch (e) {
    return { data: null, error: e.message, fixed: text };
  }
}

// Usage:
const { data, error, fixed } = repairAiJson(llmOutput);
if (error) {
  console.error('Could not repair JSON:', error);
  console.log('Repaired text was:', fixed);
} else {
  console.log('Parsed successfully:', data);
}

import re
import json

def strip_markdown_fences(text: str) -> str:
    """Remove ```json...``` wrappers that AI models add."""
    text = re.sub(r'^```(?:json)?s*', '', text, flags=re.IGNORECASE)
    text = re.sub(r's*```s*$', '', text)
    return text.strip()

def strip_comments(text: str) -> str:
    text = re.sub(r'//[^
]*', '', text)
    text = re.sub(r'/*[sS]*?*/', '', text)
    return text

def fix_python_literals(text: str) -> str:
    """Replace Python True/False/None with JSON true/false/null."""
    text = re.sub(r'(?<!["w])(True)(?!["w])', 'true', text)
    text = re.sub(r'(?<!["w])(False)(?!["w])', 'false', text)
    text = re.sub(r'(?<!["w])(None)(?!["w])', 'null', text)
    return text

def fix_trailing_commas(text: str) -> str:
    prev = None
    while prev != text:
        prev = text
        text = re.sub(r',(s*[}]])', r'\1', text)
    return text

def repair_ai_json(raw: str) -> dict | list | None:
    text = strip_markdown_fences(raw)
    text = strip_comments(text)
    text = fix_python_literals(text)
    text = fix_trailing_commas(text)
    try:
        return json.loads(text)
    except json.JSONDecodeError as e:
        raise ValueError(f"Could not repair JSON: {e}") from e

# Usage:
data = repair_ai_json(llm_output)  # handles most AI JSON errors

import OpenAI from 'openai';
const openai = new OpenAI();

// Method 1: JSON mode (guarantees valid JSON, any shape)
const completion = await openai.chat.completions.create({
  model: 'gpt-4o',
  response_format: { type: 'json_object' },  // ✅ Forces valid JSON
  messages: [
    { role: 'system', content: 'You always respond with valid JSON.' },
    { role: 'user', content: 'Generate a user profile for Alice Chen, age 30, roles: admin, editor.' },
  ],
});
const data = JSON.parse(completion.choices[0].message.content);

// Method 2: Structured outputs with JSON Schema (guarantees exact shape)
const completion2 = await openai.chat.completions.create({
  model: 'gpt-4o-2024-08-06',
  response_format: {
    type: 'json_schema',
    json_schema: {
      name: 'user_profile',
      strict: true,
      schema: {
        type: 'object',
        properties: {
          name:   { type: 'string' },
          age:    { type: 'integer' },
          roles:  { type: 'array', items: { type: 'string' } },
          active: { type: 'boolean' },
        },
        required: ['name', 'age', 'roles', 'active'],
        additionalProperties: false,
      },
    },
  },
  messages: [{ role: 'user', content: 'Generate a user profile for Alice Chen.' }],
});
// Guaranteed to parse without errors AND match the schema exactly
const user = JSON.parse(completion2.choices[0].message.content);

import { z } from 'zod';

// Define your expected shape with Zod
const UserSchema = z.object({
  id:        z.number().int().positive(),
  name:      z.string().min(1),
  email:     z.string().email(),
  roles:     z.array(z.enum(['admin', 'editor', 'viewer'])),
  active:    z.boolean(),
  createdAt: z.string().datetime().optional(),
});

type User = z.infer<typeof UserSchema>;

async function getAiGeneratedUser(prompt: string): Promise<User> {
  const rawJson = await callAiApi(prompt);

  // Step 1: repair common AI JSON errors
  const repairedText = repairAiJson(rawJson);

  // Step 2: parse JSON
  let parsed: unknown;
  try {
    parsed = JSON.parse(repairedText);
  } catch (e) {
    throw new Error(`AI returned unparseable JSON: ${e.message}`);
  }

  // Step 3: validate shape and types
  const result = UserSchema.safeParse(parsed);
  if (!result.success) {
    const issues = result.error.issues.map(i => `${i.path.join('.')}: ${i.message}`);
    throw new Error(`AI JSON failed schema validation: ${issues.join(', ')}`);
  }

  return result.data; // ✅ Fully typed, validated data
}

// ❌ TYPICAL AI OUTPUT (invalid)
{
  // User profile object
  name: 'Alice',                        // unquoted key + single quote
  "age": 30,
  "active": True,                       // Python literal
  "score": NaN,                         // JS-only value
  "balance": undefined,                 // JS-only value
  "tags": ["admin", "editor",],         // trailing comma
  "timeout": 030,                       // leading zero
  "priority": +1,                       /* block comment */
}

// ✅ VALID JSON (all errors fixed)
{
  "name": "Alice",
  "age": 30,
  "active": true,
  "score": null,
  "balance": null,
  "tags": ["admin", "editor"],
  "timeout": 30,
  "priority": 1
}