1.优化AI请求替换OpenAI SDK调用，使用httpx和自定义头请求，避免触发部分公益站的cloudflare

2.修复deepseek模型调用问题，舍弃思考过程AI响应内容，只获取结果内容
3.新增会话过期机制，更新后添加到.env中
4.支持用户在生成章节内容时设置字数

backend/.env.example

@@ -43,6 +43,12 @@ LOCAL_AUTH_PASSWORD=your_secure_password_here
 # 本地用户显示名称
 LOCAL_AUTH_DISPLAY_NAME=管理员
 
+# 会话配置
+# 会话过期时间（分钟），默认120分钟（2小时）
+SESSION_EXPIRE_MINUTES=120
+# 会话刷新阈值（分钟），剩余时间少于此值时可刷新，默认30分钟
+SESSION_REFRESH_THRESHOLD_MINUTES=30
+
 # CORS配置（生产环境）
 # 允许的跨域来源，多个用逗号分隔
 # CORS_ORIGINS=https://your-domain.com,https://www.your-domain.com

backend/app/api/auth.py

@@ -6,12 +6,20 @@ from fastapi.responses import RedirectResponse
 from pydantic import BaseModel
 from typing import Optional
 import hashlib
+from datetime import datetime, timedelta, timezone
 from app.services.oauth_service import LinuxDOOAuthService
 from app.user_manager import user_manager
 from app.database import init_db
 from app.logger import get_logger
 from app.config import settings
 
+# 中国时区 UTC+8
+CHINA_TZ = timezone(timedelta(hours=8))
+
+def get_china_now():
+    """获取中国当前时间"""
+    return datetime.now(CHINA_TZ)
+
 logger = get_logger(__name__)
 
 router = APIRouter(prefix="/auth", tags=["认证"])
@@ -84,15 +92,31 @@ async def local_login(request: LocalLoginRequest, response: Response):
     except Exception as e:
         logger.error(f"本地用户 {user.user_id} 数据库初始化失败: {e}")
     
-    # 设置 Cookie（7天有效）
+    # 设置 Cookie（2小时有效）
+    max_age = settings.SESSION_EXPIRE_MINUTES * 60
     response.set_cookie(
         key="user_id",
         value=user.user_id,
-        max_age=7 * 24 * 60 * 60,  # 7天
+        max_age=max_age,
         httponly=True,
         samesite="lax"
     )
     
+    # 设置过期时间戳 Cookie（用于前端判断）
+    china_now = get_china_now()
+    expire_time = china_now + timedelta(minutes=settings.SESSION_EXPIRE_MINUTES)
+    expire_at = int(expire_time.timestamp())
+    
+    logger.info(f"✅ [登录] 用户 {user.user_id} 登录成功，会话有效期 {settings.SESSION_EXPIRE_MINUTES} 分钟")
+    
+    response.set_cookie(
+        key="session_expire_at",
+        value=str(expire_at),
+        max_age=max_age,
+        httponly=False,  # 前端需要读取
+        samesite="lax"
+    )
+    
     return LocalLoginResponse(
         success=True,
         message="登录成功",
@@ -180,15 +204,31 @@ async def _handle_callback(
     logger.info(f"OAuth回调成功，重定向到前端: {redirect_url}")
     redirect_response = RedirectResponse(url=redirect_url)
     
-    # 设置 httponly Cookie（7天有效）
+    # 设置 httponly Cookie（2小时有效）
+    max_age = settings.SESSION_EXPIRE_MINUTES * 60
     redirect_response.set_cookie(
         key="user_id",
         value=user.user_id,
-        max_age=7 * 24 * 60 * 60,  # 7天
+        max_age=max_age,
         httponly=True,
         samesite="lax"
     )
     
+    # 设置过期时间戳 Cookie（用于前端判断）
+    china_now = get_china_now()
+    expire_time = china_now + timedelta(minutes=settings.SESSION_EXPIRE_MINUTES)
+    expire_at = int(expire_time.timestamp())
+    
+    logger.info(f"✅ [OAuth登录] 用户 {user.user_id} 登录成功，会话有效期 {settings.SESSION_EXPIRE_MINUTES} 分钟")
+    
+    redirect_response.set_cookie(
+        key="session_expire_at",
+        value=str(expire_at),
+        max_age=max_age,
+        httponly=False,  # 前端需要读取
+        samesite="lax"
+    )
+    
     return redirect_response
 
 
@@ -214,10 +254,80 @@ async def callback_alias(
     return await _handle_callback(code, state, error, response)
 
 
+@router.post("/refresh")
+async def refresh_session(request: Request, response: Response):
+    """刷新会话 - 延长登录状态"""
+    # 检查是否已登录
+    if not hasattr(request.state, "user") or not request.state.user:
+        raise HTTPException(status_code=401, detail="未登录，无法刷新会话")
+    
+    user = request.state.user
+    
+    # 检查当前会话是否即将过期（剩余时间少于阈值）
+    session_expire_at = request.cookies.get("session_expire_at")
+    if session_expire_at:
+        try:
+            expire_timestamp = int(session_expire_at)
+            current_timestamp = int(get_china_now().timestamp())
+            remaining_minutes = (expire_timestamp - current_timestamp) / 60
+            
+            # 如果剩余时间大于刷新阈值，不需要刷新
+            if remaining_minutes > settings.SESSION_REFRESH_THRESHOLD_MINUTES:
+                logger.info(f"⏱️ [刷新会话] 用户 {user.user_id} 会话仍有效，剩余 {int(remaining_minutes)} 分钟")
+                return {
+                    "message": "会话仍然有效，无需刷新",
+                    "remaining_minutes": int(remaining_minutes),
+                    "expire_at": expire_timestamp
+                }
+        except (ValueError, TypeError):
+            pass  # Cookie 格式错误，继续刷新
+    
+    # 刷新 Cookie
+    max_age = settings.SESSION_EXPIRE_MINUTES * 60
+    response.set_cookie(
+        key="user_id",
+        value=user.user_id,
+        max_age=max_age,
+        httponly=True,
+        samesite="lax"
+    )
+    
+    # 更新过期时间戳
+    china_now = get_china_now()
+    expire_time = china_now + timedelta(minutes=settings.SESSION_EXPIRE_MINUTES)
+    expire_at = int(expire_time.timestamp())
+    
+    logger.info(f"[刷新会话] 用户: {user.user_id}")
+    logger.info(f"[刷新会话] 中国当前时间: {china_now.strftime('%Y-%m-%d %H:%M:%S')} (UTC+8)")
+    logger.info(f"[刷新会话] 中国过期时间: {expire_time.strftime('%Y-%m-%d %H:%M:%S')} (UTC+8)")
+    logger.info(f"[刷新会话] 过期时间戳 (秒): {expire_at}")
+    logger.info(f"[刷新会话] Cookie max_age (秒): {max_age}")
+    
+    response.set_cookie(
+        key="session_expire_at",
+        value=str(expire_at),
+        max_age=max_age,
+        httponly=False,
+        samesite="lax"
+    )
+    
+    logger.info(f"用户 {user.user_id} 刷新会话成功")
+    return {
+        "message": "会话刷新成功",
+        "expire_at": expire_at,
+        "remaining_minutes": settings.SESSION_EXPIRE_MINUTES
+    }
+
+
 @router.post("/logout")
-async def logout(response: Response):
+async def logout(request: Request, response: Response):
     """退出登录"""
+    user_id = getattr(request.state, 'user_id', None)
+    if user_id:
+        logger.info(f"🚪 [退出] 用户 {user_id} 退出登录")
+    
     response.delete_cookie("user_id")
+    response.delete_cookie("session_expire_at")
     return {"message": "退出登录成功"}
 
 

backend/app/api/chapters.py

@@ -261,11 +261,13 @@ async def generate_chapter_content_stream(
     
     请求体参数：
     - style_id: 可选，指定使用的写作风格ID。不提供则不使用任何风格
+    - target_word_count: 可选，目标字数，默认3000字，范围500-10000字
     
     注意：此函数不使用依赖注入的db，而是在生成器内部创建独立的数据库会话
     以避免流式响应期间的连接泄漏问题
     """
     style_id = generate_request.style_id
+    target_word_count = generate_request.target_word_count or 3000
     # 预先验证章节存在性（使用临时会话）
     async for temp_db in get_db(request):
         try:
@@ -415,7 +417,8 @@ async def generate_chapter_content_stream(
                         chapter_number=current_chapter.chapter_number,
                         chapter_title=current_chapter.title,
                         chapter_outline=outline.content if outline else current_chapter.summary or '暂无大纲',
-                        style_content=style_content
+                        style_content=style_content,
+                        target_word_count=target_word_count
                     )
                 else:
                     prompt = prompt_service.get_chapter_generation_prompt(
@@ -432,7 +435,8 @@ async def generate_chapter_content_stream(
                         chapter_number=current_chapter.chapter_number,
                         chapter_title=current_chapter.title,
                         chapter_outline=outline.content if outline else current_chapter.summary or '暂无大纲',
-                        style_content=style_content
+                        style_content=style_content,
+                        target_word_count=target_word_count
                     )
                 
                 logger.info(f"开始AI流式创作章节 {chapter_id}")

backend/app/api/settings.py

@@ -6,6 +6,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from typing import Dict, Any, List
 from pathlib import Path
+from pydantic import BaseModel
 import httpx
 
 from app.database import get_db
@@ -296,4 +297,168 @@ async def get_available_models(
         raise HTTPException(
             status_code=500,
             detail=f"获取模型列表失败: {str(e)}"
-        )
+        )
+
+
+class ApiTestRequest(BaseModel):
+    """API 测试请求模型"""
+    api_key: str
+    api_base_url: str
+    provider: str
+    model_name: str
+
+
+@router.post("/test")
+async def test_api_connection(data: ApiTestRequest):
+    """
+    测试 API 连接和配置是否正确
+    
+    Args:
+        data: 包含 API 配置的请求数据
+    
+    Returns:
+        测试结果包含状态、响应时间和详细信息
+    """
+    api_key = data.api_key
+    api_base_url = data.api_base_url
+    provider = data.provider
+    model_name = data.model_name
+    import time
+    
+    try:
+        start_time = time.time()
+        
+        # 创建临时 AI 服务实例
+        test_service = AIService(
+            api_provider=provider,
+            api_key=api_key,
+            api_base_url=api_base_url,
+            default_model=model_name,
+            default_temperature=0.7,
+            default_max_tokens=100
+        )
+        
+        # 发送简单的测试请求
+        test_prompt = "请用一句话回复：测试成功"
+        
+        logger.info(f"🧪 开始测试 API 连接")
+        logger.info(f"  - 提供商: {provider}")
+        logger.info(f"  - 模型: {model_name}")
+        logger.info(f"  - Base URL: {api_base_url}")
+        
+        response = await test_service.generate_text(
+            prompt=test_prompt,
+            provider=provider,
+            model=model_name,
+            temperature=0.7,
+            max_tokens=8000
+        )
+        
+        end_time = time.time()
+        response_time = round((end_time - start_time) * 1000, 2)  # 转换为毫秒
+        
+        logger.info(f"✅ API 测试成功")
+        logger.info(f"  - 响应时间: {response_time}ms")
+        logger.info(f"  - 响应内容: {response[:100] if response else 'N/A'}")
+        
+        return {
+            "success": True,
+            "message": "API 连接测试成功",
+            "response_time_ms": response_time,
+            "provider": provider,
+            "model": model_name,
+            "response_preview": response[:100] if response and len(response) > 100 else response,
+            "details": {
+                "api_available": True,
+                "model_accessible": True,
+                "response_valid": bool(response)
+            }
+        }
+        
+    except ValueError as e:
+        # 配置错误
+        error_msg = str(e)
+        logger.error(f"❌ API 配置错误: {error_msg}")
+        return {
+            "success": False,
+            "message": "API 配置错误",
+            "error": error_msg,
+            "error_type": "ConfigurationError",
+            "suggestions": [
+                "请检查 API Key 是否正确",
+                "请确认 API Base URL 格式正确",
+                "请验证所选提供商是否匹配"
+            ]
+        }
+        
+    except TimeoutError as e:
+        # 超时错误
+        error_msg = str(e)
+        logger.error(f"❌ API 请求超时: {error_msg}")
+        return {
+            "success": False,
+            "message": "API 请求超时",
+            "error": error_msg,
+            "error_type": "TimeoutError",
+            "suggestions": [
+                "请检查网络连接",
+                "请确认 API Base URL 是否可访问",
+                "如果使用代理，请检查代理设置"
+            ]
+        }
+        
+    except Exception as e:
+        # 其他错误
+        error_msg = str(e)
+        error_type = type(e).__name__
+        
+        logger.error(f"❌ API 测试失败: {error_msg}")
+        logger.error(f"  - 错误类型: {error_type}")
+        
+        # 分析错误原因并提供建议
+        suggestions = []
+        if "blocked" in error_msg.lower():
+            suggestions = [
+                "请求被 API 提供商阻止",
+                "可能原因：API Key 被限制或地区限制",
+                "建议：检查 API Key 状态和账户余额",
+                "建议：尝试更换 API Base URL 或使用代理"
+            ]
+        elif "unauthorized" in error_msg.lower() or "401" in error_msg:
+            suggestions = [
+                "API Key 认证失败",
+                "建议：检查 API Key 是否正确",
+                "建议：确认 API Key 是否过期"
+            ]
+        elif "not found" in error_msg.lower() or "404" in error_msg:
+            suggestions = [
+                "API 端点不存在或模型不可用",
+                "建议：检查 API Base URL 是否正确",
+                "建议：确认模型名称是否正确"
+            ]
+        elif "rate limit" in error_msg.lower() or "429" in error_msg:
+            suggestions = [
+                "API 请求频率超限",
+                "建议：稍后重试",
+                "建议：升级 API 套餐"
+            ]
+        elif "insufficient" in error_msg.lower() or "quota" in error_msg.lower():
+            suggestions = [
+                "API 配额不足",
+                "建议：检查账户余额",
+                "建议：充值或升级套餐"
+            ]
+        else:
+            suggestions = [
+                "请检查所有配置参数是否正确",
+                "请确认网络连接正常",
+                "请查看详细错误信息"
+            ]
+        
+        return {
+            "success": False,
+            "message": "API 测试失败",
+            "error": error_msg,
+            "error_type": error_type,
+            "suggestions": suggestions
+        }

backend/app/api/wizard_stream.py

@@ -260,6 +260,7 @@ async def characters_generator(
             # 重试逻辑
             retry_count = 0
             batch_success = False
+            batch_error_message = ""
             
             while retry_count < MAX_RETRIES and not batch_success:
                 try:
@@ -326,37 +327,24 @@ async def characters_generator(
                     if not isinstance(characters_data, list):
                         characters_data = [characters_data]
                     
-                    # 验证生成数量是否精确
+                    # 严格验证生成数量是否精确匹配
                     if len(characters_data) != current_batch_size:
-                        logger.warning(f"批次{batch_idx+1}生成数量不匹配: 期望{current_batch_size}, 实际{len(characters_data)}")
+                        error_msg = f"批次{batch_idx+1}生成数量不正确: 期望{current_batch_size}个, 实际{len(characters_data)}个"
+                        logger.error(error_msg)
                         
-                        # 如果数量不足,重试
-                        if len(characters_data) < current_batch_size:
-                            if retry_count < MAX_RETRIES - 1:
-                                retry_count += 1
-                                yield await SSEResponse.send_progress(
-                                    f"⚠️ 生成数量不足(期望{current_batch_size},实际{len(characters_data)}),准备重试...",
-                                    batch_progress,
-                                    "warning"
-                                )
-                                continue
-                            else:
-                                # 最后一次重试仍不足，记录但继续使用
-                                logger.warning(f"批次{batch_idx+1}多次重试后仍数量不足，使用当前结果")
-                                yield await SSEResponse.send_progress(
-                                    f"⚠️ 批次{batch_idx+1}生成{len(characters_data)}个（期望{current_batch_size}），继续处理",
-                                    batch_progress,
-                                    "warning"
-                                )
-                        # 如果数量过多,只取需要的数量并发出警告
-                        else:
-                            logger.warning(f"批次{batch_idx+1}生成过多角色({len(characters_data)}>{current_batch_size}),将只取前{current_batch_size}个")
+                        # 如果还有重试机会，继续重试
+                        if retry_count < MAX_RETRIES - 1:
+                            retry_count += 1
                             yield await SSEResponse.send_progress(
-                                f"⚠️ AI生成过多，截取前{current_batch_size}个角色",
+                                f"⚠️ {error_msg}，准备重试...",
                                 batch_progress,
                                 "warning"
                             )
-                            characters_data = characters_data[:current_batch_size]
+                            continue
+                        else:
+                            # 最后一次重试仍失败，直接返回错误
+                            yield await SSEResponse.send_error(error_msg)
+                            return
                     
                     all_characters.extend(characters_data)
                     batch_success = True
@@ -364,6 +352,7 @@ async def characters_generator(
                     
                 except json.JSONDecodeError as e:
                     logger.error(f"批次{batch_idx+1}解析失败(尝试{retry_count+1}/{MAX_RETRIES}): {e}")
+                    batch_error_message = f"JSON解析失败: {str(e)}"
                     retry_count += 1
                     if retry_count < MAX_RETRIES:
                         yield await SSEResponse.send_progress(
@@ -371,14 +360,9 @@ async def characters_generator(
                             batch_progress,
                             "warning"
                         )
-                    else:
-                        yield await SSEResponse.send_progress(
-                            f"批次{batch_idx+1}多次重试失败，跳过",
-                            batch_progress,
-                            "warning"
-                        )
                 except Exception as e:
                     logger.error(f"批次{batch_idx+1}生成异常(尝试{retry_count+1}/{MAX_RETRIES}): {e}")
+                    batch_error_message = f"生成异常: {str(e)}"
                     retry_count += 1
                     if retry_count < MAX_RETRIES:
                         yield await SSEResponse.send_progress(
@@ -386,16 +370,15 @@ async def characters_generator(
                             batch_progress,
                             "warning"
                         )
-                    else:
-                        yield await SSEResponse.send_progress(
-                            f"批次{batch_idx+1}多次重试失败，跳过",
-                            batch_progress,
-                            "warning"
-                        )
-        
-        if not all_characters:
-            yield await SSEResponse.send_error("所有批次都生成失败，请重试")
-            return
+            
+            # 检查批次是否成功
+            if not batch_success:
+                error_msg = f"批次{batch_idx+1}在{MAX_RETRIES}次重试后仍然失败"
+                if batch_error_message:
+                    error_msg += f": {batch_error_message}"
+                logger.error(error_msg)
+                yield await SSEResponse.send_error(error_msg)
+                return
         
         # 保存到数据库 - 分阶段处理以保证一致性
         yield await SSEResponse.send_progress("验证角色数据...", 82)
@@ -665,6 +648,10 @@ async def characters_generator(
         logger.info(f"  - 创建角色关系：{relationships_created} 条")
         logger.info(f"  - 创建组织成员：{members_created} 条")
         
+        # 更新项目的角色数量
+        project.character_count = len(created_characters)
+        logger.info(f"✅ 更新项目角色数量: {project.character_count}")
+        
         await db.commit()
         db_committed = True
         

backend/app/config.py

@@ -78,6 +78,10 @@ class Settings(BaseSettings):
     LOCAL_AUTH_PASSWORD: Optional[str] = None  # 本地登录密码
     LOCAL_AUTH_DISPLAY_NAME: str = "本地用户"  # 本地用户显示名称
     
+    # 会话配置
+    SESSION_EXPIRE_MINUTES: int = 120  # 会话过期时间（分钟），默认2小时
+    SESSION_REFRESH_THRESHOLD_MINUTES: int = 30  # 会话刷新阈值（分钟），剩余时间少于此值时可刷新
+    
     class Config:
         env_file = ".env"
         case_sensitive = False

backend/app/schemas/chapter.py

@@ -59,4 +59,10 @@ class ChapterListResponse(BaseModel):
 
 class ChapterGenerateRequest(BaseModel):
     """AI生成章节内容的请求模型"""
-    style_id: Optional[int] = Field(None, description="写作风格ID，不提供则不使用任何风格")
+    style_id: Optional[int] = Field(None, description="写作风格ID，不提供则不使用任何风格")
+    target_word_count: Optional[int] = Field(
+        3000,
+        description="目标字数，默认3000字",
+        ge=500,   # 最小500字
+        le=10000  # 最大10000字
+    )

backend/app/services/ai_service.py

@@ -41,58 +41,7 @@ class AIService:
         # 初始化OpenAI客户端
         openai_key = api_key if api_provider == "openai" else app_settings.openai_api_key
         if openai_key:
-            # 创建自定义的httpx客户端来避免proxies参数问题
             try:
-                # 配置连接池限制，支持高并发
-                # max_keepalive_connections: 保持活跃的连接数（提高复用率）
-                # max_connections: 最大并发连接数（防止资源耗尽）
-                limits = httpx.Limits(
-                    max_keepalive_connections=50,  # 保持50个活跃连接
-                    max_connections=100,            # 最多100个并发连接
-                    keepalive_expiry=30.0          # 30秒后过期未使用的连接
-                )
-                
-                # 使用httpx.AsyncClient并设置超时和连接池
-                # connect: 连接超时10秒
-                # read: 读取超时180秒（3分钟，适合长文本生成）
-                # write: 写入超时10秒
-                # pool: 连接池超时10秒
-                http_client = httpx.AsyncClient(
-                    timeout=httpx.Timeout(
-                        connect=10.0,
-                        read=180.0,
-                        write=10.0,
-                        pool=10.0
-                    ),
-                    limits=limits
-                )
-                
-                client_kwargs = {
-                    "api_key": openai_key,
-                    "http_client": http_client
-                }
-                
-                # 优先使用用户提供的base_url，否则使用全局配置
-                base_url = api_base_url if api_provider == "openai" else app_settings.openai_base_url
-                if base_url:
-                    client_kwargs["base_url"] = base_url
-                
-                self.openai_client = AsyncOpenAI(**client_kwargs)
-                logger.info("✅ OpenAI客户端初始化成功")
-                logger.info("   - 超时设置：连接10s，读取180s")
-                logger.info("   - 连接池：50个保活连接，最大100个并发")
-            except Exception as e:
-                logger.error(f"OpenAI客户端初始化失败: {e}")
-                self.openai_client = None
-        else:
-            self.openai_client = None
-            logger.warning("OpenAI API key未配置")
-        
-        # 初始化Anthropic客户端
-        anthropic_key = api_key if api_provider == "anthropic" else app_settings.anthropic_api_key
-        if anthropic_key:
-            try:
-                # 为Anthropic设置相同的超时和连接池配置
                 limits = httpx.Limits(
                     max_keepalive_connections=50,
                     max_connections=100,
@@ -100,13 +49,56 @@ class AIService:
                 )
                 
                 http_client = httpx.AsyncClient(
-                    timeout=httpx.Timeout(
-                        connect=10.0,
-                        read=180.0,
-                        write=10.0,
-                        pool=10.0
-                    ),
-                    limits=limits
+                    timeout=httpx.Timeout(connect=60.0, read=180.0, write=60.0, pool=60.0),
+                    limits=limits,
+                    headers={
+                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+                    }
+                )
+                
+                client_kwargs = {
+                    "api_key": openai_key,
+                    "http_client": http_client
+                }
+                
+                base_url = api_base_url if api_provider == "openai" else app_settings.openai_base_url
+                if base_url:
+                    client_kwargs["base_url"] = base_url
+                
+                self.openai_client = AsyncOpenAI(**client_kwargs)
+                self.openai_http_client = http_client
+                self.openai_api_key = openai_key
+                self.openai_base_url = base_url
+                logger.info("✅ OpenAI客户端初始化成功")
+            except Exception as e:
+                logger.error(f"OpenAI客户端初始化失败: {e}")
+                self.openai_client = None
+                self.openai_http_client = None
+                self.openai_api_key = None
+                self.openai_base_url = None
+        else:
+            self.openai_client = None
+            self.openai_http_client = None
+            self.openai_api_key = None
+            self.openai_base_url = None
+            logger.warning("OpenAI API key未配置")
+        
+        # 初始化Anthropic客户端
+        anthropic_key = api_key if api_provider == "anthropic" else app_settings.anthropic_api_key
+        if anthropic_key:
+            try:
+                limits = httpx.Limits(
+                    max_keepalive_connections=50,
+                    max_connections=100,
+                    keepalive_expiry=30.0
+                )
+                
+                http_client = httpx.AsyncClient(
+                    timeout=httpx.Timeout(connect=60.0, read=180.0, write=60.0, pool=60.0),
+                    limits=limits,
+                    headers={
+                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+                    }
                 )
                 
                 client_kwargs = {
@@ -114,15 +106,12 @@ class AIService:
                     "http_client": http_client
                 }
                 
-                # 优先使用用户提供的base_url，否则使用全局配置
                 base_url = api_base_url if api_provider == "anthropic" else app_settings.anthropic_base_url
                 if base_url:
                     client_kwargs["base_url"] = base_url
                 
                 self.anthropic_client = AsyncAnthropic(**client_kwargs)
                 logger.info("✅ Anthropic客户端初始化成功")
-                logger.info("   - 超时设置：连接10s，读取180s")
-                logger.info("   - 连接池：50个保活连接，最大100个并发")
             except Exception as e:
                 logger.error(f"Anthropic客户端初始化失败: {e}")
                 self.anthropic_client = None
@@ -219,7 +208,7 @@ class AIService:
         system_prompt: Optional[str]
     ) -> str:
         """使用OpenAI生成文本"""
-        if not self.openai_client:
+        if not self.openai_http_client:
             raise ValueError("OpenAI客户端未初始化，请检查API key配置")
         
         messages = []
@@ -228,39 +217,76 @@ class AIService:
         messages.append({"role": "user", "content": prompt})
         
         try:
-            logger.info(f"🔵 开始调用OpenAI API")
+            logger.info(f"🔵 开始调用OpenAI API（直接HTTP请求）")
             logger.info(f"  - 模型: {model}")
             logger.info(f"  - 温度: {temperature}")
             logger.info(f"  - 最大tokens: {max_tokens}")
             logger.info(f"  - Prompt长度: {len(prompt)} 字符")
             logger.info(f"  - 消息数量: {len(messages)}")
             
-            response = await self.openai_client.chat.completions.create(
-                model=model,
-                messages=messages,
-                temperature=temperature,
-                max_tokens=max_tokens
-            )
+            url = f"{self.openai_base_url}/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {self.openai_api_key}",
+                "Content-Type": "application/json"
+            }
+            payload = {
+                "model": model,
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens
+            }
+            
+            logger.debug(f"  - 请求URL: {url}")
+            logger.debug(f"  - 请求头: Authorization=Bearer ***")
+            
+            response = await self.openai_http_client.post(url, headers=headers, json=payload)
+            response.raise_for_status()
+            
+            data = response.json()
             
             logger.info(f"✅ OpenAI API调用成功")
-            logger.info(f"  - 响应ID: {response.id if hasattr(response, 'id') else 'N/A'}")
-            logger.info(f"  - 选项数量: {len(response.choices)}")
+            logger.info(f"  - 响应ID: {data.get('id', 'N/A')}")
+            logger.info(f"  - 选项数量: {len(data.get('choices', []))}")
             
-            if not response.choices:
+            if not data.get('choices'):
                 logger.error("❌ OpenAI返回的choices为空")
-                return ""
+                raise ValueError("API返回的响应格式错误：choices字段为空")
             
-            content = response.choices[0].message.content
-            logger.info(f"  - 返回内容长度: {len(content) if content else 0} 字符")
+            choice = data['choices'][0]
+            message = choice.get('message', {})
+            finish_reason = choice.get('finish_reason')
+            
+            # DeepSeek R1特殊处理：只使用content（最终答案），忽略reasoning_content（思考过程）
+            # reasoning_content是AI的思考过程，不是我们需要的JSON结果
+            content = message.get('content', '')
+            
+            # 检查是否因达到长度限制而截断
+            if finish_reason == 'length':
+                logger.warning(f"⚠️  响应因达到max_tokens限制而被截断")
+                logger.warning(f"  - 当前max_tokens: {max_tokens}")
+                logger.warning(f"  - 建议: 增加max_tokens参数（推荐2000+）")
             
             if content:
+                logger.info(f"  - 返回内容长度: {len(content)} 字符")
+                logger.info(f"  - 完成原因: {finish_reason}")
                 logger.info(f"  - 返回内容预览（前200字符）: {content[:200]}")
                 return content
             else:
-                logger.error("❌ OpenAI返回了空内容")
-                logger.error(f"  - 完整响应: {response}")
-                raise ValueError("AI返回了空内容，请检查API配置或稍后重试")
+                logger.error("❌ AI返回了空内容")
+                logger.error(f"  - 完整响应: {data}")
+                logger.error(f"  - 完成原因: {finish_reason}")
+                
+                # 提供更详细的错误信息
+                if finish_reason == 'length':
+                    raise ValueError(f"AI响应被截断且无有效内容。请增加max_tokens参数（当前: {max_tokens}，建议: 2000+）")
+                else:
+                    raise ValueError(f"AI返回了空内容（finish_reason: {finish_reason}），请检查API配置或稍后重试")
             
+        except httpx.HTTPStatusError as e:
+            logger.error(f"❌ OpenAI API调用失败 (HTTP {e.response.status_code})")
+            logger.error(f"  - 错误信息: {e.response.text}")
+            logger.error(f"  - 模型: {model}")
+            raise Exception(f"API返回错误 ({e.response.status_code}): {e.response.text}")
         except Exception as e:
             logger.error(f"❌ OpenAI API调用失败")
             logger.error(f"  - 错误类型: {type(e).__name__}")
@@ -277,7 +303,7 @@ class AIService:
         system_prompt: Optional[str]
     ) -> AsyncGenerator[str, None]:
         """使用OpenAI流式生成文本"""
-        if not self.openai_client:
+        if not self.openai_http_client:
             raise ValueError("OpenAI客户端未初始化，请检查API key配置")
         
         messages = []
@@ -286,35 +312,78 @@ class AIService:
         messages.append({"role": "user", "content": prompt})
         
         try:
-            logger.info(f"🔵 开始调用OpenAI流式API")
+            logger.info(f"🔵 开始调用OpenAI流式API（直接HTTP请求）")
             logger.info(f"  - 模型: {model}")
             logger.info(f"  - Prompt长度: {len(prompt)} 字符")
             logger.info(f"  - 最大tokens: {max_tokens}")
             
-            stream = await self.openai_client.chat.completions.create(
-                model=model,
-                messages=messages,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                stream=True
-            )
+            url = f"{self.openai_base_url}/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {self.openai_api_key}",
+                "Content-Type": "application/json"
+            }
+            payload = {
+                "model": model,
+                "messages": messages,
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+                "stream": True
+            }
             
-            logger.info(f"✅ OpenAI流式API连接成功，开始接收数据...")
-            
-            chunk_count = 0
-            async for chunk in stream:
-                if chunk.choices and len(chunk.choices) > 0:
-                    if chunk.choices[0].delta.content:
-                        chunk_count += 1
-                        yield chunk.choices[0].delta.content
-            
-            logger.info(f"✅ OpenAI流式生成完成，共接收 {chunk_count} 个chunk")
+            async with self.openai_http_client.stream('POST', url, headers=headers, json=payload) as response:
+                response.raise_for_status()
+                logger.info(f"✅ OpenAI流式API连接成功，开始接收数据...")
+                
+                chunk_count = 0
+                has_content = False
+                finish_reason = None
+                
+                async for line in response.aiter_lines():
+                    if line.startswith('data: '):
+                        data_str = line[6:]
+                        if data_str.strip() == '[DONE]':
+                            break
+                        
+                        try:
+                            import json
+                            data = json.loads(data_str)
+                            if 'choices' in data and len(data['choices']) > 0:
+                                choice = data['choices'][0]
+                                delta = choice.get('delta', {})
+                                finish_reason = choice.get('finish_reason') or finish_reason
+                                
+                                # DeepSeek R1特殊处理：只收集content（最终答案），忽略reasoning_content（思考过程）
+                                # reasoning_content是AI的思考过程，不是我们需要的JSON结果
+                                content = delta.get('content', '')
+                                
+                                if content:
+                                    chunk_count += 1
+                                    has_content = True
+                                    yield content
+                        except json.JSONDecodeError:
+                            continue
+                
+                # 检查是否因长度限制截断
+                if finish_reason == 'length':
+                    logger.warning(f"⚠️  流式响应因达到max_tokens限制而被截断")
+                    logger.warning(f"  - 当前max_tokens: {max_tokens}")
+                    logger.warning(f"  - 建议: 增加max_tokens参数（推荐2000+）")
+                
+                if not has_content:
+                    logger.warning(f"⚠️  流式响应未返回任何内容")
+                    logger.warning(f"  - 完成原因: {finish_reason}")
+                
+                logger.info(f"✅ OpenAI流式生成完成，共接收 {chunk_count} 个chunk，完成原因: {finish_reason}")
             
         except httpx.TimeoutException as e:
             logger.error(f"❌ OpenAI流式API超时")
             logger.error(f"  - 错误: {str(e)}")
             logger.error(f"  - 提示: 请检查网络连接或考虑缩短prompt长度")
             raise TimeoutError(f"AI服务超时（180秒），请稍后重试或减少上下文长度") from e
+        except httpx.HTTPStatusError as e:
+            logger.error(f"❌ OpenAI流式API调用失败 (HTTP {e.response.status_code})")
+            logger.error(f"  - 错误信息: {await e.response.aread()}")
+            raise
         except Exception as e:
             logger.error(f"❌ OpenAI流式API调用失败: {str(e)}")
             logger.error(f"  - 错误类型: {type(e).__name__}")
@@ -389,7 +458,7 @@ class AIService:
             raise
 
 
-# 创建全局AI服务实例（使用环境变量配置，用于向后兼容）
+# 创建全局AI服务实例
 ai_service = AIService()
 
 

backend/app/services/prompt_service.py

@@ -460,7 +460,7 @@ class PromptService:
 3. 符合角色性格设定
 4. 体现世界观特色
 5. 使用{narrative_perspective}视角
-6. 字数不得低于3000字
+6. 字数要求：不得低于{target_word_count}字
 7. 语言自然流畅，避免AI痕迹
 
 请直接输出章节正文内容，不要包含章节标题和其他说明文字。"""
@@ -513,7 +513,7 @@ class PromptService:
 
 4. **写作风格**：
 - 使用{narrative_perspective}视角
-- 字数不得低于3000字
+- 字数要求：不得低于{target_word_count}字
 - 语言自然流畅，避免AI痕迹
 - 体现世界观特色
 
@@ -741,16 +741,18 @@ class PromptService:
     
     @classmethod
     def get_chapter_generation_prompt(cls, title: str, theme: str, genre: str,
-                                     narrative_perspective: str, time_period: str,
-                                     location: str, atmosphere: str, rules: str,
-                                     characters_info: str, outlines_context: str,
-                                     chapter_number: int, chapter_title: str,
-                                     chapter_outline: str, style_content: str = "") -> str:
+                                      narrative_perspective: str, time_period: str,
+                                      location: str, atmosphere: str, rules: str,
+                                      characters_info: str, outlines_context: str,
+                                      chapter_number: int, chapter_title: str,
+                                      chapter_outline: str, style_content: str = "",
+                                      target_word_count: int = 3000) -> str:
         """
         获取章节完整创作提示词
         
         Args:
             style_content: 写作风格要求内容，如果提供则会追加到提示词中
+            target_word_count: 目标字数，默认3000字
         """
         base_prompt = cls.format_prompt(
             cls.CHAPTER_GENERATION,
@@ -766,7 +768,8 @@ class PromptService:
             outlines_context=outlines_context,
             chapter_number=chapter_number,
             chapter_title=chapter_title,
-            chapter_outline=chapter_outline
+            chapter_outline=chapter_outline,
+            target_word_count=target_word_count
         )
         
         # 如果有风格要求，应用到提示词中
@@ -782,12 +785,14 @@ class PromptService:
                                                    characters_info: str, outlines_context: str,
                                                    previous_content: str, chapter_number: int,
                                                    chapter_title: str, chapter_outline: str,
-                                                   style_content: str = "") -> str:
+                                                   style_content: str = "",
+                                                   target_word_count: int = 3000) -> str:
         """
         获取章节完整创作提示词（带前置章节上下文）
         
         Args:
             style_content: 写作风格要求内容，如果提供则会追加到提示词中
+            target_word_count: 目标字数，默认3000字
         """
         base_prompt = cls.format_prompt(
             cls.CHAPTER_GENERATION_WITH_CONTEXT,
@@ -804,7 +809,8 @@ class PromptService:
             previous_content=previous_content,
             chapter_number=chapter_number,
             chapter_title=chapter_title,
-            chapter_outline=chapter_outline
+            chapter_outline=chapter_outline,
+            target_word_count=target_word_count
         )
         
         # 如果有风格要求，应用到提示词中