library(DiagrammeR)

grViz(diagram = "digraph{
 # 定义图形布局，从左到右
  graph[rankdir = TB]
 # 定义节点       
  node[shape = rectangle]
      A[label = '开始']
      B1[label = '提取日期范围\n节点：代码执行']
      B2[label = '提取机构范围\n节点：代码执行']
      B3[label = '提取主题和字段名称\n节点：代码执行']
      C1[label = 'DDL：建表脚本\n节点：知识库']
      C2[label = 'Q->SQL：常用 SQL 脚本库\n节点：知识库']
      C3[label = 'DB：数据库字段描述\n节点：知识库']
      C4[label = '指标释义\n节点：知识库']
      D[label = '生成 SQL\n节点：LLM']
      E[label = '执行 SQL\n工具：连接数据库']
      F[label = '判断图表类型\n节点：代码执行']
      G[label = '判断绘图还是制表\n节点：条件分支']
      H[label = '提取绘图参数\n节点：代码执行']
      I[label = '生成 Echarts 代码\n节点：代码执行']
      J[label ='绘图\n节点：直接回复']
      K[label = '提取 Markdown\n节点：代码执行']
      L[label ='制表\n节点：直接回复']
      
 # 定义线     
 edge[arrowsize = 1, style = solid, samehead = h1, sametail = t1]
  A -> {B1, B2, B3, C1, C2, C3, C4};
 {B1, B2, B3, C1, C2, C3, C4} -> D;
  D -> E -> F -> G;  
  G -> H -> I -> J;
  G -> K -> L;
}")

import re
import datetime
from typing import List, Optional

# ====== 中文数字处理 ======
_CN_DIGITS = {
    "零": 0, "〇": 0, "○": 0, "Ｏ": 0,
    "一": 1, "二": 2, "两": 2, "三": 3, "四": 4,
    "五": 5, "六": 6, "七": 7, "八": 8, "九": 9
}

def parse_cn_int_1_99(s: str) -> Optional[int]:
    if not s:
        return None
    if s.isdigit():
        return int(s)
    if s in _CN_DIGITS:
        return _CN_DIGITS[s]
    if s == "十":
        return 10
    if s.startswith("十") and len(s) == 2 and s[1] in _CN_DIGITS:
        return 10 + _CN_DIGITS[s[1]]
    if len(s) == 2 and s[0] in _CN_DIGITS and s[1] == "十":
        return _CN_DIGITS[s[0]] * 10
    if len(s) == 3 and s[0] in _CN_DIGITS and s[1] == "十" and s[2] in _CN_DIGITS:
        return _CN_DIGITS[s[0]] * 10 + _CN_DIGITS[s[2]]
    return None


def parse_cn_year(s: str) -> Optional[int]:
    s = s.strip()
    if re.fullmatch(r"\d{4}", s):
        return int(s)
    cn_digits_map = {**{k: str(v) for k, v in _CN_DIGITS.items()}}
    # 全中文逐位年份：二零二五/二〇二五
    if all(ch in cn_digits_map for ch in s) and len(s) == 4:
        return int("".join(cn_digits_map[ch] for ch in s))
    # 两位年份（阿拉伯）：25 -> 2025
    if re.fullmatch(r"\d{2}", s):
        return 2000 + int(s)
    # 两位年份（中文）：二五 -> 2025
    if len(s) == 2 and all(ch in cn_digits_map for ch in s):
        return 2000 + int("".join(cn_digits_map[ch] for ch in s))
    return None


def _months_range(year: int, start_m: int, end_m: int) -> List[str]:
    return [f"{year}-{m:02d}" for m in range(start_m, end_m + 1)]  # 修改为 yyyy-mm 格式


def _roll_recent_months(n: int) -> List[str]:
    """最近n个月（含当月），输出YYYY-MM，从最早到最新。"""
    now = datetime.datetime.now()
    y, m = now.year, now.month
    acc = []
    for i in range(n - 1, -1, -1):
        yy = y
        mm = m - i
        while mm <= 0:
            yy -= 1
            mm += 12
        acc.append(f"{yy}-{mm:02d}")  # 修改为 yyyy-mm 格式
    return acc


def _quarter_range(year: int, q_str: str) -> List[str]:
    """将季度中文序数映射为月份范围，支持 第一/第二/第三/第四 以及 一/二/三/四。"""
    q_map = {
        "第一": (1, 3), "第二": (4, 6), "第三": (7, 9), "第四": (10, 12),
        "一": (1, 3), "二": (4, 6), "三": (7, 9), "四": (10, 12),
    }
    if q_str in q_map:
        s, e = q_map[q_str]
        return _months_range(year, s, e)
    return []


def expand_date_expr(expr: str, base_year: int = None) -> List[str]:
    if base_year is None:
        base_year = datetime.datetime.now().year
    expr = expr.strip()

    # 绝对年月：2025年1月 / 二零二五年一月
    m = re.fullmatch(r"([0-9]{4}|[零〇○Ｏ一二两三四五六七八九]{4})年([0-9]{1,2}|[一二两三四五六七八九十]{1,3})月", expr)
    if m:
        y = parse_cn_year(m.group(1))
        mo = parse_cn_int_1_99(m.group(2))
        if y is not None and mo is not None and 1 <= mo <= 12:
            return [f"{y}-{mo:02d}"]  # 修改为 yyyy-mm 格式

    # 年+月份范围：2025年1-3月 / 二零二五年一到三月
    m = re.fullmatch(
        r"([0-9]{4}|[零〇○Ｏ一二两三四五六七八九]{4})年([0-9]{1,2}|[一二两三四五六七八九十]{1,3})(?:-|到|至)"
        r"([0-9]{1,2}|[一二两三四五六七八九十]{1,3})月", expr)
    if m:
        y = parse_cn_year(m.group(1))
        s = parse_cn_int_1_99(m.group(2))
        e = parse_cn_int_1_99(m.group(3))
        if y is not None and s is not None and e is not None and 1 <= s <= 12 and 1 <= e <= 12 and s <= e:
            return _months_range(y, s, e)

    # 全年：2025年全年 / 二零二五年全年
    m = re.fullmatch(r"([0-9]{4}|[零〇○Ｏ一二两三四五六七八九]{4})年全年", expr)
    if m:
        y = parse_cn_year(m.group(1))
        if y is not None:
            return _months_range(y, 1, 12)

    # 季度：绝对年份（支持 第一/第二/第三/第四）
    m = re.fullmatch(r"([0-9]{4}|[零〇○Ｏ一二两三四五六七八九]{4})年(第一|第二|第三|第四)季度", expr)
    if m:
        y = parse_cn_year(m.group(1))
        if y is not None:
            return _quarter_range(y, m.group(2))

    # 今年X-Y月
    m = re.fullmatch(
        r"(今年|当年|本年)([0-9]{1,2}|[一二两三四五六七八九十]{1,3})(?:-|到|至)([0-9]{1,2}|[一二两三四五六七八九十]{1,3})月",
        expr)
    if m:
        s = parse_cn_int_1_99(m.group(2))
        e = parse_cn_int_1_99(m.group(3))
        if s is not None and e is not None and 1 <= s <= 12 and 1 <= e <= 12 and s <= e:
            return _months_range(base_year, s, e)

    # 去年X-Y月
    m = re.fullmatch(
        r"去年([0-9]{1,2}|[一二两三四五六七八九十]{1,3})(?:-|到|至)([0-9]{1,2}|[一二两三四五六七八九十]{1,3})月", expr)
    if m:
        s = parse_cn_int_1_99(m.group(1))
        e = parse_cn_int_1_99(m.group(2))
        if s is not None and e is not None and 1 <= s <= 12 and 1 <= e <= 12 and s <= e:
            return _months_range(base_year - 1, s, e)

    # 今年X月
    m = re.fullmatch(r"(今年|当年|本年)([0-9]{1,2}|[一二两三四五六七八九十]{1,3})月", expr)
    if m:
        mo = parse_cn_int_1_99(m.group(2))
        if mo is not None and 1 <= mo <= 12:
            return [f"{base_year}-{mo:02d}"]  # 修改为 yyyy-mm 格式

    # 去年X月
    m = re.fullmatch(r"去年([0-9]{1,2}|[一二两三四五六七八九十]{1,3})月", expr)
    if m:
        mo = parse_cn_int_1_99(m.group(1))
        if mo is not None and 1 <= mo <= 12:
            return [f"{base_year - 1}-{mo:02d}"]  # 修改为 yyyy-mm 格式

    # 今年/去年 + 中文序数季度（新增：一/二/三/四 也支持）
    m = re.fullmatch(r"(今年|当年|本年)(第一|第二|第三|第四|一|二|三|四)季度", expr)
    if m:
        return _quarter_range(base_year, m.group(2))
    m = re.fullmatch(r"去年(第一|第二|第三|第四|一|二|三|四)季度", expr)
    if m:
        return _quarter_range(base_year - 1, m.group(1))

    # 相对时间
    if expr in {"今年", "当年", "本年"}:
        return _months_range(base_year, 1, 12)
    if expr == "去年":
        return _months_range(base_year - 1, 1, 12)
    if expr == "本月":
        now = datetime.datetime.now()
        return [f"{now.year}-{now.month:02d}"]  # 修改为 yyyy-mm 格式
    if expr in {"今年前三季度", "前三季度"}:
        return _months_range(base_year, 1, 9)
    if expr == "上半年":
        return _months_range(base_year, 1, 6)
    if expr == "下半年":
        return _months_range(base_year, 7, 12)

    # 最近N年（整年）
    m = re.fullmatch(r"最近([0-9]+|[一二两三四五六七八九十]{1,3})年", expr)
    if m:
        n = parse_cn_int_1_99(m.group(1))
        if n and n > 0:
            months = []
            for y in range(base_year - n + 1, base_year + 1):
                months.extend(_months_range(y, 1, 12))
            return months

    # 最近N个月（滚动）
    m = re.fullmatch(r"最近([0-9]+|[一二两三四五六七八九十]{1,3})个月", expr)
    if m:
        n = parse_cn_int_1_99(m.group(1))
        if n and n > 0:
            return _roll_recent_months(n)

    # 两位年：25年 / 二五年（解释为2000+）
    m = re.fullmatch(r"([0-9]{2}|[零〇○Ｏ一二两三四五六七八九]{2})年", expr)
    if m:
        y = parse_cn_year(m.group(1))
        if y is not None:
            return _months_range(y, 1, 12)

    # 今年前X季度 / 前X季度
    m = re.fullmatch(r"(今年|当年|本年)?前([一二三四0-9])季度", expr)
    if m:
        q_map = {"一": 1, "二": 2, "三": 3, "四": 4}
        q_str = m.group(2)
        q_num = q_map.get(q_str, int(q_str)) if q_str in q_map or q_str.isdigit() else None
        if q_num:
            end_month = q_num * 3
            return _months_range(base_year, 1, end_month)

    # 未识别则原样返回
    return [expr]


def extract_date_phrases(text: str) -> List[str]:
    """从文本中提取所有日期短语，保留最长匹配"""
    cn_year = r"(?:[0-9]{4}|[零〇○Ｏ一二两三四五六七八九]{4})"
    cn_year2 = r"(?:[0-9]{2}|[零〇○Ｏ一二两三四五六七八九]{2})"
    cn_month = r"(?:[0-9]{1,2}|[一二两三四五六七八九十]{1,3})"

    patterns = [
        rf"{cn_year}年{cn_month}(?:-|到|至){cn_month}月",
        rf"{cn_year}年(第一|第二|第三|第四)季度",
        rf"(今年|当年|本年){cn_month}(?:-|到|至){cn_month}月",
        rf"去年{cn_month}(?:-|到|至){cn_month}月",
        rf"(今年|当年|本年){cn_month}月",
        rf"去年{cn_month}月",
        r"(今年前[一二三四0-9]季度|前[一二三四0-9]季度)",  # 修改为通用前X季度
        r"(上半年|下半年)",
        rf"{cn_year}年{cn_month}月",
        rf"{cn_year}年全年",
        r"最近(?:[0-9]+|[一二两三四五六七八九十]{1,3})个月",
        r"最近(?:[0-9]+|[一二两三四五六七八九十]{1,3})年",
        r"(去年|今年|当年|本年|本月)",
        rf"{cn_year2}年",
        r"(今年|当年|本年)?前([一二三四1-4])季度",
    ]

    raw_phrases = []
    for pat in patterns:
        for m in re.finditer(pat, text):
            raw_phrases.append(m.group())

    # 去掉短的子串，只保留最长匹配
    phrases = []
    for ph in raw_phrases:
        if not any((ph != other and ph in other) for other in raw_phrases):
            phrases.append(ph)
    return phrases


# ====== Dify 节点入口 ======
def main(query: str) -> dict:
    """
    query: 输入的用户查询文本
    """
    base_year = None
    phrases = extract_date_phrases(query)

    months = []
    for ph in phrases:
        months.extend(expand_date_expr(ph, base_year))

    query_time_str = ",".join(months)
    return {
        "query_time": query_time_str
    }

# ====== 机构词库 ======
org_names = {'湖北', ...}  # 分公司

sub_org_names = {'武汉', '宜昌', ...}  # 中支

def _dedup_preserve_order(seq):
    seen = set()
    out = []
    for x in seq:
        if x not in seen:
            seen.add(x)
            out.append(x)
    return out

# ====== Dify 节点入口 ======
def main(query: str) -> dict:
    """
    query: 输入的用户查询文本
    """
    import re

    # 收集所有命中的词及其span
    hits = []
    for name in org_names:
        for m in re.finditer(re.escape(name), query):
            hits.append((m.start(), m.end(), name, "org"))
    for name in sub_org_names:
        for m in re.finditer(re.escape(name), query):
            hits.append((m.start(), m.end(), name, "sub"))

    # 最长优先 + 起始位置优先，选择非重叠命中
    hits.sort(key=lambda x: (-(x[1] - x[0]), x[0]))
    chosen = []
    occupied = [False] * len(query)

    for s, e, name, kind in hits:
        if any(occupied[i] for i in range(s, e)):
            continue
        chosen.append((s, e, name, kind))
        for i in range(s, e):
            occupied[i] = True

    # 保序输出各类名称
    org_list = _dedup_preserve_order([name for _, _, name, kind in chosen if kind == "org"])
    sub_list = _dedup_preserve_order([name for _, _, name, kind in chosen if kind == "sub"])

    return {
        "org_name": ",".join(org_list),
        "sub_org_name": ",".join(sub_list),
    }

# ====== 主题与指标定义 ======
topics = {
    "API": {"API", "标准保费"},...
}

indicators = {
    "API": {
        "月达成": {"月达成", "业绩达成"},
        "年达成": {"年达成"},
        "月达成率": {"月达成率"},
        "年达成率": {"年达成率"},
        "月同期": {"月同期"},
        "年同期": {"年同期"},
        "月同比": {"月同比"},
        "年同比": {"年同比"},
    },...
}

def _dedup_preserve_order(seq):
    seen = set()
    out = []
    for x in seq:
        if x not in seen:
            seen.add(x)
            out.append(x)
    return out


# ====== Dify 节点入口 ======
def main(query: str) -> dict:
    found_topics = []
    topic_indicators = {}

    # 遍历所有主题
    for topic, synonyms in topics.items():
        for syn in synonyms:
            if syn in query:
                found_topics.append(topic)
                # 在该主题下匹配指标
                inds = []
                for ind, ind_syns in indicators[topic].items():
                    for syn2 in ind_syns:
                        if syn2 in query:
                            inds.append(ind)
                topic_indicators[topic] = _dedup_preserve_order(inds)
                break

    # 拼接成字符串：主题:指标1,指标2;主题2:指标A
    select_field_parts = []
    for topic, vals in topic_indicators.items():
        if vals:
            select_field_parts.append(f"{topic}:{','.join(vals)}")
        else:
            select_field_parts.append(f"{topic}:")

    result = {
        "topic": ",".join(_dedup_preserve_order(found_topics)),
        "select_field": ";".join(select_field_parts)  # 字符串类型
    }
    return result

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

def main(query_data: Union[str, List[Dict[str, Any]], Dict[str, Any]]) -> dict:
    # 1) 解析输入
    if isinstance(query_data, str):
        try:
            parsed = json.loads(query_data)
        except Exception as e:
            raise ValueError(f"query_data 格式错误：{e}")
    else:
        parsed = query_data

    # 2) 提取 data 列表
    if isinstance(parsed, list):
        if len(parsed) > 0 and isinstance(parsed[0], dict) and "data" in parsed[0]:
            data_list = parsed[0]["data"]
        else:
            data_list = parsed
    elif isinstance(parsed, dict):
        if "data" in parsed and isinstance(parsed["data"], list):
            data_list = parsed["data"]
        else:
            raise ValueError("query_data 中未找到 data 部分")
    else:
        raise ValueError("query_data 必须是列表或字典")

    if not isinstance(data_list, list) or len(data_list) == 0:
        raise ValueError("data 必须是非空列表")

    keys = list(data_list[0].keys())

    # 判断是否有月份、分公司、中支字段
    has_month = "月份" in keys
    has_branch = "分公司" in keys
    has_subbranch = "中支" in keys
    org_key = "分公司" if has_branch else ("中支" if has_subbranch else None)

    # 提取月份、机构、指标
    months = sorted(set(item["月份"] for item in data_list)) if has_month else []
    orgs = sorted(set(item[org_key] for item in data_list)) if org_key else []
    indicators = [k for k in keys if k not in ["月份", "分公司", "中支"]]

    # 判断月份是否连续
    def is_consecutive(values: List[int]) -> bool:
        if not values: return False
        sorted_vals = sorted(values)
        return all(sorted_vals[i + 1] - sorted_vals[i] == 1 for i in range(len(sorted_vals) - 1))

    chart_type = None
    if len(months) >= 2 and is_consecutive([int(m) for m in months if str(m).isdigit()]):
        if orgs and len(indicators) == 1:
            chart_type = "line1"
        elif (not orgs or len(orgs) == 1) and len(indicators) >= 1:
            chart_type = "line2"
    elif len(months) <= 1:
        if orgs and len(indicators) == 1:
            chart_type = "bar1"
        elif orgs and len(indicators) >= 2:
            chart_type = "bar2"
    elif len(months) >= 2 and not is_consecutive([int(m) for m in months if str(m).isdigit()]):
        if orgs and len(indicators) == 1:
            chart_type = "bar3"
        elif orgs and len(indicators) >= 2:
            chart_type = "table"

    return {
        "chart_type": str(chart_type),
        "months": json.dumps(months, ensure_ascii=False),
        "orgs": json.dumps(orgs, ensure_ascii=False),
        "indicators": json.dumps(indicators, ensure_ascii=False),
        "org_key": str(org_key)
    }

import json
from collections import defaultdict
from typing import Any, Dict

def main(
        query_data: Any,
        chart_type: str,
        months: str = "[]",
        orgs: str = "[]",
        indicators: str = "[]",
        org_key: str = None
) -> dict:
    # 解析 JSON 字符串
    months = json.loads(months)
    orgs = json.loads(orgs)
    indicators = json.loads(indicators)

    # 解析 query_data
    if isinstance(query_data, str):
        parsed = json.loads(query_data)
    else:
        parsed = query_data

    if isinstance(parsed, list):
        if len(parsed) > 0 and isinstance(parsed[0], dict) and "data" in parsed[0]:
            data_list = parsed[0]["data"]
        else:
            data_list = parsed
    elif isinstance(parsed, dict):
        data_list = parsed["data"]
    else:
        raise ValueError("query_data 必须是列表或字典")

    series_data = []
    x_key = None
    x_values = []

    if chart_type in ["line1", "line2"]:
        x_key = "月份"
        x_values = months
        if chart_type == "line1":
            grouped = defaultdict(list)
            for item in data_list:
                grouped[item[org_key]].append(item)
            for gname, gitems in grouped.items():
                gitems_sorted = sorted(gitems, key=lambda x: x["月份"])
                for ind in indicators:
                    series_data.append({
                        "name": f"{gname}-{ind}",
                        "type": "line",
                        "data": [it[ind] for it in gitems_sorted]
                    })
        elif chart_type == "line2":
            sorted_data = sorted(data_list, key=lambda x: x["月份"])
            for ind in indicators:
                series_data.append({
                    "name": ind,
                    "type": "line",
                    "data": [it[ind] for it in sorted_data]
                })

    elif chart_type in ["bar1", "bar2"]:
        x_key = org_key
        x_values = orgs
        for ind in indicators:
            series_data.append({
                "name": ind,
                "type": "bar",
                "data": [item[ind] for item in data_list if item[org_key] in orgs]
            })

    elif chart_type == "bar3":
        x_key = "月份"
        x_values = months
        grouped = defaultdict(list)
        for item in data_list:
            grouped[item[org_key]].append(item)
        for gname, gitems in grouped.items():
            gitems_sorted = sorted(gitems, key=lambda x: x["月份"])
            for ind in indicators:
                series_data.append({
                    "name": f"{gname}-{ind}",
                    "type": "bar",
                    "data": [it[ind] for it in gitems_sorted]
                })

    elif chart_type == "table":
        return {
            "chart_type": "table",
            "data": json.dumps(data_list, ensure_ascii=False)
        }

    return {
        "x_name": str(x_key),
        "y_name": ";".join([s["name"] for s in series_data]),
        "x_values": json.dumps(x_values, ensure_ascii=False),
        "series_data": json.dumps(series_data, ensure_ascii=False),
        "chart_type": str(chart_type)
    }

import json

def main(x_values: str, series_data: str, x_name: str, y_name: str, chart_type: str) -> dict:
    x_data = json.loads(x_values.replace("'", '"'))
    series_raw = json.loads(series_data)

    # 检查是否包含百分比或万元相关指标
    is_percent = False
    is_wanyuan = False

    for s in series_raw:
        # 转换百分比数据
        if any(isinstance(v, str) and "%" in v for v in s.get("data", [])):
            is_percent = True
            s["data"] = [float(str(v).replace("%", "")) if isinstance(v, str) and "%" in v else v for v in s["data"]]

        # 判断是否为万元相关指标
        if any(key in s.get("name", "") for key in ["月达成", "年达成", "月同期", "年同期"]):
            is_wanyuan = True

    # 公共工具箱配置
    toolbox_config = {
        "show": 'true',
        "feature": {
            "dataZoom": {
                "yAxisIndex": 'none',
                "title": {
                    "zoom": "区域缩放",
                    "back": "区域缩放还原"
                }
            },
            "dataView": {"readOnly": 'true',
                         "title": "查询结果",
                         "lang": ['查询结果', '关闭', '刷新']
                         },
            "magicType": {"type": ['line', 'bar'],
                          "title": {
                              "line": "折线图",
                              "bar": "柱状图"
                          }
                          },
            "restore": {
                "title": "还原"
            },
            "saveAsImage": {
                "type": "png",
                "title": "另存为图片"
            }
        }
    }

    # tooltip formatter 根据情况调整（使用模板字符串）
    tooltip_config = {"trigger": "axis"}
    if is_percent:
        tooltip_config["valueFormatter"] = "{value}%"
        y_name = "%"
    elif is_wanyuan:
        tooltip_config["valueFormatter"] = "{value} 万元"
        y_name = "万元"

    # 基础配置
    echarts_config = {
        "tooltip": tooltip_config,
        "legend": {"top": "bottom"},
        "toolbox": toolbox_config,
        "xAxis": {
            "type": "category",
            "name": x_name,
            "data": x_data
        },
        "yAxis": {
            "type": "value",
            "name": y_name
        },
        "series": series_raw
    }

    # 针对 bar2 和 bar3 添加 stack 属性
    if chart_type == "bar2":
        for s in series_raw:
            s["stack"] = "总量"
        echarts_config["tooltip"]["axisPointer"] = {"type": "shadow"}
    elif chart_type == "bar3":
        for s in series_raw:
            s["stack"] = "时间"
        echarts_config["tooltip"]["axisPointer"] = {"type": "shadow"}

    echarts_script = f"```echarts\n{json.dumps(echarts_config, ensure_ascii=False, indent=2)}\n```"

    return {
        "echarts_code": echarts_script
    }

import json
from typing import Dict, Any

def main(query_data: Dict[str, Any] = None, **kwargs) -> dict:
    """
    从输入中提取 markdown 表格字符串：
    - query_data 允许为空（便于兼容仅用关键字参数的调用），随后用 kwargs 回填；
    - 最终确保 query_data 存在，并且含有 json 列表；
    - 优先使用首项中的 markdown 字段；如无，可选从 data 自动生成（默认关闭）。
    """
    # 1) 初始化并回填 query_data
    query_data = query_data or {}
    # 将 kwargs 中的 json 回填进 query_data（Dify 常见：main(json=[...])）
    if "json" in kwargs and "json" not in query_data:
        query_data["json"] = kwargs["json"]

    # 2) 校验结构
    if "json" not in query_data or not isinstance(query_data["json"], list):
        raise ValueError("输入数据格式错误：缺少 json 列表")

    items = query_data["json"]
    if len(items) == 0 or not isinstance(items[0], dict):
        raise ValueError("输入数据格式错误：json 列表为空或首项不是对象")

    first_item = items[0]

    # 3) 优先提取已提供的 markdown 字段
    if "markdown" in first_item and isinstance(first_item["markdown"], str):
        return {"markdown": first_item["markdown"]}

    # 4) 如无 markdown，可根据 data 生成（如需开启，取消注释）
    # if "data" in first_item and isinstance(first_item["data"], list) and first_item["data"]:
    #     rows = first_item["data"]
    #     preferred_cols = ["机构名称", "月份", "API:月达成"]
    #     cols = preferred_cols if all(c in rows[0] for c in preferred_cols) else list(rows[0].keys())
    #     header = "| " + " | ".join(cols) + " |"
    #     sep = "| " + " | ".join(["---"] * len(cols)) + " |"
    #     lines = [header, sep]
    #     for r in rows:
    #         line = "| " + " | ".join(str(r.get(c, "")) for c in cols) + " |"
    #         lines.append(line)
    #     markdown_str = "\n".join(lines)
    #     return {"markdown": markdown_str}

    # 5) 若既没有 markdown，也没有 data，则报错
    raise ValueError("未找到 markdown 字段，且无法从 data 自动生成")