feat: 更新前端密钥处理逻辑，优化文档预览功能

- 修改前端实现，AI、工作流接口仅读取代理地址，敏感密钥统一由后端管控
- 在应用根组件（App）实现基于URL参数自动唤起文档预览
- 优化消息条目组件（MessageItem），支持渲染文档链接并绑定预览点击事件
- 在区块编辑器（BlockEditor）新增事件监听，同步处理远端区块更新、删除操作，保持文档数据一致
- 重构导出记录列表组件（ExportRecordList），在导出任务创建时自动刷新列表
- 更新AI与工作流服务配置，消除前端明文暴露API密钥的风险
- 在区块服务（blockService）新增区块更新、区块删除事件定义
- 优化WebMCP服务，增强重连机制与凭证（ticket）拉取稳定性
- 升级翻译服务（translator service），完善异常捕获与超时管控逻辑
- 更新编辑器状态库（editor store），确保远端区块变更、删除操作生效
- 配置Vite接口代理，优化本地开发环境调试体验

.env

@@ -12,12 +12,11 @@ VITE_APP_TITLE=AX Document Editor
 # Default: false
 VITE_DEBUG=false
 
-# External AI services are called directly by the browser.
-VITE_AI_API_URL=http://114.242.25.27:3000/api/v1/chat/completions
-VITE_AI_API_KEY=XAgent-eVVoqEO7WJYwzCc5wQ8meEtIuyIQgHhxYvpd6fSwa7BwJW8CaBom4
-VITE_WORKFLOW_API_URL=http://114.242.25.27:3000/api/v2/chat/completions
-VITE_WORKFLOW_API_KEY=XAgent-mWHBqQw06psUYRqx6PrHWiKdfY05ebt7I9drDBHzaG9QQesIkVEICj
+# AI and workflow calls must go through the backend proxy.
+VITE_AI_PROXY_URL=/api/v1/ai/chat
+VITE_WORKFLOW_PROXY_URL=/api/v1/ai/workflow
 
 # WebMCP Bridge 连接配置
-VITE_WEBMCP_BRIDGE_TOKEN=AXWebMCP-04fb7ebd989246b28ca63a49e0efd2c0a27cc8c89e2241fda22b8b0c42c744a1
 VITE_WEBMCP_CLIENT_ID=ax-editor-local
+# Local development only. Never configure this in a production build.
+VITE_WEBMCP_BRIDGE_TOKEN=AXWebMCP-04fb7ebd989246b28ca63a49e0efd2c0a27cc8c89e2241fda22b8b0c42c744a1

.env.example

@@ -14,12 +14,9 @@ VITE_APP_TITLE=AX Document Editor
 # Default: false
 VITE_DEBUG=false
 
-# Development-only direct AI endpoints. Never ship these keys in a production build.
-VITE_AI_API_URL=
-VITE_AI_API_KEY=
-VITE_WORKFLOW_API_URL=
-VITE_WORKFLOW_API_KEY=
-
-# Production same-origin proxy endpoints. The proxy stores the upstream API keys server-side.
+# The browser must use backend proxy endpoints. Keep upstream API keys server-side.
 VITE_AI_PROXY_URL=/api/v1/ai/chat
 VITE_WORKFLOW_PROXY_URL=/api/v1/ai/workflow
+
+# Local development only; production uses a session-based WebMCP ticket.
+VITE_WEBMCP_BRIDGE_TOKEN=

README.md

@@ -126,8 +126,7 @@ ax-frontend-app/
 - 支持断网检测和重连机制
 
 **API 集成**:
-- AI 对话 API: `VITE_AI_API_URL`
-- 工作流 API: `VITE_WORKFLOW_API_URL`
+- AI 对话和工作流通过后端代理访问，使用 `VITE_AI_PROXY_URL` 与 `VITE_WORKFLOW_PROXY_URL`
 
 ---
 
@@ -407,10 +406,10 @@ Content-Type: 'application/json'
 | `VITE_API_BASE_URL` | 后端 API 地址 | `http://192.168.0.195:8000` |
 | `VITE_APP_TITLE` | 应用标题 | `AX Document Editor` |
 | `VITE_DEBUG` | 调试模式 | `false` |
-| `VITE_AI_API_URL` | AI 对话 API | `http://114.242.25.27:3000/api/v1/chat/completions` |
-| `VITE_AI_API_KEY` | AI API 密钥 | - |
-| `VITE_WORKFLOW_API_URL` | 工作流 API | `http://114.242.25.27:3000/api/v2/chat/completions` |
-| `VITE_WORKFLOW_API_KEY` | 工作流 API 密钥 | - |
+| `VITE_AI_PROXY_URL` | 后端 AI 代理地址 | `/api/v1/ai/chat` |
+| `VITE_WORKFLOW_PROXY_URL` | 后端工作流代理地址 | `/api/v1/ai/workflow` |
+
+AI 和工作流上游密钥只能配置在后端，禁止放入任何 `VITE_*` 变量。
 
 ### 配置步骤
 

docs/README.md

@@ -217,7 +217,7 @@ PDF、截图和 Word 解析库不应改为入口静态 import，否则会增加
 
 必须注意：
 
-`VITE_*` 环境变量会进入浏览器构建产物，因此 `VITE_AI_API_KEY` 和 `VITE_WORKFLOW_API_KEY` 不能作为生产秘密。生产环境应使用后端代理：
+`VITE_*` 环境变量会进入浏览器构建产物，因此 AI 和工作流密钥不能作为前端配置。浏览器只能调用后端代理，生产密钥必须保存在后端：
 
 ```text
 浏览器 -> 自有后端 -> AI / Workflow 服务
@@ -239,10 +239,8 @@ npm audit --omit=dev
 | 变量                    | 用途                            |
 | ----------------------- | ------------------------------- |
 | `VITE_API_BASE_URL`     | 后端 API 地址                   |
-| `VITE_AI_API_URL`       | AI 聊天服务地址                 |
-| `VITE_AI_API_KEY`       | AI 服务访问令牌，不应放生产秘密 |
-| `VITE_WORKFLOW_API_URL` | 文档工作流地址                  |
-| `VITE_WORKFLOW_API_KEY` | 工作流访问令牌，不应放生产秘密  |
+| `VITE_AI_PROXY_URL`       | 后端 AI 代理地址                 |
+| `VITE_WORKFLOW_PROXY_URL` | 后端工作流代理地址              |
 | `VITE_DEBUG`            | 是否输出 API 调试日志           |
 
 默认后端地址由服务层提供，仅适合本地开发。部署时应显式配置 `VITE_API_BASE_URL`。

docs/外部MCP服务接入指南.md

@@ -0,0 +1,520 @@
+# 外部 MCP 服务接入指南
+
+本文档说明 AX 文档编辑器如何接入外部 MCP（Model Context Protocol）服务，以及当前项目已经具备的能力和需要补充的实现。
+
+## 1. 先明确当前能力边界
+
+当前项目已经实现的是 **WebMCP Provider 和 Bridge**：
+
+```text
+其他网站
+  -> POST /api/v1/webmcp/invoke
+  -> AX 后端 WebMCP Bridge
+  -> AX 前端页面 WebSocket Connector
+  -> AX 前端注册的 WebMCP 工具
+```
+
+当前页面注册的工具包括：
+
+- `open_document`
+- `list_documents`
+- `get_document`
+- `search_document`
+- `get_block`
+- `get_document_toc`
+- `get_document_stats`
+- `list_export_records`
+- `insert_block`
+- `update_block`
+- `delete_block`
+- `export_document`
+- `download_export_record`
+
+这些工具在前端 [webMcpService.ts](../src/services/webMcpService.ts) 中定义，由当前 AX 页面执行。
+
+当前项目**还不是通用 MCP Client**，因此不能仅通过现有 WebMCP Bridge 自动发现或调用其他 MCP Server 的工具。要接入外部 MCP Server，需要在后端新增 MCP Client 层。
+
+## 2. 推荐的目标架构
+
+外部 MCP 服务应该由 FastAPI 后端连接，浏览器只负责展示结果和触发经过授权的操作。
+
+```text
+用户聊天输入
+  -> AX 前端 Chat Agent
+  -> AX 后端统一工具目录
+       ├── AX 本地 WebMCP 工具
+       └── 外部 MCP 工具
+  -> 工具路由器
+       ├── 本地工具：通过 WebMCP Bridge 调用当前页面
+       └── 外部工具：通过 MCP Client 调用对应 MCP Server
+  -> 返回结构化结果
+  -> 前端展示结果
+```
+
+外部 MCP Server 可能使用以下连接方式：
+
+- `stdio`：后端启动本地 MCP Server 子进程；
+- Streamable HTTP：后端通过 HTTP 连接远端 MCP Server；
+- SSE：连接支持 SSE 的 MCP Server；
+- 需要 API Key、OAuth 或其他服务端认证方式的远程服务。
+
+推荐把外部连接放在后端，原因如下：
+
+- 浏览器不能安全地启动 `stdio` 子进程；
+- API Key、OAuth Refresh Token 等机密不能放入 `VITE_*` 环境变量；
+- 后端可以统一做工具白名单、用户权限、限流、审计和写操作确认；
+- 多个前端页面可以复用同一个 MCP Client 连接池。
+
+## 3. 当前项目中已经可用的 WebMCP Bridge
+
+如果目标只是让其他网站调用 AX 自己的工具，不需要接入外部 MCP Server，可以直接使用现有接口。
+
+### 3.1 启动服务
+
+启动后端：
+
+```powershell
+cd "D:\work space\ax-shell\ax-backend-v1"
+uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
+```
+
+启动前端：
+
+```powershell
+cd "D:\work space\ax-shell\ax-frontend-app"
+npm run dev
+```
+
+然后保持 AX 页面打开：
+
+```text
+http://localhost:5173/
+```
+
+页面启动时会连接 WebSocket Bridge：
+
+```text
+ws://localhost:8000/api/v1/webmcp/bridge/{clientId}
+```
+
+### 3.2 调用 AX 工具
+
+```javascript
+async function invokeAxTool(tool, argumentsValue = {}) {
+  const response = await fetch('http://localhost:8000/api/v1/webmcp/invoke', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-WebMCP-Token': '从服务端安全配置中读取',
+    },
+    body: JSON.stringify({
+      clientId: 'ax-editor-local',
+      tool,
+      arguments: argumentsValue,
+    }),
+  });
+
+  const payload = await response.json();
+  if (!response.ok || payload.code !== 0) {
+    throw new Error(payload.detail || payload.message || 'WebMCP 调用失败');
+  }
+
+  const result = payload.data.result;
+  if (!result.ok) {
+    throw new Error(result.error || 'AX WebMCP 工具执行失败');
+  }
+
+  return result.data;
+}
+
+const documents = await invokeAxTool('list_documents', {
+  page: 1,
+  pageSize: 20,
+});
+```
+
+当前 AX 页面必须保持打开，因为 `open_document`、`update_block` 等工具依赖浏览器中的编辑器状态。
+
+## 4. 接入外部 MCP Server 的实施步骤
+
+### 步骤 1：选择连接方式
+
+先确认外部服务提供的协议和认证方式：
+
+| 类型            | 适用场景                         | 机密存放位置                   |
+| --------------- | -------------------------------- | ------------------------------ |
+| `stdio`         | 本机工具、文件系统工具、内部脚本 | 后端主机环境变量或密钥管理服务 |
+| Streamable HTTP | 远程部署的 MCP Server            | 后端服务端配置                 |
+| SSE             | 旧版或仍提供 SSE 的 MCP Server   | 后端服务端配置                 |
+| OAuth           | 第三方 SaaS 服务                 | 后端安全 Token 存储            |
+
+不要把外部 MCP Server 的命令、Token 或 API Key 写入前端代码。
+
+### 步骤 2：在后端增加 MCP Client 依赖
+
+当前 [requirements.txt](../../ax-backend-v1/requirements.txt) 尚未包含 MCP Client SDK。接入时应选择与目标 Server 协议匹配的官方或可信 SDK，并固定版本。
+
+安装依赖前应确认：
+
+- SDK 支持当前 Python 版本；
+- SDK 支持目标 Server 的传输方式；
+- SDK 的许可证和维护状态符合项目要求；
+- 依赖不会把不受信任的命令执行能力暴露给公网请求。
+
+不要直接把任意用户输入拼接到 `stdio` 命令或参数中。
+
+### 步骤 3：增加外部 Server 配置
+
+建议在后端配置中增加 Server 配置，而不是把配置硬编码到业务代码：
+
+```env
+EXTERNAL_MCP_ENABLED=false
+EXTERNAL_MCP_SERVERS_JSON={}
+EXTERNAL_MCP_CONNECT_TIMEOUT=10
+EXTERNAL_MCP_CALL_TIMEOUT=60
+EXTERNAL_MCP_MAX_RESULT_BYTES=524288
+```
+
+生产环境更推荐使用单独的密钥管理系统。配置内容至少应包括：
+
+```json
+{
+  "filesystem": {
+    "enabled": true,
+    "transport": "stdio",
+    "command": "npx",
+    "args": ["-y", "@modelcontextprotocol/server-filesystem", "D:/documents"],
+    "allowedTools": ["read_file", "list_directory"]
+  }
+}
+```
+
+注意：上面的配置是接入设计示例，不代表当前项目已经支持该配置格式。
+
+### 步骤 4：增加 MCP Client 管理器
+
+建议新增以下后端结构：
+
+```text
+ax-backend-v1/app/mcp/
+  __init__.py
+  client.py       # 单个 MCP Server 的连接和调用
+  manager.py      # 多个 Server 的生命周期管理
+  registry.py     # 工具目录、命名空间和白名单
+  schemas.py      # 工具和调用结果的数据结构
+```
+
+单个 Client 至少应提供：
+
+```python
+class ExternalMcpClient:
+    async def connect(self) -> None:
+        """建立连接并完成 MCP initialize。"""
+
+    async def list_tools(self) -> list[dict]:
+        """调用 tools/list 获取工具定义。"""
+
+    async def call_tool(self, name: str, arguments: dict) -> dict:
+        """调用 tools/call 执行工具。"""
+
+    async def close(self) -> None:
+        """释放连接、子进程和后台任务。"""
+```
+
+管理器应负责：
+
+- 应用启动时连接已启用的 Server；
+- 应用关闭时释放连接；
+- 连接断开后的有限次重连；
+- `tools/list` 结果缓存和刷新；
+- 工具名称冲突处理；
+- 单 Server 和单用户的并发限制；
+- 调用超时和结果大小限制。
+
+### 步骤 5：为外部工具添加命名空间
+
+外部工具不能直接使用裸名称，否则容易与 AX 本地工具冲突。建议统一使用：
+
+```text
+filesystem.read_file
+github.search_repositories
+notion.search
+```
+
+内部映射可以是：
+
+```python
+TOOL_MAPPING = {
+    "filesystem.read_file": {
+        "server": "filesystem",
+        "remote_name": "read_file",
+    },
+}
+```
+
+对外暴露的统一工具结构建议如下：
+
+```python
+{
+    "name": "filesystem.read_file",
+    "title": "读取文件",
+    "description": "读取允许目录中的文件内容",
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string"}
+        },
+        "required": ["path"]
+    },
+    "source": "external",
+    "server": "filesystem",
+    "requiresConfirmation": false
+}
+```
+
+### 步骤 6：增加后端代理接口
+
+推荐新增独立的外部 MCP API，而不是把外部工具直接塞进现有 AX Bridge 白名单：
+
+```http
+GET /api/v1/mcp/tools
+POST /api/v1/mcp/tools/call
+```
+
+获取工具：
+
+```http
+GET /api/v1/mcp/tools
+Authorization: Bearer <user-token>
+```
+
+调用工具：
+
+```http
+POST /api/v1/mcp/tools/call
+Authorization: Bearer <user-token>
+Content-Type: application/json
+
+{
+  "tool": "filesystem.read_file",
+  "arguments": {
+    "path": "D:/documents/example.txt"
+  }
+}
+```
+
+返回结果建议统一成：
+
+```json
+{
+  "ok": true,
+  "tool": "filesystem.read_file",
+  "server": "filesystem",
+  "data": {
+    "content": "文件内容"
+  }
+}
+```
+
+外部 MCP Server 的原始结果应在后端转换成受控结构，不能无条件把任意对象、二进制数据或超大文本直接返回给浏览器。
+
+### 步骤 7：接入聊天工具目录
+
+当前聊天转译上下文主要来自前端 [webMcpAgentService.ts](../src/services/webMcpAgentService.ts) 的本地工具列表。接入外部工具后，应将本地和外部工具合并：
+
+```text
+本地工具：getWebMcpTools()
+外部工具：GET /api/v1/mcp/tools
+统一工具目录：localTools + externalTools
+```
+
+工具调用时按来源路由：
+
+```text
+open_document
+  -> AX 前端 WebMCP Runtime
+
+filesystem.read_file
+  -> AX 后端 MCP Client
+```
+
+自然语言转译结果必须经过服务端二次校验，不能因为模型返回了某个工具名称就直接执行。
+
+## 5. 安全要求
+
+### 5.1 工具白名单
+
+只允许配置明确启用的 Server 和工具：
+
+```python
+ALLOWED_EXTERNAL_TOOLS = {
+    "filesystem.read_file",
+    "filesystem.list_directory",
+}
+```
+
+不能允许请求方任意传入 Server 地址、命令、工具名称或远程 URL。
+
+### 5.2 写操作确认
+
+以下类型的外部工具默认需要用户确认：
+
+- 写入、删除或移动文件；
+- 创建、修改或删除第三方平台数据；
+- 发送邮件、消息或通知；
+- 创建费用、订单或权限变更；
+- 执行脚本、命令或数据库写操作。
+
+确认凭证必须绑定：
+
+- 当前用户；
+- 当前会话；
+- 工具名称；
+- 完整参数哈希；
+- 短时间有效期；
+- 一次性使用标识。
+
+### 5.3 认证和权限
+
+生产环境不能使用长期共享的 `VITE_WEBMCP_BRIDGE_TOKEN`。当前项目的生产配置应使用：
+
+```env
+WEBMCP_AUTH_REQUIRED=true
+WEBMCP_JWT_SECRET=独立的高熵服务端密钥
+WEBMCP_REDIS_URL=redis://...
+WEBMCP_REQUIRE_SHARED_STORE=true
+```
+
+外部 MCP Client 还必须校验：
+
+- 当前用户是否有权访问目标 Server；
+- 当前用户是否有权访问目标资源；
+- 文档、文件或第三方对象是否属于当前租户；
+- 外部工具返回内容是否可展示给当前用户。
+
+### 5.4 SSRF 和命令执行防护
+
+如果支持 HTTP MCP Server：
+
+- 不允许用户直接提交任意 URL；
+- 只允许服务端配置的域名或地址；
+- 禁止访问云元数据地址、内网管理地址和本机敏感端口；
+- 对重定向进行重新校验；
+- 配置连接、读取和总调用超时。
+
+如果支持 `stdio` MCP Server：
+
+- 命令和参数只能来自服务端配置；
+- 不要使用 shell 拼接执行；
+- 使用参数数组启动进程；
+- 限制工作目录和环境变量；
+- 使用专用低权限系统用户；
+- 限制子进程数量、内存和运行时间。
+
+### 5.5 结果和日志
+
+必须限制：
+
+- 请求参数大小；
+- 工具结果大小；
+- 单用户并发数；
+- 单 Server 并发数；
+- 调用频率；
+- 连接重试次数。
+
+日志中不要记录：
+
+- API Key；
+- OAuth Token；
+- Cookie；
+- 完整文件内容；
+- 可能包含个人信息的工具参数。
+
+建议记录：
+
+- 用户 ID 和会话 ID；
+- Server 名称；
+- 命名空间工具名；
+- 调用是否需要确认；
+- 成功、失败或超时；
+- 调用耗时和结果大小。
+
+## 6. 推荐的分阶段落地顺序
+
+### 阶段一：只读工具
+
+先接入一个只读外部 MCP Server，例如：
+
+- 文件列表；
+- 文件读取；
+- 搜索；
+- 查询类工具。
+
+只实现：
+
+- Server 配置；
+- Client 连接；
+- `tools/list`；
+- `tools/call`；
+- 工具白名单；
+- 超时和结果限制；
+- 只读调用 API。
+
+### 阶段二：接入聊天
+
+将外部工具目录加入聊天 Agent：
+
+- 展示工具名称和描述；
+- 将工具 Schema 提供给转译器；
+- 服务端校验工具名称和参数；
+- 将调用结果转换成适合聊天展示的文本或结构化卡片。
+
+### 阶段三：写操作和确认
+
+增加：
+
+- 用户确认弹窗；
+- 一次性确认凭证；
+- 参数哈希绑定；
+- 审计日志；
+- 失败重试和幂等策略。
+
+### 阶段四：多租户和生产部署
+
+增加：
+
+- 每个租户独立的 MCP Server 配置；
+- 用户级 OAuth Token；
+- Redis 或其他共享状态存储；
+- 多实例连接管理；
+- 监控、告警和调用成本统计。
+
+## 7. 上线检查清单
+
+- [ ] 外部 MCP Client 只运行在后端。
+- [ ] 外部 MCP Server 地址来自服务端配置，不来自用户输入。
+- [ ] API Key 和 OAuth Token 没有进入前端构建产物。
+- [ ] 所有外部工具使用命名空间。
+- [ ] 工具和 Server 都有白名单。
+- [ ] 只读和写操作明确区分。
+- [ ] 写操作需要当前用户确认。
+- [ ] 确认凭证绑定用户、会话、工具和参数哈希。
+- [ ] 配置连接超时、调用超时和结果大小限制。
+- [ ] 配置单用户和单 Server 并发限制。
+- [ ] HTTP Server 已防护 SSRF。
+- [ ] `stdio` Server 使用低权限进程和固定参数。
+- [ ] 日志已脱敏。
+- [ ] 已测试断线、超时、错误结果和超大结果。
+- [ ] 已测试多用户和多租户权限隔离。
+- [ ] 生产环境未使用长期共享 Bridge Token。
+
+## 8. 相关代码和文档
+
+- [AX WebMCP 跨网站调用文档](./WebMCP调用接入文档.md)
+- [AX WebMCP 工具定义](../src/services/webMcpService.ts)
+- [AX WebMCP Bridge](../src/share/webmcp/bridge.ts)
+- [后端 WebMCP 路由](../../ax-backend-v1/app/api/v1/webmcp.py)
+- [后端配置](../../ax-backend-v1/app/config.py)
+- [后端依赖](../../ax-backend-v1/requirements.txt)
+
+> 本指南中的外部 MCP Client 目录、配置项和代理接口属于推荐设计。当前仓库已经实现的是 AX 自有 WebMCP 工具及 Bridge；在外部 MCP Client 代码落地前，不应把外部 Server 工具当作当前系统已支持的功能对外承诺。

docs/新编辑器架构设计.md

@@ -90,7 +90,7 @@ MessageItem / ExportRecordList
 
 `richTextConverter` 在生成 HTML 前会转义文本，并限制颜色和字体值格式。富文本解析使用临时 DOM，不应直接将未过滤的用户 HTML 传给 `dangerouslySetInnerHTML`。
 
-当前前端仍会读取 `VITE_AI_API_KEY` 和 `VITE_WORKFLOW_API_KEY`。Vite 的 `VITE_*` 变量会被打包到浏览器，不能视为秘密。生产部署应由后端代理 AI 和工作流请求��
+前端只读取 `VITE_AI_PROXY_URL` 和 `VITE_WORKFLOW_PROXY_URL`，AI 与工作流上游密钥必须由后端代理保存和使用。任何 `VITE_*_API_KEY` 都会被打包到浏览器，不能配置为秘密��
 
 ## 8. 性能决策
 

src/App.tsx

@@ -24,7 +24,7 @@
  * @module App
  */
 
-import React, { useCallback, useState, memo, lazy, Suspense, useMemo } from 'react';
+import React, { useCallback, useEffect, useState, memo, lazy, Suspense, useMemo } from 'react';
 import { ConfigProvider, Alert, Button, Drawer, Spin } from 'antd';
 import { MessageOutlined } from '@ant-design/icons';
 import zhCN from 'antd/locale/zh_CN';
@@ -132,8 +132,14 @@ const App: React.FC = () => {
   // ── Editor state ──────────────────────────────────────────────────────────
   const previewDocumentId = useUIStore((state) => state.previewDocumentId);
   const previewDocumentName = useUIStore((state) => state.previewDocumentName);
+  const openDocumentPreview = useUIStore((state) => state.openDocumentPreview);
   const closeDocumentPreview = useUIStore((state) => state.closeDocumentPreview);
 
+  useEffect(() => {
+    const documentId = new URLSearchParams(window.location.search).get('documentId');
+    if (documentId) openDocumentPreview(documentId);
+  }, [openDocumentPreview]);
+
   // ── Session history drawer ────────────────────────────────────────────────
   const [sessionListOpen, setSessionListOpen] = useState(false);
 

src/components/ChatPanel/MessageItem.tsx

@@ -104,6 +104,84 @@ const exportCardActionStyle: React.CSSProperties = {
   transition: 'color 0.2s',
 };
 
+const URL_PATTERN = /(https?:\/\/[^\s]+)/g;
+
+const documentLinkCardStyle: React.CSSProperties = {
+  ...exportCardStyle,
+  marginTop: 0,
+  marginBottom: 8,
+};
+
+const getDocumentIdFromUrl = (value: string): string | undefined => {
+  try {
+    return new URL(value).searchParams.get('documentId') || undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const renderMessageContent = (
+  content: string,
+  onPreviewDocument?: (documentId: string, documentName?: string) => void
+): React.ReactNode => {
+  const lines = content.split('\n');
+  const nodes: React.ReactNode[] = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const documentLine = lines[index].match(/^\s*\d+\.\s+(.+?)(?:\s+\(更新于[^)]*\))?\s*$/);
+    const documentUrl = lines[index + 1]?.trim();
+    const documentId = documentUrl && /^https?:\/\//i.test(documentUrl)
+      ? getDocumentIdFromUrl(documentUrl)
+      : undefined;
+
+    if (documentLine && documentId) {
+      nodes.push(
+        <Card
+          key={`document-link-${index}`}
+          style={documentLinkCardStyle}
+          styles={{ body: exportCardBodyStyle }}
+          hoverable
+          onClick={() => onPreviewDocument?.(documentId, documentLine[1])}
+          data-testid="document-link-card"
+        >
+          <div style={exportCardHeaderStyle}>
+            <FileTextOutlined style={exportCardIconStyle} />
+            <div style={exportCardTitleStyle}>{documentLine[1]}</div>
+          </div>
+          <div style={exportCardActionsStyle}>
+            <span>点击打开并编辑</span>
+          </div>
+        </Card>
+      );
+      index += 1;
+      continue;
+    }
+
+    const parts = lines[index].split(URL_PATTERN);
+    nodes.push(
+      <React.Fragment key={`message-line-${index}`}>
+        {parts.map((part, partIndex) => {
+          if (!/^https?:\/\//i.test(part)) return part;
+          return (
+            <a
+              key={`${part}-${partIndex}`}
+              href={part}
+              target="_blank"
+              rel="noreferrer"
+              onClick={(event) => event.stopPropagation()}
+            >
+              {part}
+            </a>
+          );
+        })}
+        {index < lines.length - 1 ? '\n' : null}
+      </React.Fragment>
+    );
+  }
+
+  return nodes;
+};
+
 // ── Component ────────────────────────────────────────────────────────────────
 
 /**
@@ -267,7 +345,7 @@ const MessageItem: React.FC<MessageItemProps> = memo(
       >
         {/* Message bubble */}
         <div style={bubbleStyle(role)} data-testid="message-bubble">
-          {content}
+          {renderMessageContent(content, onPreviewDocument)}
         </div>
 
         {/* Export record card (if present) */}

src/components/Editor/BlockEditor.tsx

@@ -11,8 +11,10 @@ import React, { useEffect, useCallback } from 'react';
 import { Spin, message } from 'antd';
 import { useShallow } from 'zustand/react/shallow';
 import { useEditorStore } from '../../stores/editorStore';
+import { BLOCK_DELETED_EVENT, BLOCK_UPDATED_EVENT } from '../../services/blockService';
 import { BlockCanvas } from './BlockCanvas';
 import { MainToolbar } from './toolbar/MainToolbar';
+import type { BlockUpdate } from '../../types/editor';
 import './BlockEditor.css';
 
 // ══════════════════════════════════════════════════════════════════════════════
@@ -86,6 +88,43 @@ export const BlockEditor: React.FC<BlockEditorProps> = ({
     };
   }, [documentId, loadDocument]);
 
+  // 接收聊天/WebMCP 已保存的块更新，立即同步当前打开的文档。
+  useEffect(() => {
+    const handleBlockUpdated = (event: Event) => {
+      const detail = (event as CustomEvent<{
+        documentId?: unknown;
+        blockId?: unknown;
+        updates?: unknown;
+      }>).detail;
+      if (
+        detail?.documentId !== documentId ||
+        typeof detail.blockId !== 'string' ||
+        !detail.updates ||
+        typeof detail.updates !== 'object'
+      ) {
+        return;
+      }
+      useEditorStore.getState().applyRemoteBlockUpdate(
+        detail.blockId,
+        detail.updates as BlockUpdate
+      );
+    };
+
+    window.addEventListener(BLOCK_UPDATED_EVENT, handleBlockUpdated);
+    return () => window.removeEventListener(BLOCK_UPDATED_EVENT, handleBlockUpdated);
+  }, [documentId]);
+
+  useEffect(() => {
+    const handleBlockDeleted = (event: Event) => {
+      const detail = (event as CustomEvent<{ documentId?: unknown; blockId?: unknown }>).detail;
+      if (detail?.documentId !== documentId || typeof detail.blockId !== 'string') return;
+      useEditorStore.getState().applyRemoteBlockDelete(detail.blockId);
+    };
+
+    window.addEventListener(BLOCK_DELETED_EVENT, handleBlockDeleted);
+    return () => window.removeEventListener(BLOCK_DELETED_EVENT, handleBlockDeleted);
+  }, [documentId]);
+
   // 在编辑器范围内接管撤销/重做快捷键，避免影响聊天输入框。
   useEffect(() => {
     const handleKeyDown = (event: KeyboardEvent) => {

src/components/ExportRecordList/ExportRecordList.tsx

@@ -17,6 +17,7 @@ import {
   downloadExportRecord,
   deleteExportRecord,
 } from '../../services/exportRecordService';
+import { EXPORT_RECORD_CREATED_EVENT } from '../../services/exportService';
 import type { ExportRecord } from '../../types/export';
 
 const { Text } = Typography;
@@ -105,28 +106,18 @@ const ExportRecordList: React.FC<ExportRecordListProps> = ({
 
   // Fetch records on mount and when page changes
   useEffect(() => {
-    let canceled = false;
+    const refresh = () => {
+      setLoading(true);
+      void fetchRecords();
+    };
 
-    listExportRecords({ userId, page, pageSize, sortOrder: 'desc' })
-      .then((response) => {
-        if (canceled) return;
-        setRecords(response.records);
-        setTotal(response.pagination.total);
-      })
-      .catch(() => {
-        if (canceled) return;
-        message.error('加载导出记录失败');
-        setRecords([]);
-        setTotal(0);
-      })
-      .finally(() => {
-        if (!canceled) setLoading(false);
-      });
+    window.addEventListener(EXPORT_RECORD_CREATED_EVENT, refresh);
+    void fetchRecords();
 
     return () => {
-      canceled = true;
+      window.removeEventListener(EXPORT_RECORD_CREATED_EVENT, refresh);
     };
-  }, [userId, page]);
+  }, [fetchRecords]);
 
   /**
    * Handle download button click

src/services/aiChatService.ts

@@ -71,23 +71,17 @@ export interface ChatCompletionResponse {
  */
 interface AIChatConfig {
   apiUrl: string;
-  apiKey: string;
 }
 
 /**
  * Get AI Chat configuration from environment variables
  */
 const getAIChatConfig = (): AIChatConfig => {
-  const isDevelopment = import.meta.env.DEV;
   return {
-    apiUrl: isDevelopment ? import.meta.env.VITE_AI_API_URL : import.meta.env.VITE_AI_PROXY_URL,
-    apiKey: isDevelopment ? import.meta.env.VITE_AI_API_KEY : '',
+    apiUrl: import.meta.env.VITE_AI_PROXY_URL,
   };
 };
 
-const getAuthorizationHeaders = (apiKey: string): Record<string, string> =>
-  apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
-
 /**
  * Send a chat completion request to AI platform
  *
@@ -112,7 +106,6 @@ export const sendChatCompletion = async (
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        ...getAuthorizationHeaders(config.apiKey),
       },
       body: JSON.stringify({
         chatId: request.chatId,
@@ -176,7 +169,6 @@ export const sendStreamingChatCompletion = async (
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        ...getAuthorizationHeaders(config.apiKey),
       },
       body: JSON.stringify({
         ...request,

src/services/blockService.ts

@@ -29,6 +29,9 @@ import type {
 
 const BLOCKS_BASE_URL = '/api/v1/documents';
 
+export const BLOCK_UPDATED_EVENT = 'ax:block-updated';
+export const BLOCK_DELETED_EVENT = 'ax:block-deleted';
+
 function encodeResourceId(value: string, name: string): string {
   const hasUnsafeCharacter = Array.from(value).some((character) => {
     const codePoint = character.codePointAt(0) ?? 0;

src/services/exportService.ts

@@ -19,6 +19,8 @@ import apiClient, { getErrorMessage, isApiError } from './api';
 import type { ApiResponse } from '../types/api';
 import type { ExportDocRequest, ExportDocResponse } from '../types/export';
 
+export const EXPORT_RECORD_CREATED_EVENT = 'ax:export-record-created';
+
 /**
  * Export document to Word format
  *
@@ -36,7 +38,10 @@ export const exportToWord = async (request: ExportDocRequest): Promise<ExportDoc
   try {
     const response = await apiClient.post<ApiResponse<ExportDocResponse>>(
       '/api/v1/export/doc',
-      request
+      request,
+      {
+        timeout: 120000,
+      }
     );
 
     const data = response.data.data;
@@ -61,6 +66,7 @@ export const exportToWord = async (request: ExportDocRequest): Promise<ExportDoc
       }
     }
 
+    window.dispatchEvent(new Event(EXPORT_RECORD_CREATED_EVENT));
     return data;
   } catch (error: unknown) {
     let friendlyMessage = '导出Word文档失败';

src/services/webMcpAgentService.ts

@@ -301,6 +301,79 @@ const documentActionHelp = (content: string): string => {
 	return '请补充要操作的文档名称或文档块信息。';
 };
 
+const formatBlockContent = (content: unknown): string => {
+	if (typeof content === 'string') return content.trim();
+	if (Array.isArray(content)) {
+		return content
+			.map((part) => {
+				if (typeof part === 'string') return part;
+				if (part && typeof part === 'object' && typeof (part as { text?: unknown }).text === 'string') {
+					return (part as { text: string }).text;
+				}
+				return '';
+			})
+			.join('')
+			.trim();
+	}
+	if (content && typeof content === 'object') {
+		const title = (content as { title?: unknown }).title;
+		if (typeof title === 'string' && title.trim()) return title.trim();
+		try {
+			return JSON.stringify(content);
+		} catch {
+			return '';
+		}
+	}
+	return '';
+};
+
+const formatSearchResult = (documentLabel: string, data: unknown): string => {
+	if (!data || typeof data !== 'object') return `未找到“${documentLabel}”中的匹配内容。`;
+	const payload = data as { blocks?: unknown; total?: unknown; query?: unknown };
+	const blocks = Array.isArray(payload.blocks) ? payload.blocks : [];
+	const total = typeof payload.total === 'number' ? payload.total : blocks.length;
+	const query = typeof payload.query === 'string' ? payload.query : '';
+	if (!blocks.length) {
+		return `在“${documentLabel}”中未找到${query ? `包含“${query}”的` : ''}内容。`;
+	}
+
+	const lines = blocks.slice(0, 20).map((block, index) => {
+		if (!block || typeof block !== 'object') return `${index + 1}. （无法读取内容）`;
+		const item = block as { id?: unknown; type?: unknown; content?: unknown };
+		const id = typeof item.id === 'string' ? item.id : '未知块';
+		const type = typeof item.type === 'string' ? item.type : '内容块';
+		const content = formatBlockContent(item.content).replace(/\s+/g, ' ').trim();
+		const preview = content.length > 500 ? `${content.slice(0, 500)}...` : content;
+		return `${index + 1}. 【${type}】${preview || '（无可显示内容）'}\n   块 ID：${id}`;
+	});
+	const suffix = total > blocks.length ? `\n\n仅显示前 ${blocks.length} 条，共找到 ${total} 条。` : '';
+	return `在“${documentLabel}”中找到 ${total} 条${query ? `包含“${query}”的` : ''}内容：\n${lines.join('\n')}\n${suffix}`.trim();
+};
+
+const getDocumentUrl = (documentId: string): string => {
+	const url = new URL(window.location.href);
+	url.searchParams.set('documentId', documentId);
+	return url.toString();
+};
+
+const formatDocumentListResult = (data: unknown): string => {
+	if (!data || typeof data !== 'object') return '暂无可查看的文档。';
+	const payload = data as { documents?: unknown; pagination?: { total?: unknown } };
+	const documents = Array.isArray(payload.documents) ? payload.documents : [];
+	if (!documents.length) return '暂无可查看的文档。';
+
+	const lines = documents.map((document, index) => {
+		if (!document || typeof document !== 'object') return `${index + 1}. 文档信息无效`;
+		const item = document as { id?: unknown; updatedAt?: unknown };
+		const documentId = typeof item.id === 'string' ? item.id : '';
+		if (!documentId) return `${index + 1}. 文档 ID 缺失`;
+		const updatedAt = typeof item.updatedAt === 'string' ? `（更新于 ${item.updatedAt}）` : '';
+		return `${index + 1}. ${documentId}${updatedAt}\n   ${getDocumentUrl(documentId)}`;
+	});
+	const total = typeof payload.pagination?.total === 'number' ? payload.pagination.total : documents.length;
+	return `共找到 ${total} 个文档：\n${lines.join('\n')}`;
+};
+
 const friendlyResult = (
 	toolName: string,
 	input: Record<string, unknown>,
@@ -310,9 +383,10 @@ const friendlyResult = (
 	const documentId = typeof input.documentId === 'string' ? input.documentId : '';
 	const blockId = typeof input.blockId === 'string' ? input.blockId : '';
 	const documentLabel = typeof input.documentTitle === 'string' ? input.documentTitle : documentId;
+	if (toolName === 'list_documents') return formatDocumentListResult(result.data);
 	if (toolName === 'open_document') return `已帮您打开“${documentLabel || '指定'}”文档。`;
 	if (toolName === 'get_document') return `已读取“${documentLabel || documentId}”文档内容。`;
-	if (toolName === 'search_document') return `已完成“${documentLabel || documentId}”文档搜索。`;
+	if (toolName === 'search_document') return formatSearchResult(documentLabel || documentId, result.data);
 	if (toolName === 'update_block') return `已修改“${documentLabel || documentId}”中的区块 ${blockId}。`;
 	if (toolName === 'delete_block') return `已删除“${documentLabel || documentId}”中的区块 ${blockId}。`;
 	if (toolName === 'insert_block') return `已向“${documentLabel || documentId}”插入新的内容块。`;
@@ -332,7 +406,7 @@ export const executeWebMcpChatCommand = async (content: string): Promise<WebMcpC
 	}
 
 	const matched = matchWebMcpChatTemplate(content);
-	const localCommand = await parseLocalDocumentCommand(content);
+	const localCommand = matched ? { handled: false as const } : await parseLocalDocumentCommand(content);
 	if (localCommand.handled && localCommand.command) {
 		const tool = getWebMcpTool(localCommand.command.toolName);
 		if (!tool) return { handled: true, response: `WebMCP 工具不存在：${localCommand.command.toolName}` };
@@ -418,7 +492,7 @@ export const confirmAndExecuteWebMcpChatCommand = async (
 ): Promise<WebMcpChatResult> => {
 	if (typeof contentOrCommand !== 'string') {
 		if (!contentOrCommand.toolName || !contentOrCommand.input) return { handled: false };
-		const result = await executeWebMcpTool(contentOrCommand.toolName, contentOrCommand.input);
+		const result = await executeWebMcpTool(contentOrCommand.toolName, contentOrCommand.input, { confirmed: true });
 		return {
 			handled: true,
 			toolName: contentOrCommand.toolName,
@@ -433,7 +507,8 @@ export const confirmAndExecuteWebMcpChatCommand = async (
 		};
 	}
 	const content = contentOrCommand;
-	const localCommand = await parseLocalDocumentCommand(content);
+	const matched = matchWebMcpChatTemplate(content);
+	const localCommand = matched ? { handled: false as const } : await parseLocalDocumentCommand(content);
 	if (localCommand.command) {
 		const { toolName, input, documentTitle } = localCommand.command;
 		const result = await executeWebMcpTool(toolName, input);
@@ -446,14 +521,13 @@ export const confirmAndExecuteWebMcpChatCommand = async (
 			response: friendlyResult(toolName, { ...input, documentTitle }, result),
 		};
 	}
-	const matched = matchWebMcpChatTemplate(content);
 	if (!matched?.template.toolName) {
 		try {
 			const translated = await translateInput(content);
 			const toolCall = translated.translation.toolCall;
 			if (!toolCall) return { handled: false };
 			const input = { ...toolCall.arguments };
-			const result = await executeWebMcpTool(toolCall.name, input);
+			const result = await executeWebMcpTool(toolCall.name, input, { confirmed: true });
 			return {
 				handled: true,
 				toolName: toolCall.name,

src/services/webMcpService.ts

@@ -6,6 +6,7 @@ import type { BlockType, CreateBlockRequest, UpdateBlockRequest } from '../types
 import type { DocumentListFilters } from '../types/document';
 import { useUIStore } from '../stores/uiStore';
 import { finishWebMcpActivity, startWebMcpActivity } from './webMcpActivityService';
+import { BLOCK_DELETED_EVENT, BLOCK_UPDATED_EVENT } from './blockService';
 
 export interface WebMcpToolResult {
 	ok: boolean;
@@ -48,11 +49,18 @@ export interface WebMcpRegistrationResult {
 	error?: string;
 }
 
+export interface WebMcpExecutionOptions {
+	confirmed?: boolean;
+}
+
 const DEFAULT_USER_ID = import.meta.env.VITE_WEBMCP_USER_ID || 'default-user';
 let registrationPromise: Promise<WebMcpRegistrationResult> | undefined;
 
 const text = (data: unknown): WebMcpToolResult => ({ ok: true, data });
 
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+	typeof value === 'object' && value !== null && !Array.isArray(value);
+
 const failed = (error: unknown): WebMcpToolResult => ({
 	ok: false,
 	error: error instanceof Error ? error.message : 'WebMCP 工具执行失败',
@@ -188,7 +196,7 @@ const tools: WebMcpTool[] = [
 		readOnlyHint: true,
 		untrustedContentHint: true,
 		inputSchema: objectSchema(
-			{ documentId: documentIdProperty, query: { type: 'string', description: '搜索关键词' }, type: { type: 'string' } },
+			{ documentId: documentIdProperty, query: { type: 'string', description: '搜索关键词', maxLength: 2000 }, type: { type: 'string', maxLength: 64 } },
 			['documentId', 'query']
 		),
 		execute: (input) =>
@@ -243,7 +251,7 @@ const tools: WebMcpTool[] = [
 			{
 				documentId: documentIdProperty,
 				type: { type: 'string', enum: ['heading', 'paragraph', 'table', 'image', 'toc'] },
-				content: { type: 'string', description: '块内容' },
+				content: { type: 'string', description: '块内容', maxLength: 200000 },
 				level: { type: 'number', minimum: 1, maximum: 6 },
 				afterBlockId: { type: 'string', description: '插入到此块之后，可选' },
 			},
@@ -267,8 +275,15 @@ const tools: WebMcpTool[] = [
 		requiresConfirmation: true,
 		inputSchema: objectSchema({ documentId: documentIdProperty, blockId: blockIdProperty, content: { type: 'string', description: '新的块内容' } }, ['documentId', 'blockId', 'content']),
 		execute: (input) => run(() => {
+			const documentId = requiredString(input, 'documentId');
+			const blockId = requiredString(input, 'blockId');
 			const updates: UpdateBlockRequest = { content: requiredString(input, 'content') };
-			return blockService.updateBlock(requiredString(input, 'documentId'), requiredString(input, 'blockId'), updates);
+			return blockService.updateBlock(documentId, blockId, updates).then((result) => {
+				window.dispatchEvent(new CustomEvent(BLOCK_UPDATED_EVENT, {
+					detail: { documentId, blockId, updates },
+				}));
+				return result;
+			});
 		}),
 	},
 	{
@@ -277,7 +292,16 @@ const tools: WebMcpTool[] = [
 		description: '删除指定文档块。需要用户确认。',
 		requiresConfirmation: true,
 		inputSchema: objectSchema({ documentId: documentIdProperty, blockId: blockIdProperty }, ['documentId', 'blockId']),
-		execute: (input) => run(() => blockService.deleteBlock(requiredString(input, 'documentId'), requiredString(input, 'blockId')).then(() => ({ message: 'Block deleted successfully' }))),
+		execute: (input) => run(() => {
+			const documentId = requiredString(input, 'documentId');
+			const blockId = requiredString(input, 'blockId');
+			return blockService.deleteBlock(documentId, blockId).then(() => {
+				window.dispatchEvent(new CustomEvent(BLOCK_DELETED_EVENT, {
+					detail: { documentId, blockId },
+				}));
+				return { message: 'Block deleted successfully' };
+			});
+		}),
 	},
 	{
 		name: 'export_document',
@@ -325,8 +349,12 @@ export const getWebMcpTool = (name: string): WebMcpTool | undefined => tools.fin
 
 export const executeWebMcpTool = async (
 	name: string,
-	input: Record<string, unknown>
+	input: unknown,
+	options: WebMcpExecutionOptions = {}
 ): Promise<WebMcpToolResult> => {
+	if (!isRecord(input)) {
+		return { ok: false, error: 'WebMCP 工具参数必须是对象' };
+	}
 	const activityId = startWebMcpActivity(name, input);
 	const tool = getWebMcpTool(name);
 	if (!tool) {
@@ -334,6 +362,11 @@ export const executeWebMcpTool = async (
 		finishWebMcpActivity(activityId, result);
 		return result;
 	}
+	if (tool.requiresConfirmation && !options.confirmed) {
+		const result = { ok: false, error: '该 WebMCP 工具需要当前页面用户确认' };
+		finishWebMcpActivity(activityId, result);
+		return result;
+	}
 	const validationError = validateToolInput(tool, input);
 	if (validationError) {
 		const result = { ok: false, error: validationError };

src/services/workflowService.ts

@@ -74,25 +74,17 @@ interface WorkflowResponse {
  */
 interface WorkflowConfig {
   apiUrl: string;
-  apiKey: string;
 }
 
 /**
  * Get Workflow configuration from environment variables
  */
 const getWorkflowConfig = (): WorkflowConfig => {
-  const isDevelopment = import.meta.env.DEV;
   return {
-    apiUrl: isDevelopment
-      ? import.meta.env.VITE_WORKFLOW_API_URL
-      : import.meta.env.VITE_WORKFLOW_PROXY_URL,
-    apiKey: isDevelopment ? import.meta.env.VITE_WORKFLOW_API_KEY : '',
+    apiUrl: import.meta.env.VITE_WORKFLOW_PROXY_URL,
   };
 };
 
-const getAuthorizationHeaders = (apiKey: string): Record<string, string> =>
-  apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
-
 /**
  * Check if user input should trigger document generation workflow
  *
@@ -137,7 +129,7 @@ export const triggerDocumentWorkflow = async (
   try {
     const config = getWorkflowConfig();
 
-    if (!config.apiUrl || !config.apiKey) {
+    if (!config.apiUrl) {
       return { content: '工作流未配置，无法生成文档。请检查前端环境配置。' };
     }
 
@@ -156,7 +148,6 @@ export const triggerDocumentWorkflow = async (
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        ...getAuthorizationHeaders(config.apiKey),
       },
       body: JSON.stringify({
         chatId: uniqueChatId, // 带时间戳的唯一ID，避免工作流缓存

src/share/webmcp/bridge.ts

@@ -1,4 +1,4 @@
-import { executeWebMcpTool, getWebMcpTool, getWebMcpTools, type WebMcpToolResult } from '../../services/webMcpService';
+import { executeWebMcpTool, getWebMcpTools, type WebMcpToolResult } from '../../services/webMcpService';
 import { finishWebMcpActivity, startWebMcpActivity } from '../../services/webMcpActivityService';
 
 interface BridgeToolCall {
@@ -11,6 +11,8 @@ interface BridgeToolCall {
 const MAX_BRIDGE_MESSAGE_LENGTH = 256 * 1024;
 const MAX_BRIDGE_RESULT_LENGTH = 512 * 1024;
 const MAX_IN_FLIGHT_CALLS = 8;
+const MAX_RECONNECT_ATTEMPTS = 6;
+const RECONNECT_BASE_DELAY_MS = 1000;
 const pendingRequestIds = new Set<string>();
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
@@ -54,8 +56,14 @@ const getBridgeUrl = (): string => {
 };
 
 const clientId = import.meta.env.VITE_WEBMCP_CLIENT_ID || `ax-editor-${crypto.randomUUID()}`;
-const bridgeToken = import.meta.env.VITE_WEBMCP_BRIDGE_TOKEN || '';
+// The static token is a local-development fallback only; production uses a session ticket.
+const developmentBridgeToken = import.meta.env.DEV
+  ? import.meta.env.VITE_WEBMCP_BRIDGE_TOKEN || ''
+  : '';
 let socket: WebSocket | undefined;
+let connectionPending = false;
+let reconnectTimer: number | undefined;
+let reconnectAttempts = 0;
 
 const getApiUrl = (path: string): string => {
   const base = import.meta.env.VITE_API_BASE_URL || window.location.origin;
@@ -63,25 +71,56 @@ const getApiUrl = (path: string): string => {
 };
 
 const getBridgeTicket = async (): Promise<string | undefined> => {
-  if (bridgeToken) return bridgeToken;
-  const response = await fetch(getApiUrl('/api/v1/webmcp/bridge/ticket'), {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    credentials: 'include',
-    body: JSON.stringify({ clientId }),
-  });
+  let response: Response;
+  try {
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+    if (developmentBridgeToken) headers['X-WebMCP-Token'] = developmentBridgeToken;
+    response = await fetch(getApiUrl('/api/v1/webmcp/bridge/ticket'), {
+      method: 'POST',
+      headers,
+      credentials: 'include',
+      body: JSON.stringify({ clientId }),
+    });
+  } catch {
+    return undefined;
+  }
   if (!response.ok) return undefined;
-  const payload = (await response.json()) as { data?: { ticket?: string } };
-  return payload.data?.ticket;
+  try {
+    const payload = (await response.json()) as { data?: { ticket?: string } };
+    return typeof payload.data?.ticket === 'string' ? payload.data.ticket : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const scheduleReconnect = (): void => {
+  if (reconnectTimer !== undefined || reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) return;
+  const delay = RECONNECT_BASE_DELAY_MS * 2 ** reconnectAttempts;
+  reconnectAttempts += 1;
+  reconnectTimer = window.setTimeout(() => {
+    reconnectTimer = undefined;
+    connectWebMcpBridge();
+  }, delay);
 };
 
 export const connectWebMcpBridge = (): WebSocket | undefined => {
-  if (socket) return socket;
+  if (socket || connectionPending || reconnectTimer !== undefined) return socket;
+  connectionPending = true;
   void getBridgeTicket().then((ticket) => {
-    if (!ticket || socket) return;
+    connectionPending = false;
+    if (!ticket || socket) {
+      if (!socket) scheduleReconnect();
+      return;
+    }
     const socketUrl = `${getBridgeUrl()}/${encodeURIComponent(clientId)}?token=${encodeURIComponent(ticket)}`;
-    socket = new WebSocket(socketUrl);
+    try {
+      socket = new WebSocket(socketUrl);
+    } catch {
+      scheduleReconnect();
+      return;
+    }
     socket.addEventListener('open', () => {
+      reconnectAttempts = 0;
       socket?.send(JSON.stringify({
         type: 'register',
         clientId,
@@ -101,18 +140,7 @@ export const connectWebMcpBridge = (): WebSocket | undefined => {
     pendingRequestIds.add(call.requestId);
     let result: WebMcpToolResult;
     try {
-      const tool = getWebMcpTool(call.tool);
-      if (!tool) {
-        const activityId = startWebMcpActivity(call.tool, call.arguments);
-        result = { ok: false, error: `未知的 WebMCP 工具: ${call.tool}` };
-        finishWebMcpActivity(activityId, result);
-      } else if (tool.requiresConfirmation) {
-        const activityId = startWebMcpActivity(call.tool, call.arguments);
-        result = { ok: false, error: '该 WebMCP 工具需要当前页面用户确认' };
-        finishWebMcpActivity(activityId, result);
-      } else {
-        result = await executeWebMcpTool(call.tool, call.arguments);
-      }
+      result = await executeWebMcpTool(call.tool, call.arguments);
     } catch (error) {
       const activityId = startWebMcpActivity(call.tool, call.arguments);
       result = { ok: false, error: error instanceof Error ? error.message : '工具执行失败' };
@@ -134,10 +162,14 @@ export const connectWebMcpBridge = (): WebSocket | undefined => {
     socket.addEventListener('close', () => {
       pendingRequestIds.clear();
       socket = undefined;
+      scheduleReconnect();
     });
     socket.addEventListener('error', () => {
       socket?.close();
     });
+  }).catch(() => {
+    connectionPending = false;
+    scheduleReconnect();
   });
   return socket;
 };

src/share/webmcp/translator.ts

@@ -1,5 +1,7 @@
 import type { WebMcpTranslationContext, WebMcpTranslationResponse } from './types';
 
+const TRANSLATION_TIMEOUT_MS = 30000;
+
 const getTranslatorUrl = (): string => {
   const baseUrl = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8000';
   return `${baseUrl.replace(/\/$/, '')}/api/v1/webmcp/translate`;
@@ -10,7 +12,7 @@ export const translateWebMcpInput = async (
   context: WebMcpTranslationContext = {}
 ): Promise<WebMcpTranslationResponse> => {
   const controller = new AbortController();
-  const timeoutId = window.setTimeout(() => controller.abort(), 15000);
+  const timeoutId = window.setTimeout(() => controller.abort(), TRANSLATION_TIMEOUT_MS);
   let response: Response;
   try {
     response = await fetch(getTranslatorUrl(), {
@@ -20,6 +22,11 @@ export const translateWebMcpInput = async (
       body: JSON.stringify({ input, context }),
       signal: controller.signal,
     });
+  } catch (error) {
+    if (error instanceof DOMException && error.name === 'AbortError') {
+      throw new Error('WebMCP 转译请求超时，请稍后重试', { cause: error });
+    }
+    throw error;
   } finally {
     window.clearTimeout(timeoutId);
   }
@@ -29,13 +36,29 @@ export const translateWebMcpInput = async (
     throw new Error(`WebMCP 转译失败 (${response.status}): ${detail}`);
   }
 
-  const payload = (await response.json()) as {
-    data?: WebMcpTranslationResponse;
-  };
-  if (!payload.data?.translation) {
+  let payload: { data?: WebMcpTranslationResponse };
+  try {
+    payload = (await response.json()) as { data?: WebMcpTranslationResponse };
+  } catch {
+    throw new Error('WebMCP 转译响应不是有效 JSON');
+  }
+  const translation = payload.data?.translation;
+  if (!translation || typeof translation !== 'object') {
     throw new Error('WebMCP 转译响应格式无效');
   }
-  return payload.data;
+  if (translation.toolCall) {
+    if (typeof translation.toolCall.name !== 'string' || !translation.toolCall.name.trim()) {
+      throw new Error('WebMCP 转译工具名称无效');
+    }
+    if (
+      typeof translation.toolCall.arguments !== 'object'
+      || translation.toolCall.arguments === null
+      || Array.isArray(translation.toolCall.arguments)
+    ) {
+      throw new Error('WebMCP 转译工具参数无效');
+    }
+  }
+  return { ...payload.data, translation };
 };
 
 export type { WebMcpTranslationContext, WebMcpTranslationResponse } from './types';

src/stores/editorStore.ts

@@ -262,6 +262,12 @@ interface EditorStore {
    */
   updateBlock: (id: string, updates: BlockUpdate) => void;
 
+  /** 应用来自聊天/WebMCP 的已保存块更新 */
+  applyRemoteBlockUpdate: (id: string, updates: BlockUpdate) => void;
+
+  /** 应用来自聊天/WebMCP 的已保存块删除 */
+  applyRemoteBlockDelete: (id: string) => void;
+
   /**
    * 标记文档已修改
    */
@@ -1273,6 +1279,60 @@ export const useEditorStore = create<EditorStore>((set, get) => {
       }
     },
 
+    // ── applyRemoteBlockUpdate ─────────────────────────────────────────────
+    applyRemoteBlockUpdate: (id: string, updates: BlockUpdate) => {
+      const { documentId, blocks, blockHashes, dirtyBlocks, pendingBlockUpdates } = get();
+      const blockIndex = blocks.findIndex((block) => block.id === id);
+      if (!documentId || blockIndex < 0) return;
+
+      const updatedBlocks = blocks.slice();
+      updatedBlocks[blockIndex] = { ...updatedBlocks[blockIndex], ...updates } as DocumentBlock;
+      const updatedHash = computeBlockHash(updatedBlocks[blockIndex]);
+      const updatedHashes = new Map(blockHashes);
+      updatedHashes.set(id, updatedHash);
+      const updatedDirtyBlocks = new Set(dirtyBlocks);
+      updatedDirtyBlocks.delete(id);
+      const updatedPending = new Map(pendingBlockUpdates);
+      updatedPending.delete(id);
+      const snapshot = JSON.stringify(updatedBlocks);
+
+      set({
+        blocks: updatedBlocks,
+        blockHashes: updatedHashes,
+        dirtyBlocks: updatedDirtyBlocks,
+        pendingBlockUpdates: updatedPending,
+        hasModified: updatedDirtyBlocks.size > 0,
+        originalBlocksSnapshot: snapshot,
+        lastSavedSnapshot: snapshot,
+      });
+    },
+
+    // ── applyRemoteBlockDelete ─────────────────────────────────────────────
+    applyRemoteBlockDelete: (id: string) => {
+      const { documentId, blocks, blockHashes, dirtyBlocks, pendingBlockUpdates } = get();
+      if (!documentId || !blocks.some((block) => block.id === id)) return;
+
+      const updatedBlocks = blocks.filter((block) => block.id !== id);
+      const updatedHashes = new Map(blockHashes);
+      updatedHashes.delete(id);
+      const updatedDirtyBlocks = new Set(dirtyBlocks);
+      updatedDirtyBlocks.delete(id);
+      const updatedPending = new Map(pendingBlockUpdates);
+      updatedPending.delete(id);
+      const snapshot = JSON.stringify(updatedBlocks);
+
+      set({
+        blocks: updatedBlocks,
+        blockHashes: updatedHashes,
+        dirtyBlocks: updatedDirtyBlocks,
+        pendingBlockUpdates: updatedPending,
+        selectedBlockId: get().selectedBlockId === id ? null : get().selectedBlockId,
+        hasModified: updatedDirtyBlocks.size > 0,
+        originalBlocksSnapshot: snapshot,
+        lastSavedSnapshot: snapshot,
+      });
+    },
+
     // ── deleteBlock ─────────────────────────────────────────────────────────
     deleteBlock: async (id: string) => {
       const {

vite.config.ts

@@ -1,9 +1,13 @@
-import { defineConfig } from 'vite';
+import { defineConfig, loadEnv } from 'vite';
 import react from '@vitejs/plugin-react';
 import { visualizer } from 'rollup-plugin-visualizer';
 
 // https://vite.dev/config/
-export default defineConfig({
+export default defineConfig(({ mode }) => {
+  const env = loadEnv(mode, process.cwd(), '');
+  const apiTarget = env.VITE_API_BASE_URL || 'http://localhost:8000';
+
+  return {
   plugins: [
     react(),
     
@@ -56,12 +60,24 @@ export default defineConfig({
     host: true,
     strictPort: true,
     open: false,
+    proxy: {
+      '/api': {
+        target: apiTarget,
+        changeOrigin: true,
+      },
+    },
   },
 
   preview: {
     port: 4173,
     host: true,
     strictPort: true,
+    proxy: {
+      '/api': {
+        target: apiTarget,
+        changeOrigin: true,
+      },
+    },
   },
 
   // 依赖预构建优化
@@ -79,4 +95,5 @@ export default defineConfig({
       'mammoth',
     ],
   },
+  };
 });