以下是您需要的 JSON：
```json
{"action": "move", "target_x": 10, "target_y": 5}

**2. 前缀废话**

模型在 JSON 前面加了一段它认为"有用"的说明：

**3. 后缀废话**

JSON 之后还有内容：

**4. 多个 JSON 对象**

模型输出了多个 JSON 块，只有第一个是有效的：

**5. JSON 内部格式错误**

最难处理的一类——结构本身有问题，比如多了逗号、字符串没闭合、或者字段名称写错了：

了解了这些"敌人"的形态，才能有针对性地设计防御策略。

---

## 二、第一层防线：让模型不那么乱

解析层面的防御固然必要，但如果能在源头减少脏输出的概率，问题就会简单很多。

### 2.1 使用 JSON Mode（结构化输出强制模式）

现代主流 LLM API 都提供了某种形式的"强制 JSON 输出"模式。在 OpenAI 兼容接口里（包括很多国内厂商），这叫做 `response_format`：

```go
req := openai.ChatCompletionRequest{
    Model: model,
    ResponseFormat: &openai.ChatCompletionResponseFormat{
        Type: openai.ChatCompletionResponseFormatTypeJSONObject,
    },
    Messages: []openai.ChatCompletionMessage{
        {Role: openai.ChatMessageRoleUser, Content: prompt},
    },
}

请严格按照以下 JSON 格式返回你的决策，不要包含任何其他文字、解释或 Markdown 代码块：

{
  "action": "move | stay | talk",
  "speak": "如果是 talk，填写说话内容，否则留空字符串",
  "target_x": 目标X坐标（整数）,
  "target_y": 目标Y坐标（整数）
}

示例输出（仅供格式参考，不要照抄内容）：
{"action": "move", "speak": "", "target_x": 5, "target_y": 3}

var result MyStruct
err := json.Unmarshal([]byte(respText), &result)
if err != nil {
    return nil, err
}

func parseJSONResponse(respText string, target any) error {
    // 第一步：找到第一个 "{" 的位置
    // 这一步可以过滤掉 JSON 之前的所有前缀废话和 Markdown 标记
    start := strings.Index(respText, "{")
    if start == -1 {
        return fmt.Errorf("LLM response contains no JSON object: %s", respText)
    }

    // 第二步：使用 json.Decoder 而非 json.Unmarshal
    // Decoder 天生只读取 Reader 中的第一个合法 JSON 对象
    // 遇到第一个完整的 JSON 对象后就停止，后续所有内容（废话、多余的 JSON）被自动忽略
    decoder := json.NewDecoder(strings.NewReader(respText[start:]))
    if err := decoder.Decode(target); err != nil {
        return fmt.Errorf("JSON decode failed: %w, raw response: %s", err, respText)
    }

    return nil
}

func parseJSONArrayResponse(respText string, target any) error {
    start := strings.Index(respText, "[")
    if start == -1 {
        return fmt.Errorf("LLM response contains no JSON array: %s", respText)
    }
    decoder := json.NewDecoder(strings.NewReader(respText[start:]))
    return decoder.Decode(target)
}

startObj := strings.Index(respText, "{")
startArr := strings.Index(respText, "[")

start := -1
if startObj != -1 && startArr != -1 {
    if startObj < startArr {
        start = startObj
    } else {
        start = startArr
    }
} else if startObj != -1 {
    start = startObj
} else if startArr != -1 {
    start = startArr
}

func stripMarkdownCodeBlock(s string) string {
    // 去除 ```json 或 ``` 开头
    s = strings.TrimSpace(s)
    if strings.HasPrefix(s, "```") {
        // 找到第一行的结尾（即 ```json 这一行的末尾）
        firstNewline := strings.Index(s, "\n")
        if firstNewline != -1 {
            s = s[firstNewline+1:]
        }
    }
    // 去除末尾的 ```
    if strings.HasSuffix(s, "```") {
        s = s[:len(s)-3]
    }
    return strings.TrimSpace(s)
}

clean := stripMarkdownCodeBlock(respText)
err := parseJSONResponse(clean, &result)

var result MyStruct
var lastErr error
for attempt := 0; attempt < 3; attempt++ {
    respText, err := callLLM(ctx, prompt)
    if err != nil {
        lastErr = err
        continue
    }
    if err = parseJSONResponse(respText, &result); err == nil {
        return &result, nil
    }
    lastErr = err
    time.Sleep(time.Duration(1<<attempt) * time.Second) // 指数退避
}
return nil, fmt.Errorf("failed after 3 attempts: %w", lastErr)

你上一次的输出无法被解析为 JSON，原因是：[错误信息]

你的原始输出是：
[原文]

请严格按照 JSON 格式重新输出，不要包含任何额外内容。

调用 LLM API
    ↓
是否启用了 JSON Mode？（能用就用）
    ↓
去除 Markdown 代码块（如果需要）
    ↓
找到第一个 { 或 [
    ↓
用 json.Decoder 解析
    ↓
    ├── 成功 → 返回结果
    └── 失败 → 带错误信息重试（最多 N 次）
                ↓
                继续失败 → 记录日志，返回错误，触发降级逻辑