#!/usr/bin/env python3 """ LLM 驱动的 jsonData / kpInfo 生成器 从教研配置文本 + 组件类型 + per-type prompt模板 → 调用 LLM 生成结构化 JSON 核心设计 v2： - 每种组件类型使用 PRD 定义的精确 prompt 模板（prompts/prompt_registry.py） - 教研配置文本拆解为结构化字段作为 prompt 输入变量 - 角色配置通过 section-character 映射解析 - 对无模板的类型回退到 few-shot 样例方式 - 规则负责后处理：校验必需字段、修正 cType/cId """ import os import sys import json import logging import re CURRENT_PATH = os.path.dirname(os.path.abspath(__file__)) SKILL_ROOT = os.path.dirname(CURRENT_PATH) if CURRENT_PATH not in sys.path: sys.path.insert(0, CURRENT_PATH) # Ensure prompts package is importable if SKILL_ROOT not in sys.path: sys.path.insert(0, SKILL_ROOT) logger = logging.getLogger("generate_json") if not logger.handlers: handler = logging.StreamHandler() handler.setFormatter(logging.Formatter( "%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s" )) logger.addHandler(handler) logger.setLevel(logging.INFO) # ============ 参考样例加载 ============ _examples_cache = None def _load_examples(): """加载所有组件类型的参考样例""" global _examples_cache if _examples_cache is not None: return _examples_cache examples_path = os.path.join(SKILL_ROOT, "references", "examples", "all_types_examples.json") if not os.path.exists(examples_path): logger.warning(f"参考样例文件不存在: {examples_path}") _examples_cache = {} return _examples_cache with open(examples_path, "r") as f: _examples_cache = json.load(f) logger.info(f"加载参考样例: {len(_examples_cache)} 种类型") return _examples_cache def _get_examples_for_type(cType): """获取指定组件类型的参考样例""" examples = _load_examples() type_data = examples.get(cType) if not type_data or not type_data.get("examples"): return [] return type_data["examples"] # ============ Prompt 构建（v2 per-type 模板） ============ from prompts.prompt_registry import ( parse_teaching_config_fields, build_full_prompt, get_supported_types, CDESC_TYPES, build_cdesc_prompt, ) from prompts.core_reading_prompts import ( CORE_READING_STEPS, build_step_prompt, ) from prompts.core_imagedrag_prompts import ( CORE_IMAGEDRAG_STEPS, build_imagedrag_prompt, ) from prompts.core_speaking_prompts import ( CORE_SPEAKING_STEPS, build_speaking_prompt, ) from prompts.core_speaking_inquiry_prompts import ( CORE_SPEAKING_INQUIRY_STEPS, build_speaking_inquiry_prompt, ) from prompts.core_speaking_image_prompts import ( CORE_SPEAKING_IMAGE_STEPS, build_speaking_image_prompt, ) from prompts.core_listening_order_prompts import ( CORE_LISTENING_ORDER_STEPS, build_listening_order_prompt, ) from prompts.core_listening_drag_prompts import ( CORE_LISTENING_DRAG_STEPS, build_listening_drag_prompt, ) from prompts.core_listening_choose_prompts import ( CORE_LISTENING_CHOOSE_STEPS, build_listening_choose_prompt, ) from prompts.core_writing_img_prompts import ( CORE_WRITING_IMG_MAKE_SENTENCE_STEPS, CORE_WRITING_IMG_WRITE_STEPS, build_writing_img_prompt, ) from prompts.core_writing_question_prompts import ( CORE_WRITING_Q_MAKE_SENTENCE_STEPS, CORE_WRITING_Q_WRITE_STEPS, build_writing_question_prompt, ) # Fallback: 旧版 few-shot 方式（对无 prompt 模板的类型） FALLBACK_SYSTEM_PROMPT = """你是一个互动组件配置JSON生成专家。根据教研配置文本生成对应的 jsonData JSON。 ## 组件类型: {cType} ## 输出要求 1. 输出必须是单行合法JSON 2. cType 必须为 "{cType}" 3. cId 必须为提供的组件ID 4. 严格按照参考样例的JSON结构输出 5. "无"的字段使用空数组[]或空对象{{}} ## 参考样例 {examples_text} 请直接输出单行JSON，不要包含任何其他符号。""" def _build_fallback_examples_text(examples, max_examples=2): """构建 few-shot 样例文本（回退用）""" parts = [] for i, ex in enumerate(examples[:max_examples], 1): teaching_config = ex.get("teaching_config", "") json_data = ex.get("jsonData", "") try: jd_obj = json.loads(json_data) if isinstance(json_data, str) else json_data json_data_formatted = json.dumps(jd_obj, ensure_ascii=False) except (json.JSONDecodeError, TypeError): json_data_formatted = str(json_data) parts.append(f"### 样例 {i}\n教研配置:\n{teaching_config}\n\n输出:\n{json_data_formatted}") return "\n\n".join(parts) def _build_fallback_user_prompt(cId, teaching_config, character_map, has_image): """构建 user prompt（回退用）""" parts = [f"组件ID: {cId}"] if has_image: parts.append(f'配图: 是（img="{cId}.png"）') if character_map: parts.append(f"角色配置: {json.dumps(character_map, ensure_ascii=False)}") parts.append(f"\n教研配置:\n{teaching_config}") parts.append("\n请直接输出单行JSON") return "\n".join(parts) # ============ 语音识别热词自动生成 ============ ASR_HOTWORD_PROMPT = """#任务 参考当前的互动配置，如果互动对话为[表达]类，则根据互动场景，给出一些可能高频出现的 或者 可能有一定识别难度的词汇，用","连接。如果互动对话为[朗读]类，则返回"无"。 语音识别词汇的考虑范围: - 交互中可能提及的专有名词(例如人名、地名、特定物品名称等) - 互动目标的一些场景表达，例如 题目中要谈论"目标"，则热词中可以提供 goal/target 等。 #输入 情境引入: $pre_dialog$ 互动对话: $interaction$ 后置对话: $post_dialog$ #输出 现在，根据任务要求直接输出符合要求的热词字段("无"，或者逗号连接的多个单词)。""" # 需要自动生成热词的组件类型 ASR_TYPES = {"mid_dialog_express"} def generate_asr_hotwords(cType, parsed_fields, llm_client): """ 用 LLM 自动生成语音识别热词。 表达类互动自动生成，朗读类返回"无"。 Args: cType: 组件类型 parsed_fields: 解析后的教研配置字段 llm_client: LLMClient 实例 Returns: str: 热词字符串（逗号分隔）或 "无" """ if cType not in ASR_TYPES: return "无" pre_dialog = parsed_fields.get("情境引入", "无") interaction = parsed_fields.get("互动内容", "无") post_dialog = parsed_fields.get("后置对话", "无") prompt = ASR_HOTWORD_PROMPT.replace( "$pre_dialog$", pre_dialog ).replace( "$interaction$", interaction ).replace( "$post_dialog$", post_dialog ) try: content, usage = llm_client.call("", prompt, max_tokens=256, temperature=0.3) hotwords = content.strip().strip('"').strip() logger.info(f"[热词生成] cType={cType}, hotwords={hotwords[:80]}, tokens={usage}") return hotwords if hotwords else "无" except Exception as e: logger.warning(f"[热词生成] 失败: {e}") return "无" # ============ kpInfo 生成 ============ KP_SYSTEM_PROMPT = """你是一个知识点信息JSON生成专家。根据提供的组件类型、组件ID和知识点文本，生成 kpInfo JSON。 ## 输出要求 1. 输出必须是合法JSON 2. 结构固定为: ```json { "pushType": "relationKp", "cType": "<组件cType>", "cId": "<组件ID>", "kpInfo": [ { "kpId": null, "kpType": "vocab 或 sentence", "kpTitle": "<知识点标题>", "kpSkill": "vocab_meaning 或 sentence_meaning", "kpSkillName": "词义 或 语义" } ] } ``` 3. 判断知识点类型的规则: - 如果知识点是单个英文单词（如 school, play），则 kpType="vocab", kpSkill="vocab_meaning", kpSkillName="词义" - 如果知识点包含 "..." 或是句子片段（如 "You need to..."），则 kpType="sentence", kpSkill="sentence_meaning", kpSkillName="语义" 4. 知识点文本中可能包含数字后缀（如 "school 1"），数字后缀表示出现次数，不要包含在 kpTitle 中 5. 多个知识点用换行分隔，每个生成一条 kpInfo 条目 6. 去除 标签及其属性 请直接输出JSON，不要包含任何其他文字。""" def _build_kp_user_prompt(cType, cId, knowledge_text): """构建知识点 user prompt""" return f"cType: {cType}\ncId: {cId}\n知识点文本:\n{knowledge_text}" # ============ 核心生成函数 ============ def generate_json_data(cType, cId, teaching_config, character_map=None, has_image=False, knowledge_text="", llm_client=None): """ 使用 LLM 生成组件的 jsonData。 优先使用 per-type prompt 模板，对无模板的类型回退到 few-shot。 Args: cType: 英文类型标识（如 "mid_dialog_repeat"） cId: 组件ID（如 "1214101"） teaching_config: 教研配置文本 character_map: 角色映射 {"Eva": 663, "Peter": 653} has_image: 是否配图 knowledge_text: 知识点文本 llm_client: LLMClient 实例 Returns: dict: 生成的 jsonData 对象 """ if llm_client is None: from llm_client import get_client llm_client = get_client() # 优先使用 per-type prompt 模板 if cType in get_supported_types(): json_data = _generate_with_template(cType, cId, teaching_config, character_map, llm_client) else: # 回退到 few-shot 方式 logger.info(f"组件类型 {cType} 无 prompt 模板，使用 few-shot 回退") json_data = _generate_with_fallback(cType, cId, teaching_config, character_map, has_image, llm_client) # 后处理：确保必需字段正确 json_data = _post_process_json_data(json_data, cType, cId, has_image) logger.info(f"生成 jsonData: cType={cType}, cId={cId}") return json_data def _generate_with_template(cType, cId, teaching_config, character_map, llm_client): """使用 per-type prompt 模板生成 jsonData""" # 解析教研配置为结构化字段 parsed_fields = parse_teaching_config_fields(teaching_config) # 对需要热词的类型，自动生成语音识别热词 if cType in ASR_TYPES: existing_hotwords = parsed_fields.get("语音识别热词", "").strip() if not existing_hotwords or existing_hotwords == "无": hotwords = generate_asr_hotwords(cType, parsed_fields, llm_client) parsed_fields["语音识别热词"] = hotwords # 对需要互动描述的类型，LLM 预生成 cDesc 文本 if cType in CDESC_TYPES: cdesc_prompt = build_cdesc_prompt(cType, parsed_fields) 互动描述, usage = llm_client.call("", cdesc_prompt, max_tokens=1024, temperature=0.3) parsed_fields["互动描述"] = 互动描述.strip() logger.info(f"[cDesc] cType={cType}, cId={cId}, tokens={usage}") # 构建角色配置字符串（如 "663-EVA, 653-peter, 658-Vicky"） resource_mapping_str = "" if character_map: parts = [f"{v}-{k}" for k, v in character_map.items()] resource_mapping_str = ", ".join(parts) # 构建完整 prompt full_prompt = build_full_prompt(cType, cId, parsed_fields, resource_mapping_str) # 调用 LLM（单一 user prompt，无 system prompt） json_data, usage = llm_client.call_for_json("", full_prompt, max_tokens=4096, temperature=0.1) logger.info(f"[template] cType={cType}, cId={cId}, tokens={usage}") return json_data def _generate_with_fallback(cType, cId, teaching_config, character_map, has_image, llm_client): """使用 few-shot 样例回退生成 jsonData""" examples = _get_examples_for_type(cType) examples_text = _build_fallback_examples_text(examples) if examples else "（无参考样例）" system_prompt = FALLBACK_SYSTEM_PROMPT.format(cType=cType, examples_text=examples_text) user_prompt = _build_fallback_user_prompt(cId, teaching_config, character_map or {}, has_image) json_data, usage = llm_client.call_for_json(system_prompt, user_prompt, max_tokens=4096, temperature=0.1) logger.info(f"[fallback] cType={cType}, cId={cId}, tokens={usage}") return json_data def generate_kp_info(cType, cId, knowledge_text, llm_client=None, level=None): """ 生成组件的 kpInfo（通过 MySQL 知识点库匹配） Args: cType: 英文类型标识 cId: 组件ID knowledge_text: 知识点文本（来自sheet H列） llm_client: LLMClient 实例 level: 剧本级别（如 "L1", "L2"） Returns: dict: 生成的 kpInfo 对象，如果无知识点则返回 None """ if not knowledge_text or not knowledge_text.strip(): return None from kp_matcher import match_knowledge_points return match_knowledge_points(knowledge_text, cType, cId, level=level, llm_client=llm_client) CORE_TYPES = {"core_reading_order", "core_reading_imageDrag", "core_speaking_reply", "core_speaking_inquiry", "core_speaking_image", "core_listening_order", "core_listening_drag", "core_listening_choose", "core_writing_imgMakeSentence", "core_writing_imgWrite", "core_writing_questionMakeSentence", "core_writing_questionWrite"} def parse_core_reading_fields(teaching_config): """ 从组件配置文本中提取 core_reading_order 所需的输入字段。 组件配置 = 教研配置-任务 + 教研配置-材料 拼接，包含 【xxx】 sections。 额外可能包含 【流程编排】【角色配置】【专有词汇】【学习材料】 等。 Returns: dict: 字段名 → 值 """ fields = parse_teaching_config_fields(teaching_config) # 任务配置 = 任务标题 + 任务背景 task_parts = [] if fields.get("任务标题"): task_parts.append(f"【任务标题】\n{fields['任务标题']}") if fields.get("任务背景"): task_parts.append(f"【任务背景】\n{fields['任务背景']}") 任务配置 = "\n\n".join(task_parts) if task_parts else "" # 通关知识 通关知识 = fields.get("通关知识", "") # 材料配置 = 阅读材料 section (用于 Step1/Step2) 材料配置 = fields.get("阅读材料", "") # 学习材料 / 学习过程 (用于 Step2, bitable中有时叫【学习过程】) 学习材料 = fields.get("学习材料", "") or fields.get("学习过程", "") # 互动题目 / 题目部分 互动题目 = fields.get("题目部分", "") or fields.get("互动题目", "") # 流程编排 流程编排 = fields.get("流程编排", "") # 角色配置 (从组件配置的 【角色配置】section) 角色配置 = fields.get("角色配置", "") # 专有词汇 / 专有名词 专有词汇 = fields.get("专有词汇", "") or fields.get("专有名词", "") return { "任务配置": 任务配置, "通关知识": 通关知识, "材料配置": 材料配置, "学习材料": 学习材料, "互动题目": 互动题目, "流程编排": 流程编排, "角色配置": 角色配置, "专有词汇": 专有词汇, } def generate_core_reading_order(cId, teaching_config, character_map=None, llm_client=None, level=None): """ 合作阅读（core_reading_order）7步 LLM 生成流水线。 Step 1: 阅读材料格式化 → 材料正文 (text) Step 2: 学习材料格式化 → 学习内容 (text) Step 3: 学习过程配置 → 学习配置 (text) Step 4: taskData → JSON Step 5: textData → JSON Step 6: sequenceData → JSON Step 7: learningData → JSON Args: cId: 组件ID teaching_config: 教研配置文本（组件配置列） character_map: 角色映射 dict（可选，从section-character映射解析而来） llm_client: LLMClient 实例 Returns: dict: { "taskData": dict, "textData": dict, "sequenceData": dict, "learningData": dict, "kpInfo": dict or None, "intermediate": {"阅读材料格式化": str, "学习材料格式化": str, "学习过程配置": str} } """ if llm_client is None: from llm_client import get_client llm_client = get_client() cType = "core_reading_order" # 解析输入字段 fields = parse_core_reading_fields(teaching_config) # 角色配置：优先使用组件配置中的，回退到 character_map 角色配置 = fields["角色配置"] if not 角色配置 and character_map: 角色配置 = "\n".join(f"{k}：{v}" for k, v in character_map.items()) # 学习材料输入：优先使用【学习材料】section，回退到【阅读材料】 step2_input = fields["学习材料"] if fields["学习材料"].strip() else fields["材料配置"] logger.info(f"[core_reading] 开始7步生成: cId={cId}") # ── Step 1: 阅读材料格式化 ── logger.info(f"[core_reading] Step 1/7: 阅读材料格式化") prompt1 = build_step_prompt("step1_format_reading", {"材料配置": fields["材料配置"]}) 材料正文, usage1 = llm_client.call("", prompt1, max_tokens=8192, temperature=0.1) 材料正文 = 材料正文.strip() logger.info(f" Step 1 完成: {len(材料正文)} 字符, tokens={usage1}") # ── Step 2: 学习材料格式化 ── logger.info(f"[core_reading] Step 2/7: 学习材料格式化") prompt2 = build_step_prompt("step2_format_learning", {"材料配置": step2_input}) 学习内容, usage2 = llm_client.call("", prompt2, max_tokens=8192, temperature=0.1) 学习内容 = 学习内容.strip() logger.info(f" Step 2 完成: {len(学习内容)} 字符, tokens={usage2}") # ── Step 3: 学习过程配置 ── logger.info(f"[core_reading] Step 3/7: 学习过程配置") prompt3 = build_step_prompt("step3_learning_process", { "文章材料": 材料正文, "学习内容": 学习内容, "专有词汇": fields["专有词汇"], }) 学习配置, usage3 = llm_client.call("", prompt3, max_tokens=8192, temperature=0.3) 学习配置 = 学习配置.strip() logger.info(f" Step 3 完成: {len(学习配置)} 字符, tokens={usage3}") # ── Step 4: taskData ── logger.info(f"[core_reading] Step 4/7: taskData") prompt4 = build_step_prompt("step4_task_data", { "ID": str(cId), "任务配置": fields["任务配置"], "通关知识": fields["通关知识"], "角色配置": 角色配置, }) taskData, usage4 = llm_client.call_for_json("", prompt4, max_tokens=4096, temperature=0.1) logger.info(f" Step 4 完成: taskData keys={list(taskData.keys())}, tokens={usage4}") # ── Step 5: textData ── logger.info(f"[core_reading] Step 5/7: textData") prompt5 = build_step_prompt("step5_text_data", { "ID": str(cId), "材料正文": 材料正文, "互动题目": fields["互动题目"], "角色配置": 角色配置, }) textData, usage5 = llm_client.call_for_json("", prompt5, max_tokens=8192, temperature=0.1) logger.info(f" Step 5 完成: textData keys={list(textData.keys())}, tokens={usage5}") # ── Step 6: sequenceData ── logger.info(f"[core_reading] Step 6/7: sequenceData") prompt6 = build_step_prompt("step6_sequence_data", { "ID": str(cId), "流程编排": fields["流程编排"], "角色配置": 角色配置, }) sequenceData, usage6 = llm_client.call_for_json("", prompt6, max_tokens=4096, temperature=0.1) logger.info(f" Step 6 完成: sequenceData keys={list(sequenceData.keys())}, tokens={usage6}") # ── Step 7: learningData ── logger.info(f"[core_reading] Step 7/7: learningData") prompt7 = build_step_prompt("step7_learning_data", {"学习配置": 学习配置}) learningData, usage7 = llm_client.call_for_json("", prompt7, max_tokens=8192, temperature=0.1) logger.info(f" Step 7 完成: learningData keys={list(learningData.keys())}, tokens={usage7}") # ── kpInfo (MySQL 匹配) ── kp_info = generate_kp_info(cType, cId, fields["通关知识"], llm_client=llm_client, level=level) logger.info(f"[core_reading] 7步生成全部完成: cId={cId}") return { "taskInfo": taskData, "materialInfo": textData, "flowInfo": sequenceData, "studyInfo": learningData, "kpInfo": kp_info, "intermediate": { "阅读材料格式化": 材料正文, "学习材料格式化": 学习内容, "学习过程配置": 学习配置, }, } def parse_core_imagedrag_fields(teaching_config): """ 从组件配置文本中提取 core_reading_imageDrag 所需的输入字段。 组件配置 = 教研-导览配置 + 教研-互动配置 拼接，包含 【xxx】 sections。 Returns: dict: 字段名 → 值 """ fields = parse_teaching_config_fields(teaching_config) # 用户任务描述 = 任务标题 + 任务背景 + 任务描述 desc_parts = [] if fields.get("任务标题"): desc_parts.append(f"【任务标题】\n{fields['任务标题']}") if fields.get("任务背景"): desc_parts.append(f"【任务背景】\n{fields['任务背景']}") if fields.get("任务描述"): desc_parts.append(f"【任务描述】\n{fields['任务描述']}") 用户任务描述 = "\n\n".join(desc_parts) if desc_parts else "" # 用户任务知识 / 通关知识 用户任务知识 = fields.get("用户任务知识", "") or fields.get("通关知识", "") # 互动配置 (包含 阅读材料 + 互动问题) 互动配置 = fields.get("互动配置", "") or fields.get("阅读材料", "") # 如果没有单独的互动配置 section, 尝试拼接阅读材料+互动问题 if not 互动配置: parts = [] for key in ["阅读材料1", "阅读材料2", "阅读材料", "材料部分", "互动问题"]: if fields.get(key): parts.append(fields[key]) 互动配置 = "\n\n".join(parts) # 角色配置 角色配置 = fields.get("角色配置", "") # 专有词汇 / 专有名词 专有词汇 = fields.get("专有词汇", "") or fields.get("专有名词", "") return { "用户任务描述": 用户任务描述, "用户任务知识": 用户任务知识, "互动配置": 互动配置, "角色配置": 角色配置, "专有词汇": 专有词汇, } def generate_core_reading_imagedrag(cId, teaching_config, character_map=None, llm_client=None, level=None): """ 看图选词（core_reading_imageDrag）5步 LLM 生成流水线。 Step 1: 学习流程配置 → 中间文本 Step 2: 互动描述 → 中间文本 Step 3: taskInfo → JSON Step 4: questionGroup → JSON Step 5: studyInfo → JSON Returns: dict: { "taskData": dict, "questionGroupData": list/dict, "studyData": dict, "kpInfo": dict or None, "intermediate": {"学习流程配置": str, "互动描述": str} } """ if llm_client is None: from llm_client import get_client llm_client = get_client() cType = "core_reading_imageDrag" # 解析输入字段 fields = parse_core_imagedrag_fields(teaching_config) # 角色配置：优先使用组件配置中的，回退到 character_map 角色配置 = fields["角色配置"] if not 角色配置 and character_map: 角色配置 = "\n".join(f"{k}：{v}" for k, v in character_map.items()) logger.info(f"[core_imagedrag] 开始5步生成: cId={cId}") # ── Step 1: 学习流程配置 ── logger.info(f"[core_imagedrag] Step 1/5: 学习流程配置") prompt1 = build_imagedrag_prompt("step1_learning_flow", { "互动配置": fields["互动配置"], "用户任务知识": fields["用户任务知识"], "专有词汇": fields["专有词汇"], }) 学习流程配置, usage1 = llm_client.call("", prompt1, max_tokens=8192, temperature=0.3) 学习流程配置 = 学习流程配置.strip() logger.info(f" Step 1 完成: {len(学习流程配置)} 字符, tokens={usage1}") # ── Step 2: 互动描述 ── logger.info(f"[core_imagedrag] Step 2/5: 互动描述") prompt2 = build_imagedrag_prompt("step2_interaction_desc", { "用户任务描述": fields["用户任务描述"], "互动配置": fields["互动配置"], }) 互动描述, usage2 = llm_client.call("", prompt2, max_tokens=4096, temperature=0.3) 互动描述 = 互动描述.strip() logger.info(f" Step 2 完成: {len(互动描述)} 字符, tokens={usage2}") # ── Step 3: taskInfo ── logger.info(f"[core_imagedrag] Step 3/5: taskInfo") prompt3 = build_imagedrag_prompt("step3_task_info", { "ID": str(cId), "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "角色配置": 角色配置, "互动描述": 互动描述, }) taskData, usage3 = llm_client.call_for_json("", prompt3, max_tokens=4096, temperature=0.1) logger.info(f" Step 3 完成: taskData keys={list(taskData.keys())}, tokens={usage3}") # ── Step 4: questionGroup ── logger.info(f"[core_imagedrag] Step 4/5: questionGroup") prompt4 = build_imagedrag_prompt("step4_question_group", { "配置材料": fields["互动配置"], }) questionGroupData, usage4 = llm_client.call_for_json("", prompt4, max_tokens=8192, temperature=0.1) logger.info(f" Step 4 完成: questionGroupData type={type(questionGroupData).__name__}, tokens={usage4}") # ── Step 5: studyInfo ── logger.info(f"[core_imagedrag] Step 5/5: studyInfo") prompt5 = build_imagedrag_prompt("step5_study_info", { "学习流程配置": 学习流程配置, }) studyData, usage5 = llm_client.call_for_json("", prompt5, max_tokens=8192, temperature=0.1) logger.info(f" Step 5 完成: studyData keys={list(studyData.keys()) if isinstance(studyData, dict) else 'list'}, tokens={usage5}") # ── kpInfo (MySQL 匹配) ── kp_info = generate_kp_info(cType, cId, fields["用户任务知识"], llm_client=llm_client, level=level) logger.info(f"[core_imagedrag] 5步生成全部完成: cId={cId}") return { "taskInfo": taskData, "questionGroup": questionGroupData, "studyInfo": studyData, "kpInfo": kp_info, "intermediate": { "学习流程配置": 学习流程配置, "互动描述": 互动描述, }, } def parse_core_speaking_fields(teaching_config): """ 从组件配置文本中提取 core_speaking_reply 所需的输入字段。 组件配置 = 教研-用户视角任务信息 + 教研-任务规则与NPC设定 拼接。 Returns: dict: 字段名 → 值 """ fields = parse_teaching_config_fields(teaching_config) # 用户任务描述 = 任务标题 + 任务背景 + 任务描述 desc_parts = [] if fields.get("任务标题"): desc_parts.append(f"【任务标题】\n{fields['任务标题']}") if fields.get("任务背景"): desc_parts.append(f"【任务背景】\n{fields['任务背景']}") if fields.get("任务描述"): desc_parts.append(f"【任务描述】\n{fields['任务描述']}") 用户任务描述 = "\n\n".join(desc_parts) if desc_parts else "" # 用户任务知识 / 通关知识 用户任务知识 = fields.get("用户任务知识", "") or fields.get("通关知识", "") # 示例对话 示例对话 = fields.get("示例对话", "") # 角色配置 角色配置 = fields.get("角色配置", "") # 专有词汇 / 专有名词 专有词汇 = fields.get("专有词汇", "") or fields.get("专有名词", "") # 对话配置 = 对话角色 + 回合设定 dialog_parts = [] if fields.get("对话角色"): dialog_parts.append(f"【对话角色】\n{fields['对话角色']}") if fields.get("回合设定"): dialog_parts.append(f"【回合设定】\n{fields['回合设定']}") 对话配置 = "\n\n".join(dialog_parts) if dialog_parts else "" # NPC任务设定 / 任务设定 npc任务设定 = fields.get("任务设定", "") or fields.get("npc任务设定", "") # NPC视角任务背景 / 任务背景(NPC视角) # 如果有单独的NPC背景section用它，否则复用任务背景 npc任务背景 = fields.get("npc视角任务背景", "") or fields.get("任务背景", "") # 通过规则 通过规则 = fields.get("通过规则", "") return { "用户任务描述": 用户任务描述, "用户任务知识": 用户任务知识, "示例对话": 示例对话, "角色配置": 角色配置, "专有词汇": 专有词汇, "对话配置": 对话配置, "npc任务设定": npc任务设定, "npc视角任务背景": npc任务背景, "通过规则": 通过规则, } def generate_core_speaking_reply(cId, teaching_config, character_map=None, llm_client=None, level=None): """ 口语快答（core_speaking_reply）7步 LLM 生成流水线。 Step 1: 学习流程配置 → 中间文本 Step 2: promptInfo配置 → 中间文本 Step 3: 语音识别热词 → 中间文本 Step 4: taskData → JSON Step 5: settingData → JSON Step 6: configData → JSON Step 7: learningData → JSON Returns: dict: { "taskData": dict, "settingData": dict, "configData": dict, "learningData": dict, "kpInfo": dict or None, "intermediate": {"学习流程配置": str, "promptInfo配置": str, "语音识别热词": str} } """ if llm_client is None: from llm_client import get_client llm_client = get_client() cType = "core_speaking_reply" # 解析输入字段 fields = parse_core_speaking_fields(teaching_config) # 角色配置：优先使用组件配置中的，回退到 character_map 角色配置 = fields["角色配置"] if not 角色配置 and character_map: 角色配置 = "\n".join(f"{k}：{v}" for k, v in character_map.items()) logger.info(f"[core_speaking] 开始7步生成: cId={cId}") # ── Step 1: 学习流程配置 ── logger.info(f"[core_speaking] Step 1/7: 学习流程配置") prompt1 = build_speaking_prompt("step1_learning_flow", { "用户任务描述": fields["用户任务描述"], "示例对话": fields["示例对话"], "专有词汇": fields["专有词汇"], }) 学习流程配置, usage1 = llm_client.call("", prompt1, max_tokens=8192, temperature=0.3) 学习流程配置 = 学习流程配置.strip() logger.info(f" Step 1 完成: {len(学习流程配置)} 字符, tokens={usage1}") # ── Step 2: promptInfo配置 ── logger.info(f"[core_speaking] Step 2/7: promptInfo配置") prompt2 = build_speaking_prompt("step2_prompt_info", { "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "示例对话": fields["示例对话"], "npc视角任务背景": fields["npc视角任务背景"], "npc任务设定": fields["npc任务设定"], }) promptInfo配置, usage2 = llm_client.call("", prompt2, max_tokens=8192, temperature=0.3) promptInfo配置 = promptInfo配置.strip() logger.info(f" Step 2 完成: {len(promptInfo配置)} 字符, tokens={usage2}") # ── Step 3: 语音识别热词 ── logger.info(f"[core_speaking] Step 3/7: 语音识别热词") prompt3 = build_speaking_prompt("step3_asr_hotwords", { "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "示例对话": fields["示例对话"], }) 语音识别热词, usage3 = llm_client.call("", prompt3, max_tokens=1024, temperature=0.1) 语音识别热词 = 语音识别热词.strip() logger.info(f" Step 3 完成: {len(语音识别热词)} 字符, tokens={usage3}") # ── Step 4: taskData ── logger.info(f"[core_speaking] Step 4/7: taskData") prompt4 = build_speaking_prompt("step4_task_data", { "ID": str(cId), "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "角色配置": 角色配置, }) taskData, usage4 = llm_client.call_for_json("", prompt4, max_tokens=4096, temperature=0.1) logger.info(f" Step 4 完成: taskData keys={list(taskData.keys())}, tokens={usage4}") # ── Step 5: settingData ── logger.info(f"[core_speaking] Step 5/7: settingData") prompt5 = build_speaking_prompt("step5_setting_data", { "ID": str(cId), "对话配置": fields["对话配置"], }) settingData, usage5 = llm_client.call_for_json("", prompt5, max_tokens=2048, temperature=0.1) logger.info(f" Step 5 完成: settingData keys={list(settingData.keys())}, tokens={usage5}") # ── Step 6: configData ── logger.info(f"[core_speaking] Step 6/7: configData") prompt6 = build_speaking_prompt("step6_config_data", { "语音识别热词": 语音识别热词, "任务背景": fields["npc视角任务背景"], "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "角色驱动配置": promptInfo配置, "示例对话": fields["示例对话"], "通过规则": fields["通过规则"], }) configData, usage6 = llm_client.call_for_json("", prompt6, max_tokens=8192, temperature=0.1) logger.info(f" Step 6 完成: configData keys={list(configData.keys())}, tokens={usage6}") # ── Step 7: learningData ── logger.info(f"[core_speaking] Step 7/7: learningData") prompt7 = build_speaking_prompt("step7_learning_data", { "学习配置": 学习流程配置, }) learningData, usage7 = llm_client.call_for_json("", prompt7, max_tokens=8192, temperature=0.1) logger.info(f" Step 7 完成: learningData keys={list(learningData.keys())}, tokens={usage7}") # ── kpInfo (MySQL 匹配) ── kp_info = generate_kp_info(cType, cId, fields["用户任务知识"], llm_client=llm_client, level=level) logger.info(f"[core_speaking] 7步生成全部完成: cId={cId}") return { "taskInfo": taskData, "dialogSetting": settingData, "dialogConfig": configData, "studyInfo": learningData, "kpInfo": kp_info, "intermediate": { "学习流程配置": 学习流程配置, "promptInfo配置": promptInfo配置, "语音识别热词": 语音识别热词, }, } def parse_core_speaking_inquiry_fields(teaching_config): """ 从组件配置文本中提取 core_speaking_inquiry 所需的输入字段。 组件配置 = 教研-用户视角任务信息 + 教研-任务规则与NPC设定 拼接。 与口语快答相同的输入源，额外提取【知识库】section。 Returns: dict: 字段名 → 值 """ fields = parse_teaching_config_fields(teaching_config) desc_parts = [] if fields.get("任务标题"): desc_parts.append(f"【任务标题】\n{fields['任务标题']}") if fields.get("任务背景"): desc_parts.append(f"【任务背景】\n{fields['任务背景']}") if fields.get("任务描述"): desc_parts.append(f"【任务描述】\n{fields['任务描述']}") 用户任务描述 = "\n\n".join(desc_parts) if desc_parts else "" 用户任务知识 = fields.get("用户任务知识", "") or fields.get("通关知识", "") 示例对话 = fields.get("示例对话", "") 角色配置 = fields.get("角色配置", "") 专有词汇 = fields.get("专有词汇", "") or fields.get("专有名词", "") dialog_parts = [] if fields.get("对话角色"): dialog_parts.append(f"【对话角色】\n{fields['对话角色']}") if fields.get("回合设定"): dialog_parts.append(f"【回合设定】\n{fields['回合设定']}") 对话配置 = "\n\n".join(dialog_parts) if dialog_parts else "" npc任务设定 = fields.get("任务设定", "") or fields.get("npc任务设定", "") npc任务背景 = fields.get("npc视角任务背景", "") or fields.get("任务背景", "") 通过规则 = fields.get("通过规则", "") 知识库 = fields.get("知识库", "") return { "用户任务描述": 用户任务描述, "用户任务知识": 用户任务知识, "示例对话": 示例对话, "角色配置": 角色配置, "专有词汇": 专有词汇, "对话配置": 对话配置, "npc任务设定": npc任务设定, "npc视角任务背景": npc任务背景, "通过规则": 通过规则, "知识库": 知识库, } def generate_core_speaking_inquiry(cId, teaching_config, character_map=None, llm_client=None, level=None): """ 口语妙问（core_speaking_inquiry）7步 LLM 生成流水线。 Step 1: 学习流程配置 → 中间文本 Step 2: promptInfo配置 → 中间文本 Step 3: 语音识别热词 → 中间文本 Step 4: taskData → JSON Step 5: settingData → JSON Step 6: configData → JSON Step 7: learningData → JSON Returns: dict: { "taskData": dict, "settingData": dict, "configData": dict, "learningData": dict, "kpInfo": dict or None, "intermediate": {"学习流程配置": str, "promptInfo配置": str, "语音识别热词": str} } """ if llm_client is None: from llm_client import get_client llm_client = get_client() cType = "core_speaking_inquiry" fields = parse_core_speaking_inquiry_fields(teaching_config) 角色配置 = fields["角色配置"] if not 角色配置 and character_map: 角色配置 = "\n".join(f"{k}：{v}" for k, v in character_map.items()) logger.info(f"[core_speaking_inquiry] 开始7步生成: cId={cId}") # ── Step 1: 学习流程配置 ── logger.info(f"[core_speaking_inquiry] Step 1/7: 学习流程配置") prompt1 = build_speaking_inquiry_prompt("step1_learning_flow", { "用户任务描述": fields["用户任务描述"], "示例对话": fields["示例对话"], "专有词汇": fields["专有词汇"], }) 学习流程配置, usage1 = llm_client.call("", prompt1, max_tokens=8192, temperature=0.3) 学习流程配置 = 学习流程配置.strip() logger.info(f" Step 1 完成: {len(学习流程配置)} 字符, tokens={usage1}") # ── Step 2: promptInfo配置 ── logger.info(f"[core_speaking_inquiry] Step 2/7: promptInfo配置") prompt2 = build_speaking_inquiry_prompt("step2_prompt_info", { "用户任务描述": fields["用户任务描述"], "示例对话": fields["示例对话"], "npc视角任务背景": fields["npc视角任务背景"], "npc知识库": fields["知识库"], }) promptInfo配置, usage2 = llm_client.call("", prompt2, max_tokens=8192, temperature=0.3) promptInfo配置 = promptInfo配置.strip() logger.info(f" Step 2 完成: {len(promptInfo配置)} 字符, tokens={usage2}") # ── Step 3: 语音识别热词 ── logger.info(f"[core_speaking_inquiry] Step 3/7: 语音识别热词") prompt3 = build_speaking_inquiry_prompt("step3_asr_hotwords", { "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "示例对话": fields["示例对话"], }) 语音识别热词, usage3 = llm_client.call("", prompt3, max_tokens=1024, temperature=0.1) 语音识别热词 = 语音识别热词.strip() logger.info(f" Step 3 完成: {len(语音识别热词)} 字符, tokens={usage3}") # ── Step 4: taskData ── logger.info(f"[core_speaking_inquiry] Step 4/7: taskData") prompt4 = build_speaking_inquiry_prompt("step4_task_data", { "ID": str(cId), "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "角色配置": 角色配置, }) taskData, usage4 = llm_client.call_for_json("", prompt4, max_tokens=4096, temperature=0.1) logger.info(f" Step 4 完成: taskData keys={list(taskData.keys())}, tokens={usage4}") # ── Step 5: settingData ── logger.info(f"[core_speaking_inquiry] Step 5/7: settingData") prompt5 = build_speaking_inquiry_prompt("step5_setting_data", { "ID": str(cId), "对话配置": fields["对话配置"], }) settingData, usage5 = llm_client.call_for_json("", prompt5, max_tokens=2048, temperature=0.1) logger.info(f" Step 5 完成: settingData keys={list(settingData.keys())}, tokens={usage5}") # ── Step 6: configData ── logger.info(f"[core_speaking_inquiry] Step 6/7: configData") prompt6 = build_speaking_inquiry_prompt("step6_config_data", { "语音识别热词": 语音识别热词, "任务背景": fields["npc视角任务背景"], "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "角色驱动配置": promptInfo配置, "示例对话": fields["示例对话"], "通过规则": fields["通过规则"], }) configData, usage6 = llm_client.call_for_json("", prompt6, max_tokens=8192, temperature=0.1) logger.info(f" Step 6 完成: configData keys={list(configData.keys())}, tokens={usage6}") # ── Step 7: learningData ── logger.info(f"[core_speaking_inquiry] Step 7/7: learningData") prompt7 = build_speaking_inquiry_prompt("step7_learning_data", { "学习配置": 学习流程配置, }) learningData, usage7 = llm_client.call_for_json("", prompt7, max_tokens=8192, temperature=0.1) logger.info(f" Step 7 完成: learningData keys={list(learningData.keys())}, tokens={usage7}") # ── kpInfo (MySQL 匹配) ── kp_info = generate_kp_info(cType, cId, fields["用户任务知识"], llm_client=llm_client, level=level) logger.info(f"[core_speaking_inquiry] 7步生成全部完成: cId={cId}") return { "taskInfo": taskData, "dialogSetting": settingData, "dialogConfig": configData, "studyInfo": learningData, "kpInfo": kp_info, "intermediate": { "学习流程配置": 学习流程配置, "promptInfo配置": promptInfo配置, "语音识别热词": 语音识别热词, }, } def parse_core_speaking_image_fields(teaching_config): """ 从组件配置文本中提取 core_speaking_image 所需的输入字段。 组件配置 = 教研-导览配置 + 教研-对话配置 拼接。 Returns: dict: 字段名 → 值 """ fields = parse_teaching_config_fields(teaching_config) desc_parts = [] if fields.get("任务标题"): desc_parts.append(f"【任务标题】\n{fields['任务标题']}") if fields.get("任务背景"): desc_parts.append(f"【任务背景】\n{fields['任务背景']}") if fields.get("任务描述"): desc_parts.append(f"【任务描述】\n{fields['任务描述']}") 用户任务描述 = "\n\n".join(desc_parts) if desc_parts else "" 用户任务知识 = fields.get("知识", "") or fields.get("用户任务知识", "") or fields.get("通关知识", "") # 对话信息 = 对话角色 + 角色背景 dialog_info_parts = [] if fields.get("对话角色"): dialog_info_parts.append(fields["对话角色"]) if fields.get("角色背景"): dialog_info_parts.append(fields["角色背景"]) 对话信息 = "\n".join(dialog_info_parts) if dialog_info_parts else "" 互动问题 = fields.get("互动问题", "") 通过规则 = fields.get("通过规则", "") 示例对话 = fields.get("示例对话", "") 角色配置 = fields.get("角色配置", "") 专有词汇 = fields.get("专有词汇", "") or fields.get("专有名词", "") return { "用户任务描述": 用户任务描述, "用户任务知识": 用户任务知识, "对话信息": 对话信息, "互动问题": 互动问题, "通过规则": 通过规则, "示例对话": 示例对话, "角色配置": 角色配置, "专有词汇": 专有词汇, } def generate_core_speaking_image(cId, teaching_config, character_map=None, llm_client=None, level=None): """ 看图说话（core_speaking_image）8步 LLM 生成流水线。 Step 1: 学习流程配置 → 中间文本 Step 2: 语音识别热词 → 中间文本 Step 3: taskData → JSON Step 4: imageInfo → JSON Step 5: optionList → JSON Step 6: questionList → JSON Step 7: configData → JSON (depends on questionList) Step 8: learningData → JSON (depends on 学习流程配置) Returns: dict: { "taskData": dict, "configData": dict, "imageInfo": dict, "optionList": list, "questionList": list, "learningData": dict, "kpInfo": dict or None, "intermediate": {"学习流程配置": str, "语音识别热词": str} } """ if llm_client is None: from llm_client import get_client llm_client = get_client() cType = "core_speaking_image" fields = parse_core_speaking_image_fields(teaching_config) 角色配置 = fields["角色配置"] if not 角色配置 and character_map: 角色配置 = "\n".join(f"{k}：{v}" for k, v in character_map.items()) logger.info(f"[core_speaking_image] 开始8步生成: cId={cId}") # ── Step 1: 学习流程配置 ── logger.info(f"[core_speaking_image] Step 1/8: 学习流程配置") prompt1 = build_speaking_image_prompt("step1_learning_flow", { "用户任务描述": fields["用户任务描述"], "示例对话": fields["示例对话"], "专有词汇": fields["专有词汇"], "对话信息": fields["对话信息"], }) 学习流程配置, usage1 = llm_client.call("", prompt1, max_tokens=8192, temperature=0.3) 学习流程配置 = 学习流程配置.strip() logger.info(f" Step 1 完成: {len(学习流程配置)} 字符, tokens={usage1}") # ── Step 2: 语音识别热词 ── logger.info(f"[core_speaking_image] Step 2/8: 语音识别热词") prompt2 = build_speaking_image_prompt("step2_asr_hotwords", { "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "示例对话": fields["示例对话"], }) 语音识别热词, usage2 = llm_client.call("", prompt2, max_tokens=1024, temperature=0.1) 语音识别热词 = 语音识别热词.strip() logger.info(f" Step 2 完成: {len(语音识别热词)} 字符, tokens={usage2}") # ── Step 3: taskData ── # 互动描述 = 示例对话内容的英文部分 互动描述 = fields["示例对话"] logger.info(f"[core_speaking_image] Step 3/8: taskData") prompt3 = build_speaking_image_prompt("step3_task_data", { "ID": str(cId), "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "角色配置": 角色配置, "互动描述": 互动描述, }) taskData, usage3 = llm_client.call_for_json("", prompt3, max_tokens=4096, temperature=0.1) logger.info(f" Step 3 完成: taskData keys={list(taskData.keys())}, tokens={usage3}") # ── Step 4: imageInfo ── logger.info(f"[core_speaking_image] Step 4/8: imageInfo") prompt4 = build_speaking_image_prompt("step4_image_info", { "ID": str(cId), }) imageInfo, usage4 = llm_client.call_for_json("", prompt4, max_tokens=512, temperature=0.0) logger.info(f" Step 4 完成: imageInfo keys={list(imageInfo.keys()) if isinstance(imageInfo, dict) else 'N/A'}, tokens={usage4}") # ── Step 5: optionList ── logger.info(f"[core_speaking_image] Step 5/8: optionList") prompt5 = build_speaking_image_prompt("step5_option_list", { "ID": str(cId), "互动问题": fields["互动问题"], }) optionList, usage5 = llm_client.call_for_json("", prompt5, max_tokens=2048, temperature=0.1) logger.info(f" Step 5 完成: optionList items={len(optionList) if isinstance(optionList, list) else 'N/A'}, tokens={usage5}") # ── Step 6: questionList ── logger.info(f"[core_speaking_image] Step 6/8: questionList") prompt6 = build_speaking_image_prompt("step6_question_list", { "ID": str(cId), "互动问题": fields["互动问题"], "对话信息": fields["对话信息"], }) questionList, usage6 = llm_client.call_for_json("", prompt6, max_tokens=4096, temperature=0.1) logger.info(f" Step 6 完成: questionList items={len(questionList) if isinstance(questionList, list) else 'N/A'}, tokens={usage6}") # ── Step 7: configData (depends on questionList) ── logger.info(f"[core_speaking_image] Step 7/8: configData") questionList_str = json.dumps(questionList, ensure_ascii=False) if questionList else "[]" prompt7 = build_speaking_image_prompt("step7_config_data", { "语音识别热词": 语音识别热词, "用户任务描述": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "示例对话": fields["示例对话"], "通过规则": fields["通过规则"], "questionList": questionList_str, }) configData, usage7 = llm_client.call_for_json("", prompt7, max_tokens=8192, temperature=0.1) logger.info(f" Step 7 完成: configData keys={list(configData.keys())}, tokens={usage7}") # ── Step 8: learningData (depends on 学习流程配置) ── logger.info(f"[core_speaking_image] Step 8/8: learningData") prompt8 = build_speaking_image_prompt("step8_learning_data", { "学习配置": 学习流程配置, "互动问题": fields["互动问题"], }) learningData, usage8 = llm_client.call_for_json("", prompt8, max_tokens=8192, temperature=0.1) logger.info(f" Step 8 完成: learningData keys={list(learningData.keys()) if isinstance(learningData, dict) else 'list'}, tokens={usage8}") # ── kpInfo (MySQL 匹配) ── kp_info = generate_kp_info(cType, cId, fields["用户任务知识"], llm_client=llm_client, level=level) logger.info(f"[core_speaking_image] 8步生成全部完成: cId={cId}") return { "taskInfo": taskData, "dialogConfig": configData, "imageInfo": imageInfo, "optionList": optionList, "questionList": questionList, "studyInfo": learningData, "kpInfo": kp_info, "intermediate": { "学习流程配置": 学习流程配置, "语音识别热词": 语音识别热词, }, } # ============ 合作听力 (core_listening_order) ============ def parse_core_listening_order_fields(teaching_config): """ 从组件配置文本中提取 core_listening_order 所需的输入字段。 组件配置 = 教研配置-任务 + 教研配置-材料 拼接，包含 【xxx】 sections。 Returns: dict: 字段名 → 值 """ fields = parse_teaching_config_fields(teaching_config) # 任务配置 = 任务标题 + 任务背景 task_parts = [] if fields.get("任务标题"): task_parts.append(f"【任务标题】\n{fields['任务标题']}") if fields.get("任务背景"): task_parts.append(f"【任务背景】\n{fields['任务背景']}") 任务配置 = "\n\n".join(task_parts) if task_parts else "" # 任务名称 (for 互动描述 prompt) 任务名称 = fields.get("任务标题", "") # 通关知识 通关知识 = fields.get("通关知识", "") # 听力材料 听力材料 = fields.get("听力材料", "") or fields.get("阅读材料", "") or fields.get("材料配置", "") # 学习流程 学习流程 = fields.get("学习流程", "") or fields.get("学习过程", "") or fields.get("学习材料", "") # 互动题目 / 题目部分 互动题目 = fields.get("互动题目", "") or fields.get("题目部分", "") or fields.get("题目配置", "") # 流程编排 流程编排 = fields.get("流程编排", "") # 角色配置 角色配置 = fields.get("角色配置", "") # 专有词汇 (暂不实现，保留占位) 专有词汇 = fields.get("专有词汇", "") or fields.get("专有名词", "") return { "任务配置": 任务配置, "任务名称": 任务名称, "通关知识": 通关知识, "听力材料": 听力材料, "学习流程": 学习流程, "互动题目": 互动题目, "流程编排": 流程编排, "角色配置": 角色配置, "专有词汇": 专有词汇, } def generate_core_listening_order(cId, teaching_config, character_map=None, llm_client=None, level=None): """ 合作听力（core_listening_order）6步 LLM 生成流水线。 Step 1: 学习过程配置 → 中间文本 Step 2: 互动描述 → 中间文本 Step 3: taskData → JSON Step 4: textData → JSON Step 5: sequenceData → JSON Step 6: learningData → JSON Returns: dict: { "taskData": dict, "textData": dict, "sequenceData": dict, "learningData": dict, "kpInfo": dict or None, "intermediate": {"学习过程配置": str, "互动描述": str} } """ if llm_client is None: from llm_client import get_client llm_client = get_client() cType = "core_listening_order" # 解析输入字段 fields = parse_core_listening_order_fields(teaching_config) # 角色配置：优先使用组件配置中的，回退到 character_map 角色配置 = fields["角色配置"] if not 角色配置 and character_map: 角色配置 = "\n".join(f"{k}：{v}" for k, v in character_map.items()) logger.info(f"[core_listening_order] 开始6步生成: cId={cId}") # ── Step 1: 学习过程配置 ── logger.info(f"[core_listening_order] Step 1/6: 学习过程配置") prompt1 = build_listening_order_prompt("step1_learning_process", { "听力材料": fields["听力材料"], "学习流程": fields["学习流程"], "专有词汇": fields["专有词汇"], }) 学习过程配置, usage1 = llm_client.call("", prompt1, max_tokens=8192, temperature=0.3) 学习过程配置 = 学习过程配置.strip() logger.info(f" Step 1 完成: {len(学习过程配置)} 字符, tokens={usage1}") # ── Step 2: 互动描述 ── logger.info(f"[core_listening_order] Step 2/6: 互动描述") prompt2 = build_listening_order_prompt("step2_interaction_desc", { "任务名称": fields["任务名称"], "听力材料": fields["听力材料"], "互动题目": fields["互动题目"], }) 互动描述, usage2 = llm_client.call("", prompt2, max_tokens=4096, temperature=0.3) 互动描述 = 互动描述.strip() logger.info(f" Step 2 完成: {len(互动描述)} 字符, tokens={usage2}") # ── Step 3: taskData ── logger.info(f"[core_listening_order] Step 3/6: taskData") prompt3 = build_listening_order_prompt("step3_task_data", { "ID": str(cId), "用户任务配置": fields["任务配置"], "用户任务知识": fields["通关知识"], "角色配置": 角色配置, }) taskData, usage3 = llm_client.call_for_json("", prompt3, max_tokens=4096, temperature=0.1) logger.info(f" Step 3 完成: taskData keys={list(taskData.keys())}, tokens={usage3}") # ── Step 4: textData ── logger.info(f"[core_listening_order] Step 4/6: textData") prompt4 = build_listening_order_prompt("step4_text_data", { "ID": str(cId), "听力材料": fields["听力材料"], "题目配置": fields["互动题目"], "角色配置": 角色配置, }) textData, usage4 = llm_client.call_for_json("", prompt4, max_tokens=8192, temperature=0.1) logger.info(f" Step 4 完成: textData keys={list(textData.keys())}, tokens={usage4}") # ── Step 5: sequenceData ── logger.info(f"[core_listening_order] Step 5/6: sequenceData") prompt5 = build_listening_order_prompt("step5_sequence_data", { "ID": str(cId), "流程编排": fields["流程编排"], "角色配置": 角色配置, }) sequenceData, usage5 = llm_client.call_for_json("", prompt5, max_tokens=8192, temperature=0.1) logger.info(f" Step 5 完成: sequenceData keys={list(sequenceData.keys())}, tokens={usage5}") # ── Step 6: learningData ── logger.info(f"[core_listening_order] Step 6/6: learningData") prompt6 = build_listening_order_prompt("step6_learning_data", { "学习配置": 学习过程配置, }) learningData, usage6 = llm_client.call_for_json("", prompt6, max_tokens=16384, temperature=0.1) logger.info(f" Step 6 完成: learningData keys={list(learningData.keys())}, tokens={usage6}") # kpInfo kp_info = None if fields["通关知识"]: try: kp_info = generate_kp_info(cType, cId, fields["通关知识"], llm_client, level=level) except Exception as e: logger.warning(f"kpInfo 生成失败: {e}") logger.info(f"[core_listening_order] 6步生成完成: cId={cId}") return { "taskInfo": taskData, "materialInfo": textData, "flowInfo": sequenceData, "studyInfo": learningData, "kpInfo": kp_info, "intermediate": { "学习过程配置": 学习过程配置, "互动描述": 互动描述, }, } # ============ 听力拖拽 (core_listening_drag) ============ def parse_core_listening_drag_fields(teaching_config): """ 从组件配置文本中提取 core_listening_drag 所需的输入字段。 组件配置 = 教研-导览配置 + 教研-互动配置 拼接，包含 【xxx】 sections。 Returns: dict: 字段名 → 值 """ fields = parse_teaching_config_fields(teaching_config) # 用户任务描述 = 任务标题 + 任务背景 desc_parts = [] if fields.get("任务标题"): desc_parts.append(f"【任务标题】\n{fields['任务标题']}") if fields.get("任务背景"): desc_parts.append(f"【任务背景】\n{fields['任务背景']}") 用户任务描述 = "\n\n".join(desc_parts) if desc_parts else "" # 任务名称 任务名称 = fields.get("任务标题", "") # 用户任务知识 用户任务知识 = fields.get("用户任务知识", "") or fields.get("通关知识", "") # 听力材料（配置中可能写作【听力文本】或【听力材料】） 听力材料 = fields.get("听力材料", "") or fields.get("听力文本", "") or fields.get("互动配置", "") or fields.get("阅读材料", "") # 学习流程（配置中可能写作【学习过程】或【学习流程】） 学习流程 = fields.get("学习流程", "") or fields.get("学习过程", "") # 关联知识 关联知识 = fields.get("关联知识", "") # 题目（配置中可能写作【题目信息】或【题目】） 题目 = fields.get("题目", "") or fields.get("题目信息", "") or fields.get("互动题目", "") or fields.get("题目部分", "") # 题目材料 (for 互动描述) 题目材料 = fields.get("题目材料", "") or 题目 # 开场语 开场语 = fields.get("开场语", "") # 角色配置 角色配置 = fields.get("角色配置", "") # 专有词汇 专有词汇 = fields.get("专有词汇", "") or fields.get("专有名词", "") return { "用户任务描述": 用户任务描述, "任务名称": 任务名称, "用户任务知识": 用户任务知识, "听力材料": 听力材料, "学习流程": 学习流程, "关联知识": 关联知识, "题目": 题目, "题目材料": 题目材料, "开场语": 开场语, "角色配置": 角色配置, "专有词汇": 专有词汇, } def generate_core_listening_drag(cId, teaching_config, character_map=None, llm_client=None, level=None): """ 听力拖拽（core_listening_drag）7步 LLM 生成流水线。 Step 1: 学习过程配置 → 中间文本 Step 2: 互动描述 → 中间文本 Step 3: taskData → JSON Step 4: preDialog → JSON Step 5: dialogList → JSON Step 6: questionList → JSON Step 7: learningData → JSON Returns: dict: { "taskData": dict, "preDialogData": list, "dialogListData": list, "questionListData": list, "learningData": dict, "kpInfo": dict or None, "intermediate": {"学习过程配置": str, "互动描述": str} } """ if llm_client is None: from llm_client import get_client llm_client = get_client() cType = "core_listening_drag" # 解析输入字段 fields = parse_core_listening_drag_fields(teaching_config) # 角色配置：优先使用组件配置中的，回退到 character_map 角色配置 = fields["角色配置"] if not 角色配置 and character_map: 角色配置 = "\n".join(f"{k}：{v}" for k, v in character_map.items()) logger.info(f"[core_listening_drag] 开始7步生成: cId={cId}") # ── Step 1: 学习过程配置 ── logger.info(f"[core_listening_drag] Step 1/7: 学习过程配置") prompt1 = build_listening_drag_prompt("step1_learning_process", { "听力材料": fields["听力材料"], "学习流程": fields["学习流程"], "专有词汇": fields["专有词汇"], "关联知识": fields["关联知识"], }) 学习过程配置, usage1 = llm_client.call("", prompt1, max_tokens=8192, temperature=0.3) 学习过程配置 = 学习过程配置.strip() logger.info(f" Step 1 完成: {len(学习过程配置)} 字符, tokens={usage1}") # ── Step 2: 互动描述 ── logger.info(f"[core_listening_drag] Step 2/7: 互动描述") prompt2 = build_listening_drag_prompt("step2_interaction_desc", { "任务名称": fields["任务名称"], "题目材料": fields["题目材料"], }) 互动描述, usage2 = llm_client.call("", prompt2, max_tokens=4096, temperature=0.3) 互动描述 = 互动描述.strip() logger.info(f" Step 2 完成: {len(互动描述)} 字符, tokens={usage2}") # ── Step 3: taskData ── logger.info(f"[core_listening_drag] Step 3/7: taskData") prompt3 = build_listening_drag_prompt("step3_task_data", { "ID": str(cId), "用户任务配置": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "角色配置": 角色配置, "互动描述": 互动描述, }) taskData, usage3 = llm_client.call_for_json("", prompt3, max_tokens=4096, temperature=0.1) logger.info(f" Step 3 完成: taskData keys={list(taskData.keys())}, tokens={usage3}") # ── Step 4: preDialog ── logger.info(f"[core_listening_drag] Step 4/7: preDialog") prompt4 = build_listening_drag_prompt("step4_pre_dialog", { "开场语": fields["开场语"], }) preDialogData, usage4 = llm_client.call_for_json("", prompt4, max_tokens=4096, temperature=0.1) logger.info(f" Step 4 完成: preDialogData type={type(preDialogData).__name__}, tokens={usage4}") # ── Step 5: dialogList ── logger.info(f"[core_listening_drag] Step 5/7: dialogList") prompt5 = build_listening_drag_prompt("step5_dialog_list", { "听力材料": fields["听力材料"], }) dialogListData, usage5 = llm_client.call_for_json("", prompt5, max_tokens=8192, temperature=0.1) logger.info(f" Step 5 完成: dialogListData type={type(dialogListData).__name__}, tokens={usage5}") # ── Step 6: questionList ── logger.info(f"[core_listening_drag] Step 6/7: questionList") prompt6 = build_listening_drag_prompt("step6_question_list", { "ID": str(cId), "题目": fields["题目"], }) questionListData, usage6 = llm_client.call_for_json("", prompt6, max_tokens=8192, temperature=0.1) logger.info(f" Step 6 完成: questionListData type={type(questionListData).__name__}, tokens={usage6}") # ── Step 7: learningData ── logger.info(f"[core_listening_drag] Step 7/7: learningData") prompt7 = build_listening_drag_prompt("step7_learning_data", { "学习配置": 学习过程配置, }) learningData, usage7 = llm_client.call_for_json("", prompt7, max_tokens=16384, temperature=0.1) logger.info(f" Step 7 完成: learningData keys={list(learningData.keys()) if isinstance(learningData, dict) else 'list'}, tokens={usage7}") # kpInfo kp_info = None if fields["用户任务知识"]: try: kp_info = generate_kp_info(cType, cId, fields["用户任务知识"], llm_client, level=level) except Exception as e: logger.warning(f"kpInfo 生成失败: {e}") logger.info(f"[core_listening_drag] 7步生成完成: cId={cId}") return { "taskInfo": taskData, "preDialog": preDialogData, "dialogList": dialogListData, "questionList": questionListData, "studyInfo": learningData, "kpInfo": kp_info, "intermediate": { "学习过程配置": 学习过程配置, "互动描述": 互动描述, }, } # ============ 听力选择 (core_listening_choose) ============ def parse_core_listening_choose_fields(teaching_config): """ 从组件配置文本中提取 core_listening_choose 所需的输入字段。 组件配置 = 教研-导览配置 + 教研-互动配置 拼接，包含 【xxx】 sections。 注意：听力选择的题目可能以【题目组1】【题目组2】...形式出现。 Returns: dict: 字段名 → 值 """ fields = parse_teaching_config_fields(teaching_config) # 用户任务描述 = 任务标题 + 任务背景 desc_parts = [] if fields.get("任务标题"): desc_parts.append(f"【任务标题】\n{fields['任务标题']}") if fields.get("任务背景"): desc_parts.append(f"【任务背景】\n{fields['任务背景']}") 用户任务描述 = "\n\n".join(desc_parts) if desc_parts else "" # 任务名称 任务名称 = fields.get("任务标题", "") # 用户任务知识 用户任务知识 = fields.get("用户任务知识", "") or fields.get("通关知识", "") # 听力材料（配置中可能写作【听力文本】或【听力材料】） 听力材料 = fields.get("听力材料", "") or fields.get("听力文本", "") or fields.get("互动配置", "") or fields.get("阅读材料", "") # 学习流程（配置中可能写作【学习过程】或【学习流程】） 学习流程 = fields.get("学习流程", "") or fields.get("学习过程", "") # 题目：支持【题目组1】【题目组2】...格式，合并所有题目组 题目 = fields.get("题目", "") or fields.get("互动题目", "") or fields.get("题目部分", "") if not 题目: # 查找所有 题目组N 字段并按序合并 题目组_parts = [] for key in sorted(fields.keys()): if key.startswith("题目组"): 题目组_parts.append(f"【{key}】\n{fields[key]}") if 题目组_parts: 题目 = "\n".join(题目组_parts) # 听力材料为空时，fallback 到题目组内容（听力选择的听力文本嵌在题目组中） if not 听力材料 and 题目: 听力材料 = 题目 # 题目材料 (for 互动描述) 题目材料 = fields.get("题目材料", "") or 题目 # 角色配置 角色配置 = fields.get("角色配置", "") # 专有词汇 专有词汇 = fields.get("专有词汇", "") or fields.get("专有名词", "") return { "用户任务描述": 用户任务描述, "任务名称": 任务名称, "用户任务知识": 用户任务知识, "听力材料": 听力材料, "学习流程": 学习流程, "题目": 题目, "题目材料": 题目材料, "角色配置": 角色配置, "专有词汇": 专有词汇, } def generate_core_listening_choose(cId, teaching_config, character_map=None, llm_client=None, level=None): """ 听力选择（core_listening_choose）5步 LLM 生成流水线。 Step 1: 学习过程配置 → 中间文本 Step 2: 互动描述 → 中间文本 Step 3: taskData → JSON Step 4: questionGroup → JSON Step 5: learningData → JSON Returns: dict: { "taskData": dict, "questionGroupData": list/dict, "learningData": dict, "kpInfo": dict or None, "intermediate": {"学习过程配置": str, "互动描述": str} } """ if llm_client is None: from llm_client import get_client llm_client = get_client() cType = "core_listening_choose" # 解析输入字段 fields = parse_core_listening_choose_fields(teaching_config) # 角色配置：优先使用组件配置中的，回退到 character_map 角色配置 = fields["角色配置"] if not 角色配置 and character_map: 角色配置 = "\n".join(f"{k}：{v}" for k, v in character_map.items()) logger.info(f"[core_listening_choose] 开始5步生成: cId={cId}") # ── Step 1: 学习过程配置 ── logger.info(f"[core_listening_choose] Step 1/5: 学习过程配置") prompt1 = build_listening_choose_prompt("step1_learning_process", { "听力材料": fields["听力材料"], "学习流程": fields["学习流程"], "专有词汇": fields["专有词汇"], }) 学习过程配置, usage1 = llm_client.call("", prompt1, max_tokens=8192, temperature=0.3) 学习过程配置 = 学习过程配置.strip() logger.info(f" Step 1 完成: {len(学习过程配置)} 字符, tokens={usage1}") # ── Step 2: 互动描述 ── logger.info(f"[core_listening_choose] Step 2/5: 互动描述") prompt2 = build_listening_choose_prompt("step2_interaction_desc", { "任务名称": fields["任务名称"], "题目材料": fields["题目材料"], }) 互动描述, usage2 = llm_client.call("", prompt2, max_tokens=4096, temperature=0.3) 互动描述 = 互动描述.strip() logger.info(f" Step 2 完成: {len(互动描述)} 字符, tokens={usage2}") # ── Step 3: taskData ── logger.info(f"[core_listening_choose] Step 3/5: taskData") prompt3 = build_listening_choose_prompt("step3_task_data", { "ID": str(cId), "用户任务配置": fields["用户任务描述"], "用户任务知识": fields["用户任务知识"], "角色配置": 角色配置, "互动描述": 互动描述, }) taskData, usage3 = llm_client.call_for_json("", prompt3, max_tokens=4096, temperature=0.1) logger.info(f" Step 3 完成: taskData keys={list(taskData.keys())}, tokens={usage3}") # ── Step 4: questionGroup ── logger.info(f"[core_listening_choose] Step 4/5: questionGroup") prompt4 = build_listening_choose_prompt("step4_question_group", { "ID": str(cId), "题目": fields["题目"], }) questionGroupData, usage4 = llm_client.call_for_json("", prompt4, max_tokens=8192, temperature=0.1) logger.info(f" Step 4 完成: questionGroupData type={type(questionGroupData).__name__}, tokens={usage4}") # ── Step 5: learningData ── logger.info(f"[core_listening_choose] Step 5/5: learningData") prompt5 = build_listening_choose_prompt("step5_learning_data", { "学习配置": 学习过程配置, }) learningData, usage5 = llm_client.call_for_json("", prompt5, max_tokens=16384, temperature=0.1) logger.info(f" Step 5 完成: learningData keys={list(learningData.keys()) if isinstance(learningData, dict) else 'list'}, tokens={usage5}") # kpInfo kp_info = None if fields["用户任务知识"]: try: kp_info = generate_kp_info(cType, cId, fields["用户任务知识"], llm_client, level=level) except Exception as e: logger.warning(f"kpInfo 生成失败: {e}") logger.info(f"[core_listening_choose] 5步生成完成: cId={cId}") return { "taskInfo": taskData, "questionGroup": questionGroupData, "studyInfo": learningData, "kpInfo": kp_info, "intermediate": { "学习过程配置": 学习过程配置, "互动描述": 互动描述, }, } # ============ 写作类核心互动（4种） ============ def parse_core_writing_fields(teaching_config): """ 从组件配置文本中提取写作类核心互动所需的输入字段。 组件配置 = 教研配置-任务信息 + 教研配置-全文信息 拼接，包含 【xxx】 sections。 Returns: dict: 字段名 → 值 """ fields = parse_teaching_config_fields(teaching_config) 任务名称 = fields.get("任务名称", "") 任务背景 = fields.get("任务背景", "") 任务描述 = fields.get("任务描述", "") 剧情提要 = fields.get("剧情提要", "") 知识 = fields.get("知识", "") # 学习内容：可能写作【学习内容】【学习流程】【学习过程】，也可能用【知识】代替 学习内容 = fields.get("学习内容", "") or fields.get("学习流程", "") or fields.get("学习过程", "") or 知识 写作材料 = fields.get("写作材料", "") 通过规则 = fields.get("通过规则", "") 题目类型 = fields.get("题目类型", "") or fields.get("题干类型", "") # 题干描述 may be in teaching_config as 【题干描述】 or inside 题目类型 题干描述 = fields.get("题干描述", "") # 写作类型 写作类型 = fields.get("写作类型", "") # 构建任务信息 (用于 taskInfo prompt) 任务信息_parts = [] if 任务名称: 任务信息_parts.append(f"【任务名称】\n{任务名称}") if 任务背景: 任务信息_parts.append(f"【任务背景】\n{任务背景}") if 任务描述: 任务信息_parts.append(f"【任务描述】\n{任务描述}") if 剧情提要: 任务信息_parts.append(f"【剧情提要】\n{剧情提要}") if 知识: 任务信息_parts.append(f"【知识】\n{知识}") 任务信息 = "\n\n".join(任务信息_parts) # 重建题目类型文本 题目类型_text = "" if 题目类型 or 题干描述 or 写作类型: parts = [] if 题目类型: parts.append(f"【题干类型】\n{题目类型}") if 题干描述: parts.append(f"【题干描述】\n{题干描述}") if 写作类型: parts.append(f"【写作类型】\n{写作类型}") 题目类型_text = "\n".join(parts) return { "任务名称": 任务名称, "任务背景": 任务背景, "任务描述": 任务描述, "剧情提要": 剧情提要, "知识": 知识, "学习内容": 学习内容, "写作材料": 写作材料, "通过规则": 通过规则, "题目类型": 题目类型_text, "写作类型": 写作类型, "任务信息": 任务信息, } def _generate_core_writing(cId, cType, teaching_config, character_map=None, llm_client=None, level=None): """ 写作类核心互动通用6步 LLM 生成流水线。 Step 1: 学习流程配置 → 中间文本 Step 2: 互动描述 → 中间文本 Step 3: taskInfo → JSON Step 4: textInfo → JSON Step 5: studyInfo → JSON Step 6: evalInfo → JSON Returns: dict: { "taskInfo": dict, "textInfo": dict, "studyInfo": dict, "evalInfo": dict, "kpInfo": dict or None, "intermediate": {"学习流程配置": str, "互动描述": str} } """ if llm_client is None: from llm_client import get_client llm_client = get_client() fields = parse_core_writing_fields(teaching_config) # 选择 prompt builder is_img_type = cType in ("core_writing_imgMakeSentence", "core_writing_imgWrite") if is_img_type: build_prompt = lambda step, repl: build_writing_img_prompt(cType, step, repl) else: build_prompt = lambda step, repl: build_writing_question_prompt(cType, step, repl) log_prefix = f"[{cType}]" logger.info(f"{log_prefix} 开始6步生成: cId={cId}") # ── Step 1: 学习流程配置 ── logger.info(f"{log_prefix} Step 1/6: 学习流程配置") prompt1 = build_prompt("step1_learning_flow", { "任务背景": fields["任务背景"], "任务描述": fields["任务描述"], "写作材料": fields["写作材料"], "学习内容": fields["学习内容"], }) 学习流程配置, usage1 = llm_client.call("", prompt1, max_tokens=8192, temperature=0.3) 学习流程配置 = 学习流程配置.strip() logger.info(f" Step 1 完成: {len(学习流程配置)} 字符, tokens={usage1}") # ── Step 2: 互动描述 ── logger.info(f"{log_prefix} Step 2/6: 互动描述") prompt2 = build_prompt("step2_interaction_desc", { "任务背景": fields["任务背景"], "写作材料": fields["写作材料"], }) 互动描述, usage2 = llm_client.call("", prompt2, max_tokens=4096, temperature=0.3) 互动描述 = 互动描述.strip() logger.info(f" Step 2 完成: {len(互动描述)} 字符, tokens={usage2}") # ── Step 3: taskInfo ── logger.info(f"{log_prefix} Step 3/6: taskInfo") prompt3 = build_prompt("step3_task_info", { "ID": str(cId), "题目类型": fields["题目类型"], "任务信息": fields["任务信息"], "知识": fields["知识"], "写作材料": fields["写作材料"], "互动描述": 互动描述, }) taskInfo, usage3 = llm_client.call_for_json("", prompt3, max_tokens=4096, temperature=0.1) logger.info(f" Step 3 完成: taskInfo keys={list(taskInfo.keys())}, tokens={usage3}") # ── Step 4: textInfo ── logger.info(f"{log_prefix} Step 4/6: textInfo") prompt4 = build_prompt("step4_text_info", { "通过规则": fields["通过规则"], "写作材料": fields["写作材料"], }) textInfo, usage4 = llm_client.call_for_json("", prompt4, max_tokens=4096, temperature=0.1) logger.info(f" Step 4 完成: textInfo keys={list(textInfo.keys())}, tokens={usage4}") # ── Step 5: studyInfo ── logger.info(f"{log_prefix} Step 5/6: studyInfo") taskInfo_str = json.dumps(taskInfo, ensure_ascii=False) prompt5 = build_prompt("step5_study_info", { "taskInfo": taskInfo_str, "学习流程配置": 学习流程配置, "学习内容": fields["学习内容"], }) studyInfo, usage5 = llm_client.call_for_json("", prompt5, max_tokens=16384, temperature=0.1) logger.info(f" Step 5 完成: studyInfo keys={list(studyInfo.keys()) if isinstance(studyInfo, dict) else 'list'}, tokens={usage5}") # ── Step 6: evalInfo ── logger.info(f"{log_prefix} Step 6/6: evalInfo") textInfo_str = json.dumps(textInfo, ensure_ascii=False) prompt6 = build_prompt("step6_eval_info", { "taskInfo": taskInfo_str, "任务信息": fields["任务信息"], "textInfo": textInfo_str, }) evalInfo, usage6 = llm_client.call_for_json("", prompt6, max_tokens=4096, temperature=0.1) logger.info(f" Step 6 完成: evalInfo keys={list(evalInfo.keys())}, tokens={usage6}") # kpInfo kp_info = None if fields["知识"]: try: kp_info = generate_kp_info(cType, cId, fields["知识"], llm_client, level=level) except Exception as e: logger.warning(f"kpInfo 生成失败: {e}") logger.info(f"{log_prefix} 6步生成完成: cId={cId}") return { "taskInfo": taskInfo, "textInfo": textInfo, "studyInfo": studyInfo, "evalInfo": evalInfo, "kpInfo": kp_info, "intermediate": { "学习流程配置": 学习流程配置, "互动描述": 互动描述, }, } def generate_core_writing_img_make_sentence(cId, teaching_config, character_map=None, llm_client=None, level=None): """看图组句（core_writing_imgMakeSentence）6步 LLM 生成流水线。""" return _generate_core_writing(cId, "core_writing_imgMakeSentence", teaching_config, character_map, llm_client, level=level) def generate_core_writing_img_write(cId, teaching_config, character_map=None, llm_client=None, level=None): """看图撰写（core_writing_imgWrite）6步 LLM 生成流水线。""" return _generate_core_writing(cId, "core_writing_imgWrite", teaching_config, character_map, llm_client, level=level) def generate_core_writing_question_make_sentence(cId, teaching_config, character_map=None, llm_client=None, level=None): """邮件组句（core_writing_questionMakeSentence）6步 LLM 生成流水线。""" return _generate_core_writing(cId, "core_writing_questionMakeSentence", teaching_config, character_map, llm_client, level=level) def generate_core_writing_question_write(cId, teaching_config, character_map=None, llm_client=None, level=None): """邮件撰写（core_writing_questionWrite）6步 LLM 生成流水线。""" return _generate_core_writing(cId, "core_writing_questionWrite", teaching_config, character_map, llm_client, level=level) def generate_component(component, character_map=None, section_char_map=None, llm_client=None, level=None): """ 一站式生成单个组件的 jsonData + kpInfo Args: component: parse_sheet_rows 返回的组件 dict character_map: 全局角色映射（回退用） section_char_map: 角色-section对应表（优先用） llm_client: LLMClient 实例 level: 剧本级别（如 "L1", "L2"），用于知识点匹配 Returns: dict: {"jsonData": {...}, "kpInfo": {...} or None, "cType": str} 对核心互动类型返回额外字段: taskData, textData, sequenceData, learningData """ from match_component import match_component_type from parse_script import resolve_resource_mapping # 类型匹配 type_info = match_component_type(component["type_name"]) cType = type_info["cType"] cId = component["cId"] has_image = component.get("has_image", False) or type_info.get("has_image", False) # 解析角色配置：优先通过 section-character 映射 resolved_char_map = character_map or {} config_info = component.get("config_info", "") if section_char_map and config_info: resolved_char_map = resolve_resource_mapping( section_char_map, config_info, character_map ) # ── 核心互动类型：多步 LLM 生成 ── if cType in CORE_TYPES: _core_call_args = dict( cId=cId, teaching_config=component["teaching_config"], character_map=resolved_char_map, llm_client=llm_client, level=level, ) _core_base = { "cType": cType, "type_name": component["type_name"], "cId": cId, "has_image": has_image, "category": "core", "bitable": type_info.get("bitable") or type_info.get("bitable_wiki"), "db_table": type_info.get("db_table"), } if cType == "core_reading_order": result = generate_core_reading_order(**_core_call_args) return { **_core_base, "jsonData": result["taskInfo"], "taskInfo": result["taskInfo"], "materialInfo": result["materialInfo"], "flowInfo": result["flowInfo"], "studyInfo": result["studyInfo"], "kpInfo": result["kpInfo"], "intermediate": result["intermediate"], } elif cType == "core_reading_imageDrag": result = generate_core_reading_imagedrag(**_core_call_args) return { **_core_base, "jsonData": result["taskInfo"], "taskInfo": result["taskInfo"], "questionGroup": result["questionGroup"], "studyInfo": result["studyInfo"], "kpInfo": result["kpInfo"], "intermediate": result["intermediate"], } elif cType == "core_speaking_reply": result = generate_core_speaking_reply(**_core_call_args) return { **_core_base, "jsonData": result["taskInfo"], "taskInfo": result["taskInfo"], "dialogSetting": result["dialogSetting"], "dialogConfig": result["dialogConfig"], "studyInfo": result["studyInfo"], "kpInfo": result["kpInfo"], "intermediate": result["intermediate"], } elif cType == "core_speaking_inquiry": result = generate_core_speaking_inquiry(**_core_call_args) return { **_core_base, "jsonData": result["taskInfo"], "taskInfo": result["taskInfo"], "dialogSetting": result["dialogSetting"], "dialogConfig": result["dialogConfig"], "studyInfo": result["studyInfo"], "kpInfo": result["kpInfo"], "intermediate": result["intermediate"], } elif cType == "core_speaking_image": result = generate_core_speaking_image(**_core_call_args) return { **_core_base, "jsonData": result["taskInfo"], "taskInfo": result["taskInfo"], "dialogConfig": result["dialogConfig"], "imageInfo": result["imageInfo"], "optionList": result["optionList"], "questionList": result["questionList"], "studyInfo": result["studyInfo"], "kpInfo": result["kpInfo"], "intermediate": result["intermediate"], } elif cType == "core_listening_order": result = generate_core_listening_order(**_core_call_args) return { **_core_base, "jsonData": result["taskInfo"], "taskInfo": result["taskInfo"], "materialInfo": result["materialInfo"], "flowInfo": result["flowInfo"], "studyInfo": result["studyInfo"], "kpInfo": result["kpInfo"], "intermediate": result["intermediate"], } elif cType == "core_listening_drag": result = generate_core_listening_drag(**_core_call_args) return { **_core_base, "jsonData": result["taskInfo"], "taskInfo": result["taskInfo"], "preDialog": result["preDialog"], "dialogList": result["dialogList"], "questionList": result["questionList"], "studyInfo": result["studyInfo"], "kpInfo": result["kpInfo"], "intermediate": result["intermediate"], } elif cType == "core_listening_choose": result = generate_core_listening_choose(**_core_call_args) return { **_core_base, "jsonData": result["taskInfo"], "taskInfo": result["taskInfo"], "questionGroup": result["questionGroup"], "studyInfo": result["studyInfo"], "kpInfo": result["kpInfo"], "intermediate": result["intermediate"], } elif cType in ("core_writing_imgMakeSentence", "core_writing_imgWrite", "core_writing_questionMakeSentence", "core_writing_questionWrite"): _writing_funcs = { "core_writing_imgMakeSentence": generate_core_writing_img_make_sentence, "core_writing_imgWrite": generate_core_writing_img_write, "core_writing_questionMakeSentence": generate_core_writing_question_make_sentence, "core_writing_questionWrite": generate_core_writing_question_write, } result = _writing_funcs[cType](**_core_call_args) return { **_core_base, "jsonData": result["taskInfo"], "taskInfo": result["taskInfo"], "textInfo": result["textInfo"], "studyInfo": result["studyInfo"], "evalInfo": result["evalInfo"], "kpInfo": result["kpInfo"], "intermediate": result["intermediate"], } else: raise ValueError(f"核心互动类型 {cType} 尚未实现生成器") # ── 中互动类型：单步 LLM 生成 ── # 生成 jsonData json_data = generate_json_data( cType=cType, cId=cId, teaching_config=component["teaching_config"], character_map=resolved_char_map, has_image=has_image, knowledge_text=component.get("knowledge_text", ""), llm_client=llm_client, ) # 生成 kpInfo kp_info = generate_kp_info( cType=cType, cId=cId, knowledge_text=component.get("knowledge_text", ""), llm_client=llm_client, level=level, ) return { "jsonData": json_data, "kpInfo": kp_info, "cType": cType, "type_name": component["type_name"], "cId": cId, "has_image": has_image, "category": "mid", "bitable": type_info.get("bitable"), "db_table": type_info.get("db_table"), } # ============ 辅助函数 ============ def _get_cn_name(cType): """从 cType 获取中文类型名""" from match_component import MID_INTERACTION_TYPES for cn_name, info in MID_INTERACTION_TYPES.items(): if info["cType"] == cType: return cn_name return cType def _post_process_json_data(json_data, cType, cId, has_image): """后处理 jsonData：确保必需字段正确""" if not isinstance(json_data, dict): logger.warning(f"jsonData 不是 dict: {type(json_data)}") return json_data # 强制覆盖 cType 和 cId json_data["cType"] = cType json_data["cId"] = str(cId) # 确保配图相关字段（仅在 has_image 且 LLM 遗漏时补充） if has_image and "img" not in json_data: json_data["img"] = f"{cId}.png" return json_data def _try_rule_based_kp(cType, cId, knowledge_text): """ 尝试规则化生成 kpInfo（知识点结构固定，多数情况可规则处理） Returns: dict or None: 成功返回 kpInfo，无法处理返回 None """ # 清理 标签 clean_text = re.sub(r']*>', '', knowledge_text) clean_text = re.sub(r'', '', clean_text) clean_text = clean_text.strip() if not clean_text: return None lines = [l.strip() for l in clean_text.split("\n") if l.strip()] kp_list = [] for line in lines: # 去除数字后缀（如 "school 1" → "school", "You need to... 2" → "You need to..."） stripped = re.sub(r'\s+\d+$', '', line).strip() if not stripped: continue # 判断 vocab vs sentence if "..." in stripped or len(stripped.split()) > 3: kp_list.append({ "kpId": None, "kpType": "sentence", "kpTitle": stripped, "kpSkill": "sentence_meaning", "kpSkillName": "语义", }) else: kp_list.append({ "kpId": None, "kpType": "vocab", "kpTitle": stripped, "kpSkill": "vocab_meaning", "kpSkillName": "词义", }) if not kp_list: return None return { "pushType": "relationKp", "cType": cType, "cId": str(cId), "kpInfo": kp_list, } # ============ CLI 测试 ============ if __name__ == "__main__": sys.path.insert(0, CURRENT_PATH) from llm_client import get_client client = get_client() # 测试用教研配置 test_config = """【任务标题】 表示大家一起上学 【资源配置】 图片时机： 互动内容 【情境引入】 User: Great! User: Oh, there's no time left. 【互动内容】 User: Let's go to school now. (朗读) 【后置对话】 无""" test_kp = "school" test_char_map = {"Eva": 663, "Peter": 653, "Vicky": 658} print("=== 测试 jsonData 生成 (v2 template) ===") jd = generate_json_data( cType="mid_dialog_repeat", cId="1214101", teaching_config=test_config, character_map=test_char_map, has_image=True, knowledge_text=test_kp, llm_client=client, ) print(json.dumps(jd, ensure_ascii=False, indent=2)) print("\n=== 测试 kpInfo 生成 ===") kp = generate_kp_info("mid_dialog_repeat", "1214101", test_kp, client) print(json.dumps(kp, ensure_ascii=False, indent=2))