Upload 26 files

Dockerfile

@@ -32,9 +32,6 @@ COPY . .
 RUN mkdir -p /app/logs /app/data/temp && \
     echo '{"ssoNormal": {}, "ssoSuper": {}}' > /app/data/token.json
 
-RUN chmod -R 777 /app
+EXPOSE 8000
 
-
-EXPOSE 7860
-
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

app/api/admin/manage.py

@@ -24,6 +24,8 @@ router = APIRouter(tags=["管理"])
 # 常量定义
 STATIC_DIR = Path(__file__).parents[2] / "template"
 TEMP_DIR = Path(__file__).parents[3] / "data" / "temp"
+IMAGE_CACHE_DIR = TEMP_DIR / "image"
+VIDEO_CACHE_DIR = TEMP_DIR / "video"
 SESSION_EXPIRE_HOURS = 24
 BYTES_PER_KB = 1024
 BYTES_PER_MB = 1024 * 1024
@@ -250,7 +252,7 @@ async def admin_login(request: LoginRequest) -> LoginResponse:
 
 
 @router.post("/api/logout")
-async def admin_logout(authenticated: bool = Depends(verify_admin_session),
+async def admin_logout(_: bool = Depends(verify_admin_session),
                        authorization: Optional[str] = Header(None)) -> Dict[str, Any]:
     """
     管理员登出
@@ -277,7 +279,7 @@ async def admin_logout(authenticated: bool = Depends(verify_admin_session),
 
 
 @router.get("/api/tokens", response_model=TokenListResponse)
-async def list_tokens(authenticated: bool = Depends(verify_admin_session)) -> TokenListResponse:
+async def list_tokens(_: bool = Depends(verify_admin_session)) -> TokenListResponse:
     """
     获取所有Token列表
     
@@ -335,7 +337,7 @@ async def list_tokens(authenticated: bool = Depends(verify_admin_session)) -> To
 
 @router.post("/api/tokens/add")
 async def add_tokens(request: AddTokensRequest,
-                    authenticated: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+                    _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
     """
     批量添加Token
     
@@ -370,7 +372,7 @@ async def add_tokens(request: AddTokensRequest,
 
 @router.post("/api/tokens/delete")
 async def delete_tokens(request: DeleteTokensRequest,
-                       authenticated: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+                       _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
     """
     批量删除Token
     
@@ -404,7 +406,7 @@ async def delete_tokens(request: DeleteTokensRequest,
 
 
 @router.get("/api/settings")
-async def get_settings(authenticated: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+async def get_settings(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
     """获取全局配置"""
     try:
         logger.debug("[Admin] 获取全局配置")
@@ -426,8 +428,15 @@ class UpdateSettingsRequest(BaseModel):
     grok_config: Optional[Dict[str, Any]] = None
 
 
+class StreamTimeoutSettings(BaseModel):
+    """流式超时配置"""
+    stream_chunk_timeout: int = 120
+    stream_first_response_timeout: int = 30
+    stream_total_timeout: int = 600
+
+
 @router.post("/api/settings")
-async def update_settings(request: UpdateSettingsRequest, authenticated: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+async def update_settings(request: UpdateSettingsRequest, _: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
     """更新全局配置"""
     try:
         import toml
@@ -482,21 +491,37 @@ def _format_size(size_bytes: int) -> str:
 
 
 @router.get("/api/cache/size")
-async def get_cache_size(authenticated: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+async def get_cache_size(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
     """获取缓存大小"""
     try:
         logger.debug("[Admin] 开始获取缓存大小")
 
-        if not TEMP_DIR.exists():
-            logger.warning(f"[Admin] 缓存目录不存在: {TEMP_DIR}")
-            return {"success": True, "data": {"size": "0 MB"}}
-
-        # 计算目录大小
-        total_size = _calculate_dir_size(TEMP_DIR)
-        size_str = _format_size(total_size)
-
-        logger.debug(f"[Admin] 缓存大小获取完成 - 大小: {size_str}")
-        return {"success": True, "data": {"size": size_str}}
+        # 计算图片缓存大小
+        image_size = 0
+        if IMAGE_CACHE_DIR.exists():
+            image_size = _calculate_dir_size(IMAGE_CACHE_DIR)
+        
+        # 计算视频缓存大小
+        video_size = 0
+        if VIDEO_CACHE_DIR.exists():
+            video_size = _calculate_dir_size(VIDEO_CACHE_DIR)
+        
+        # 总大小
+        total_size = image_size + video_size
+
+        logger.debug(f"[Admin] 缓存大小获取完成 - 图片: {_format_size(image_size)}, 视频: {_format_size(video_size)}, 总计: {_format_size(total_size)}")
+        
+        return {
+            "success": True,
+            "data": {
+                "image_size": _format_size(image_size),
+                "video_size": _format_size(video_size),
+                "total_size": _format_size(total_size),
+                "image_size_bytes": image_size,
+                "video_size_bytes": video_size,
+                "total_size_bytes": total_size
+            }
+        }
 
     except Exception as e:
         logger.error(f"[Admin] 获取缓存大小异常 - 错误: {str(e)}")
@@ -507,35 +532,50 @@ async def get_cache_size(authenticated: bool = Depends(verify_admin_session)) ->
 
 
 @router.post("/api/cache/clear")
-async def clear_cache(authenticated: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
-    """清理缓存 - 删除所有临���文件"""
+async def clear_cache(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """清理缓存
+
+    删除所有临时文件"""
     try:
         logger.debug("[Admin] 开始清理缓存")
 
-        if not TEMP_DIR.exists():
-            logger.warning(f"[Admin] 缓存目录不存在: {TEMP_DIR}")
-            return {
-                "success": True,
-                "message": "缓存目录不存在，无需清理",
-                "data": {"deleted_count": 0}
-            }
-
-        # 删除所有文件
         deleted_count = 0
-        for file_path in TEMP_DIR.iterdir():
-            if file_path.is_file():
-                try:
-                    file_path.unlink()
-                    deleted_count += 1
-                    logger.debug(f"[Admin] 删除缓存文件: {file_path.name}")
-                except Exception as e:
-                    logger.error(f"[Admin] 删除缓存文件失败: {file_path.name}, 错误: {str(e)}")
-
-        logger.debug(f"[Admin] 缓存清理完成 - 删除文件数量: {deleted_count}")
+        image_count = 0
+        video_count = 0
+
+        # 清理图片缓存
+        if IMAGE_CACHE_DIR.exists():
+            for file_path in IMAGE_CACHE_DIR.iterdir():
+                if file_path.is_file():
+                    try:
+                        file_path.unlink()
+                        image_count += 1
+                        logger.debug(f"[Admin] 删除图片缓存: {file_path.name}")
+                    except Exception as e:
+                        logger.error(f"[Admin] 删除图片缓存失败: {file_path.name}, 错误: {str(e)}")
+
+        # 清理视频缓存
+        if VIDEO_CACHE_DIR.exists():
+            for file_path in VIDEO_CACHE_DIR.iterdir():
+                if file_path.is_file():
+                    try:
+                        file_path.unlink()
+                        video_count += 1
+                        logger.debug(f"[Admin] 删除视频缓存: {file_path.name}")
+                    except Exception as e:
+                        logger.error(f"[Admin] 删除视频缓存失败: {file_path.name}, 错误: {str(e)}")
+
+        deleted_count = image_count + video_count
+        logger.debug(f"[Admin] 缓存清理完成 - 图片: {image_count}, 视频: {video_count}, 总计: {deleted_count}")
+
         return {
             "success": True,
-            "message": f"成功清理缓存，删除 {deleted_count} 个文件",
-            "data": {"deleted_count": deleted_count}
+            "message": f"成功清理缓存，删除图片 {image_count} 个，视频 {video_count} 个，共 {deleted_count} 个文件",
+            "data": {
+                "deleted_count": deleted_count,
+                "image_count": image_count,
+                "video_count": video_count
+            }
         }
 
     except Exception as e:
@@ -546,8 +586,88 @@ async def clear_cache(authenticated: bool = Depends(verify_admin_session)) -> Di
         )
 
 
+@router.post("/api/cache/clear/images")
+async def clear_image_cache(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """清理图片缓存
+
+    仅删除图片缓存文件"""
+    try:
+        logger.debug("[Admin] 开始清理图片缓存")
+
+        deleted_count = 0
+
+        # 清理图片缓存
+        if IMAGE_CACHE_DIR.exists():
+            for file_path in IMAGE_CACHE_DIR.iterdir():
+                if file_path.is_file():
+                    try:
+                        file_path.unlink()
+                        deleted_count += 1
+                        logger.debug(f"[Admin] 删除图片缓存: {file_path.name}")
+                    except Exception as e:
+                        logger.error(f"[Admin] 删除图片缓存失败: {file_path.name}, 错误: {str(e)}")
+
+        logger.debug(f"[Admin] 图片缓存清理完成 - 删除 {deleted_count} 个文件")
+
+        return {
+            "success": True,
+            "message": f"成功清理图片缓存，删除 {deleted_count} 个文件",
+            "data": {
+                "deleted_count": deleted_count,
+                "type": "images"
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"[Admin] 清理图片缓存异常 - 错误: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail={"error": f"清理图片缓存失败: {str(e)}", "code": "IMAGE_CACHE_CLEAR_ERROR"}
+        )
+
+
+@router.post("/api/cache/clear/videos")
+async def clear_video_cache(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+    """清理视频缓存
+
+    仅删除视频缓存文件"""
+    try:
+        logger.debug("[Admin] 开始清理视频缓存")
+
+        deleted_count = 0
+
+        # 清理视频缓存
+        if VIDEO_CACHE_DIR.exists():
+            for file_path in VIDEO_CACHE_DIR.iterdir():
+                if file_path.is_file():
+                    try:
+                        file_path.unlink()
+                        deleted_count += 1
+                        logger.debug(f"[Admin] 删除视频缓存: {file_path.name}")
+                    except Exception as e:
+                        logger.error(f"[Admin] 删除视频缓存失败: {file_path.name}, 错误: {str(e)}")
+
+        logger.debug(f"[Admin] 视频缓存清理完成 - 删除 {deleted_count} 个文件")
+
+        return {
+            "success": True,
+            "message": f"成功清理视频缓存，删除 {deleted_count} 个文件",
+            "data": {
+                "deleted_count": deleted_count,
+                "type": "videos"
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"[Admin] 清理视频缓存异常 - 错误: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail={"error": f"清理视频缓存失败: {str(e)}", "code": "VIDEO_CACHE_CLEAR_ERROR"}
+        )
+
+
 @router.get("/api/stats")
-async def get_stats(authenticated: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
+async def get_stats(_: bool = Depends(verify_admin_session)) -> Dict[str, Any]:
     """
     获取统计信息
 

app/api/v1/chat.py

@@ -22,21 +22,21 @@ router = APIRouter(prefix="/chat", tags=["聊天"])
 @router.post("/completions", response_model=None)
 async def chat_completions(
     request: OpenAIChatRequest,
-    authenticated: Optional[str] = Depends(auth_manager.verify)
+    _: Optional[str] = Depends(auth_manager.verify)
 ):
     """
     创建聊天补全
-    
+
     兼容OpenAI聊天API的端点，支持流式和非流式响应。
-    
+
     Args:
         request: OpenAI格式的聊天请求
-        authenticated: 认证状态（由依赖注入）
-        
+        _: 认证依赖（自动验证）
+
     Returns:
         OpenAIChatCompletionResponse: 非流式响应
         StreamingResponse: 流式响应
-        
+
     Raises:
         HTTPException: 当请求处理失败时
     """
@@ -62,7 +62,7 @@ async def chat_completions(
         return result
         
     except GrokApiException as e:
-        logger.error(f"[Chat] Grok API错误: {str(e)}", extra={"details": e.details})
+        logger.error(f"[Chat] Grok API错误: {str(e)} - 详情: {e.details}")
         raise HTTPException(
             status_code=500,
             detail={
@@ -74,7 +74,7 @@ async def chat_completions(
             }
         )
     except Exception as e:
-        logger.error(f"[Chat] 聊天请求处理失败: {str(e)}", exc_info=True)
+        logger.error(f"[Chat] 聊天请求处理失败: {str(e)}")
         raise HTTPException(
             status_code=500,
             detail={

app/api/v1/images.py

@@ -4,7 +4,7 @@ from fastapi import APIRouter, HTTPException
 from fastapi.responses import FileResponse
 
 from app.core.logger import logger
-from app.services.grok.image_cache import image_cache_service
+from app.services.grok.cache import image_cache_service, video_cache_service
 
 
 router = APIRouter()
@@ -12,38 +12,47 @@ router = APIRouter()
 
 @router.get("/images/{img_path:path}")
 async def get_image(img_path: str):
-    """获取缓存的图片
+    """获取缓存的图片或视频
 
     Args:
-        img_path: 图片路径，格式如 users-xxx-generated-xxx-image.jpg
+        img_path: 文件路径，格式如 users-xxx-generated-xxx-image.jpg 或 users-xxx-generated-xxx-video.mp4
 
     Returns:
-        图片文件响应
+        文件响应
     """
     try:
         # 将路径转换回原始格式（短横线转斜杠）
         original_path = "/" + img_path.replace('-', '/')
 
-        # 检查缓存是否存在
-        cache_path = image_cache_service.get_cached_image(original_path)
+        # 判断是图片还是视频
+        is_video = any(original_path.lower().endswith(ext) for ext in ['.mp4', '.webm', '.mov', '.avi'])
+        
+        if is_video:
+            # 检查视频缓存
+            cache_path = video_cache_service.get_cached_video(original_path)
+            media_type = "video/mp4"
+        else:
+            # 检查图片缓存
+            cache_path = image_cache_service.get_cached_image(original_path)
+            media_type = "image/jpeg"
 
         if cache_path and cache_path.exists():
-            logger.debug(f"[ImageAPI] 返回缓存图片: {cache_path}")
+            logger.debug(f"[MediaAPI] 返回缓存文件: {cache_path}")
             return FileResponse(
                 path=str(cache_path),
-                media_type="image/jpeg",
+                media_type=media_type,
                 headers={
                     "Cache-Control": "public, max-age=86400",
                     "Access-Control-Allow-Origin": "*"
                 }
             )
 
-        # 图片不存在
-        logger.warning(f"[ImageAPI] 图片未找到: {original_path}")
-        raise HTTPException(status_code=404, detail="Image not found")
+        # 文件不存在
+        logger.warning(f"[MediaAPI] 文件未找到: {original_path}")
+        raise HTTPException(status_code=404, detail="File not found")
 
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"[ImageAPI] 获取图片失败: {e}")
+        logger.error(f"[MediaAPI] 获取文件失败: {e}")
         raise HTTPException(status_code=500, detail=str(e))

app/api/v1/models.py

@@ -19,15 +19,15 @@ router = APIRouter(tags=["模型"])
 
 
 @router.get("/models")
-async def list_models(authenticated: Optional[str] = Depends(auth_manager.verify)) -> Dict[str, Any]:
+async def list_models(_: Optional[str] = Depends(auth_manager.verify)) -> Dict[str, Any]:
     """
     获取可用模型列表
-    
+
     返回 OpenAI 兼容的模型列表格式，包含系统支持的所有 Grok 模型的详细信息。
-    
+
     Args:
-        authenticated: 认证状态（由依赖注入）
-    
+        _: 认证依赖（自动验证）
+
     Returns:
         Dict[str, Any]: 包含模型列表的响应数据
     """
@@ -85,14 +85,14 @@ async def list_models(authenticated: Optional[str] = Depends(auth_manager.verify
 
 
 @router.get("/models/{model_id}")
-async def get_model(model_id: str, authenticated: Optional[str] = Depends(auth_manager.verify)) -> Dict[str, Any]:
+async def get_model(model_id: str, _: Optional[str] = Depends(auth_manager.verify)) -> Dict[str, Any]:
     """
     获取特定模型信息
-    
+
     Args:
         model_id (str): 模型ID
-        authenticated: 认证状态（由依赖注入）
-        
+        _: 认证依赖（自动验证）
+
     Returns:
         Dict[str, Any]: 模型详细信息
     """

app/core/exception.py

@@ -101,7 +101,7 @@ async def grok_api_exception_handler(_: Request, exc: GrokApiException) -> JSONR
     )
 
 
-async def global_exception_handler(_: Request) -> JSONResponse:
+async def global_exception_handler(_: Request, exc: Exception) -> JSONResponse:
     """处理未捕获异常"""
     return JSONResponse(
         status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,

app/models/grok_models.py

@@ -66,6 +66,20 @@ _MODEL_CONFIG = {
             "default_max_output_tokens": 65536,
             "supported_max_output_tokens": 131072,
             "default_top_p": 0.95
+        },
+        "grok-imagine-0.9": {
+            "grok_model": ("grok-3", "MODEL_MODE_FAST"),
+            "rate_limit_model": "grok-3",
+            "cost": {"type": "low_cost", "multiplier": 1, "description": "计1次调用"},
+            "requires_super": False,
+            "display_name": "Grok Imagine 0.9",
+            "description": "Video generation model powered by Grok",
+            "raw_model_path": "xai/grok-imagine-0.9",
+            "default_temperature": 1.0,
+            "default_max_output_tokens": 8192,
+            "supported_max_output_tokens": 131072,
+            "default_top_p": 0.95,
+            "is_video_model": True
         }
     }
 
@@ -82,6 +96,7 @@ class Models(Enum):
     GROK_4_FAST_EXPERT = "grok-4-fast-expert"
     GROK_4_EXPERT = "grok-4-expert"
     GROK_4_HEAVY = "grok-4-heavy"
+    GROK_IMAGINE_0_9 = "grok-imagine-0.9"
 
     @classmethod
     def get_model_info(cls, model: str) -> dict:

app/models/openai_schema.py

@@ -15,8 +15,8 @@ class OpenAIChatRequest(BaseModel):
     max_tokens: Optional[int] = Field(None, ge=1, le=100000, description="最大Token数")
     top_p: Optional[float] = Field(1.0, ge=0, le=1, description="采样参数")
 
-    @field_validator('messages')
     @classmethod
+    @field_validator('messages')
     def validate_messages(cls, v):
         """验证消息格式"""
         if not v:
@@ -49,13 +49,13 @@ class OpenAIChatRequest(BaseModel):
 
         return v
 
-    @field_validator('model')
     @classmethod
+    @field_validator('model')
     def validate_model(cls, v):
         """验证模型名称"""
         allowed_models = [
             'grok-3-fast', 'grok-4-fast', 'grok-4-fast-expert',
-            'grok-4-expert', 'grok-4-heavy'
+            'grok-4-expert', 'grok-4-heavy', 'grok-imagine-0.9'
         ]
         if v not in allowed_models:
             raise HTTPException(
@@ -68,16 +68,16 @@ class OpenAIChatCompletionMessage(BaseModel):
     """聊天完成消息"""
     role: str = Field(..., description="角色")
     content: str = Field(..., description="消息内容")
-    reference_id: Optional[str] = Field(None, description="参考ID")
-    annotations: Optional[List[str]] = Field(None, description="注释")
+    reference_id: Optional[str] = Field(default=None, description="参考ID")
+    annotations: Optional[List[str]] = Field(default=None, description="注释")
 
 
 class OpenAIChatCompletionChoice(BaseModel):
     """聊天完成选项"""
     index: int = Field(..., description="选项索引")
     message: OpenAIChatCompletionMessage = Field(..., description="响应消息")
-    logprobs: Optional[float] = Field(None, description="对数概率")
-    finish_reason: str = Field("stop", description="完成原因")
+    logprobs: Optional[float] = Field(default=None, description="对数概率")
+    finish_reason: str = Field(default="stop", description="完成原因")
 
 
 class OpenAIChatCompletionResponse(BaseModel):
@@ -108,8 +108,8 @@ class OpenAIChatCompletionChunkChoice(BaseModel):
 class OpenAIChatCompletionChunkResponse(BaseModel):
     """流式聊天完成响应"""
     id: str = Field(..., description="响应ID")
-    object: str = Field("chat.completion.chunk", description="对象类型")
+    object: str = Field(default="chat.completion.chunk", description="对象类型")
     created: int = Field(..., description="创建时间戳")
     model: str = Field(..., description="使用的模型")
-    system_fingerprint: Optional[str] = Field(None, description="系统指纹")
+    system_fingerprint: Optional[str] = Field(default=None, description="系统指纹")
     choices: List[OpenAIChatCompletionChunkChoice] = Field(..., description="响应选项")

app/services/grok/cache.py

@@ -0,0 +1,216 @@
+"""缓存服务模块"""
+
+import asyncio
+from pathlib import Path
+from typing import Optional
+from curl_cffi.requests import AsyncSession
+
+from app.core.config import setting
+from app.core.logger import logger
+from app.services.grok.statsig import get_dynamic_headers
+
+
+class CacheService:
+    """缓存服务基类"""
+
+    def __init__(self, cache_type: str):
+        """初始化缓存服务"""
+        self.cache_type = cache_type
+        self.cache_dir = Path(f"data/temp/{cache_type}")
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    @staticmethod
+    def _get_cache_filename(file_path: str) -> str:
+        """将文件路径转换为缓存文件名"""
+        filename = file_path.lstrip('/').replace('/', '-')
+        return filename
+
+    def _get_cache_path(self, file_path: str) -> Path:
+        """获取缓存文件的完整路径"""
+        filename = self._get_cache_filename(file_path)
+        return self.cache_dir / filename
+
+    async def download_file(self, file_path: str, auth_token: str, timeout: float = 30.0) -> Optional[Path]:
+        """下载并缓存文件
+
+        Args:
+            file_path: 文件路径，如 /users/xxx/generated/xxx/file.jpg
+            auth_token: 认证令牌
+            timeout: 下载超时时间（秒）
+
+        Returns:
+            缓存文件路径，下载失败返回 None
+        """
+        cache_path = self._get_cache_path(file_path)
+
+        if cache_path.exists():
+            logger.debug(f"[{self.cache_type.upper()}Cache] 文件已缓存: {cache_path}")
+            return cache_path
+
+        file_url = f"https://assets.grok.com{file_path}"
+
+        try:
+            # 构建 Cookie
+            cf_clearance = setting.grok_config.get("cf_clearance", "")
+            cookie = f"{auth_token};{cf_clearance}" if cf_clearance else auth_token
+
+            # 构建请求头
+            headers = {
+                **get_dynamic_headers(pathname=file_path),
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+                "Sec-Fetch-Dest": "document",
+                "Sec-Fetch-Mode": "navigate",
+                "Sec-Fetch-Site": "same-site",
+                "Sec-Fetch-User": "?1",
+                "Upgrade-Insecure-Requests": "1",
+                "Referer": "https://grok.com/",
+                "Cookie": cookie
+            }
+
+            # 代理配置
+            proxy_url = setting.grok_config.get("proxy_url")
+            proxies = {"http": proxy_url, "https": proxy_url} if proxy_url else {}
+
+            async with AsyncSession() as session:
+                logger.debug(f"[{self.cache_type.upper()}Cache] 开始下载: {file_url}")
+                response = await session.get(
+                    file_url,
+                    headers=headers,
+                    proxies=proxies,
+                    timeout=timeout,
+                    allow_redirects=True,
+                    impersonate="chrome133a"
+                )
+                response.raise_for_status()
+
+                cache_path.write_bytes(response.content)
+                logger.debug(f"[{self.cache_type.upper()}Cache] 文件已缓存: {cache_path} ({len(response.content)} bytes)")
+
+                asyncio.create_task(self.cleanup_cache())
+
+                return cache_path
+
+        except Exception as e:
+            logger.error(f"[{self.cache_type.upper()}Cache] 下载文件失败: {e}")
+            return None
+
+    def get_cached_file(self, file_path: str) -> Optional[Path]:
+        """获取缓存的文件路径
+
+        Args:
+            file_path: 文件路径
+
+        Returns:
+            缓存文件路径，不存在返回 None
+        """
+        cache_path = self._get_cache_path(file_path)
+        return cache_path if cache_path.exists() else None
+
+    async def cleanup_cache(self):
+        """清理缓存目录，确保不超过配置的大小限制"""
+        try:
+            # 获取配置的最大缓存大小
+            config_key = f"{self.cache_type}_cache_max_size_mb"
+            max_size_mb = setting.global_config.get(config_key, 500)
+            max_size_bytes = max_size_mb * 1024 * 1024
+
+            # 获取缓存大小和修改时间
+            files = []
+            total_size = 0
+
+            for file_path in self.cache_dir.glob("*"):
+                if file_path.is_file():
+                    size = file_path.stat().st_size
+                    mtime = file_path.stat().st_mtime
+                    files.append((file_path, size, mtime))
+                    total_size += size
+
+            # 如果总大小未超限，无需清理
+            if total_size <= max_size_bytes:
+                logger.debug(f"[{self.cache_type.upper()}Cache] 缓存大小 {total_size / 1024 / 1024:.2f}MB，未超限")
+                return
+
+            logger.info(f"[{self.cache_type.upper()}Cache] 缓存大小 {total_size / 1024 / 1024:.2f}MB 超过限制 {max_size_mb}MB，开始清理")
+
+            # 按修改时间排序
+            files.sort(key=lambda x: x[2])
+
+            # 删除文件直到总大小低于限制
+            for file_path, size, _ in files:
+                if total_size <= max_size_bytes:
+                    break
+
+                file_path.unlink()
+                total_size -= size
+                logger.debug(f"[{self.cache_type.upper()}Cache] 已删除缓存文件: {file_path}")
+
+            logger.info(f"[{self.cache_type.upper()}Cache] 缓存清理完成，当前大小 {total_size / 1024 / 1024:.2f}MB")
+
+        except Exception as e:
+            logger.error(f"[{self.cache_type.upper()}Cache] 清理缓存失败: {e}")
+
+
+class ImageCacheService(CacheService):
+    """图片缓存服务"""
+
+    def __init__(self):
+        super().__init__("image")
+
+    async def download_image(self, image_path: str, auth_token: str) -> Optional[Path]:
+        """下载并缓存图片
+
+        Args:
+            image_path: 图片路径，如 /users/xxx/generated/xxx/image.jpg
+            auth_token: 认证令牌
+
+        Returns:
+            缓存文件路径，下载失败返回 None`
+        """
+        return await self.download_file(image_path, auth_token, timeout=30.0)
+
+    def get_cached_image(self, image_path: str) -> Optional[Path]:
+        """获取缓存的图片路径
+
+        Args:
+            image_path: 图片路径
+
+        Returns:
+            缓存文件路径，不存在返回 None
+        """
+        return self.get_cached_file(image_path)
+
+
+class VideoCacheService(CacheService):
+    """视频缓存服务"""
+
+    def __init__(self):
+        super().__init__("video")
+
+    async def download_video(self, video_path: str, auth_token: str) -> Optional[Path]:
+        """下载并缓存视频
+
+        Args:
+            video_path: 视频路径，如 /users/xxx/generated/xxx/video.mp4
+            auth_token: 认证令牌
+
+        Returns:
+            缓存文件路径，下载失败返回 None
+        """
+        return await self.download_file(video_path, auth_token, timeout=60.0)
+
+    def get_cached_video(self, video_path: str) -> Optional[Path]:
+        """获取缓存的视频路径
+
+        Args:
+            video_path: 视频路径
+
+        Returns:
+            缓存文件路径，不存在返回 None
+        """
+        return self.get_cached_file(video_path)
+
+
+# 全局实例
+image_cache_service = ImageCacheService()
+video_cache_service = VideoCacheService()
+

app/services/grok/client.py

@@ -3,6 +3,7 @@
 import asyncio
 import json
 from typing import Dict, List, Tuple, Any
+
 from curl_cffi import requests as curl_requests
 
 from app.core.config import setting
@@ -39,11 +40,24 @@ class GrokClient:
         auth_token = token_manager.get_token(model)
         model_name, model_mode = Models.to_grok(model)
 
+        # 检查是否为视频模型
+        is_video_model = Models.get_model_info(model).get("is_video_model", False)
+        
+        # 视频模型特殊处理：只允许一张图片
+        if is_video_model and len(image_urls) > 1:
+            logger.warning(f"[Client] 视频模型只允许一张图片，当前有{len(image_urls)}张，只使用第一张")
+            image_urls = image_urls[:1]
+        
         # 上传图片并获取附件ID列表
         image_attachments = await GrokClient._upload_imgs(image_urls, auth_token)
 
+        # 视频模型：文本添加 --mode=custom
+        if is_video_model:
+            content = f"{content} --mode=custom"
+            logger.debug(f"[Client] 视频模型文本处理: {content}")
+
         # 构建Grok请求载荷
-        payload = GrokClient._build_payload(content, model_name, model_mode, image_attachments)
+        payload = GrokClient._build_payload(content, model_name, model_mode, image_attachments, is_video_model)
 
         return await GrokClient._send_request(payload, auth_token, model, stream)
 
@@ -89,9 +103,9 @@ class GrokClient:
         return image_attachments
 
     @staticmethod
-    def _build_payload(content: str, model_name: str, model_mode: str, image_attachments: List[str]) -> Dict[str, Any]:
+    def _build_payload(content: str, model_name: str, model_mode: str, image_attachments: List[str], is_video_model: bool = False) -> Dict[str, Any]:
         """构建Grok API请求载荷"""
-        return {
+        payload = {
             "temporary": setting.grok_config.get("temporary", True),
             "modelName": model_name,
             "message": content,
@@ -116,6 +130,13 @@ class GrokClient:
             "modelMode": model_mode,
             "isAsyncChat": False
         }
+        
+        # 视频模型特殊配置
+        if is_video_model:
+            payload["toolOverrides"] = {"videoGen": True}
+            logger.debug("[Client] 视频模型载荷配置: toolOverrides.videoGen = True")
+        
+        return payload
 
     @staticmethod
     async def _send_request(payload: dict, auth_token: str, model: str, stream: bool):
@@ -127,18 +148,23 @@ class GrokClient:
         try:
             # 构建请求头和代理
             headers = GrokClient._build_headers(auth_token)
-            proxies = GrokClient._get_proxy()
+            proxy_config = GrokClient._get_proxy()
+
+            # 构建请求参数
+            request_kwargs = {
+                "headers": headers,
+                "data": json.dumps(payload),
+                "impersonate": IMPERSONATE_BROWSER,
+                "timeout": REQUEST_TIMEOUT,
+                "stream": True,
+                "proxies": proxy_config if proxy_config else None
+            }
 
             # 在线程池中执行同步HTTP请求，避免阻塞事件循环
             response = await asyncio.to_thread(
                 curl_requests.post,
                 GROK_API_ENDPOINT,
-                headers=headers,
-                data=json.dumps(payload),
-                impersonate=IMPERSONATE_BROWSER,
-                timeout=REQUEST_TIMEOUT,
-                stream=True,
-                **proxies
+                **request_kwargs
             )
 
             logger.debug(f"[Client] API响应状态码: {response.status_code}")
@@ -154,9 +180,14 @@ class GrokClient:
             return await GrokClient._process_response(response, auth_token, model, stream)
 
         except curl_requests.RequestsError as e:
+            logger.error(f"[Client] 网络请求错误: {e}")
             raise GrokApiException(f"网络错误: {e}", "NETWORK_ERROR") from e
         except json.JSONDecodeError as e:
+            logger.error(f"[Client] JSON解析错误: {e}")
             raise GrokApiException(f"JSON解析错误: {e}", "JSON_ERROR") from e
+        except Exception as e:
+            logger.error(f"[Client] 未知请求错误: {type(e).__name__}: {e}")
+            raise GrokApiException(f"请求处理错误: {e}", "REQUEST_ERROR") from e
 
     @staticmethod
     def _build_headers(auth_token: str) -> Dict[str, str]:
@@ -183,9 +214,9 @@ class GrokClient:
         try:
             error_data = response.json()
             error_message = str(error_data)
-        except Exception:
+        except Exception as e:
             error_data = response.text
-            error_message = error_data[:200] if error_data else "未知错误"
+            error_message = error_data[:200] if error_data else e
 
         # 记录Token失败
         asyncio.create_task(token_manager.record_failure(auth_token, response.status_code, error_message))
@@ -203,7 +234,7 @@ class GrokClient:
             result = GrokResponseProcessor.process_stream(response, auth_token)
             asyncio.create_task(GrokClient._update_rate_limits(auth_token, model))
         else:
-            result = await GrokResponseProcessor.process_normal(response, auth_token)
+            result = await GrokResponseProcessor.process_normal(response, auth_token, model)
             asyncio.create_task(GrokClient._update_rate_limits(auth_token, model))
 
         return result

app/services/grok/processer.py

@@ -3,7 +3,8 @@
 import json
 import uuid
 import time
-from typing import Iterator
+import asyncio
+from typing import AsyncGenerator
 
 from app.core.config import setting
 from app.core.exception import GrokApiException
@@ -16,15 +17,70 @@ from app.models.openai_schema import (
     OpenAIChatCompletionChunkChoice,
     OpenAIChatCompletionChunkMessage
 )
-from app.services.grok.image_cache import image_cache_service
+from app.services.grok.cache import image_cache_service, video_cache_service
+
+
+class StreamTimeoutManager:
+    """流式响应超时管理器"""
+    
+    def __init__(self, chunk_timeout: int = 120, first_response_timeout: int = 30, total_timeout: int = 600):
+        """初始化超时管理器
+        
+        Args:
+            chunk_timeout: 数据块间隔超时（秒）
+            first_response_timeout: 首次响应超时（秒）
+            total_timeout: 总超时限制（秒，0表示不限制）
+        """
+        self.chunk_timeout = chunk_timeout
+        self.first_response_timeout = first_response_timeout
+        self.total_timeout = total_timeout
+        
+        self.start_time = asyncio.get_event_loop().time()
+        self.last_chunk_time = self.start_time
+        self.first_chunk_received = False
+    
+    def check_timeout(self) -> tuple[bool, str]:
+        """检查是否超时
+        
+        Returns:
+            (is_timeout, timeout_message): 是否超时及超时信息
+        """
+        current_time = asyncio.get_event_loop().time()
+        
+        # 检查首次响应超时
+        if not self.first_chunk_received:
+            if current_time - self.start_time > self.first_response_timeout:
+                return True, f"首次响应超时 ({self.first_response_timeout}秒未收到首个数据块)"
+        
+        # 检查总超时
+        if self.total_timeout > 0:
+            if current_time - self.start_time > self.total_timeout:
+                return True, f"流式响应总超时 ({self.total_timeout}秒)"
+        
+        # 检查数据块间隔超时
+        if self.first_chunk_received:
+            if current_time - self.last_chunk_time > self.chunk_timeout:
+                return True, f"数据块间隔超时 ({self.chunk_timeout}秒无新数据)"
+        
+        return False, ""
+    
+    def mark_chunk_received(self):
+        """标记收到数据块"""
+        self.last_chunk_time = asyncio.get_event_loop().time()
+        self.first_chunk_received = True
+    
+    def get_total_duration(self) -> float:
+        """获取总耗时（秒）"""
+        return asyncio.get_event_loop().time() - self.start_time
 
 
 class GrokResponseProcessor:
     """Grok API 响应处理器"""
 
     @staticmethod
-    async def process_normal(response, auth_token: str) -> OpenAIChatCompletionResponse:
+    async def process_normal(response, auth_token: str, model: str = None) -> OpenAIChatCompletionResponse:
         """处理非流式响应"""
+        response_closed = False
         try:
             for chunk in response.iter_lines():
                 if not chunk:
@@ -40,8 +96,51 @@ class GrokResponseProcessor:
                         {"code": error.get("code")}
                     )
 
+                # 提取响应数据
+                grok_resp = data.get("result", {}).get("response", {})
+                
+                # 提取视频数据
+                if video_resp := grok_resp.get("streamingVideoGenerationResponse"):
+                    if video_url := video_resp.get("videoUrl"):
+                        logger.debug(f"[Processor] 检测到视频生成: {video_url}")
+                        full_video_url = f"https://assets.grok.com/{video_url}"
+                        
+                        # 下载并缓存视频
+                        try:
+                            cache_path = await video_cache_service.download_video(f"/{video_url}", auth_token)
+                            if cache_path:
+                                video_path = video_url.replace('/', '-')
+                                base_url = setting.global_config.get("base_url", "")
+                                local_video_url = f"{base_url}/images/{video_path}" if base_url else f"/images/{video_path}"
+                                content = f'<video src="{local_video_url}" controls="controls" width="500" height="300"></video>'
+                            else:
+                                content = f'<video src="{full_video_url}" controls="controls" width="500" height="300"></video>'
+                        except Exception as e:
+                            logger.warning(f"[Processor] 缓存视频失败: {e}")
+                            content = f'<video src="{full_video_url}" controls="controls" width="500" height="300"></video>'
+                        
+                        # 返回视频响应
+                        result = OpenAIChatCompletionResponse(
+                            id=f"chatcmpl-{uuid.uuid4()}",
+                            object="chat.completion",
+                            created=int(time.time()),
+                            model=model or "grok-imagine-0.9",
+                            choices=[OpenAIChatCompletionChoice(
+                                index=0,
+                                message=OpenAIChatCompletionMessage(
+                                    role="assistant",
+                                    content=content
+                                ),
+                                finish_reason="stop"
+                            )],
+                            usage=None
+                        )
+                        response_closed = True
+                        response.close()
+                        return result
+
                 # 提取模型响应
-                model_response = data.get("result", {}).get("response", {}).get("modelResponse")
+                model_response = grok_resp.get("modelResponse")
                 if not model_response:
                     continue
 
@@ -53,10 +152,10 @@ class GrokResponseProcessor:
                     )
 
                 # 构建响应内容
-                model = model_response.get("model")
+                model_name = model_response.get("model")
                 content = model_response.get("message", "")
 
-                # 添加生成的图片
+                # 提取图片数据
                 if images := model_response.get("generatedImageUrls"):
                     for img in images:
                         try:
@@ -72,12 +171,12 @@ class GrokResponseProcessor:
                             logger.warning(f"[Processor] 缓存图片失败: {e}")
                             content += f"\n![Generated Image](https://assets.grok.com/{img})"
 
-                # 返回OpenAI格式响应
+                # 返回 OpenAI 响应格式
                 result = OpenAIChatCompletionResponse(
                     id=f"chatcmpl-{uuid.uuid4()}",
                     object="chat.completion",
                     created=int(time.time()),
-                    model=model,
+                    model=model_name,
                     choices=[OpenAIChatCompletionChoice(
                         index=0,
                         message=OpenAIChatCompletionMessage(
@@ -88,29 +187,48 @@ class GrokResponseProcessor:
                     )],
                     usage=None
                 )
+                response_closed = True
                 response.close()
                 return result
 
             raise GrokApiException("无响应数据", "NO_RESPONSE")
 
         except json.JSONDecodeError as e:
+            logger.error(f"[Processor] JSON解析失败: {e}")
             raise GrokApiException(f"JSON解析失败: {e}", "JSON_ERROR") from e
+        except Exception as e:
+            logger.error(f"[Processor] 处理响应时发生未知错误: {type(e).__name__}: {e}")
+            raise GrokApiException(f"响应处理错误: {e}", "PROCESS_ERROR") from e
         finally:
-            # 确保响应对象被关闭
-            if hasattr(response, 'close'):
-                response.close()
+            # 确保响应对象被关闭，避免双重释放
+            if not response_closed and hasattr(response, 'close'):
+                try:
+                    response.close()
+                except Exception as e:
+                    logger.warning(f"[Processor] 关闭响应对象时出错: {e}")
 
     @staticmethod
-    async def process_stream(response, auth_token: str) -> Iterator[str]:
+    async def process_stream(response, auth_token: str) -> AsyncGenerator[str, None]:
         """处理流式响应"""
+        # 流式生成状态
         is_image = False
         is_thinking = False
         thinking_finished = False
         chunk_index = 0
         model = None
         filtered_tags = setting.grok_config.get("filtered_tags", "").split(",")
-
-        def make_chunk(content: str, finish: str = None):
+        video_progress_started = False
+        last_video_progress = -1
+        response_closed = False
+
+        # 初始化超时管理器
+        timeout_manager = StreamTimeoutManager(
+            chunk_timeout=setting.grok_config.get("stream_chunk_timeout", 120),
+            first_response_timeout=setting.grok_config.get("stream_first_response_timeout", 30),
+            total_timeout=setting.grok_config.get("stream_total_timeout", 600)
+        )
+
+        def make_chunk(chunk_content: str, finish: str = None):
             """生成OpenAI格式的响应块"""
             chunk_data = OpenAIChatCompletionChunkResponse(
                 id=f"chatcmpl-{uuid.uuid4()}",
@@ -120,8 +238,8 @@ class GrokResponseProcessor:
                     index=chunk_index,
                     delta=OpenAIChatCompletionChunkMessage(
                         role="assistant",
-                        content=content
-                    ) if content else {},
+                        content=chunk_content
+                    ) if chunk_content else {},
                     finish_reason=finish
                 )]
             ).model_dump()
@@ -130,6 +248,14 @@ class GrokResponseProcessor:
 
         try:
             for chunk in response.iter_lines():
+                # 超时检查
+                is_timeout, timeout_msg = timeout_manager.check_timeout()
+                if is_timeout:
+                    logger.warning(f"[Processor] {timeout_msg}")
+                    yield make_chunk("", "stop")
+                    yield "data: [DONE]\n\n"
+                    return
+
                 logger.debug(f"[Processor] 接收到数据块: {len(chunk)} bytes")
                 if not chunk:
                     continue
@@ -156,6 +282,47 @@ class GrokResponseProcessor:
                         if m := user_resp.get("model"):
                             model = m
 
+                    # 提取视频数据
+                    if video_resp := grok_resp.get("streamingVideoGenerationResponse"):
+                        progress = video_resp.get("progress", 0)
+                        
+                        if progress > last_video_progress:
+                            last_video_progress = progress
+                            
+                            # 添加 <think> 标签
+                            if not video_progress_started:
+                                content = f"<think>视频已生成{progress}%\n"
+                                video_progress_started = True
+                            elif progress < 100:
+                                content = f"视频已生成{progress}%\n"
+                            else:
+                                # 进度100%时关闭 <think> 标签并立即处理视频
+                                content = f"视频已生成{progress}%</think>\n"
+                                
+                                # 立即下载并缓存视频
+                                if v_url := video_resp.get("videoUrl"):
+                                    logger.debug(f"[Processor] 视频生成完成: {v_url}")
+                                    full_video_url = f"https://assets.grok.com/{v_url}"
+                                    
+                                    try:
+                                        cache_path = await video_cache_service.download_video(f"/{v_url}", auth_token)
+                                        if cache_path:
+                                            video_path = v_url.replace('/', '-')
+                                            base_url = setting.global_config.get("base_url", "")
+                                            local_video_url = f"{base_url}/images/{video_path}" if base_url else f"/images/{video_path}"
+                                            content += f'<video src="{local_video_url}" controls="controls"></video>'
+                                        else:
+                                            content += f'<video src="{full_video_url}" controls="controls"></video>'
+                                    except Exception as e:
+                                        logger.warning(f"[Processor] 缓存视频失败: {e}")
+                                        content += f'<video src="{full_video_url}" controls="controls"></video>'
+
+                            yield make_chunk(content)
+                            timeout_manager.mark_chunk_received()
+                            chunk_index += 1
+                        
+                        continue
+
                     # 检查生成模式
                     if grok_resp.get("imageAttachmentInfo"):
                         is_image = True
@@ -163,16 +330,16 @@ class GrokResponseProcessor:
                     # 获取token
                     token = grok_resp.get("token", "")
 
-                    # 图片模式
+                    # 提取图片数据
                     if is_image:
                         if model_resp := grok_resp.get("modelResponse"):
                             # 生成图片链接并缓存
                             content = ""
                             for img in model_resp.get("generatedImageUrls", []):
                                 try:
-                                    # 异步下载并缓存图片
+                                    # 缓存图片
                                     await image_cache_service.download_image(f"/{img}", auth_token)
-                                    # 使用本地缓存路径
+                                    # 本地图片路径
                                     img_path = img.replace('/', '-')
                                     base_url = setting.global_config.get("base_url", "")
                                     img_url = f"{base_url}/images/{img_path}" if base_url else f"/images/{img_path}"
@@ -181,12 +348,14 @@ class GrokResponseProcessor:
                                     logger.warning(f"[Processor] 缓存图片失败: {e}")
                                     content += f"![Generated Image](https://assets.grok.com/{img})\n"
                             yield make_chunk(content.strip(), "stop")
+                            timeout_manager.mark_chunk_received()
                             return
                         elif token:
                             yield make_chunk(token)
+                            timeout_manager.mark_chunk_received()
                             chunk_index += 1
 
-                    # 对话模式
+                    # 提取对话数据
                     else:
                         # 过滤 list 格式的 token
                         if isinstance(token, list):
@@ -200,7 +369,7 @@ class GrokResponseProcessor:
                         current_is_thinking = grok_resp.get("isThinking", False)
                         message_tag = grok_resp.get("messageTag")
 
-                        # 跳过后续的 thinking
+                        # 跳过后续的 <think> 标签
                         if thinking_finished and current_is_thinking:
                             continue
 
@@ -208,7 +377,7 @@ class GrokResponseProcessor:
                         if grok_resp.get("toolUsageCardId"):
                             if web_search := grok_resp.get("webSearchResults"):
                                 if current_is_thinking:
-                                    # 添加搜索结果到 token
+                                    # 封装搜索结果
                                     for result in web_search.get("results", []):
                                         title = result.get("title", "")
                                         url = result.get("url", "")
@@ -238,6 +407,7 @@ class GrokResponseProcessor:
                                 thinking_finished = True
 
                             yield make_chunk(content)
+                            timeout_manager.mark_chunk_received()
                             chunk_index += 1
                             is_thinking = current_is_thinking
 
@@ -250,11 +420,23 @@ class GrokResponseProcessor:
 
             # 发送结束块
             yield make_chunk("", "stop")
+
             # 发送流结束标记
             yield "data: [DONE]\n\n"
+            
+            # 记录流式响应统计
+            logger.info(f"[Processor] 流式响应完成，总耗时: {timeout_manager.get_total_duration():.2f}秒")
 
         except Exception as e:
             logger.error(f"[Processor] 流式处理严重错误: {e}")
             yield make_chunk(f"处理错误: {e}", "error")
             # 发送流结束标记
-            yield "data: [DONE]\n\n"
+            yield "data: [DONE]\n\n"
+        finally:
+            # 确保响应对象被关闭
+            if not response_closed and hasattr(response, 'close'):
+                try:
+                    response.close()
+                    logger.debug("[Processor] 流式响应对象已关闭")
+                except Exception as e:
+                    logger.warning(f"[Processor] 关闭流式响应对象时出错: {e}")

app/template/admin.html

@@ -304,27 +304,58 @@
                         </div>
                         <div>
                             <label class="text-sm font-medium flex items-center gap-1 mb-2">
-                                缓存上限 (MB)
+                                图片缓存上限 (MB)
                                 <span class="inline-flex items-center justify-center w-3.5 h-3.5 rounded-full border border-muted-foreground text-muted-foreground cursor-help" style="font-size:10px;line-height:1" title="图片缓存目录的最大容量，超过后自动删除最旧的缓存文件">?</span>
                             </label>
-                            <input id="cfgTempMaxSize" type="number" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="500">
+                            <input id="cfgImageCacheMaxSize" type="number" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="500">
+                        </div>
+                        <div>
+                            <label class="text-sm font-medium flex items-center gap-1 mb-2">
+                                视频缓存上限 (MB)
+                                <span class="inline-flex items-center justify-center w-3.5 h-3.5 rounded-full border border-muted-foreground text-muted-foreground cursor-help" style="font-size:10px;line-height:1" title="视频缓存目录的最大容量，超过后自动删除最旧的缓存文件">?</span>
+                            </label>
+                            <input id="cfgVideoCacheMaxSize" type="number" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="1000">
                         </div>
                         <div>
                             <label class="text-sm font-medium flex items-center gap-1 mb-2">
                                 缓存大小
                                 <span class="inline-flex items-center justify-center w-3.5 h-3.5 rounded-full border border-muted-foreground text-muted-foreground cursor-help" style="font-size:10px;line-height:1" title="当前缓存目录的大小">?</span>
                             </label>
-                            <div class="flex gap-2">
-                                <input id="cacheSize" readonly class="flex h-9 flex-1 rounded-md border border-input bg-muted px-3 py-2 text-sm" placeholder="0 MB">
-                                <button onclick="clearCache()" class="inline-flex items-center justify-center rounded-md text-sm font-medium bg-orange-600 text-white hover:bg-orange-700 h-9 px-3 transition-colors">
-                                    <svg class="h-4 w-4 mr-1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-                                        <path d="M3 6h18"/>
-                                        <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
-                                        <line x1="10" y1="11" x2="10" y2="17"/>
-                                        <line x1="14" y1="11" x2="14" y2="17"/>
-                                    </svg>
-                                    清除
-                                </button>
+                            <div class="space-y-2">
+                                <div class="flex gap-2 items-center">
+                                    <span class="text-sm text-muted-foreground w-12">图片:</span>
+                                    <input id="imageCacheSize" readonly class="flex h-9 flex-1 rounded-md border border-input bg-muted px-3 py-2 text-sm" placeholder="0 MB">
+                                    <button onclick="clearImageCache()" class="inline-flex items-center justify-center rounded-md text-sm font-medium bg-destructive text-destructive-foreground hover:bg-destructive/90 h-9 px-3 transition-colors" title="仅清除图片缓存">
+                                        <svg class="h-4 w-4" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                            <rect x="3" y="3" width="18" height="18" rx="2" ry="2"/>
+                                            <circle cx="9" cy="9" r="2"/>
+                                            <path d="M21 15l-3.086-3.086a2 2 0 0 0-2.828 0L6 21"/>
+                                        </svg>
+                                    </button>
+                                </div>
+                                <div class="flex gap-2 items-center">
+                                    <span class="text-sm text-muted-foreground w-12">视频:</span>
+                                    <input id="videoCacheSize" readonly class="flex h-9 flex-1 rounded-md border border-input bg-muted px-3 py-2 text-sm" placeholder="0 MB">
+                                    <button onclick="clearVideoCache()" class="inline-flex items-center justify-center rounded-md text-sm font-medium bg-destructive text-destructive-foreground hover:bg-destructive/90 h-9 px-3 transition-colors" title="仅清除视频缓存">
+                                        <svg class="h-4 w-4" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                            <polygon points="23 7 16 12 23 17 23 7"/>
+                                            <rect x="1" y="5" width="15" height="14" rx="2" ry="2"/>
+                                        </svg>
+                                    </button>
+                                </div>
+                                <div class="flex gap-2 items-center">
+                                    <span class="text-sm text-muted-foreground w-12">总计:</span>
+                                    <input id="totalCacheSize" readonly class="flex h-9 flex-1 rounded-md border border-input bg-muted px-3 py-2 text-sm font-medium" placeholder="0 MB">
+                                    <button onclick="clearCache()" class="inline-flex items-center justify-center rounded-md text-sm font-medium bg-destructive text-destructive-foreground hover:bg-destructive/90 h-9 px-3 transition-colors" title="清除所有缓存（图片+视频）">
+                                        <svg class="h-4 w-4 mr-1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                            <path d="M3 6h18"/>
+                                            <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/>
+                                            <line x1="10" y1="11" x2="10" y2="17"/>
+                                            <line x1="14" y1="11" x2="14" y2="17"/>
+                                        </svg>
+                                        清除全部
+                                    </button>
+                                </div>
                             </div>
                         </div>
                         <div>
@@ -389,6 +420,27 @@
                                 <option value="true">开启</option>
                             </select>
                         </div>
+                        <div>
+                            <label class="text-sm font-medium flex items-center gap-1 mb-2">
+                                数据块间隔超时 (秒)
+                                <span class="inline-flex items-center justify-center w-3.5 h-3.5 rounded-full border border-muted-foreground text-muted-foreground cursor-help" style="font-size:10px;line-height:1" title="流式响应中，两次数据块之间的最大等待时间。超过此时间将结束会话">?</span>
+                            </label>
+                            <input id="cfgStreamChunkTimeout" type="number" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="120">
+                        </div>
+                        <div>
+                            <label class="text-sm font-medium flex items-center gap-1 mb-2">
+                                首次响应超时 (秒)
+                                <span class="inline-flex items-center justify-center w-3.5 h-3.5 rounded-full border border-muted-foreground text-muted-foreground cursor-help" style="font-size:10px;line-height:1" title="从请求开始到收到第一个数据块的最大等待时间。超过此时间将结束会话">?</span>
+                            </label>
+                            <input id="cfgStreamFirstResponseTimeout" type="number" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="30">
+                        </div>
+                        <div>
+                            <label class="text-sm font-medium flex items-center gap-1 mb-2">
+                                总超时限制 (秒)
+                                <span class="inline-flex items-center justify-center w-3.5 h-3.5 rounded-full border border-muted-foreground text-muted-foreground cursor-help" style="font-size:10px;line-height:1" title="流式响应的总时长限制。设置为0表示不限制总时长">?</span>
+                            </label>
+                            <input id="cfgStreamTotalTimeout" type="number" class="flex h-9 w-full rounded-md border border-input bg-background px-3 py-2 text-sm" placeholder="600">
+                        </div>
                     </div>
                     <div class="mt-6 flex justify-end">
                         <button onclick="saveGrokSettings()" class="inline-flex items-center justify-center rounded-md text-sm font-medium bg-primary text-primary-foreground hover:bg-primary/90 h-9 px-6 transition-colors">保存配置</button>
@@ -482,11 +534,13 @@
         showToast=(m,t='info')=>{const d=document.createElement('div'),bc={success:'bg-green-600',error:'bg-destructive',info:'bg-primary'};d.className=`fixed bottom-4 right-4 ${bc[t]||bc.info} text-white px-4 py-2.5 rounded-lg shadow-lg text-sm font-medium z-50 animate-slide-up`;d.textContent=m;document.body.appendChild(d);setTimeout(()=>{d.style.opacity='0';d.style.transition='opacity 0.3s';setTimeout(()=>d.parentNode&&document.body.removeChild(d),300)},2000)},
         logout=async()=>{if(!confirm('确定要退出登录吗?'))return;try{await apiRequest('/api/logout',{method:'POST'})}catch(e){console.error('登出失败:',e)}finally{localStorage.removeItem('adminToken');location.href='/login'}},
         switchTab=t=>{['tokens','settings'].forEach(n=>{$(`panel${n.charAt(0).toUpperCase()+n.slice(1)}`).classList[n===t?'remove':'add']('hidden');$(`tab${n.charAt(0).toUpperCase()+n.slice(1)}`).classList[n===t?'add':'remove']('border-primary','text-primary');$(`tab${n.charAt(0).toUpperCase()+n.slice(1)}`).classList[n===t?'remove':'add']('border-transparent','text-muted-foreground')});t==='settings'&&loadSettings()},
-        loadSettings=async()=>{try{const r=await apiRequest('/api/settings');if(!r)return;const d=await r.json();if(d.success){const g=d.data.global,k=d.data.grok;$('cfgAdminUser').value=g.admin_username||'';$('cfgAdminPass').value='';$('cfgLogLevel').value=g.log_level||'DEBUG';$('cfgTempMaxSize').value=g.temp_max_size_mb||500;$('cfgBaseUrl').value=g.base_url||'';$('cfgApiKey').value=k.api_key||'';$('cfgProxyUrl').value=k.proxy_url||'';$('cfgCfClearance').value=k.cf_clearance||'';$('cfgStatsigId').value=k.x_statsig_id||'';$('cfgFilteredTags').value=k.filtered_tags||'';$('cfgTemporary').value=k.temporary!==false?'true':'false';await loadCacheSize()}}catch(e){console.error('加载配置失败:',e);showToast('加载配置失败','error')}},
-        loadCacheSize=async()=>{try{const r=await apiRequest('/api/cache/size');if(!r)return;const d=await r.json();if(d.success){$('cacheSize').value=d.data.size||'0 MB'}}catch(e){console.error('加载缓存大小失败:',e);$('cacheSize').value='0 MB'}},
+        loadSettings=async()=>{try{const r=await apiRequest('/api/settings');if(!r)return;const d=await r.json();if(d.success){const g=d.data.global,k=d.data.grok;$('cfgAdminUser').value=g.admin_username||'';$('cfgAdminPass').value='';$('cfgLogLevel').value=g.log_level||'DEBUG';$('cfgImageCacheMaxSize').value=g.image_cache_max_size_mb||500;$('cfgVideoCacheMaxSize').value=g.video_cache_max_size_mb||1000;$('cfgBaseUrl').value=g.base_url||'';$('cfgApiKey').value=k.api_key||'';$('cfgProxyUrl').value=k.proxy_url||'';$('cfgCfClearance').value=k.cf_clearance||'';$('cfgStatsigId').value=k.x_statsig_id||'';$('cfgFilteredTags').value=k.filtered_tags||'';$('cfgTemporary').value=k.temporary!==false?'true':'false';$('cfgStreamChunkTimeout').value=k.stream_chunk_timeout||120;$('cfgStreamFirstResponseTimeout').value=k.stream_first_response_timeout||30;$('cfgStreamTotalTimeout').value=k.stream_total_timeout||600;await loadCacheSize()}}catch(e){console.error('加载配置失败:',e);showToast('加载配置失败','error')}},
+        loadCacheSize=async()=>{try{const r=await apiRequest('/api/cache/size');if(!r)return;const d=await r.json();if(d.success){$('imageCacheSize').value=d.data.image_size||'0 MB';$('videoCacheSize').value=d.data.video_size||'0 MB';$('totalCacheSize').value=d.data.total_size||'0 MB'}}catch(e){console.error('加载缓存大小失败:',e);$('imageCacheSize').value='0 MB';$('videoCacheSize').value='0 MB';$('totalCacheSize').value='0 MB'}},
+        clearImageCache=async()=>{if(!confirm('确定要清理图片缓存吗？此操作将删除所有图片缓存文件！'))return;try{const r=await apiRequest('/api/cache/clear/images',{method:'POST'});if(!r)return;const d=await r.json();if(d.success){showToast(`图片缓存清理完成，已删除 ${d.data.deleted_count||0} 个文件`,'success');await loadCacheSize()}else{showToast('清理失败: '+(d.error||'未知错误'),'error')}}catch(e){showToast('清理失败: '+e.message,'error')}},
+        clearVideoCache=async()=>{if(!confirm('确定要清理视频缓存吗？此操作将删除所有视频缓存文件！'))return;try{const r=await apiRequest('/api/cache/clear/videos',{method:'POST'});if(!r)return;const d=await r.json();if(d.success){showToast(`视频缓存清理完成，已删除 ${d.data.deleted_count||0} 个文件`,'success');await loadCacheSize()}else{showToast('清理失败: '+(d.error||'未知错误'),'error')}}catch(e){showToast('清理失败: '+e.message,'error')}},
         clearCache=async()=>{if(!confirm('确定要清理缓存吗？此操作将删除 /data/temp 目录中的所有文件！'))return;try{const r=await apiRequest('/api/cache/clear',{method:'POST'});if(!r)return;const d=await r.json();if(d.success){showToast(`缓存清理完成，已删除 ${d.data.deleted_count||0} 个文件`,'success');await loadCacheSize()}else{showToast('清理失败: '+(d.error||'未知错误'),'error')}}catch(e){showToast('清理失败: '+e.message,'error')}},
-        saveGlobalSettings=async()=>{const gc={admin_username:$('cfgAdminUser').value,log_level:$('cfgLogLevel').value,temp_max_size_mb:parseInt($('cfgTempMaxSize').value)||500,base_url:$('cfgBaseUrl').value};if($('cfgAdminPass').value)gc.admin_password=$('cfgAdminPass').value;try{const r=await apiRequest('/api/settings');if(!r)return;const d=await r.json();if(!d.success)return showToast('加载配置失败','error');const s=await apiRequest('/api/settings',{method:'POST',body:JSON.stringify({global_config:gc,grok_config:d.data.grok})});if(!s)return;const sd=await s.json();sd.success?(showToast('全局配置保存成功','success'),$('cfgAdminPass').value=''):showToast('保存失败: '+(sd.error||'未知错误'),'error')}catch(e){showToast('保存失败: '+e.message,'error')}},
-        saveGrokSettings=async()=>{const kc={api_key:$('cfgApiKey').value,proxy_url:$('cfgProxyUrl').value,cf_clearance:$('cfgCfClearance').value,x_statsig_id:$('cfgStatsigId').value,filtered_tags:$('cfgFilteredTags').value,temporary:$('cfgTemporary').value==='true'};try{const r=await apiRequest('/api/settings');if(!r)return;const d=await r.json();if(!d.success)return showToast('加载配置失败','error');const s=await apiRequest('/api/settings',{method:'POST',body:JSON.stringify({global_config:d.data.global,grok_config:kc})});if(!s)return;const sd=await s.json();sd.success?showToast('Grok配置保存成功','success'):showToast('保存失败: '+(sd.error||'未知错误'),'error')}catch(e){showToast('保存失败: '+e.message,'error')}};
+        saveGlobalSettings=async()=>{const gc={admin_username:$('cfgAdminUser').value,log_level:$('cfgLogLevel').value,image_cache_max_size_mb:parseInt($('cfgImageCacheMaxSize').value)||500,video_cache_max_size_mb:parseInt($('cfgVideoCacheMaxSize').value)||1000,base_url:$('cfgBaseUrl').value};if($('cfgAdminPass').value)gc.admin_password=$('cfgAdminPass').value;try{const r=await apiRequest('/api/settings');if(!r)return;const d=await r.json();if(!d.success)return showToast('加载配置失败','error');const s=await apiRequest('/api/settings',{method:'POST',body:JSON.stringify({global_config:gc,grok_config:d.data.grok})});if(!s)return;const sd=await s.json();sd.success?(showToast('全局配置保存成功','success'),$('cfgAdminPass').value=''):showToast('保存失败: '+(sd.error||'未知错误'),'error')}catch(e){showToast('保存失败: '+e.message,'error')}},
+        saveGrokSettings=async()=>{const kc={api_key:$('cfgApiKey').value,proxy_url:$('cfgProxyUrl').value,cf_clearance:$('cfgCfClearance').value,x_statsig_id:$('cfgStatsigId').value,filtered_tags:$('cfgFilteredTags').value,temporary:$('cfgTemporary').value==='true',stream_chunk_timeout:parseInt($('cfgStreamChunkTimeout').value)||120,stream_first_response_timeout:parseInt($('cfgStreamFirstResponseTimeout').value)||30,stream_total_timeout:parseInt($('cfgStreamTotalTimeout').value)||600};try{const r=await apiRequest('/api/settings');if(!r)return;const d=await r.json();if(!d.success)return showToast('加载配置失败','error');const s=await apiRequest('/api/settings',{method:'POST',body:JSON.stringify({global_config:d.data.global,grok_config:kc})});if(!s)return;const sd=await s.json();sd.success?showToast('Grok配置保存成功','success'):showToast('保存失败: '+(sd.error||'未知错误'),'error')}catch(e){showToast('保存失败: '+e.message,'error')}};
         window.addEventListener('DOMContentLoaded',()=>{checkAuth();refreshTokens();setInterval(()=>{loadStats();updateRemaining()},30000)});
     </script>
 </body>

data/setting.toml

@@ -2,12 +2,18 @@
 admin_username = "admin"
 admin_password = "admin"
 log_level = "INFO"
-temp_max_size_mb = 500
+image_cache_max_size_mb = 500
+video_cache_max_size_mb = 1000
 base_url = ""
 
+
+
 [grok]
 api_key = ""
 proxy_url = ""
+stream_chunk_timeout = 120
+stream_first_response_timeout = 30
+stream_total_timeout = 600
 cf_clearance = ""
 temporary = true
 filtered_tags = "xaiartifact,xai:tool_usage_card,grok:render"