네, 결과는 다음과 같습니다:
```json
{
"title": "샘플",
"tags": ["a", "b",], ← 마지막 쉼표
}

`json.loads()`

에 이것을 그대로 전달하면 당연히 실패합니다. 앞뒤의 설명문, 코드 페이스, 마지막 쉼표 — 인간에게는 사소한 것이지만, 파서(Parser)는 가차 없이 중단됩니다. 게다가 까다로운 점은, **개발 중에는 거의 재현되지 않는다**는 것입니다. 온도(Temperature)나 미세한 입력 차이에 따라 확률적으로 발생하기 때문에, 실무 환경에서 처음 맞닥뜨리게 됩니다.

"LLM 측의 프롬프트를 완벽하게 만든다"는 것만으로는 문제를 0으로 만들 수 없습니다. 그래서 **받는 쪽을 견고하게(Robust) 만든다**는 방침을 세웠습니다.

## 수행한 내용

### 오류의 종류를 먼저 파악하기

대책을 세우기 전에, 실제로 발생했던 오류들을 분류해 두면 설계가 쉬워집니다.

| 오류 유형 | 예시 | 처리 가능한 단계 |
|---|---|---|
| 코드 페이스 포함 | ````json ... ```` | 추출 |
| 앞뒤 설명문 포함 | `네, 다음과 같습니다~` / `이상입니다` | 추출 |
| 마지막 쉼표 | `[a, b,]` | 수복 |
| 닫는 괄호 부족 | 출력이 중간에 끊김 (`max_tokens` 도달) | 수복 (일부) |
| 애초에 JSON 없음 | 전체 문장이 자연어임 | 처리 불가 → 실패로 측정 |

"처리할 수 없는 오류"도 있다는 점을 미리 인정하는 것이 중요합니다. 무리하게 고치려다 보면, **깨진 데이터를 "그럴듯하게" 통과시켜 버리는 것**이 더 위험하기 때문입니다.

### 1단계: 추출 (extract)

먼저 코드 페이스를 제거하고, 첫 번째 `{` 에서부터 **괄호의 대응이 맞는 위치**까지를 추출합니다. 문자열 리터럴 내부의 `{ }`를 잘못 세면 버그가 발생하므로, 문자열의 안팎을 추적하며 세는 것이 포인트입니다.

```python
import re

def extract_json_block(text: str) -> str:
    # 코드 페이스 (```json ... ```)를 제거
    text = re.sub(r"```(?:json)?", "", text).strip()
    start = text.find("{")
    if start == -1:
        raise ValueError("JSON object not found")
    
    depth = 0
    in_str = False
    esc = False
    
    for i in range(start, len(text)):
        c = text[i]
        if in_str:
            if esc:
                esc = False
            elif c == "\\":
                esc = True
            elif c == '"':
                in_str = False
        else:
            if c == '"':
                in_str = True
            elif c == "{":
                depth += 1
            elif c == "}":
                depth -= 1
                
            if depth == 0:
                return text[start : i + 1]
                
    # 여기까지 오면 = 닫는 괄호가 부족함 (중간에 끊김) → 2단계로 넘김
    return text[start:]

import json

def try_load(s: str):
    try:
        return json.loads(s), None
    except json.JSONDecodeError as e:
        return None, e

def repair_json(s: str) -> str:
    # 1) trailing comma: ,} 또는 ,] 를 } 또는 ] 로 변경
    s = re.sub(r",\s*([\}\]])", r"\1", s)
    # 2) 닫기 누락: 열기/닫기 개수 차이만큼 보충 (1단계에서 끊긴 경우 구제)
    s += "}" * max(0, s.count("{") - s.count("}"))
    s += "]" * max(0, s.count("[") - s.count("]"))
    return s

from enum import Enum
from pydantic import BaseModel

class ParseStage(str, Enum):
    RAW = "raw"           # 그대로 통과
    EXTRACTED = "extracted" # 추출을 통해 통과
    REPAIRED = "repaired"   # 수복을 통해 통과
    FAILED = "failed"       # 모두 실패

def robust_parse(text: str):
    # 1단계: 우선 그대로 시도
    data, _ = try_load(text)
    if data is not None:
        return data, ParseStage.RAW
    
    # 2단계: 추출 후 시도
    block = extract_json_block(text)
    data, _ = try_load(block)
    if data is not None:
        return data, ParseStage.EXTRACTED
    
    # 3단계: 수복 후 시도
    data, err = try_load(repair_json(block))
    if data is not None:
        return data, ParseStage.REPAIRED
    
    return None, ParseStage.FAILED

def parse_and_validate(text: str, model: type[BaseModel]) -> BaseModel:
    data, stage = robust_parse(text)
    metrics_increment(f"llm_json.{stage.value}") # ← 붕괴 유형을 측정
    
    if data is None:
        raise ValueError("LLM did not return parseable JSON")
    
    return model.model_validate(data) # 스키마 검증 (타입이 다르면 여기서 예외 발생)

class Article(BaseModel):
    title: str
    tags: list[str]
    score: float

article = parse_and_validate(llm_response_text, Article)

llm_json.raw 92.0%
llm_json.extracted 6.5%
llm_json.repaired 1.3%
llm_json.failed 0.2%