增加自定义提示词管理系统 超时默认为10分钟 优化UI

.env.example

@@ -54,8 +54,8 @@ CUSTOM_API_URL=
 # AI_MAX_TOKENS: AI 响应的最大 token 数（默认值：1200）
 # AI_MAX_TOKENS=1200
 
-# OPENAI_TIMEOUT: 请求超时时间（毫秒）（默认值：60000）
-# OPENAI_TIMEOUT=60000
+# OPENAI_TIMEOUT: 请求超时时间（毫秒）（默认值：600000）
+# OPENAI_TIMEOUT=600000
 
 # -----------------------------------------------------------------------------
 # 两阶段 AI 生成配置
@@ -74,3 +74,4 @@ CUSTOM_API_URL=
 # - development（开发环境）
 # - production（生产环境）
 NODE_ENV=development
+

README.md

@@ -1,279 +1,365 @@
-<div align="center">
-
-<!-- 顶部装饰线 - 统一为深灰色调 -->
-<img width="100%" src="https://capsule-render.vercel.app/api?type=waving&color=455A64&height=120&section=header" />
-
-<br>
-  
-<img src="public/logo.svg" width="200" alt="ManimCat Logo" />
-
-<!-- 装饰：猫咪足迹 -->
-<div style="opacity: 0.3; margin: 20px 0;">
-  <img src="https://raw.githubusercontent.com/Tarikul-Islam-Anik/Animated-Fluent-Emojis/master/Emojis/Animals/Paw%20Prints.png" width="40" alt="paws" />
-</div>
-
-<h1>
-  <picture>
-    <img src="https://readme-typing-svg.herokuapp.com?font=Fira+Code&size=40&duration=3000&pause=1000&color=455A64&center=true&vCenter=true&width=435&lines=ManimCat+%F0%9F%90%BE" alt="ManimCat" />
-  </picture>
-</h1>
-
-<!-- 装饰：数学符号分隔 -->
-<p align="center">
-  <span style="font-family: monospace; font-size: 24px; color: #90A4AE;">
-    ∫ &nbsp; ∑ &nbsp; ∂ &nbsp; ∞
-  </span>
-</p>
-
-<p align="center">
-  <strong>🎬 AI-Powered Mathematical Animation Generator</strong>
-</p>
-
-<p align="center">
-  让数学动画创作变得简单优雅 · 基于 Manim 与大语言模型
-</p>
-
-<!-- 装饰：几何点阵分隔 -->
-<div style="margin: 30px 0;">
-  <span style="color: #CFD8DC; font-size: 20px;">◆ &nbsp; ◆ &nbsp; ◆</span>
-</div>
-
-<p align="center">
-  <img src="https://img.shields.io/badge/ManimCE-0.19.2-455A64?style=for-the-badge&logo=python&logoColor=white" alt="ManimCE" />
-  <img src="https://img.shields.io/badge/React-19.2.0-455A64?style=for-the-badge&logo=react&logoColor=white" alt="React" />
-  <img src="https://img.shields.io/badge/Node.js-18+-455A64?style=for-the-badge&logo=node.js&logoColor=white" alt="Node.js" />
-  <img src="https://img.shields.io/badge/License-MIT-607D8B?style=for-the-badge" alt="License" />
-</p>
-
-<p align="center" style="font-size: 18px;">
-  <a href="#前言"><strong>前言</strong></a> •
-  <a href="#样例"><strong>样例</strong></a> •
-  <a href="#技术"><strong>技术</strong></a> •
-  <a href="#部署"><strong>部署</strong></a> •
-  <a href="#贡献"><strong>贡献</strong></a> •
-  <a href="#思路"><strong>思路</strong></a> •
-  <a href="#现状"><strong>现状</strong></a>
-</p>
-
-<br>
-
-<!-- 底部装饰线 - 统一为深灰色调 -->
-<img width="100%" src="https://capsule-render.vercel.app/api?type=waving&color=455A64&height=100&section=footer" />
-
-</div>
-
-<br>
-
-## 前言
-
-很荣幸在这里介绍我的新项目ManimCat，它是~一只猫~
-
-本项目基于[manim-video-generator](https://github.com/rohitg00/manim-video-generator)架构级重构与二次开发而来，在此感谢原作者 Rohit Ghumare。我重写了整个前后端架构，解决了原版在并发和渲染稳定性上的痛点，并加以个人审美设计与应用的理想化改进。
-
- ManimCat 是一个基于 AI 的数学动画生成平台，致力于让数学教师使用manim代码生成视频应用到课堂与教学之中。
-
-用户只需输入自然语言描述，系统便会通过 AI 自动生成 Manim 代码并渲染出精美的数学可视化视频，支持 LaTeX 公式、模板化生成以及代码错误自动修复，让复杂概念的动态展示变得触手可及。
-
-
-## 样例
-
-期待ing！
-
-## 技术
-
-### 技术栈
-
-**后端**
-- Express.js 4.18.0 + TypeScript 5.9.3
-- Bull 4.16.5 + ioredis 5.9.2（Redis 任务队列）
-- OpenAI SDK 4.50.0
-- Zod 3.23.0（数据验证）
-
-**前端**
-- React 19.2.0 + TypeScript 5.9.3
-- Vite 7.2.4
-- TailwindCSS 3.4.19
-- react-syntax-highlighter 16.1.0
-
-**系统依赖**
-- Python 3.11
-- Manim Community Edition 0.19.2
-- LaTeX（texlive）
-- ffmpeg + Xvfb
-
-**部署**
-- Docker + Docker Compose
-- Redis 7
-
-### 技术路线
-
-```
-用户请求 → POST /api/generate
-           ↓
-       [认证中间件]
-           ↓
-       [Bull 任务队列]
-           ↓
-    ┌───────────────────────────────────┐
-    │     视频生成处理器            │
-    ├───────────────────────────────────┤
-    │ 1. 检查概念缓存              │
-    │ 2. 概念分析                  │
-    │    - LaTeX 检测              │
-    │    - 模板匹配                 │
-    │    - AI 生成（两阶段）        │
-    │      ├─ 阶段1: 概念设计师      │
-    │      └─ 阶段2: 代码生成者      │
-    │ 3. 代码重试管理器             │
-    │    ├─ 首次生成代码 → 渲染     │
-    │    ├─ 失败 → 检查错误可修复性  │
-    │    ├─ 重试循环（最多4次）       │
-    │    │   ├─ 发送完整对话历史      │
-    │    │   ├─ AI 修复代码          │
-    │    │   └─ 重新渲染             │
-    │    └─ 成功/失败 → 存储结果     │
-    │ 4. 存储结果到 Redis           │
-    └──────────────────��────────────────┘
-           ↓
-      前端轮询状态
-           ↓
-    GET /api/jobs/:jobId
-```
-
-**重试机制说明：**
-- 概念设计师结果会保存，不需要重复设计
-- 每次重试都发送完整的对话历史（原始提示词 + 历史代码 + 错误信息）
-- 最多重试 4 次，失败后任务标记为失败
-
-### 环境变量配置
-
-| 环境变量 | 默认值 | 说明 |
-|---------|--------|------|
-| `PORT` | `3000` | 后端服务端口 |
-| `REDIS_URL` | `redis://localhost:6379` | Redis 连接地址 |
-| `OPENAI_API_KEY` | - | OpenAI API Key（必需） |
-| `OPENAI_MODEL` | `glm-4-flash` | 使用的 AI 模型 |
-| `OPENAI_TIMEOUT` | `600000` | OpenAI 请求超时时间（毫秒） |
-| `AI_TEMPERATURE` | `0.7` | AI 温度参数（0-1） |
-| `AI_MAX_CODE_TOKENS` | `1200` | 代码生成最大 Token 数 |
-| `DESIGNER_TEMPERATURE` | `0.8` | 概念设计师温度参数 |
-| `DESIGNER_MAX_TOKENS` | `800` | 概念设计师最大 Token 数 |
-| `ENABLE_AI_CODE_FIX` | `true` | 是否启用 AI 代码修复 |
-| `CODE_RETRY_MAX_RETRIES` | `4` | 代码重试最大次数 |
-| `CUSTOM_API_URL` | - | 自定义 API 地址 |
-| `ENABLE_JOB_CACHE` | `true` | 是否启用任务缓存 |
-| `CACHE_TTL_SECONDS` | `3600` | 缓存过期时间（秒） |
-
-**示例 `.env` 文件：**
-
-```bash
-PORT=3000
-REDIS_URL=redis://localhost:6379
-OPENAI_API_KEY=your-api-key-here
-OPENAI_MODEL=glm-4-flash
-AI_TEMPERATURE=0.7
-CODE_RETRY_MAX_RETRIES=4
-```
-
-## 部署
-
-请查看[部署文档](DEPLOYMENT.md)。
-
-## 贡献
-
-我对原作品进行了一些修改和重构，使其更符合我的设计想法：
-
-  1. 框架架构重构
-
-  - 后端使用 Express.js + Bull 任务队列架构
-
-  2. 前后端分离
-
-  - 前后端分离，React + TypeScript + Vite 独立前端
-
-  3. 存储方案升级
-
-  - Redis 存储（任务结果、状态、缓存，支持持久化）
-
-  4. 任务队列系统
-
-  - Bull + Redis 任务队列，支持重试、超时、指数退避
-
-  5. 前端技术栈
-
-  - React 19 + TailwindCSS + react-syntax-highlighter
-
-  6. 项目结构
-
-  - src/{config,middlewares,routes,services,queues,prompts,types,utils}/
-    frontend/src/{components,hooks,lib,types}/
-
-  7. 新增功能
-
-
-  - CORS 配置中间件
-
-  - 前端主题切换、设置模态框等组件
-
-  - 增加对第三方oai格式的请求支持
-
-  - 支持第三方自定义api
-
-  - 增加重试机制，增加前后端状态查询
-
-  - 重构UI，重构提示词，采取强注入manim api规范的方式
-
-  - 增加前端自定义视频参数
-
-  - 支持内存查询端点
-
-  - 优化提示词管理系统
-
-  - 对AI的输出结合提示词进行高度优化的正则清理，适配思考模型
-
-  ## 思路
-
-  1. 在原作者使用AI一键生成manim视频并且后端渲染的基础上，增加了fallback机制，提升弱模型的生成完成度
-
-  2. 考虑到多数AI的manim语料训练并不多，为了降低AI幻觉率，采用提示词工程的方法，强注入manimv0.19.2的api索引表知识（自行爬取清洗制作）
-
-  ## 现状
-
-目前仍在完善项目，这只是第一个预览版本。我将致力于设计出更好的提示词与fallback流程。目标是可以对一道中国高考数学题进行完整的可视化。以下是建设的计划：
-
-- 优化提示词，生成更长篇幅的Manim代码和更精准的效果
-- 增加调度和重试功能 
-- 增加一定的验证页面，以防止滥用 （已经完成）
-- 增加自定义模式功能，使用不同提示词生成不同视频
-- 增加迭代功能，延长生成代码和视频长度
-- 提供可能的打包版本，让非开发者可以本地实现项目
-
-##  开源与版权声明 (License & Copyright)
-
-### 1. 软件协议 (Software License)
-本项目后端架构及前端部分实现参考/使用了 [manim-video-generator](https://github.com/rohitg00/manim-video-generator) 的核心思想。
-*   继承部分代码遵循 **MIT License**。
-*   本项目新增的重构代码、任务队列逻辑及前端组件，同样以 **MIT License** 向开源社区开放。
-
-### 2. 核心资产版权声明 (Core Assets - **PROHIBITED FOR COMMERCIAL USE**)
-**以下内容为本人（ManimCat 作者）原创，严禁任何形式的商用行为：**
-
-*   **Prompt Engineering（提示词工程）**：本项目中 `src/prompts/` 目录下所有高度优化的 Manim 代码生成提示词及逻辑，均为本人原创。
-*   **API Index Data**：本人自行爬取、清洗并制作的 Manim v0.18.2 API 索引表及相关强约束规则。
-*   **特定算法逻辑**：针对思考模型的正则清理算法及 fallback 容错机制。
-
-**未经本人书面许可，任何人不得将上述“核心资产”用于：**
-1.  直接打包作为付费产品销售。
-2.  集成在付费订阅制的商业 AI 服务中。
-3.  在未注明出处的情况下进行二次分发并获利。
-
-> 事实上，作者已经关注到市面上存在一些闭源商业项目，正利用类似的 AI + Manim 思路向数学教育工作者收取高额费用进行盈利。然而，开源社区目前仍缺乏针对教育场景深度优化的成熟项目。
-
-> ManimCat 的诞生正是为了对标并挑战这些闭源商业软件。 我希望通过开源的方式，让每一位老师都能廉价地享受到 AI 带来的教学可视化便利————你只需要支付api的费用，幸运的是，对于优秀的中国LLM大模型来说，这些花费很廉价。为了保护这一愿景不被商业机构剽窃并反向收割用户，我坚决禁止任何对本项目核心提示词及索引数据的商业授权。
-
-
-## 维护说明
-
-由于作者精力有限（个人业余兴趣开发者，非专业背景），目前完全无法对外部代码进行有效的审查和长期维护。因此，本项目暂不支持团队协同开发，不接受 PR。感谢理解。
-
-如果你有好的建议或发现了 Bug，欢迎提交 Issue 进行讨论，我会根据自己的节奏进行改进。如果你希望在本项目基础上进行大规模修改，欢迎 Fork 出属于你自己的版本。
+<div align="center">
+
+<!-- 顶部装饰线 - 统一为深灰色调 -->
+<img width="100%" src="https://capsule-render.vercel.app/api?type=waving&color=455A64&height=120&section=header" />
+
+<br>
+  
+<img src="public/logo.svg" width="200" alt="ManimCat Logo" />
+
+<!-- 装饰：猫咪足迹 -->
+<div style="opacity: 0.3; margin: 20px 0;">
+  <img src="https://raw.githubusercontent.com/Tarikul-Islam-Anik/Animated-Fluent-Emojis/master/Emojis/Animals/Paw%20Prints.png" width="40" alt="paws" />
+</div>
+
+<h1>
+  <picture>
+    <img src="https://readme-typing-svg.herokuapp.com?font=Fira+Code&size=40&duration=3000&pause=1000&color=455A64&center=true&vCenter=true&width=435&lines=ManimCat+%F0%9F%90%BE" alt="ManimCat" />
+  </picture>
+</h1>
+
+<!-- 装饰：数学符号分隔 -->
+<p align="center">
+  <span style="font-family: monospace; font-size: 24px; color: #90A4AE;">
+    ∫ &nbsp; ∑ &nbsp; ∂ &nbsp; ∞
+  </span>
+</p>
+
+<p align="center">
+  <strong>🎬 AI-Powered Mathematical Animation Generator</strong>
+</p>
+
+<p align="center">
+  让数学动画创作变得简单优雅 · 基于 Manim 与大语言模型
+</p>
+
+<!-- 装饰：几何点阵分隔 -->
+<div style="margin: 30px 0;">
+  <span style="color: #CFD8DC; font-size: 20px;">◆ &nbsp; ◆ &nbsp; ◆</span>
+</div>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/ManimCE-0.19.2-455A64?style=for-the-badge&logo=python&logoColor=white" alt="ManimCE" />
+  <img src="https://img.shields.io/badge/React-19.2.0-455A64?style=for-the-badge&logo=react&logoColor=white" alt="React" />
+  <img src="https://img.shields.io/badge/Node.js-18+-455A64?style=for-the-badge&logo=node.js&logoColor=white" alt="Node.js" />
+  <img src="https://img.shields.io/badge/License-MIT-607D8B?style=for-the-badge" alt="License" />
+</p>
+
+<p align="center" style="font-size: 18px;">
+  <a href="#前言"><strong>前言</strong></a> •
+  <a href="#样例"><strong>样例</strong></a> •
+  <a href="#技术"><strong>技术</strong></a> •
+  <a href="#部署"><strong>部署</strong></a> •
+  <a href="#贡献"><strong>贡献</strong></a> •
+  <a href="#思路"><strong>思路</strong></a> •
+  <a href="#现状"><strong>现状</strong></a>
+</p>
+
+<br>
+
+<!-- 底部装饰线 - 统一为深灰色调 -->
+<img width="100%" src="https://capsule-render.vercel.app/api?type=waving&color=455A64&height=100&section=footer" />
+
+</div>
+
+<br>
+
+## 前言
+
+很荣幸在这里介绍我的新项目ManimCat，它是~一只猫~
+
+本项目基于[manim-video-generator](https://github.com/rohitg00/manim-video-generator)架构级重构与二次开发而来，在此感谢原作者 Rohit Ghumare。我重写了整个前后端架构，解决了原版在并发和渲染稳定性上的痛点，并加以个人审美设计与应用的理想化改进。
+
+ ManimCat 是一个基于 AI 的数学动画生成平台，致力于让数学教师使用manim代码生成视频应用到课堂与教学之中。
+
+用户只需输入自然语言描述，系统便会通过 AI 自动生成 Manim 代码并渲染出精美的数学可视化视频，支持 LaTeX 公式、模板化生成以及代码错误自动修复，让复杂概念的动态展示变得触手可及。
+
+
+## 样例
+
+期待ing！
+
+## 技术
+
+### 技术栈
+
+**后端**
+- Express.js 4.18.0 + TypeScript 5.9.3
+- Bull 4.16.5 + ioredis 5.9.2（Redis 任务队列）
+- OpenAI SDK 4.50.0
+- Zod 3.23.0（数据验证）
+
+**前端**
+- React 19.2.0 + TypeScript 5.9.3
+- Vite 7.2.4
+- TailwindCSS 3.4.19
+- react-syntax-highlighter 16.1.0
+
+**系统依赖**
+- Python 3.11
+- Manim Community Edition 0.19.2
+- LaTeX（texlive）
+- ffmpeg + Xvfb
+
+**部署**
+- Docker + Docker Compose
+- Redis 7
+
+### 技术路线
+
+```
+用户请求 → POST /api/generate
+           ↓
+       [认证中间件]
+           ↓
+       [Bull 任务队列]
+           ↓
+    ┌───────────────────────────────────┐
+    │     视频生成处理器            │
+    ├───────────────────────────────────┤
+    │ 1. 检查概念缓存              │
+    │ 2. 概念分析                  │
+    │    - LaTeX 检测              │
+    │    - 模板匹配                 │
+    │    - AI 生成（两阶段）        │
+    │      ├─ 阶段1: 概念设计师      │
+    │      └─ 阶段2: 代码生成者      │
+    │ 3. 代码重试管理器             │
+    │    ├─ 首次生成代码 → 渲染     │
+    │    ├─ 失败 → 检查错误可修复性  │
+    │    ├─ 重试循环（最多4次）       │
+    │    │   ├─ 发送完整对话历史      │
+    │    │   ├─ AI 修复代码          │
+    │    │   └─ 重新渲染             │
+    │    └─ 成功/失败 → 存储结果     │
+    │ 4. 存储结果到 Redis           │
+    └───────────────────────────────────┘
+           ↓
+      前端轮询状态
+           ↓
+    GET /api/jobs/:jobId
+```
+
+**重试机制说明：**
+- 概念设计师结果会保存，不需要重复设计
+- 每次重试都发送完整的对话历史（原始提示词 + 历史代码 + 错误信息）
+- 最多重试 4 次，失败后任务标记为失败
+
+### 环境变量配置
+
+| 环境变量 | 默认值 | 说明 |
+|---------|--------|------|
+| `PORT` | `3000` | 服务端口 |
+| `REDIS_HOST` | `localhost` | Redis 地址 |
+| `REDIS_PORT` | `6379` | Redis 端口 |
+| `REDIS_PASSWORD` | - | Redis 密码（如需） |
+| `REDIS_DB` | `0` | Redis 数据库 |
+| `OPENAI_API_KEY` | - | OpenAI API Key（必填） |
+| `OPENAI_MODEL` | `glm-4-flash` | OpenAI 模型 |
+| `OPENAI_TIMEOUT` | `600000` | OpenAI 请求超时（毫秒） |
+| `CUSTOM_API_URL` | - | 自定义 OpenAI 兼容 API |
+| `MANIMCAT_API_KEY` | - | API 访问密钥（可选） |
+| `AI_TEMPERATURE` | `0.7` | 生成温度 |
+| `AI_MAX_TOKENS` | `1200` | 生成最大 tokens |
+| `DESIGNER_TEMPERATURE` | `0.8` | 设计师温度 |
+| `DESIGNER_MAX_TOKENS` | `800` | 设计师最大 tokens |
+| `REQUEST_TIMEOUT` | `600000` | 请求超时（毫秒） |
+| `JOB_TIMEOUT` | `600000` | 任务超时（毫秒） |
+| `MANIM_TIMEOUT` | `600000` | Manim 渲染超时（毫秒） |
+| `CODE_RETRY_MAX_RETRIES` | `4` | 代码修复重试次数 |
+
+**示例 `.env` 文件：**
+
+```bash
+PORT=3000
+REDIS_HOST=localhost
+REDIS_PORT=6379
+OPENAI_API_KEY=your-api-key-here
+OPENAI_MODEL=glm-4-flash
+OPENAI_TIMEOUT=600000
+AI_TEMPERATURE=0.7
+CODE_RETRY_MAX_RETRIES=4
+```
+
+## 部署
+
+请查看[部署文档](DEPLOYMENT.md)。
+
+## 贡献
+
+我对原作品进行了一些修改和重构，使其更符合我的设计想法：
+
+  1. 框架架构重构
+
+  - 后端使用 Express.js + Bull 任务队列架构
+
+  2. 前后端分离
+
+  - 前后端分离，React + TypeScript + Vite 独立前端
+
+  3. 存储方案升级
+
+  - Redis 存储（任务结果、状态、缓存，支持持久化）
+
+  4. 任务队列系统
+
+  - Bull + Redis 任务队列，支持重试、超时、指数退避
+
+  5. 前端技术栈
+
+  - React 19 + TailwindCSS + react-syntax-highlighter
+
+  6. 项目结构
+
+  - src/{config,middlewares,routes,services,queues,prompts,types,utils}/
+    frontend/src/{components,hooks,lib,types}/
+
+  7. 新增功能
+
+
+  - CORS 配置中间件
+
+  - 前端主题切换、设置模态框等组件
+
+  - 增加对第三方oai格式的请求支持
+
+  - 支持第三方自定义api
+
+  - 增加重试机制，增加前后端状态查询
+
+  - 重构UI，重构提示词，采取强注入manim api规范的方式
+
+  - 增加前端自定义视频参数
+
+  - 支持内存查询端点
+
+  - 优化提示词管理系统
+
+  - 对AI的输出结合提示词进行高度优化的正则清理，适配思考模型
+
+  - **自定义提示词管理**：新增专门的提示词管理页面，支持配置8种不同类型的提示词
+
+## 自定义提示词管理
+
+### 功能概述
+
+提示词管理页面提供了对 AI 生成行为的精细控制，用户可以配置不同阶段的提示词，影响从概念设计到代码生成和修复的各个环节。
+
+### 提示词类型
+
+系统支持 **8 种提示词类型**，分为两个主要类别：
+
+#### 系统级提示词（System）
+- **conceptDesigner**：概念设计系统提示词 - 用于指导 AI 理解数学概念并设计动画场景
+- **codeGeneration**：代码生成系统提示词 - 用于指导 AI 生成符合规范的 Manim 代码
+- **codeRetry**：系统重试提示词 - 仅用于代码渲染失败后的修复阶段，系统本身不会 重���，只是进入修复流程时使用该系统提示词
+
+#### 用户级提示词（User）
+- **conceptDesigner**：概念设计用户提示词 - 补充说明概念设计的具体需求和风格
+- **codeGeneration**：代码生成用户提示词 - 补充说明代码生成的具体要求和规范
+- **codeRetryInitial**：代码修复初始重试提示词 - 代码第一次失败时的修复指导
+- **codeRetryFix**：代码修复提示词 - 代码第二次失败时的详细修复指导
+
+### 使用流程
+
+1. **访问页面**：点击主界面右上角的“提示词管理”按钮（文档图标）
+2. **选择类型**：在侧边栏选择要编辑的提示词类型
+3. **编辑提示词**：在主编辑区输入或修改提示词内容
+4. **保存配置**：点击保存按钮或自动保存
+5. **应用效果**：配置会自动应用到下一次生成任务
+
+### 与主页面概念输入的关系
+
+- **主页面输入**：每次生成动画时需要重新输入的**具体任务描述**
+- **提示词管理**：一次配置，多次使用的**全局行为规则**
+- **结合使用**：系统会将用户输入的概念与配置的提示词结合使用，生成符合要求的动画
+
+### 特点
+
+- **侧边栏导航**：清晰的分类展示，支持快速切换
+- **恢复默认**：一键恢复到系统默认提示词
+- **字符限制**：每个提示词最多支持 20000 字符
+- **持久化存储**：配置会保存到浏览器 localStorage 中
+
+### 提示词生效逻辑
+
+- **默认优先级**：用户未修改时，使用后端默认提示词模板
+- **覆盖优先级**：用户修改后，仅覆盖对应字段，其余继续使用默认值
+- **重试阶段**：初次生成失败后进入修复流程，系统提示词使用 `codeRetry`，用户提示词使用 `codeRetryInitial`/`codeRetryFix`
+
+### 与原项目对比
+
+#### 原项目（manim-video-generator）
+- **硬编码提示词**：提示词直接写死在代码中，无法修改
+- **单一提示词**：整个项目只有一个固定的提示词模板
+- **缺乏灵活性**：无法根据不同任务调整 AI 的行为
+- **难以维护**：修改提示词需要重新部署应用
+
+#### 本项目（ManimCat）
+- **动态提示词**：支持 8 种不同类型的提示词配置
+- **分类管理**：系统级和用户级提示词分开管理，逻辑清晰
+- **实时生效**：配置后立即生效，无需重新部署
+- **版本控制**：支持恢复默认值和持久化存储
+
+### 提示词生效逻辑
+
+- **默认优先级**：用户未修改时，使用后端默认提示词模板
+- **覆盖优先级**：用户修改后，仅覆盖对应字段，其余继续使用默认值
+- **重试阶段**：初次生成失败后进入修复流程，系统提示词使用 `codeRetry`，用户提示词使用 `codeRetryInitial`/`codeRetryFix`
+- **精细控制**：每个阶段的提示词都可以独立配置
+
+### 架构优势
+
+这种设计使得 ManimCat 在处理不同类型的数学动画时更加灵活：
+- 对于简单任务，可以使用默认提示词快速生成
+- 对于复杂任务，可以通过提示词管理页面进行精细调整
+- 支持不同风格的数学可视化（严谨数学证明、通俗教学演示等）
+- 便于维护和扩展，新的提示词类型可以轻松添加
+
+  ## 思路
+
+  1. 在原作者使用AI一键生成manim视频并且后端渲染的基础上，增加了fallback机制，提升弱模型的生成完成度
+
+  2. 考虑到多数AI的manim语料训练并不多，为了降低AI幻觉率，采用提示词工程的方法，强注入manimv0.19.2的api索引表知识（自行爬取清洗制作）
+
+  ## 现状
+
+目前仍在完善项目，这只是第一个预览版本。我将致力于设计出更好的提示词与fallback流程。目标是可以对一道中国高考数学题进行完整的可视化。以下是建设的计划：
+
+- 优化提示词，生成更长篇幅的Manim代码和更精准的效果
+- 增加调度和重试功能 
+- 增加一定的验证页面，以防止滥用 （已经完成）
+- 增加自定义模式功能，使用不同提示词生成不同视频
+- 增加迭代功能，延长生成代码和视频长度
+- 提供可能的打包版本，让非开发者可以本地实现项目
+
+##  开源与版权声明 (License & Copyright)
+
+### 1. 软件协议 (Software License)
+本项目后端架构及前端部分实现参考/使用了 [manim-video-generator](https://github.com/rohitg00/manim-video-generator) 的核心思想。
+*   继承部分代码遵循 **MIT License**。
+*   本项目新增的重构代码、任务队列逻辑及前端组件，同样以 **MIT License** 向开源社区开放。
+
+### 2. 核心资产版权声明 (Core Assets - **PROHIBITED FOR COMMERCIAL USE**)
+**以下内容为本人（ManimCat 作者）原创，严禁任何形式的商用行为：**
+
+*   **Prompt Engineering（提示词工程）**：本项目中 `src/prompts/` 目录下所有高度优化的 Manim 代���生成提示词及逻辑，均为本人原创。
+*   **API Index Data**：本人自行爬取、清洗并制作的 Manim v0.18.2 API 索引表及相关强约束规则。
+*   **特定算法逻辑**：针对思考模型的正则清理算法及 fallback 容错机制。
+
+**未经本人书面许可，任何人不得将上述“核心资产”用于：**
+1.  直接打包作为付费产品销售。
+2.  集成在付费订阅制的商业 AI 服务中。
+3.  在未注明出处的情况下进行二次分发并获利。
+
+> 事实上，作者已经关注到市面上存在一些闭源商业项目，正利用类似的 AI + Manim 思路向数学教育工作者收取高额费用进行盈利。然而，开源社区目前仍缺乏针对教育场景深度优化的成熟项目。
+
+> ManimCat 的诞生正是为了对标并挑战这些闭源商业软件。 我希望通过开源的方式，让每一位老师都能廉价地享受到 AI 带来的教学可视化便利————你只需要支付api的费用，幸运的是，对于优秀的中国LLM大模型来说，这些花费很廉价。为了保护这一愿景不被商业机构剽窃并反向收割用户，我坚决禁止任何对本项目核心提示词及索引数据的商业授权。
+
+
+## 维护说明
+
+由于作者精力有限（个人业余兴趣开发者，非专业背景），目前完全无法对外部代码进行有效的审查和长期维护。因此，本项目暂不支持团队协同开发，不接受 PR。感谢理解。
+
+如果你有好的建议或发现了 Bug，欢迎提交 Issue 进行讨论，我会根据自己的节奏进行改进。如果你希望在本项目基础上进行大规模修改，欢迎 Fork 出属于你自己的版本。
+

docker-compose.yml

@@ -15,7 +15,7 @@ services:
     healthcheck:
       test: ["CMD", "redis-cli", "ping"]
       interval: 5s
-      timeout: 3s
+      timeout: 600s
       retries: 10
       start_period: 5s
     command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru
@@ -55,7 +55,7 @@ services:
     healthcheck:
       test: ["CMD-SHELL", "node -e \"require('http').get('http://localhost:3000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))\""]
       interval: 30s
-      timeout: 10s
+      timeout: 600s
       retries: 3
       start_period: 40s
     networks:
@@ -81,3 +81,4 @@ volumes:
     driver: local
   video-storage:
     driver: local
+

frontend/src/App.tsx

@@ -7,12 +7,14 @@ import { LoadingSpinner } from './components/LoadingSpinner';
 import { ResultSection } from './components/ResultSection';
 import { ThemeToggle } from './components/ThemeToggle';
 import { SettingsModal } from './components/SettingsModal';
+import { PromptsManager } from './components/PromptsManager';
 import ManimCatLogo from './components/ManimCatLogo';
 import type { Quality } from './types/api';
 
 function App() {
   const { status, result, error, jobId, stage, generate, reset, cancel } = useGeneration();
   const [settingsOpen, setSettingsOpen] = useState(false);
+  const [promptsOpen, setPromptsOpen] = useState(false);
 
   const handleSubmit = (data: { concept: string; quality: Quality; forceRefresh: boolean }) => {
     generate(data);
@@ -22,9 +24,18 @@ function App() {
     <div className="min-h-screen bg-bg-primary transition-colors duration-300">
       {/* 主题切换按钮 */}
       <div className="fixed top-4 right-4 z-50 flex items-center gap-2">
+        <button
+          onClick={() => setPromptsOpen(true)}
+          className="p-2.5 text-text-secondary/70 hover:text-text-secondary hover:bg-bg-secondary/50 rounded-full transition-all active:scale-90 active:duration-75"
+          title="提示词管理"
+        >
+          <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M7 8h10M7 12h4m1 8l-4-4H5a2 2 0 01-2-2V6a2 2 0 012-2h14a2 2 0 012 2v8a2 2 0 01-2 2h-3l-4 4z" />
+          </svg>
+        </button>
         <button
           onClick={() => setSettingsOpen(true)}
-          className="p-2.5 text-text-secondary/70 hover:text-text-secondary hover:bg-bg-secondary/50 rounded-full transition-all"
+          className="p-2.5 text-text-secondary/70 hover:text-text-secondary hover:bg-bg-secondary/50 rounded-full transition-all active:scale-90 active:duration-75"
           title="API 设置"
         >
           <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
@@ -141,6 +152,12 @@ function App() {
           console.log('保存配置:', config);
         }}
       />
+
+      {/* 提示词管理 */}
+      <PromptsManager
+        isOpen={promptsOpen}
+        onClose={() => setPromptsOpen(false)}
+      />
     </div>
   );
 }

frontend/src/components/PromptInput.tsx

@@ -0,0 +1,88 @@
+// 提示词输入组件
+// 提供统一的提示词编辑界面
+
+interface PromptInputProps {
+  value: string;
+  onChange: (value: string) => void;
+  label: string;
+  placeholder?: string;
+  maxLength?: number;
+  disabled?: boolean;
+  showWordCount?: boolean;
+  onSave?: () => void;
+  onRestoreDefault?: () => void;
+}
+
+export function PromptInput({
+  value,
+  onChange,
+  label,
+  placeholder,
+  maxLength = 20000,
+  disabled = false,
+  showWordCount = true,
+  onSave,
+  onRestoreDefault
+}: PromptInputProps) {
+  const wordCount = value.length;
+  const isMaxLength = wordCount >= maxLength;
+
+  return (
+    <div className="w-full space-y-4">
+      {/* 标签和操作按钮 */}
+      <div className="flex items-center justify-between">
+        <label className="text-sm font-medium text-text-primary">
+          {label}
+        </label>
+        <div className="flex gap-2">
+          {onRestoreDefault && (
+            <button
+              onClick={onRestoreDefault}
+              disabled={disabled}
+              className="px-3 py-1.5 text-xs text-text-secondary hover:text-text-primary hover:bg-bg-secondary/50 rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+            >
+              恢复默认
+            </button>
+          )}
+          {onSave && (
+            <button
+              onClick={onSave}
+              disabled={disabled}
+              className="px-3 py-1.5 text-xs bg-accent text-white hover:bg-accent-hover rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+            >
+              保存
+            </button>
+          )}
+        </div>
+      </div>
+
+      {/* 输入区域 */}
+      <textarea
+        value={value}
+        onChange={(e) => {
+          if (e.target.value.length <= maxLength) {
+            onChange(e.target.value);
+          }
+        }}
+        placeholder={placeholder}
+        disabled={disabled}
+        rows={20}
+        className={`w-full px-4 py-3 bg-bg-secondary/50 border border-bg-secondary/50 rounded-xl text-sm text-text-primary placeholder-text-secondary/40 focus:outline-none focus:ring-2 focus:ring-accent/20 focus:bg-bg-secondary/70 focus:border-accent/30 transition-all resize-y min-h-[480px] ${
+          isMaxLength
+            ? 'border-red-500/30 focus:ring-red-500/20 focus:border-red-500/50'
+            : ''
+        }`}
+      />
+
+      {/* 字符计数 */}
+      {showWordCount && (
+        <div className="flex items-center justify-between text-xs text-text-secondary/60">
+          <span>{wordCount} / {maxLength} 字符</span>
+          {isMaxLength && (
+            <span className="text-red-500">已达到字符限制</span>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/components/PromptSidebar.tsx

@@ -0,0 +1,189 @@
+// 提示词管理侧边栏组件
+
+import type { ReactNode } from 'react';
+
+interface SidebarItemProps {
+  icon: ReactNode;
+  label: string;
+  active?: boolean;
+  onClick?: () => void;
+  children?: ReactNode;
+  expanded?: boolean;
+  onToggle?: () => void;
+  indent?: boolean;
+}
+
+function SidebarItem({
+  icon,
+  label,
+  active = false,
+  onClick,
+  children,
+  expanded = true,
+  onToggle,
+  indent = false
+}: SidebarItemProps) {
+  const hasChildren = !!children;
+
+  return (
+    <div className={`${indent ? 'ml-4' : ''}`}>
+      <button
+        onClick={() => hasChildren ? onToggle?.() : onClick?.()}
+        className={`w-full flex items-center gap-3 px-4 py-2.5 text-sm transition-colors ${
+          active
+            ? 'text-accent bg-bg-secondary/50 rounded-lg'
+            : 'text-text-secondary hover:text-text-primary hover:bg-bg-secondary/30 rounded-lg'
+        }`}
+      >
+        <span className="w-5 h-5 flex items-center justify-center">{icon}</span>
+        <span className="flex-1 text-left">{label}</span>
+        {hasChildren && (
+          <svg
+            className={`w-4 h-4 transition-transform ${expanded ? 'rotate-180' : ''}`}
+            fill="none"
+            stroke="currentColor"
+            viewBox="0 0 24 24"
+          >
+            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" />
+          </svg>
+        )}
+      </button>
+      {hasChildren && expanded && (
+        <div className="mt-1 space-y-1">
+          {children}
+        </div>
+      )}
+    </div>
+  );
+}
+
+interface PromptSidebarProps {
+  activeSection: string;
+  activePrompt: string;
+  onSectionChange: (section: string, prompt: string) => void;
+}
+
+export function PromptSidebar({
+  activeSection,
+  activePrompt,
+  onSectionChange
+}: PromptSidebarProps) {
+  return (
+    <div className="w-64 bg-bg-secondary/30 border-r border-bg-secondary/50 overflow-y-auto">
+      <div className="p-4 space-y-6">
+        {/* 概念设计提示词 */}
+        <div>
+          <h3 className="px-4 text-xs font-medium text-text-secondary/60 uppercase tracking-wider mb-2">
+            概念设计
+          </h3>
+          <div className="space-y-1">
+            <SidebarItem
+              icon={
+                <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M7 21a4 4 0 01-4-4V5a2 2 0 012-2h4a2 2 0 012 2v12a4 4 0 01-4 4zm0 0h12a2 2 0 002-2v-4a2 2 0 00-2-2h-2.343M11 7.343l1.657-1.657a2 2 0 012.828 0l2.829 2.829a2 2 0 010 2.828l-8.486 8.485M7 17h.01" />
+                </svg>
+              }
+              label="系统提示词"
+              active={activeSection === 'system' && activePrompt === 'conceptDesigner'}
+              onClick={() => onSectionChange('system', 'conceptDesigner')}
+              indent
+            />
+            <SidebarItem
+              icon={
+                <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M15.232 5.232l3.536 3.536m-2.036-5.036a2.5 2.5 0 113.536 3.536L6.5 21.036H3v-3.572L16.732 3.732z" />
+                </svg>
+              }
+              label="用户提示词"
+              active={activeSection === 'user' && activePrompt === 'conceptDesigner'}
+              onClick={() => onSectionChange('user', 'conceptDesigner')}
+              indent
+            />
+          </div>
+        </div>
+
+        {/* 代码生成提示词 */}
+        <div>
+          <h3 className="px-4 text-xs font-medium text-text-secondary/60 uppercase tracking-wider mb-2">
+            代码生成
+          </h3>
+          <div className="space-y-1">
+            <SidebarItem
+              icon={
+                <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 9l4-4 4 4m0 6l-4 4-4-4" />
+                </svg>
+              }
+              label="系统提示词"
+              active={activeSection === 'system' && activePrompt === 'codeGeneration'}
+              onClick={() => onSectionChange('system', 'codeGeneration')}
+              indent
+            />
+            <SidebarItem
+              icon={
+                <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M10 20l4-16m4 4l4 4-4 4M6 16l-4-4 4-4" />
+                </svg>
+              }
+              label="用户提示词"
+              active={activeSection === 'user' && activePrompt === 'codeGeneration'}
+              onClick={() => onSectionChange('user', 'codeGeneration')}
+              indent
+            />
+          </div>
+        </div>
+
+        {/* 代码修复提示词 */}
+        <div>
+          <h3 className="px-4 text-xs font-medium text-text-secondary/60 uppercase tracking-wider mb-2">
+            代码修复
+          </h3>
+          <div className="space-y-1">
+            <SidebarItem
+              icon={
+                <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z" />
+                </svg>
+              }
+              label="初始重试提示词"
+              active={activeSection === 'user' && activePrompt === 'codeRetryInitial'}
+              onClick={() => onSectionChange('user', 'codeRetryInitial')}
+              indent
+            />
+            <SidebarItem
+              icon={
+                <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M13 10V3L4 14h7v7l9-11h-7z" />
+                </svg>
+              }
+              label="修复提示词"
+              active={activeSection === 'user' && activePrompt === 'codeRetryFix'}
+              onClick={() => onSectionChange('user', 'codeRetryFix')}
+              indent
+            />
+          </div>
+        </div>
+
+        {/* 系统重试提示词 */}
+        <div>
+          <h3 className="px-4 text-xs font-medium text-text-secondary/60 uppercase tracking-wider mb-2">
+            系统重试
+          </h3>
+          <div className="space-y-1">
+            <SidebarItem
+              icon={
+                <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
+                </svg>
+              }
+              label="重试提示词"
+              active={activeSection === 'system' && activePrompt === 'codeRetry'}
+              onClick={() => onSectionChange('system', 'codeRetry')}
+              indent
+            />
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/PromptsManager.tsx

@@ -0,0 +1,214 @@
+// 提示词管理主页面组件
+// 包含侧边栏导航和主编辑区的完整布局
+
+import { useEffect, useState } from 'react';
+import { PromptSidebar } from './PromptSidebar';
+import { PromptInput } from './PromptInput';
+import { usePrompts } from '../hooks/usePrompts';
+
+interface PromptsManagerProps {
+  isOpen: boolean;
+  onClose: () => void;
+}
+
+// 提示词类型配置
+const PROMPT_CONFIG = {
+  system: {
+    conceptDesigner: {
+      label: '概念设计系统提示词',
+      placeholder: '输入概念设计阶段的系统提示词...',
+      description: '用于指导 AI 理解数学概念并设计动画场景'
+    },
+    codeGeneration: {
+      label: '代码生成系统提示词',
+      placeholder: '输入代码生成阶段的系统提示词...',
+      description: '用于指导 AI 生成符合规范的 Manim 代码'
+    },
+    codeRetry: {
+      label: '系统重试提示词',
+      placeholder: '输入系统重试阶段的提示词...',
+      description: '用于指导 AI 在代码失败时进行重试和优化'
+    }
+  },
+  user: {
+    conceptDesigner: {
+      label: '概念设计用户提示词',
+      placeholder: '输入概念设计阶段的用户提示词...',
+      description: '补充说明概念设计的具体需求和风格'
+    },
+    codeGeneration: {
+      label: '代码生成用户提示词',
+      placeholder: '输入代码生成阶段的用户提示词...',
+      description: '补充说明代码生成的具体要求和规范'
+    },
+    codeRetryInitial: {
+      label: '代码修复初始重试提示词',
+      placeholder: '输入代码修复初始重试阶段的提示词...',
+      description: '代码第一次失败时的修复指导'
+    },
+    codeRetryFix: {
+      label: '代码修复提示词',
+      placeholder: '输入代码修复阶段的提示词...',
+      description: '代码第二次失败时的详细修复指导'
+    }
+  }
+};
+
+export function PromptsManager({ isOpen, onClose }: PromptsManagerProps) {
+  const {
+    isLoading,
+    activeSection,
+    activePrompt,
+    setActiveSection,
+    setActivePrompt,
+    getCurrentPrompt,
+    setCurrentPrompt,
+    restoreDefault
+  } = usePrompts();
+
+    const [saveStatus, setSaveStatus] = useState<'idle' | 'saving' | 'success' | 'error'>('idle');
+
+    const TRANSITION_MS = 400;
+
+    const [shouldRender, setShouldRender] = useState(isOpen);
+
+    const [isVisible, setIsVisible] = useState(isOpen);
+
+  useEffect(() => {
+    if (isOpen) {
+      setShouldRender(true);
+      // 延迟一帧再显示，确保初始 opacity-0 生效
+      setTimeout(() => setIsVisible(true), 50);
+    } else {
+      setIsVisible(false);
+      const timeout = window.setTimeout(() => setShouldRender(false), 400);
+      return () => window.clearTimeout(timeout);
+    }
+  }, [isOpen]);
+
+  // 处理侧边栏导航
+  const handleSectionChange = (section: string, prompt: string) => {
+    setActiveSection(section);
+    setActivePrompt(prompt);
+    setSaveStatus('idle');
+  };
+
+  // 处理保存
+  const handleSave = () => {
+    setSaveStatus('saving');
+    setTimeout(() => {
+      setSaveStatus('success');
+      setTimeout(() => setSaveStatus('idle'), 2000);
+    }, 500);
+  };
+
+  // 处理恢复默认
+  const handleRestoreDefault = () => {
+    restoreDefault();
+    setSaveStatus('success');
+    setTimeout(() => setSaveStatus('idle'), 2000);
+  };
+
+  // 获取当前配置
+  const currentConfig = activeSection === 'system'
+    ? PROMPT_CONFIG.system[activePrompt as keyof typeof PROMPT_CONFIG.system]
+    : PROMPT_CONFIG.user[activePrompt as keyof typeof PROMPT_CONFIG.user];
+
+  if (!shouldRender) return null;
+
+  return (
+    <div
+      className={`fixed inset-0 z-50 flex flex-col bg-bg-primary transition-all duration-[400ms] ease-out ${isVisible ? 'opacity-100 translate-y-0 scale-100' : 'opacity-0 translate-y-8 scale-95 pointer-events-none'}`}
+    >
+      {/* 顶部导航栏 */}
+      <div className="h-16 bg-bg-secondary border-b border-bg-secondary/50 flex items-center justify-between px-6">
+        <div className="flex items-center gap-4">
+          <button
+            onClick={onClose}
+            className="p-2 text-text-secondary hover:text-text-primary hover:bg-bg-secondary/50 rounded-lg transition-colors"
+            title="返回主界面"
+          >
+            <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M15 19l-7-7 7-7" />
+            </svg>
+          </button>
+          <h1 className="text-lg font-medium text-text-primary">提示词管理</h1>
+        </div>
+        <div className="flex items-center gap-3">
+          {saveStatus === 'success' && (
+            <div className="flex items-center gap-2 text-sm text-green-600 dark:text-green-400">
+              <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 13l4 4L19 7" />
+              </svg>
+              <span>保存成功</span>
+            </div>
+          )}
+          <button
+            onClick={handleSave}
+            disabled={saveStatus === 'saving'}
+            className="px-4 py-2 bg-accent text-white text-sm font-medium rounded-lg hover:bg-accent-hover disabled:opacity-50 disabled:cursor-not-allowed transition-all"
+          >
+            {saveStatus === 'saving' ? (
+              <>
+                <svg className="animate-spin w-4 h-4 inline mr-2" fill="none" viewBox="0 0 24 24">
+                  <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
+                  <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+                </svg>
+                保存中...
+              </>
+            ) : (
+              '保存'
+            )}
+          </button>
+        </div>
+      </div>
+
+      {/* 主内容区 */}
+      <div className="flex-1 flex overflow-hidden">
+        {/* 侧边栏 */}
+        <PromptSidebar
+          activeSection={activeSection}
+          activePrompt={activePrompt}
+          onSectionChange={handleSectionChange}
+        />
+
+        {/* 主编辑区 */}
+        <div className="flex-1 overflow-y-auto p-8">
+          <div className="max-w-4xl mx-auto space-y-8">
+            {/* 当前提示词信息 */}
+            <div className="bg-bg-secondary/30 rounded-xl p-6">
+              <h2 className="text-xl font-medium text-text-primary mb-2">
+                {currentConfig?.label || '提示词编辑'}
+              </h2>
+              <p className="text-sm text-text-secondary/70">
+                {currentConfig?.description || '在此处编辑提示词，它将用于指导 AI 生成和优化动画'}
+              </p>
+            </div>
+
+            {/* 输入组件 */}
+            <div className="space-y-6">
+              <PromptInput
+                value={getCurrentPrompt()}
+                onChange={setCurrentPrompt}
+                label={currentConfig?.label || '提示词'}
+                placeholder={currentConfig?.placeholder}
+                showWordCount
+                disabled={isLoading}
+                onSave={handleSave}
+                onRestoreDefault={handleRestoreDefault}
+              />
+
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* 底部状态栏 */}
+      <div className="h-10 bg-bg-secondary border-t border-bg-secondary/50 flex items-center justify-between px-6 text-xs text-text-secondary">
+        <span>提示词管理</span>
+        <span>字符限制：20000</span>
+      </div>
+    </div>
+  );
+}
+

frontend/src/hooks/useGeneration.ts

@@ -1,227 +1,253 @@
-// 生成请求 Hook
-
-import { useState, useCallback, useRef, useEffect } from 'react';
-import { generateAnimation, getJobStatus } from '../lib/api';
-import { loadCustomConfig, generateWithCustomApi } from '../lib/custom-ai';
-import type { GenerateRequest, JobResult, ProcessingStage, VideoConfig } from '../types/api';
-
-interface UseGenerationReturn {
-  status: 'idle' | 'processing' | 'completed' | 'error';
-  result: JobResult | null;
-  error: string | null;
-  jobId: string | null;
-  stage: ProcessingStage;
-  generate: (request: GenerateRequest) => Promise<void>;
-  reset: () => void;
-  cancel: () => void;
-}
-
-/** 轮询间隔 */
-const POLL_INTERVAL = 1000;
-
-/** 从 localStorage 加载超时配置 */
-function getTimeoutConfig(): number {
-  try {
-    const saved = localStorage.getItem('manimcat_settings');
-    if (saved) {
-      const parsed = JSON.parse(saved);
-      if (parsed.video?.timeout) {
-        return parsed.video.timeout;
-      }
-    }
-  } catch {
-    // 忽略错误，使用默认值
-  }
-  return 120; // 默认 120 秒
-}
-
-export function useGeneration(): UseGenerationReturn {
-  const [status, setStatus] = useState<'idle' | 'processing' | 'completed' | 'error'>('idle');
-  const [result, setResult] = useState<JobResult | null>(null);
-  const [error, setError] = useState<string | null>(null);
-  const [jobId, setJobId] = useState<string | null>(null);
-  const [stage, setStage] = useState<ProcessingStage>('analyzing');
-
-  const pollCountRef = useRef(0);
-  const pollIntervalRef = useRef<number | null>(null);
-  const abortControllerRef = useRef<AbortController | null>(null);
-
-  // 清理轮询和请求
-  useEffect(() => {
-    return () => {
-      if (pollIntervalRef.current) {
-        clearInterval(pollIntervalRef.current);
-      }
-      abortControllerRef.current?.abort();
-    };
-  }, []);
-
-  // 更新处理阶段
-  const updateStage = useCallback((count: number) => {
-    if (count < 5) {
-      setStage('analyzing');
-    } else if (count < 15) {
-      setStage('generating');
-    } else if (count < 25) {
-      setStage('refining');
-    } else if (count < 60) {
-      setStage('rendering');
-    } else {
-      setStage('still-rendering');
-    }
-  }, []);
-
-  // 开始轮询
-  const startPolling = useCallback((id: string) => {
-    pollCountRef.current = 0;
-    setJobId(id);
-    
-    // 获取用户配置的超时时间
-    const maxPollCount = getTimeoutConfig();
-
-    pollIntervalRef.current = window.setInterval(async () => {
-      pollCountRef.current++;
-
-      try {
-        const data = await getJobStatus(id, abortControllerRef.current?.signal);
-
-        if (data.status === 'completed') {
-          if (pollIntervalRef.current) {
-            clearInterval(pollIntervalRef.current);
-          }
-          setStatus('completed');
-          setResult(data);
-        } else if (data.status === 'failed') {
-          if (pollIntervalRef.current) {
-            clearInterval(pollIntervalRef.current);
-          }
-          setStatus('error');
-          setError(data.error || '生成失败');
-        } else {
-          // 使用后端返回的 stage，如果没有则使用前端估算的 fallback
-          if (data.stage) {
-            setStage(data.stage);
-          } else {
-            updateStage(pollCountRef.current);
-          }
-        }
-
-        // 超时检查（使用用户配置的超时时间）
-        if (pollCountRef.current >= maxPollCount) {
-          if (pollIntervalRef.current) {
-            clearInterval(pollIntervalRef.current);
-          }
-          setStatus('error');
-          setError(`生成超时（${maxPollCount}秒），请尝试更简单的概念或增加超时时间`);
-        }
-      } catch (err) {
-        if (err instanceof Error && err.name === 'AbortError') {
-          return;
-        }
-
-        // 如果是连接错误（后端断开），停止轮询
-        if (err instanceof Error && (err.message.includes('ECONNREFUSED') || err.message.includes('Failed to fetch'))) {
-          console.error('后端连接断开，停止轮询');
-          if (pollIntervalRef.current) {
-            clearInterval(pollIntervalRef.current);
-          }
-          setStatus('error');
-          setError('后端服务已断开，请刷新页面重试');
-          return;
-        }
-
-        console.error('轮询错误:', err);
-
-        // 如果是任务未找到 (404) 或明确的失效提示
-        if (err instanceof Error && (err.message.includes('未找到任务') || err.message.includes('失效'))) {
-          if (pollIntervalRef.current) {
-            clearInterval(pollIntervalRef.current);
-            pollIntervalRef.current = null;
-          }
-          setStatus('error');
-          setError('任务已失效（可能因服务重启），请重新生成');
-          return;
-        }
-      }
-    }, POLL_INTERVAL);
-  }, [updateStage]);
-
-  // 生成动画
-  const generate = useCallback(async (request: GenerateRequest) => {
-    setStatus('processing');
-    setError(null);
-    setResult(null);
-    setStage('analyzing');
-    pollCountRef.current = 0;
-    abortControllerRef.current = new AbortController();
-
-    try {
-      // 检查是否有自定义 AI 配置
-      const customConfig = loadCustomConfig();
-
-      if (customConfig) {
-        // 使用自定义 AI 生成代码
-        setStage('generating');
-        const code = await generateWithCustomApi(
-          request.concept,
-          customConfig,
-          abortControllerRef.current.signal
-        );
-
-        // 发送代码到后端渲染
-        setStage('rendering');
-        const response = await generateAnimation(
-          { ...request, code },
-          abortControllerRef.current.signal
-        );
-        startPolling(response.jobId);
-      } else {
-        // 使用后端 AI
-        const response = await generateAnimation(request, abortControllerRef.current.signal);
-        startPolling(response.jobId);
-      }
-    } catch (err) {
-      if (err instanceof Error && err.name === 'AbortError') {
-        return;
-      }
-      setStatus('error');
-      setError(err instanceof Error ? err.message : '生成请求失败');
-    }
-  }, [startPolling]);
-
-  // 重置状态
-  const reset = useCallback(() => {
-    setStatus('idle');
-    setError(null);
-    setResult(null);
-    setJobId(null);
-    setStage('analyzing');
-    if (pollIntervalRef.current) {
-      clearInterval(pollIntervalRef.current);
-    }
-    abortControllerRef.current?.abort();
-  }, []);
-
-  // 取消生成
-  const cancel = useCallback(() => {
-    if (pollIntervalRef.current) {
-      clearInterval(pollIntervalRef.current);
-    }
-    abortControllerRef.current?.abort();
-    setStatus('idle');
-    setError(null);
-    setJobId(null);
-    setStage('analyzing');
-  }, []);
-
-  return {
-    status,
-    result,
-    error,
-    jobId,
-    stage,
-    generate,
-    reset,
-    cancel,
-  };
-}
+// 生成请求 Hook
+
+import { useState, useCallback, useRef, useEffect } from 'react';
+import { generateAnimation, getJobStatus, cancelJob } from '../lib/api';
+import { loadCustomConfig, generateWithCustomApi } from '../lib/custom-ai';
+import { loadPrompts } from './usePrompts';
+import type { GenerateRequest, JobResult, ProcessingStage, VideoConfig } from '../types/api';
+
+interface UseGenerationReturn {
+  status: 'idle' | 'processing' | 'completed' | 'error';
+  result: JobResult | null;
+  error: string | null;
+  jobId: string | null;
+  stage: ProcessingStage;
+  generate: (request: GenerateRequest) => Promise<void>;
+  reset: () => void;
+  cancel: () => void;
+}
+
+/** 轮询间隔 */
+const POLL_INTERVAL = 1000;
+
+/** 从 localStorage 加载超时配置 */
+function getTimeoutConfig(): number {
+  try {
+    const saved = localStorage.getItem('manimcat_settings');
+    if (saved) {
+      const parsed = JSON.parse(saved);
+      if (parsed.video?.timeout) {
+        return parsed.video.timeout;
+      }
+    }
+  } catch {
+    // 忽略错误，使用默认值
+  }
+  return 120; // 默认 120 秒
+}
+
+export function useGeneration(): UseGenerationReturn {
+  const [status, setStatus] = useState<'idle' | 'processing' | 'completed' | 'error'>('idle');
+  const [result, setResult] = useState<JobResult | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [jobId, setJobId] = useState<string | null>(null);
+  const [stage, setStage] = useState<ProcessingStage>('analyzing');
+
+  const pollCountRef = useRef(0);
+  const pollIntervalRef = useRef<number | null>(null);
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  const requestCancel = useCallback(async (id: string | null) => {
+    if (!id) {
+      return;
+    }
+
+    try {
+      await cancelJob(id);
+    } catch (err) {
+      console.warn('取消任务失败', err);
+    }
+  }, []);
+
+  // 清理轮询和请求
+  useEffect(() => {
+    return () => {
+      if (pollIntervalRef.current) {
+        clearInterval(pollIntervalRef.current);
+      }
+      abortControllerRef.current?.abort();
+    };
+  }, []);
+
+  // 更新处理阶段
+  const updateStage = useCallback((count: number) => {
+    if (count < 5) {
+      setStage('analyzing');
+    } else if (count < 15) {
+      setStage('generating');
+    } else if (count < 25) {
+      setStage('refining');
+    } else if (count < 60) {
+      setStage('rendering');
+    } else {
+      setStage('still-rendering');
+    }
+  }, []);
+
+  // 开始轮询
+  const startPolling = useCallback((id: string) => {
+    pollCountRef.current = 0;
+    setJobId(id);
+    
+    // 获取用户配置的超时时间
+    const maxPollCount = getTimeoutConfig();
+
+    pollIntervalRef.current = window.setInterval(async () => {
+      pollCountRef.current++;
+
+      try {
+        const data = await getJobStatus(id, abortControllerRef.current?.signal);
+
+        if (data.status === 'completed') {
+          if (pollIntervalRef.current) {
+            clearInterval(pollIntervalRef.current);
+          }
+          setStatus('completed');
+          setResult(data);
+        } else if (data.status === 'failed') {
+          if (pollIntervalRef.current) {
+            clearInterval(pollIntervalRef.current);
+          }
+          setStatus('error');
+          if (data.cancel_reason) {
+            setError(`任务已取消：${data.cancel_reason}`);
+          } else {
+            setError(data.error || '生成失败');
+          }
+        } else {
+          // 使用后端返回的 stage，如果没有则使用前端估算的 fallback
+          if (data.stage) {
+            setStage(data.stage);
+          } else {
+            updateStage(pollCountRef.current);
+          }
+        }
+
+        // 超时检查（使用用户配置的超时时间）
+        if (pollCountRef.current >= maxPollCount) {
+          if (pollIntervalRef.current) {
+            clearInterval(pollIntervalRef.current);
+          }
+          await requestCancel(id);
+          setStatus('error');
+          setError(`生成超时（${maxPollCount}秒），请尝试更简单的概念或增加超时时间`);
+        }
+      } catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+          return;
+        }
+
+        // 如果是连接错误（后端断开），停止轮询
+        if (err instanceof Error && (err.message.includes('ECONNREFUSED') || err.message.includes('Failed to fetch'))) {
+          console.error('后端连接断开，停止轮询');
+          if (pollIntervalRef.current) {
+            clearInterval(pollIntervalRef.current);
+          }
+          setStatus('error');
+          setError('后端服务已断开，请刷新页面重试');
+          return;
+        }
+
+        console.error('轮询错误:', err);
+        await requestCancel(id);
+
+        // 如果是任务未找到 (404) 或明确的失效提示
+        if (err instanceof Error && (err.message.includes('未找到任务') || err.message.includes('失效'))) {
+          if (pollIntervalRef.current) {
+            clearInterval(pollIntervalRef.current);
+            pollIntervalRef.current = null;
+          }
+          setStatus('error');
+          setError('任务已失效（可能因服务重启），请重新生成');
+          return;
+        }
+      }
+    }, POLL_INTERVAL);
+  }, [requestCancel, updateStage]);
+
+  // 生成动画
+  const generate = useCallback(async (request: GenerateRequest) => {
+    setStatus('processing');
+    setError(null);
+    setResult(null);
+    setStage('analyzing');
+    pollCountRef.current = 0;
+    abortControllerRef.current = new AbortController();
+
+    try {
+      // 加载提示词配置
+      const promptOverrides = loadPrompts();
+
+      // 检查是否有自定义 AI 配置
+      const customConfig = loadCustomConfig();
+
+      if (customConfig) {
+        // 使用自定义 AI 生成代码
+        setStage('generating');
+        const code = await generateWithCustomApi(
+          request.concept,
+          customConfig,
+          abortControllerRef.current.signal
+        );
+
+        // 发送代码到后端渲染
+        setStage('rendering');
+        const response = await generateAnimation(
+          { ...request, code, promptOverrides },
+          abortControllerRef.current.signal
+        );
+        startPolling(response.jobId);
+      } else {
+        // 使用后端 AI
+        const response = await generateAnimation(
+          { ...request, promptOverrides },
+          abortControllerRef.current.signal
+        );
+        startPolling(response.jobId);
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name === 'AbortError') {
+        return;
+      }
+      setStatus('error');
+      setError(err instanceof Error ? err.message : '生成请求失败');
+    }
+  }, [startPolling]);
+
+  // 重置状态
+  const reset = useCallback(() => {
+    setStatus('idle');
+    setError(null);
+    setResult(null);
+    setJobId(null);
+    setStage('analyzing');
+    if (pollIntervalRef.current) {
+      clearInterval(pollIntervalRef.current);
+    }
+    abortControllerRef.current?.abort();
+  }, []);
+
+  // 取消生成
+  const cancel = useCallback(() => {
+    if (pollIntervalRef.current) {
+      clearInterval(pollIntervalRef.current);
+    }
+    void requestCancel(jobId);
+    abortControllerRef.current?.abort();
+    setStatus('idle');
+    setError(null);
+    setJobId(null);
+    setStage('analyzing');
+  }, [jobId, requestCancel]);
+
+  return {
+    status,
+    result,
+    error,
+    jobId,
+    stage,
+    generate,
+    reset,
+    cancel,
+  };
+}

frontend/src/hooks/usePrompts.ts

@@ -0,0 +1,173 @@
+// 提示词管理 Hook
+// 负责提示词的状态管理、存储和加载
+
+import { useState, useEffect, useCallback } from 'react';
+import { getPromptDefaults } from '../lib/api';
+import type { PromptOverrides } from '../types/api';
+
+/** 存储在 localStorage 中的键名 */
+const PROMPTS_STORAGE_KEY = 'manimcat_prompt_overrides';
+
+/** 默认提示词配置 */
+const DEFAULT_PROMPTS: PromptOverrides = {
+  system: {
+    conceptDesigner: '',
+    codeGeneration: '',
+    codeRetry: '',
+  },
+  user: {
+    conceptDesigner: '',
+    codeGeneration: '',
+    codeRetryInitial: '',
+    codeRetryFix: '',
+  },
+};
+
+/** 从 localStorage 加载提示词配置 */
+/** Load prompt overrides from localStorage if available. */
+export function loadStoredPrompts(): PromptOverrides | null {
+  try {
+    const saved = localStorage.getItem(PROMPTS_STORAGE_KEY);
+    if (saved) {
+      const parsed = JSON.parse(saved);
+      return {
+        system: { ...DEFAULT_PROMPTS.system, ...parsed.system },
+        user: { ...DEFAULT_PROMPTS.user, ...parsed.user },
+      };
+    }
+  } catch (error) {
+    console.error('Failed to load prompts:', error);
+  }
+  return null;
+}
+
+export function loadPrompts(): PromptOverrides {
+  return loadStoredPrompts() || DEFAULT_PROMPTS;
+}
+
+/** 保存提示词配置到 localStorage */
+export function savePrompts(prompts: PromptOverrides): void {
+  try {
+    localStorage.setItem(PROMPTS_STORAGE_KEY, JSON.stringify(prompts));
+  } catch (error) {
+    console.error('Failed to save prompts:', error);
+  }
+}
+
+/** 提示词管理 Hook */
+export function usePrompts() {
+  const [prompts, setPrompts] = useState<PromptOverrides>(DEFAULT_PROMPTS);
+  const [defaultPrompts, setDefaultPrompts] = useState<PromptOverrides>(DEFAULT_PROMPTS);
+  const [isLoading, setIsLoading] = useState<boolean>(true);
+  const [activeSection, setActiveSection] = useState<string>('system');
+  const [activePrompt, setActivePrompt] = useState<string>('conceptDesigner');
+
+  // 从 localStorage 加载配置
+  useEffect(() => {
+    const savedPrompts = loadStoredPrompts();
+    if (savedPrompts) {
+      setPrompts(savedPrompts);
+    }
+
+    let isActive = true;
+    const loadDefaults = async () => {
+      setIsLoading(true);
+      try {
+        const defaults = await getPromptDefaults();
+        if (isActive) {
+          setDefaultPrompts(defaults);
+        }
+      } catch (error) {
+        console.error('Failed to load prompt defaults:', error);
+      } finally {
+        if (isActive) {
+          setIsLoading(false);
+        }
+      }
+    };
+
+    void loadDefaults();
+    return () => {
+      isActive = false;
+    };
+  }, []);
+
+  // 保存到 localStorage
+  useEffect(() => {
+    savePrompts(prompts);
+  }, [prompts]);
+
+  // 更新提示词
+  const updatePrompt = useCallback((section: string, type: string, value: string) => {
+    setPrompts(prev => {
+      const newPrompts = { ...prev };
+
+      if (section === 'system') {
+        if (!newPrompts.system) {
+          newPrompts.system = {};
+        }
+        newPrompts.system[type as keyof PromptOverrides['system']] = value;
+      } else if (section === 'user') {
+        if (!newPrompts.user) {
+          newPrompts.user = {};
+        }
+        newPrompts.user[type as keyof PromptOverrides['user']] = value;
+      }
+
+      return newPrompts;
+    });
+  }, []);
+
+  // 恢复默认值
+  const restoreDefault = useCallback(() => {
+    setPrompts(DEFAULT_PROMPTS);
+  }, []);
+
+  // 获取当前编辑的提示词
+  const getDefaultPrompt = useCallback((section: string, type: string) => {
+    if (section === 'system') {
+      return defaultPrompts.system?.[type as keyof PromptOverrides['system']] || '';
+    }
+    if (section === 'user') {
+      return defaultPrompts.user?.[type as keyof PromptOverrides['user']] || '';
+    }
+    return '';
+  }, [defaultPrompts]);
+
+  // 
+  const getCurrentPrompt = useCallback(() => {
+    let current = '';
+    if (activeSection === 'system') {
+      current = prompts.system?.[activePrompt as keyof PromptOverrides['system']] || '';
+    } else if (activeSection === 'user') {
+      current = prompts.user?.[activePrompt as keyof PromptOverrides['user']] || '';
+    }
+
+    if (current && current.trim().length > 0) {
+      return current;
+    }
+
+    return getDefaultPrompt(activeSection, activePrompt);
+  }, [prompts, activeSection, activePrompt, getDefaultPrompt]);
+
+  // 
+  const setCurrentPrompt = useCallback((value: string) => {
+    const defaultValue = getDefaultPrompt(activeSection, activePrompt);
+    const nextValue = value === defaultValue ? '' : value;
+    updatePrompt(activeSection, activePrompt, nextValue);
+  }, [activeSection, activePrompt, getDefaultPrompt, updatePrompt]);
+
+  return {
+    prompts,
+    defaultPrompts,
+    isLoading,
+    activeSection,
+    activePrompt,
+    setActiveSection,
+    setActivePrompt,
+    updatePrompt,
+    restoreDefault,
+    getCurrentPrompt,
+    setCurrentPrompt,
+  };
+}

frontend/src/lib/api.ts

@@ -1,78 +1,107 @@
-// API 请求函数
-
-import type { GenerateRequest, GenerateResponse, JobResult, ApiError, VideoConfig } from '../types/api';
-
-const API_BASE = '/api';
-
-/** 从 localStorage 加载视频配置 */
-function loadVideoConfig(): VideoConfig {
-  try {
-    const saved = localStorage.getItem('manimcat_settings');
-    if (saved) {
-      const parsed = JSON.parse(saved);
-      if (parsed.video) {
-        return parsed.video;
-      }
-    }
-  } catch {
-    // 忽略错误，使用默认值
-  }
-  return { quality: 'medium', frameRate: 30, timeout: 120 };
-}
-
-/**
- * 获取 API 请求头（包含认证信息）
- */
-function getAuthHeaders(): HeadersInit {
-  const headers: HeadersInit = {
-    'Content-Type': 'application/json',
-  };
-
-  // 从 localStorage 获取用户配置的 API Key
-  const apiKey = localStorage.getItem('manimcat_api_key');
-  if (apiKey) {
-    headers['Authorization'] = `Bearer ${apiKey}`;
-  }
-
-  return headers;
-}
-
-/**
- * 提交动画生成请求
- */
-export async function generateAnimation(request: GenerateRequest, signal?: AbortSignal): Promise<GenerateResponse> {
-  // 如果请求中没有 videoConfig，则从设置中加载默认值
-  const videoConfig = request.videoConfig || loadVideoConfig();
-
-  const payload = { ...request, videoConfig };
-  const response = await fetch(`${API_BASE}/generate`, {
-    method: 'POST',
-    headers: getAuthHeaders(),
-    body: JSON.stringify(payload),
-    signal,
-  });
-
-  if (!response.ok) {
-    const error: ApiError = await response.json();
-    throw new Error(error.error || '生成请求失败');
-  }
-
-  return response.json();
-}
-
-/**
- * 查询任务状态
- */
-export async function getJobStatus(jobId: string, signal?: AbortSignal): Promise<JobResult> {
-  const response = await fetch(`${API_BASE}/jobs/${jobId}`, {
-    headers: getAuthHeaders(),
-    signal,
-  });
-
-  if (!response.ok) {
-    const error: ApiError = await response.json();
-    throw new Error(error.error || '查询任务状态失败');
-  }
-
-  return response.json();
-}
+// API 请求函数
+
+import type { GenerateRequest, GenerateResponse, JobResult, ApiError, VideoConfig, PromptOverrides } from '../types/api';
+
+const API_BASE = '/api';
+
+/** 从 localStorage 加载视频配置 */
+function loadVideoConfig(): VideoConfig {
+  try {
+    const saved = localStorage.getItem('manimcat_settings');
+    if (saved) {
+      const parsed = JSON.parse(saved);
+      if (parsed.video) {
+        return parsed.video;
+      }
+    }
+  } catch {
+    // 忽略错误，使用默认值
+  }
+  return { quality: 'medium', frameRate: 30, timeout: 120 };
+}
+
+/**
+ * 获取 API 请求头（包含认证信息）
+ */
+function getAuthHeaders(): HeadersInit {
+  const headers: HeadersInit = {
+    'Content-Type': 'application/json',
+  };
+
+  // 从 localStorage 获取用户配置的 API Key
+  const apiKey = localStorage.getItem('manimcat_api_key');
+  if (apiKey) {
+    headers['Authorization'] = `Bearer ${apiKey}`;
+  }
+
+  return headers;
+}
+
+/**
+ * 提交动画生成请求
+ */
+export async function generateAnimation(request: GenerateRequest, signal?: AbortSignal): Promise<GenerateResponse> {
+  // 如果请求中没有 videoConfig，则从设置中加载默认值
+  const videoConfig = request.videoConfig || loadVideoConfig();
+
+  const payload = { ...request, videoConfig };
+  const response = await fetch(`${API_BASE}/generate`, {
+    method: 'POST',
+    headers: getAuthHeaders(),
+    body: JSON.stringify(payload),
+    signal,
+  });
+
+  if (!response.ok) {
+    const error: ApiError = await response.json();
+    throw new Error(error.error || '生成请求失败');
+  }
+
+  return response.json();
+}
+
+export async function getPromptDefaults(signal?: AbortSignal): Promise<PromptOverrides> {
+  const response = await fetch(`${API_BASE}/prompts/defaults`, {
+    headers: getAuthHeaders(),
+    signal,
+  });
+
+  if (!response.ok) {
+    const error: ApiError = await response.json();
+    throw new Error(error.error || 'Failed to load prompt defaults');
+  }
+
+  return response.json();
+}
+
+/**
+ * 查询任务状态
+ */
+export async function getJobStatus(jobId: string, signal?: AbortSignal): Promise<JobResult> {
+  const response = await fetch(`${API_BASE}/jobs/${jobId}`, {
+    headers: getAuthHeaders(),
+    signal,
+  });
+
+  if (!response.ok) {
+    const error: ApiError = await response.json();
+    throw new Error(error.error || '查询任务状态失败');
+  }
+
+  return response.json();
+}
+
+/**
+ * 取消任务
+ */
+export async function cancelJob(jobId: string): Promise<void> {
+  const response = await fetch(`${API_BASE}/jobs/${jobId}/cancel`, {
+    method: 'POST',
+    headers: getAuthHeaders(),
+  });
+
+  if (!response.ok) {
+    const error: ApiError = await response.json();
+    throw new Error(error.error || '取消任务失败');
+  }
+}

frontend/src/types/api.ts

@@ -11,6 +11,20 @@ export interface ApiConfig {
   manimcatApiKey: string;
 }
 
+export interface PromptOverrides {
+  system?: {
+    conceptDesigner?: string;
+    codeGeneration?: string;
+    codeRetry?: string;
+  };
+  user?: {
+    conceptDesigner?: string;
+    codeGeneration?: string;
+    codeRetryInitial?: string;
+    codeRetryFix?: string;
+  };
+}
+
 /** 视频配置 */
 export interface VideoConfig {
   /** 默认质量 */
@@ -42,6 +56,8 @@ export interface GenerateRequest {
   code?: string;
   /** 视频配置 */
   videoConfig?: VideoConfig;
+  /** Prompt overrides */
+  promptOverrides?: PromptOverrides;
 }
 
 /** 生成响应 */
@@ -64,9 +80,11 @@ export interface JobResult {
   used_ai?: boolean;
   render_quality?: string;
   generation_type?: string;
-  render_peak_memory_mb?: number;
+  render_peak_memory_mb?: number;
+
   error?: string;
   details?: string;
+  cancel_reason?: string;
 }
 
 /** API 错误 */

public/assets/index-Cyf_XhIu.css

@@ -0,0 +1 @@
+@import"https://cdn.jsdelivr.net/npm/lxgw-wenkai-screen-webfont@1.1.0/style.css";*,:before,:after{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }::backdrop{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }*,:before,:after{box-sizing:border-box;border-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:Inter,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif;font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:SF Mono,Monaco,Cascadia Code,Roboto Mono,monospace;font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-size:100%;font-weight:inherit;line-height:inherit;letter-spacing:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}button,input:where([type=button]),input:where([type=reset]),input:where([type=submit]){-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}ol,ul,menu{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,textarea::-moz-placeholder{opacity:1;color:#9ca3af}input::placeholder,textarea::placeholder{opacity:1;color:#9ca3af}button,[role=button]{cursor:pointer}:disabled{cursor:default}img,svg,video,canvas,audio,iframe,embed,object{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border-width:0}.pointer-events-none{pointer-events:none}.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.inset-0{inset:0}.-top-2{top:-.5rem}.-top-2\.5{top:-.625rem}.left-0{left:0}.left-1{left:.25rem}.left-3{left:.75rem}.left-4{left:1rem}.right-0{right:0}.right-3{right:.75rem}.right-4{right:1rem}.top-1{top:.25rem}.top-1\/2{top:50%}.top-4{top:1rem}.top-full{top:100%}.z-10{z-index:10}.z-50{z-index:50}.mx-auto{margin-left:auto;margin-right:auto}.mb-1{margin-bottom:.25rem}.mb-12{margin-bottom:3rem}.mb-2{margin-bottom:.5rem}.mb-3{margin-bottom:.75rem}.mb-4{margin-bottom:1rem}.mb-5{margin-bottom:1.25rem}.mb-6{margin-bottom:1.5rem}.ml-1{margin-left:.25rem}.ml-4{margin-left:1rem}.mr-2{margin-right:.5rem}.mt-0\.5{margin-top:.125rem}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.mt-4{margin-top:1rem}.mt-5{margin-top:1.25rem}.mt-8{margin-top:2rem}.inline{display:inline}.flex{display:flex}.grid{display:grid}.hidden{display:none}.h-10{height:2.5rem}.h-16{height:4rem}.h-3\.5{height:.875rem}.h-4{height:1rem}.h-5{height:1.25rem}.h-7{height:1.75rem}.h-8{height:2rem}.h-\[360px\]{height:360px}.h-full{height:100%}.min-h-\[80px\]{min-height:80px}.min-h-screen{min-height:100vh}.w-10{width:2.5rem}.w-12{width:3rem}.w-16{width:4rem}.w-3\.5{width:.875rem}.w-4{width:1rem}.w-5{width:1.25rem}.w-64{width:16rem}.w-8{width:2rem}.w-full{width:100%}.max-w-2xl{max-width:42rem}.max-w-4xl{max-width:56rem}.max-w-lg{max-width:32rem}.max-w-md{max-width:28rem}.flex-1{flex:1 1 0%}.-translate-x-full{--tw-translate-x: -100%;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.-translate-y-1\/2{--tw-translate-y: -50%;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.translate-x-0{--tw-translate-x: 0px;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.translate-x-5{--tw-translate-x: 1.25rem;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.rotate-180{--tw-rotate: 180deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.transform{transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}@keyframes spin{to{transform:rotate(360deg)}}.animate-spin{animation:spin 1s linear infinite}.cursor-pointer{cursor:pointer}.resize-none{resize:none}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.flex-col{flex-direction:column}.items-start{align-items:flex-start}.items-center{align-items:center}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-1\.5{gap:.375rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.gap-4{gap:1rem}.gap-6{gap:1.5rem}.space-y-1>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.25rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.25rem * var(--tw-space-y-reverse))}.space-y-4>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1rem * var(--tw-space-y-reverse))}.space-y-5>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1.25rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1.25rem * var(--tw-space-y-reverse))}.space-y-6>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1.5rem * var(--tw-space-y-reverse))}.space-y-8>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(2rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(2rem * var(--tw-space-y-reverse))}.overflow-auto{overflow:auto}.overflow-hidden{overflow:hidden}.overflow-y-auto{overflow-y:auto}.whitespace-pre-wrap{white-space:pre-wrap}.rounded{border-radius:.25rem}.rounded-2xl{border-radius:1rem}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:.5rem}.rounded-xl{border-radius:.75rem}.border{border-width:1px}.border-b{border-bottom-width:1px}.border-r{border-right-width:1px}.border-t{border-top-width:1px}.border-bg-secondary\/50{border-color:rgba(var(--bg-secondary-rgb),.5)}.border-red-500\/30{border-color:#ef44444d}.bg-accent{background-color:rgba(var(--accent-rgb),1)}.bg-bg-primary{background-color:rgba(var(--bg-primary-rgb),1)}.bg-bg-secondary{background-color:rgba(var(--bg-secondary-rgb),1)}.bg-bg-secondary\/20{background-color:rgba(var(--bg-secondary-rgb),.2)}.bg-bg-secondary\/30{background-color:rgba(var(--bg-secondary-rgb),.3)}.bg-bg-secondary\/40{background-color:rgba(var(--bg-secondary-rgb),.4)}.bg-bg-secondary\/50{background-color:rgba(var(--bg-secondary-rgb),.5)}.bg-bg-secondary\/70{background-color:rgba(var(--bg-secondary-rgb),.7)}.bg-bg-tertiary{background-color:rgba(var(--bg-tertiary-rgb),1)}.bg-black{--tw-bg-opacity: 1;background-color:rgb(0 0 0 / var(--tw-bg-opacity, 1))}.bg-black\/50{background-color:#00000080}.bg-blue-50{--tw-bg-opacity: 1;background-color:rgb(239 246 255 / var(--tw-bg-opacity, 1))}.bg-green-50{--tw-bg-opacity: 1;background-color:rgb(240 253 244 / var(--tw-bg-opacity, 1))}.bg-red-50{--tw-bg-opacity: 1;background-color:rgb(254 242 242 / var(--tw-bg-opacity, 1))}.bg-red-50\/50{background-color:#fef2f280}.bg-red-50\/80{background-color:#fef2f2cc}.bg-white{--tw-bg-opacity: 1;background-color:rgb(255 255 255 / var(--tw-bg-opacity, 1))}.bg-gradient-to-r{background-image:linear-gradient(to right,var(--tw-gradient-stops))}.from-transparent{--tw-gradient-from: transparent var(--tw-gradient-from-position);--tw-gradient-to: rgb(0 0 0 / 0) var(--tw-gradient-to-position);--tw-gradient-stops: var(--tw-gradient-from), var(--tw-gradient-to)}.via-white\/10{--tw-gradient-to: rgb(255 255 255 / 0) var(--tw-gradient-to-position);--tw-gradient-stops: var(--tw-gradient-from), rgb(255 255 255 / .1) var(--tw-gradient-via-position), var(--tw-gradient-to)}.to-transparent{--tw-gradient-to: transparent var(--tw-gradient-to-position)}.object-contain{-o-object-fit:contain;object-fit:contain}.p-1{padding:.25rem}.p-2{padding:.5rem}.p-2\.5{padding:.625rem}.p-4{padding:1rem}.p-5{padding:1.25rem}.p-6{padding:1.5rem}.p-8{padding:2rem}.px-1\.5{padding-left:.375rem;padding-right:.375rem}.px-12{padding-left:3rem;padding-right:3rem}.px-2{padding-left:.5rem;padding-right:.5rem}.px-3{padding-left:.75rem;padding-right:.75rem}.px-4{padding-left:1rem;padding-right:1rem}.px-5{padding-left:1.25rem;padding-right:1.25rem}.px-6{padding-left:1.5rem;padding-right:1.5rem}.px-8{padding-left:2rem;padding-right:2rem}.py-0\.5{padding-top:.125rem;padding-bottom:.125rem}.py-1{padding-top:.25rem;padding-bottom:.25rem}.py-1\.5{padding-top:.375rem;padding-bottom:.375rem}.py-12{padding-top:3rem;padding-bottom:3rem}.py-16{padding-top:4rem;padding-bottom:4rem}.py-2{padding-top:.5rem;padding-bottom:.5rem}.py-2\.5{padding-top:.625rem;padding-bottom:.625rem}.py-3{padding-top:.75rem;padding-bottom:.75rem}.py-3\.5{padding-top:.875rem;padding-bottom:.875rem}.py-4{padding-top:1rem;padding-bottom:1rem}.pr-10{padding-right:2.5rem}.pt-4{padding-top:1rem}.text-left{text-align:left}.text-center{text-align:center}.font-mono{font-family:SF Mono,Monaco,Cascadia Code,Roboto Mono,monospace}.text-5xl{font-size:3rem;line-height:1}.text-\[10px\]{font-size:10px}.text-base{font-size:1rem;line-height:1.5rem}.text-lg{font-size:1.125rem;line-height:1.75rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xl{font-size:1.25rem;line-height:1.75rem}.text-xs{font-size:.75rem;line-height:1rem}.font-light{font-weight:300}.font-medium{font-weight:500}.uppercase{text-transform:uppercase}.tracking-tight{letter-spacing:-.025em}.tracking-wide{letter-spacing:.025em}.tracking-wider{letter-spacing:.05em}.text-accent{color:rgba(var(--accent-rgb),1)}.text-blue-600{--tw-text-opacity: 1;color:rgb(37 99 235 / var(--tw-text-opacity, 1))}.text-green-600{--tw-text-opacity: 1;color:rgb(22 163 74 / var(--tw-text-opacity, 1))}.text-red-500{--tw-text-opacity: 1;color:rgb(239 68 68 / var(--tw-text-opacity, 1))}.text-red-600{--tw-text-opacity: 1;color:rgb(220 38 38 / var(--tw-text-opacity, 1))}.text-text-primary{color:rgba(var(--text-primary-rgb),1)}.text-text-primary\/90{color:rgba(var(--text-primary-rgb),.9)}.text-text-secondary{color:rgba(var(--text-secondary-rgb),1)}.text-text-secondary\/40{color:rgba(var(--text-secondary-rgb),.4)}.text-text-secondary\/50{color:rgba(var(--text-secondary-rgb),.5)}.text-text-secondary\/60{color:rgba(var(--text-secondary-rgb),.6)}.text-text-secondary\/70{color:rgba(var(--text-secondary-rgb),.7)}.text-text-secondary\/80{color:rgba(var(--text-secondary-rgb),.8)}.text-white{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity, 1))}.placeholder-text-secondary\/40::-moz-placeholder{color:rgba(var(--text-secondary-rgb),.4)}.placeholder-text-secondary\/40::placeholder{color:rgba(var(--text-secondary-rgb),.4)}.opacity-25{opacity:.25}.opacity-75{opacity:.75}.shadow-lg{--tw-shadow: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);--tw-shadow-colored: 0 10px 15px -3px var(--tw-shadow-color), 0 4px 6px -4px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-md{--tw-shadow: 0 4px 6px -1px rgb(0 0 0 / .1), 0 2px 4px -2px rgb(0 0 0 / .1);--tw-shadow-colored: 0 4px 6px -1px var(--tw-shadow-color), 0 2px 4px -2px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-sm{--tw-shadow: 0 1px 2px 0 rgb(0 0 0 / .05);--tw-shadow-colored: 0 1px 2px 0 var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-xl{--tw-shadow: 0 20px 25px -5px rgb(0 0 0 / .1), 0 8px 10px -6px rgb(0 0 0 / .1);--tw-shadow-colored: 0 20px 25px -5px var(--tw-shadow-color), 0 8px 10px -6px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-accent\/25{--tw-shadow-color: rgba(var(--accent-rgb), .25);--tw-shadow: var(--tw-shadow-colored)}.shadow-black\/10{--tw-shadow-color: rgb(0 0 0 / .1);--tw-shadow: var(--tw-shadow-colored)}.drop-shadow-lg{--tw-drop-shadow: drop-shadow(0 10px 8px rgb(0 0 0 / .04)) drop-shadow(0 4px 3px rgb(0 0 0 / .1));filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.transition-all{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-transform{transition-property:transform;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.duration-200{transition-duration:.2s}.duration-300{transition-duration:.3s}.duration-500{transition-duration:.5s}.ease-out{transition-timing-function:cubic-bezier(0,0,.2,1)}:root{--bg-primary-rgb: 245, 245, 245;--bg-secondary-rgb: 238, 238, 238;--bg-tertiary-rgb: 224, 224, 224;--text-primary-rgb: 33, 33, 33;--text-secondary-rgb: 117, 117, 117;--text-tertiary-rgb: 158, 158, 158;--accent-rgb: 66, 66, 66;--accent-hover-rgb: 48, 48, 48;--border-rgb: 0, 0, 0}.dark{--bg-primary-rgb: 18, 18, 18;--bg-secondary-rgb: 28, 28, 28;--bg-tertiary-rgb: 38, 38, 38;--text-primary-rgb: 245, 245, 245;--text-secondary-rgb: 189, 189, 189;--text-tertiary-rgb: 117, 117, 117;--accent-rgb: 138, 138, 138;--accent-hover-rgb: 158, 158, 158;--border-rgb: 255, 255, 255}body{font-family:LXGW WenKai Screen,LXGW WenKai TC,LXGW WenKai Lite,LXGW WenKai,sans-serif;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;background-color:rgba(var(--bg-primary-rgb),1);color:rgba(var(--text-primary-rgb),1);transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.3s}select option{padding:10px 16px;background-color:#fff;color:#212121}select option:hover,select option:focus{background-color:#f5f5f5}select option:checked{background-color:#424242;color:#fff;font-weight:500}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:transparent}::-webkit-scrollbar-thumb{background:#0000001a;border-radius:9999px}.dark ::-webkit-scrollbar-thumb{background:#ffffff26}::-webkit-scrollbar-thumb:hover{background:#0003}.dark ::-webkit-scrollbar-thumb:hover{background:#ffffff40}.dark .react-syntax-highlighter{background:transparent!important}@keyframes fade-in{0%{opacity:0;transform:translateY(8px)}to{opacity:1;transform:translateY(0)}}.animate-fade-in{animation:fade-in .3s ease-out}.hover\:bg-accent-hover:hover{background-color:rgba(var(--accent-hover-rgb),1)}.hover\:bg-bg-secondary:hover{background-color:rgba(var(--bg-secondary-rgb),1)}.hover\:bg-bg-secondary\/30:hover{background-color:rgba(var(--bg-secondary-rgb),.3)}.hover\:bg-bg-secondary\/50:hover{background-color:rgba(var(--bg-secondary-rgb),.5)}.hover\:bg-bg-secondary\/60:hover{background-color:rgba(var(--bg-secondary-rgb),.6)}.hover\:bg-bg-secondary\/70:hover{background-color:rgba(var(--bg-secondary-rgb),.7)}.hover\:bg-bg-secondary\/80:hover{background-color:rgba(var(--bg-secondary-rgb),.8)}.hover\:text-accent:hover{color:rgba(var(--accent-rgb),1)}.hover\:text-accent-hover:hover{color:rgba(var(--accent-hover-rgb),1)}.hover\:text-red-500:hover{--tw-text-opacity: 1;color:rgb(239 68 68 / var(--tw-text-opacity, 1))}.hover\:text-text-primary:hover{color:rgba(var(--text-primary-rgb),1)}.hover\:text-text-secondary:hover{color:rgba(var(--text-secondary-rgb),1)}.hover\:shadow-xl:hover{--tw-shadow: 0 20px 25px -5px rgb(0 0 0 / .1), 0 8px 10px -6px rgb(0 0 0 / .1);--tw-shadow-colored: 0 20px 25px -5px var(--tw-shadow-color), 0 8px 10px -6px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.hover\:shadow-accent\/35:hover{--tw-shadow-color: rgba(var(--accent-rgb), .35);--tw-shadow: var(--tw-shadow-colored)}.focus\:border-accent\/30:focus{border-color:rgba(var(--accent-rgb),.3)}.focus\:border-red-500\/50:focus{border-color:#ef444480}.focus\:bg-bg-secondary\/70:focus{background-color:rgba(var(--bg-secondary-rgb),.7)}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.focus\:ring-2:focus{--tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);--tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow, 0 0 #0000)}.focus\:ring-accent\/20:focus{--tw-ring-color: rgba(var(--accent-rgb), .2)}.focus\:ring-red-500\/20:focus{--tw-ring-color: rgb(239 68 68 / .2)}.active\:scale-\[0\.97\]:active{--tw-scale-x: .97;--tw-scale-y: .97;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.active\:scale-\[0\.98\]:active{--tw-scale-x: .98;--tw-scale-y: .98;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-30:disabled{opacity:.3}.disabled\:opacity-50:disabled{opacity:.5}.group:hover .group-hover\:translate-x-1{--tw-translate-x: .25rem;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}@keyframes shimmer{to{transform:translate(100%)}}.group:hover .group-hover\:animate-shimmer{animation:shimmer 1.5s infinite}.dark\:bg-blue-900\/20:is(.dark *){background-color:#1e3a8a33}.dark\:bg-green-900\/20:is(.dark *){background-color:#14532d33}.dark\:bg-red-900\/10:is(.dark *){background-color:#7f1d1d1a}.dark\:bg-red-900\/20:is(.dark *){background-color:#7f1d1d33}.dark\:text-blue-400:is(.dark *){--tw-text-opacity: 1;color:rgb(96 165 250 / var(--tw-text-opacity, 1))}.dark\:text-green-400:is(.dark *){--tw-text-opacity: 1;color:rgb(74 222 128 / var(--tw-text-opacity, 1))}.dark\:text-red-400:is(.dark *){--tw-text-opacity: 1;color:rgb(248 113 113 / var(--tw-text-opacity, 1))}@media(min-width:640px){.sm\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.sm\:p-6{padding:1.5rem}.sm\:py-20{padding-top:5rem;padding-bottom:5rem}.sm\:text-6xl{font-size:3.75rem;line-height:1}.sm\:text-base{font-size:1rem;line-height:1.5rem}}@media(min-width:1024px){.lg\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}}

public/assets/index-DkT5mxpT.css

@@ -1 +0,0 @@
-@import"https://cdn.jsdelivr.net/npm/lxgw-wenkai-webfont@1.1.0/style.css";@import"https://cdn.jsdelivr.net/npm/lxgw-wenkai-lite-webfont@1.1.0/style.css";@import"https://cdn.jsdelivr.net/npm/lxgw-wenkai-tc-webfont@1.0.0/style.css";@import"https://cdn.jsdelivr.net/npm/lxgw-wenkai-screen-webfont@1.1.0/style.css";*,:before,:after{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }::backdrop{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }*,:before,:after{box-sizing:border-box;border-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:Inter,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif;font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:SF Mono,Monaco,Cascadia Code,Roboto Mono,monospace;font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-size:100%;font-weight:inherit;line-height:inherit;letter-spacing:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}button,input:where([type=button]),input:where([type=reset]),input:where([type=submit]){-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}ol,ul,menu{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,textarea::-moz-placeholder{opacity:1;color:#9ca3af}input::placeholder,textarea::placeholder{opacity:1;color:#9ca3af}button,[role=button]{cursor:pointer}:disabled{cursor:default}img,svg,video,canvas,audio,iframe,embed,object{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border-width:0}.pointer-events-none{pointer-events:none}.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.inset-0{inset:0}.-top-2{top:-.5rem}.-top-2\.5{top:-.625rem}.left-0{left:0}.left-1{left:.25rem}.left-3{left:.75rem}.left-4{left:1rem}.right-0{right:0}.right-3{right:.75rem}.right-4{right:1rem}.top-1{top:.25rem}.top-1\/2{top:50%}.top-4{top:1rem}.top-full{top:100%}.z-10{z-index:10}.z-50{z-index:50}.mx-auto{margin-left:auto;margin-right:auto}.mb-1{margin-bottom:.25rem}.mb-12{margin-bottom:3rem}.mb-3{margin-bottom:.75rem}.mb-5{margin-bottom:1.25rem}.mb-6{margin-bottom:1.5rem}.ml-1{margin-left:.25rem}.mt-0\.5{margin-top:.125rem}.mt-2{margin-top:.5rem}.mt-4{margin-top:1rem}.mt-5{margin-top:1.25rem}.mt-8{margin-top:2rem}.flex{display:flex}.grid{display:grid}.hidden{display:none}.h-10{height:2.5rem}.h-16{height:4rem}.h-3\.5{height:.875rem}.h-4{height:1rem}.h-5{height:1.25rem}.h-7{height:1.75rem}.h-8{height:2rem}.h-\[360px\]{height:360px}.h-full{height:100%}.min-h-\[80px\]{min-height:80px}.min-h-screen{min-height:100vh}.w-10{width:2.5rem}.w-12{width:3rem}.w-16{width:4rem}.w-3\.5{width:.875rem}.w-4{width:1rem}.w-5{width:1.25rem}.w-8{width:2rem}.w-full{width:100%}.max-w-2xl{max-width:42rem}.max-w-4xl{max-width:56rem}.max-w-lg{max-width:32rem}.max-w-md{max-width:28rem}.flex-1{flex:1 1 0%}.-translate-x-full{--tw-translate-x: -100%;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.-translate-y-1\/2{--tw-translate-y: -50%;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.translate-x-0{--tw-translate-x: 0px;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.translate-x-5{--tw-translate-x: 1.25rem;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.rotate-180{--tw-rotate: 180deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.transform{transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}@keyframes spin{to{transform:rotate(360deg)}}.animate-spin{animation:spin 1s linear infinite}.cursor-pointer{cursor:pointer}.resize-none{resize:none}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.flex-col{flex-direction:column}.items-start{align-items:flex-start}.items-center{align-items:center}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-1\.5{gap:.375rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.gap-4{gap:1rem}.gap-6{gap:1.5rem}.space-y-5>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1.25rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1.25rem * var(--tw-space-y-reverse))}.space-y-6>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1.5rem * var(--tw-space-y-reverse))}.overflow-auto{overflow:auto}.overflow-hidden{overflow:hidden}.rounded{border-radius:.25rem}.rounded-2xl{border-radius:1rem}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:.5rem}.rounded-xl{border-radius:.75rem}.bg-accent{background-color:rgba(var(--accent-rgb),1)}.bg-bg-primary{background-color:rgba(var(--bg-primary-rgb),1)}.bg-bg-secondary{background-color:rgba(var(--bg-secondary-rgb),1)}.bg-bg-secondary\/20{background-color:rgba(var(--bg-secondary-rgb),.2)}.bg-bg-secondary\/30{background-color:rgba(var(--bg-secondary-rgb),.3)}.bg-bg-secondary\/40{background-color:rgba(var(--bg-secondary-rgb),.4)}.bg-bg-secondary\/50{background-color:rgba(var(--bg-secondary-rgb),.5)}.bg-bg-secondary\/70{background-color:rgba(var(--bg-secondary-rgb),.7)}.bg-bg-tertiary{background-color:rgba(var(--bg-tertiary-rgb),1)}.bg-black{--tw-bg-opacity: 1;background-color:rgb(0 0 0 / var(--tw-bg-opacity, 1))}.bg-black\/50{background-color:#00000080}.bg-blue-50{--tw-bg-opacity: 1;background-color:rgb(239 246 255 / var(--tw-bg-opacity, 1))}.bg-green-50{--tw-bg-opacity: 1;background-color:rgb(240 253 244 / var(--tw-bg-opacity, 1))}.bg-red-50{--tw-bg-opacity: 1;background-color:rgb(254 242 242 / var(--tw-bg-opacity, 1))}.bg-red-50\/50{background-color:#fef2f280}.bg-red-50\/80{background-color:#fef2f2cc}.bg-white{--tw-bg-opacity: 1;background-color:rgb(255 255 255 / var(--tw-bg-opacity, 1))}.bg-gradient-to-r{background-image:linear-gradient(to right,var(--tw-gradient-stops))}.from-transparent{--tw-gradient-from: transparent var(--tw-gradient-from-position);--tw-gradient-to: rgb(0 0 0 / 0) var(--tw-gradient-to-position);--tw-gradient-stops: var(--tw-gradient-from), var(--tw-gradient-to)}.via-white\/10{--tw-gradient-to: rgb(255 255 255 / 0) var(--tw-gradient-to-position);--tw-gradient-stops: var(--tw-gradient-from), rgb(255 255 255 / .1) var(--tw-gradient-via-position), var(--tw-gradient-to)}.to-transparent{--tw-gradient-to: transparent var(--tw-gradient-to-position)}.object-contain{-o-object-fit:contain;object-fit:contain}.p-1{padding:.25rem}.p-2{padding:.5rem}.p-2\.5{padding:.625rem}.p-4{padding:1rem}.p-5{padding:1.25rem}.p-6{padding:1.5rem}.p-8{padding:2rem}.px-1\.5{padding-left:.375rem;padding-right:.375rem}.px-12{padding-left:3rem;padding-right:3rem}.px-2{padding-left:.5rem;padding-right:.5rem}.px-3{padding-left:.75rem;padding-right:.75rem}.px-4{padding-left:1rem;padding-right:1rem}.px-5{padding-left:1.25rem;padding-right:1.25rem}.px-6{padding-left:1.5rem;padding-right:1.5rem}.px-8{padding-left:2rem;padding-right:2rem}.py-0\.5{padding-top:.125rem;padding-bottom:.125rem}.py-1{padding-top:.25rem;padding-bottom:.25rem}.py-1\.5{padding-top:.375rem;padding-bottom:.375rem}.py-12{padding-top:3rem;padding-bottom:3rem}.py-16{padding-top:4rem;padding-bottom:4rem}.py-2{padding-top:.5rem;padding-bottom:.5rem}.py-2\.5{padding-top:.625rem;padding-bottom:.625rem}.py-3\.5{padding-top:.875rem;padding-bottom:.875rem}.py-4{padding-top:1rem;padding-bottom:1rem}.pr-10{padding-right:2.5rem}.pt-4{padding-top:1rem}.text-left{text-align:left}.text-center{text-align:center}.font-mono{font-family:SF Mono,Monaco,Cascadia Code,Roboto Mono,monospace}.text-5xl{font-size:3rem;line-height:1}.text-\[10px\]{font-size:10px}.text-base{font-size:1rem;line-height:1.5rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xl{font-size:1.25rem;line-height:1.75rem}.text-xs{font-size:.75rem;line-height:1rem}.font-light{font-weight:300}.font-medium{font-weight:500}.uppercase{text-transform:uppercase}.tracking-tight{letter-spacing:-.025em}.tracking-wide{letter-spacing:.025em}.text-accent{color:rgba(var(--accent-rgb),1)}.text-blue-600{--tw-text-opacity: 1;color:rgb(37 99 235 / var(--tw-text-opacity, 1))}.text-green-600{--tw-text-opacity: 1;color:rgb(22 163 74 / var(--tw-text-opacity, 1))}.text-red-500{--tw-text-opacity: 1;color:rgb(239 68 68 / var(--tw-text-opacity, 1))}.text-red-600{--tw-text-opacity: 1;color:rgb(220 38 38 / var(--tw-text-opacity, 1))}.text-text-primary{color:rgba(var(--text-primary-rgb),1)}.text-text-primary\/90{color:rgba(var(--text-primary-rgb),.9)}.text-text-secondary{color:rgba(var(--text-secondary-rgb),1)}.text-text-secondary\/50{color:rgba(var(--text-secondary-rgb),.5)}.text-text-secondary\/60{color:rgba(var(--text-secondary-rgb),.6)}.text-text-secondary\/70{color:rgba(var(--text-secondary-rgb),.7)}.text-text-secondary\/80{color:rgba(var(--text-secondary-rgb),.8)}.text-white{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity, 1))}.placeholder-text-secondary\/40::-moz-placeholder{color:rgba(var(--text-secondary-rgb),.4)}.placeholder-text-secondary\/40::placeholder{color:rgba(var(--text-secondary-rgb),.4)}.opacity-25{opacity:.25}.opacity-75{opacity:.75}.shadow-lg{--tw-shadow: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);--tw-shadow-colored: 0 10px 15px -3px var(--tw-shadow-color), 0 4px 6px -4px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-md{--tw-shadow: 0 4px 6px -1px rgb(0 0 0 / .1), 0 2px 4px -2px rgb(0 0 0 / .1);--tw-shadow-colored: 0 4px 6px -1px var(--tw-shadow-color), 0 2px 4px -2px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-sm{--tw-shadow: 0 1px 2px 0 rgb(0 0 0 / .05);--tw-shadow-colored: 0 1px 2px 0 var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-xl{--tw-shadow: 0 20px 25px -5px rgb(0 0 0 / .1), 0 8px 10px -6px rgb(0 0 0 / .1);--tw-shadow-colored: 0 20px 25px -5px var(--tw-shadow-color), 0 8px 10px -6px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.shadow-accent\/25{--tw-shadow-color: rgba(var(--accent-rgb), .25);--tw-shadow: var(--tw-shadow-colored)}.shadow-black\/10{--tw-shadow-color: rgb(0 0 0 / .1);--tw-shadow: var(--tw-shadow-colored)}.drop-shadow-lg{--tw-drop-shadow: drop-shadow(0 10px 8px rgb(0 0 0 / .04)) drop-shadow(0 4px 3px rgb(0 0 0 / .1));filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.transition-all{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-transform{transition-property:transform;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.duration-200{transition-duration:.2s}.duration-300{transition-duration:.3s}.duration-500{transition-duration:.5s}.ease-out{transition-timing-function:cubic-bezier(0,0,.2,1)}:root{--bg-primary-rgb: 245, 245, 245;--bg-secondary-rgb: 238, 238, 238;--bg-tertiary-rgb: 224, 224, 224;--text-primary-rgb: 33, 33, 33;--text-secondary-rgb: 117, 117, 117;--text-tertiary-rgb: 158, 158, 158;--accent-rgb: 66, 66, 66;--accent-hover-rgb: 48, 48, 48;--border-rgb: 0, 0, 0}.dark{--bg-primary-rgb: 18, 18, 18;--bg-secondary-rgb: 28, 28, 28;--bg-tertiary-rgb: 38, 38, 38;--text-primary-rgb: 245, 245, 245;--text-secondary-rgb: 189, 189, 189;--text-tertiary-rgb: 117, 117, 117;--accent-rgb: 138, 138, 138;--accent-hover-rgb: 158, 158, 158;--border-rgb: 255, 255, 255}body{font-family:LXGW WenKai Screen,LXGW WenKai TC,LXGW WenKai Lite,LXGW WenKai,sans-serif;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;background-color:rgba(var(--bg-primary-rgb),1);color:rgba(var(--text-primary-rgb),1);transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.3s}select option{padding:10px 16px;background-color:#fff;color:#212121}select option:hover,select option:focus{background-color:#f5f5f5}select option:checked{background-color:#424242;color:#fff;font-weight:500}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:transparent}::-webkit-scrollbar-thumb{background:#0000001a;border-radius:9999px}.dark ::-webkit-scrollbar-thumb{background:#ffffff26}::-webkit-scrollbar-thumb:hover{background:#0003}.dark ::-webkit-scrollbar-thumb:hover{background:#ffffff40}.dark .react-syntax-highlighter{background:transparent!important}@keyframes fade-in{0%{opacity:0;transform:translateY(8px)}to{opacity:1;transform:translateY(0)}}.animate-fade-in{animation:fade-in .3s ease-out}.hover\:bg-accent-hover:hover{background-color:rgba(var(--accent-hover-rgb),1)}.hover\:bg-bg-secondary:hover{background-color:rgba(var(--bg-secondary-rgb),1)}.hover\:bg-bg-secondary\/30:hover{background-color:rgba(var(--bg-secondary-rgb),.3)}.hover\:bg-bg-secondary\/50:hover{background-color:rgba(var(--bg-secondary-rgb),.5)}.hover\:bg-bg-secondary\/60:hover{background-color:rgba(var(--bg-secondary-rgb),.6)}.hover\:bg-bg-secondary\/70:hover{background-color:rgba(var(--bg-secondary-rgb),.7)}.hover\:bg-bg-secondary\/80:hover{background-color:rgba(var(--bg-secondary-rgb),.8)}.hover\:text-accent:hover{color:rgba(var(--accent-rgb),1)}.hover\:text-accent-hover:hover{color:rgba(var(--accent-hover-rgb),1)}.hover\:text-red-500:hover{--tw-text-opacity: 1;color:rgb(239 68 68 / var(--tw-text-opacity, 1))}.hover\:text-text-primary:hover{color:rgba(var(--text-primary-rgb),1)}.hover\:text-text-secondary:hover{color:rgba(var(--text-secondary-rgb),1)}.hover\:shadow-xl:hover{--tw-shadow: 0 20px 25px -5px rgb(0 0 0 / .1), 0 8px 10px -6px rgb(0 0 0 / .1);--tw-shadow-colored: 0 20px 25px -5px var(--tw-shadow-color), 0 8px 10px -6px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.hover\:shadow-accent\/35:hover{--tw-shadow-color: rgba(var(--accent-rgb), .35);--tw-shadow: var(--tw-shadow-colored)}.focus\:bg-bg-secondary\/70:focus{background-color:rgba(var(--bg-secondary-rgb),.7)}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.focus\:ring-2:focus{--tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);--tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow, 0 0 #0000)}.focus\:ring-accent\/20:focus{--tw-ring-color: rgba(var(--accent-rgb), .2)}.focus\:ring-red-500\/20:focus{--tw-ring-color: rgb(239 68 68 / .2)}.active\:scale-\[0\.97\]:active{--tw-scale-x: .97;--tw-scale-y: .97;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.active\:scale-\[0\.98\]:active{--tw-scale-x: .98;--tw-scale-y: .98;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-30:disabled{opacity:.3}.disabled\:opacity-50:disabled{opacity:.5}.group:hover .group-hover\:translate-x-1{--tw-translate-x: .25rem;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}@keyframes shimmer{to{transform:translate(100%)}}.group:hover .group-hover\:animate-shimmer{animation:shimmer 1.5s infinite}.dark\:bg-blue-900\/20:is(.dark *){background-color:#1e3a8a33}.dark\:bg-green-900\/20:is(.dark *){background-color:#14532d33}.dark\:bg-red-900\/10:is(.dark *){background-color:#7f1d1d1a}.dark\:bg-red-900\/20:is(.dark *){background-color:#7f1d1d33}.dark\:text-blue-400:is(.dark *){--tw-text-opacity: 1;color:rgb(96 165 250 / var(--tw-text-opacity, 1))}.dark\:text-green-400:is(.dark *){--tw-text-opacity: 1;color:rgb(74 222 128 / var(--tw-text-opacity, 1))}.dark\:text-red-400:is(.dark *){--tw-text-opacity: 1;color:rgb(248 113 113 / var(--tw-text-opacity, 1))}@media(min-width:640px){.sm\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.sm\:p-6{padding:1.5rem}.sm\:py-20{padding-top:5rem;padding-bottom:5rem}.sm\:text-6xl{font-size:3.75rem;line-height:1}.sm\:text-base{font-size:1rem;line-height:1.5rem}}@media(min-width:1024px){.lg\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}}

public/index.html

@@ -2,14 +2,12 @@
 <html lang="zh-CN">
   <head>
     <meta charset="UTF-8" />
-    <!-- 预连接 CDN，加速字体加载 -->
-    <link rel="preconnect" href="https://cdn.jsdelivr.net" crossorigin />
     <!-- 直接内嵌 SVG 作为 favicon -->
     <link rel="icon" href="data:image/svg+xml,<svg viewBox='0 0 512 512' xmlns='http://www.w3.org/2000/svg'><rect width='512' height='512' fill='%23faf9f5'/><path d='M 100 400 V 140 L 230 300 L 360 140 V 260' fill='none' stroke='%23455a64' stroke-width='55' stroke-linecap='round' stroke-linejoin='round'/><g transform='translate(360, 340)'><path d='M -70 40 C -80 0, -80 -30, -50 -60 L -20 -30 L 20 -30 L 50 -60 C 80 -30, 80 0, 70 40 C 60 70, -60 70, -70 40 Z' fill='%23455a64'/><circle cx='-35' cy='-5' r='18' fill='%23ffffff'/><circle cx='35' cy='-5' r='18' fill='%23ffffff'/><circle cx='-38' cy='-5' r='6' fill='%23455a64'/><circle cx='32' cy='-5' r='6' fill='%23455a64'/></g></svg>" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>ManimCat - 数学动画生成器</title>
-    <script type="module" crossorigin src="/assets/index-0yzmNnTY.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DkT5mxpT.css">
+    <script type="module" crossorigin src="/assets/index-FIHmTYvd.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Cyf_XhIu.css">
   </head>
   <body>
     <div id="root"></div>

src/config/redis.ts

@@ -60,6 +60,7 @@ export function createRedisClient(): Redis {
  */
 export const REDIS_KEYS = {
   JOB_RESULT: 'job:result:',
+  JOB_CANCEL: 'job:cancel:',
   CONCEPT_CACHE: 'concept:cache:',
   QUEUE_PREFIX: 'bull:'
 } as const

src/prompts/index.ts

@@ -64,6 +64,20 @@ export const SYSTEM_PROMPTS = {
 - **坐标系一致性**：所有图形必须通过 \`axes.c2p\` 映射到坐标轴上，严禁脱离坐标系的自由定位。`
 }
 
+export const SYSTEM_PROMPT_BASE = SYSTEM_PROMPTS.codeGeneration
+
+export const SYSTEM_PROMPT_STAGES = {
+  conceptDesigner: SYSTEM_PROMPTS.conceptDesigner,
+  codeGeneration: '',
+  codeFix: SYSTEM_PROMPTS.codeFix.replace(SYSTEM_PROMPT_BASE, '')
+}
+
+export const SYSTEM_PROMPT_COMBINED = {
+  conceptDesigner: SYSTEM_PROMPT_STAGES.conceptDesigner,
+  codeGeneration: `${SYSTEM_PROMPT_BASE}${SYSTEM_PROMPT_STAGES.codeGeneration}`,
+  codeFix: `${SYSTEM_PROMPT_BASE}${SYSTEM_PROMPT_STAGES.codeFix}`
+}
+
 // =====================
 // API Index
 // =====================

src/queues/processors/steps/analysis-step.ts

@@ -1,140 +1,142 @@
-/**
- * 概念分析步骤
- * 分析用户输入，决定生成策略
- */
-
-import {
-  isLikelyLatex,
-  selectTemplate,
-  generateLatexSceneCode
-} from '../../../services/manim-templates'
-import { generateTwoStageAIManimCode } from '../../../services/concept-designer'
-import { createLogger } from '../../../utils/logger'
-import type { CustomApiConfig } from '../../../types'
-
-const logger = createLogger('AnalysisStep')
-
-/**
- * 概念分析结果
- */
-export interface AnalysisResult {
-  analysisType: 'latex' | 'template' | 'ai' | 'fallback'
-  manimCode: string | null
-  needsAI: boolean
-}
-
-/**
- * 代码生成结果
- */
-export interface GenerationResult {
-  manimCode: string
-  usedAI: boolean
-  generationType: string
-  sceneDesign?: string // 新增：保存场景设计方案，用于重试
-}
-
-/**
- * 分析概念
- */
-export async function analyzeConcept(
-  jobId: string,
-  concept: string,
-  _quality: string
-): Promise<AnalysisResult> {
-  logger.info('Analyzing concept', { jobId, concept })
-
-  // 检查是否为 LaTeX
-  if (isLikelyLatex(concept)) {
-    logger.info('Detected LaTeX', { jobId })
-    return {
-      analysisType: 'latex',
-      manimCode: generateLatexSceneCode(concept),
-      needsAI: false
-    }
-  }
-
-  // 尝试匹配模板
-  const templateResult = selectTemplate(concept)
-  if (templateResult) {
-    logger.info('Matched template', { jobId, template: templateResult.templateName })
-    return {
-      analysisType: 'template',
-      manimCode: templateResult.code,
-      needsAI: false
-    }
-  }
-
-  // 需要 AI 生成
-  logger.info('Using AI for unique output', { jobId })
-  return {
-    analysisType: 'ai',
-    manimCode: null,
-    needsAI: true
-  }
-}
-
-/**
- * 生成代码
- */
-export async function generateCode(
-  jobId: string,
-  concept: string,
-  _quality: string,
-  analyzeResult: AnalysisResult,
-  customApiConfig?: CustomApiConfig
-): Promise<GenerationResult> {
-  const { analysisType, manimCode, needsAI } = analyzeResult
-  logger.info('Generating code', { jobId, needsAI, analysisType })
-
-  // 基本可视化代码（fallback）
-  const basicVisualizationCode = `from manim import *
-
-class MainScene(Scene):
-    def construct(self):
-        text = Text("Animation for: ${concept}")
-        self.play(Write(text))
-        self.wait(1)
-`.replace('${concept}', concept)
-
-  if (needsAI) {
-    // 使用两阶段 AI 生成：概念设计者 + 代码生成者
-    try {
-      logger.info('使用两阶段 AI 生成', { jobId })
-      const result = await generateTwoStageAIManimCode(concept, customApiConfig)
-      if (result.code && result.code.length > 0) {
-        logger.info('两阶段 AI 代码生成成功', { jobId, length: result.code.length, hasSceneDesign: !!result.sceneDesign })
-        // 保存 sceneDesign 用于重试
-        return {
-          manimCode: result.code,
-          usedAI: true,
-          generationType: 'two-stage-ai',
-          sceneDesign: result.sceneDesign
-        }
-      }
-    } catch (error) {
-      logger.warn('AI generation failed, using fallback', { jobId, error: String(error) })
-    }
-    return { manimCode: basicVisualizationCode, usedAI: false, generationType: 'fallback' }
-  }
-
-  if (manimCode) {
-    logger.info('Using pre-generated code', { jobId, length: manimCode.length })
-    return { manimCode, usedAI: false, generationType: analysisType }
-  }
-
-  return { manimCode: basicVisualizationCode, usedAI: false, generationType: 'fallback' }
-}
-
-/**
- * 分析并生成（合并分析+生成）
- */
-export async function analyzeAndGenerate(
-  jobId: string,
-  concept: string,
-  quality: string,
-  _timings: Record<string, number>,
-  customApiConfig?: CustomApiConfig
-): Promise<GenerationResult> {
-  const analysisResult = await analyzeConcept(jobId, concept, quality)
-  return generateCode(jobId, concept, quality, analysisResult, customApiConfig)
-}
+/**
+ * 概念分析步骤
+ * 分析用户输入，决定生成策略
+ */
+
+import {
+  isLikelyLatex,
+  selectTemplate,
+  generateLatexSceneCode
+} from '../../../services/manim-templates'
+import { generateTwoStageAIManimCode } from '../../../services/concept-designer'
+import { createLogger } from '../../../utils/logger'
+import type { CustomApiConfig, PromptOverrides } from '../../../types'
+
+const logger = createLogger('AnalysisStep')
+
+/**
+ * 概念分析结果
+ */
+export interface AnalysisResult {
+  analysisType: 'latex' | 'template' | 'ai' | 'fallback'
+  manimCode: string | null
+  needsAI: boolean
+}
+
+/**
+ * 代码生成结果
+ */
+export interface GenerationResult {
+  manimCode: string
+  usedAI: boolean
+  generationType: string
+  sceneDesign?: string // 新增：保存场景设计方案，用于重试
+}
+
+/**
+ * 分析概念
+ */
+export async function analyzeConcept(
+  jobId: string,
+  concept: string,
+  _quality: string
+): Promise<AnalysisResult> {
+  logger.info('Analyzing concept', { jobId, concept })
+
+  // 检查是否��� LaTeX
+  if (isLikelyLatex(concept)) {
+    logger.info('Detected LaTeX', { jobId })
+    return {
+      analysisType: 'latex',
+      manimCode: generateLatexSceneCode(concept),
+      needsAI: false
+    }
+  }
+
+  // 尝试匹配模板
+  const templateResult = selectTemplate(concept)
+  if (templateResult) {
+    logger.info('Matched template', { jobId, template: templateResult.templateName })
+    return {
+      analysisType: 'template',
+      manimCode: templateResult.code,
+      needsAI: false
+    }
+  }
+
+  // 需要 AI 生成
+  logger.info('Using AI for unique output', { jobId })
+  return {
+    analysisType: 'ai',
+    manimCode: null,
+    needsAI: true
+  }
+}
+
+/**
+ * 生成代码
+ */
+export async function generateCode(
+  jobId: string,
+  concept: string,
+  _quality: string,
+  analyzeResult: AnalysisResult,
+  customApiConfig?: CustomApiConfig,
+  promptOverrides?: PromptOverrides
+): Promise<GenerationResult> {
+  const { analysisType, manimCode, needsAI } = analyzeResult
+  logger.info('Generating code', { jobId, needsAI, analysisType })
+
+  // 基本可视化代码（fallback）
+  const basicVisualizationCode = `from manim import *
+
+class MainScene(Scene):
+    def construct(self):
+        text = Text("Animation for: ${concept}")
+        self.play(Write(text))
+        self.wait(1)
+`.replace('${concept}', concept)
+
+  if (needsAI) {
+    // 使用两阶段 AI 生成：概念设计者 + 代码生成者
+    try {
+      logger.info('使用两阶段 AI 生成', { jobId })
+      const result = await generateTwoStageAIManimCode(concept, customApiConfig, promptOverrides)
+      if (result.code && result.code.length > 0) {
+        logger.info('两阶段 AI 代码生成成功', { jobId, length: result.code.length, hasSceneDesign: !!result.sceneDesign })
+        // 保存 sceneDesign 用于重试
+        return {
+          manimCode: result.code,
+          usedAI: true,
+          generationType: 'two-stage-ai',
+          sceneDesign: result.sceneDesign
+        }
+      }
+    } catch (error) {
+      logger.warn('AI generation failed, using fallback', { jobId, error: String(error) })
+    }
+    return { manimCode: basicVisualizationCode, usedAI: false, generationType: 'fallback' }
+  }
+
+  if (manimCode) {
+    logger.info('Using pre-generated code', { jobId, length: manimCode.length })
+    return { manimCode, usedAI: false, generationType: analysisType }
+  }
+
+  return { manimCode: basicVisualizationCode, usedAI: false, generationType: 'fallback' }
+}
+
+/**
+ * 分析并生成（合并分析+生成）
+ */
+export async function analyzeAndGenerate(
+  jobId: string,
+  concept: string,
+  quality: string,
+  _timings: Record<string, number>,
+  customApiConfig?: CustomApiConfig,
+  promptOverrides?: PromptOverrides
+): Promise<GenerationResult> {
+  const analysisResult = await analyzeConcept(jobId, concept, quality)
+  return generateCode(jobId, concept, quality, analysisResult, customApiConfig, promptOverrides)
+}

src/queues/processors/steps/render-step.ts

@@ -12,7 +12,7 @@ import { storeJobStage } from '../../../services/job-store'
 import { createLogger } from '../../../utils/logger'
 import { cleanManimCode } from '../../../utils/manim-code-cleaner'
 import { createRetryContext, executeCodeRetry } from '../../../services/code-retry'
-import type { VideoJobData, VideoConfig } from '../../../types'
+import type { PromptOverrides, VideoJobData, VideoConfig } from '../../../types'
 
 const logger = createLogger('RenderStep')
 
@@ -67,6 +67,7 @@ export async function renderVideo(
   timings: Record<string, number>,
   customApiConfig?: any,
   videoConfig?: VideoConfig,
+  promptOverrides?: PromptOverrides,
   onStageUpdate?: () => Promise<void>
 ): Promise<RenderResult> {
   const { manimCode, usedAI, generationType, sceneDesign } = codeResult
@@ -170,7 +171,7 @@ export async function renderVideo(
       const retryStart = Date.now()
 
       // 创建重试上下文
-      const retryContext = createRetryContext(concept, sceneDesign)
+      const retryContext = createRetryContext(concept, sceneDesign, promptOverrides)
 
       // 执行重试管理器
       const retryManagerResult = await executeCodeRetry(
@@ -281,7 +282,7 @@ export async function handlePreGeneratedCode(
     manimCode: preGeneratedCode,
     usedAI: false,
     generationType: 'custom-api'
-  }, timings, jobData.customApiConfig, jobData.videoConfig)
+  }, timings, jobData.customApiConfig, jobData.videoConfig, jobData.promptOverrides)
   timings.render = Date.now() - renderStart
 
   // 存储结果

src/queues/processors/steps/storage-step.ts

@@ -4,6 +4,7 @@
  */
 
 import { storeJobResult } from '../../../services/job-store'
+import { clearJobCancelled } from '../../../services/job-cancel-store'
 import { cacheResult } from './cache-step'
 import type { RenderResult } from './render-step'
 import { createLogger } from '../../../utils/logger'
@@ -31,6 +32,7 @@ export async function storeResult(
       renderPeakMemoryMB
     }
   })
+  await clearJobCancelled(jobId)
   logger.info('Result stored', { jobId, videoUrl })
 
   // 缓存结果（如果启用）

src/queues/processors/video.processor.ts

@@ -1,103 +1,115 @@
-/**
- * Video Processor
- * 任务处理器 - 主编排器
- *
- * 职责：任务流程编排，异常处理，计时统计
- */
-
-import { videoQueue } from '../../config/bull'
-import { storeJobResult } from '../../services/job-store'
-import { createLogger } from '../../utils/logger'
-import type { VideoJobData } from '../../types'
-
-// 导入步骤模块
-import { checkCache, handleCacheHit } from './steps/cache-step'
-import { analyzeAndGenerate } from './steps/analysis-step'
-import { renderVideo, handlePreGeneratedCode } from './steps/render-step'
-import { storeResult } from './steps/storage-step'
-
-const logger = createLogger('VideoProcessor')
-
-/**
- * 任务处理器主函数
- */
-videoQueue.process(async (job) => {
-  const data = job.data as VideoJobData
-  const { jobId, concept, quality, forceRefresh = false, preGeneratedCode } = data
-
-  logger.info('Processing video job', { jobId, concept, quality, hasPreGeneratedCode: !!preGeneratedCode })
-
-  // 阶段时长追踪
-  const timings: Record<string, number> = {}
-
-  try {
-    // 如果有预生成代码，跳过缓存和 AI 生成阶段，直接渲染
-    if (preGeneratedCode) {
-      return await handlePreGeneratedCode(jobId, concept, quality, preGeneratedCode, timings, data)
-    }
-
-    // Step 1: 检查缓存
-    await storeJobStage(jobId, 'analyzing')
-    const cacheStart = Date.now()
-    const cacheResult = await checkCache(jobId, concept, quality, forceRefresh, timings)
-    timings.cache = Date.now() - cacheStart
-
-    if (cacheResult.hit) {
-      // 缓存命中 - 直接处理缓存结果
-      await handleCacheHit(jobId, concept, quality, cacheResult.data!, timings)
-      logger.info('Job completed (cache hit)', { jobId, timings })
-      return { success: true, source: 'cache', timings }
-    }
-
-    // Step 2 & 3: 分析概念并生成代码
-    await storeJobStage(jobId, 'generating')
-    const analyzeStart = Date.now()
-    const codeResult = await analyzeAndGenerate(jobId, concept, quality, timings, data.customApiConfig)
-    timings.analyze = Date.now() - analyzeStart
-
-    // Step 4: 渲染视频
-    const renderStart = Date.now()
-    const renderResult = await renderVideo(
-      jobId,
-      concept,
-      quality,
-      codeResult,
-      timings,
-      data.customApiConfig,
-      data.videoConfig,
-      () => storeJobStage(jobId, 'rendering')
-    )
-    timings.render = Date.now() - renderStart
-
-    // Step 5: 存储结果
-    const storeStart = Date.now()
-    await storeResult(renderResult, timings)
-    timings.store = Date.now() - storeStart
-
-    // 总时长
-    timings.total = timings.cache + timings.analyze + timings.render + timings.store
-
-    logger.info('Job completed', { jobId, source: 'generation', timings })
-
-    return { success: true, source: 'generation', timings }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error)
-    logger.error('Job failed', { jobId, error: errorMessage, timings })
-
-    // 存储失败结果
-    await storeJobResult(jobId, {
-      status: 'failed',
-      data: { error: errorMessage }
-    })
-
-    throw error
-  }
-})
-
-/**
- * 存储任务阶段（辅助函数）
- */
-async function storeJobStage(jobId: string, stage: string): Promise<void> {
-  const { storeJobStage: storeStage } = await import('../../services/job-store')
-  await storeStage(jobId, stage as any)
-}
+/**
+ * Video Processor
+ * 任务处理器 - 主编排器
+ *
+ * 职责：任务流程编排，异常处理，计时统计
+ */
+
+import { videoQueue } from '../../config/bull'
+import { storeJobResult } from '../../services/job-store'
+import { ensureJobNotCancelled } from '../../services/job-cancel'
+import { clearJobCancelled } from '../../services/job-cancel-store'
+import { JobCancelledError } from '../../utils/errors'
+import { createLogger } from '../../utils/logger'
+import type { VideoJobData } from '../../types'
+
+// 导入步骤模块
+import { checkCache, handleCacheHit } from './steps/cache-step'
+import { analyzeAndGenerate } from './steps/analysis-step'
+import { renderVideo, handlePreGeneratedCode } from './steps/render-step'
+import { storeResult } from './steps/storage-step'
+
+const logger = createLogger('VideoProcessor')
+
+/**
+ * 任务处理器主函数
+ */
+videoQueue.process(async (job) => {
+  const data = job.data as VideoJobData
+  const { jobId, concept, quality, forceRefresh = false, preGeneratedCode, promptOverrides } = data
+
+  logger.info('Processing video job', { jobId, concept, quality, hasPreGeneratedCode: !!preGeneratedCode })
+
+  // 阶段时长追踪
+  const timings: Record<string, number> = {}
+
+  try {
+    await ensureJobNotCancelled(jobId, job)
+    // 如果有预生成代码，跳过缓存和 AI 生成阶段，直接渲染
+    if (preGeneratedCode) {
+      await ensureJobNotCancelled(jobId, job)
+      return await handlePreGeneratedCode(jobId, concept, quality, preGeneratedCode, timings, data)
+    }
+
+    // Step 1: 检查缓存
+    await ensureJobNotCancelled(jobId, job)
+    await storeJobStage(jobId, 'analyzing')
+    const cacheStart = Date.now()
+    const cacheResult = await checkCache(jobId, concept, quality, forceRefresh, timings)
+    timings.cache = Date.now() - cacheStart
+
+    if (cacheResult.hit) {
+      // 缓存命中 - 直接处理缓存结果
+      await handleCacheHit(jobId, concept, quality, cacheResult.data!, timings)
+      logger.info('Job completed (cache hit)', { jobId, timings })
+      return { success: true, source: 'cache', timings }
+    }
+
+    // Step 2 & 3: 分析概念并生成代码
+    await ensureJobNotCancelled(jobId, job)
+    await storeJobStage(jobId, 'generating')
+    const analyzeStart = Date.now()
+    const codeResult = await analyzeAndGenerate(jobId, concept, quality, timings, data.customApiConfig, promptOverrides)
+    timings.analyze = Date.now() - analyzeStart
+
+    // Step 4: 渲染视频
+    await ensureJobNotCancelled(jobId, job)
+    const renderStart = Date.now()
+    const renderResult = await renderVideo(
+      jobId,
+      concept,
+      quality,
+      codeResult,
+      timings,
+      data.customApiConfig,
+      data.videoConfig,
+      promptOverrides,
+      () => storeJobStage(jobId, 'rendering')
+    )
+    timings.render = Date.now() - renderStart
+
+    // Step 5: 存储结果
+    await ensureJobNotCancelled(jobId, job)
+    const storeStart = Date.now()
+    await storeResult(renderResult, timings)
+    timings.store = Date.now() - storeStart
+
+    // 总时长
+    timings.total = timings.cache + timings.analyze + timings.render + timings.store
+
+    logger.info('Job completed', { jobId, source: 'generation', timings })
+
+    return { success: true, source: 'generation', timings }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    const cancelReason = error instanceof JobCancelledError ? error.details : undefined
+    logger.error('Job failed', { jobId, error: errorMessage, timings })
+
+    // 存储失败结果
+    await storeJobResult(jobId, {
+      status: 'failed',
+      data: { error: errorMessage, cancelReason }
+    })
+    await clearJobCancelled(jobId)
+
+    throw error
+  }
+})
+
+/**
+ * 存储任务阶段（辅助函数）
+ */
+async function storeJobStage(jobId: string, stage: string): Promise<void> {
+  const { storeJobStage: storeStage } = await import('../../services/job-store')
+  await storeStage(jobId, stage as any)
+}

src/routes/generate.route.ts

@@ -1,135 +1,185 @@
-/**
- * 生成路由
- * POST /api/generate - 创建视频生成任务
- *
- * 迁移自 src/api/generate.step.ts
- * 改动点：
+/**
+ * 生成路由
+ * POST /api/generate - 创建视频生成任务
+ *
+ * 迁移自 src/api/generate.step.ts
+ * 改动点：
  * - 使用 Express Router
- * - emit() 改为 videoQueue.add()
- * - Zod 验证保持不变
- * - 有预生成代码时不使用认证（前端已通过自定义 API 认证）
- */
-
-import express from 'express'
-import { z } from 'zod'
-import { v4 as uuidv4 } from 'uuid'
-import { videoQueue } from '../config/bull'
-import { storeJobStage } from '../services/job-store'
-import { createLogger } from '../utils/logger'
-import { ValidationError } from '../utils/errors'
-import { asyncHandler } from '../middlewares/error-handler'
-import { authMiddleware } from '../middlewares/auth.middleware'
-import type { GenerateRequest, GenerateResponse, VideoConfig } from '../types'
-
-const router = express.Router()
-const logger = createLogger('GenerateRoute')
-
-// 请求体 schema（与原有保持一致）
-const bodySchema = z.object({
-  concept: z.string().min(1, '概念必填'),
-  quality: z.enum(['low', 'medium', 'high']).optional().default('low'),
-  forceRefresh: z.boolean().optional().default(false),
-  /** 预生成的代码（使用自定义 AI 时） */
-  code: z.string().optional(),
-  /** 自定义 API 配置（用于代码修复） */
-  customApiConfig: z.object({
-    apiUrl: z.string(),
-    apiKey: z.string(),
-    model: z.string()
-  }).optional(),
-  /** 视频配置 */
-  videoConfig: z.object({
-    quality: z.enum(['low', 'medium', 'high']).optional(),
-    frameRate: z.number().int().min(1).max(120).optional(),
-    timeout: z.number().optional()
-  }).optional()
-})
-
-/**
- * 处理视频生成请求的核心逻辑
- */
-async function handleGenerateRequest(req: express.Request, res: express.Response) {
-  let parsed;
-  try {
-    parsed = bodySchema.parse(req.body);
-  } catch (error: any) {
-    throw error;
-  }
-
-  const { concept, quality, forceRefresh, code, customApiConfig, videoConfig } = parsed;
-
-  // 清理输入
-  const sanitizedConcept = concept.trim().replace(/\s+/g, ' ')
-
-  if (sanitizedConcept.length === 0) {
-    throw new ValidationError('提供的概念为空', { concept })
-  }
-
-  // 生成唯一的任务 ID
-  const jobId = uuidv4()
-
-  logger.info('收到动画生成请求', {
-    jobId,
-    concept: sanitizedConcept,
-    quality,
-    forceRefresh,
-    hasPreGeneratedCode: !!code,
-    videoConfig
-  })
-
-  // 设置初始阶段
-  await storeJobStage(jobId, code ? 'rendering' : 'analyzing')
-
-  // 添加任务到 Bull 队列
-  await videoQueue.add(
-    {
-      jobId,
-      concept: sanitizedConcept,
-      quality,
-      forceRefresh,
-      preGeneratedCode: code,
-      customApiConfig,
-      videoConfig,
-      timestamp: new Date().toISOString()
-    },
-    {
-      jobId
-    }
-  )
-
-  logger.info('动画请求已加入队列', { jobId })
-
-  const response: GenerateResponse = {
-    success: true,
-    jobId,
-    message: code ? '视频渲染已开始' : '动画生成已开始',
-    status: 'processing'
-  }
-
-  res.status(202).json(response)
-}
-
-/**
- * 条件认证中间件
- * 如果请求包含预生成代码，跳过认证
- */
-function optionalAuthMiddleware(
-  req: express.Request,
-  res: express.Response,
-  next: express.NextFunction
-) {
-  // 如果有预生成代码，跳过认证（因为 AI 调用已在前端完成）
-  if (req.body?.code) {
-    return next()
-  }
-  // 否则使用完整认证
-  return authMiddleware(req, res, next)
-}
-
-/**
- * POST /api/generate
- * 提交视频生成任务
- */
-router.post('/generate', optionalAuthMiddleware, asyncHandler(handleGenerateRequest))
-
-export default router
+ * - emit() 改为 videoQueue.add()
+ * - Zod 验证保持不变
+ * - 有预生成代码时不使用认证（前端已通过自定义 API 认证）
+ */
+
+import express from 'express'
+import { z } from 'zod'
+import { v4 as uuidv4 } from 'uuid'
+import { videoQueue } from '../config/bull'
+import { storeJobStage } from '../services/job-store'
+import { createLogger } from '../utils/logger'
+import { AuthenticationError, ValidationError } from '../utils/errors'
+import { asyncHandler } from '../middlewares/error-handler'
+import { authMiddleware } from '../middlewares/auth.middleware'
+import type { GenerateRequest, GenerateResponse, VideoConfig } from '../types'
+
+const router = express.Router()
+const logger = createLogger('GenerateRoute')
+
+function extractToken(authHeader: string | string[] | undefined): string {
+  if (!authHeader) return ''
+
+  if (typeof authHeader === 'string') {
+    return authHeader.replace(/^Bearer\s+/i, '')
+  }
+  if (Array.isArray(authHeader)) {
+    return authHeader[0]?.replace(/^Bearer\s+/i, '') || ''
+  }
+  return ''
+}
+
+function hasPromptOverrides(promptOverrides: any): boolean {
+  if (!promptOverrides) return false
+  const system = promptOverrides.system || {}
+  const user = promptOverrides.user || {}
+  return Object.values(system).some((value) => typeof value === 'string' && value.trim().length > 0) ||
+    Object.values(user).some((value) => typeof value === 'string' && value.trim().length > 0)
+}
+
+function requirePromptOverrideAuth(req: express.Request): void {
+  const manimcatApiKey = process.env.MANIMCAT_API_KEY
+  if (!manimcatApiKey) {
+    throw new AuthenticationError('Prompt overrides require MANIMCAT_API_KEY to be set.')
+  }
+
+  const token = extractToken(req.headers?.authorization)
+  if (!token || token !== manimcatApiKey) {
+    throw new AuthenticationError('Prompt overrides require a valid MANIMCAT_API_KEY token.')
+  }
+}
+
+// 请求体 schema（与原有保持一致）
+const bodySchema = z.object({
+  concept: z.string().min(1, '概念必填'),
+  quality: z.enum(['low', 'medium', 'high']).optional().default('low'),
+  forceRefresh: z.boolean().optional().default(false),
+  /** 预生成的代码（使用自定义 AI 时） */
+  code: z.string().optional(),
+  /** 自定义 API 配置（用于代码修复） */
+  customApiConfig: z.object({
+    apiUrl: z.string(),
+    apiKey: z.string(),
+    model: z.string()
+  }).optional(),
+  promptOverrides: z.object({
+    system: z.object({
+      conceptDesigner: z.string().max(20000).optional(),
+      codeGeneration: z.string().max(20000).optional(),
+      codeRetry: z.string().max(20000).optional()
+    }).optional(),
+    user: z.object({
+      conceptDesigner: z.string().max(20000).optional(),
+      codeGeneration: z.string().max(20000).optional(),
+      codeRetryInitial: z.string().max(20000).optional(),
+      codeRetryFix: z.string().max(20000).optional()
+    }).optional()
+  }).optional(),
+  /** 视频配置 */
+  videoConfig: z.object({
+    quality: z.enum(['low', 'medium', 'high']).optional(),
+    frameRate: z.number().int().min(1).max(120).optional(),
+    timeout: z.number().optional()
+  }).optional()
+})
+
+/**
+ * 处理视频生成请求的核心逻辑
+ */
+async function handleGenerateRequest(req: express.Request, res: express.Response) {
+  let parsed;
+  try {
+    parsed = bodySchema.parse(req.body);
+  } catch (error: any) {
+    throw error;
+  }
+
+  const { concept, quality, forceRefresh, code, customApiConfig, promptOverrides, videoConfig } = parsed;
+
+  // 清理输入
+  if (hasPromptOverrides(promptOverrides)) {
+    requirePromptOverrideAuth(req)
+  }
+
+  const sanitizedConcept = concept.trim().replace(/\s+/g, ' ')
+
+  if (sanitizedConcept.length === 0) {
+    throw new ValidationError('提供的概念为空', { concept })
+  }
+
+  // 生成唯一的任务 ID
+  const jobId = uuidv4()
+
+  logger.info('收到动画生成请求', {
+    jobId,
+    concept: sanitizedConcept,
+    quality,
+    forceRefresh,
+    hasPreGeneratedCode: !!code,
+    videoConfig
+  })
+
+  // 设置初始阶段
+  await storeJobStage(jobId, code ? 'rendering' : 'analyzing')
+
+  // 添加任务到 Bull 队列
+  await videoQueue.add(
+    {
+      jobId,
+      concept: sanitizedConcept,
+      quality,
+      forceRefresh,
+      preGeneratedCode: code,
+      customApiConfig,
+      promptOverrides,
+      videoConfig,
+      timestamp: new Date().toISOString()
+    },
+    {
+      jobId
+    }
+  )
+
+  logger.info('动画请求已加入队列', { jobId })
+
+  const response: GenerateResponse = {
+    success: true,
+    jobId,
+    message: code ? '视频渲染已开始' : '动画生成已开始',
+    status: 'processing'
+  }
+
+  res.status(202).json(response)
+}
+
+/**
+ * 条件认证中间件
+ * 如果请求包含预生成代码，跳过认证
+ */
+function optionalAuthMiddleware(
+  req: express.Request,
+  res: express.Response,
+  next: express.NextFunction
+) {
+  // 如果有预生成代码，跳过认证（因为 AI 调用已在前端完成）
+  if (req.body?.code) {
+    return next()
+  }
+  // 否则使用完整认证
+  return authMiddleware(req, res, next)
+}
+
+/**
+ * POST /api/generate
+ * 提交视频生成任务
+ */
+router.post('/generate', optionalAuthMiddleware, asyncHandler(handleGenerateRequest))
+
+export default router

src/routes/index.ts

@@ -1,24 +1,28 @@
-/**
- * Routes Index
- * 路由总入口
- * - 统一挂载所有路由
- * - API 版本控制
- */
-
-import express from 'express'
-import generateRouter from './generate.route'
-import jobStatusRouter from './job-status.route'
-import healthRouter from './health.route'
-import metricsRouter from './metrics.route'
-
-const router = express.Router()
-
-// 挂载健康检查路由（不使用 /api 前缀）
-router.use(healthRouter)
-
-// 挂载 API 路由（使用 /api 前缀）
-router.use('/api', generateRouter)
-router.use('/api', jobStatusRouter)
-router.use('/api/metrics', metricsRouter)
-
-export default router
+/**
+ * Routes Index
+ * 路由总入口
+ * - 统一挂载所有路由
+ * - API 版本控制
+ */
+
+import express from 'express'
+import generateRouter from './generate.route'
+import jobStatusRouter from './job-status.route'
+import jobCancelRouter from './job-cancel.route'
+import promptsRouter from './prompts.route'
+import healthRouter from './health.route'
+import metricsRouter from './metrics.route'
+
+const router = express.Router()
+
+// 挂载健康检查路由（不使用 /api 前缀）
+router.use(healthRouter)
+
+// 挂载 API 路由（使用 /api 前缀）
+router.use('/api', generateRouter)
+router.use('/api', jobStatusRouter)
+router.use('/api', jobCancelRouter)
+router.use('/api', promptsRouter)
+router.use('/api/metrics', metricsRouter)
+
+export default router

src/routes/job-cancel.route.ts

@@ -0,0 +1,36 @@
+/**
+ * Job Cancel Route
+ * POST /api/jobs/:jobId/cancel
+ */
+
+import express, { type Request, type Response } from 'express'
+import { asyncHandler } from '../middlewares/error-handler'
+import { cancelJob } from '../services/job-cancel'
+import { ValidationError } from '../utils/errors'
+
+const router = express.Router()
+
+router.post(
+  '/jobs/:jobId/cancel',
+  asyncHandler(async (req: Request, res: Response) => {
+    const { jobId } = req.params
+
+    if (!jobId) {
+      throw new ValidationError('Missing jobId')
+    }
+
+    const result = await cancelJob(jobId)
+    const status = result.jobState == 'completed' ? 'completed' : 'cancelled'
+    const message = status == 'completed' ? 'Job already completed' : 'Job cancelled'
+
+    res.status(200).json({
+      success: true,
+      jobId,
+      status,
+      jobState: result.jobState,
+      message
+    })
+  })
+)
+
+export default router

src/routes/job-status.route.ts

@@ -103,7 +103,8 @@ router.get(
       status: 'failed' as const,
       success: false as const,
       error: result.data.error,
-      details: result.data.details
+      details: result.data.details,
+      cancel_reason: result.data.cancelReason
     })
   })
 )

src/routes/prompts.route.ts

@@ -0,0 +1,38 @@
+import express from 'express'
+
+import { SYSTEM_PROMPTS, generateConceptDesignerPrompt, generateCodeGenerationPrompt } from '../prompts'
+import { CODE_RETRY_SYSTEM_PROMPT, buildInitialCodePrompt } from '../services/code-retry/prompts'
+import { buildRetryFixPrompt } from '../services/code-retry/manager'
+import type { PromptOverrides } from '../types'
+
+const router = express.Router()
+
+const PLACEHOLDERS = {
+  concept: '{{concept}}',
+  seed: '{{seed}}',
+  sceneDesign: '{{sceneDesign}}',
+  errorMessage: '{{errorMessage}}',
+  attempt: '{{attempt}}'
+}
+
+function buildDefaultPromptTemplates(): PromptOverrides {
+  return {
+    system: {
+      conceptDesigner: SYSTEM_PROMPTS.conceptDesigner,
+      codeGeneration: SYSTEM_PROMPTS.codeGeneration,
+      codeRetry: CODE_RETRY_SYSTEM_PROMPT
+    },
+    user: {
+      conceptDesigner: generateConceptDesignerPrompt(PLACEHOLDERS.concept, PLACEHOLDERS.seed),
+      codeGeneration: generateCodeGenerationPrompt(PLACEHOLDERS.concept, PLACEHOLDERS.seed, PLACEHOLDERS.sceneDesign),
+      codeRetryInitial: buildInitialCodePrompt(PLACEHOLDERS.concept, PLACEHOLDERS.seed, PLACEHOLDERS.sceneDesign),
+      codeRetryFix: buildRetryFixPrompt(PLACEHOLDERS.concept, PLACEHOLDERS.errorMessage, PLACEHOLDERS.attempt)
+    }
+  }
+}
+
+router.get('/prompts/defaults', (_req, res) => {
+  res.json(buildDefaultPromptTemplates())
+})
+
+export default router

src/server.ts

@@ -1,235 +1,238 @@
-/**
- * Express Application Entry Point
- * Express 应用主入口
- */
-
-import 'dotenv/config'
-import express, { type Request, Response, type NextFunction } from 'express'
-import { appConfig, validateConfig, printConfig, isDevelopment } from './config/app'
-import { redisClient } from './config/redis'
-import { closeQueue } from './config/bull'
-import { corsMiddleware } from './middlewares/cors'
-import { errorHandler, notFoundHandler } from './middlewares/error-handler'
-import { logger, createLogger } from './utils/logger'
-import routes from './routes'
-import type { Server } from 'http'
-import path from 'path'
-
-// 导入队列处理器以启动 worker
-import './queues/processors/video.processor'
-
-const app = express()
-const appLogger = createLogger('Server')
-
-let server: Server | null = null
-
-/**
- * 请求日志中间件
- */
-function requestLogger(req: Request, res: Response, next: NextFunction): void {
-  const start = Date.now()
-
-  res.on('finish', () => {
-    const duration = Date.now() - start
-    // 只记录非查询状态的请求
-    if (!req.path.includes('/jobs/')) {
-      appLogger.info('Request completed', {
-        method: req.method,
-        path: req.path,
-        status: res.statusCode,
-        duration: `${duration}ms`
-      })
-    }
-  })
-
-  next()
-}
-
-/**
- * 初始化应用
- */
-async function initializeApp(): Promise<void> {
-  try {
-    // 验证配置
-    validateConfig()
-
-    // 基础中间件
-    app.use(express.json({ limit: '10mb' }))
-    app.use(express.urlencoded({ extended: true, limit: '10mb' }))
-    app.use(corsMiddleware)
-    
-    // JSON 解析错误处理
-    app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
-      if (err instanceof SyntaxError && 'body' in err) {
-        appLogger.error('JSON 解析错误', {
-          method: req.method,
-          path: req.path,
-          error: err.message,
-          body: req.body
-        })
-        return res.status(400).json({
-          error: 'Invalid JSON',
-          message: err.message
-        })
-      }
-      next(err)
-    })
-
-    // 请求日志（开发环境）
-    if (isDevelopment()) {
-      app.use(requestLogger)
-    }
-
-    // 静态文件服务
-    app.use(express.static('public'))
-
-    // 挂载所有路由（包括健康检查和 API 路由）
-    app.use(routes)
-
-    // SPA fallback：任何非 API 请求都返回 React 的 index.html
-    app.get('*', (req, res) => {
-      // 跳过健康检查和 API 路由
-      if (req.path.startsWith('/health') || req.path.startsWith('/api')) {
-        return notFoundHandler(req, res, () => {})
-      }
-      // 返回 React 前端的 index.html
-      const indexPath = path.join(__dirname, '..', 'public', 'index.html')
-      res.sendFile(indexPath, (err) => {
-        if (err) {
-          return notFoundHandler(req, res, () => {})
-        }
-      })
-    })
-
-    // 全局错误处理
-    app.use(errorHandler)
-
-    // 打印配置信息
-    printConfig()
-
-    appLogger.info('Express application initialized successfully')
-  } catch (error) {
-    appLogger.error('Failed to initialize application', { error })
-    throw error
-  }
-}
-
-/**
- * 尝试在指定端口启动服务器
- */
-function tryListen(port: number, host: string, retries = 3): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const attemptListen = (attemptNumber: number) => {
-      server = app.listen(port, host)
-        .on('listening', () => {
-          appLogger.info(`🚀 Server listening on http://${host}:${port}`)
-          appLogger.info(`📝 Environment: ${appConfig.nodeEnv}`)
-          appLogger.info(`🔍 Health check: http://${host}:${port}/health`)
-          resolve()
-        })
-        .on('error', (error: NodeJS.ErrnoException) => {
-          if (error.code === 'EADDRINUSE') {
-            appLogger.warn(`Port ${port} is in use, attempt ${attemptNumber}/${retries}`)
-            
-            if (attemptNumber < retries) {
-              // 等待一段时间后重试
-              setTimeout(() => {
-                attemptListen(attemptNumber + 1)
-              }, 1000 * attemptNumber) // 递增等待时间
-            } else {
-              appLogger.error(`Failed to bind to port ${port} after ${retries} attempts`)
-              reject(new Error(`Port ${port} is already in use. Please stop the existing process or use a different port.`))
-            }
-          } else {
-            appLogger.error('Server error', { error })
-            reject(error)
-          }
-        })
-    }
-
-    attemptListen(1)
-  })
-}
-
-/**
- * 启动服务器
- */
-async function startServer(): Promise<void> {
-  await initializeApp()
-  await tryListen(appConfig.port, appConfig.host)
-  setupShutdownHandlers()
-}
-
-/**
- * 设置优雅关闭处理器
- */
-function setupShutdownHandlers(): void {
-  // 优雅关闭处理
-  const shutdown = async (signal: string): Promise<void> => {
-    appLogger.info(`Received ${signal}, starting graceful shutdown...`)
-
-    if (!server) {
-      appLogger.warn('Server instance not found, skipping server close')
-      await cleanupResources()
-      process.exit(0)
-      return
-    }
-
-    // 停止接收新连接
-    server.close(async (err) => {
-      if (err) {
-        appLogger.error('Error closing server', { error: err })
-        process.exit(1)
-      }
-
-      await cleanupResources()
-    })
-
-    // 强制退出超时
-    setTimeout(() => {
-      appLogger.warn('Forced shutdown after timeout')
-      process.exit(1)
-    }, 30000) // 30 秒超时
-  }
-
-  // 清理资源
-  const cleanupResources = async (): Promise<void> => {
-    try {
-      // 关闭队列
-      await closeQueue()
-
-      // 关闭 Redis 连接
-      await redisClient.quit()
-
-      appLogger.info('Graceful shutdown completed')
-      process.exit(0)
-    } catch (error) {
-      appLogger.error('Error during shutdown', { error })
-      process.exit(1)
-    }
-  }
-
-  // 监听退出信号
-  process.on('SIGTERM', () => shutdown('SIGTERM'))
-  process.on('SIGINT', () => shutdown('SIGINT'))
-
-  // 未捕获异常处理
-  process.on('uncaughtException', (error) => {
-    appLogger.error('Uncaught exception', { error })
-    shutdown('UNCAUGHT_EXCEPTION')
-  })
-
-  process.on('unhandledRejection', (reason, promise) => {
-    appLogger.error('Unhandled rejection', { reason, promise })
-    shutdown('UNHANDLED_REJECTION')
-  })
-}
-
-// 启动应用
-startServer().catch((error) => {
-  appLogger.error('Failed to start server', { error })
-  process.exit(1)
-})
-
-// 导出 app 用于测试
-export default app
+/**
+ * Express Application Entry Point
+ * Express 应用主入口
+ */
+
+import 'dotenv/config'
+import express, { type Request, Response, type NextFunction } from 'express'
+import { appConfig, validateConfig, printConfig, isDevelopment } from './config/app'
+import { redisClient } from './config/redis'
+import { closeQueue } from './config/bull'
+import { corsMiddleware } from './middlewares/cors'
+import { errorHandler, notFoundHandler } from './middlewares/error-handler'
+import { logger, createLogger } from './utils/logger'
+import routes from './routes'
+import type { Server } from 'http'
+import path from 'path'
+
+// 导入队列处理器以启动 worker
+import './queues/processors/video.processor'
+
+const app = express()
+const appLogger = createLogger('Server')
+
+let server: Server | null = null
+
+/**
+ * 请求日志中间件
+ */
+function requestLogger(req: Request, res: Response, next: NextFunction): void {
+  const start = Date.now()
+
+  res.on('finish', () => {
+    const duration = Date.now() - start
+    // 只记录非查询状态的请求
+    if (!req.path.includes('/jobs/')) {
+      appLogger.info('Request completed', {
+        method: req.method,
+        path: req.path,
+        status: res.statusCode,
+        duration: `${duration}ms`
+      })
+    }
+  })
+
+  next()
+}
+
+/**
+ * 初始化应用
+ */
+async function initializeApp(): Promise<void> {
+  try {
+    // 验证配置
+    validateConfig()
+
+    // 基础中间件
+    app.use(express.json({ limit: '10mb' }))
+    app.use(express.urlencoded({ extended: true, limit: '10mb' }))
+    app.use(corsMiddleware)
+    
+    // JSON 解析错误处理
+    app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
+      if (err instanceof SyntaxError && 'body' in err) {
+        appLogger.error('JSON 解析错误', {
+          method: req.method,
+          path: req.path,
+          error: err.message,
+          body: req.body
+        })
+        return res.status(400).json({
+          error: 'Invalid JSON',
+          message: err.message
+        })
+      }
+      next(err)
+    })
+
+    // 请求日志（开发环境）
+    if (isDevelopment()) {
+      app.use(requestLogger)
+    }
+
+    // 静态文件服务
+    app.use(express.static('public'))
+
+    // 挂载所有路由（包括健康检查和 API 路由）
+    app.use(routes)
+
+    // SPA fallback：任何非 API 请求都返回 React 的 index.html
+    app.get('*', (req, res) => {
+      // 跳过健康检查和 API 路由
+      if (req.path.startsWith('/health') || req.path.startsWith('/api')) {
+        return notFoundHandler(req, res, () => {})
+      }
+      // 返回 React 前端的 index.html
+      const indexPath = path.join(__dirname, '..', 'public', 'index.html')
+      res.sendFile(indexPath, (err) => {
+        if (err) {
+          return notFoundHandler(req, res, () => {})
+        }
+      })
+    })
+
+    // 全局错误处理
+    app.use(errorHandler)
+
+    // 打印配置信息
+    printConfig()
+
+    appLogger.info('Express application initialized successfully')
+  } catch (error) {
+    appLogger.error('Failed to initialize application', { error })
+    throw error
+  }
+}
+
+/**
+ * 尝试在指定端口启动服务器
+ */
+function tryListen(port: number, host: string, retries = 3): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const attemptListen = (attemptNumber: number) => {
+      server = app.listen(port, host)
+        .on('listening', () => {
+          appLogger.info(`🚀 Server listening on http://${host}:${port}`)
+          appLogger.info(`📝 Environment: ${appConfig.nodeEnv}`)
+          appLogger.info(`🔍 Health check: http://${host}:${port}/health`)
+          resolve()
+        })
+        .on('error', (error: NodeJS.ErrnoException) => {
+          if (error.code === 'EADDRINUSE') {
+            appLogger.warn(`Port ${port} is in use, attempt ${attemptNumber}/${retries}`)
+            
+            if (attemptNumber < retries) {
+              // 等待一段时间后重试
+              setTimeout(() => {
+                attemptListen(attemptNumber + 1)
+              }, 1000 * attemptNumber) // 递增等待时间
+            } else {
+              appLogger.error(`Failed to bind to port ${port} after ${retries} attempts`)
+              reject(new Error(`Port ${port} is already in use. Please stop the existing process or use a different port.`))
+            }
+          } else {
+            appLogger.error('Server error', { error })
+            reject(error)
+          }
+        })
+    }
+
+    attemptListen(1)
+  })
+}
+
+/**
+ * 启动服务器
+ */
+async function startServer(): Promise<void> {
+  await initializeApp()
+  await tryListen(appConfig.port, appConfig.host)
+  setupShutdownHandlers()
+}
+
+/**
+ * 设置优雅关闭处理器
+ */
+function setupShutdownHandlers(): void {
+  // 优雅关闭处理
+  const shutdown = async (signal: string): Promise<void> => {
+    appLogger.info(`Received ${signal}, starting graceful shutdown...`)
+
+    if (!server) {
+      appLogger.warn('Server instance not found, skipping server close')
+      await cleanupResources()
+      process.exit(0)
+      return
+    }
+
+    // 停止接收新连接
+    server.close(async (err) => {
+      if (err) {
+        appLogger.error('Error closing server', { error: err })
+        process.exit(1)
+      }
+
+      await cleanupResources()
+    })
+
+    // 强制退出超时
+    setTimeout(() => {
+      appLogger.warn('Forced shutdown after timeout')
+      process.exit(1)
+    }, 10 * 60 * 1000) // 10 minutes timeout
+  }
+
+  // 清理资源
+  const cleanupResources = async (): Promise<void> => {
+    try {
+      // 关闭队列
+      await closeQueue()
+
+      // 关闭 Redis 连接
+      await redisClient.quit()
+
+      appLogger.info('Graceful shutdown completed')
+      process.exit(0)
+    } catch (error) {
+      appLogger.error('Error during shutdown', { error })
+      process.exit(1)
+    }
+  }
+
+  // 监听退出信号
+  process.on('SIGTERM', () => shutdown('SIGTERM'))
+  process.on('SIGINT', () => shutdown('SIGINT'))
+
+  // 未捕获异常处理
+  process.on('uncaughtException', (error) => {
+    appLogger.error('Uncaught exception', { error })
+    shutdown('UNCAUGHT_EXCEPTION')
+  })
+
+  process.on('unhandledRejection', (reason, promise) => {
+    appLogger.error('Unhandled rejection', { reason, promise })
+    shutdown('UNHANDLED_REJECTION')
+  })
+}
+
+// 启动应用
+startServer().catch((error) => {
+  appLogger.error('Failed to start server', { error })
+  process.exit(1)
+})
+
+// 导出 app 用于测试
+export default app
+
+
+

src/services/code-retry/manager.ts

@@ -1,310 +1,332 @@
-/**
- * Code Retry Service - 重试管理器
- *
- * 核心逻辑：
- * 1. 维护完整的对话历史（原始提示词 + 每次生成的代码 + 每次的错误）
- * 2. 每次重试都发送完整的对话历史
- * 3. 最多重试 4 次
- */
-
-import crypto from 'crypto'
-import OpenAI from 'openai'
-import { createLogger } from '../../utils/logger'
-import { cleanManimCode } from '../../utils/manim-code-cleaner'
-
-import type { CodeRetryOptions, CodeRetryResult, RenderResult, RetryManagerResult, ChatMessage, CodeRetryContext } from './types'
-import { buildInitialCodePrompt, CODE_RETRY_SYSTEM_PROMPT } from './prompts'
-import { getClient } from './client'
-import { extractCodeFromResponse, extractErrorMessage, getErrorType } from './utils'
-
-const logger = createLogger('CodeRetryManager')
-
-// 配置
-const MAX_RETRIES = parseInt(process.env.CODE_RETRY_MAX_RETRIES || '4', 10)
-const OPENAI_MODEL = process.env.OPENAI_MODEL || 'glm-4-flash'
-const AI_TEMPERATURE = parseFloat(process.env.AI_TEMPERATURE || '0.7')
-const MAX_TOKENS = parseInt(process.env.AI_MAX_TOKENS || '1200', 10)
-
-/**
- * 生成唯一种子
- */
-function generateSeed(concept: string): string {
-  const timestamp = Date.now()
-  const randomPart = crypto.randomBytes(4).toString('hex')
-  return crypto.createHash('md5').update(`${concept}-${timestamp}-${randomPart}`).digest('hex').slice(0, 8)
-}
-
-/**
- * 创建重试上下文
- */
-export function createRetryContext(
-  concept: string,
-  sceneDesign: string
-): CodeRetryContext {
-  const seed = generateSeed(concept)
-
-  return {
-    concept,
-    sceneDesign,
-    originalPrompt: buildInitialCodePrompt(concept, seed, sceneDesign),
-    messages: []
-  }
-}
-
-/**
- * 首次代码生成
- */
-async function generateInitialCode(
-  context: CodeRetryContext,
-  customApiConfig?: any
-): Promise<string> {
-  const client = getClient(customApiConfig)
-  if (!client) {
-    throw new Error('OpenAI 客户端不可用')
-  }
-
-  try {
-    const response = await client.chat.completions.create({
-      model: OPENAI_MODEL,
-      messages: [
-        { role: 'system', content: CODE_RETRY_SYSTEM_PROMPT },
-        { role: 'user', content: context.originalPrompt }
-      ],
-      temperature: AI_TEMPERATURE,
-      max_tokens: MAX_TOKENS
-    })
-
-    const content = response.choices[0]?.message?.content || ''
-    if (!content) {
-      throw new Error('AI 返回空内容')
-    }
-
-    // 清洗代码
-    const code = extractCodeFromResponse(content)
-    const cleaned = cleanManimCode(code)
-
-    // 保存对话历史
-    context.messages.push(
-      { role: 'user', content: context.originalPrompt },
-      { role: 'assistant', content: code }
-    )
-
-    logger.info('首次代码生成成功', {
-      concept: context.concept,
-      codeLength: cleaned.code.length
-    })
-
-    return cleaned.code
-  } catch (error) {
-    if (error instanceof OpenAI.APIError) {
-      logger.error('OpenAI API 错误', {
-        status: error.status,
-        message: error.message
-      })
-    }
-    throw error
-  }
-}
-
-/**
- * 重试代码生成
- */
-async function retryCodeGeneration(
-  context: CodeRetryContext,
-  errorMessage: string,
-  attempt: number,
-  customApiConfig?: any
-): Promise<string> {
-  const client = getClient(customApiConfig)
-  if (!client) {
-    throw new Error('OpenAI 客户端不可用')
-  }
-
-  // 构建重试提示词（包含完整对话历史和错误信息）
-  const retryPrompt = buildRetryPrompt(context, errorMessage, attempt)
-
-  try {
-    // 构建消息数组：system + 历史消息 + 当前重试提示词
-    const messages: ChatMessage[] = [
-      { role: 'system', content: CODE_RETRY_SYSTEM_PROMPT },
-      ...context.messages,
-      { role: 'user', content: retryPrompt }
-    ]
-
-    const response = await client.chat.completions.create({
-      model: OPENAI_MODEL,
-      messages,
-      temperature: AI_TEMPERATURE,
-      max_tokens: MAX_TOKENS
-    })
-
-    const content = response.choices[0]?.message?.content || ''
-    if (!content) {
-      throw new Error('AI 返回空内容')
-    }
-
-    // 清洗代码
-    const code = extractCodeFromResponse(content)
-    const cleaned = cleanManimCode(code)
-
-    // 保存对话历史
-    context.messages.push(
-      { role: 'user', content: retryPrompt },
-      { role: 'assistant', content: code }
-    )
-
-    logger.info('代码重试生成成功', {
-      concept: context.concept,
-      attempt,
-      codeLength: cleaned.code.length
-    })
-
-    return cleaned.code
-  } catch (error) {
-    if (error instanceof OpenAI.APIError) {
-      logger.error('OpenAI API 错误（重试）', {
-        attempt,
-        status: error.status,
-        message: error.message
-      })
-    }
-    throw error
-  }
-}
-
-/**
- * 构建重试提示词
- */
-function buildRetryPrompt(
-  context: CodeRetryContext,
-  errorMessage: string,
-  attempt: number
-): string {
-  return `## 目标层
-
-### 输入预期
-
-- **概念**：${context.concept}
-- **错误信息**（第 ${attempt} 次重试）：${errorMessage}
-
-### 产出要求
-
-- **修复代码**：根据错误信息修复之前的代码。
-- **完整代码**：必须输出完整的、可运行的 Manim 代码，不是修复片段！
-- **锚点协议**：代码必须包裹在 ### START ### 和 ### END ### 之间
-- **纯代码输出**：严禁包含任何解释性文字。
-- **结构规范**：核心类名固定为 \`MainScene\`（若为 3D 场景则继承自 \`ThreeDScene\`）。
-- **导入规范**：必须使用全部导入 \`from manim import *\`
-
-## 行为层
-
-### 修复原则
-
-1. **分析错误**：根据错误信息找出代码中的问题
-2. **完整修复**：修复后必须输出完整的 Manim 代码（包含 import、class 定义等所有部分）
-3. **确保可运行**：修复后的代码必须是完整的、可直接运行的 Python 代码
-
-### 重要提示
-
-不要只输出修复的代码片段！必须输出完整的 Manim 代码。
-
-示例格式：
-
-\`\`\`
-### START ###
-from manim import *
-
-class MainScene(Scene):
-    def construct(self):
-        # ... 你的完整代码 ...
-### END ###
-\`\`\`
-
-请修复上述代码，输出完整的 Python 代码。`
-}
-
-/**
- * 重试管理器 - 核心函数
- *
- * 流程：
- * 1. 首次生成代码 → 渲染
- * 2. 如果失败，检查错误是否可修复
- * 3. 重试（最多4次），每次都发送完整对话历史
- * 4. 如果4次后仍失败，返回失败结果
- */
-export async function executeCodeRetry(
-  context: CodeRetryContext,
-  renderer: (code: string) => Promise<RenderResult>,
-  customApiConfig?: any
-): Promise<RetryManagerResult> {
-  logger.info('开始代码重试管理', {
-    concept: context.concept,
-    maxRetries: MAX_RETRIES
-  })
-
-  // 步骤1：首次代码生成和渲染
-  let currentCode = await generateInitialCode(context, customApiConfig)
-  let renderResult = await renderer(currentCode)
-
-  if (renderResult.success) {
-    logger.info('首次渲染成功')
-    return { code: currentCode, success: true, attempts: 1 }
-  }
-
-  // 步骤2：提取错误信息并开始重试
-  let errorMessage = extractErrorMessage(renderResult.stderr)
-  let errorType = getErrorType(renderResult.stderr)
-  logger.warn('首次渲染失败', { errorType, error: errorMessage })
-  // 所有错误都尝试重试，AI 有能力修复语法、导入等问题
-
-  // 步骤3：重试循环
-  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-    logger.info(`开始第 ${attempt} 次重试`, {
-      totalAttempts: attempt + 1,
-      errorType,
-      error: errorMessage
-    })
-
-    try {
-      currentCode = await retryCodeGeneration(context, errorMessage, attempt, customApiConfig)
-      renderResult = await renderer(currentCode)
-
-      if (renderResult.success) {
-        logger.info('重试渲染成功', { attempt: attempt + 1 })
-        return { code: currentCode, success: true, attempts: attempt + 1 }
-      }
-
-      // 更新错误信息
-      errorMessage = extractErrorMessage(renderResult.stderr)
-      errorType = getErrorType(renderResult.stderr)
-      logger.warn('重试渲染失败', { attempt: attempt + 1, errorType, error: errorMessage })
-    } catch (error) {
-      logger.error('重试过程出错', { attempt: attempt + 1, error: String(error) })
-    }
-  }
-
-  // 步骤4：所有重试失败
-  logger.error('所有重试均失败', {
-    totalAttempts: MAX_RETRIES + 1,
-    finalError: extractErrorMessage(renderResult.stderr)
-  })
-
-  return {
-    code: currentCode,
-    success: false,
-    attempts: MAX_RETRIES + 1,
-    lastError: extractErrorMessage(renderResult.stderr)
-  }
-}
-
-/**
- * 导出类型
- */
-export type {
-  CodeRetryOptions,
-  CodeRetryResult,
-  RenderResult,
-  RetryManagerResult,
-  ChatMessage,
-  CodeRetryContext
-} from './types'
+/**
+ * Code Retry Service - 重试管理器
+ *
+ * 核心逻辑：
+ * 1. 维护完整的对话历史（原始提示词 + 每次生成的代码 + 每次的错误）
+ * 2. 每次重试都发送完整的对话历史
+ * 3. 最多重试 4 次
+ */
+
+import crypto from 'crypto'
+import OpenAI from 'openai'
+import { createLogger } from '../../utils/logger'
+import { cleanManimCode } from '../../utils/manim-code-cleaner'
+
+import type { CodeRetryOptions, CodeRetryResult, RenderResult, RetryManagerResult, ChatMessage, CodeRetryContext } from './types'
+import type { PromptOverrides } from '../../types'
+import { buildInitialCodePrompt, CODE_RETRY_SYSTEM_PROMPT } from './prompts'
+import { getClient } from './client'
+import { extractCodeFromResponse, extractErrorMessage, getErrorType } from './utils'
+
+const logger = createLogger('CodeRetryManager')
+
+// 配置
+const MAX_RETRIES = parseInt(process.env.CODE_RETRY_MAX_RETRIES || '4', 10)
+const OPENAI_MODEL = process.env.OPENAI_MODEL || 'glm-4-flash'
+const AI_TEMPERATURE = parseFloat(process.env.AI_TEMPERATURE || '0.7')
+const MAX_TOKENS = parseInt(process.env.AI_MAX_TOKENS || '1200', 10)
+
+/**
+ * 生成唯一种子
+ */
+function applyPromptTemplate(template: string, values: Record<string, string>): string {
+  let output = template
+  for (const [key, value] of Object.entries(values)) {
+    output = output.replace(new RegExp(`{{\s*${key}\s*}}`, 'g'), value)
+  }
+  return output
+}
+
+function getCodeRetrySystemPrompt(promptOverrides?: PromptOverrides): string {
+  return promptOverrides?.system?.codeRetry || CODE_RETRY_SYSTEM_PROMPT
+}
+
+function buildInitialPrompt(
+  concept: string,
+  seed: string,
+  sceneDesign: string,
+  promptOverrides?: PromptOverrides
+): string {
+  const override = promptOverrides?.user?.codeRetryInitial
+  if (override) {
+    return applyPromptTemplate(override, {
+      concept,
+      seed,
+      sceneDesign
+    })
+  }
+  return buildInitialCodePrompt(concept, seed, sceneDesign)
+}
+
+function generateSeed(concept: string): string {
+  const timestamp = Date.now()
+  const randomPart = crypto.randomBytes(4).toString('hex')
+  return crypto.createHash('md5').update(`${concept}-${timestamp}-${randomPart}`).digest('hex').slice(0, 8)
+}
+
+/**
+ * 创建重试上下文
+ */
+export function createRetryContext(
+  concept: string,
+  sceneDesign: string,
+  promptOverrides?: PromptOverrides
+): CodeRetryContext {
+  const seed = generateSeed(concept)
+
+  return {
+    concept,
+    sceneDesign,
+    originalPrompt: buildInitialPrompt(concept, seed, sceneDesign, promptOverrides),
+    messages: [],
+    promptOverrides
+  }
+}
+
+/**
+ * 首次代码生成
+ */
+async function generateInitialCode(
+  context: CodeRetryContext,
+  customApiConfig?: any
+): Promise<string> {
+  const client = getClient(customApiConfig)
+  if (!client) {
+    throw new Error('OpenAI 客户端不可用')
+  }
+
+  try {
+    const response = await client.chat.completions.create({
+      model: OPENAI_MODEL,
+      messages: [
+        { role: 'system', content: getCodeRetrySystemPrompt(context.promptOverrides) },
+        { role: 'user', content: context.originalPrompt }
+      ],
+      temperature: AI_TEMPERATURE,
+      max_tokens: MAX_TOKENS
+    })
+
+    const content = response.choices[0]?.message?.content || ''
+    if (!content) {
+      throw new Error('AI 返回空内容')
+    }
+
+    // 清洗代码
+    const code = extractCodeFromResponse(content)
+    const cleaned = cleanManimCode(code)
+
+    // 保存对话历史
+    context.messages.push(
+      { role: 'user', content: context.originalPrompt },
+      { role: 'assistant', content: code }
+    )
+
+    logger.info('首次代码生成成功', {
+      concept: context.concept,
+      codeLength: cleaned.code.length
+    })
+
+    return cleaned.code
+  } catch (error) {
+    if (error instanceof OpenAI.APIError) {
+      logger.error('OpenAI API 错误', {
+        status: error.status,
+        message: error.message
+      })
+    }
+    throw error
+  }
+}
+
+/**
+ * 重试代码生成
+ */
+async function retryCodeGeneration(
+  context: CodeRetryContext,
+  errorMessage: string,
+  attempt: number,
+  customApiConfig?: any
+): Promise<string> {
+  const client = getClient(customApiConfig)
+  if (!client) {
+    throw new Error('OpenAI 客户端不可用')
+  }
+
+  // 构建重试提示词（包含完整对话历史和错误信息）
+  const retryPrompt = buildRetryPrompt(context, errorMessage, attempt)
+
+  try {
+    // 构建消息数组：system + 历史消息 + 当前重试提示词
+    const messages: ChatMessage[] = [
+      { role: 'system', content: getCodeRetrySystemPrompt(context.promptOverrides) },
+      ...context.messages,
+      { role: 'user', content: retryPrompt }
+    ]
+
+    const response = await client.chat.completions.create({
+      model: OPENAI_MODEL,
+      messages,
+      temperature: AI_TEMPERATURE,
+      max_tokens: MAX_TOKENS
+    })
+
+    const content = response.choices[0]?.message?.content || ''
+    if (!content) {
+      throw new Error('AI 返回空内容')
+    }
+
+    // 清洗代码
+    const code = extractCodeFromResponse(content)
+    const cleaned = cleanManimCode(code)
+
+    // 保存对话历史
+    context.messages.push(
+      { role: 'user', content: retryPrompt },
+      { role: 'assistant', content: code }
+    )
+
+    logger.info('代码重试生成成功', {
+      concept: context.concept,
+      attempt,
+      codeLength: cleaned.code.length
+    })
+
+    return cleaned.code
+  } catch (error) {
+    if (error instanceof OpenAI.APIError) {
+      logger.error('OpenAI API 错误（重试）', {
+        attempt,
+        status: error.status,
+        message: error.message
+      })
+    }
+    throw error
+  }
+}
+
+/**
+ * 构建重试提示词
+ */
+export function buildRetryFixPrompt(
+  concept: string,
+  errorMessage: string,
+  attempt: number | string
+): string {
+  return `## 目标层
+
+### 输入预期
+
+- **概念**：${concept}
+- **错误信息**（第 ${attempt} 次重试）：${errorMessage}
+
+### 产出要求
+
+- **修复代码**：根据错误信息修复之前的代码。
+- **完整代码**：必须输出完整的、可运行的 Manim 代码，不是修复片段！
+- **锚点协议**：代码必须包裹在 ### START ### 和 ### END ### 之间
+- **纯代码输出**：严禁包含任何解释性文字。
+- **结构规范**：核心类名固定为 \`AnimationScene\`
+`
+}
+
+function buildRetryPrompt(
+  context: CodeRetryContext,
+  errorMessage: string,
+  attempt: number
+): string {
+  const override = context.promptOverrides?.user?.codeRetryFix
+  if (override) {
+    return applyPromptTemplate(override, {
+      concept: context.concept,
+      errorMessage,
+      attempt: String(attempt)
+    })
+  }
+  return buildRetryFixPrompt(context.concept, errorMessage, attempt)
+}
+
+/**
+ * 重试管理器 - 核心函数
+ *
+ * 流程：
+ * 1. 首次生成代码 → 渲染
+ * 2. 如果失败，检查错误是否可修复
+ * 3. 重试（最多4次），每次都发送完整对话历史
+ * 4. 如果4次后仍失败，返回失败结果
+ */
+export async function executeCodeRetry(
+  context: CodeRetryContext,
+  renderer: (code: string) => Promise<RenderResult>,
+  customApiConfig?: any
+): Promise<RetryManagerResult> {
+  logger.info('开始代码重试管理', {
+    concept: context.concept,
+    maxRetries: MAX_RETRIES
+  })
+
+  // 步骤1：首次代码生成和渲染
+  let currentCode = await generateInitialCode(context, customApiConfig)
+  let renderResult = await renderer(currentCode)
+
+  if (renderResult.success) {
+    logger.info('首次渲染成功')
+    return { code: currentCode, success: true, attempts: 1 }
+  }
+
+  // 步骤2：提取错误信息并开始重试
+  let errorMessage = extractErrorMessage(renderResult.stderr)
+  let errorType = getErrorType(renderResult.stderr)
+  logger.warn('首次渲染失败', { errorType, error: errorMessage })
+  // 所有错误都尝试重试，AI 有能力修复语法、导入等问题
+
+  // 步骤3：重试循环
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    logger.info(`开始第 ${attempt} 次重试`, {
+      totalAttempts: attempt + 1,
+      errorType,
+      error: errorMessage
+    })
+
+    try {
+      currentCode = await retryCodeGeneration(context, errorMessage, attempt, customApiConfig)
+      renderResult = await renderer(currentCode)
+
+      if (renderResult.success) {
+        logger.info('重试渲染成功', { attempt: attempt + 1 })
+        return { code: currentCode, success: true, attempts: attempt + 1 }
+      }
+
+      // 更新错误信息
+      errorMessage = extractErrorMessage(renderResult.stderr)
+      errorType = getErrorType(renderResult.stderr)
+      logger.warn('重试渲染失败', { attempt: attempt + 1, errorType, error: errorMessage })
+    } catch (error) {
+      logger.error('重试过程出错', { attempt: attempt + 1, error: String(error) })
+    }
+  }
+
+  // 步骤4：所有重试失败
+  logger.error('所有重试均失败', {
+    totalAttempts: MAX_RETRIES + 1,
+    finalError: extractErrorMessage(renderResult.stderr)
+  })
+
+  return {
+    code: currentCode,
+    success: false,
+    attempts: MAX_RETRIES + 1,
+    lastError: extractErrorMessage(renderResult.stderr)
+  }
+}
+
+/**
+ * 导出类型
+ */
+export type {
+  CodeRetryOptions,
+  CodeRetryResult,
+  RenderResult,
+  RetryManagerResult,
+  ChatMessage,
+  CodeRetryContext
+} from './types'

src/services/code-retry/prompts.ts

@@ -3,10 +3,10 @@
  */
 
 import { API_INDEX } from '../../prompts/api-index'
+import { SYSTEM_PROMPT_BASE } from '../../prompts'
 
 // System prompt - 与代码生成者一致
-export const CODE_RETRY_SYSTEM_PROMPT = `你是一位 Manim 动画专家，专注于通过动态动画深度解读数学概念。
-严格按照提示词词规范输出，确保代码符合 Manim Community Edition (v0.19.2) 的最佳实践。`
+export const CODE_RETRY_SYSTEM_PROMPT = SYSTEM_PROMPT_BASE
 
 /**
  * 构建首次代码生成的用户提示词
@@ -88,4 +88,4 @@ ${API_INDEX}
 ${sceneDesign}
 \`\`\`
 
-请根据上述设计方案生成 Manim 代码。`}
+请根据上述设计方案生成 Manim 代码。`}

src/services/code-retry/types.ts

@@ -1,62 +1,62 @@
-/**
- * Code Retry Service - 类型定义
- */
-
-import type { CustomApiConfig } from '../../types'
-
-/**
- * 对话消息类型
- */
-export interface ChatMessage {
-  role: 'system' | 'user' | 'assistant'
-  content: string
-}
-
-/**
- * 代码重试上下文
- * 维护完整的对话历史
- */
-export interface CodeRetryContext {
-  concept: string
-  sceneDesign: string
-  originalPrompt: string // 原始写代码的提示词
-  messages: ChatMessage[] // 完整对话历史
-}
-
-/**
- * 代码重试选项
- */
-export interface CodeRetryOptions {
-  context: CodeRetryContext
-  customApiConfig?: CustomApiConfig
-}
-
-/**
- * 代码重试结果
- */
-export interface CodeRetryResult {
-  success: boolean
-  code: string
-  attempt: number
-  reason?: string
-}
-
-/**
- * 渲染结果
- */
-export interface RenderResult {
-  success: boolean
-  stderr: string
-  stdout: string
-  peakMemoryMB: number
-}
-
-/**
- * 重试管理器结果
- */
-export interface RetryManagerResult {
-  code: string
-  success: boolean
-  attempts: number
-  lastError?: string
-}
+/**
+ * Code Retry Service - 类型定义
+ */
+
+import type { CustomApiConfig, PromptOverrides } from '../../types'
+
+/**
+ * 对话消息类型
+ */
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant'
+  content: string
+}
+
+/**
+ * 代码重试上下文
+ * 维护完整的对话历史
+ */
+export interface CodeRetryContext {
+  concept: string
+  sceneDesign: string
+  originalPrompt: string // 原始写代码的提示词
+  messages: ChatMessage[] // 完整对话历史
+}
+
+/**
+ * 代码重试选项
+ */
+export interface CodeRetryOptions {
+  context: CodeRetryContext
+  customApiConfig?: CustomApiConfig
+}
+
+/**
+ * 代码重试结果
+ */
+export interface CodeRetryResult {
+  success: boolean
+  code: string
+  attempt: number
+  reason?: string
+}
+
+/**
+ * 渲染结果
+ */
+export interface RenderResult {
+  success: boolean
+  stderr: string
+  stdout: string
+  peakMemoryMB: number
+}
+
+/**
+ * 重试管理器结果
+ */
+export interface RetryManagerResult {
+  code: string
+  success: boolean
+  attempts: number
+  lastError?: string
+}

src/services/concept-designer.ts

@@ -1,314 +1,331 @@
-/**
- * 概念设计者服务 - 两阶段 AI 生成架构
- * 第一阶段：设计者/思考者 - 将抽象概念转化为详细的场景设计方案
- * 第二阶段：代码生成者 - 将设计方案转化为 Manim 代码
- */
-
-import OpenAI from 'openai'
-import crypto from 'crypto'
-import { createLogger } from '../utils/logger'
-import { SYSTEM_PROMPTS, generateConceptDesignerPrompt, generateCodeGenerationPrompt } from '../prompts'
-import type { CustomApiConfig } from '../types'
-
-const logger = createLogger('ConceptDesigner')
-
-const OPENAI_MODEL = process.env.OPENAI_MODEL || 'glm-4-flash'
-const DESIGNER_TEMPERATURE = parseFloat(process.env.DESIGNER_TEMPERATURE || '0.8')
-const CODER_TEMPERATURE = parseFloat(process.env.AI_TEMPERATURE || '0.7')
-const MAX_TOKENS = parseInt(process.env.AI_MAX_TOKENS || '1200', 10)
-const DESIGNER_MAX_TOKENS = parseInt(process.env.DESIGNER_MAX_TOKENS || '800', 10)
-const OPENAI_TIMEOUT = parseInt(process.env.OPENAI_TIMEOUT || '600000', 10)
-
-const CUSTOM_API_URL = process.env.CUSTOM_API_URL?.trim()
-
-let openaiClient: OpenAI | null = null
-
-try {
-  const baseConfig = {
-    timeout: OPENAI_TIMEOUT,
-    defaultHeaders: {
-      'User-Agent': 'ManimCat/1.0'
-    }
-  }
-
-  if (CUSTOM_API_URL) {
-    openaiClient = new OpenAI({
-      ...baseConfig,
-      baseURL: CUSTOM_API_URL,
-      apiKey: process.env.OPENAI_API_KEY
-    })
-  } else {
-    openaiClient = new OpenAI(baseConfig)
-  }
-} catch (error) {
-  logger.warn('OpenAI 客户端初始化失败', { error })
-}
-
-/**
- * 创建自定义 OpenAI 客户端
- */
-function createCustomClient(config: CustomApiConfig): OpenAI {
-  return new OpenAI({
-    baseURL: config.apiUrl.trim().replace(/\/+$/, ''),
-    apiKey: config.apiKey,
-    timeout: OPENAI_TIMEOUT,
-    defaultHeaders: {
-      'User-Agent': 'ManimCat/1.0'
-    }
-    })
-}
-
-/**
- * 基于概念和时间戳生成唯一种子
- */
-function generateUniqueSeed(concept: string): string {
-  const timestamp = Date.now()
-  const randomPart = crypto.randomBytes(4).toString('hex')
-  return crypto.createHash('md5').update(`${concept}-${timestamp}-${randomPart}`).digest('hex').slice(0, 8)
-}
-
-function extractDesignFromResponse(text: string): string {
-  if (!text) return ''
-  const sanitized = text.replace(/<think>[\s\S]*?<\/think>/gi, '')
-  const match = sanitized.match(/<design>([\s\S]*?)<\/design>/i)
-  if (match) {
-    return match[1].trim()
-  }
-  return sanitized.trim()
-}
-
-function extractCodeFromResponse(text: string): string {
-  if (!text) return ''
-  const sanitized = text.replace(/<think>[\s\S]*?<\/think>/gi, '')
-  const anchorMatch = sanitized.match(/### START ###([\s\S]*?)### END ###/)
-  if (anchorMatch) {
-    return anchorMatch[1].trim()
-  }
-  const codeMatch = sanitized.match(/```(?:python)?([\s\S]*?)```/i)
-  if (codeMatch) {
-    return codeMatch[1].trim()
-  }
-  return sanitized.trim()
-}
-
-/**
- * 清洗设计方案文本
- */
-interface CleanDesignResult {
-  text: string
-  changes: string[]
-}
-
-function cleanDesignText(text: string): CleanDesignResult {
-  const changes: string[] = []
-  let cleaned = text
-
-  // 移除多余的空白行
-  const beforeLength = cleaned.length
-  cleaned = cleaned.replace(/\n{3,}/g, '\n\n')
-  if (cleaned.length !== beforeLength) {
-    changes.push('remove-extra-newlines')
-  }
-
-  // 移除首尾空白
-  cleaned = cleaned.trim()
-
-  return { text: cleaned, changes }
-}
-
-/**
- * 阶段1：设计者/思考者
- * 接收用户的抽象概念，输出详细的场景设计方案
- */
-async function generateSceneDesign(
-  concept: string,
-  customApiConfig?: CustomApiConfig
-): Promise<string> {
-  const client = customApiConfig ? createCustomClient(customApiConfig) : openaiClient
-
-  if (!client) {
-    logger.warn('OpenAI 客户端不可用')
-    return ''
-  }
-
-  try {
-    const seed = generateUniqueSeed(concept)
-
-    const systemPrompt = SYSTEM_PROMPTS.conceptDesigner
-    const userPrompt = generateConceptDesignerPrompt(concept, seed)
-
-    logger.info('开始阶段1：生成场景设计方案', { concept, seed })
-
-    const response = await client.chat.completions.create({
-      model: OPENAI_MODEL,
-      messages: [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt }
-      ],
-      temperature: DESIGNER_TEMPERATURE,
-      max_tokens: DESIGNER_MAX_TOKENS
-    })
-
-    const content = response.choices[0]?.message?.content || ''
-    if (!content) {
-      logger.warn('设计者返回空内容')
-      return ''
-    }
-
-    const extractedDesign = extractDesignFromResponse(content)
-    const cleanedDesign = cleanDesignText(extractedDesign)
-    if (cleanedDesign.changes.length > 0) {
-      logger.info('设计方案已清洗', {
-        concept,
-        seed,
-        changes: cleanedDesign.changes,
-        originalLength: content.length,
-        cleanedLength: cleanedDesign.text.length
-      })
-    }
-
-    if (!cleanedDesign.text) {
-      logger.warn('设计者返回空方案')
-      return ''
-    }
-
-    logger.info('阶段1：场景设计方案生成成功', {
-      concept,
-      seed,
-      designLength: cleanedDesign.text.length,
-      design: cleanedDesign.text
-    })
-
-    return cleanedDesign.text
-  } catch (error) {
-    if (error instanceof OpenAI.APIError) {
-      logger.error('设计者 API 错误', {
-        concept,
-        status: error.status,
-        code: error.code,
-        type: error.type,
-        message: error.message
-      })
-    } else if (error instanceof Error) {
-      logger.error('设计者生成失败', {
-        concept,
-        errorName: error.name,
-        errorMessage: error.message
-      })
-    } else {
-      logger.error('设计者生成失败（未知错误）', { concept, error: String(error) })
-    }
-    return ''
-  }
-}
-
-/**
- * 阶段2：代码生成者
- * 接收场景设计方案，输出 Manim 代码
- */
-async function generateCodeFromDesign(
-  concept: string,
-  sceneDesign: string,
-  customApiConfig?: CustomApiConfig
-): Promise<string> {
-  const client = customApiConfig ? createCustomClient(customApiConfig) : openaiClient
-
-  if (!client) {
-    logger.warn('OpenAI 客户端不可用')
-    return ''
-  }
-
-  try {
-    const seed = generateUniqueSeed(`${concept}-${sceneDesign.slice(0, 20)}`)
-
-    const systemPrompt = SYSTEM_PROMPTS.codeGeneration
-    const userPrompt = generateCodeGenerationPrompt(concept, seed, sceneDesign)
-
-    logger.info('开始阶段2：根据设计方案生成代码', { concept, seed })
-
-    const response = await client.chat.completions.create({
-      model: OPENAI_MODEL,
-      messages: [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userPrompt }
-      ],
-      temperature: CODER_TEMPERATURE,
-      max_tokens: MAX_TOKENS
-    })
-
-    const content = response.choices[0]?.message?.content || ''
-    if (!content) {
-      logger.warn('代码生成者返回空内容')
-      return ''
-    }
-
-    logger.info('阶段2：代码生成成功', {
-      concept,
-      seed,
-      codeLength: content.length,
-      code: content
-    })
-
-    return content
-  } catch (error) {
-    // ✅ 正确：将完整的判断表达式放在括号内
-    if (error instanceof OpenAI.APIError) {
-      logger.error('代码生成者 API 错误', {
-        concept,
-        status: error.status,
-        code: error.code,
-        type: error.type,
-        message: error.message
-      })
-    } else if (error instanceof Error) {
-      logger.error('代码生成者失败', {
-        concept,
-        errorName: error.name,
-        errorMessage: error.message
-      })
-    } else {
-      logger.error('代码生成者失败（未知错误）', { concept, error: String(error) })
-    }
-    return ''
-  }
-
-}
-
-/**
- * 两阶段 AI 生成
- * 1. 设计者生成场景设计方案
- * 2. 代码生成者根据设计方案生成代码
- */
-export async function generateTwoStageAIManimCode(
-  concept: string,
-  customApiConfig?: CustomApiConfig
-): Promise<{ code: string; sceneDesign: string }> 
- {
-  logger.info('开始两阶段 AI 生成流程', { concept })
-
-  // 阶段1：生成场景设计方案
-  const sceneDesign = await generateSceneDesign(concept, customApiConfig)
-
-  if (!sceneDesign) {
-    logger.warn('场景设计方案生成失败，中止流程')
-    return { code: '', sceneDesign: '' }
-  }
-
-  // 阶段2：根据设计方案生成代码
-  const code = await generateCodeFromDesign(concept, sceneDesign, customApiConfig)
-
-  logger.info('两阶段 AI 生成流程完成', {
-    concept,
-    hasSceneDesign: !!sceneDesign,
-    hasCode: !!code
-  })
-
-  return { code, sceneDesign }
-}
-
-/**
- * 检查 OpenAI 客户端是否可用
- */
-export function isOpenAIAvailable(): boolean {
-  return openaiClient !== null
-}
+/**
+ * 概念设计者服务 - 两阶段 AI 生成架构
+ * 第一阶段：设计者/思考者 - 将抽象概念转化为详细的场景设计方案
+ * 第二阶段：代码生成者 - 将设计方案转化为 Manim 代码
+ */
+
+import OpenAI from 'openai'
+import crypto from 'crypto'
+import { createLogger } from '../utils/logger'
+import { SYSTEM_PROMPTS, generateConceptDesignerPrompt, generateCodeGenerationPrompt } from '../prompts'
+import type { CustomApiConfig, PromptOverrides } from '../types'
+
+const logger = createLogger('ConceptDesigner')
+
+const OPENAI_MODEL = process.env.OPENAI_MODEL || 'glm-4-flash'
+const DESIGNER_TEMPERATURE = parseFloat(process.env.DESIGNER_TEMPERATURE || '0.8')
+const CODER_TEMPERATURE = parseFloat(process.env.AI_TEMPERATURE || '0.7')
+const MAX_TOKENS = parseInt(process.env.AI_MAX_TOKENS || '1200', 10)
+const DESIGNER_MAX_TOKENS = parseInt(process.env.DESIGNER_MAX_TOKENS || '800', 10)
+const OPENAI_TIMEOUT = parseInt(process.env.OPENAI_TIMEOUT || '600000', 10)
+
+const CUSTOM_API_URL = process.env.CUSTOM_API_URL?.trim()
+
+let openaiClient: OpenAI | null = null
+
+try {
+  const baseConfig = {
+    timeout: OPENAI_TIMEOUT,
+    defaultHeaders: {
+      'User-Agent': 'ManimCat/1.0'
+    }
+  }
+
+  if (CUSTOM_API_URL) {
+    openaiClient = new OpenAI({
+      ...baseConfig,
+      baseURL: CUSTOM_API_URL,
+      apiKey: process.env.OPENAI_API_KEY
+    })
+  } else {
+    openaiClient = new OpenAI(baseConfig)
+  }
+} catch (error) {
+  logger.warn('OpenAI 客户端初始化失败', { error })
+}
+
+/**
+ * 创建自定义 OpenAI 客户端
+ */
+function createCustomClient(config: CustomApiConfig): OpenAI {
+  return new OpenAI({
+    baseURL: config.apiUrl.trim().replace(/\/+$/, ''),
+    apiKey: config.apiKey,
+    timeout: OPENAI_TIMEOUT,
+    defaultHeaders: {
+      'User-Agent': 'ManimCat/1.0'
+    }
+    })
+}
+
+/**
+ * 基于概念和时间戳生成唯一种子
+ */
+function generateUniqueSeed(concept: string): string {
+  const timestamp = Date.now()
+  const randomPart = crypto.randomBytes(4).toString('hex')
+  return crypto.createHash('md5').update(`${concept}-${timestamp}-${randomPart}`).digest('hex').slice(0, 8)
+}
+
+function applyPromptTemplate(template: string, values: Record<string, string>): string {
+  let output = template
+  for (const [key, value] of Object.entries(values)) {
+    output = output.replace(new RegExp(`{{\s*${key}\s*}}`, 'g'), value)
+  }
+  return output
+}
+
+function extractDesignFromResponse(text: string): string {
+  if (!text) return ''
+  const sanitized = text.replace(/<think>[\s\S]*?<\/think>/gi, '')
+  const match = sanitized.match(/<design>([\s\S]*?)<\/design>/i)
+  if (match) {
+    return match[1].trim()
+  }
+  return sanitized.trim()
+}
+
+function extractCodeFromResponse(text: string): string {
+  if (!text) return ''
+  const sanitized = text.replace(/<think>[\s\S]*?<\/think>/gi, '')
+  const anchorMatch = sanitized.match(/### START ###([\s\S]*?)### END ###/)
+  if (anchorMatch) {
+    return anchorMatch[1].trim()
+  }
+  const codeMatch = sanitized.match(/```(?:python)?([\s\S]*?)```/i)
+  if (codeMatch) {
+    return codeMatch[1].trim()
+  }
+  return sanitized.trim()
+}
+
+/**
+ * 清洗设计方案文本
+ */
+interface CleanDesignResult {
+  text: string
+  changes: string[]
+}
+
+function cleanDesignText(text: string): CleanDesignResult {
+  const changes: string[] = []
+  let cleaned = text
+
+  // 移除多余的空白行
+  const beforeLength = cleaned.length
+  cleaned = cleaned.replace(/\n{3,}/g, '\n\n')
+  if (cleaned.length !== beforeLength) {
+    changes.push('remove-extra-newlines')
+  }
+
+  // 移除首尾空白
+  cleaned = cleaned.trim()
+
+  return { text: cleaned, changes }
+}
+
+/**
+ * 阶段1：设计者/思考者
+ * 接收用户的抽象概念，输出详细的场景设计方案
+ */
+async function generateSceneDesign(
+  concept: string,
+  customApiConfig?: CustomApiConfig,
+  promptOverrides?: PromptOverrides
+): Promise<string> {
+  const client = customApiConfig ? createCustomClient(customApiConfig) : openaiClient
+
+  if (!client) {
+    logger.warn('OpenAI 客户端不可用')
+    return ''
+  }
+
+  try {
+    const seed = generateUniqueSeed(concept)
+
+    const systemPrompt = promptOverrides?.system?.conceptDesigner || SYSTEM_PROMPTS.conceptDesigner
+    const userPromptOverride = promptOverrides?.user?.conceptDesigner
+    const userPrompt = userPromptOverride
+      ? applyPromptTemplate(userPromptOverride, { concept, seed })
+      : generateConceptDesignerPrompt(concept, seed)
+
+    logger.info('开始阶段1：生成场景设计方案', { concept, seed })
+
+    const response = await client.chat.completions.create({
+      model: OPENAI_MODEL,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt }
+      ],
+      temperature: DESIGNER_TEMPERATURE,
+      max_tokens: DESIGNER_MAX_TOKENS
+    })
+
+    const content = response.choices[0]?.message?.content || ''
+    if (!content) {
+      logger.warn('设计者返回空内容')
+      return ''
+    }
+
+    const extractedDesign = extractDesignFromResponse(content)
+    const cleanedDesign = cleanDesignText(extractedDesign)
+    if (cleanedDesign.changes.length > 0) {
+      logger.info('设计方案已清洗', {
+        concept,
+        seed,
+        changes: cleanedDesign.changes,
+        originalLength: content.length,
+        cleanedLength: cleanedDesign.text.length
+      })
+    }
+
+    if (!cleanedDesign.text) {
+      logger.warn('设计者返回空方案')
+      return ''
+    }
+
+    logger.info('阶段1：场景设计方案生成成功', {
+      concept,
+      seed,
+      designLength: cleanedDesign.text.length,
+      design: cleanedDesign.text
+    })
+
+    return cleanedDesign.text
+  } catch (error) {
+    if (error instanceof OpenAI.APIError) {
+      logger.error('设计者 API 错误', {
+        concept,
+        status: error.status,
+        code: error.code,
+        type: error.type,
+        message: error.message
+      })
+    } else if (error instanceof Error) {
+      logger.error('设计者生成失败', {
+        concept,
+        errorName: error.name,
+        errorMessage: error.message
+      })
+    } else {
+      logger.error('设计者生成失败（未知错误）', { concept, error: String(error) })
+    }
+    return ''
+  }
+}
+
+/**
+ * 阶段2：代码生成者
+ * 接收场景设计方案，输出 Manim 代码
+ */
+async function generateCodeFromDesign(
+  concept: string,
+  sceneDesign: string,
+  customApiConfig?: CustomApiConfig,
+  promptOverrides?: PromptOverrides
+): Promise<string> {
+  const client = customApiConfig ? createCustomClient(customApiConfig) : openaiClient
+
+  if (!client) {
+    logger.warn('OpenAI 客户端不可用')
+    return ''
+  }
+
+  try {
+    const seed = generateUniqueSeed(`${concept}-${sceneDesign.slice(0, 20)}`)
+
+    const systemPrompt = promptOverrides?.system?.codeGeneration || SYSTEM_PROMPTS.codeGeneration
+    const userPromptOverride = promptOverrides?.user?.codeGeneration
+    const userPrompt = userPromptOverride
+      ? applyPromptTemplate(userPromptOverride, { concept, seed, sceneDesign })
+      : generateCodeGenerationPrompt(concept, seed, sceneDesign)
+
+    logger.info('开始阶段2：根据设计方案生成代码', { concept, seed })
+
+    const response = await client.chat.completions.create({
+      model: OPENAI_MODEL,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userPrompt }
+      ],
+      temperature: CODER_TEMPERATURE,
+      max_tokens: MAX_TOKENS
+    })
+
+    const content = response.choices[0]?.message?.content || ''
+    if (!content) {
+      logger.warn('代码生成者返回空内容')
+      return ''
+    }
+
+    logger.info('阶段2：代码生成成功', {
+      concept,
+      seed,
+      codeLength: content.length,
+      code: content
+    })
+
+    return content
+  } catch (error) {
+    // ✅ 正确：将完整的判断表达式放在括号内
+    if (error instanceof OpenAI.APIError) {
+      logger.error('代码生成者 API 错误', {
+        concept,
+        status: error.status,
+        code: error.code,
+        type: error.type,
+        message: error.message
+      })
+    } else if (error instanceof Error) {
+      logger.error('代码生成者失败', {
+        concept,
+        errorName: error.name,
+        errorMessage: error.message
+      })
+    } else {
+      logger.error('代码生成者失败（未知错误）', { concept, error: String(error) })
+    }
+    return ''
+  }
+
+}
+
+/**
+ * 两阶段 AI 生成
+ * 1. 设计者生成场景设计方案
+ * 2. 代码生成者根据设计方案生成代码
+ */
+export async function generateTwoStageAIManimCode(
+  concept: string,
+  customApiConfig?: CustomApiConfig,
+  promptOverrides?: PromptOverrides
+): Promise<{ code: string; sceneDesign: string }> 
+ {
+  logger.info('开始两阶段 AI 生成流程', { concept })
+
+  // 阶段1：生成场景设计方案
+  const sceneDesign = await generateSceneDesign(concept, customApiConfig, promptOverrides)
+
+  if (!sceneDesign) {
+    logger.warn('场景设计方案生成失败，中止流程')
+    return { code: '', sceneDesign: '' }
+  }
+
+  // 阶段2：根据设计方案生成代码
+  const code = await generateCodeFromDesign(concept, sceneDesign, customApiConfig, promptOverrides)
+
+  logger.info('两阶段 AI 生成流程完成', {
+    concept,
+    hasSceneDesign: !!sceneDesign,
+    hasCode: !!code
+  })
+
+  return { code, sceneDesign }
+}
+
+/**
+ * 检查 OpenAI 客户端是否可用
+ */
+export function isOpenAIAvailable(): boolean {
+  return openaiClient !== null
+}

src/services/job-cancel-store.ts

@@ -0,0 +1,47 @@
+/**
+ * Job Cancel Store
+ * 取消状态存取
+ */
+
+import { redisClient, REDIS_KEYS, generateRedisKey } from '../config/redis'
+
+const JOB_CANCEL_KEY_PREFIX = `${REDIS_KEYS.JOB_CANCEL}`
+const CANCEL_TTL_SECONDS = 7 * 24 * 60 * 60
+
+export async function markJobCancelled(jobId: string, reason: string = 'Job cancelled'): Promise<void> {
+  const key = generateRedisKey(JOB_CANCEL_KEY_PREFIX, jobId)
+  const payload = {
+    jobId,
+    reason,
+    timestamp: Date.now()
+  }
+
+  await redisClient.set(key, JSON.stringify(payload))
+  await redisClient.expire(key, CANCEL_TTL_SECONDS)
+}
+
+export async function isJobCancelled(jobId: string): Promise<boolean> {
+  const key = generateRedisKey(JOB_CANCEL_KEY_PREFIX, jobId)
+  return (await redisClient.get(key)) !== null
+}
+
+export async function clearJobCancelled(jobId: string): Promise<void> {
+  const key = generateRedisKey(JOB_CANCEL_KEY_PREFIX, jobId)
+  await redisClient.del(key)
+}
+
+export async function getCancelReason(jobId: string): Promise<string | null> {
+  const key = generateRedisKey(JOB_CANCEL_KEY_PREFIX, jobId)
+  const data = await redisClient.get(key)
+
+  if (!data) {
+    return null
+  }
+
+  try {
+    const parsed = JSON.parse(data) as { reason?: string }
+    return parsed.reason || null
+  } catch {
+    return null
+  }
+}

src/services/job-cancel.ts

@@ -0,0 +1,68 @@
+/**
+ * Job Cancel Service
+ * 任务取消逻辑
+ */
+
+import { videoQueue } from '../config/bull'
+import { createLogger } from '../utils/logger'
+import { JobCancelledError } from '../utils/errors'
+import { clearJobCancelled, getCancelReason, isJobCancelled, markJobCancelled } from './job-cancel-store'
+import { cancelManimProcess } from '../utils/manim-process-registry'
+import { deleteJobStage, getJobResult, storeJobResult } from './job-store'
+
+const logger = createLogger('JobCancel')
+export async function ensureJobNotCancelled(jobId: string, job?: { discard: () => void }): Promise<void> {
+  if (!(await isJobCancelled(jobId))) {
+    return
+  }
+
+  try {
+    job?.discard()
+  } catch (error) {
+    logger.warn('Failed to discard cancelled job', { jobId, error })
+  }
+
+  const reason = await getCancelReason(jobId)
+  throw new JobCancelledError('Job cancelled', reason || undefined)
+}
+
+export async function cancelJob(jobId: string): Promise<{ jobState: string | null }> {
+  const existing = await getJobResult(jobId)
+  if (existing?.status === 'completed') {
+    return { jobState: 'completed' }
+  }
+
+  const cancelReason = 'Cancelled by client'
+  await markJobCancelled(jobId, cancelReason)
+
+  let jobState: string | null = null
+  const job = await videoQueue.getJob(jobId)
+
+  if (job) {
+    jobState = await job.getState()
+
+    if (jobState === 'waiting' || jobState === 'delayed') {
+      await job.remove()
+      await clearJobCancelled(jobId)
+      logger.info('Removed pending job', { jobId, jobState })
+    }
+
+    if (jobState === 'active') {
+      const killed = cancelManimProcess(jobId)
+      logger.info('Signaled active job cancellation', { jobId, killed })
+    }
+  } else {
+    await clearJobCancelled(jobId)
+  }
+
+  if (!existing || existing.status != 'failed') {
+    await storeJobResult(jobId, {
+      status: 'failed',
+      data: { error: 'Job cancelled', cancelReason }
+    })
+  }
+
+  await deleteJobStage(jobId)
+
+  return { jobState }
+}

src/services/job-store.ts

@@ -1,188 +1,188 @@
-/**
- * 任务存储服务
- * 改造点：
- * - 移除 InternalStateManager 依赖
- * - 使用 ioredis 直接操作 Redis
- * - 接口保持兼容，方便业务代码无感知迁移
- * - 支持 stage 存储，用于前端显示精确的处理阶段
- */
-
-import { redisClient, REDIS_KEYS, generateRedisKey } from '../config/redis'
-import { videoQueue } from '../config/bull'
-import { createLogger } from '../utils/logger'
-import type { JobResult, ProcessingStage } from '../types'
-
-const logger = createLogger('JobStore')
-
-const JOB_RESULTS_GROUP = 'job-results'
-const JOB_RESULT_KEY_PREFIX = `${REDIS_KEYS.JOB_RESULT}`
-const JOB_STAGE_KEY_PREFIX = `${REDIS_KEYS.JOB_RESULT}:stage`
-
-/**
- * 使用 Redis 存储任务结果
- */
-export async function storeJobResult(
-  jobId: string,
-  result: Omit<JobResult, 'timestamp'>
-): Promise<void> {
-  const key = generateRedisKey(JOB_RESULT_KEY_PREFIX, jobId)
-  const data = {
-    ...result,
-    timestamp: Date.now()
-  }
-
-  try {
-    await redisClient.set(key, JSON.stringify(data))
-    // 设置过期时间：7 天后自动清理
-    await redisClient.expire(key, 7 * 24 * 60 * 60)
-    logger.info('任务结果已存储', { jobId, status: result.status })
-  } catch (error) {
-    logger.error('存储任务结果失败', { jobId, error })
-    throw error
-  }
-}
-
-/**
- * 从 Redis 获取任务结果
- */
-export async function getJobResult(
-  jobId: string
-): Promise<JobResult | null> {
-  const key = generateRedisKey(JOB_RESULT_KEY_PREFIX, jobId)
-
-  try {
-    const data = await redisClient.get(key)
-    if (!data) {
-      return null
-    }
-    return JSON.parse(data) as JobResult
-  } catch (error) {
-    logger.error('获取任务结果失败', { jobId, error })
-    return null
-  }
-}
-
-/**
- * 获取 Bull 任务状态
- * 返回任务在队列中的状态
- */
-export async function getBullJobStatus(
-  jobId: string
-): Promise<'waiting' | 'active' | 'completed' | 'failed' | 'delayed' | null> {
-  try {
-    const job = await videoQueue.getJob(jobId)
-    if (!job) {
-      return null
-    }
-    const state = await job.getState()
-    // Bull 可能返回 'paused' 等状态，过滤掉
-    if (state === 'paused') {
-      return 'waiting'
-    }
-    // 只返回我们关心的状态
-    if (state === 'waiting' || state === 'active' || state === 'completed' || state === 'failed' || state === 'delayed') {
-      return state
-    }
-    return null
-  } catch (error) {
-    logger.error('获取 Bull 任务状态失败', { jobId, error })
-    return null
-  }
-}
-
-/**
- * 从 Redis 删除任务结果
- */
-export async function deleteJobResult(
-  jobId: string
-): Promise<void> {
-  const key = generateRedisKey(JOB_RESULT_KEY_PREFIX, jobId)
-
-  try {
-    await redisClient.del(key)
-    logger.info('任务结果已删除', { jobId })
-  } catch (error) {
-    logger.error('删除任务结果失败', { jobId, error })
-    throw error
-  }
-}
-
-/**
- * 获取所有任务结果（用于调试/管理）
- */
-export async function getAllJobResults(): Promise<Array<{ jobId: string; result: JobResult }>> {
-  try {
-    const keys = await redisClient.keys(`${JOB_RESULT_KEY_PREFIX}*`)
-    const results: Array<{ jobId: string; result: JobResult }> = []
-
-    for (const key of keys) {
-      const data = await redisClient.get(key)
-      if (data) {
-        const jobId = key.substring(JOB_RESULT_KEY_PREFIX.length)
-        results.push({ jobId, result: JSON.parse(data) as JobResult })
-      }
-    }
-
-    return results
-  } catch (error) {
-    logger.error('获取所有任务结果失败', { error })
-    return []
-  }
-}
-
-/**
- * 存储任务处理阶段
- */
-export async function storeJobStage(
-  jobId: string,
-  stage: ProcessingStage
-): Promise<void> {
-  const key = generateRedisKey(JOB_STAGE_KEY_PREFIX, jobId)
-
-  try {
-    await redisClient.set(key, stage)
-    // 设置过期时间：与 job result 相同，7 天后自动清理
-    await redisClient.expire(key, 7 * 24 * 60 * 60)
-    logger.debug('任务阶段已存储', { jobId, stage })
-  } catch (error) {
-    logger.error('存储任务阶段失败', { jobId, error })
-    throw error
-  }
-}
-
-/**
- * 获取任务处理阶段
- */
-export async function getJobStage(
-  jobId: string
-): Promise<ProcessingStage | null> {
-  const key = generateRedisKey(JOB_STAGE_KEY_PREFIX, jobId)
-
-  try {
-    const stage = await redisClient.get(key)
-    if (!stage) {
-      return null
-    }
-    return stage as ProcessingStage
-  } catch (error) {
-    logger.error('获取任务阶段失败', { jobId, error })
-    return null
-  }
-}
-
-/**
- * 删除任务阶段
- */
-export async function deleteJobStage(
-  jobId: string
-): Promise<void> {
-  const key = generateRedisKey(JOB_STAGE_KEY_PREFIX, jobId)
-
-  try {
-    await redisClient.del(key)
-    logger.debug('任务阶段已删除', { jobId })
-  } catch (error) {
-    logger.error('删除任务阶段失败', { jobId, error })
-    throw error
-  }
+/**
+ * 任务存储服务
+ * 改造点：
+ * - ���除 InternalStateManager 依赖
+ * - 使用 ioredis 直接操作 Redis
+ * - 接口保持兼容，方便业务代码无感知迁移
+ * - 支持 stage 存储，用于前端显示精确的处理阶段
+ */
+
+import { redisClient, REDIS_KEYS, generateRedisKey } from '../config/redis'
+import { videoQueue } from '../config/bull'
+import { createLogger } from '../utils/logger'
+import type { JobResult, ProcessingStage } from '../types'
+
+const logger = createLogger('JobStore')
+
+const JOB_RESULTS_GROUP = 'job-results'
+const JOB_RESULT_KEY_PREFIX = `${REDIS_KEYS.JOB_RESULT}`
+const JOB_STAGE_KEY_PREFIX = `${REDIS_KEYS.JOB_RESULT}:stage`
+
+/**
+ * 使用 Redis 存储任务结果
+ */
+export async function storeJobResult(
+  jobId: string,
+  result: Omit<JobResult, 'timestamp'>
+): Promise<void> {
+  const key = generateRedisKey(JOB_RESULT_KEY_PREFIX, jobId)
+  const data = {
+    ...result,
+    timestamp: Date.now()
+  }
+
+  try {
+    await redisClient.set(key, JSON.stringify(data))
+    // 设置过期时间：7 天后自动清理
+    await redisClient.expire(key, 7 * 24 * 60 * 60)
+    logger.info('任务结果已存储', { jobId, status: result.status })
+  } catch (error) {
+    logger.error('存储任务结果失败', { jobId, error })
+    throw error
+  }
+}
+
+/**
+ * 从 Redis 获取任务结果
+ */
+export async function getJobResult(
+  jobId: string
+): Promise<JobResult | null> {
+  const key = generateRedisKey(JOB_RESULT_KEY_PREFIX, jobId)
+
+  try {
+    const data = await redisClient.get(key)
+    if (!data) {
+      return null
+    }
+    return JSON.parse(data) as JobResult
+  } catch (error) {
+    logger.error('获取任务结果失败', { jobId, error })
+    return null
+  }
+}
+
+/**
+ * 获取 Bull 任务状态
+ * 返回任务在队列中的状态
+ */
+export async function getBullJobStatus(
+  jobId: string
+): Promise<'waiting' | 'active' | 'completed' | 'failed' | 'delayed' | null> {
+  try {
+    const job = await videoQueue.getJob(jobId)
+    if (!job) {
+      return null
+    }
+    const state = await job.getState()
+    // Bull 可能返回 'paused' 等状态，过滤掉
+    if (state === 'paused') {
+      return 'waiting'
+    }
+    // 只返回我们关心的状态
+    if (state === 'waiting' || state === 'active' || state === 'completed' || state === 'failed' || state === 'delayed') {
+      return state
+    }
+    return null
+  } catch (error) {
+    logger.error('获取 Bull 任务状态失败', { jobId, error })
+    return null
+  }
+}
+
+/**
+ * 从 Redis 删除任务结果
+ */
+export async function deleteJobResult(
+  jobId: string
+): Promise<void> {
+  const key = generateRedisKey(JOB_RESULT_KEY_PREFIX, jobId)
+
+  try {
+    await redisClient.del(key)
+    logger.info('任务结果已删除', { jobId })
+  } catch (error) {
+    logger.error('删除任务结果失败', { jobId, error })
+    throw error
+  }
+}
+
+/**
+ * 获取所有任务结果（用于调试/管理）
+ */
+export async function getAllJobResults(): Promise<Array<{ jobId: string; result: JobResult }>> {
+  try {
+    const keys = await redisClient.keys(`${JOB_RESULT_KEY_PREFIX}*`)
+    const results: Array<{ jobId: string; result: JobResult }> = []
+
+    for (const key of keys) {
+      const data = await redisClient.get(key)
+      if (data) {
+        const jobId = key.substring(JOB_RESULT_KEY_PREFIX.length)
+        results.push({ jobId, result: JSON.parse(data) as JobResult })
+      }
+    }
+
+    return results
+  } catch (error) {
+    logger.error('获取所有任务结果失败', { error })
+    return []
+  }
+}
+
+/**
+ * 存储任务处理阶段
+ */
+export async function storeJobStage(
+  jobId: string,
+  stage: ProcessingStage
+): Promise<void> {
+  const key = generateRedisKey(JOB_STAGE_KEY_PREFIX, jobId)
+
+  try {
+    await redisClient.set(key, stage)
+    // 设置过期时间：与 job result 相同，7 天后自动清理
+    await redisClient.expire(key, 7 * 24 * 60 * 60)
+    logger.debug('任务阶段已存储', { jobId, stage })
+  } catch (error) {
+    logger.error('存储任务阶段失败', { jobId, error })
+    throw error
+  }
+}
+
+/**
+ * 获取任务处理阶段
+ */
+export async function getJobStage(
+  jobId: string
+): Promise<ProcessingStage | null> {
+  const key = generateRedisKey(JOB_STAGE_KEY_PREFIX, jobId)
+
+  try {
+    const stage = await redisClient.get(key)
+    if (!stage) {
+      return null
+    }
+    return stage as ProcessingStage
+  } catch (error) {
+    logger.error('获取任务阶段失败', { jobId, error })
+    return null
+  }
+}
+
+/**
+ * 删除任务阶段
+ */
+export async function deleteJobStage(
+  jobId: string
+): Promise<void> {
+  const key = generateRedisKey(JOB_STAGE_KEY_PREFIX, jobId)
+
+  try {
+    await redisClient.del(key)
+    logger.debug('任务阶段已删除', { jobId })
+  } catch (error) {
+    logger.error('删除任务���段失败', { jobId, error })
+    throw error
+  }
 }

src/types/index.ts

@@ -42,6 +42,23 @@ export interface CustomApiConfig {
   model: string
 }
 
+/**
+ * Prompt overrides for generation stages
+ */
+export interface PromptOverrides {
+  system?: {
+    conceptDesigner?: string
+    codeGeneration?: string
+    codeRetry?: string
+  }
+  user?: {
+    conceptDesigner?: string
+    codeGeneration?: string
+    codeRetryInitial?: string
+    codeRetryFix?: string
+  }
+}
+
 /**
  * 视频生成任务数据
  */
@@ -83,6 +100,7 @@ export interface FailedJobResult {
   data: {
     error: string
     details?: string
+    cancelReason?: string
   }
   timestamp: number
 }
@@ -114,6 +132,7 @@ export interface GenerateRequest {
   concept: string
   quality?: VideoQuality
   forceRefresh?: boolean
+  promptOverrides?: PromptOverrides
 }
 
 /**
@@ -162,6 +181,7 @@ export interface JobStatusFailedResponse {
   success: false
   error: string
   details?: string
+  cancel_reason?: string
 }
 
 /**

src/utils/errors.ts

@@ -121,6 +121,16 @@ export class TimeoutError extends AppError {
   }
 }
 
+/**
+ * 任务取消错误 499
+ */
+export class JobCancelledError extends AppError {
+  constructor(message: string = 'Job cancelled', details?: any) {
+    super(message, 499, true, details)
+    this.name = 'JobCancelledError'
+  }
+}
+
 /**
  * 判断是否为应用错误
  */

src/utils/manim-executor.ts

@@ -1,223 +1,535 @@
-/**
- * Manim 执行器
- * 执行 Manim 命令，管理子进程
- */
-
-import { spawn } from 'child_process'
-import { createLogger } from './logger'
-
-const logger = createLogger('ManimExecutor')
-
-/**
- * Manim 执行结果
- */
-export interface ManimExecutionResult {
-  success: boolean
-  stdout: string
-  stderr: string
-  peakMemoryMB: number
-}
-
-/**
- * Manim 执行选项
- */
-export interface ManimExecuteOptions {
-  jobId: string
-  quality: string
-  frameRate: number
-  tempDir: string
-  mediaDir: string
-}
-
-/**
- * 获取进程的内存使用情况（MB）
- */
-export async function getProcessMemory(pid: number): Promise<number | null> {
-  return new Promise((resolve) => {
-    const platform = process.platform
-
-    if (platform === 'win32') {
-      // Windows: 使用 wmic 获取进程内存
-      spawn('wmic', ['process', 'where', `ProcessId=${pid}`, 'get', 'WorkingSetSize', '/value'])
-        .stdout.on('data', (data) => {
-          const output = data.toString()
-          const match = output.match(/WorkingSetSize=(\d+)/)
-          if (match) {
-            // 转换为 MB
-            const bytes = parseInt(match[1], 10)
-            resolve(Math.round(bytes / 1024 / 1024))
-          } else {
-            resolve(null)
-          }
-        })
-        .on('error', () => resolve(null))
-        .on('close', () => resolve(null))
-    } else {
-      // Linux/Mac: 使用 ps 获取进程内存
-      spawn('ps', ['-o', 'rss=', '-p', pid.toString()])
-        .stdout.on('data', (data) => {
-          const output = data.toString().trim()
-          if (output) {
-            // ps 返回的是 KB，转换为 MB
-            const kb = parseInt(output, 10)
-            resolve(Math.round(kb / 1024))
-          } else {
-            resolve(null)
-          }
-        })
-        .on('error', () => resolve(null))
-        .on('close', () => resolve(null))
-    }
-  })
-}
-
-/**
- * 执行 manim 命令
- */
-export function executeManimCommand(
-  codeFile: string,
-  options: ManimExecuteOptions
-): Promise<ManimExecutionResult> {
-  const { jobId, quality, frameRate, tempDir, mediaDir } = options
-
-  return new Promise((resolve) => {
-    const startTime = Date.now()
-
-    // 质量对应的分辨率
-    const resolutionMap: Record<string, { width: number; height: number }> = {
-      low: { width: 854, height: 480 },
-      medium: { width: 1280, height: 720 },
-      high: { width: 1920, height: 1080 }
-    }
-
-    const resolution = resolutionMap[quality] || resolutionMap.medium
-
-    const args = [
-      'render',
-      '--format', 'mp4',
-      '-r', frameRate.toString(),
-      '--resolution', `${resolution.width},${resolution.height}`,
-      '--media_dir', mediaDir,
-      codeFile,
-      'MainScene'
-    ]
-
-    logger.info(`Job ${jobId}: 启动 manim 进程`, {
-      command: `manim ${args.join(' ')}`,
-      cwd: tempDir
-    })
-
-    const proc = spawn('manim', args, { cwd: tempDir })
-
-    let stdout = ''
-    let stderr = ''
-    let lastProgressTime = Date.now()
-    let lastLogTime = Date.now()
-    let peakMemory = 0 // 峰值内存（MB）
-
-    // 内存监控定时器（每2秒检查一次）
-    const memoryMonitor = setInterval(async () => {
-      if (proc.pid) {
-        const memory = await getProcessMemory(proc.pid)
-        if (memory) {
-          if (memory > peakMemory) {
-            peakMemory = memory
-          }
-          logger.info(`Job ${jobId}: Manim 内存使用`, {
-            memoryMB: memory,
-        peakMemoryMB: peakMemory
-          })
-        }
-      }
-    }, 2000)
-
-    proc.stdout.on('data', (data) => {
-      const text = data.toString()
-      stdout += text
-
-      // 实时输出所有 stdout（每5秒批量输出一次，避免过于频繁）
-      const elapsed = Date.now() - lastLogTime
-      if (elapsed > 5000) {
-        logger.info(`Job ${jobId}: Manim 进度输出`, {
-          output: text.trim(),
-          totalOutputLength: stdout.length
-        })
-        lastLogTime = Date.now()
-      }
-
-      // 检测进度条更新（单独处理，更频繁）
-      if (text.includes('%') || text.includes('it/s')) {
-        const progressElapsed = Date.now() - lastProgressTime
-        if (progressElapsed > 3000) {
-          logger.info(`Job ${jobId}: 渲染进度`, { progress: text.trim() })
-          lastProgressTime = Date.now()
-        }
-      }
-    })
-
-    proc.stderr.on('data', (data) => {
-      const text = data.toString()
-      stderr += text
-
-      // 实时记录所有 stderr 输出（不论是否包含错误）
-      logger.info(`Job ${jobId}: Manim stderr 实时输出`, {
-        output: text.trim(),
-        totalStderrLength: stderr.length
-      })
-    })
-
-    // 设置超时（5分钟）
-    const timeout = setTimeout(() => {
-      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
-      logger.warn(`Job ${jobId}: Manim render timeout (${elapsed}s), killing process`, {
-        peakMemoryMB: peakMemory
-      })
-      clearInterval(memoryMonitor)
-      proc.kill('SIGKILL')
-      resolve({
-        success: false,
-        stdout,
-        stderr: stderr || 'Manim render timeout (5 minutes)',
-        peakMemoryMB: peakMemory
-      })
-    }, 10 * 60 * 1000)
-
-    proc.on('close', (code) => {
-      clearTimeout(timeout)
-      clearInterval(memoryMonitor)
-      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
-      if (code === 0) {
-        logger.info(`Job ${jobId}: Manim 成功完成`, {
-          elapsed: `${elapsed}s`,
-          exitCode: code,
-          stdoutLength: stdout.length,
-          stderrLength: stderr.length,
-        peakMemoryMB: peakMemory
-        })
-        resolve({ success: true, stdout, stderr, peakMemoryMB: peakMemory })
-      } else {
-        logger.error(`Job ${jobId}: Manim 退出异常`, {
-          elapsed: `${elapsed}s`,
-          exitCode: code,
-          stdoutLength: stdout.length,
-          stderrLength: stderr.length,
-          stderrPreview: stderr.slice(-500),
-        peakMemoryMB: peakMemory
-        })
-        resolve({ success: false, stdout, stderr, peakMemoryMB: peakMemory })
-      }
-    })
-
-    proc.on('error', (error) => {
-      clearTimeout(timeout)
-      clearInterval(memoryMonitor)
-      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
-      logger.error(`Job ${jobId}: Manim 进程启动失败`, {
-        elapsed: `${elapsed}s`,
-        errorMessage: error.message,
-        errorStack: error.stack
-      })
-      resolve({ success: false, stdout, stderr: error.message, peakMemoryMB: peakMemory })
-    })
-  })
-}
+/**
+
+ * Manim 执行器
+
+ * 执行 Manim 命令，管理子进程
+
+ */
+
+
+
+import { spawn } from 'child_process'
+import { promises as fs } from 'fs'
+
+import { createLogger } from './logger'
+
+import { registerManimProcess, unregisterManimProcess, wasManimProcessCancelled } from './manim-process-registry'
+
+
+
+const logger = createLogger('ManimExecutor')
+
+
+
+/**
+
+ * Manim 执行结果
+
+ */
+
+export interface ManimExecutionResult {
+
+  success: boolean
+
+  stdout: string
+
+  stderr: string
+
+  peakMemoryMB: number
+
+}
+
+
+
+/**
+
+ * Manim 执行选项
+
+ */
+
+export interface ManimExecuteOptions {
+
+  jobId: string
+
+  quality: string
+
+  frameRate: number
+
+  tempDir: string
+
+  mediaDir: string
+
+}
+
+
+
+/**
+
+ * 获取进程的内存使用情况（MB）
+
+ */
+
+export async function getProcessMemory(pid: number): Promise<number | null> {
+  const platform = process.platform
+
+  if (platform === 'linux') {
+    return getLinuxProcessTreeMemory(pid)
+  }
+
+  if (platform === 'win32') {
+    return getWindowsProcessMemory(pid)
+  }
+
+  return getUnixProcessMemory(pid)
+}
+
+async function getLinuxProcessTreeMemory(pid: number): Promise<number | null> {
+  const visited = new Set<number>()
+  const queue: number[] = [pid]
+  let totalKb = 0
+
+  while (queue.length > 0) {
+    const current = queue.shift()
+    if (!current || visited.has(current)) {
+      continue
+    }
+    visited.add(current)
+
+    const rssKb = await readLinuxVmRssKb(current)
+    if (rssKb) {
+      totalKb += rssKb
+    }
+
+    const children = await readLinuxChildPids(current)
+    for (const child of children) {
+      if (!visited.has(child)) {
+        queue.push(child)
+      }
+    }
+  }
+
+  if (!totalKb) {
+    return null
+  }
+
+  return Math.round(totalKb / 1024)
+}
+
+async function readLinuxVmRssKb(pid: number): Promise<number | null> {
+  try {
+    const status = await fs.readFile(`/proc/${pid}/status`, 'utf-8')
+    const line = status.split(/\r?\n/).find((entry) => entry.startsWith('VmRSS:'))
+    if (!line) {
+      return null
+    }
+    const match = line.match(/VmRSS:\s+(\d+)/)
+    if (!match) {
+      return null
+    }
+    return parseInt(match[1], 10)
+  } catch {
+    return null
+  }
+}
+
+async function readLinuxChildPids(pid: number): Promise<number[]> {
+  try {
+    const children = await fs.readFile(`/proc/${pid}/task/${pid}/children`, 'utf-8')
+    if (!children.trim()) {
+      return []
+    }
+    return children
+      .trim()
+      .split(/\s+/)
+      .map((value) => parseInt(value, 10))
+      .filter((value) => !Number.isNaN(value))
+  } catch {
+    return []
+  }
+}
+
+async function getWindowsProcessMemory(pid: number): Promise<number | null> {
+  return new Promise((resolve) => {
+    spawn('wmic', ['process', 'where', `ProcessId=${pid}`, 'get', 'WorkingSetSize', '/value'])
+      .stdout.on('data', (data) => {
+        const output = data.toString()
+        const match = output.match(/WorkingSetSize=(\d+)/)
+        if (match) {
+          const bytes = parseInt(match[1], 10)
+          resolve(Math.round(bytes / 1024 / 1024))
+        } else {
+          resolve(null)
+        }
+      })
+      .on('error', () => resolve(null))
+      .on('close', () => resolve(null))
+  })
+}
+
+async function getUnixProcessMemory(pid: number): Promise<number | null> {
+  return new Promise((resolve) => {
+    spawn('ps', ['-o', 'rss=', '-p', pid.toString()])
+      .stdout.on('data', (data) => {
+        const output = data.toString().trim()
+        if (output) {
+          const kb = parseInt(output, 10)
+          resolve(Math.round(kb / 1024))
+        } else {
+          resolve(null)
+        }
+      })
+      .on('error', () => resolve(null))
+      .on('close', () => resolve(null))
+  })
+}
+
+
+
+/**
+
+ * 执行 manim 命令
+
+ */
+
+export function executeManimCommand(
+
+  codeFile: string,
+
+  options: ManimExecuteOptions
+
+): Promise<ManimExecutionResult> {
+
+  const { jobId, quality, frameRate, tempDir, mediaDir } = options
+
+
+
+  return new Promise((resolve) => {
+
+    const startTime = Date.now()
+
+
+
+    // 质量对应的分辨率
+
+    const resolutionMap: Record<string, { width: number; height: number }> = {
+
+      low: { width: 854, height: 480 },
+
+      medium: { width: 1280, height: 720 },
+
+      high: { width: 1920, height: 1080 }
+
+    }
+
+
+
+    const resolution = resolutionMap[quality] || resolutionMap.medium
+
+
+
+    const args = [
+
+      'render',
+
+      '--format', 'mp4',
+
+      '-r', frameRate.toString(),
+
+      '--resolution', `${resolution.width},${resolution.height}`,
+
+      '--media_dir', mediaDir,
+
+      codeFile,
+
+      'MainScene'
+
+    ]
+
+
+
+    logger.info(`Job ${jobId}: 启动 manim 进程`, {
+
+      command: `manim ${args.join(' ')}`,
+
+      cwd: tempDir
+
+    })
+
+
+
+    const proc = spawn('manim', args, { cwd: tempDir })
+
+
+
+    registerManimProcess(jobId, proc)
+
+
+
+    let stdout = ''
+
+    let stderr = ''
+
+    let lastProgressTime = Date.now()
+
+    let lastLogTime = Date.now()
+
+    let peakMemory = 0 // 峰值内存（MB）
+
+
+
+    // 内存监控定时器（每2秒检查一次）
+
+    const memoryMonitor = setInterval(async () => {
+
+      if (proc.pid) {
+
+        const memory = await getProcessMemory(proc.pid)
+
+        if (memory) {
+
+          if (memory > peakMemory) {
+
+            peakMemory = memory
+
+          }
+
+          logger.info(`Job ${jobId}: Manim 内存使用`, {
+
+            memoryMB: memory,
+
+        peakMemoryMB: peakMemory
+
+          })
+
+        }
+
+      }
+
+    }, 2000)
+
+
+
+    proc.stdout.on('data', (data) => {
+
+      const text = data.toString()
+
+      stdout += text
+
+
+
+    // 10 minutes timeout
+
+      const elapsed = Date.now() - lastLogTime
+
+      if (elapsed > 5000) {
+
+        logger.info(`Job ${jobId}: Manim 进度输出`, {
+
+          output: text.trim(),
+
+          totalOutputLength: stdout.length
+
+        })
+
+        lastLogTime = Date.now()
+
+      }
+
+
+
+      // 检测进度条更新（单独处理，更频繁）
+
+      if (text.includes('%') || text.includes('it/s')) {
+
+        const progressElapsed = Date.now() - lastProgressTime
+
+        if (progressElapsed > 3000) {
+
+          logger.info(`Job ${jobId}: 渲染进度`, { progress: text.trim() })
+
+          lastProgressTime = Date.now()
+
+        }
+
+      }
+
+    })
+
+
+
+    proc.stderr.on('data', (data) => {
+
+      const text = data.toString()
+
+      stderr += text
+
+
+
+      // 实时记录所有 stderr 输出（不论是否包含错误）
+
+      logger.info(`Job ${jobId}: Manim stderr 实时输出`, {
+
+        output: text.trim(),
+
+        totalStderrLength: stderr.length
+
+      })
+
+    })
+
+
+
+    // 10 minutes timeout
+
+    const timeout = setTimeout(() => {
+
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+
+      logger.warn(`Job ${jobId}: Manim render timeout (${elapsed}s), killing process`, {
+
+        peakMemoryMB: peakMemory
+
+      })
+
+      clearInterval(memoryMonitor)
+
+      proc.kill('SIGKILL')
+
+      resolve({
+
+        success: false,
+
+        stdout,
+
+        stderr: stderr || 'Manim render timeout (10 minutes)',
+
+        peakMemoryMB: peakMemory
+
+      })
+
+    }, 10 * 60 * 1000)
+
+
+
+    proc.on('close', (code) => {
+
+      clearTimeout(timeout)
+
+      clearInterval(memoryMonitor)
+
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+
+      const cancelled = wasManimProcessCancelled(jobId)
+
+      unregisterManimProcess(jobId)
+
+
+
+      if (cancelled) {
+
+        logger.warn(`Job ${jobId}: Manim cancelled`, { elapsed: `${elapsed}s` })
+
+        resolve({ success: false, stdout, stderr: 'Job cancelled', peakMemoryMB: peakMemory })
+
+        return
+
+      }
+
+
+
+      if (code == 0) {
+
+        logger.info(`Job ${jobId}: Manim 成功完成`, {
+
+          elapsed: `${elapsed}s`,
+
+          exitCode: code,
+
+          stdoutLength: stdout.length,
+
+          stderrLength: stderr.length,
+
+        peakMemoryMB: peakMemory
+
+        })
+
+        resolve({ success: true, stdout, stderr, peakMemoryMB: peakMemory })
+
+      } else {
+
+        logger.error(`Job ${jobId}: Manim 退出异常`, {
+
+          elapsed: `${elapsed}s`,
+
+          exitCode: code,
+
+          stdoutLength: stdout.length,
+
+          stderrLength: stderr.length,
+
+          stderrPreview: stderr.slice(-500),
+
+        peakMemoryMB: peakMemory
+
+        })
+
+        resolve({ success: false, stdout, stderr, peakMemoryMB: peakMemory })
+
+      }
+
+    })
+
+
+
+    proc.on('error', (error) => {
+
+      clearTimeout(timeout)
+
+      clearInterval(memoryMonitor)
+
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+
+      const cancelled = wasManimProcessCancelled(jobId)
+
+      unregisterManimProcess(jobId)
+
+
+
+      if (cancelled) {
+
+        logger.warn(`Job ${jobId}: Manim cancelled`, { elapsed: `${elapsed}s` })
+
+        resolve({ success: false, stdout, stderr: 'Job cancelled', peakMemoryMB: peakMemory })
+
+        return
+
+      }
+
+
+
+      logger.error(`Job ${jobId}: Manim 进程启动失败`, {
+
+        elapsed: `${elapsed}s`,
+
+        errorMessage: error.message,
+
+        errorStack: error.stack
+
+      })
+
+      resolve({ success: false, stdout, stderr: error.message, peakMemoryMB: peakMemory })
+
+    })
+
+  })
+
+}
+
+
+
+
+
+
+
+
+

src/utils/manim-process-registry.ts

@@ -0,0 +1,37 @@
+/**
+ * Manim Process Registry
+ * Manim 子进程管理
+ */
+
+import type { ChildProcess } from 'child_process'
+
+const activeProcesses = new Map<string, { proc: ChildProcess; cancelled: boolean }>()
+
+export function registerManimProcess(jobId: string, proc: ChildProcess): void {
+  activeProcesses.set(jobId, { proc, cancelled: false })
+}
+
+export function unregisterManimProcess(jobId: string): void {
+  activeProcesses.delete(jobId)
+}
+
+export function cancelManimProcess(jobId: string): boolean {
+  const entry = activeProcesses.get(jobId)
+  if (!entry) {
+    return false
+  }
+
+  entry.cancelled = true
+
+  try {
+    entry.proc.kill('SIGKILL')
+  } catch {
+    return false
+  }
+
+  return true
+}
+
+export function wasManimProcessCancelled(jobId: string): boolean {
+  return activeProcesses.get(jobId)?.cancelled ?? false
+}

zeabur.json

@@ -1,119 +1,129 @@
-{
-  "name": "manimcat",
-  "description": "ManimCat - AI-powered mathematical animation generator with Express.js, Bull Queue and Redis",
-  "version": "2.0.0",
-  "icon": "https://raw.githubusercontent.com/yourusername/ManimCat/main/public/logo.svg",
-  "services": {
-    "app": {
-      "type": "service",
-      "dockerfile": "Dockerfile",
-      "buildCommand": "npm run build",
-      "startCommand": "node dist/server.js",
-      "port": 3000,
-      "healthCheck": {
-        "path": "/health",
-        "interval": 30,
-        "timeout": 10,
-        "retries": 3,
-        "startPeriod": 40
-      },
-      "env": [
-        {
-          "key": "NODE_ENV",
-          "value": "production",
-          "description": "Node environment"
-        },
-        {
-          "key": "PORT",
-          "value": "3000",
-          "description": "Server port"
-        },
-        {
-          "key": "REDIS_HOST",
-          "value": "${REDIS_HOST}",
-          "description": "Redis host (auto-injected by Zeabur)"
-        },
-        {
-          "key": "REDIS_PORT",
-          "value": "${REDIS_PORT}",
-          "description": "Redis port (auto-injected by Zeabur)"
-        },
-        {
-          "key": "REDIS_PASSWORD",
-          "value": "${REDIS_PASSWORD}",
-          "description": "Redis password (if required)"
-        },
-        {
-          "key": "REDIS_DB",
-          "value": "0",
-          "description": "Redis database number"
-        },
-        {
-          "key": "OPENAI_API_KEY",
-          "description": "OpenAI API key for AI code generation (required)",
-          "required": true
-        },
-        {
-          "key": "OPENAI_MODEL",
-          "value": "glm-4-flash",
-          "description": "OpenAI-compatible model (glm-4-flash/gpt-4o-mini/gpt-4-turbo, etc.)"
-        },
-        {
-          "key": "CUSTOM_API_URL",
-          "value": "",
-          "description": "Custom OpenAI-compatible API endpoint (optional)"
-        },
-        {
-          "key": "MANIMCAT_API_KEY",
-          "value": "",
-          "description": "API key for authentication (optional, leave empty to disable auth)"
-        },
-        {
-          "key": "DISPLAY",
-          "value": ":99",
-          "description": "X display for Xvfb"
-        }
-      ],
-      "volumes": [
-        {
-          "name": "videos",
-          "mountPath": "/app/public/videos"
-        },
-        {
-          "name": "tmp",
-          "mountPath": "/app/tmp"
-        }
-      ],
-      "resources": {
-        "cpu": "2",
-        "memory": "4Gi",
-        "disk": "20Gi"
-      }
-    },
-    "redis": {
-      "type": "redis",
-      "version": "7",
-      "persistence": true,
-      "config": {
-        "maxmemory": "512mb",
-        "maxmemory-policy": "allkeys-lru",
-        "appendonly": "yes"
-      },
-      "resources": {
-        "cpu": "0.5",
-        "memory": "512Mi",
-        "disk": "5Gi"
-      }
-    }
-  },
-  "dependencies": {
-    "app": ["redis"]
-  },
-  "regions": ["auto"],
-  "networking": {
-    "app": {
-      "public": true,
-      "domains": []
-    }
-  }
-}
+{
+  "name": "manimcat",
+  "description": "ManimCat - AI-powered mathematical animation generator with Express.js, Bull Queue and Redis",
+  "version": "2.0.0",
+  "icon": "https://raw.githubusercontent.com/yourusername/ManimCat/main/public/logo.svg",
+  "services": {
+    "app": {
+      "type": "service",
+      "dockerfile": "Dockerfile",
+      "buildCommand": "npm run build",
+      "startCommand": "node dist/server.js",
+      "port": 3000,
+      "healthCheck": {
+        "path": "/health",
+        "interval": 30,
+        "timeout": 600,
+        "retries": 3,
+        "startPeriod": 40
+      },
+      "env": [
+        {
+          "key": "NODE_ENV",
+          "value": "production",
+          "description": "Node environment"
+        },
+        {
+          "key": "PORT",
+          "value": "3000",
+          "description": "Server port"
+        },
+        {
+          "key": "REDIS_HOST",
+          "value": "${REDIS_HOST}",
+          "description": "Redis host (auto-injected by Zeabur)"
+        },
+        {
+          "key": "REDIS_PORT",
+          "value": "${REDIS_PORT}",
+          "description": "Redis port (auto-injected by Zeabur)"
+        },
+        {
+          "key": "REDIS_PASSWORD",
+          "value": "${REDIS_PASSWORD}",
+          "description": "Redis password (if required)"
+        },
+        {
+          "key": "REDIS_DB",
+          "value": "0",
+          "description": "Redis database number"
+        },
+        {
+          "key": "OPENAI_API_KEY",
+          "description": "OpenAI API key for AI code generation (required)",
+          "required": true
+        },
+        {
+          "key": "OPENAI_MODEL",
+          "value": "glm-4-flash",
+          "description": "OpenAI-compatible model (glm-4-flash/gpt-4o-mini/gpt-4-turbo, etc.)"
+        },
+        {
+          "key": "CUSTOM_API_URL",
+          "value": "",
+          "description": "Custom OpenAI-compatible API endpoint (optional)"
+        },
+        {
+          "key": "MANIMCAT_API_KEY",
+          "value": "",
+          "description": "API key for authentication (optional, leave empty to disable auth)"
+        },
+        {
+          "key": "DISPLAY",
+          "value": ":99",
+          "description": "X display for Xvfb"
+        }
+      ],
+      "volumes": [
+        {
+          "name": "videos",
+          "mountPath": "/app/public/videos"
+        },
+        {
+          "name": "tmp",
+          "mountPath": "/app/tmp"
+        }
+      ],
+      "resources": {
+        "cpu": "2",
+        "memory": "4Gi",
+        "disk": "20Gi"
+      }
+    },
+    "redis": {
+      "type": "redis",
+      "version": "7",
+      "persistence": true,
+      "config": {
+        "maxmemory": "512mb",
+        "maxmemory-policy": "allkeys-lru",
+        "appendonly": "yes"
+      },
+      "resources": {
+        "cpu": "0.5",
+        "memory": "512Mi",
+        "disk": "5Gi"
+      }
+    }
+  },
+  "dependencies": {
+    "app": ["redis"]
+  },
+  "regions": ["auto"],
+  "networking": {
+    "app": {
+      "public": true,
+      "domains": []
+    }
+  }
+}
+
+
+
+
+
+
+
+
+
+