Why Valid JSON from LLMs Can Still Trigger Parser Syntax Errors

# Naive logging (hides the issue)
print(f"Received: {raw_response}")

# Raw byte inspection (reveals the issue)
print(repr(raw_response[:80]))

# Example of a response containing a BOM
raw_response = '\ufeff{\n  "customer": "Acme Corp",\n  "issue": "billing dispute"\n}'

```json
\{
  "customer": "Acme Corp",
  "issue": "billing dispute"
\}
```

If your pipeline uses a simple `.strip()` call, it will remove leading and trailing newlines, but the backticks and the `json` language identifier will remain. The JSON parser reads the first backtick (`` ` ``) and immediately fails with a syntax error.

---

## Culprit 3: Conversational Prose and Explanations

Despite system prompts commanding the model to "return ONLY raw JSON without any conversational text," LLMs are inherently conversational. They frequently prepend or append explanations:

```text
Sure! Here is the extracted customer information you requested:
\{
  "customer": "Acme Corp",
  "issue": "billing dispute"
\}
I hope this helps!

import json
import re
from typing import Any, Dict, Optional

def extract_json(raw: str) -> Dict[str, Any]:
    """
    Clean and extract a valid JSON object from a raw LLM text response.
    Handles UTF-8 BOMs, markdown fences, and leading/trailing conversational text.
    """
    if not raw:
        raise ValueError("Received empty input string for JSON parsing.")

    # 1. Strip UTF-8 Byte Order Mark (BOM) if present
    if raw.startswith("\ufeff"):
        raw = raw.lstrip("\ufeff")

    # Normalize line endings and strip surrounding whitespace
    raw = raw.strip()

    # 2. Extract contents from Markdown code blocks
    # Matches ```json ... ``` or ``` ... ``` case-insensitively
    markdown_pattern = re.compile(r"```(?:json)?\s*(.*?)\s*```", re.DOTALL | re.IGNORECASE)
    match = markdown_pattern.search(raw)
    if match:
        raw = match.group(1).strip()
    else:
        # 3. Fallback: Search for the outermost curly braces
        # This handles cases where the model includes leading or trailing conversational text
        start = raw.find("\{")
        end = raw.rfind("\}")
        if start != -1 and end > start:
            raw = raw[start:end + 1]
        else:
            # Try array boundaries if the expected output is a list
            start_array = raw.find("[")
            end_array = raw.rfind("]")
            if start_array != -1 and end_array > start_array:
                raw = raw[start_array:end_array + 1]

    # 4. Parse the cleaned string
    try:
        return json.loads(raw)
    except json.JSONDecodeError as e:
        # Log the raw representation to capture invisible characters in debugging
        raise ValueError(f"Failed to parse JSON. Raw snippet: \{repr(raw[:100])\}. Error: \{e\}") from e

from pydantic import BaseModel, Field, ValidationError

class CustomerIssue(BaseModel):
    customer: str = Field(..., min_length=1)
    issue: str = Field(..., min_length=1)
    priority: int = Field(..., ge=1, le=5)

def process_pipeline(raw_llm_output: str) -> Optional[CustomerIssue]:
    try:
        parsed_dict = extract_json(raw_llm_output)
        # Validate against the Pydantic schema
        validated_data = CustomerIssue(**parsed_dict)
        return validated_data
    except (ValueError, ValidationError) as err:
        print(f"Pipeline Error: \{err\}")
        # Implement your retry logic or fallback routine here
        return None

def run_test_suite():
    fixtures = [
        (
            "Clean JSON",
            '\{"customer": "Acme Corp", "issue": "billing", "priority": 2\}'
        ),
        (
            "UTF-8 BOM Prefix",
            '\ufeff\{"customer": "Acme Corp", "issue": "billing", "priority": 2\}'
        ),
        (
            "Markdown Fenced Block",
            '```json\n{"customer": "Acme Corp", "issue": "billing", "priority": 2}\n```'
        ),
        (
            "BOM and Markdown Fenced Block",
            '\ufeff```json\n{"customer": "Acme Corp", "issue": "billing", "priority": 2}\n```'
        ),
        (
            "Conversational Prose Wrap",
            'Here is the result you requested:\n\{\n  "customer": "Acme Corp",\n  "issue": "billing",\n  "priority": 2\n\}\nHope this helps!'
        )
    ]

    print("Running parser validation tests...")
    for name, raw_input in fixtures:
        try:
            result = extract_json(raw_input)
            # Simple validation check
            assert result["customer"] == "Acme Corp"
            assert result["priority"] == 2
            print(f"[PASS] \{name\}")
        except Exception as e:
            print(f"[FAIL] \{name\}: \{e\}")

if __name__ == "__main__":
    run_test_suite()

import requests

# Configure your unified client pointing to n1n.ai
API_URL = "https://api.n1n.ai/v1/chat/completions"
API_KEY = "your_n1n_api_key"

headers = \{
    "Authorization": f"Bearer \{API_KEY\}",
    "Content-Type": "application/json"
\}

# Define the target schema using JSON Schema syntax
json_schema = \{
    "name": "CustomerIssueSchema",
    "strict": True,
    "schema": \{
        "type": "object",
        "properties": \{
            "customer": \{"type": "string"\},
            "issue": \{"type": "string"\},
            "priority": \{"type": "integer", "minimum": 1, "maximum": 5\}
        \},
        "required": ["customer", "issue", "priority"],
        "additionalProperties": False
    \}
\}

payload = \{
    "model": "gpt-4o-mini",
    "messages": [
        \{
            "role": "system",
            "content": "You are a data extraction assistant. Extract customer issue details."
        \},
        \{
            "role": "user",
            "content": "Acme Corp reported a billing dispute. This is a high-priority incident (level 2)."
        \}
    ],
    "response_format": \{
        "type": "json_schema",
        "json_schema": json_schema
    \}
\}

response = requests.post(API_URL, json=payload, headers=headers)
result = response.json()

# The response content is guaranteed to be a valid JSON string matching the schema
raw_content = result["choices"][0]["message"]["content"]
parsed_data = json.loads(raw_content)
print(parsed_data)