🚀 fix: 修复导入错误并集成persona系统

✨ 修复内容:
- 修正 travel_assistant.py 文件内容错误
- 添加预算识别功能
- 集成persona系统
- 更新API验证器

🐛 解决问题:
- ImportError: cannot import TravelAssistant
- 文件路径配置问题

modules/info_extractor.py

@@ -1,119 +1,145 @@
+# modules/info_extractor.py - 增强版本（添加预算识别）
 import re
-from .config_loader import ConfigLoader
 from utils.logger import log
 
 class InfoExtractor:
-    def __init__(self, config_loader: ConfigLoader):
-        self.configs = config_loader
-
-    def extract(self, user_input: str) -> dict:
-        """从用户输入中提取目的地、天数和旅行风格"""
+    def __init__(self, config):
+        self.config = config
+    
+    def extract(self, message: str) -> dict:
+        """从用户消息中提取信息"""
         extracted_info = {}
-        user_lower = user_input.lower()
-
-        try:
-            # 提取目的地
-            destination = self._extract_destination(user_lower)
-            if destination:
-                extracted_info["destination"] = destination
-
-            # 提取天数
-            duration = self._extract_duration(user_input)
-            if duration:
-                extracted_info["duration"] = duration
-            
-            # 提取旅行风格 (persona)
-            persona = self._extract_persona(user_input)
-            if persona:
-                extracted_info["persona"] = persona
-            
-            return extracted_info
-            
-        except Exception as e:
-            log.error(f"❌ 信息提取失败: {e}", exc_info=True)
-            return {}
-
-    def _extract_destination(self, user_lower: str) -> dict:
+        
+        # 1. 提取目的地信息
+        destination = self._extract_destination(message)
+        if destination:
+            extracted_info['destination'] = destination
+        
+        # 2. 提取天数信息
+        duration = self._extract_duration(message)
+        if duration:
+            extracted_info['duration'] = duration
+        
+        # 3. 提取预算信息（新增）
+        budget = self._extract_budget(message)
+        if budget:
+            extracted_info['budget'] = budget
+        
+        return extracted_info
+    
+    def _extract_destination(self, message: str) -> dict:
         """提取目的地信息"""
-        for alias, city_info in self.configs.cities.items():
-            if alias in user_lower:
-                return city_info
+        message_lower = message.lower()
+        
+        # 从配置中的城市列表匹配
+        for city_key, city_info in self.config.cities.items():
+            if city_key in message_lower:
+                return {
+                    'name': city_info['name'],
+                    'country': city_info.get('country', ''),
+                    'highlights': city_info.get('highlights', ''),
+                    'best_season': city_info.get('best_season', ''),
+                    'avg_daily_budget': city_info.get('avg_daily_budget', 100)
+                }
+        
         return None
-
-    def _extract_duration(self, user_input: str) -> dict:
-        """提取天数信息 - 改进版本"""
+    
+    def _extract_duration(self, message: str) -> dict:
+        """提取旅行天数"""
+        # 匹配各种天数表达方式
         patterns = [
-            (r'(\d+)\s*天', lambda x: int(x)),
-            (r'(\d+)\s*日', lambda x: int(x)),
-            (r'一周|7天|七天', lambda x: 7),
-            (r'两周|14天|十四天', lambda x: 14),
-            (r'周末', lambda x: 2),
-            (r'三天|3天', lambda x: 3),
-            (r'五天|5天', lambda x: 5),
-            (r'十天|10天', lambda x: 10),
+            r'(\d+)\s*天',
+            r'(\d+)\s*日',
+            r'(\d+)\s*days?',
+            r'玩\s*(\d+)\s*天',
+            r'待\s*(\d+)\s*天',
+            r'(\d+)\s*个天',
         ]
         
-        for pattern, converter in patterns:
-            match = re.search(pattern, user_input)
+        for pattern in patterns:
+            match = re.search(pattern, message, re.IGNORECASE)
             if match:
-                try:
-                    if match.groups():
-                        days = converter(match.group(1))
-                    else:
-                        days = converter(None)
-                    
-                    if 1 <= days <= 30:
-                        return {"days": days, "description": f"{days}天旅行"}
-                except (ValueError, TypeError):
-                    continue
+                days = int(match.group(1))
+                if 1 <= days <= 30:  # 合理的天数范围
+                    return {
+                        'days': days,
+                        'description': f"{days}天"
+                    }
+        
         return None
-
-    def _extract_persona(self, user_input: str) -> dict:
-        """提取用户偏好 - 根据实际personas.json结构"""
-        user_lower = user_input.lower()
-    
-        # 检查personas配置
-        for persona_key, persona_info in self.configs.personas.items():
-            # 检查persona名称中的关键词
-            persona_name = persona_info.get('name', '').lower()
-            # 移除emoji并检查关键词
-            clean_name = ''.join(char for char in persona_name if char.isalpha() or char.isspace())
-        
-            if any(keyword in user_lower for keyword in clean_name.split() if len(keyword) > 1):
-                return {**persona_info, "key": persona_key}  # 添加key方便后续使用
-        
-            # 检查风格关键词
-            style = persona_info.get('style', '').lower()
-            if any(keyword in user_lower for keyword in style.split('、') if len(keyword) > 1):
-                return {**persona_info, "key": persona_key}
-        
-            # 检查特征描述
-            characteristics = persona_info.get('characteristics', [])
-            for char in characteristics:
-                char_keywords = char.lower().split()[:3]  # 取前3个词作为关键词
-                if any(keyword in user_lower for keyword in char_keywords if len(keyword) > 1):
-                    return {**persona_info, "key": persona_key}
     
-        # 基于关键词的简单映射
-        keyword_persona_map = {
-            '规划': 'planner',
-            '计划': 'planner', 
-            '效率': 'planner',
-            '预算': 'planner',
-            '分享': 'social',
-            '朋友': 'social',
-            '拍照': 'social',
-            '打卡': 'social',
-            '深度': 'experiential',
-            '文化': 'experiential',
-            '地道': 'experiential',
-            '当地': 'experiential'
+    def _extract_budget(self, message: str) -> dict:
+        """提取预算信息（新增功能）"""
+        message_lower = message.lower()
+        
+        # 1. 匹配具体金额（支持多种货币）
+        money_patterns = [
+            # 欧元
+            (r'(\d+(?:,\d{3})*(?:\.\d{2})?)\s*(?:欧元|euros?|eur|€)', 'EUR'),
+            # 美元
+            (r'(\d+(?:,\d{3})*(?:\.\d{2})?)\s*(?:美元|dollars?|usd|\$)', 'USD'),
+            # 人民币
+            (r'(\d+(?:,\d{3})*(?:\.\d{2})?)\s*(?:元|人民币|rmb|¥)', 'CNY'),
+            # 英镑
+            (r'(\d+(?:,\d{3})*(?:\.\d{2})?)\s*(?:英镑|pounds?|gbp|£)', 'GBP'),
+        ]
+        
+        for pattern, currency in money_patterns:
+            match = re.search(pattern, message_lower)
+            if match:
+                amount_str = match.group(1).replace(',', '')
+                amount = float(amount_str)
+                return {
+                    'amount': amount,
+                    'currency': currency,
+                    'type': self._categorize_budget_amount(amount, currency),
+                    'description': f"{amount}{currency}"
+                }
+        
+        # 2. 匹配预算类型关键词
+        budget_keywords = {
+            'economy': ['经济', '便宜', '省钱', '穷游', '节约', '预算有限', '学生'],
+            'comfortable': ['舒适', '中等', '适中', '一般', '普通', '正常'],
+            'luxury': ['豪华', '奢华', '高端', '贵', '不差钱', '任性', '土豪']
         }
+        
+        for budget_type, keywords in budget_keywords.items():
+            for keyword in keywords:
+                if keyword in message_lower:
+                    return {
+                        'type': budget_type,
+                        'description': self._get_budget_type_description(budget_type)
+                    }
+        
+        return None
     
-        for keyword, persona_key in keyword_persona_map.items():
-            if keyword in user_input:
-                persona_info = self.configs.personas.get(persona_key, {})
-                if persona_info:
-                    return {**persona_info, "key": persona_key}
+    def _categorize_budget_amount(self, amount: float, currency: str) -> str:
+        """根据金额和货币分类预算类型"""
+        # 将所有货币转换为欧元基准进行分类
+        eur_rates = {
+            'EUR': 1.0,
+            'USD': 0.85,  # 1 USD ≈ 0.85 EUR
+            'CNY': 0.13,  # 1 CNY ≈ 0.13 EUR
+            'GBP': 1.15   # 1 GBP ≈ 1.15 EUR
+        }
+        
+        eur_amount = amount * eur_rates.get(currency, 1.0)
+        
+        # 按每日预算分类（假设7天行程）
+        daily_budget = eur_amount / 7
+        
+        if daily_budget < 50:
+            return 'economy'
+        elif daily_budget < 150:
+            return 'comfortable'
+        else:
+            return 'luxury'
     
-        return None
+    def _get_budget_type_description(self, budget_type: str) -> str:
+        """获取预算类型的描述"""
+        descriptions = {
+            'economy': '经济型预算',
+            'comfortable': '舒适型预算',
+            'luxury': '豪华型预算'
+        }
+        return descriptions.get(budget_type, '中等预算')

modules/response_generator.py

@@ -1,3 +1,4 @@
+# modules/response_generator.py - 完整版本（含persona+预算）
 import json
 import os
 from .ai_model import AIModel
@@ -27,7 +28,7 @@ class ResponseGenerator:
             
             # 1. 检查是否需要收集目的地
             if not session_state.get("destination"):
-                return "听起来很棒！你想去欧洲的哪个城市呢？比如巴黎, 罗马, 巴塞罗那？"
+                return "Hi！你想去欧洲的哪个城市呢？比如巴黎, 罗马, 巴塞罗那？"
             
             # 2. 检查是否需要收集天数
             if not session_state.get("duration"):
@@ -40,7 +41,18 @@ class ResponseGenerator:
             # 4. persona由前端传入，这里检查是否存在
             # 注意：如果前端没传persona，可以询问或使用默认值
             if not session_state.get("persona"):
-                return "请告诉我您更偏向哪种旅行风格：高效规划型、社交分享型，还是深度体验型？"
+                separator = '*' * 60
+    
+                persona_selection_message = f"""请告诉我您更偏向哪种旅行风格：高效规划型、社交分享型，还是深度体验型？
+
+        {separator}
+
+        🗓️ **高效规划型** - 注重时间安排和预算控制，喜欢详细的行程规划
+
+        🤝 **社交分享型** - 重视与朋友分享，喜欢拍照打卡和热闹的体验
+
+        🎨 **深度体验型** - 追求地道文化体验，避开商业化景点"""
+                return persona_selection_message
             
             # 【增强阶段】信息收集完毕，现在用知识库和persona增强回答质量
             return self._generate_persona_enhanced_plan(user_message, session_state)

modules/travel_assistant.py

@@ -1,323 +1,57 @@
-# modules/response_generator.py - 完整版本（含persona+预算）
-import json
-import os
+# modules/travel_assistant.py - 正确版本
+from .config_loader import ConfigLoader
 from .ai_model import AIModel
 from .knowledge_base import KnowledgeBase
+from .info_extractor import InfoExtractor
+from .session_manager import SessionManager
+from .response_generator import ResponseGenerator
 from utils.logger import log
 
-class ResponseGenerator:
-    def __init__(self, ai_model: AIModel, knowledge_base: KnowledgeBase):
-        self.ai_model = ai_model
-        self.kb = knowledge_base
-        self.personas = self._load_personas()
-
-    def _load_personas(self):
-        """加载personas配置"""
-        try:
-            personas_path = os.path.join(os.path.dirname(__file__), '..', 'data', 'personas.json')
-            with open(personas_path, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-                return data.get('personas', {})
-        except Exception as e:
-            log.error(f"❌ 加载personas.json失败: {e}")
-            return {}
-
-    def generate(self, user_message: str, session_state: dict) -> str:
-        try:
-            # 【主流程】按顺序收集信息：目的地 → 天数 → 预算 → persona（可选）
-            
-            # 1. 检查是否需要收集目的地
-            if not session_state.get("destination"):
-                return "Hi！你想去欧洲的哪个城市呢？比如巴黎, 罗马, 巴塞罗那？"
-            
-            # 2. 检查是否需要收集天数
-            if not session_state.get("duration"):
-                return f"好的，{session_state['destination']['name']}是个很棒的选择！你计划玩几天呢？"
-            
-            # 3. 检查是否需要收集预算
-            if not session_state.get("budget"):
-                return f"了解！{session_state['duration']['days']}天的行程。为了给您更合适的建议，请问您的预算大概是多少呢？（比如：2000欧元，或者经济型/舒适型/豪华型）"
-            
-            # 4. persona由前端传入，这里检查是否存在
-            # 注意：如果前端没传persona，可以询问或使用默认值
-            if not session_state.get("persona"):
-                separator = '*' * 60
-    
-                persona_selection_message = f"""请告诉我您更偏向哪种旅行风格：高效规划型、社交分享型，还是深度体验型？
-
-        {separator}
-
-        🗓️ **高效规划型** - 注重时间安排和预算控制，喜欢详细的行程规划
-
-        🤝 **社交分享型** - 重视与朋友分享，喜欢拍照打卡和热闹的体验
-
-        🎨 **深度体验型** - 追求地道文化体验，避开商业化景点"""
-                return persona_selection_message
-            
-            # 【增强阶段】信息收集完毕，现在用知识库和persona增强回答质量
-            return self._generate_persona_enhanced_plan(user_message, session_state)
-                
-        except Exception as e:
-            log.error(f"❌ 响应生成失败: {e}", exc_info=True)
-            return "抱歉，我在处理您的请求时遇到了问题，请稍后再试。"
-
-    def _generate_persona_enhanced_plan(self, user_message: str, session_state: dict) -> str:
-        """根据persona和完整信息生成定制化的旅行计划"""
-        
-        # 1. 获取知识库上下文
-        search_query = self._build_search_query(session_state)
-        relevant_knowledge = self.kb.search(search_query)
-        knowledge_context = self._format_knowledge_context(relevant_knowledge)
-        
-        # 2. 根据persona构建定制化prompt
-        persona_prompt = self._build_persona_enhanced_prompt(session_state, knowledge_context)
-        
-        # 3. 使用AI生成回答
-        if self.ai_model.is_available():
-            return self.ai_model.generate(user_message, persona_prompt)
-        else:
-            return self._generate_fallback_plan(session_state, knowledge_context)
-
-    def _build_persona_enhanced_prompt(self, session_state: dict, knowledge_context: str = "") -> str:
-        """根据persona构建增强的prompt"""
-        destination = session_state.get("destination", {})
-        duration = session_state.get("duration", {})
-        budget = session_state.get("budget", {})
-        persona = session_state.get("persona", {})
-        
-        # 基础信息
-        location = destination.get('name', '目的地')
-        days = duration.get('days', '几')
-        budget_info = self._format_budget_info(budget)
-        
-        # 获取persona配置
-        persona_key = persona.get('key')
-        if not persona_key or persona_key not in self.personas:
-            # 如果没有有效persona，使用通用prompt
-            return self._build_generic_prompt(session_state, knowledge_context)
-        
-        persona_config = self.personas[persona_key]
-        
-        # 使用personas.json中的prompt_template
-        persona_template = persona_config.get('prompt_template', '')
-        
-        # 替换模板中的变量
-        enhanced_prompt = persona_template.format(
-            location=location,
-            days=days,
-            date="近期",  # 可以从session中获取更具体的日期
-            user_tags="",  # 可以从用户偏好中提取
-            commercial_preference="适中",  # 可以从session中获取
-            group_description="个人/朋友",  # 可以从session中获取
-            budget=budget_info,  # 使用格式化的预算信息
-            tags=""  # 可以从session中获取
-        )
-        
-        # 添加知识库上下文
-        if knowledge_context:
-            enhanced_prompt += f"\n\n【背景知识】\n{knowledge_context}"
-        
-        # 添加预算约束信息
-        enhanced_prompt += f"\n\n【预算约束】\n用户预算：{budget_info}，请确保所有推荐都在预算范围内。"
-        
-        # 添加persona特定的指导原则
-        characteristics = persona_config.get('characteristics', [])
-        if characteristics:
-            enhanced_prompt += f"\n\n【用户特征】\n" + "\n".join([f"- {char}" for char in characteristics])
-        
-        recommendation_strategy = persona_config.get('recommendation_strategy', [])
-        if recommendation_strategy:
-            enhanced_prompt += f"\n\n【推荐策略】\n" + "\n".join([f"- {strategy}" for strategy in recommendation_strategy])
-        
-        tone_guidelines = persona_config.get('tone', [])
-        if tone_guidelines:
-            enhanced_prompt += f"\n\n【语言风格】\n" + "\n".join([f"- {tone}" for tone in tone_guidelines])
-        
-        return enhanced_prompt
-
-    def _format_budget_info(self, budget: dict) -> str:
-        """格式化预算信息"""
-        if not budget:
-            return "中等预算"
-        
-        # 如果有具体金额
-        if budget.get('amount') and budget.get('currency'):
-            return f"{budget['amount']}{budget['currency']}"
-        
-        # 如果有预算类型
-        if budget.get('type'):
-            budget_type_map = {
-                'economy': '经济型预算',
-                'comfortable': '舒适型预算', 
-                'luxury': '豪华型预算'
+class TravelAssistant:
+    def __init__(self):
+        # 依赖注入：在这里实例化所有需要的模块
+        log.info("开始初始化 Travel Assistant 核心模块...")
+        self.config = ConfigLoader()
+        self.kb = KnowledgeBase()
+        self.ai_model = AIModel()
+        self.session_manager = SessionManager()
+        self.info_extractor = InfoExtractor(self.config)
+        self.response_generator = ResponseGenerator(self.ai_model, self.kb)
+        log.info("✅ Travel Assistant 核心模块全部初始化完成！")
+
+    def chat(self, message: str, session_id: str, history: list, persona_key: str = None):
+        # 1. 获取或创建会话
+        session_state = self.session_manager.get_or_create_session(session_id)
+        current_session_id = session_state['session_id']
+
+        # 2. 如果前端传来了persona，直接设置到session中
+        if persona_key and persona_key in self.config.personas:
+            persona_info = {
+                'key': persona_key,
+                'name': self.config.personas[persona_key]['name'],
+                'style': self.config.personas[persona_key]['style'],
+                'source': 'frontend_selection'  # 标记来源
             }
-            return budget_type_map.get(budget['type'], budget['type'])
-        
-        # 如果有预算范围
-        if budget.get('range'):
-            return budget['range']
-        
-        return "中等预算"
-
-    def _build_generic_prompt(self, session_state: dict, knowledge_context: str = "") -> str:
-        """构建通用prompt（当没有persona时使用）"""
-        destination = session_state.get("destination", {})
-        duration = session_state.get("duration", {})
-        budget = session_state.get("budget", {})
-        
-        location = destination.get('name', '目的地')
-        days = duration.get('days', '几')
-        budget_info = self._format_budget_info(budget)
-        
-        prompt = f"""你是一个专业的旅游助手。请为用户生成一个详细的旅行计划。
+            self.session_manager.update_session(current_session_id, {'persona': persona_info})
+            session_state = self.session_manager.get_or_create_session(current_session_id)
+            log.info(f"设置用户persona: {persona_info['name']}")
 
-【基本信息】
-- 目的地：{location}
-- 旅行天数：{days}天
-- 预算：{budget_info}
-
-【要求】
-- 提供具体的景点推荐和路线安排
-- 包含交通、住宿、餐饮建议
-- 确保所有推荐都在预算范围内
-- 提供实用的旅行贴士"""
-        
-        if knowledge_context:
-            prompt += f"\n\n【背景信息】\n{knowledge_context}"
-        
-        prompt += "\n\n请生成一份实用���详细的旅行计划。"
-        
-        return prompt
-
-    def _build_search_query(self, session_state: dict) -> str:
-        """构建知识库搜索查询"""
-        destination = session_state.get("destination", {})
-        persona = session_state.get("persona", {})
-        budget = session_state.get("budget", {})
-        
-        query_parts = []
-        
-        # 添加目的地
-        if destination.get('name'):
-            query_parts.append(destination['name'])
-        
-        # 添加persona类型
-        if persona.get('key'):
-            query_parts.append(persona['key'])
-        
-        # 添加预算类型
-        if budget.get('type'):
-            query_parts.append(budget['type'])
+        # 3. 从用户输入中提取其他信息（目的地、天数、预算）
+        extracted_info = self.info_extractor.extract(message)
         
-        return " ".join(query_parts) if query_parts else "欧洲旅行"
+        # 4. 更新会话状态
+        if extracted_info:
+            self.session_manager.update_session(current_session_id, extracted_info)
+            # 重新获取更新后的状态
+            session_state = self.session_manager.get_or_create_session(current_session_id)
 
-    def _generate_fallback_plan(self, session_state: dict, knowledge_context: str = "") -> str:
-        """AI不可用时的备用计划生成（现在包含预算和persona信息）"""
-        destination = session_state.get("destination", {})
-        duration = session_state.get("duration", {})
-        budget = session_state.get("budget", {})
-        persona = session_state.get("persona", {})
+        # 5. 生成回复
+        bot_response = self.response_generator.generate(message, session_state)
         
-        location = destination.get('name', '目的地')
-        days = duration.get('days', '几')
-        budget_info = self._format_budget_info(budget)
-        persona_name = persona.get('name', '旅行者')
+        # 6. 格式化状态信息用于前端显示
+        status_info = self.session_manager.format_session_info(session_state)
         
-        plan = f"为您推荐 {location} {days}天旅行计划：\n\n"
+        # 7. 更新对话历史
+        new_history = history + [[message, bot_response]]
         
-        # 用户信息概述
-        plan += f"👤 旅行者类型：{persona_name}\n"
-        plan += f"💰 预算范围：{budget_info}\n\n"
-        
-        # 优先使用知识库信息
-        if knowledge_context and "相关旅游知识" in knowledge_context:
-            plan += f"📚 {knowledge_context}\n\n"
-        
-        # 使用cities.json中的基础信息
-        highlights = destination.get('highlights', '精彩景点等待您的探索')
-        plan += f"🎯 主要景点：{highlights}\n\n"
-        
-        best_season = destination.get('best_season', '全年适宜')
-        plan += f"🌤️ 最佳旅行时间：{best_season}\n\n"
-        
-        avg_budget = destination.get('avg_daily_budget', 100)
-        plan += f"💰 日均预算参考：约{avg_budget}欧元/天\n\n"
-        
-        # 根据persona调整建议风格
-        if persona.get('key') == 'planner':
-            plan += "📋 建议制定详细的每日行程表，包含具体时间安排和备选方案。\n\n"
-        elif persona.get('key') == 'social':
-            plan += "📸 推荐寻找热门打卡点，准备好相机记录美好时光！\n\n"
-        elif persona.get('key') == 'experiential':
-            plan += "🎨 建议深入当地社区，寻找地道的文化体验和小众景点。\n\n"
-        
-        # 预算相关建议
-        if budget.get('type') == 'economy':
-            plan += "💡 经济型贴士：考虑使用公共交通，选择青旅或民宿，寻找当地平价美食。\n\n"
-        elif budget.get('type') == 'luxury':
-            plan += "✨ 豪华体验：可以考虑五星酒店、私人导览和米其林餐厅。\n\n"
-        
-        plan += "如需更详细的个性化规划，请告诉我您的具体需求！"
-        return plan
-
-    def _format_knowledge_context(self, knowledge_items: list) -> str:
-        """格式化知识库内容作为上下文"""
-        if not knowledge_items: 
-            return "基于一般旅游建议"
-        
-        try:
-            # 只使用最相关的一条知识
-            item = knowledge_items[0]
-            knowledge = item.get('knowledge', {})
-            travel_knowledge = knowledge.get('travel_knowledge', {})
-            
-            context_parts = []
-            
-            # 1. 获取目的地信息
-            destination_info = travel_knowledge.get('destination_info', {})
-            if destination_info:
-                primary_destinations = destination_info.get('primary_destinations', [])
-                if primary_destinations:
-                    context_parts.append(f"目的地: {', '.join(primary_destinations)}")
-                
-                recommended_duration = destination_info.get('recommended_duration')
-                if recommended_duration:
-                    context_parts.append(f"推荐天数: {recommended_duration}天")
-
-            # 2. 获取预算信息
-            budget_analysis = travel_knowledge.get('budget_analysis', {})
-            if budget_analysis:
-                total_budget = budget_analysis.get('total_budget_range')
-                if total_budget:
-                    context_parts.append(f"预算参考: {total_budget}")
-                
-                daily_average = budget_analysis.get('daily_average')
-                if daily_average:
-                    context_parts.append(f"日均预算: {daily_average}")
-
-            # 3. 获取专业见解
-            professional_insights = travel_knowledge.get('professional_insights', {})
-            if professional_insights:
-                common_mistakes = professional_insights.get('common_mistakes', [])
-                if common_mistakes:
-                    context_parts.append(f"避免误区: {', '.join(common_mistakes[:2])}")
-                
-                insider_secrets = professional_insights.get('insider_secrets', [])
-                if insider_secrets:
-                    context_parts.append(f"内行贴士: {', '.join(insider_secrets[:2])}")
-                
-                seasonal_info = professional_insights.get('seasonal_considerations', {})
-                if seasonal_info:
-                    best_months = seasonal_info.get('best_months', [])
-                    if best_months:
-                        context_parts.append(f"最佳时间: {', '.join(best_months)}")
-
-            # 4. 拼接结果
-            if context_parts:
-                return "相关旅游知识：\n- " + "\n- ".join(context_parts)
-            else:
-                return "基于专业旅游建议"
-                
-        except Exception as e:
-            log.error(f"❌ 格式化知识库上下文失败: {e}", exc_info=True)
-            return "基于一般旅游建议"
+        return bot_response, current_session_id, status_info, new_history

utils/validators.py

@@ -1,3 +1,4 @@
+# utils/validators.py - 更新版本
 from pydantic import BaseModel
 from typing import List, Optional, Dict, Any