update:1.修复大纲展开功能bug，按顺序展开 2.优化大纲细化UI展示，大纲设置为卷 3.实现角色关系修改功能 4.优化提示词避免出现过多特殊符号 5.优化向导页面的AI生产进度页面和灵感模式保持统一，支持重试 6.优化项目生成过长中断添加自动恢复逻辑

2025-11-26 14:56:13 +08:00
parent 42fdad71aa
commit 8121c04af9
18 changed files with 2094 additions and 1307 deletions
@@ -1124,14 +1124,23 @@ async def generate_chapter_content_stream(
                # 发送开始事件
                yield f"data: {json.dumps({'type': 'start', 'message': '开始AI创作...'}, ensure_ascii=False)}\n\n"
                
-                # 🔧 MCP工具增强：收集章节参考资料
+                # 🔧 MCP工具增强：收集章节参考资料（优化版）
                mcp_reference_materials = ""
                if enable_mcp and current_user_id:
                    try:
-                        yield f"data: {json.dumps({'type': 'progress', 'message': '🔍 尝试使用MCP工具收集参考资料...', 'progress': 28}, ensure_ascii=False)}\n\n"
+                        # 1️⃣ 静默检查工具可用性
+                        from app.services.mcp_tool_service import mcp_tool_service
+                        available_tools = await mcp_tool_service.get_user_enabled_tools(
+                            user_id=current_user_id,
+                            db_session=db_session
+                        )
                        
-                        # 构建资料收集提示词
-                        planning_prompt = f"""你正在为小说《{project.title}》创作第{current_chapter.chapter_number}章《{current_chapter.title}》。
+                        # 2️⃣ 只在有工具时才显示消息和调用
+                        if available_tools:
+                            yield f"data: {json.dumps({'type': 'progress', 'message': '🔍 使用MCP工具收集参考资料...', 'progress': 28}, ensure_ascii=False)}\n\n"
+                            
+                            # 构建资料收集提示词
+                            planning_prompt = f"""你正在为小说《{project.title}》创作第{current_chapter.chapter_number}章《{current_chapter.title}》。

 【章节大纲】
 {outline.content if outline else current_chapter.summary or '暂无大纲'}
@@ -1151,30 +1160,32 @@ async def generate_chapter_content_stream(
 4. 文化习俗和生活细节

 请根据章节内容，有针对性地查询1-2个最关键的问题。"""
-                        
-                        # 调用MCP增强的AI（非流式，最多2轮工具调用）
-                        planning_result = await user_ai_service.generate_text_with_mcp(
-                            prompt=planning_prompt,
-                            user_id=current_user_id,
-                            db_session=db_session,
-                            enable_mcp=True,
-                            max_tool_rounds=2,
-                            tool_choice="auto",
-                            provider=None,
-                            model=None
-                        )
-                        
-                        # 提取参考资料
-                        if planning_result.get("tool_calls_made", 0) > 0:
-                            tool_count = planning_result["tool_calls_made"]
-                            yield f"data: {json.dumps({'type': 'progress', 'message': f'✅ MCP工具调用成功（{tool_count}次）', 'progress': 32}, ensure_ascii=False)}\n\n"
-                            mcp_reference_materials = planning_result.get("content", "")
-                            logger.info(f"📚 MCP工具收集参考资料：{len(mcp_reference_materials)} 字符")
+                            
+                            # 调用MCP增强的AI（非流式，限制1轮避免超时）
+                            planning_result = await user_ai_service.generate_text_with_mcp(
+                                prompt=planning_prompt,
+                                user_id=current_user_id,
+                                db_session=db_session,
+                                enable_mcp=True,
+                                max_tool_rounds=1,  # ✅ 减少为1轮，避免超时
+                                tool_choice="auto",
+                                provider=None,
+                                model=None
+                            )
+                            
+                            # 3️⃣ 提取参考资料并显示结果
+                            if planning_result.get("tool_calls_made", 0) > 0:
+                                tool_count = planning_result["tool_calls_made"]
+                                yield f"data: {json.dumps({'type': 'progress', 'message': f'✅ MCP工具调用成功（{tool_count}次）', 'progress': 32}, ensure_ascii=False)}\n\n"
+                                mcp_reference_materials = planning_result.get("content", "")
+                                logger.info(f"📚 MCP工具收集参考资料：{len(mcp_reference_materials)} 字符")
+                            else:
+                                yield f"data: {json.dumps({'type': 'progress', 'message': 'ℹ️ MCP未使用工具，继续', 'progress': 32}, ensure_ascii=False)}\n\n"
                        else:
-                            yield f"data: {json.dumps({'type': 'progress', 'message': 'ℹ️ 未使用MCP工具（无可用工具或不需要）', 'progress': 32}, ensure_ascii=False)}\n\n"
+                            logger.debug(f"用户 {current_user_id} 未启用MCP工具，跳过MCP增强")
                            
                    except Exception as e:
-                        logger.warning(f"MCP工具调用失败（降级处理）: {e}")
+                        logger.warning(f"⚠️ MCP工具调用失败，降级为基础模式: {str(e)}")
                        yield f"data: {json.dumps({'type': 'progress', 'message': '⚠️ MCP工具暂时不可用，使用基础模式', 'progress': 32}, ensure_ascii=False)}\n\n"
                
                # 根据是否有前置内容选择不同的提示词，并应用写作风格、记忆增强和MCP参考资料
@@ -436,27 +436,54 @@ async def generate_character(
        logger.info(f"  - 用户ID：{user_id}")
        
        try:
-            # 使用支持MCP的生成方法
-            result = await user_ai_service.generate_text_with_mcp(
-                prompt=prompt,
-                user_id=user_id,
-                db_session=db,
-                enable_mcp=True,
-                max_tool_rounds=2,
-                tool_choice="auto",
-                provider=None,  # 使用AIService初始化时的配置
-                model=None      # 使用AIService初始化时的配置
-            )
-            
-            # 提取内容
-            if isinstance(result, dict):
-                ai_response = result.get('content', '')
-                logger.info(f"✅ AI响应接收完成（MCP增强），长度：{len(ai_response)} 字符")
-                if result.get('tool_calls'):
-                    logger.info(f"  - 工具调用：{len(result['tool_calls'])} 次")
+            # 🔧 MCP工具增强：静默检查并收集参考资料
+            mcp_enhanced_prompt = prompt
+            if user_id:
+                try:
+                    from app.services.mcp_tool_service import mcp_tool_service
+                    available_tools = await mcp_tool_service.get_user_enabled_tools(
+                        user_id=user_id,
+                        db_session=db
+                    )
+                    
+                    # 只在有工具时才调用
+                    if available_tools:
+                        logger.info(f"🔍 检测到可用MCP工具，尝试收集参考资料...")
+                        result = await user_ai_service.generate_text_with_mcp(
+                            prompt=prompt,
+                            user_id=user_id,
+                            db_session=db,
+                            enable_mcp=True,
+                            max_tool_rounds=1,  # 减少为1轮，避免超时
+                            tool_choice="auto",
+                            provider=None,
+                            model=None
+                        )
+                        
+                        # 提取内容
+                        if isinstance(result, dict):
+                            ai_response = result.get('content', '')
+                            logger.info(f"✅ AI响应接收完成（MCP增强），长度：{len(ai_response)} 字符")
+                            if result.get('tool_calls_made', 0) > 0:
+                                logger.info(f"  - MCP工具调用：{result['tool_calls_made']} 次")
+                        else:
+                            ai_response = result
+                            logger.info(f"✅ AI响应接收完成，长度：{len(ai_response) if ai_response else 0} 字符")
+                    else:
+                        logger.debug(f"用户 {user_id} 未启用MCP工具，使用基础模式")
+                        # 不使用MCP，直接生成
+                        result = await user_ai_service.generate_text(prompt=prompt)
+                        ai_response = result.get('content', '') if isinstance(result, dict) else result
+                        
+                except Exception as mcp_error:
+                    logger.warning(f"⚠️ MCP工具调用失败，降级为基础模式: {str(mcp_error)}")
+                    # 降级：不使用MCP
+                    result = await user_ai_service.generate_text(prompt=prompt)
+                    ai_response = result.get('content', '') if isinstance(result, dict) else result
            else:
-                ai_response = result
-                logger.info(f"✅ AI响应接收完成，长度：{len(ai_response) if ai_response else 0} 字符")
+                # 无用户ID，直接使用基础模式
+                result = await user_ai_service.generate_text(prompt=prompt)
+                ai_response = result.get('content', '') if isinstance(result, dict) else result
                
        except Exception as ai_error:
            logger.error(f"❌ AI服务调用异常：{str(ai_error)}")
@@ -807,21 +834,47 @@ async def generate_character_stream(
            logger.info(f"🎯 开始为项目 {request.project_id} 生成角色（SSE流式）")
            
            try:
-                result = await user_ai_service.generate_text_with_mcp(
-                    prompt=prompt,
-                    user_id=user_id,
-                    db_session=db,
-                    enable_mcp=True,
-                    max_tool_rounds=2,
-                    tool_choice="auto",
-                    provider=None,
-                    model=None
-                )
-                
-                if isinstance(result, dict):
-                    ai_response = result.get('content', '')
+                # 🔧 MCP工具增强：静默检查并收集参考资料
+                if user_id:
+                    try:
+                        from app.services.mcp_tool_service import mcp_tool_service
+                        available_tools = await mcp_tool_service.get_user_enabled_tools(
+                            user_id=user_id,
+                            db_session=db
+                        )
+                        
+                        # 只在有工具时才调用
+                        if available_tools:
+                            logger.info(f"🔍 检测到可用MCP工具，尝试收集参考资料...")
+                            result = await user_ai_service.generate_text_with_mcp(
+                                prompt=prompt,
+                                user_id=user_id,
+                                db_session=db,
+                                enable_mcp=True,
+                                max_tool_rounds=1,  # 减少为1轮，避免超时
+                                tool_choice="auto",
+                                provider=None,
+                                model=None
+                            )
+                            
+                            if isinstance(result, dict):
+                                ai_response = result.get('content', '')
+                                if result.get('tool_calls_made', 0) > 0:
+                                    logger.info(f"✅ MCP工具调用成功（{result['tool_calls_made']}次）")
+                            else:
+                                ai_response = result
+                        else:
+                            logger.debug(f"用户 {user_id} 未启用MCP工具，使用基础模式")
+                            result = await user_ai_service.generate_text(prompt=prompt)
+                            ai_response = result.get('content', '') if isinstance(result, dict) else result
+                            
+                    except Exception as mcp_error:
+                        logger.warning(f"⚠️ MCP工具调用失败，降级为基础模式: {str(mcp_error)}")
+                        result = await user_ai_service.generate_text(prompt=prompt)
+                        ai_response = result.get('content', '') if isinstance(result, dict) else result
                else:
-                    ai_response = result
+                    result = await user_ai_service.generate_text(prompt=prompt)
+                    ai_response = result.get('content', '') if isinstance(result, dict) else result
                    
            except Exception as ai_error:
                logger.error(f"❌ AI服务调用异常：{str(ai_error)}")
@@ -310,7 +310,7 @@ async def generate_outline(
        # 模式：全新生成
        if actual_mode == "new":
            return await _generate_new_outline(
-                request, project, db, user_ai_service
+                request, project, db, user_ai_service, user_id
            )
        
        # 模式：续写
@@ -344,7 +344,8 @@ async def _generate_new_outline(
    request: OutlineGenerateRequest,
    project: Project,
    db: AsyncSession,
-    user_ai_service: AIService
+    user_ai_service: AIService,
+    user_id: str = None
 ) -> OutlineListResponse:
    """全新生成大纲（MCP增强版）"""
    logger.info(f"全新生成大纲 - 项目: {project.id}, enable_mcp: {request.enable_mcp}")
@@ -360,14 +361,26 @@ async def _generate_new_outline(
        for char in characters
    ])
    
-    # 🔍 MCP工具增强：收集情节设计参考资料
+    # 🔍 MCP工具增强：收集情节设计参考资料（优化版）
    mcp_reference_materials = ""
    if request.enable_mcp:
        try:
-            logger.info(f"🔍 尝试使用MCP工具收集大纲设计参考资料...")
+            # 1️⃣ 静默检查工具可用性（注意：新建大纲时user_id可能不可用）
+            from app.services.mcp_tool_service import mcp_tool_service
+            # 使用传入的user_id参数
            
-            # 构建资料收集查询
-            planning_query = f"""你正在为小说《{project.title}》设计完整大纲。
+            if user_id:
+                available_tools = await mcp_tool_service.get_user_enabled_tools(
+                    user_id=user_id,
+                    db_session=db
+                )
+                
+                # 2️⃣ 只在有工具时才调用
+                if available_tools:
+                    logger.info(f"🔍 检测到可用MCP工具，收集大纲设计参考资料...")
+                    
+                    # 构建资料收集查询
+                    planning_query = f"""你正在为小说《{project.title}》设计完整大纲。
 项目信息：
 - 主题：{request.theme or project.theme}
 - 类型：{request.genre or project.genre}
@@ -389,27 +402,31 @@ async def _generate_new_outline(
 3. 符合世界观的情节元素和场景设计灵感

 请有针对性地查询1-2个最关键的问题。"""
-            
-            # 调用MCP增强的AI（非流式，最多2轮工具调用）
-            planning_result = await user_ai_service.generate_text_with_mcp(
-                prompt=planning_query,
-                user_id="system",  # 全新生成时可能没有用户上下文
-                db_session=db,
-                enable_mcp=True,
-                max_tool_rounds=2,
-                tool_choice="auto",
-                provider=None,
-                model=None
-            )
-            
-            # 提取参考资料
-            if planning_result.get("tool_calls_made", 0) > 0:
-                mcp_reference_materials = planning_result.get("content", "")
-                logger.info(f"📚 MCP工具收集参考资料：{len(mcp_reference_materials)} 字符")
+                    
+                    # 调用MCP增强的AI（非流式，限制1轮避免超时）
+                    planning_result = await user_ai_service.generate_text_with_mcp(
+                        prompt=planning_query,
+                        user_id=user_id,
+                        db_session=db,
+                        enable_mcp=True,
+                        max_tool_rounds=1,  # ✅ 减少为1轮，避免超时
+                        tool_choice="auto",
+                        provider=None,
+                        model=None
+                    )
+                    
+                    # 提取参考资料
+                    if planning_result.get("tool_calls_made", 0) > 0:
+                        mcp_reference_materials = planning_result.get("content", "")
+                        logger.info(f"✅ MCP工具收集参考资料：{len(mcp_reference_materials)} 字符")
+                    else:
+                        logger.info(f"ℹ️ MCP未使用工具，继续")
+                else:
+                    logger.debug(f"用户 {user_id} 未启用MCP工具，跳过MCP增强")
            else:
-                logger.info(f"ℹ️ MCP工具未进行调用，继续正常生成")
+                logger.debug("无用户上下文，跳过MCP增强")
        except Exception as e:
-            logger.warning(f"⚠️ MCP工具调用失败，继续使用常规模式: {str(e)}")
+            logger.warning(f"⚠️ MCP工具调用失败，降级为基础模式: {str(e)}")
            mcp_reference_materials = ""
    
    # 使用完整提示词（插入MCP参考资料）
@@ -659,15 +676,24 @@ async def _continue_outline(
            logger.warning(f"⚠️ 记忆上下文构建失败，继续不使用记忆: {str(e)}")
            memory_context = None
        
-        # 🔍 MCP工具增强：收集续写参考资料
+        # 🔍 MCP工具增强：收集续写参考资料（优化版）
        mcp_reference_materials = ""
        if request.enable_mcp:
            try:
-                logger.info(f"🔍 第{batch_num + 1}批：尝试使用MCP工具收集续写参考资料...")
+                # 1️⃣ 静默检查工具可用性
+                from app.services.mcp_tool_service import mcp_tool_service
+                available_tools = await mcp_tool_service.get_user_enabled_tools(
+                    user_id=user_id,
+                    db_session=db
+                )
                
-                # 构建资料收集查询
-                latest_summary = latest_outlines[-1].content if latest_outlines else ""
-                planning_query = f"""你正在为小说《{project.title}》续写大纲。
+                # 2️⃣ 只在有工具时才调用
+                if available_tools:
+                    logger.info(f"🔍 第{batch_num + 1}批：检测到可用MCP工具，收集续写参考资料...")
+                    
+                    # 构建资料收集查询
+                    latest_summary = latest_outlines[-1].content if latest_outlines else ""
+                    planning_query = f"""你正在为小说《{project.title}》续写大纲。
 当前进度：已有{len(latest_outlines)}章，即将续写第{current_start_chapter}-{current_start_chapter + current_batch_size - 1}章

 项目信息：
@@ -686,27 +712,29 @@ async def _continue_outline(
 3. 符合类型特点的场景设计和剧情元素

 请有针对性地查询1-2个最关键的问题。"""
-                
-                # 调用MCP增强的AI（非流式，最多2轮工具调用）
-                planning_result = await user_ai_service.generate_text_with_mcp(
-                    prompt=planning_query,
-                    user_id=user_id,
-                    db_session=db,
-                    enable_mcp=True,
-                    max_tool_rounds=2,
-                    tool_choice="auto",
-                    provider=None,
-                    model=None
-                )
-                
-                # 提取参考资料
-                if planning_result.get("tool_calls_made", 0) > 0:
-                    mcp_reference_materials = planning_result.get("content", "")
-                    logger.info(f"📚 第{batch_num + 1}批MCP工具收集参考资料：{len(mcp_reference_materials)} 字符")
+                    
+                    # 调用MCP增强的AI（非流式，限制1轮避免超时）
+                    planning_result = await user_ai_service.generate_text_with_mcp(
+                        prompt=planning_query,
+                        user_id=user_id,
+                        db_session=db,
+                        enable_mcp=True,
+                        max_tool_rounds=1,  # ✅ 减少为1轮，避免超时
+                        tool_choice="auto",
+                        provider=None,
+                        model=None
+                    )
+                    
+                    # 提取参考资料
+                    if planning_result.get("tool_calls_made", 0) > 0:
+                        mcp_reference_materials = planning_result.get("content", "")
+                        logger.info(f"✅ 第{batch_num + 1}批MCP工具收集参考资料：{len(mcp_reference_materials)} 字符")
+                    else:
+                        logger.info(f"ℹ️ 第{batch_num + 1}批MCP未使用工具，继续")
                else:
-                    logger.info(f"ℹ️ 第{batch_num + 1}批MCP工具未进行调用，继续正常生成")
+                    logger.debug(f"用户 {user_id} 未启用MCP工具，跳过第{batch_num + 1}批MCP增强")
            except Exception as e:
-                logger.warning(f"⚠️ 第{batch_num + 1}批MCP工具调用失败，继续使用常规模式: {str(e)}")
+                logger.warning(f"⚠️ 第{batch_num + 1}批MCP工具调用失败，降级为基础模式: {str(e)}")
                mcp_reference_materials = ""
        
        # 使用标准续写提示词模板（支持记忆+MCP增强）
@@ -892,15 +920,29 @@ async def new_outline_generator(
            for char in characters
        ])
        
-        # 🔍 MCP工具增强：收集情节设计参考资料
+        # 🔍 MCP工具增强：收集情节设计参考资料（优化版）
        mcp_reference_materials = ""
        if enable_mcp:
            try:
-                yield await SSEResponse.send_progress("🔍 使用MCP工具收集参考资料...", 18)
-                logger.info(f"🔍 尝试使用MCP工具收集大纲设计参考资料...")
+                # 1️⃣ 静默检查工具可用性
+                from app.services.mcp_tool_service import mcp_tool_service
+                # 尝试从环境获取user_id（SSE流式场景下可能没有）
+                # 这里可以考虑让前端传递user_id
+                user_id_for_mcp = data.get("user_id")  # 需要前端传递
                
-                # 构建资料收集查询
-                planning_query = f"""你正在为小说《{project.title}》设计完整大纲。
+                if user_id_for_mcp:
+                    available_tools = await mcp_tool_service.get_user_enabled_tools(
+                        user_id=user_id_for_mcp,
+                        db_session=db
+                    )
+                    
+                    # 2️⃣ 只在有工具时才显示消息和调用
+                    if available_tools:
+                        yield await SSEResponse.send_progress("🔍 使用MCP工具收集参考资料...", 18)
+                        logger.info(f"🔍 检测到可用MCP工具，收集大纲设计参考资料...")
+                        
+                        # 构建资料收集查询
+                        planning_query = f"""你正在为小说《{project.title}》设计完整大纲。
 项目信息：
 - 主题：{data.get('theme') or project.theme}
 - 类型：{data.get('genre') or project.genre}
@@ -922,28 +964,32 @@ async def new_outline_generator(
 3. 符合世界观的情节元素和场景设计灵感

 请有针对性地查询1-2个最关键的问题。"""
-                
-                # 调用MCP增强的AI（非流式，最多2轮工具调用）
-                planning_result = await user_ai_service.generate_text_with_mcp(
-                    prompt=planning_query,
-                    user_id="system",
-                    db_session=db,
-                    enable_mcp=True,
-                    max_tool_rounds=2,
-                    tool_choice="auto",
-                    provider=None,
-                    model=None
-                )
-                
-                # 提取参考资料
-                if planning_result.get("tool_calls_made", 0) > 0:
-                    mcp_reference_materials = planning_result.get("content", "")
-                    logger.info(f"📚 MCP工具收集参考资料：{len(mcp_reference_materials)} 字符")
-                    yield await SSEResponse.send_progress(f"📚 MCP收集到参考资料 ({len(mcp_reference_materials)}字符)", 19)
+                        
+                        # 调用MCP增强的AI（非流式，限制1轮避免超时）
+                        planning_result = await user_ai_service.generate_text_with_mcp(
+                            prompt=planning_query,
+                            user_id=user_id_for_mcp,
+                            db_session=db,
+                            enable_mcp=True,
+                            max_tool_rounds=1,  # ✅ 减少为1轮，避免超时
+                            tool_choice="auto",
+                            provider=None,
+                            model=None
+                        )
+                        
+                        # 提取参考资料
+                        if planning_result.get("tool_calls_made", 0) > 0:
+                            mcp_reference_materials = planning_result.get("content", "")
+                            logger.info(f"✅ MCP工具收集参考资料：{len(mcp_reference_materials)} 字符")
+                            yield await SSEResponse.send_progress(f"✅ MCP收集到参考资料 ({len(mcp_reference_materials)}字符)", 19)
+                        else:
+                            logger.info(f"ℹ️ MCP未使用工具，继续")
+                    else:
+                        logger.debug(f"用户 {user_id_for_mcp} 未启用MCP工具，跳过MCP增强")
                else:
-                    logger.info(f"ℹ️ MCP工具未进行调用，继续正常生成")
+                    logger.debug("无用户上下文，跳过MCP增强")
            except Exception as e:
-                logger.warning(f"⚠️ MCP工具调用失败，继续使用常规模式: {str(e)}")
+                logger.warning(f"⚠️ MCP工具调用失败，降级为基础模式: {str(e)}")
                mcp_reference_materials = ""
        
        # 使用完整提示词（插入MCP参考资料）
@@ -1185,20 +1231,29 @@ async def continue_outline_generator(
            except Exception as e:
                logger.warning(f"⚠️ 记忆上下文构建失败: {str(e)}")
                memory_context = None
-            # 🔍 MCP工具增强：收集续写参考资料
+            # 🔍 MCP工具增强：收集续写参考资料（优化版）
            mcp_reference_materials = ""
            enable_mcp = data.get("enable_mcp", True)
            if enable_mcp:
                try:
-                    yield await SSEResponse.send_progress(
-                        f"🔍 第{str(batch_num + 1)}批：使用MCP工具收集参考资料...",
-                        batch_progress + 4
+                    # 1️⃣ 静默检查工具可用性
+                    from app.services.mcp_tool_service import mcp_tool_service
+                    available_tools = await mcp_tool_service.get_user_enabled_tools(
+                        user_id=user_id,
+                        db_session=db
                    )
-                    logger.info(f"🔍 第{batch_num + 1}批：尝试使用MCP工具收集续写参考资料...")
                    
-                    # 构建资料收集查询
-                    latest_summary = latest_outlines[-1].content if latest_outlines else ""
-                    planning_query = f"""你正在为小说《{project.title}》续写大纲。
+                    # 2️⃣ 只在有工具时才显示消息和调用
+                    if available_tools:
+                        yield await SSEResponse.send_progress(
+                            f"🔍 第{str(batch_num + 1)}批：使用MCP工具收集参考资料...",
+                            batch_progress + 4
+                        )
+                        logger.info(f"🔍 第{batch_num + 1}批：检测到可用MCP工具，收集续写参考资料...")
+                        
+                        # 构建资料收集查询
+                        latest_summary = latest_outlines[-1].content if latest_outlines else ""
+                        planning_query = f"""你正在为小说《{project.title}》续写大纲。
 当前进度：已有{len(latest_outlines)}章，即将续写第{current_start_chapter}-{current_start_chapter + current_batch_size - 1}章

 项目信息：
@@ -1217,31 +1272,33 @@ async def continue_outline_generator(
 3. 符合类型特点的场景设计和剧情元素

 请有针对性地查询1-2个最关键的问题。"""
-                    
-                    # 调用MCP增强的AI（非流式，最多2轮工具调用）
-                    planning_result = await user_ai_service.generate_text_with_mcp(
-                        prompt=planning_query,
-                        user_id=user_id,
-                        db_session=db,
-                        enable_mcp=True,
-                        max_tool_rounds=2,
-                        tool_choice="auto",
-                        provider=None,
-                        model=None
-                    )
-                    
-                    # 提取参考资料
-                    if planning_result.get("tool_calls_made", 0) > 0:
-                        mcp_reference_materials = planning_result.get("content", "")
-                        logger.info(f"📚 第{batch_num + 1}批MCP工具收集参考资料：{len(mcp_reference_materials)} 字符")
-                        yield await SSEResponse.send_progress(
-                            f"📚 第{str(batch_num + 1)}批收集到参考资料 ({len(mcp_reference_materials)}字符)",
-                            batch_progress + 4.5
+                        
+                        # 调用MCP增强的AI（非流式，限制1轮避免超时）
+                        planning_result = await user_ai_service.generate_text_with_mcp(
+                            prompt=planning_query,
+                            user_id=user_id,
+                            db_session=db,
+                            enable_mcp=True,
+                            max_tool_rounds=1,  # ✅ 减少为1轮，避免超时
+                            tool_choice="auto",
+                            provider=None,
+                            model=None
                        )
+                        
+                        # 提取参考资料
+                        if planning_result.get("tool_calls_made", 0) > 0:
+                            mcp_reference_materials = planning_result.get("content", "")
+                            logger.info(f"✅ 第{batch_num + 1}批MCP工具收集参考资料：{len(mcp_reference_materials)} 字符")
+                            yield await SSEResponse.send_progress(
+                                f"✅ 第{str(batch_num + 1)}批收集到参考资料 ({len(mcp_reference_materials)}字符)",
+                                batch_progress + 4.5
+                            )
+                        else:
+                            logger.info(f"ℹ️ 第{batch_num + 1}批MCP未使用工具，继续")
                    else:
-                        logger.info(f"ℹ️ 第{batch_num + 1}批MCP工具未进行调用，继续正常生成")
+                        logger.debug(f"用户 {user_id} 未启用MCP工具，跳过第{batch_num + 1}批MCP增强")
                except Exception as e:
-                    logger.warning(f"⚠️ 第{batch_num + 1}批MCP工具调用失败，继续使用常规模式: {str(e)}")
+                    logger.warning(f"⚠️ 第{batch_num + 1}批MCP工具调用失败，降级为基础模式: {str(e)}")
                    mcp_reference_materials = ""
            
            
@@ -246,6 +246,10 @@ async def world_building_generator(
        except Exception as e:
            logger.warning(f"设置默认写作风格失败: {e}，不影响项目创建")
        
+        # 更新向导步骤状态为1（世界观已完成）
+        project.wizard_step = 1
+        await db.commit()
+        
        db_committed = True
        
        # 发送最终结果
@@ -824,8 +828,9 @@ async def characters_generator(
        logger.info(f"  - 创建角色关系：{relationships_created} 条")
        logger.info(f"  - 创建组织成员：{members_created} 条")
        
-        # 更新项目的角色数量
+        # 更新项目的角色数量和向导步骤状态为2（角色已完成）
        project.character_count = len(created_characters)
+        project.wizard_step = 2
        logger.info(f"✅ 更新项目角色数量: {project.character_count}")
        
        await db.commit()
@@ -1022,7 +1027,7 @@ async def outline_generator(
        project.target_words = target_words
        project.status = "writing"
        project.wizard_status = "completed"
-        project.wizard_step = 4
+        project.wizard_step = 3 
        
        await db.commit()
        db_committed = True
@@ -1269,7 +1274,6 @@ async def regenerate_world_building_stream(
    # 从中间件注入user_id到data中
    if hasattr(request.state, 'user_id'):
        data['user_id'] = request.state.user_id
-    
    return create_sse_response(world_building_regenerate_generator(project_id, data, db, user_ai_service))