要在代码节点里处理大模型输出的「可能是JSON也可能是Markdown」内容，核心思路是：先尝试解析成JSON，解析失败则按Markdown/纯文本处理。

一、通用处理逻辑（先讲清楚原理）

不管用什么语言，流程都是固定的：

1. 拿到大模型的原始输出字符串（比如 llm_output）
2. 预处理输出字符串（关键！因为大模型经常会带```json、```markdown 这种代码块标记，还有前后空格/换行）
3. 尝试解析JSON：
   • 解析成功 → 得到JSON对象，后续直接用键值对取数据
   • 解析失败 → 判定为Markdown/纯文本，直接按字符串处理，或者用Markdown解析库渲染
4. 统一处理后续逻辑（比如不管是JSON还是Markdown，都提取关键信息、转成你流程里的变量）

二、Python 代码节点示例（最常用，低代码平台基本都支持）

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

def process_llm_output(llm_output: str) -> Dict[str, Any]:
    """
    处理大模型输出，自动识别JSON/Markdown
    :param llm_output: 大模型原始输出字符串
    :return: 处理结果，包含类型、解析后数据、原始文本
    """
    # --------------------------
    # 1. 预处理：清除代码块标记、前后空白
    # --------------------------
    # 去掉 ```json / ```markdown / ```这类标记
    cleaned_output = re.sub(r'```(json|markdown)?\s*', '', llm_output, flags=re.IGNORECASE)
    cleaned_output = re.sub(r'```\s*$', '', cleaned_output)
    # 去掉前后多余的换行和空格
    cleaned_output = cleaned_output.strip()

    result = {
        "type": "unknown",  # 类型：json / markdown / text
        "parsed_data": None,  # JSON解析后的对象，失败则为None
        "raw_text": cleaned_output  # 清洗后的原始文本
    }

    # --------------------------
    # 2. 尝试解析JSON
    # --------------------------
    try:
        parsed_data = json.loads(cleaned_output)
        # 解析成功，标记为JSON类型
        result["type"] = "json"
        result["parsed_data"] = parsed_data
    except json.JSONDecodeError:
        # 解析失败，判定为Markdown/纯文本
        result["type"] = "markdown"
        result["parsed_data"] = None

    # --------------------------
    # 3. 你可以在这里加统一的后续处理逻辑
    # --------------------------
    # 比如：如果是JSON，提取特定字段；如果是Markdown，提取标题/关键信息
    if result["type"] == "json":
        # 示例：提取JSON里的字段，赋值给流程变量
        result["extracted_content"] = result["parsed_data"].get("content", "")
    else:
        # 示例：如果是Markdown，直接用清洗后的文本
        result["extracted_content"] = result["raw_text"]

    return result

# --------------
# 调用示例
# --------------
# 假设大模型输出存在变量里，你直接调用函数即可
# 注意：低代码平台里，通常用类似 ${大模型输出变量名} 来获取值
llm_output = ${你的大模型输出变量}
output = process_llm_output(llm_output)

# 你可以把结果赋值给流程里的变量，比如：
# ${content_type} = output["type"]
# ${parsed_data} = output["parsed_data"]
# ${extracted_content} = output["extracted_content"]

三、JavaScript 代码节点示例（如果你的平台是前端/Node.js环境）

function processLlmOutput(llmOutput) {
    // 1. 预处理：清除代码块标记、前后空白
    let cleanedOutput = llmOutput
        .replace(/```(json|markdown)?\s*/gi, '') // 去掉开头的```json/```markdown
        .replace(/```\s*$/gi, '') // 去掉结尾的```
        .trim();

    let result = {
        type: 'unknown',
        parsedData: null,
        rawText: cleanedOutput
    };

    // 2. 尝试解析JSON
    try {
        const parsedData = JSON.parse(cleanedOutput);
        result.type = 'json';
        result.parsedData = parsedData;
    } catch (e) {
        result.type = 'markdown';
        result.parsedData = null;
    }

    // 3. 后续统一处理
    if (result.type === 'json') {
        result.extractedContent = result.parsedData.content || '';
    } else {
        result.extractedContent = result.rawText;
    }

    return result;
}

// 调用示例（适配低代码平台变量）
const llmOutput = ${你的大模型输出变量};
const output = processLlmOutput(llmOutput);

// 赋值给流程变量（平台不同写法可能略有差异）
// return {
//     content_type: output.type,
//     parsed_data: output.parsedData,
//     extracted_content: output.extractedContent
// };

四、关键细节避坑（直接关系到能不能稳定跑）

1. 必须预处理大模型输出！

大模型输出的JSON经常会带这些“干扰项”，不处理直接解析肯定失败：

• 开头/结尾的 ```json 或 ` ````代码块标记
• 前后多余的换行、空格、注释（比如// 说明）
• Markdown格式的文本里，混有{}字符，会被误判为JSON

2. 处理“假JSON”的情况

有时候大模型会输出“看起来像JSON，但实际语法错误”的内容，比如：

• 键名没加双引号（{content: "xxx"}）
• 结尾多了逗号（{"a":1, "b":2,}）
• 有控制字符、特殊符号

如果你的场景对JSON容错要求高，可以用demjson（Python）这类宽松解析库，或者加一层json5解析（支持非标准JSON）。

3. 区分Markdown和普通文本

大部分场景里，Markdown和纯文本不需要做额外区分，直接当字符串处理即可。如果需要渲染Markdown，可以在代码节点里引入Markdown解析库（比如Python的markdown库、JS的marked库），但低代码平台里通常不推荐这么做，除非平台支持安装第三方依赖。

4. 流程里的变量适配

低代码平台的代码节点，通常不支持直接返回复杂对象，你可以把解析后的关键字段拆成多个变量，比如：

• content_type：标记是json还是markdown
• parsed_json：如果是JSON，存解析后的对象（平台支持的话）
• final_content：统一处理后的文本内容，给后续节点直接用

五、极简版（如果你的平台不支持复杂函数）

如果平台限制多，写不了完整函数，可以用下面这种极简写法（Python）：

import json
import re

# 清洗输出
raw = ${你的大模型输出变量}
cleaned = re.sub(r'```(json|markdown)?\s*', '', raw, flags=re.I)
cleaned = re.sub(r'```\s*$', '', cleaned).strip()

# 尝试解析JSON
is_json = False
parsed = None
try:
    parsed = json.loads(cleaned)
    is_json = True
except:
    pass

# 赋值给流程变量（根据你的平台调整）
# ${is_json} = is_json
# ${parsed_data} = parsed
# ${final_text} = parsed.get("content", cleaned) if is_json else cleaned