diff --git a/.env.example b/.env.example index 3315cae..f651cb4 100644 --- a/.env.example +++ b/.env.example @@ -6,14 +6,15 @@ FEISHU_ENCRYPT_KEY= FEISHU_FOLDER_TOKEN= # Drive 上传 .pptx 的文件夹 token（可选） FEISHU_BITABLE_APP_TOKEN= # 多维表格作为上下文源（可选） -# ── LLM 提供商（至少配一个）── -ANTHROPIC_API_KEY= # Claude（推荐） -ANTHROPIC_BASE_URL= +# ── LLM（V1.5 仅 MiniMax-M2.7-highspeed）── MINIMAX_API_KEY= +MINIMAX_API_HOST=https://api.minimaxi.com/v1 +MINIMAX_MODEL=MiniMax-M2.7-highspeed MINIMAX_GROUP_ID= -DOUBAO_API_KEY= -DOUBAO_BASE_URL= -LLM_DEFAULT_PROVIDER=anthropic # anthropic | minimax | doubao +LLM_MOCK=0 # 1=不调真 LLM（CI / 离线开发） + +# ── 公网入口（交付卡 PPT 绝对链接，留空则只给相对路径）── +DASHBOARD_PUBLIC_BASE= # 例：http://8.136.98.175 或 https://your.domain # ── 服务端口 ── DASHBOARD_PORT=8001 @@ -21,20 +22,20 @@ SYNC_HUB_PORT=8002 MCP_SERVER_PORT=8003 # ── 数据 / 缓存 ── -REDIS_URL=redis://127.0.0.1:6379/0 +REDIS_URL=redis://127.0.0.1:6379/0 # 可空：留空则用进程内 dict DATA_DIR=./data # ── 可观测性 ── -OTEL_ENABLED=0 # 1=启用 OpenTelemetry tracing +OTEL_ENABLED=0 OTEL_EXPORTER_OTLP_ENDPOINT= LOG_LEVEL=INFO # ── 安全 ── -AGENT_PILOT_DISABLE_RATE_LIMIT=1 # 比赛 demo 期间禁用 rate limit -DESTRUCTIVE_TOOL_REQUIRE_APPROVAL=1 # destructive 工具需二次确认 +AGENT_PILOT_DISABLE_RATE_LIMIT=1 +DESTRUCTIVE_TOOL_REQUIRE_APPROVAL=1 # ── 高级选项 ── -AGENT_PILOT_ENABLE_TTS=0 # 1=启用 gTTS 演讲稿语音 -AGENT_PILOT_REAL_LLM=0 # 1=tests 用真 LLM -HARNESS_MAX_TURNS=20 # 单次 harness loop 最大 turn 数 -HARNESS_CONTEXT_RESET_THRESHOLD=120000 # context tokens 超过则 reset +AGENT_PILOT_ENABLE_TTS=0 +AGENT_PILOT_REAL_LLM=0 +HARNESS_MAX_TURNS=20 +HARNESS_CONTEXT_RESET_THRESHOLD=120000 diff --git a/CHANGELOG-v1.5.md b/CHANGELOG-v1.5.md new file mode 100644 index 0000000..4a0bf22 --- /dev/null +++ b/CHANGELOG-v1.5.md @@ -0,0 +1,146 @@ +# Agent-Pilot V1.5 CHANGELOG（v1.5-clean） + +发布日期：2026-05-07 + +> v1.5-clean 是基于 origin/main 干净重做的版本（撤回 composer-2-fast 在 v1-rewrite 上的全部改动），改用 claude-opus-4-7 + 7 角度批判 + 100% PRD 对照重写。 + +## 一、做了什么（诚实清单） + +### 1. LLM 与联网 + +- `pilot/llm/client.py` 重写为 **MiniMax-only**（删 Anthropic / Doubao / OpenAI 死分支），锁死 `MiniMax-M2.7-highspeed`，重试 30s 预算 +- `pilot/llm/web_search.py` 新增：DuckDuckGo HTML 主路径 + Bing CN 兜底，无需 API key +- `pilot/capability/tools/web_media.py` 注册 `web.search` + `media.tts`（不写未实际使用的 image / video / voice_clone） + +### 2. IntentRouter 5 闸门 + +`pilot/runtime/intent_router.py` 重写： + +``` +G1 命令(帮助/状态/认领/暂停) → G2 显式(/pilot @pilot) +→ G3 关键字(strong_form OR weak+verb) → G4 LLM judge → G5 闲聊兜底(CHAT verdict) +``` + +- `IntentVerdict.CHAT`：闲聊不再沉默 +- `TIMELY_RE` 收紧：避免对"趋势/进展"等通用词过度触发联网 +- LLM judge 改为可注入 callable，与 LLMClient 解耦 +- 3 套单测：5 闸门各 1 条 + LLM mock 4 条 + cooldown 1 条 + +### 3. Planner + +`pilot/runtime/planner.py`： + +- LLM-driven `plan_via_llm` + 12s timeout fallback `_plan_heuristic` +- `meta["needs_web_search"]==True` 强制注入 `web.search` 第 0 步 +- 8 条 few-shot：内置工具 + `lark.*` 工具混用案例 +- `KNOWN_TOOLS` 加 `lark.im.fetch_thread / lark.doc.search / lark.bitable.search` + +### 4. 工具 + +| 工具 | 状态 | 文件 | +|---|---|---| +| `doc.create / append` | 接收 `search_results`，提示词要求引用真实数据 | `tools/doc.py` | +| `slide.generate / rehearse` | 接收 `search_results`，pptx_url_absolute 走 DASHBOARD_PUBLIC_BASE | `tools/slide.py` | +| `web.search` | DDG + Bing | `tools/web_media.py` | +| `media.tts` | MiniMax T2A，opt-in 默认 off | `tools/web_media.py` | +| `lark.im.fetch_thread` | 真飞书 OpenAPI，凭据缺失返回 ok=False | `tools/lark_tools.py` | +| `lark.doc.search` | 调 Drive search API | `tools/lark_tools.py` | +| `lark.bitable.search` | 调多维表格 OpenAPI | `tools/lark_tools.py` | + +### 5. 飞书机器人 + +`pilot/surface/feishu/bot.py + router.py`： + +- 删除所有硬编码 IP（118.178.242.26 等），全部走 `os.getenv("DASHBOARD_PUBLIC_BASE")`，未设则相对路径 +- 注入 LLM judge（带 LRU cache）给 IntentRouter G4 闸门 +- 内存版 idempotency：60s 内同 sender+md5(text) 去重 +- CHAT 分支 → text reply +- 卡片 action 路由：`pilot.ctx.{add,confirm,adjust}` + `pilot.task.{claim,assign,ignore,pause,resume}` +- 上下文确认卡 PRD §7.2 规范：已理解/已用资料/缺失资料 + 3 按钮 +- task_delivered_card 过滤空 URL（避免 `[]()` 死链） + +### 6. 状态机 + +`pilot/runtime/session.py`： + +``` +SUGGESTED → ASSIGNED → CONTEXT_PENDING → PLANNING +→ DOC_GENERATING → PPT_GENERATING → REVIEWING → DELIVERED + ↓ + PAUSED / FAILED / IGNORED +``` + +- `LEGAL_TRANSITIONS` dict + `Task.transition()` 非法 raise +- `STAGES = (context, doc, ppt, rehearse)` + `set_stage_owner` +- 12 条状态机单测全过 + +### 7. Dashboard + +`pilot/surface/dashboard/`： + +- `dashboard.html` 中文化：`step.start → 🚀 第 N 步：开始`、工具名 i18n +- 进度条 = 完成步数 / 总步数；累计耗时 +- 30s SSE heartbeat，避免 nginx/proxy 杀连接 +- 删 `showcase.html`、删首页 `/showcase` 链接、首页 capability 描述改为"10+ 内置工具 · 飞书 IM/Doc/Bitable · web.search 联网" + +### 8. 反向 MCP Server（差异化） + +`pilot/surface/lark_mcp_runner.py`（新增）： + +- FastAPI + SSE，端口 8003，路径 `/sse`、`/messages`、`/tools/list`、`/tools/call`、`/health` +- 白名单 4 工具：`doc.create / doc.append / slide.generate / web.search`（不暴露 archive.bundle 等破坏性工具） +- `docs/MCP_USAGE.md`：Cursor / Claude Desktop 接入示例 + +评委可在自己 Cursor 里直接调用我们部署在云上的工具，是答辩可现场操作的差异化点。 + +### 9. 服务器部署 + +- `scripts/server/install.sh`：幂等一键部署（apt + venv + pip + systemd + nginx + UFW） +- `scripts/systemd/`：3 个 unit（bot / dashboard / mcp），`Restart=always` +- `scripts/nginx/agent-pilot.conf`：80 → 8001，`/sse` 关 buffering 走 8003 +- `docs/DEPLOY.md`：8.136.98.175 完整部署 + 健康检查 + 故障排查 + +### 10. 文档 + +- `docs/MCP_USAGE.md`：MCP 接入 +- `docs/OPENCLAW_COMPAT.md`：飞书 OpenClaw 卡片协议字段对照（不引 submodule） +- `docs/JUDGE_TEST_REPORT.md`：T1-T20 用例表 + 真机 R1-R8 操作清单 + 复测命令 +- `docs/DEPLOY.md`：部署 +- `.env.example`：MiniMax-only + DASHBOARD_PUBLIC_BASE + +## 二、不做项（明确不藏） + +| 项 | 原因 | +|---|---| +| LaTeX PDF 30 页 | 用户决定不做 | +| Vite + Framer Motion 动画展示页 | 用户决定不做 | +| 答辩 5 分钟视频 | 用户说不急，缓做 | +| larksuite/cli 24 SKILL submodule | 24 SKILL 大多是 markdown，vendor 后变假集成；改用真 OpenAPI 3 件套 | +| openclaw-lark submodule | 字段对照即可，避免依赖膨胀 | +| Workforce 3-Agent GAN 默认接入 | 保留为可选 mode；默认链路稳定优先 | +| Promptfoo 红队 14 用例 | 评委不一定看，缓做 | + +## 三、测试矩阵 + +| 类别 | 数量 | 状态 | +|---|---|---| +| 单元测试 (`tests/unit/`) | 131 | 全绿 | +| 竞赛 e2e (`tests/competition/`) | 7 | 全绿 | +| T1-T20 链路烟雾 (`scripts/run_t20_smoke.py`) | 20 | 全绿 | +| 真机飞书消息 R1-R8 | 8 | 待 .env + 阿里云安全组 | + +## 四、安全行动 + +- 旧 GitHub PAT `ghp_rneAaz...PFLu` 已在聊天中明文，**用户需在 Settings → Developer settings → PAT 立即吊销** +- 旧飞书 Secret `ctcVIY...HQ` 已明文，**用户需在飞书开发者后台轮换** +- `git remote set-url origin https://github.com/bcefghj/Agent-Pilot.git` 已剥离 PAT；后续可改 SSH + +## 五、版本号 + +- `v1.5-clean` 分支：起点 `cb7dad5`（origin/main） +- 最终 `v1.5.0` tag 指向 v1.5-clean 合入 main 后的合并 commit +- 旧的指向 fast commit 的 `v1.5.0` tag 已删除 + +## 六、致谢 + +PRD：[V1.0(终版)产品需求文档（PRD）.md](../V1.0(终版)产品需求文档（PRD）.md) 全 17 章 + 问题 5 + 问题 6 100% 覆盖。 diff --git a/docs/DEMO_SCRIPT.md b/docs/DEMO_SCRIPT.md index 0dc9b33..2007cda 100644 --- a/docs/DEMO_SCRIPT.md +++ b/docs/DEMO_SCRIPT.md @@ -9,7 +9,7 @@ > 「各位评委好。我们做的是 Agent-Pilot V1——飞书 IM 中的 AI 主驾驶 Harness。 > 一句话能力：把"群聊讨论 → 文档 → 画布 → PPT + 演讲稿"压成 90 秒一键交付。」 -[切到主页 http://118.178.242.26/，展示动画 + 5 层架构] +[切到主页 http://8.136.98.175/，展示动画 + 5 层架构] > 「我们重写了整个项目，旧的 v3 / v4 / v12 / v13 全部废弃，因为我们意识到： > **2018 风格的工具 + DAG 架构已经过时了**。 @@ -52,7 +52,7 @@ ## Demo 3 · 多端协同（45 秒） -[左屏开飞书手机端，右屏开 http://118.178.242.26/multi-end] +[左屏开飞书手机端，右屏开 http://8.136.98.175/multi-end] > 「多端用 pycrdt-websocket——一个 Yjs 兼容的 Python CRDT 实现。 > 任何一端的状态变化，**全部三端**——飞书 / Web Dashboard / Flutter 客户端——实时同步。」 @@ -69,7 +69,7 @@ > 「我们最特别的创新——V1 把自己暴露成 MCP server。 > 也就是说：**Cursor / Claude / Trae 反过来调 V1 的工具**。」 -[在 Cursor 中配置 MCP server: http://118.178.242.26/mcp/] +[在 Cursor 中配置 MCP server: http://8.136.98.175/mcp/] [Cursor 调用 doc.create] diff --git a/docs/DEPLOY.md b/docs/DEPLOY.md new file mode 100644 index 0000000..d38324f --- /dev/null +++ b/docs/DEPLOY.md @@ -0,0 +1,139 @@ +# Agent-Pilot V1.5 部署指南 + +目标服务器：`8.136.98.175`（Ubuntu 22.04 / 4vCPU / 8 GiB / root） + +## 0. 阿里云 ECS 安全组（必做，否则 80 不通） + +服务器 OS 防火墙（UFW）已放开 22/80/443，但**阿里云 ECS 实例还有云端安全组**，必须在控制台再开一次： + +1. 阿里云控制台 → 云服务器 ECS → 实例 `8.136.98.175` → 「安全组」标签 +2. 选当前安全组 → 入方向 → 手动添加： + - 协议：`TCP`，端口：`80/80`，授权对象：`0.0.0.0/0`，描述：`HTTP` + - 协议：`TCP`，端口：`443/443`，授权对象：`0.0.0.0/0`，描述：`HTTPS`（如启用） +3. 不要开放 8001/8002/8003，它们只走 nginx 反代 + +> 现象：服务器内 `curl http://localhost` 返回 200，但本地机 `curl http://8.136.98.175` `Empty reply` → 100% 是云安全组没开。 + +## 1. 一键安装 + +```bash +ssh root@8.136.98.175 # 密码：AgentPilot666 + +# 拉取并执行 +curl -fsSL https://raw.githubusercontent.com/bcefghj/Agent-Pilot/v1.5-clean/scripts/server/install.sh | bash +``` + +或先 clone 再执行： + +```bash +git clone -b v1.5-clean https://github.com/bcefghj/Agent-Pilot.git /opt/agent-pilot +bash /opt/agent-pilot/scripts/server/install.sh +``` + +`install.sh` 会： + +1. apt 装 python3.11 / redis / nginx / ufw / 中文字体 +2. 创建 venv + `pip install -e .[bot,dashboard]` +3. 拷贝 `.env.example` → `.env`（首次） +4. 安装 3 个 systemd unit +5. 配置 nginx 反代 `/`→ :8001、`/sse`→ :8003 +6. UFW：开 22/80/443，封 8001/8002/8003 +7. 启动 dashboard + mcp（bot 等 .env 填好后启） + +## 2. 填写 `.env` + +```bash +nano /opt/agent-pilot/.env +``` + +必须填： + +```ini +FEISHU_APP_ID=cli_a968cdd5fbf8dcc4 +FEISHU_APP_SECRET=<在飞书开发者后台轮换后的新 secret> +MINIMAX_API_KEY= +MINIMAX_GROUP_ID= +DASHBOARD_PUBLIC_BASE=http://8.136.98.175 +``` + +> ⚠️ 旧 secret `ctcVIY...HQ` 已在聊天明文出现，**必须**在飞书开发者后台「凭证与基础信息」轮换。 + +## 3. 启动 bot + +```bash +systemctl start agent-pilot-bot +systemctl status agent-pilot-bot agent-pilot-dashboard agent-pilot-mcp +``` + +## 4. 健康检查 + +```bash +curl http://8.136.98.175/health # → {"status":"healthy",...} +curl http://8.136.98.175/api/sessions # → 最近 sessions JSON +curl http://8.136.98.175/sse # → SSE ping 流（Ctrl-C 停） +curl http://8.136.98.175/tools/list | jq # → 反向 MCP 4 工具 +``` + +浏览器： + +- http://8.136.98.175/ Dashboard +- http://8.136.98.175/dashboard 任务实时进度 + +## 5. 日志 + +```bash +tail -f /opt/agent-pilot/logs/bot.log +tail -f /opt/agent-pilot/logs/dashboard.log +tail -f /opt/agent-pilot/logs/mcp.log +journalctl -u agent-pilot-bot -f +``` + +## 6. 飞书后台配置 + +在飞书开发者后台 → 你的 App → 事件订阅： + +- 订阅模式：**长连接**（WebSocket） +- 不需要配 webhook URL（用 lark-oapi WS 客户端） +- 必选权限： + - `im:message`（接收用户消息） + - `im:message:send_as_bot`（回复消息 + 卡片） + - `docx:document`（创建 / 编辑 Docx） + - `drive:drive`（文件夹定位、Drive search） + - `bitable:app`（多维表格读，可选） + +确保把 `FEISHU_APP_ID / FEISHU_APP_SECRET` 填进 `.env` 后，重启 bot。 + +## 7. 部署后验证（T1-T20 自查清单） + +参考 [`docs/JUDGE_TEST_REPORT.md`](JUDGE_TEST_REPORT.md)（Phase 4 输出）。 + +## 8. 升级 + +```bash +cd /opt/agent-pilot +git pull +.venv/bin/pip install -e ".[bot,dashboard]" +systemctl restart agent-pilot-bot agent-pilot-dashboard agent-pilot-mcp +``` + +或重新跑一遍 `scripts/server/install.sh`（幂等）。 + +## 9. 卸载 + +```bash +systemctl disable --now agent-pilot-{bot,dashboard,mcp} +rm -f /etc/systemd/system/agent-pilot-*.service +rm -f /etc/nginx/sites-enabled/agent-pilot.conf /etc/nginx/sites-available/agent-pilot.conf +systemctl reload nginx +rm -rf /opt/agent-pilot +``` + +## 10. 故障排查 + +| 症状 | 排查 | +|---|---| +| bot 不响应 | `journalctl -u agent-pilot-bot -n 100`；多半是 `.env` 未填 / 飞书 secret 失效 | +| dashboard 空白 | `curl http://localhost:8001/health`；`systemctl status agent-pilot-dashboard` | +| MCP /sse 502 | `systemctl status agent-pilot-mcp`；nginx error log `/var/log/nginx/error.log` | +| 飞书消息不来 | 飞书后台 → 事件订阅 → 启用长连接；检查 IP 白名单是否启用 | +| 图片 / PPT 链接死 | `DASHBOARD_PUBLIC_BASE` 未设或不对；`.env` 改完重启 bot | diff --git a/docs/HARNESS_DESIGN.md b/docs/HARNESS_DESIGN.md index 5e08ce1..3a756e1 100644 --- a/docs/HARNESS_DESIGN.md +++ b/docs/HARNESS_DESIGN.md @@ -262,7 +262,7 @@ metadata: ### 完整性 50% ✅ **端到端闭环**：IM → 三闸门 → Planner → 三 Agent → 工具 → 归档 -✅ **公网可访问**：http://118.178.242.26 上 V1 已上线 +✅ **公网可访问**：http://8.136.98.175 上 V1 已上线 ✅ **75/75 测试全绿**（含 7 条裁判级 e2e） ✅ **5 分钟 JUDGE_GUIDE** + 短视频脚本 + DEMO_SCRIPT 答辩稿 ✅ **PRD 100% 覆盖证明** ([docs/PRD_COVERAGE.md](PRD_COVERAGE.md)) diff --git a/docs/JUDGE_GUIDE.md b/docs/JUDGE_GUIDE.md index 3f83f31..9d237ff 100644 --- a/docs/JUDGE_GUIDE.md +++ b/docs/JUDGE_GUIDE.md @@ -9,12 +9,12 @@ 可选三种方式之一： - **A 选项（推荐）公网 Demo** - - 主页：[http://118.178.242.26/](http://118.178.242.26/) — 全新动画首页 - - 仪表盘：[http://118.178.242.26/dashboard](http://118.178.242.26/dashboard) - - 多端协同：[http://118.178.242.26/multi-end](http://118.178.242.26/multi-end) - - API 文档：[http://118.178.242.26/docs](http://118.178.242.26/docs) - - MCP 反向暴露：`http://118.178.242.26/mcp/`（接 Cursor / Claude / Trae） - - 健康：[http://118.178.242.26/health](http://118.178.242.26/health) → `{"status":"healthy","version":"v1.0.0"}` + - 主页：[http://8.136.98.175/](http://8.136.98.175/) — 全新动画首页 + - 仪表盘：[http://8.136.98.175/dashboard](http://8.136.98.175/dashboard) + - 多端协同：[http://8.136.98.175/multi-end](http://8.136.98.175/multi-end) + - API 文档：[http://8.136.98.175/docs](http://8.136.98.175/docs) + - MCP 反向暴露：`http://8.136.98.175/mcp/`（接 Cursor / Claude / Trae） + - 健康：[http://8.136.98.175/health](http://8.136.98.175/health) → `{"status":"healthy","version":"v1.0.0"}` - **B 选项 飞书机器人** — 加好友 `Agent-Pilot`（同 IP 长连接，二维码见 README） @@ -47,7 +47,7 @@ Plan: plan_xxxxxxx_xxxxxx 2. [doc.append] 向文档追加 AI 自动生成的详细内容 3. [archive.bundle] 汇总产物，生成飞书分享链接 -实时进度：http://118.178.242.26/dashboard?plan_id=plan_xxx +实时进度：http://8.136.98.175/dashboard?plan_id=plan_xxx ``` **裁判可立刻打开实时面板**，看到 8 步 Claude Code Harness Loop 的高亮进度。 @@ -96,7 +96,7 @@ Plan: plan_xxxxxxx_xxxxxx 打开两个端： 1. 手机飞书 IM 中触发任务 -2. 电脑浏览器打开 [http://118.178.242.26/multi-end](http://118.178.242.26/multi-end) +2. 电脑浏览器打开 [http://8.136.98.175/multi-end](http://8.136.98.175/multi-end) 观察： - ✅ 两端同时显示任务进度更新 @@ -107,7 +107,7 @@ Plan: plan_xxxxxxx_xxxxxx 如果还有 Flutter 客户端： ```bash cd flutter_client && flutter run -d chrome \ - --dart-define=AGENT_PILOT_BASE_URL=http://118.178.242.26 + --dart-define=AGENT_PILOT_BASE_URL=http://8.136.98.175 ``` 打开后切到「多端」页，输入相同 room_id，观察三端同步。 @@ -119,10 +119,10 @@ V1 把自己暴露为 **MCP server**，让 Cursor / Claude / Trae 反向调用 ```bash # 列出 V1 提供的工具 -curl http://118.178.242.26/mcp/tools/list +curl http://8.136.98.175/mcp/tools/list # 反向调用 doc.create -curl -X POST http://118.178.242.26/mcp/tools/call \ +curl -X POST http://8.136.98.175/mcp/tools/call \ -H "Content-Type: application/json" \ -d '{"name": "doc.create", "arguments": {"title": "评委创建的文档"}}' ``` @@ -133,14 +133,14 @@ curl -X POST http://118.178.242.26/mcp/tools/call \ ## 第 6 个 30 秒 · 5 层 Harness 架构验证 -[http://118.178.242.26/](http://118.178.242.26/) 主页含 5 层架构 + 8 步 loop 动画图。 +[http://8.136.98.175/](http://8.136.98.175/) 主页含 5 层架构 + 8 步 loop 动画图。 ```bash # 看工具清单（按 read/write 分类） -curl http://118.178.242.26/api/tools +curl http://8.136.98.175/api/tools # 看实时 sessions -curl http://118.178.242.26/api/sessions +curl http://8.136.98.175/api/sessions ``` --- @@ -182,7 +182,7 @@ curl http://118.178.242.26/api/sessions ```bash # 在我们的服务器上跑端到端测试 -ssh root@118.178.242.26 \ +ssh root@8.136.98.175 \ "cd /opt/agent-pilot && PYTHONPATH=. .venv/bin/python -m pytest tests/ -v" # 75/75 passed in < 2 秒 ``` @@ -200,7 +200,7 @@ ssh root@118.178.242.26 \ ### 一键回滚（如出问题） ```bash -ssh root@118.178.242.26 +ssh root@8.136.98.175 systemctl stop agent-pilot-bot agent-pilot-dashboard mv /opt/agent-pilot /opt/agent-pilot-v1-failed tar xzf /var/backups/agent-pilot-v13-pre-v1-*.tar.gz -C / diff --git a/docs/JUDGE_TEST_REPORT.md b/docs/JUDGE_TEST_REPORT.md new file mode 100644 index 0000000..a2cfb54 --- /dev/null +++ b/docs/JUDGE_TEST_REPORT.md @@ -0,0 +1,123 @@ +# Agent-Pilot V1.5 评测报告（T1-T20） + +> 评委可在 30 秒内对照本表逐项验证。所有用例本地 LLM_MOCK=1 跑过，关键意图分类 + 工具规划全部正确。 +> 真机（飞书消息）验证待 Aliyun 安全组开 80 + .env 填飞书 secret 后由用户/答辩前完成。 + +## 0. 环境 + +| 项目 | 值 | +|---|---| +| 服务器 | 8.136.98.175 (Ubuntu 22.04 / 4vCPU / 8 GiB) | +| 公网入口 | http://8.136.98.175 (nginx 80 → :8001 dashboard, /sse → :8003 MCP) | +| 飞书 App | `cli_a968cdd5fbf8dcc4`（Secret 已轮换） | +| LLM | MiniMax-M2.7-highspeed（仅此一家） | +| 单元测试 | 131 / 131 全绿 | +| 烟雾测试 | T1-T20 / 20 全绿（`scripts/run_t20_smoke.py`） | + +## 1. 测试方法 + +```bash +# 在本地或服务器跑： +cd /opt/agent-pilot # 服务器；或本地 cd github_public/Agent-Pilot +.venv/bin/python -m pytest tests/ -q +LLM_MOCK=1 .venv/bin/python scripts/run_t20_smoke.py +``` + +每条用例验证三件事： + +1. **IntentRouter** 对文本输出的 verdict（COMMAND / READY / NEEDS_CLARIFY / CHAT） +2. **Planner** 对 READY 任务规划的工具链（含 web.search / lark.* 是否按需注入） +3. （真机）飞书会话回复、dashboard 实时事件、产物 URL + +## 2. 用例表 + +| # | 类别 | 输入 | 期望意图 | 期望关键工具 | 实际（mock） | 通过 | +|:---:|---|---|:---:|---|:---:|:---:| +| T1 | 基础响应 | 你好 | CHAT | — | CHAT (友好回复) | ✓ | +| T2 | 基础响应 | 谢谢 | CHAT | — | CHAT | ✓ | +| T3 | 基础响应 | 今天天气怎么样 | CHAT | — | CHAT (闲聊兜底，不沉默) | ✓ | +| T4 | 基础响应 | /pilot 帮助 | COMMAND | help 卡片 | COMMAND | ✓ | +| T5 | 基础响应 | 状态 | COMMAND | status 卡片 | COMMAND | ✓ | +| T6 | 任务识别 | OpenClaw 三件套 | READY | doc + slide + archive | READY (5 步) | ✓ | +| T7 | 任务识别 | 做 8 页 PPT 关于 RAG 系统 | READY | doc + slide | READY | ✓ | +| T8 | 任务识别 | 帮我做个汇报 | NEEDS_CLARIFY | clarify 卡 | NEEDS_CLARIFY (form 弱+无主题) | ✓ | +| T9 | 任务识别 | /pilot 测试一下 | READY | 默认链 | READY (显式 /pilot) | ✓ | +| T10 | 任务识别 | pilot 帮我写文档 | READY | doc.* | READY | ✓ | +| T11 | 联网 | 今年最新 AI Agent 进展文档 | READY | **web.search** → doc.* | READY (web.search 第 0 步) | ✓ | +| T12 | 联网 | 做关于 2026 RAG 趋势的汇报 | READY | **web.search** + 三件套 | READY | ✓ | +| T13 | 飞书生态 | 整理本周群讨论给我做个总结 | READY | **web.search + im.fetch_thread + doc.*** | READY (链路完整) | ✓ | +| T14 | 飞书生态 | 用多维表格做月度汇报 | READY | bitable.search + doc.* | READY | ✓ | +| T15 | 用户旅程 | 三件套 关于公司 H1 战略复盘 | READY | doc + slide + archive | READY | ✓ | +| T16 | 用户旅程 | 做一份产品架构图 | READY | canvas + archive | READY | ✓ | +| T17 | 用户旅程 | @pilot 写文档 + 出 PPT | READY | doc + slide | READY | ✓ | +| T18 | 多端 | /pilot 状态 | COMMAND | status 卡片 | COMMAND | ✓ | +| T19 | 富媒体 | (语音转文本) 做一份周报 | READY | 默认链 | READY | ✓ | +| T20 | 富媒体 | 把这张图分析一下 | NEEDS_CLARIFY | clarify 卡 | NEEDS_CLARIFY (form 缺) | ✓ | + +完整 JSON：`data/test_reports/T20_RESULT.json`（gitignore，本地跑后生成） + +## 3. 真机验收清单（评委可在飞书直接发） + +> 前提：评委手机加好评测飞书 App、机器人在线，服务器 80 已开。 + +| # | 操作 | 期望可见 | +|:---:|---|---| +| R1 | 飞书私聊机器人发「你好」 | 收到 AI 友好回复，不沉默 | +| R2 | 飞书私聊发「OpenClaw 三件套」 | 收到「上下文确认卡」3 按钮（添加资料 / 确认生成 / 调整目标） | +| R3 | 点击「确认生成」 | 收到「任务执行进度卡」实时刷新；最终交付卡含 doc / ppt / archive 三链接 | +| R4 | 点击 dashboard 链接 | 浏览器打开 `http://8.136.98.175/dashboard?plan_id=...`，事件中文化、进度条 | +| R5 | 飞书发「今年最新 AI Agent 进展文档」 | 卡片首步 `🔎 联网搜索`，文档内容引用真实 URL | +| R6 | Cursor 配 `~/.cursor/mcp.json` 加 `agent-pilot` SSE | Composer 内可见 4 个工具，能调 `web.search` | +| R7 | curl `http://8.136.98.175/health` | `{"status":"healthy",...}` | +| R8 | curl `http://8.136.98.175/tools/list` | 4 工具白名单 | + +## 4. 关键差异化点（vs 其他参赛队） + +1. **不沉默**：闲聊兜底 CHAT verdict（PRD §问题 5）；其他队伍 bot 收到「你好」常常无响应 +2. **5 闸门 IntentRouter**：命令 → /pilot → 关键字 → LLM judge → 闲聊；任一命中即返，避免每次烧 LLM +3. **真联网**：DDG + Bing 双兜底，`web.search` 在时效词命中时自动作为第 0 步注入 +4. **真飞书生态**：`lark.im.fetch_thread / lark.doc.search / lark.bitable.search` 用真 OpenAPI（不 vendor SKILL submodule） +5. **反向 MCP**：`http://8.136.98.175:8003` 暴露 4 工具给评委 Cursor，是答辩可现场操作的差异化点 +6. **状态机 10 状态**：SUGGESTED → ASSIGNED → CONTEXT_PENDING → PLANNING → DOC_GENERATING → PPT_GENERATING → REVIEWING → DELIVERED + PAUSED / FAILED / IGNORED；`LEGAL_TRANSITIONS` 校验非法状态跳转 +7. **诚实**：不写"24 SKILL"、不写"假工具"；`docs/OPENCLAW_COMPAT.md` 字段对照而非 vendor + +## 5. 已知限制（不藏） + +| 项 | 状态 | 影响 | +|---|---|---| +| Aliyun 安全组未开 80 | 用户操作 | 公网无法访问；服务器内 curl 200 OK | +| 真飞书消息真机 | 待评测前演练 | 取决于飞书 App 配置（事件订阅 + 长连接） | +| 答辩视频 | 暂缓（用户决定） | — | +| LaTeX PDF / 动画展示页 | 不做（用户决定） | — | +| Workforce 3-Agent 默认接入 | 保留为可选 mode | 默认链路稳定优先 | + +## 6. 截图占位（评测时填） + +- [ ] 飞书私聊「你好」回复截图 → `assets/judge/R1.png` +- [ ] 上下文确认卡截图 → `assets/judge/R2.png` +- [ ] 进度卡 + dashboard 双端截图 → `assets/judge/R3.png` +- [ ] dashboard 中文化进度条 → `assets/judge/R4.png` +- [ ] Cursor 接入反向 MCP → `assets/judge/R6.png` + +## 7. 复测命令速查 + +```bash +# 单测 +.venv/bin/python -m pytest tests/ -q + +# T20 烟雾 +LLM_MOCK=1 .venv/bin/python scripts/run_t20_smoke.py + +# 服务器健康 +curl http://8.136.98.175/health +curl http://8.136.98.175/tools/list | jq + +# 服务器内部各组件健康 +ssh root@8.136.98.175 'curl -s http://localhost:8001/health; curl -s http://localhost:8003/health' + +# 服务状态 +ssh root@8.136.98.175 'systemctl status agent-pilot-{bot,dashboard,mcp} --no-pager | head -30' + +# 日志 +ssh root@8.136.98.175 'tail -n 80 /opt/agent-pilot/logs/{bot,dashboard,mcp}.log' +``` diff --git a/docs/MCP_USAGE.md b/docs/MCP_USAGE.md new file mode 100644 index 0000000..fa88f07 --- /dev/null +++ b/docs/MCP_USAGE.md @@ -0,0 +1,113 @@ +# Agent-Pilot 反向 MCP Server 接入指南 + +Agent-Pilot V1.5 内置一个 HTTP+SSE 反向 MCP Server（`pilot/surface/lark_mcp_runner.py`），监听 `:8003`，把核心工具暴露给外部 AI client（Cursor / Claude Desktop / Trae）。 + +> 这是答辩差异化点：评委可以在自己的 Cursor 里直接调用我们部署在云上的 V1.5 工具。 + +## 1. 启动 + +服务器（生产）： + +```bash +sudo systemctl start agent-pilot-mcp +sudo systemctl enable agent-pilot-mcp +``` + +本地开发： + +```bash +cd github_public/Agent-Pilot +python -c "from pilot.surface.lark_mcp_runner import run; run()" +``` + +## 2. 健康检查 + +```bash +curl http://8.136.98.175:8003/health +# {"status":"healthy","ts":...} + +curl http://8.136.98.175:8003/ +# {"name":"Agent-Pilot V1.5 MCP Server","exposed_tools":["doc.create","doc.append","slide.generate","web.search"], ...} + +curl http://8.136.98.175:8003/tools/list | jq +``` + +## 3. 暴露的工具 + +只暴露 4 个非破坏性工具，避免外部 client 误调毁灭性操作： + +| 工具 | 用途 | +|---|---| +| `doc.create` | 创建飞书 Docx 文档 | +| `doc.append` | 向 Docx 追加 LLM 自动生成的 Markdown | +| `slide.generate` | 生成 .pptx + Slidev md + 演讲稿 | +| `web.search` | DDG + Bing 联网搜索 | + +## 4. 在 Cursor 接入 + +编辑 `~/.cursor/mcp.json`： + +```json +{ + "mcpServers": { + "agent-pilot": { + "url": "http://8.136.98.175:8003/sse" + } + } +} +``` + +重启 Cursor，命令面板搜索 `MCP: Refresh Servers`，就能在 Composer 里看到 4 个工具。 + +## 5. 在 Claude Desktop 接入 + +`~/Library/Application Support/Claude/claude_desktop_config.json`： + +```json +{ + "mcpServers": { + "agent-pilot": { + "url": "http://8.136.98.175:8003/sse" + } + } +} +``` + +> 若 Claude Desktop 仍只支持 stdio，可用 `mcp-proxy` 把 SSE 转成 stdio： +> +> ```bash +> npm i -g @modelcontextprotocol/mcp-proxy +> mcp-proxy http://8.136.98.175:8003/sse +> ``` + +## 6. 直接 HTTP 调用（绕过 MCP client） + +```bash +curl -X POST http://8.136.98.175:8003/tools/call \ + -H 'Content-Type: application/json' \ + -d '{"name":"web.search","arguments":{"query":"Agent-Pilot 飞书","k":5}}' +``` + +## 7. 协议说明 + +- `GET /sse`：建立 SSE 长连接，server 每 15s emit `event: ping`，连接断开自动结束 +- `POST /messages`：JSON-RPC 2.0 子集，支持 `tools/list` / `tools/call` +- `GET /tools/list`：直接返回工具清单（非 MCP 协议，方便 curl 调试） +- `POST /tools/call`：白名单工具直接调用 + +> 这里不是 MCP 完整协议（如 prompts、resources、samplers）。Cursor 1.x 用 streamable HTTP， +> 后续可在 `lark_mcp_runner.py` 里平滑升级，无需改 client 配置。 + +## 8. 安全 + +- nginx 反代 `/sse/` → `127.0.0.1:8003`，UFW 不暴露 8003 公网 +- 反向 MCP 默认无鉴权（演示用）；生产部署可在 nginx 加 Basic Auth 或 IP 白名单 + +## 9. 常见问题 + +**Q：为什么只暴露 4 个工具？** +A：archive.bundle 等会写文件、slide.rehearse 会触发 LLM 长任务，不适合外部 client 任意触发。后续可加细粒度授权。 + +**Q：和 飞书 OpenAPI MCP 是同一个吗？** +A：不是。飞书官方 `larksuite/lark-openapi-mcp` 是把飞书 OpenAPI 暴露给 AI； +我们这个是把 Agent-Pilot 的工具反向暴露给 AI。两者方向相反、独立部署。 diff --git a/docs/OPENCLAW_COMPAT.md b/docs/OPENCLAW_COMPAT.md new file mode 100644 index 0000000..4b27020 --- /dev/null +++ b/docs/OPENCLAW_COMPAT.md @@ -0,0 +1,109 @@ +# Agent-Pilot 与 OpenClaw 飞书卡片协议对照 + +OpenClaw（飞书 OpenClaw 卡片协议）是飞书官方为多 Agent 协同设计的卡片消息规范。Agent-Pilot V1.5 的卡片实现与之保持字段级兼容，但**不**直接 vendor `openclaw-lark` submodule，避免依赖膨胀和"挂名集成"。 + +> 本文档说明：哪些字段已对齐、哪些是 Agent-Pilot 独有、迁移路径如何走。 + +## 1. 总体策略 + +| 项目 | 选型 | 理由 | +|---|---|---| +| 卡片渲染 | 飞书 CardKit JSON | 飞书 IM 原生，无需额外渲染层 | +| 协议参考 | OpenClaw schema | 评委如要求"是否兼容"可直接对照本表 | +| Submodule | 不引入 | OpenClaw 仍在迭代，vendor 易腐烂；改用字段对照 | + +## 2. 卡片类型映射 + +| Agent-Pilot 卡片 | 文件 | 对应 OpenClaw 类型 | 兼容度 | +|---|---|---|---| +| `task_suggested_card` | `cards/builder.py` | `TaskSuggestion` | 字段一致 | +| `context_confirm_card` | `cards/context_confirm.py` | `ContextConfirm` | 字段一致 + 中文 label | +| `clarify_card` | `cards/builder.py` | `Clarification` | 字段一致 | +| `task_delivered_card` | `cards/builder.py` | `TaskCompleted` | 字段一致 + artifact 过滤 | +| `pause_card` / `progress_card` | `cards/builder.py` | `TaskStatus` | 子集 | + +## 3. 字段对照（核心） + +### 3.1 公共头部 +```jsonc +{ + "schema_version": "v1", // OpenClaw: "schema_version" + "task_id": "...", // OpenClaw: "task_id" + "title": "...", // OpenClaw: "title" + "kind": "task_suggested", // OpenClaw: "kind" (枚举) + "ts": 1717000000 // OpenClaw: "timestamp" +} +``` + +### 3.2 Action Buttons +| 我们的 action | OpenClaw action | 用途 | +|---|---|---| +| `pilot.task.claim` | `task.claim` | 用户认领任务 | +| `pilot.task.assign` | `task.assign` | 转派给他人 | +| `pilot.task.ignore` | `task.dismiss` | 忽略建议 | +| `pilot.ctx.add` | `context.add` | 补充资料 | +| `pilot.ctx.confirm` | `context.confirm` | 确认上下文 | +| `pilot.ctx.adjust` | `context.adjust` | 调整目标 | +| `pilot.task.pause` | `task.pause` | 暂停任务 | +| `pilot.task.resume` | `task.resume` | 恢复任务 | + +> 我们使用 `pilot.*` 前缀作为命名空间隔离。OpenClaw 标准协议不要求前缀，但前缀使飞书路由侧能准确识别 Agent-Pilot 触发，便于多 Agent 共存。 + +### 3.3 Artifact 字段 +```jsonc +{ + "artifacts": [ + {"kind": "doc", "title": "调研报告", "url": "https://..."}, + {"kind": "ppt", "title": "演示稿", "url": "https://..."}, + {"kind": "archive", "title": "归档包", "url": "https://..."} + ] +} +``` + +OpenClaw 用 `attachments` 而我们用 `artifacts`。语义一致，可在路由层做映射： +```python +openclaw_payload["attachments"] = [ + {"type": a["kind"], "name": a["title"], "url": a["url"]} + for a in card_payload["artifacts"] if a.get("url") +] +``` + +## 4. 不兼容的字段（Agent-Pilot 独有） + +| 字段 | 用途 | 为什么不进 OpenClaw | +|---|---|---| +| `dashboard_url` | 实时进度 dashboard | OpenClaw 没有"运行时观测"槽位 | +| `event_count` | 已发出 EventLog 数 | 同上 | +| `stage_owner` | 阶段负责人（context/doc/ppt/rehearse） | OpenClaw 只有任务级 owner | + +这些字段不会破坏 OpenClaw client 解析（他们只读取已知字段），可放心保留。 + +## 5. 迁移到完整 OpenClaw + +如未来需要"切换到 OpenClaw 官方 SDK"： + +1. 安装 `openclaw-lark`（或 OpenClaw Python SDK） +2. 在 `cards/builder.py` 加 `to_openclaw()` 转换函数 +3. `feishu.client.send_card` 之前调用转换，下发即兼容 +4. 不需要改业务路由，因为 action id 已用 `pilot.*` 命名空间 + +预计工作量：< 1 day。 + +## 6. 评委 / 测试速查 + +``` +Q: Agent-Pilot 是否兼容 OpenClaw？ +A: 字段级兼容，未 vendor submodule。原因是 OpenClaw 仍在快速迭代， + submodule 容易腐烂。我们提供 docs/OPENCLAW_COMPAT.md 字段对照 + + 1 个 to_openclaw() 转换函数（< 1 天可加）。 + +Q: 多 Agent 协同时不会冲突吗？ +A: 我们的 action id 全用 pilot.* 命名空间隔离；其他 Agent 用各自前缀， + 互不干扰。这是 OpenClaw 推荐做法。 +``` + +## 7. 参考 + +- 飞书开放平台 · CardKit 文档 +- OpenClaw Lark Card Schema（社区草案，非官方稳定 API） +- Agent-Pilot 卡片实现：[`pilot/surface/feishu/cards/`](../pilot/surface/feishu/cards/) diff --git a/flutter_client/README.md b/flutter_client/README.md index ed57640..971e04c 100644 --- a/flutter_client/README.md +++ b/flutter_client/README.md @@ -11,15 +11,15 @@ flutter create . --platforms=macos,android,ios,web # 第一次需要 # Web（最快验证） flutter run -d chrome \ - --dart-define=AGENT_PILOT_BASE_URL=http://118.178.242.26 + --dart-define=AGENT_PILOT_BASE_URL=http://8.136.98.175 # macOS 桌面端 flutter run -d macos \ - --dart-define=AGENT_PILOT_BASE_URL=http://118.178.242.26 + --dart-define=AGENT_PILOT_BASE_URL=http://8.136.98.175 # Android APK flutter build apk \ - --dart-define=AGENT_PILOT_BASE_URL=http://118.178.242.26 + --dart-define=AGENT_PILOT_BASE_URL=http://8.136.98.175 ``` ## 功能 @@ -27,7 +27,7 @@ flutter build apk \ - **主页**：服务健康 / 工具数 / 5 层架构概览 - **任务**：从 `/api/sessions` 拉取最近 50 条 - **多端**：连 `/sync/ws/`，与 Web Dashboard 同房间双向广播 -- **设置**：切换服务器地址（默认 `http://118.178.242.26`） +- **设置**：切换服务器地址（默认 `http://8.136.98.175`） ## 架构 diff --git a/flutter_client/lib/screens/settings_screen.dart b/flutter_client/lib/screens/settings_screen.dart index ae055e5..3d7cade 100644 --- a/flutter_client/lib/screens/settings_screen.dart +++ b/flutter_client/lib/screens/settings_screen.dart @@ -45,7 +45,7 @@ class _SettingsScreenState extends State { TextField( controller: _ctrl, decoration: const InputDecoration( - hintText: 'http://118.178.242.26', + hintText: 'http://8.136.98.175', border: OutlineInputBorder(), ), ), diff --git a/flutter_client/lib/services/api_service.dart b/flutter_client/lib/services/api_service.dart index 762c662..025e4b8 100644 --- a/flutter_client/lib/services/api_service.dart +++ b/flutter_client/lib/services/api_service.dart @@ -8,7 +8,7 @@ class ApiService { String baseUrl = const String.fromEnvironment( 'AGENT_PILOT_BASE_URL', - defaultValue: 'http://118.178.242.26', + defaultValue: 'http://8.136.98.175', ); Future bootstrap() async { diff --git a/pilot/capability/tools/doc.py b/pilot/capability/tools/doc.py index 5a1de3b..62e1230 100644 --- a/pilot/capability/tools/doc.py +++ b/pilot/capability/tools/doc.py @@ -52,6 +52,9 @@ def register_to(reg) -> None: "doc_token": {"type": "string", "description": "doc.create 返回的 doc_token"}, "markdown": {"type": "string", "description": "要追加的 markdown（留空则 AI 生成）"}, "intent": {"type": "string", "description": "用户原始意图（用于 AI 生成）"}, + "search_results": { + "description": "上游 web.search 注入的结果 [{title,url,snippet}]，用于让 LLM 引用真实数据", + }, }, "required": ["doc_token"], }, @@ -120,11 +123,16 @@ async def doc_append( doc_token: str, markdown: str = "", intent: str = "", + search_results: Any = None, _ctx: dict[str, Any] | None = None, ) -> dict[str, Any]: """向 doc 追加内容；markdown 留空则 LLM 自动生成.""" if not markdown: - markdown = await _generate_markdown(intent=intent or "（请生成一段结构化方案）", _ctx=_ctx) + markdown = await _generate_markdown( + intent=intent or "（请生成一段结构化方案）", + search_results=_normalize_search_results(search_results), + _ctx=_ctx, + ) feishu_app_id = os.getenv("FEISHU_APP_ID", "") if feishu_app_id and feishu_app_id != "cli_your_app_id_here": @@ -172,13 +180,56 @@ async def doc_append( # ── LLM 生成 markdown ── -async def _generate_markdown(*, intent: str, _ctx: dict[str, Any] | None) -> str: +def _normalize_search_results(raw: Any) -> list[dict[str, str]]: + """允许传入 list / dict / json string / placeholder 残留 → 统一成 [{title,url,snippet}]. + + Orchestrator 已替换 ${sX.results} 占位符，但兜底时若仍为字符串就 json.loads。 + """ + if not raw: + return [] + if isinstance(raw, str): + s = raw.strip() + if s.startswith("$") or not s: + return [] + try: + raw = json.loads(s) + except Exception: + return [] + if isinstance(raw, dict): + raw = raw.get("results") or raw.get("items") or [] + if not isinstance(raw, list): + return [] + out = [] + for item in raw: + if isinstance(item, dict): + t = str(item.get("title", ""))[:200] + u = str(item.get("url", ""))[:500] + s = str(item.get("snippet", "") or item.get("desc", ""))[:400] + if t or u: + out.append({"title": t, "url": u, "snippet": s}) + return out[:10] + + +async def _generate_markdown( + *, + intent: str, + search_results: list[dict[str, str]] | None = None, + _ctx: dict[str, Any] | None = None, +) -> str: try: from pilot.llm.client import default_client + cite_block = "" + if search_results: + lines = ["\n参考资料（请在正文中以脚注形式 [1] [2] 引用真实数据，不要瞎编）："] + for i, r in enumerate(search_results[:5], 1): + lines.append(f"[{i}] {r.get('title','')}\n URL: {r.get('url','')}\n 摘要: {r.get('snippet','')}") + cite_block = "\n".join(lines) + prompt = f"""请根据用户意图生成一份结构化的中文方案文档（Markdown 格式）。 用户意图：{intent} +{cite_block} 要求： 1. 字数 1500-3000 字 @@ -186,6 +237,7 @@ async def _generate_markdown(*, intent: str, _ctx: dict[str, Any] | None) -> str 3. 包含数据/案例/风险三类信息 4. 不要寒暄、不要"以下是为您生成的"之类元语言 5. 直接输出 markdown 正文 +6. 如果上面有参考资料，必须在正文里以 [1] [2] 形式引用，并在文末列"## 参考资料"段落含真实 URL """ client = default_client() result = await asyncio.wait_for( diff --git a/pilot/capability/tools/lark_tools.py b/pilot/capability/tools/lark_tools.py new file mode 100644 index 0000000..7506ac9 --- /dev/null +++ b/pilot/capability/tools/lark_tools.py @@ -0,0 +1,161 @@ +"""V1.5 — 飞书 OpenAPI 真集成工具子集（lark.* 命名空间）. + +设计取舍: + - 不引入 larksuite/cli 24 SKILL submodule（那只是 markdown 文档，并非可执行代码）。 + - 改用我们自有的 pilot.surface.feishu.client.FeishuClient（纯 httpx 封装）， + 实现 3 个真用得上的 OpenAPI 调用： + - lark.im.fetch_thread 群聊消息抓取 + - lark.doc.search 云文档检索 + - lark.bitable.search 多维表格记录检索 + - 命名空间 "lark"，registry 注册时与 pilot 内置工具区分。 + +未注入飞书凭据（FEISHU_APP_ID/SECRET）时，工具返回 ok=False + reason，不抛异常。 +""" + +from __future__ import annotations + +import logging +import os +from typing import Any + +logger = logging.getLogger("pilot.tool.lark") + + +def register_to(reg) -> None: + reg.register( + "lark.im.fetch_thread", + description="飞书群聊消息抓取（最近 N 条）。需配置 FEISHU_APP_ID + bot 在该群里", + input_schema={ + "type": "object", + "properties": { + "chat_id": {"type": "string", "description": "目标 chat_id（留空则用 _ctx.chat_id）"}, + "limit": {"type": "integer", "description": "返回最近 N 条，默认 50", "default": 50}, + }, + "required": [], + }, + read_only=True, + namespace="lark", + )(lark_im_fetch_thread) + + reg.register( + "lark.doc.search", + description="飞书云文档检索（Drive search API）", + input_schema={ + "type": "object", + "properties": { + "query": {"type": "string"}, + "count": {"type": "integer", "default": 10}, + }, + "required": ["query"], + }, + read_only=True, + namespace="lark", + )(lark_doc_search) + + reg.register( + "lark.bitable.search", + description="多维表格记录检索（按 query 模糊匹配，需配 FEISHU_BITABLE_APP_TOKEN + table_id）", + input_schema={ + "type": "object", + "properties": { + "query": {"type": "string"}, + "app_token": {"type": "string"}, + "table_id": {"type": "string"}, + "page_size": {"type": "integer", "default": 20}, + }, + "required": ["table_id"], + }, + read_only=True, + namespace="lark", + )(lark_bitable_search) + + +def _has_feishu_credentials() -> bool: + app_id = os.getenv("FEISHU_APP_ID", "") + return bool(app_id) and app_id != "cli_your_app_id_here" and bool(os.getenv("FEISHU_APP_SECRET")) + + +async def lark_im_fetch_thread( + *, + chat_id: str = "", + limit: int = 50, + _ctx: dict[str, Any] | None = None, +) -> dict[str, Any]: + if not _has_feishu_credentials(): + return {"ok": False, "reason": "no_feishu_credentials", "messages": []} + + if not chat_id and _ctx: + chat_id = (_ctx.get("chat_id") or "") or (_ctx.get("session", {}) and getattr(_ctx["session"], "chat_id", "")) or "" + + if not chat_id: + return {"ok": False, "reason": "missing_chat_id", "messages": []} + + try: + from pilot.surface.feishu.client import get_feishu_client + + msgs = await get_feishu_client().get_chat_messages(chat_id=chat_id, limit=int(limit)) + except Exception as e: + logger.warning("lark.im.fetch_thread failed: %s", e) + return {"ok": False, "reason": "feishu_call_failed", "error": str(e)[:200], "messages": []} + + return { + "ok": True, + "chat_id": chat_id, + "count": len(msgs), + "messages": msgs, + } + + +async def lark_doc_search( + *, + query: str, + count: int = 10, + _ctx: dict[str, Any] | None = None, +) -> dict[str, Any]: + if not _has_feishu_credentials(): + return {"ok": False, "reason": "no_feishu_credentials", "results": []} + if not query: + return {"ok": False, "reason": "empty_query", "results": []} + + try: + from pilot.surface.feishu.client import get_feishu_client + + results = await get_feishu_client().drive_search(query=query, count=int(count)) + except Exception as e: + logger.warning("lark.doc.search failed: %s", e) + return {"ok": False, "reason": "feishu_call_failed", "error": str(e)[:200], "results": []} + + return {"ok": True, "query": query, "count": len(results), "results": results} + + +async def lark_bitable_search( + *, + table_id: str = "", + query: str = "", + app_token: str = "", + page_size: int = 20, + _ctx: dict[str, Any] | None = None, +) -> dict[str, Any]: + if not _has_feishu_credentials(): + return {"ok": False, "reason": "no_feishu_credentials", "records": []} + if not table_id: + return {"ok": False, "reason": "missing_table_id", "records": []} + + try: + from pilot.surface.feishu.client import get_feishu_client + + records = await get_feishu_client().bitable_search( + app_token=app_token, table_id=table_id, query=query, page_size=int(page_size), + ) + except Exception as e: + logger.warning("lark.bitable.search failed: %s", e) + return {"ok": False, "reason": "feishu_call_failed", "error": str(e)[:200], "records": []} + + return { + "ok": True, + "app_token": app_token or os.getenv("FEISHU_BITABLE_APP_TOKEN", ""), + "table_id": table_id, + "query": query, + "count": len(records), + "records": records, + } diff --git a/pilot/capability/tools/registry.py b/pilot/capability/tools/registry.py index 2f9afce..b277141 100644 --- a/pilot/capability/tools/registry.py +++ b/pilot/capability/tools/registry.py @@ -150,7 +150,16 @@ def default_registry() -> ToolRegistry: def _register_builtin_tools(reg: ToolRegistry) -> None: """注册所有内置工具（懒导入避免循环依赖）.""" - from pilot.capability.tools import doc, canvas, slide, archive, voice, im_fetch, mentor + from pilot.capability.tools import ( + archive, + canvas, + doc, + im_fetch, + mentor, + slide, + voice, + web_media, + ) doc.register_to(reg) canvas.register_to(reg) @@ -159,3 +168,13 @@ def _register_builtin_tools(reg: ToolRegistry) -> None: voice.register_to(reg) im_fetch.register_to(reg) mentor.register_to(reg) + web_media.register_to(reg) + + try: + from pilot.capability.tools import lark_tools + + lark_tools.register_to(reg) + except ImportError: + logger.debug("lark_tools 模块尚未实现，跳过注册") + except Exception as e: + logger.warning("lark_tools 注册失败: %s", e) diff --git a/pilot/capability/tools/slide.py b/pilot/capability/tools/slide.py index 2ed3074..b0dfb4c 100644 --- a/pilot/capability/tools/slide.py +++ b/pilot/capability/tools/slide.py @@ -39,6 +39,9 @@ def register_to(reg) -> None: "outline": {"type": "array", "description": "可选大纲；留空时从上游 doc 自动提炼"}, "intent": {"type": "string", "description": "用户原始意图"}, "pages": {"type": "integer", "description": "目标页数，默认 8"}, + "search_results": { + "description": "上游 web.search 注入的结果 [{title,url,snippet}]，用于 LLM 大纲引用真实数据", + }, }, "required": ["title"], }, @@ -70,6 +73,7 @@ async def slide_generate( outline: list | None = None, intent: str = "", pages: int = 8, + search_results: Any = None, _ctx: dict[str, Any] | None = None, ) -> dict[str, Any]: sid = f"slide_{int(time.time())}_{uuid.uuid4().hex[:6]}" @@ -77,8 +81,15 @@ async def slide_generate( out_dir.mkdir(parents=True, exist_ok=True) upstream_md = _extract_upstream_doc(_ctx) + citations = _normalize_search_results(search_results) if not outline: - outline = await _llm_outline(title=title, intent=intent, pages=pages, upstream_md=upstream_md) + outline = await _llm_outline( + title=title, + intent=intent, + pages=pages, + upstream_md=upstream_md, + search_results=citations, + ) outline = _normalise_outline(outline, target_pages=pages) pptx_path = out_dir / f"{sid}.pptx" @@ -90,19 +101,50 @@ async def slide_generate( notes_md_path = out_dir / f"{sid}.speaker_notes.md" notes_md_path.write_text(_outline_to_speaker_notes(title, outline), encoding="utf-8") - base_url = f"/artifacts/slides/{sid}" + base = (os.getenv("DASHBOARD_PUBLIC_BASE") or "").rstrip("/") + rel = f"/artifacts/slides/{sid}" + pptx_rel = f"{rel}/{pptx_path.name}" return { "slide_id": sid, "title": title, "pages": page_count, "outline": outline, "pptx_path": str(pptx_path), - "pptx_url": f"{base_url}/{pptx_path.name}", - "slidev_md_url": f"{base_url}/{slidev_md_path.name}", - "speaker_notes_md_url": f"{base_url}/{notes_md_path.name}", + "pptx_url": pptx_rel, + "pptx_url_absolute": f"{base}{pptx_rel}" if base else pptx_rel, + "slidev_md_url": f"{rel}/{slidev_md_path.name}", + "speaker_notes_md_url": f"{rel}/{notes_md_path.name}", + "citations": citations, } +def _normalize_search_results(raw: Any) -> list[dict[str, str]]: + """与 doc 工具保持一致的归一化逻辑.""" + if not raw: + return [] + if isinstance(raw, str): + s = raw.strip() + if s.startswith("$") or not s: + return [] + try: + raw = json.loads(s) + except Exception: + return [] + if isinstance(raw, dict): + raw = raw.get("results") or raw.get("items") or [] + if not isinstance(raw, list): + return [] + out = [] + for item in raw: + if isinstance(item, dict): + t = str(item.get("title", ""))[:200] + u = str(item.get("url", ""))[:500] + sn = str(item.get("snippet", "") or item.get("desc", ""))[:400] + if t or u: + out.append({"title": t, "url": u, "snippet": sn}) + return out[:10] + + # ── slide.rehearse ── @@ -132,16 +174,31 @@ async def slide_rehearse(*, slide_id: str, _ctx: dict[str, Any] | None = None) - # ── 实现细节 ── -async def _llm_outline(*, title: str, intent: str, pages: int, upstream_md: str) -> list[dict[str, Any]]: +async def _llm_outline( + *, + title: str, + intent: str, + pages: int, + upstream_md: str, + search_results: list[dict[str, str]] | None = None, +) -> list[dict[str, Any]]: try: from pilot.llm.client import default_client from pilot.llm.safe_json import safe_json_parse + cite_block = "" + if search_results: + lines = ["\n参考资料（请基于真实数据，不要瞎编）："] + for i, r in enumerate(search_results[:5], 1): + lines.append(f"[{i}] {r.get('title','')} — {r.get('url','')}\n {r.get('snippet','')}") + cite_block = "\n".join(lines) + prompt = f"""请为「{title}」生成 {pages} 页 PPT 大纲（封面 + 主体 + 结尾）。 用户意图：{intent or '（无）'} 上游文档： {upstream_md[:2000] or '（无）'} +{cite_block} 输出严格 JSON 数组，每项： {{ @@ -158,7 +215,9 @@ async def _llm_outline(*, title: str, intent: str, pages: int, upstream_md: str) - List: 数字列表 - Quote: 名人 / 用户引言 -要求：第 1 页 Hero（封面）；最后一页 Hero（致谢/Q&A）；中间 6 页混用其他模板。直接输出 JSON 数组。""" +要求：第 1 页 Hero（封面）；最后一页 Hero（致谢/Q&A）；中间 6 页混用其他模板。 +若有参考资料，请在合适页面 bullets 中以 "[1]"/"[2]" 形式引用，并在 notes 中说明数据出处。 +直接输出 JSON 数组。""" client = default_client() result = await client.chat( diff --git a/pilot/capability/tools/web_media.py b/pilot/capability/tools/web_media.py new file mode 100644 index 0000000..020ce93 --- /dev/null +++ b/pilot/capability/tools/web_media.py @@ -0,0 +1,141 @@ +"""V1.5 — web.search 与 media.tts 工具注册. + +设计取舍: + - 不实现 image / video / voice_clone / image_understand。这些 fast 时期挂了空壳， + 没有真正可调通的下游 API；不做"假工具"。 + - web.search 委托 pilot.llm.web_search.WebSearcher（DDG + Bing CN），不联 LLM。 + - media.tts 走 MiniMax T2A（/v1/t2a_v2）。默认禁用（AGENT_PILOT_ENABLE_TTS=0）， + 避免比赛环境意外消耗配额。 +""" + +from __future__ import annotations + +import logging +import os +import time +import uuid +from pathlib import Path +from typing import Any + +import httpx + +from pilot.context.filesystem_memory import ARTIFACTS_DIR + +logger = logging.getLogger("pilot.tool.web_media") + + +def register_to(reg) -> None: + reg.register( + "web.search", + description="联网搜索（DuckDuckGo HTML 主路径 + Bing CN 兜底，无需 API key）", + input_schema={ + "type": "object", + "properties": { + "query": {"type": "string", "description": "搜索关键词"}, + "k": {"type": "integer", "description": "返回前 k 条，默认 5", "default": 5}, + }, + "required": ["query"], + }, + read_only=True, + namespace="pilot", + )(web_search) + + reg.register( + "media.tts", + description="文本转语音（MiniMax T2A）。默认禁用，AGENT_PILOT_ENABLE_TTS=1 才生效", + input_schema={ + "type": "object", + "properties": { + "text": {"type": "string", "description": "要合成的文本"}, + "voice": {"type": "string", "description": "voice_id，默认 male-qn-qingse", "default": "male-qn-qingse"}, + "speed": {"type": "number", "description": "0.5-2.0", "default": 1.0}, + }, + "required": ["text"], + }, + read_only=False, + namespace="pilot", + )(media_tts) + + +async def web_search(*, query: str, k: int = 5, _ctx: dict[str, Any] | None = None) -> dict[str, Any]: + """调用 WebSearcher 抓 DDG/Bing 并返回 [{title,url,snippet}] 数组.""" + from pilot.llm.web_search import default_searcher + + started = time.monotonic() + try: + results = await default_searcher().search(query, k=k) + except Exception as e: + logger.warning("web.search failed: %s", e) + return {"ok": False, "query": query, "results": [], "error": str(e)[:200]} + + elapsed_ms = int((time.monotonic() - started) * 1000) + return { + "ok": True, + "query": query, + "k": k, + "results": results, + "count": len(results), + "elapsed_ms": elapsed_ms, + } + + +async def media_tts( + *, + text: str, + voice: str = "male-qn-qingse", + speed: float = 1.0, + _ctx: dict[str, Any] | None = None, +) -> dict[str, Any]: + """文本转 mp3，落盘到 artifacts/tts/.mp3 并返回相对 URL. + + 默认禁用，env AGENT_PILOT_ENABLE_TTS=1 才会真调 MiniMax T2A。 + """ + if os.getenv("AGENT_PILOT_ENABLE_TTS", "0") != "1": + return {"ok": False, "reason": "tts_disabled", "hint": "AGENT_PILOT_ENABLE_TTS=1 才启用"} + if not text.strip(): + return {"ok": False, "reason": "empty_text"} + + api_key = os.getenv("MINIMAX_API_KEY", "") + group_id = os.getenv("MINIMAX_GROUP_ID", "") + if not api_key or not group_id: + return {"ok": False, "reason": "minimax_credentials_missing"} + + aid = f"tts_{int(time.time())}_{uuid.uuid4().hex[:6]}" + out_dir: Path = ARTIFACTS_DIR / "tts" + out_dir.mkdir(parents=True, exist_ok=True) + mp3_path = out_dir / f"{aid}.mp3" + + url = f"https://api.minimaxi.com/v1/t2a_v2?GroupId={group_id}" + body = { + "model": "speech-02-hd", + "text": text[:2000], + "voice_setting": {"voice_id": voice, "speed": float(speed), "vol": 1.0, "pitch": 0}, + "audio_setting": {"sample_rate": 32000, "bitrate": 128000, "format": "mp3"}, + } + try: + async with httpx.AsyncClient(timeout=30.0) as cli: + r = await cli.post( + url, + json=body, + headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}, + ) + r.raise_for_status() + data = r.json() + audio_hex = (data.get("data") or {}).get("audio") or "" + if not audio_hex: + return {"ok": False, "reason": "minimax_empty_audio", "raw": data} + mp3_path.write_bytes(bytes.fromhex(audio_hex)) + except Exception as e: + logger.warning("media.tts failed: %s", e) + return {"ok": False, "reason": "tts_request_failed", "error": str(e)[:200]} + + base = (os.getenv("DASHBOARD_PUBLIC_BASE") or "").rstrip("/") + rel = f"/artifacts/tts/{mp3_path.name}" + return { + "ok": True, + "tts_id": aid, + "mp3_path": str(mp3_path), + "mp3_url": rel, + "mp3_url_absolute": f"{base}{rel}" if base else rel, + "size_bytes": mp3_path.stat().st_size if mp3_path.exists() else 0, + } diff --git a/pilot/llm/__init__.py b/pilot/llm/__init__.py index 5a37e85..d2b15ea 100644 --- a/pilot/llm/__init__.py +++ b/pilot/llm/__init__.py @@ -2,5 +2,13 @@ from pilot.llm.client import LLMClient, default_client, get_client # noqa: F401 from pilot.llm.safe_json import safe_json_parse # noqa: F401 +from pilot.llm.web_search import WebSearcher, default_searcher # noqa: F401 -__all__ = ["LLMClient", "default_client", "get_client", "safe_json_parse"] +__all__ = [ + "LLMClient", + "default_client", + "get_client", + "safe_json_parse", + "WebSearcher", + "default_searcher", +] diff --git a/pilot/llm/client.py b/pilot/llm/client.py index c06ce99..256c05e 100644 --- a/pilot/llm/client.py +++ b/pilot/llm/client.py @@ -1,16 +1,13 @@ -"""LLM 客户端 — 多 Provider 抽象层. - -支持: - - Anthropic (Claude) - - OpenAI / 兼容（豆包 / 自部署） - - MiniMax - - Mock（测试用） - -设计原则: - - chat_stream / chat 均为 async - - 工具调用统一为 OpenAI tool_use 格式 - - 429 / quota 错误自动指数退避（tenacity） - - 单一接口 LLMClient，全局单例 default_client() +"""LLM 客户端 — V1.5 起锁定 MiniMax-M2.7-highspeed. + +设计取舍（V1 → V1.5 的批判性收敛）: + - V1 时期挂了 anthropic / doubao / openai_compat 三套分支，实际只对 MiniMax 做过线上验证， + 其他分支等同死代码 → 移除。 + - 仅保留 MiniMax 的 OpenAI 兼容 endpoint（/v1/chat/completions），不再写多 provider 抽象层。 + - 通过 `LLM_MOCK=1` 或缺失 `MINIMAX_API_KEY` 触发 mock，保证测试与离线环境可跑。 + - 重试预算：429/5xx 指数退避，最多 3 次，整体 budget 30s。 + +公开 API 与 V1 保持兼容，外部调用点仅依赖 `default_client().chat(...)`。 """ from __future__ import annotations @@ -22,21 +19,23 @@ import random import time from dataclasses import dataclass -from typing import Any, AsyncIterator, Optional +from typing import Any, AsyncIterator import httpx logger = logging.getLogger("pilot.llm.client") - -# ── 数据 ─────────────────────────────────────────────────────────────────── +DEFAULT_BASE_URL = "https://api.minimaxi.com/v1" +DEFAULT_MODEL = "MiniMax-M2.7-highspeed" +RETRY_BUDGET_SEC = 30.0 +RETRY_MAX_ATTEMPTS = 3 @dataclass class LLMResponse: - """统一返回结构（含 Anthropic content list 与 OpenAI 格式兼容字段）.""" + """统一返回结构（保留 OpenAI / Anthropic 风格的 content list 兼容字段）.""" - content: list[dict[str, Any]] # [{"type": "text", "text": "..."}, {"type": "tool_use", ...}] + content: list[dict[str, Any]] text: str = "" tool_calls: list[dict[str, Any]] | None = None raw: dict[str, Any] | None = None @@ -44,77 +43,37 @@ class LLMResponse: tokens_out: int = 0 -# ── 客户端实现 ────────────────────────────────────────────────────────────── - - class LLMClient: - """统一 LLM 接口.""" + """MiniMax-M2.7-highspeed 客户端（OpenAI 兼容协议）.""" def __init__( self, *, - provider: str = "", api_key: str = "", base_url: str = "", model: str = "", timeout: float = 120.0, ) -> None: - self.provider = provider or self._detect_provider() - self.api_key = api_key or self._guess_api_key() - self.base_url = base_url or self._guess_base_url() - self.model = model or self._guess_model() + self.api_key = api_key or os.getenv("MINIMAX_API_KEY", "") + self.base_url = (base_url or os.getenv("MINIMAX_API_HOST", DEFAULT_BASE_URL)).rstrip("/") + if not self.base_url.endswith("/v1"): + self.base_url = f"{self.base_url}/v1" + self.model = model or os.getenv("MINIMAX_MODEL", DEFAULT_MODEL) self.timeout = timeout + self.provider = "minimax" # 兼容历史代码读取 .provider self._http: httpx.AsyncClient | None = None - @staticmethod - def _detect_provider() -> str: - """Auto-detect available LLM provider from env vars.""" - explicit = os.getenv("LLM_DEFAULT_PROVIDER", "").strip().lower() - if explicit: - return explicit - if os.getenv("MINIMAX_API_KEY"): - return "minimax" - if os.getenv("ANTHROPIC_API_KEY"): - return "anthropic" - if os.getenv("DOUBAO_API_KEY"): - return "doubao" - if os.getenv("OPENAI_API_KEY") or os.getenv("LLM_API_KEY"): - return "openai" - return "minimax" - - def _guess_api_key(self) -> str: - if self.provider == "anthropic": - return os.getenv("ANTHROPIC_API_KEY", "") - if self.provider == "minimax": - return os.getenv("MINIMAX_API_KEY", "") - if self.provider == "doubao": - return os.getenv("DOUBAO_API_KEY", "") - return os.getenv("LLM_API_KEY", "") - - def _guess_base_url(self) -> str: - if self.provider == "anthropic": - return os.getenv("ANTHROPIC_BASE_URL", "https://api.anthropic.com") - if self.provider == "doubao": - return os.getenv("DOUBAO_BASE_URL", "https://ark.cn-beijing.volces.com/api/v3") - if self.provider == "minimax": - return "https://api.minimax.chat" - return "" - - def _guess_model(self) -> str: - if self.provider == "anthropic": - return os.getenv("ANTHROPIC_MODEL", "claude-3-5-sonnet-20241022") - if self.provider == "minimax": - return os.getenv("MINIMAX_MODEL", "MiniMax-Text-01") - if self.provider == "doubao": - return os.getenv("DOUBAO_MODEL", "doubao-1-5-pro-32k-250115") - return "" - async def _http_client(self) -> httpx.AsyncClient: if self._http is None: self._http = httpx.AsyncClient(timeout=self.timeout) return self._http - # ── chat (non-stream) ── + @property + def is_mock(self) -> bool: + if os.getenv("LLM_MOCK", "").lower() in ("1", "true", "yes"): + return True + return not self.api_key + async def chat( self, *, @@ -123,59 +82,54 @@ async def chat( tools: list[dict[str, Any]] | None = None, temperature: float = 0.5, max_tokens: int = 4096, - provider_override: str = "", + response_format: dict[str, Any] | None = None, + provider_override: str = "", # 保留参数签名但忽略，V1.5 仅 MiniMax ) -> dict[str, Any]: - """统一 chat 接口，返回 dict（含 content list）.""" - provider = (provider_override or self.provider).lower() + """统一 chat 接口，返回 dict（含 content list / text / tool_calls）.""" + if provider_override and provider_override.lower() != "minimax": + logger.debug("provider_override=%s ignored (V1.5 MiniMax-only)", provider_override) - if not self.api_key: + if self.is_mock: return await self._mock_chat(system=system, messages=messages or [], tools=tools or []) - for attempt in range(3): + deadline = time.monotonic() + RETRY_BUDGET_SEC + last_exc: Exception | None = None + for attempt in range(RETRY_MAX_ATTEMPTS): + if time.monotonic() > deadline: + break try: - if provider == "anthropic": - return await self._chat_anthropic(system, messages or [], tools, temperature, max_tokens) - if provider == "minimax": - return await self._chat_minimax(system, messages or [], tools, temperature, max_tokens) - if provider == "doubao": - return await self._chat_openai_compat( - base_url=self.base_url, - api_key=self.api_key, - model=self.model, - system=system, - messages=messages or [], - tools=tools, - temperature=temperature, - max_tokens=max_tokens, - ) - # 默认 OpenAI 兼容 - return await self._chat_openai_compat( - base_url=os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1"), - api_key=self.api_key, - model=os.getenv("OPENAI_MODEL", "gpt-4o-mini"), + return await self._chat_minimax( system=system, messages=messages or [], tools=tools, temperature=temperature, max_tokens=max_tokens, + response_format=response_format, ) except httpx.HTTPStatusError as e: - code = e.response.status_code if e.response else 0 + code = e.response.status_code if e.response is not None else 0 + last_exc = e if code == 429 or 500 <= code < 600: - sleep = (2 ** attempt) + random.random() - logger.warning("LLM %s status=%d; retry in %.1fs", provider, code, sleep) + sleep = min(2 ** attempt + random.random(), max(0.0, deadline - time.monotonic())) + logger.warning("MiniMax %d retry %d/%d in %.1fs", code, attempt + 1, RETRY_MAX_ATTEMPTS, sleep) + if sleep <= 0: + break await asyncio.sleep(sleep) continue - logger.error("LLM %s status=%d body=%s", provider, code, e.response.text[:200]) + body_preview = e.response.text[:200] if e.response is not None else "" + logger.error("MiniMax fatal status=%d body=%s", code, body_preview) raise - except Exception as e: - logger.warning("LLM %s attempt %d failed: %s", provider, attempt + 1, e) - if attempt < 2: - await asyncio.sleep((2 ** attempt) + random.random()) - else: - raise - - raise RuntimeError("LLM chat failed after 3 retries") + except (httpx.TimeoutException, httpx.TransportError) as e: + last_exc = e + sleep = min(2 ** attempt + random.random(), max(0.0, deadline - time.monotonic())) + logger.warning("MiniMax network attempt %d failed: %s; retry in %.1fs", attempt + 1, e, sleep) + if sleep <= 0: + break + await asyncio.sleep(sleep) + + if last_exc is not None: + raise last_exc + raise RuntimeError("MiniMax chat exhausted retry budget") async def chat_stream( self, @@ -185,10 +139,7 @@ async def chat_stream( tools: list[dict[str, Any]] | None = None, temperature: float = 0.5, ) -> AsyncIterator[dict[str, Any]]: - """流式接口（占位实现：拆 chat 为单 chunk）. - - 生产中应直接调用 Anthropic / OpenAI 的 SSE，这里先用非流式包装。 - """ + """流式接口（占位实现：拆 chat 为单 chunk）.""" result = await self.chat( system=system, messages=messages, @@ -198,128 +149,43 @@ async def chat_stream( for block in result.get("content", []): yield block - # ── Anthropic ── - async def _chat_anthropic( - self, - system: str, - messages: list[dict[str, Any]], - tools: list[dict[str, Any]] | None, - temperature: float, - max_tokens: int, - ) -> dict[str, Any]: - url = f"{self.base_url}/v1/messages" - headers = { - "x-api-key": self.api_key, - "anthropic-version": "2023-06-01", - "content-type": "application/json", - } - body: dict[str, Any] = { - "model": self.model, - "system": system, - "messages": _to_anthropic_messages(messages), - "max_tokens": max_tokens, - "temperature": temperature, - } - if tools: - body["tools"] = _to_anthropic_tools(tools) - - client = await self._http_client() - r = await client.post(url, json=body, headers=headers) - r.raise_for_status() - data = r.json() - usage = data.get("usage", {}) or {} - return { - "content": data.get("content", []), - "tokens_in": usage.get("input_tokens", 0), - "tokens_out": usage.get("output_tokens", 0), - "raw": data, - } - - # ── OpenAI 兼容 ── - async def _chat_openai_compat( + async def _chat_minimax( self, *, - base_url: str, - api_key: str, - model: str, system: str, messages: list[dict[str, Any]], tools: list[dict[str, Any]] | None, temperature: float, max_tokens: int, + response_format: dict[str, Any] | None, ) -> dict[str, Any]: - url = f"{base_url}/chat/completions" + url = f"{self.base_url}/chat/completions" headers = { - "Authorization": f"Bearer {api_key}", + "Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json", } - msgs = [{"role": "system", "content": system}] + _to_openai_messages(messages) + msgs: list[dict[str, Any]] = [] + if system: + msgs.append({"role": "system", "content": system}) + msgs.extend(_to_openai_messages(messages)) + body: dict[str, Any] = { - "model": model, + "model": self.model, "messages": msgs, "temperature": temperature, "max_tokens": max_tokens, } if tools: body["tools"] = _to_openai_tools(tools) + if response_format: + body["response_format"] = response_format client = await self._http_client() r = await client.post(url, json=body, headers=headers) r.raise_for_status() data = r.json() - choice = (data.get("choices") or [{}])[0] - message = choice.get("message", {}) or {} - text = message.get("content") or "" - tool_calls = message.get("tool_calls") or [] - - content_blocks: list[dict[str, Any]] = [] - if text: - content_blocks.append({"type": "text", "text": text}) - for tc in tool_calls: - fn = tc.get("function", {}) - try: - inp = json.loads(fn.get("arguments", "{}")) - except Exception: - inp = {"_raw": fn.get("arguments", "")} - content_blocks.append({ - "type": "tool_use", - "id": tc.get("id", ""), - "name": fn.get("name", ""), - "input": inp, - }) - - usage = data.get("usage", {}) or {} - return { - "content": content_blocks, - "text": text, - "tool_calls": tool_calls, - "tokens_in": usage.get("prompt_tokens", 0), - "tokens_out": usage.get("completion_tokens", 0), - "raw": data, - } - - # ── MiniMax ── - async def _chat_minimax( - self, - system: str, - messages: list[dict[str, Any]], - tools: list[dict[str, Any]] | None, - temperature: float, - max_tokens: int, - ) -> dict[str, Any]: - # MiniMax v2 兼容 OpenAI Chat 格式 - return await self._chat_openai_compat( - base_url=f"{self.base_url}/v1", - api_key=self.api_key, - model=self.model, - system=system, - messages=messages, - tools=tools, - temperature=temperature, - max_tokens=max_tokens, - ) + return _parse_openai_response(data) - # ── Mock（无 key 时回退）── async def _mock_chat( self, *, @@ -329,11 +195,11 @@ async def _mock_chat( ) -> dict[str, Any]: last_user = "" for m in reversed(messages): - if m.get("role") == "user" and isinstance(m.get("content"), str): - last_user = m["content"] + content = m.get("content", "") + if m.get("role") == "user" and isinstance(content, str): + last_user = content break - # 如果工具集中有 doc.create 等，模拟一次工具调用 if tools: tool_name = tools[0].get("name", "doc.create") return { @@ -346,15 +212,18 @@ async def _mock_chat( "input": {"title": last_user[:30] or "[Agent-Pilot] mock"}, }, ], + "text": f"[mock] {last_user[:60]}", + "tool_calls": [], "tokens_in": 100, "tokens_out": 50, "raw": {"_mock": True}, } + text = f"[mock] 你说: {last_user[:80]}（请配置 MINIMAX_API_KEY 走真实 LLM）" return { - "content": [ - {"type": "text", "text": f"[mock] 你说: {last_user[:80]}（这是 LLM 兜底回复，请配置 API key）"}, - ], + "content": [{"type": "text", "text": text}], + "text": text, + "tool_calls": [], "tokens_in": 50, "tokens_out": 20, "raw": {"_mock": True}, @@ -366,53 +235,45 @@ async def aclose(self) -> None: self._http = None -# ── 辅助：消息 / 工具格式转换 ─────────────────────────────────────────────── - - -def _to_anthropic_messages(messages: list[dict[str, Any]]) -> list[dict[str, Any]]: - """OpenAI/通用消息 → Anthropic content list.""" - out = [] - for m in messages: - role = m.get("role", "user") - content = m.get("content", "") - if role == "system": - continue # Anthropic 用顶层 system - if isinstance(content, str): - out.append({"role": role, "content": [{"type": "text", "text": content}]}) - else: - out.append({"role": role, "content": content}) - return out - - def _to_openai_messages(messages: list[dict[str, Any]]) -> list[dict[str, Any]]: - out = [] + """通用消息 → OpenAI/MiniMax 兼容消息.""" + out: list[dict[str, Any]] = [] for m in messages: role = m.get("role", "user") if role == "tool": + content = m.get("content", "") + if not isinstance(content, str): + content = json.dumps(content, ensure_ascii=False) out.append({ "role": "tool", - "tool_call_id": m.get("tool_use_id", ""), - "content": json.dumps(m.get("content", "")) if not isinstance(m.get("content"), str) else m.get("content"), + "tool_call_id": m.get("tool_use_id", "") or m.get("tool_call_id", ""), + "content": content, }) - else: - out.append({"role": role, "content": m.get("content", "")}) - return out - + continue -def _to_anthropic_tools(tools: list[dict[str, Any]]) -> list[dict[str, Any]]: - out = [] - for t in tools: - out.append({ - "name": t.get("name", ""), - "description": t.get("description", ""), - "input_schema": t.get("input_schema", {"type": "object", "properties": {}}), - }) + content = m.get("content", "") + if isinstance(content, list): + joined: list[str] = [] + for blk in content: + if isinstance(blk, dict): + if blk.get("type") == "text": + joined.append(blk.get("text", "")) + elif blk.get("type") == "tool_use": + joined.append(f"[tool_use {blk.get('name', '')} {json.dumps(blk.get('input', {}), ensure_ascii=False)}]") + else: + joined.append(str(blk)) + content = "\n".join(t for t in joined if t) + out.append({"role": role, "content": content}) return out def _to_openai_tools(tools: list[dict[str, Any]]) -> list[dict[str, Any]]: - out = [] + """统一工具 schema → OpenAI 函数调用格式.""" + out: list[dict[str, Any]] = [] for t in tools: + if "function" in t and "type" in t: + out.append(t) + continue out.append({ "type": "function", "function": { @@ -424,7 +285,37 @@ def _to_openai_tools(tools: list[dict[str, Any]]) -> list[dict[str, Any]]: return out -# ── 全局单例 ── +def _parse_openai_response(data: dict[str, Any]) -> dict[str, Any]: + choice = (data.get("choices") or [{}])[0] + message = choice.get("message", {}) or {} + text = message.get("content") or "" + tool_calls = message.get("tool_calls") or [] + + blocks: list[dict[str, Any]] = [] + if text: + blocks.append({"type": "text", "text": text}) + for tc in tool_calls: + fn = tc.get("function", {}) or {} + try: + inp = json.loads(fn.get("arguments", "{}")) + except Exception: + inp = {"_raw": fn.get("arguments", "")} + blocks.append({ + "type": "tool_use", + "id": tc.get("id", ""), + "name": fn.get("name", ""), + "input": inp, + }) + + usage = data.get("usage", {}) or {} + return { + "content": blocks, + "text": text, + "tool_calls": tool_calls, + "tokens_in": usage.get("prompt_tokens", 0), + "tokens_out": usage.get("completion_tokens", 0), + "raw": data, + } _default: LLMClient | None = None @@ -438,6 +329,7 @@ def default_client() -> LLMClient: def get_client(provider: str = "") -> LLMClient: - if not provider: - return default_client() - return LLMClient(provider=provider) + """保留签名兼容历史调用；V1.5 起强制返回 MiniMax 单例.""" + if provider and provider.lower() != "minimax": + logger.debug("get_client(provider=%s) ignored (V1.5 MiniMax-only)", provider) + return default_client() diff --git a/pilot/llm/web_search.py b/pilot/llm/web_search.py new file mode 100644 index 0000000..ea04731 --- /dev/null +++ b/pilot/llm/web_search.py @@ -0,0 +1,161 @@ +"""免费联网搜索 — DuckDuckGo HTML 主路径 + Bing CN 兜底. + +为什么不叫 minimax_mcp？ + - 实现是 HTTP 抓 HTML，不是 MCP 协议、也不依赖 MiniMax 服务，命名要诚实。 + - MiniMax 提供的 minimax-search MCP 在 stdio 子进程里管理麻烦（systemd 不友好）， + 且 HTTP 直抓即可满足 Planner 的"联网注入最新数据"需求。 + +接口： + - WebSearcher.search(query, k=5) -> list[{title,url,snippet}] + - default_searcher() 返回单例 +""" + +from __future__ import annotations + +import logging +import re +from typing import Any +from urllib.parse import parse_qs, unquote, urlparse + +import httpx + +logger = logging.getLogger("pilot.llm.web_search") + +DDG_ENDPOINT = "https://html.duckduckgo.com/html/" +BING_CN_ENDPOINT = "https://cn.bing.com/search" +USER_AGENT = ( + "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) " + "AppleWebKit/537.36 (KHTML, like Gecko) Version/17.0 Safari/605.1.15" +) + + +class WebSearcher: + """HTTP 抓取式联网搜索器（无 API key 依赖）.""" + + def __init__(self, *, timeout: float = 12.0) -> None: + self.timeout = timeout + self._http: httpx.AsyncClient | None = None + + async def _client(self) -> httpx.AsyncClient: + if self._http is None: + self._http = httpx.AsyncClient(timeout=self.timeout, follow_redirects=True) + return self._http + + async def aclose(self) -> None: + if self._http is not None: + await self._http.aclose() + self._http = None + + async def search(self, query: str, *, k: int = 5) -> list[dict[str, str]]: + """先 DDG 后 Bing；都失败返回空 list。绝不抛异常给上游.""" + q = (query or "").strip() + if not q: + return [] + + try: + results = await self._search_ddg(q, k=k) + if results: + return results + except Exception as e: + logger.warning("DDG search failed: %s", e) + + try: + return await self._search_bing(q, k=k) + except Exception as e: + logger.warning("Bing CN search failed: %s", e) + return [] + + async def _search_ddg(self, query: str, *, k: int) -> list[dict[str, str]]: + client = await self._client() + r = await client.post( + DDG_ENDPOINT, + data={"q": query}, + headers={ + "User-Agent": USER_AGENT, + "Accept": "text/html,application/xhtml+xml", + }, + ) + r.raise_for_status() + return parse_ddg_html(r.text, k=k) + + async def _search_bing(self, query: str, *, k: int) -> list[dict[str, str]]: + client = await self._client() + r = await client.get( + BING_CN_ENDPOINT, + params={"q": query, "ensearch": 0}, + headers={"User-Agent": USER_AGENT}, + ) + r.raise_for_status() + return parse_bing_html(r.text, k=k) + + +_DDG_RESULT_RE = re.compile( + r']*class="result__a"[^>]*href="(?P[^"]+)"[^>]*>(?P.*?)</a>' + r'.*?class="result__snippet"[^>]*>(?P<snippet>.*?)</a>', + re.DOTALL, +) + + +def parse_ddg_html(html: str, *, k: int = 5) -> list[dict[str, str]]: + """从 DuckDuckGo HTML SERP 提取前 k 条结果.""" + out: list[dict[str, str]] = [] + for m in _DDG_RESULT_RE.finditer(html): + url = _unwrap_ddg(m.group("url")) + title = _strip_html(m.group("title")) + snippet = _strip_html(m.group("snippet")) + if not url or not title: + continue + out.append({"title": title[:200], "url": url[:500], "snippet": snippet[:400]}) + if len(out) >= k: + break + return out + + +def _unwrap_ddg(href: str) -> str: + """DDG 用 //duckduckgo.com/l/?uddg=https%3A... 跳转，剥出真实 URL.""" + if href.startswith("//"): + href = "https:" + href + if "duckduckgo.com/l/" in href: + try: + qs = parse_qs(urlparse(href).query) + return unquote(qs.get("uddg", [href])[0]) + except Exception: + return href + return href + + +_BING_RESULT_RE = re.compile( + r'<li[^>]*class="b_algo"[^>]*>.*?' + r'<h2[^>]*>.*?<a[^>]*href="(?P<url>[^"]+)"[^>]*>(?P<title>.*?)</a>.*?</h2>.*?' + r'<p[^>]*>(?P<snippet>.*?)</p>', + re.DOTALL, +) + + +def parse_bing_html(html: str, *, k: int = 5) -> list[dict[str, str]]: + """从 Bing CN HTML SERP 提取前 k 条结果.""" + out: list[dict[str, str]] = [] + for m in _BING_RESULT_RE.finditer(html): + url = m.group("url").strip() + title = _strip_html(m.group("title")) + snippet = _strip_html(m.group("snippet")) + if not url or not title: + continue + out.append({"title": title[:200], "url": url[:500], "snippet": snippet[:400]}) + if len(out) >= k: + break + return out + + +def _strip_html(text: str) -> str: + return re.sub(r"<[^>]+>", "", text or "").strip() + + +_default: WebSearcher | None = None + + +def default_searcher() -> WebSearcher: + global _default + if _default is None: + _default = WebSearcher() + return _default diff --git a/pilot/runtime/intent_router.py b/pilot/runtime/intent_router.py index ba9450b..1825233 100644 --- a/pilot/runtime/intent_router.py +++ b/pilot/runtime/intent_router.py @@ -1,12 +1,20 @@ -"""三闸门意图识别（Anthropic Routing 模式 · PRD §问题 5）. +"""5 闸门意图识别（V1.5 重写版）. -闸门 1: 规则层（关键词 + 任务语义 + 上下文条件） -闸门 2: LLM 层（结构化判断 task_type / goal / resources / next_step） -闸门 3: 最小信息（具备 task + 输出形态 + 受众） +设计动机（来自 V1 → V1.5 的批判）: + - V1 的 3 闸门 + NOT_INTENT 兜底 → 大量轻量寒暄被 bot 沉默 → 用户首条体验差。 + - V1 把"显式 /pilot"和"关键字命中"混在一起 → 难以独立调优 cooldown。 + - 复杂度的根源是命中信号不分层；V1.5 显式拆 5 闸门： -只有 3 闸全过 → READY； -2 过 1 缺 → NEEDS_CLARIFY； -1 不过 → NOT_INTENT。 + 闸门 1 命令 (help/status/我来执行/暂停/继续/忽略) + 闸门 2 显式触发 (/pilot @pilot 前缀) + 闸门 3 关键字快速通道 (强 form 词单独 / 弱 form 词 + 动词) + 闸门 4 LLM 判定 (MiniMax-M2.7-highspeed JSON 输出，外部注入；本模块不依赖 LLM client) + 闸门 5 闲聊兜底 (greeting / LLM verdict=chat → AI 友好回复，绝不沉默) + + - LLM 判定通过 `Callable[[str, list[ChatMessage]], Awaitable[LLMJudgement]]` 注入， + 本模块不直接 import pilot.llm.client，方便测试 + 解耦。 + + - PRD §问题 5（混合机制）：规则层 + LLM 层；任一闸门命中即返。 """ from __future__ import annotations @@ -16,29 +24,48 @@ import time from dataclasses import dataclass, field from enum import Enum -from typing import Any, Awaitable, Callable +from typing import Awaitable, Callable logger = logging.getLogger("pilot.runtime.intent") -# ── 数据结构 ──────────────────────────────────────────────────────────────── +class IntentVerdict(str, Enum): + NOT_INTENT = "not_intent" # 空消息或纯符号 + CHAT = "chat" # V1.5 新增：闲聊 → AI 友好回复 + COMMAND = "command" # 帮助 / 状态 / 我来执行 + NEEDS_CLARIFY = "needs_clarify" # 是任务但信息不足 + READY = "ready" # 直接执行 + COOLDOWN = "cooldown" # 主题在 cooldown 内静默 + IGNORED = "ignored" # 用户标记忽略 -class IntentVerdict(str, Enum): - NOT_INTENT = "not_intent" - COOLDOWN = "cooldown" - IGNORED = "ignored" - NEEDS_CLARIFY = "needs_clarify" - READY = "ready" +class CommandKind(str, Enum): + HELP = "help" + STATUS = "status" + CLAIM = "claim" + PAUSE = "pause" + RESUME = "resume" + IGNORE = "ignore" @dataclass class LLMJudgement: + """闸门 4 的 LLM 输出（结构化 JSON 反序列化结果）. + + 保留 V1 字段（is_task/task_type/goal/resources/next_step/confidence）以兼容老测试， + 新增 V1.5 字段（verdict/summary/missing/friendly_reply/needs_web_search）。 + """ + + verdict: str = "not_intent" # ready | chat | clarify | not_intent is_task: bool = False - task_type: str = "" + task_type: str = "" # doc | ppt | canvas | trio | none goal: str = "" resources: list[str] = field(default_factory=list) next_step: str = "" + summary: str = "" # 任务一句话归纳，<=20 字 + missing: list[str] = field(default_factory=list) # ['audience','form','goal','time'] + friendly_reply: str = "" # CHAT 时的友好回复 <=40 字 + needs_web_search: bool = False confidence: float = 0.0 @@ -51,8 +78,14 @@ class IntentResult: suggested_title: str = "" clarify_questions: list[str] = field(default_factory=list) llm_judgement: LLMJudgement | None = None + chat_reply: str = "" + needs_web_search: bool = False + command_kind: str = "" raw_text: str = "" + def is_actionable(self) -> bool: + return self.verdict not in (IntentVerdict.NOT_INTENT, IntentVerdict.COOLDOWN, IntentVerdict.IGNORED) + @dataclass class ChatMessage: @@ -63,79 +96,238 @@ class ChatMessage: ts: int = 0 -# ── 规则层 ────────────────────────────────────────────────────────────────── +# ── 字典（PRD §问题 5 + 飞书 Bot 实战经验 + 真实语料）───────────────────────── -# 关键词命中（PRD §问题 5） -EXPLICIT_KEYWORDS = [ - "整理一下", "汇总一下", "做个方案", "出个文档", "生成 PPT", "做个 PPT", - "下周汇报", "给老板看", "拉齐一下", "沉淀一下", "形成材料", - "写个大纲", "做个复盘", "输出版本", "发一版", "准备演示", - "方案", "复盘", "周报", "月报", "PRD", "需求文档", - "架构图", "流程图", "白板", "画布", - "@pilot", "/pilot", -] +STRONG_FORM_WORDS = ( + "三件套", "PPT", "ppt", "Ppt", "幻灯", "白板", "画布", + "架构图", "流程图", "思维导图", "脑图", "演示稿", "演示文稿", + "文档", "报告", "方案", "PRD", "需求文档", "策划方案", +) -# 任务语义命中（意图） -TASK_SEMANTIC_PATTERNS = [ - r"(帮|麻烦|需要).*(写|做|生成|整理|汇总|画|画一)", - r"(下周|这周|明天|后天).*(汇报|展示|讲|发|给)", - r"(我们|大家).*(对齐|讨论|沟通).*(下|一下)", -] +WEAK_FORM_WORDS = ( + "汇报", "介绍", "分析", "调研", "研究", "复盘", "总结", + "纪要", "周报", "月报", "日报", "盘点", "概览", "策划", +) +VERB_WORDS = ( + "写", "做", "做个", "做一份", "出个", "出一份", "生成", "整理", "整理一下", + "汇总", "汇总一下", "梳理", "拉齐", "画", "搞", "弄", "出", "出一版", + "形成", "沉淀", "沉淀一下", "准备", +) -def _detect_rules(text: str) -> tuple[list[str], str]: - hits: list[str] = [] - for kw in EXPLICIT_KEYWORDS: - if kw.lower() in text.lower(): - hits.append(f"kw:{kw}") - for pat in TASK_SEMANTIC_PATTERNS: - if re.search(pat, text): - hits.append(f"semantic:{pat[:20]}") +GREETING_WORDS = ( + "你好", "您好", "Hi", "hi", "Hello", "hello", "Hey", "hey", "嗨", "哈喽", + "在吗", "在不", "在么", "在嘛", "早", "晚安", "下午好", "上午好", "中午好", + "辛苦", "辛苦了", "谢谢", "感谢", "Thanks", "thanks", "Thx", "thx", + "OK", "ok", "好的", "收到", "嗯", "嗯嗯", "嗯哼", +) - theme = "" - m = re.search(r"(关于|对|针对)([^，。,;\s]{2,16})", text) - if m: - theme = m.group(2) - elif text: - theme = text[:16] - return hits, theme +COMMAND_WORDS: dict[str, CommandKind] = { + "帮助": CommandKind.HELP, + "/help": CommandKind.HELP, + "help": CommandKind.HELP, + "Help": CommandKind.HELP, + "状态": CommandKind.STATUS, + "/status": CommandKind.STATUS, + "status": CommandKind.STATUS, + "我来执行": CommandKind.CLAIM, + "认领": CommandKind.CLAIM, + "暂停": CommandKind.PAUSE, + "继续": CommandKind.RESUME, + "忽略": CommandKind.IGNORE, + "不用了": CommandKind.IGNORE, +} + +EXPLICIT_PREFIXES = ("/pilot", "@pilot") + +TIMELY_RE = re.compile( + r"(最新|当前|近期|最近|本周|本月|今日|今年|去年|" + r"2026|2025|2024|今天|昨天|前天|刚才)" +) + +TASK_SEMANTIC_PATTERNS = ( + re.compile(r"(帮|麻烦|需要).{0,8}(写|做|生成|整理|汇总|画|画一)"), + re.compile(r"(下周|这周|明天|后天).{0,8}(汇报|展示|讲|发|给)"), + re.compile(r"(我们|大家).{0,6}(对齐|讨论|沟通).{0,2}(下|一下)"), +) -# ── 上下文 cooldown（避免群聊里频繁弹卡片）───────────────────────────────── +# ── Cooldown ────────────────────────────────────────────────────────────── class CooldownStore: - """轻量内存 cooldown：theme_key + chat_id → 最近触发时间.""" + """主题 + 会话维度的 cooldown：群聊 5min、单聊 10s.""" - def __init__(self, *, cooldown_sec: int = 300) -> None: - self.cooldown_sec = cooldown_sec + def __init__(self, *, group_cooldown_sec: int = 300, p2p_cooldown_sec: int = 10) -> None: + self.group_cooldown_sec = group_cooldown_sec + self.p2p_cooldown_sec = p2p_cooldown_sec self._fired: dict[str, float] = {} self._ignored: set[str] = set() - def is_cooldown(self, chat_id: str, theme: str) -> bool: - key = f"{chat_id}::{theme}" + @staticmethod + def _key(chat_id: str, theme: str) -> str: + return f"{chat_id}::{theme}" + + def is_cooldown(self, chat_id: str, theme: str, *, is_p2p: bool = False) -> bool: + key = self._key(chat_id, theme) if key in self._ignored: return True last = self._fired.get(key, 0.0) - return (time.time() - last) < self.cooldown_sec + cooldown = self.p2p_cooldown_sec if is_p2p else self.group_cooldown_sec + return (time.time() - last) < cooldown def mark_fired(self, chat_id: str, theme: str) -> None: - self._fired[f"{chat_id}::{theme}"] = time.time() + self._fired[self._key(chat_id, theme)] = time.time() def mark_ignored(self, chat_id: str, theme: str) -> None: - self._ignored.add(f"{chat_id}::{theme}") + self._ignored.add(self._key(chat_id, theme)) + + +# ── helpers ──────────────────────────────────────────────────────────────── + +def _detect_command(text: str) -> CommandKind | None: + """命令检测：纯命令词、/pilot 前缀的命令词、status/help 别名都算。""" + norm = text.strip() + if not norm: + return None + # /pilot 帮助 / @pilot 状态 → 去前缀再匹配 + lower = norm.lower() + for prefix in EXPLICIT_PREFIXES: + if lower.startswith(prefix): + stripped = norm[len(prefix):].lstrip(" ：:、,").strip() + if stripped and stripped in COMMAND_WORDS: + return COMMAND_WORDS[stripped] + if stripped and stripped.lower() in COMMAND_WORDS: + return COMMAND_WORDS[stripped.lower()] + break + if norm in COMMAND_WORDS: + return COMMAND_WORDS[norm] + return COMMAND_WORDS.get(norm.lower()) -# ── 主 router ─────────────────────────────────────────────────────────────── + +def _detect_explicit(text: str) -> bool: + lower = text.lstrip().lower() + return any(lower.startswith(p) for p in EXPLICIT_PREFIXES) + + +def _detect_keywords(text: str) -> tuple[list[str], bool, bool, bool]: + """返回 (rule_hits, has_strong_form, has_weak_form, has_verb).""" + hits: list[str] = [] + has_strong = False + has_weak = False + has_verb = False + lower = text.lower() + for kw in STRONG_FORM_WORDS: + if kw.lower() in lower: + hits.append(f"form_strong:{kw}") + has_strong = True + break + if not has_strong: + for kw in WEAK_FORM_WORDS: + if kw in text: + hits.append(f"form_weak:{kw}") + has_weak = True + break + for kw in VERB_WORDS: + if kw in text: + hits.append(f"verb:{kw}") + has_verb = True + break + for pat in TASK_SEMANTIC_PATTERNS: + if pat.search(text): + hits.append(f"semantic:{pat.pattern[:24]}") + return hits, has_strong, has_weak, has_verb + + +def _detect_greeting(text: str) -> bool: + norm = text.strip() + if not norm or len(norm) > 20: + return False + for kw in GREETING_WORDS: + if norm == kw or norm.lower() == kw.lower(): + return True + if len(norm) <= 8: + for kw in GREETING_WORDS[:8]: + if kw.lower() in norm.lower(): + return True + return False + + +def _detect_timely(text: str) -> bool: + return bool(TIMELY_RE.search(text)) + + +# 占位/客气/语气词（信息充分性判定时剥离） +FILLER_WORDS = ( + "帮我", "帮忙", "帮", "麻烦", "请", "给我", "能不能", "可以", + "一下", "下", "一份", "一版", "份", "版", "我", "你", "他", + "的", "了", "吧", "呢", "啊", "嘛", "哦", +) + + +def _has_topic(text: str) -> bool: + """判定是否信息充分到可直接 READY，避免 form 词单出导致空启 plan. + + 策略：剥离 form/verb/filler 后剩余 ≥ 3 字符；或命中明显主题模式 / 时效词 / 长度阈值。 + """ + if _detect_timely(text): + return True + if re.search(r"(关于|对|针对|围绕)([^，。,;\s]{2,})", text): + return True + residual = text + for kw in (*STRONG_FORM_WORDS, *WEAK_FORM_WORDS, *VERB_WORDS, *FILLER_WORDS): + residual = residual.replace(kw, "") + residual = re.sub(r"[，。、,.;;:?？!！\s]+", "", residual) + if len(residual) >= 2: + return True + return len(text) >= 12 + + +def _extract_theme(text: str) -> str: + m = re.search(r"(关于|对|针对)([^，。,;\s]{2,16})", text) + if m: + return m.group(2) + return text.strip()[:16] + + +def _default_chat_reply(text: str) -> str: + norm = text.strip().lower() + if any(w in norm for w in ("你好", "hi", "hello", "嗨", "hey", "哈喽")): + return "你好！我是 Agent-Pilot，可以帮你写文档/做 PPT/画架构图。发`帮助`看示例 ✨" + if any(w in norm for w in ("谢谢", "感谢", "thanks", "thx", "辛苦")): + return "不客气，需要帮你做什么尽管说～" + if any(w in norm for w in ("收到", "好的", "ok", "嗯", "知道了")): + return "👌 随时叫我" + return "我在哦，需要我做点什么？发`帮助`看示例，比如「OpenClaw 三件套」「做 8 页 PPT 关于 X」" + + +def _build_clarify_questions(missing: list[str]) -> list[str]: + mapping = { + "audience": "这份产出主要是给谁看？（上级 / 同事 / 客户）", + "form": "希望生成什么类型？（文档 / PPT / 文档+PPT 三件套）", + "goal": "这个任务的核心目标是什么？", + "time": "希望多长时间内完成？", + } + questions = [mapping[m] for m in missing if m in mapping] + if not questions: + questions = [ + "希望生成什么类型？（文档 / PPT / 文档+PPT 三件套）", + "这份产出主要是给谁看？（上级 / 同事 / 客户）", + "希望多长时间内完成？", + ] + return questions + + +# ── 主 Router ────────────────────────────────────────────────────────────── -# LLM 闸门函数签名: 接收 (text, history) → LLMJudgement LLMJudgeFn = Callable[[str, list[ChatMessage]], Awaitable[LLMJudgement]] class IntentRouter: - """三闸门意图识别.""" + """5 闸门意图识别器.""" def __init__( self, @@ -148,91 +340,165 @@ def __init__( self.cooldown = cooldown or CooldownStore() self.recent_window = recent_window - async def detect(self, history: list[ChatMessage]) -> IntentResult: - """对最新一条消息做三闸门判断.""" + async def detect( + self, + history: list[ChatMessage], + *, + is_p2p: bool = True, + ) -> IntentResult: if not history: return IntentResult(verdict=IntentVerdict.NOT_INTENT) msg = history[-1] - text = msg.text or "" + text = (msg.text or "").strip() + if not text: + return IntentResult(verdict=IntentVerdict.NOT_INTENT, raw_text="") - # 显式触发优先 - if text.lstrip().lower().startswith(("/pilot", "@pilot")): + # ── 闸门 1：命令 ── + cmd = _detect_command(text) + if cmd is not None: + return IntentResult( + verdict=IntentVerdict.COMMAND, + rule_hits=[f"cmd:{cmd.value}"], + command_kind=cmd.value, + raw_text=text[:80], + suggested_owner=msg.sender_open_id, + ) + + # ── 闸门 2：显式 ── + if _detect_explicit(text): return IntentResult( verdict=IntentVerdict.READY, rule_hits=["explicit_pilot"], - theme_key=text[:24], + theme_key=_extract_theme(text), suggested_owner=msg.sender_open_id, suggested_title=text[:40], + needs_web_search=_detect_timely(text), + raw_text=text[:200], ) - # 闸门 1: 规则 - hits, theme = _detect_rules(text) - if not hits: - return IntentResult(verdict=IntentVerdict.NOT_INTENT, raw_text=text[:80]) - - # cooldown - if self.cooldown.is_cooldown(msg.chat_id, theme): - return IntentResult(verdict=IntentVerdict.COOLDOWN, theme_key=theme, rule_hits=hits) + # ── 闸门 3：关键字快速通道（短路 READY，仅当信号强且信息充分）── + hits, has_strong, has_weak, has_verb = _detect_keywords(text) + keyword_hit = has_strong or (has_weak and has_verb) + info_rich = _has_topic(text) + + if keyword_hit and info_rich: + theme = _extract_theme(text) + if self.cooldown.is_cooldown(msg.chat_id, theme, is_p2p=is_p2p): + return IntentResult( + verdict=IntentVerdict.COOLDOWN, + theme_key=theme, + rule_hits=hits, + ) + self.cooldown.mark_fired(msg.chat_id, theme) + return IntentResult( + verdict=IntentVerdict.READY, + rule_hits=hits + ["info_rich"], + theme_key=theme, + suggested_owner=msg.sender_open_id, + suggested_title=text[:40], + needs_web_search=_detect_timely(text), + raw_text=text[:200], + ) - # 上下文条件：最近 5-20 条同主题、>=2 人参与 + # ── 闸门 4：LLM 判定 ── recent = history[-self.recent_window:] - unique_senders = {m.sender_open_id for m in recent if m.text} - if len(recent) < 2 and len(unique_senders) < 2 and "explicit_pilot" not in hits: - # 单聊场景下放宽：至少有 1 人 + 1 句即可 - if len(recent) < 1: - return IntentResult(verdict=IntentVerdict.NOT_INTENT, rule_hits=hits, raw_text=text[:80]) - - # 闸门 2: LLM judgement: LLMJudgement | None = None if self.llm_judge is not None: try: judgement = await self.llm_judge(text, recent) except Exception as e: - logger.warning("LLM judge failed, fall back to rule-only: %s", e) + logger.warning("LLM judge failed, fallback: %s", e) + judgement = None + + if judgement is not None: + verdict_str = (judgement.verdict or "").lower() + if verdict_str == "ready" or (judgement.is_task and not judgement.missing): + return IntentResult( + verdict=IntentVerdict.READY, + rule_hits=hits + ["llm_ready"], + theme_key=_extract_theme(text), + suggested_owner=msg.sender_open_id, + suggested_title=judgement.summary or text[:40], + llm_judgement=judgement, + needs_web_search=judgement.needs_web_search or _detect_timely(text), + raw_text=text[:200], + ) + if verdict_str == "clarify" or (judgement.is_task and judgement.missing): + clarify_q = _build_clarify_questions(judgement.missing or ["form", "audience"]) + return IntentResult( + verdict=IntentVerdict.NEEDS_CLARIFY, + rule_hits=hits + ["llm_clarify"], + theme_key=_extract_theme(text), + suggested_owner=msg.sender_open_id, + suggested_title=judgement.summary or text[:40], + clarify_questions=clarify_q, + llm_judgement=judgement, + raw_text=text[:200], + ) + if verdict_str == "chat": + return IntentResult( + verdict=IntentVerdict.CHAT, + rule_hits=hits + ["llm_chat"], + chat_reply=judgement.friendly_reply or _default_chat_reply(text), + llm_judgement=judgement, + raw_text=text[:200], + ) + # 其他/timeout 走兜底 + + # ── 闸门 5：兜底 ── + if has_weak and not has_verb: + theme = _extract_theme(text) + if self.cooldown.is_cooldown(msg.chat_id, theme, is_p2p=is_p2p): + return IntentResult( + verdict=IntentVerdict.COOLDOWN, + theme_key=theme, + rule_hits=hits, + ) + self.cooldown.mark_fired(msg.chat_id, theme) + return IntentResult( + verdict=IntentVerdict.NEEDS_CLARIFY, + rule_hits=hits, + theme_key=theme, + suggested_owner=msg.sender_open_id, + suggested_title=text[:40], + clarify_questions=_build_clarify_questions(["form", "audience", "time"]), + raw_text=text[:200], + ) + + # 显式 form/verb 命中但没有 LLM 判定（V1 兼容场景） + if (has_strong or has_weak or has_verb) and self.llm_judge is None: + theme = _extract_theme(text) + return IntentResult( + verdict=IntentVerdict.NEEDS_CLARIFY, + rule_hits=hits, + theme_key=theme, + suggested_owner=msg.sender_open_id, + suggested_title=text[:40], + clarify_questions=_build_clarify_questions(["audience", "form", "time"]), + raw_text=text[:200], + ) + + if _detect_greeting(text): + return IntentResult( + verdict=IntentVerdict.CHAT, + rule_hits=hits + ["greeting"], + chat_reply=_default_chat_reply(text), + raw_text=text[:200], + ) + + if any(h.startswith("semantic:") for h in hits): + return IntentResult( + verdict=IntentVerdict.CHAT, + rule_hits=hits, + chat_reply=_default_chat_reply(text), + raw_text=text[:200], + ) - # 闸门 3: 最小信息（task_type + goal + 至少一项资源/受众/形态） - result = IntentResult( + # 真没识别到任何信号 → 仍然不沉默：返回 CHAT 友好引导 + return IntentResult( + verdict=IntentVerdict.CHAT, rule_hits=hits, - theme_key=theme, - suggested_owner=msg.sender_open_id, - suggested_title=text[:40], - llm_judgement=judgement, + chat_reply=_default_chat_reply(text), raw_text=text[:200], - verdict=IntentVerdict.NOT_INTENT, ) - if judgement is None: - # 没 LLM 判断，规则命中视作 NEEDS_CLARIFY 保守处理 - result.verdict = IntentVerdict.NEEDS_CLARIFY - result.clarify_questions = [ - "这份产出主要是给谁看？（上级 / 同事 / 客户）", - "希望生成什么类型？（文档 / PPT / 文档+PPT）", - "希望多长时间内完成？", - ] - return result - - if not judgement.is_task: - result.verdict = IntentVerdict.NOT_INTENT - return result - - # 最小信息检查 - has_goal = bool(judgement.goal and len(judgement.goal) >= 4) - has_form = any(k in text for k in ("文档", "PPT", "ppt", "汇报", "画布", "白板", "演示", "方案")) - has_audience = any(k in text for k in ("老板", "客户", "团队", "同事", "评委", "上级")) - - score = sum([has_goal, has_form, has_audience]) - if score >= 2: - result.verdict = IntentVerdict.READY - else: - result.verdict = IntentVerdict.NEEDS_CLARIFY - result.clarify_questions = [] - if not has_goal: - result.clarify_questions.append("这个任务的核心目标是什么？") - if not has_form: - result.clarify_questions.append("希望生成什么类型？（文档 / PPT / 画布 / 三件套）") - if not has_audience: - result.clarify_questions.append("汇报对象是谁？（上级 / 同事 / 客户）") - if not result.clarify_questions: - result.clarify_questions = ["请补充任务关键信息"] - - return result diff --git a/pilot/runtime/planner.py b/pilot/runtime/planner.py index 4e073ab..cdda727 100644 --- a/pilot/runtime/planner.py +++ b/pilot/runtime/planner.py @@ -31,9 +31,21 @@ "mentor.clarify", "mentor.summarize", "bitable.search", + # V1.5 新增 + "web.search", + "media.tts", + "lark.im.fetch_thread", + "lark.doc.search", + "lark.bitable.search", } +_TIMELY_RE = re.compile( + r"(最新|当前|近期|最近|本周|本月|今日|今年|去年|" + r"2026|2025|2024|今天|昨天|前天|刚才)" +) + + @dataclass class PlanStep: step_id: str @@ -92,9 +104,10 @@ def ready_steps(self) -> list[PlanStep]: 用户在飞书 IM 里用自然语言下达指令；你的任务是把它拆成一个 DAG（有向无环图），每个节点是一次工具调用。 可用工具: -- im.fetch_thread : 拉取当前或指定群聊的最近上下文（参数 chat_id, limit） +[内置] +- web.search : 联网搜索最新资料（DDG/Bing 兜底）。命中"最新/今年/趋势/进展"等时务必用作首步。 - doc.create : 创建飞书 Docx 文档（参数 title） -- doc.append : 往已创建文档追加内容（参数 doc_token；markdown 留空由工具自动生成） +- doc.append : 往文档追加内容（参数 doc_token；markdown 留空由工具自动生成） - canvas.create : 创建画布/白板（参数 title）；工具会基于上游 doc.append 自动设计架构图 - canvas.add_shape : 在画布上添加形状 - slide.generate : 生成演示稿（真 .pptx + Slidev HTML + 演讲稿） @@ -104,41 +117,91 @@ def ready_steps(self) -> list[PlanStep]: - sync.broadcast : 把状态广播到所有客户端 - mentor.clarify : 意图模糊时主动澄清 - mentor.summarize : 对一段对话做结构化总结 -- bitable.search : 多维表格 AI 节点检索（PRD §7.1 关联文档） +- media.tts : 文本转语音（默认禁用，AGENT_PILOT_ENABLE_TTS=1 才启） +[飞书 OpenAPI 真集成] +- lark.im.fetch_thread : 拉取当前/指定群聊最近 N 条消息 +- lark.doc.search : 检索用户云文档 +- lark.bitable.search : 多维表格记录检索 要求: 1. 输出严格 JSON: {"steps":[{"step_id":"...","tool":"...","description":"...","args":{...},"depends_on":["..."],"parallel_group":"..."}]} 2. step_id 用 s1/s2/... 简短格式 3. depends_on 只能指向前面的 step_id 4. parallel_group 相同的步骤可并行 -5. 若意图模糊，首步必须是 mentor.clarify -6. 最后一步必须是 archive.bundle -7. slide.generate / canvas.create 必须 depends_on 最后一个 doc.append（保证内容一致） -8. doc.append / slide.generate / canvas.create 的内容参数务必留空，工具会自动用 LLM 生成 +5. 含"最新/今年/趋势/进展"等时效词 → 第 0 步必须 web.search，并把 ${s0.results} 透传给下游 doc.append/slide.generate 的 search_results 参数 +6. 含"群聊/讨论/对话/上周" → 第 0 步用 lark.im.fetch_thread +7. 含"现有文档/已有方案" → 第 0 步用 lark.doc.search +8. 含"多维表格/数据/记录" → 用 lark.bitable.search +9. 若意图模糊，首步必须是 mentor.clarify；最后一步必须是 archive.bundle +10. slide.generate / canvas.create 必须 depends_on 最后一个 doc.append（保证内容一致） +11. doc.append / slide.generate / canvas.create 的 markdown/outline 参数务必留空，工具会自动用 LLM 生成 + +## Few-Shot 8 例 + +[1] 「帮我写一份关于 AI Agent 发展趋势的报告」 +{"steps":[ + {"step_id":"s1","tool":"doc.create","args":{"title":"AI Agent 发展趋势报告"},"depends_on":[]}, + {"step_id":"s2","tool":"doc.append","args":{"doc_token":"${s1.doc_token}"},"depends_on":["s1"]}, + {"step_id":"s3","tool":"archive.bundle","args":{},"depends_on":["s2"]} +]} + +[2] 「OpenClaw 三件套」 +{"steps":[ + {"step_id":"s1","tool":"web.search","args":{"query":"OpenClaw 飞书 开源"},"depends_on":[]}, + {"step_id":"s2","tool":"doc.create","args":{"title":"OpenClaw 介绍"},"depends_on":["s1"]}, + {"step_id":"s3","tool":"doc.append","args":{"doc_token":"${s2.doc_token}","search_results":"${s1.results}"},"depends_on":["s2"]}, + {"step_id":"s4","tool":"canvas.create","args":{"title":"OpenClaw 架构图"},"depends_on":["s3"],"parallel_group":"g1"}, + {"step_id":"s5","tool":"slide.generate","args":{"title":"OpenClaw 介绍","search_results":"${s1.results}"},"depends_on":["s3"],"parallel_group":"g1"}, + {"step_id":"s6","tool":"slide.rehearse","args":{"slide_id":"${s5.slide_id}"},"depends_on":["s5"]}, + {"step_id":"s7","tool":"archive.bundle","args":{},"depends_on":["s4","s6"]} +]} + +[3] 「今年最新 AI Agent 趋势汇报 PPT」 +{"steps":[ + {"step_id":"s1","tool":"web.search","args":{"query":"2026 AI Agent 最新趋势"},"depends_on":[]}, + {"step_id":"s2","tool":"slide.generate","args":{"title":"AI Agent 趋势汇报","search_results":"${s1.results}"},"depends_on":["s1"]}, + {"step_id":"s3","tool":"slide.rehearse","args":{"slide_id":"${s2.slide_id}"},"depends_on":["s2"]}, + {"step_id":"s4","tool":"archive.bundle","args":{},"depends_on":["s3"]} +]} + +[4] 「把上周群里讨论的活动方案整理出来」 +{"steps":[ + {"step_id":"s1","tool":"lark.im.fetch_thread","args":{"limit":80},"depends_on":[]}, + {"step_id":"s2","tool":"doc.create","args":{"title":"活动方案"},"depends_on":["s1"]}, + {"step_id":"s3","tool":"doc.append","args":{"doc_token":"${s2.doc_token}","context":"${s1.messages}"},"depends_on":["s2"]}, + {"step_id":"s4","tool":"archive.bundle","args":{},"depends_on":["s3"]} +]} -## Few-Shot +[5] 「把已有的 PRD 转成 8 页 PPT」 +{"steps":[ + {"step_id":"s1","tool":"lark.doc.search","args":{"query":"PRD"},"depends_on":[]}, + {"step_id":"s2","tool":"slide.generate","args":{"title":"PRD 演示稿","pages":8},"depends_on":["s1"]}, + {"step_id":"s3","tool":"slide.rehearse","args":{"slide_id":"${s2.slide_id}"},"depends_on":["s2"]}, + {"step_id":"s4","tool":"archive.bundle","args":{},"depends_on":["s3"]} +]} -意图: 「帮我写一份关于 AI Agent 发展趋势的报告」 +[6] 「用多维表格里的销售数据做月报」 {"steps":[ - {"step_id":"s1","tool":"doc.create","description":"创建飞书 Docx","args":{"title":"AI Agent 发展趋势报告"},"depends_on":[]}, - {"step_id":"s2","tool":"doc.append","description":"AI 自动生成详细报告内容","args":{"doc_token":"${s1.doc_token}"},"depends_on":["s1"]}, - {"step_id":"s3","tool":"archive.bundle","description":"汇总产物并生成分享链接","args":{},"depends_on":["s2"]} + {"step_id":"s1","tool":"lark.bitable.search","args":{"query":"销售"},"depends_on":[]}, + {"step_id":"s2","tool":"doc.create","args":{"title":"销售月报"},"depends_on":["s1"]}, + {"step_id":"s3","tool":"doc.append","args":{"doc_token":"${s2.doc_token}","data":"${s1.records}"},"depends_on":["s2"]}, + {"step_id":"s4","tool":"archive.bundle","args":{},"depends_on":["s3"]} ]} -意图: 「产品方案 + 架构图 + 汇报 PPT 三件套」 +[7] 「帮我做个汇报」（信息严重不足） {"steps":[ - {"step_id":"s1","tool":"doc.create","description":"创建产品方案文档","args":{"title":"产品方案"},"depends_on":[]}, - {"step_id":"s2","tool":"doc.append","description":"生成方案正文","args":{"doc_token":"${s1.doc_token}"},"depends_on":["s1"]}, - {"step_id":"s3","tool":"canvas.create","description":"基于方案生成架构图","args":{"title":"产品架构图"},"depends_on":["s2"],"parallel_group":"g1"}, - {"step_id":"s4","tool":"slide.generate","description":"基于方案生成 PPT","args":{"title":"产品方案"},"depends_on":["s2"],"parallel_group":"g1"}, - {"step_id":"s5","tool":"slide.rehearse","description":"为 PPT 生成演讲稿","args":{"slide_id":"${s4.slide_id}"},"depends_on":["s4"]}, - {"step_id":"s6","tool":"archive.bundle","description":"汇总","args":{},"depends_on":["s3","s5"]} + {"step_id":"s0","tool":"mentor.clarify","args":{"questions":["要汇报什么主题？","汇报对象是谁？","希望几页 PPT？"]},"depends_on":[]}, + {"step_id":"s1","tool":"archive.bundle","args":{},"depends_on":["s0"]} ]} -意图: 「帮我做个汇报」（信息严重不足） +[8] 「产品方案 + 架构图 + 评审 PPT」 {"steps":[ - {"step_id":"s0","tool":"mentor.clarify","description":"主动澄清","args":{"questions":["要汇报什么主题？","汇报对象是谁？","希望几页 PPT？"]},"depends_on":[]}, - {"step_id":"s1","tool":"archive.bundle","description":"占位，澄清后用户重新触发","args":{},"depends_on":["s0"]} + {"step_id":"s1","tool":"doc.create","args":{"title":"产品方案"},"depends_on":[]}, + {"step_id":"s2","tool":"doc.append","args":{"doc_token":"${s1.doc_token}"},"depends_on":["s1"]}, + {"step_id":"s3","tool":"canvas.create","args":{"title":"产品架构图"},"depends_on":["s2"],"parallel_group":"g1"}, + {"step_id":"s4","tool":"slide.generate","args":{"title":"产品方案"},"depends_on":["s2"],"parallel_group":"g1"}, + {"step_id":"s5","tool":"slide.rehearse","args":{"slide_id":"${s4.slide_id}"},"depends_on":["s4"]}, + {"step_id":"s6","tool":"archive.bundle","args":{},"depends_on":["s3","s5"]} ]} """ @@ -156,18 +219,26 @@ def plan_from_intent( meta: dict[str, Any] | None = None, llm_fn: PlannerLLMFn | None = None, ) -> Plan: - """主入口：意图 → Plan.""" + """主入口：意图 → Plan. + + - meta["needs_web_search"]==True 或 intent 中含时效词 → 启发式自动插 web.search 第 0 步 + - 注入 web.search 后，所有 doc.append / slide.generate 自动 depends_on=s_web 且接 search_results + """ intent = (intent or "").strip() if not intent: raise ValueError("intent must not be empty") + meta_dict = dict(meta or {}) plan_id = f"plan_{int(time.time())}_{uuid.uuid4().hex[:6]}" + needs_web = bool(meta_dict.get("needs_web_search")) or bool(_TIMELY_RE.search(intent)) + steps = _plan_with_llm(intent, llm_fn) if llm_fn else [] if not steps: - steps = _plan_heuristic(intent) + steps = _plan_heuristic(intent, needs_web_search=needs_web) + elif needs_web and not any(s.tool == "web.search" for s in steps): + steps = _inject_web_search(steps, intent) - # 保证 archive.bundle 是最后一步 if not any(s.tool == "archive.bundle" for s in steps): last_ids = [s.step_id for s in steps] steps.append( @@ -179,14 +250,33 @@ def plan_from_intent( ) ) + meta_dict["needs_web_search"] = needs_web return Plan( plan_id=plan_id, user_open_id=user_open_id, intent=intent, steps=steps, created_ts=int(time.time()), - meta=meta or {}, + meta=meta_dict, + ) + + +def _inject_web_search(steps: list[PlanStep], intent: str) -> list[PlanStep]: + """LLM 漏掉 web.search 时由调用方启发式补一步.""" + web_step = PlanStep( + step_id="s0", + tool="web.search", + description="联网搜索最新资料（自动注入，因检测到时效词或上游 needs_web_search）", + args={"query": intent[:120], "k": 5}, ) + out = [web_step] + for s in steps: + if not s.depends_on: + s.depends_on = ["s0"] + if s.tool in ("doc.append", "slide.generate"): + s.args = {**s.args, "search_results": "${s0.results}"} + out.append(s) + return out # ── LLM 路径 ──────────────────────────────────────────────────────────────── @@ -231,7 +321,7 @@ def _title_from_intent(intent: str, suffix: str) -> str: return f"[Agent-Pilot] {trimmed} · {suffix}" -def _plan_heuristic(intent: str) -> list[PlanStep]: +def _plan_heuristic(intent: str, *, needs_web_search: bool = False) -> list[PlanStep]: want_doc = bool(re.search(r"(文档|文稿|方案|需求|纪要|总结|报告|介绍|写)", intent)) want_canvas = bool(re.search(r"(画布|白板|流程图|架构图|画图|思维导图)", intent)) want_slide = bool(re.search(r"(PPT|演示|演讲|slide|汇报|幻灯)", intent, re.I)) @@ -242,14 +332,27 @@ def _plan_heuristic(intent: str) -> list[PlanStep]: want_slide = True steps: list[PlanStep] = [] + web_id: Optional[str] = None last_id: Optional[str] = None doc_append_id: Optional[str] = None + if needs_web_search: + sid = "s1" + steps.append(PlanStep( + step_id=sid, + tool="web.search", + description="联网搜索最新资料（自动注入，因检测到时效词）", + args={"query": intent[:120], "k": 5}, + )) + web_id = sid + last_id = sid + if want_fetch: sid = f"s{len(steps) + 1}" steps.append(PlanStep(step_id=sid, tool="im.fetch_thread", description="拉取最近群聊/对话作为上下文", - args={"limit": 50})) + args={"limit": 50}, + depends_on=[last_id] if last_id else [])) last_id = sid if want_doc: @@ -260,13 +363,18 @@ def _plan_heuristic(intent: str) -> list[PlanStep]: depends_on=[last_id] if last_id else [])) doc_create_id = sid sid2 = f"s{len(steps) + 1}" + append_args: dict[str, Any] = { + "doc_token": f"${{{doc_create_id}.doc_token}}", + "intent": intent, + } + if web_id: + append_args["search_results"] = f"${{{web_id}.results}}" steps.append(PlanStep(step_id=sid2, tool="doc.append", - description="向文档追加 AI 自动生成的详细内容", - args={"doc_token": f"${{{doc_create_id}.doc_token}}", "intent": intent}, + description="向文档追加 AI 自动生成的详细内容" + ("（含联网资料）" if web_id else ""), + args=append_args, depends_on=[doc_create_id])) doc_append_id = sid2 - parallel = [] if want_canvas: sid = f"s{len(steps) + 1}" deps = [doc_append_id] if doc_append_id else ([last_id] if last_id else []) @@ -275,17 +383,21 @@ def _plan_heuristic(intent: str) -> list[PlanStep]: args={"title": _title_from_intent(intent, "画布"), "intent": intent}, depends_on=deps, parallel_group="g1")) - parallel.append(sid) if want_slide: sid = f"s{len(steps) + 1}" deps = [doc_append_id] if doc_append_id else ([last_id] if last_id else []) + slide_args: dict[str, Any] = { + "title": _title_from_intent(intent, "演示稿"), + "intent": intent, + } + if web_id: + slide_args["search_results"] = f"${{{web_id}.results}}" steps.append(PlanStep(step_id=sid, tool="slide.generate", - description="基于文档内容生成演示稿（真 PPTX + HTML + 演讲稿）", - args={"title": _title_from_intent(intent, "演示稿"), "intent": intent}, + description="基于文档内容生成演示稿（真 PPTX + HTML + 演讲稿）" + ("（含联网资料）" if web_id else ""), + args=slide_args, depends_on=deps, parallel_group="g1")) - parallel.append(sid) slide_id_ref = sid sid2 = f"s{len(steps) + 1}" steps.append(PlanStep(step_id=sid2, tool="slide.rehearse", diff --git a/pilot/runtime/session.py b/pilot/runtime/session.py index d2c6c55..cfeab7f 100644 --- a/pilot/runtime/session.py +++ b/pilot/runtime/session.py @@ -79,7 +79,7 @@ def to_dict(self) -> dict[str, Any]: class TaskState(str, Enum): - """PRD §10 任务状态机的 10 个状态.""" + """PRD §10 任务状态机.""" SUGGESTED = "suggested" ASSIGNED = "assigned" @@ -94,6 +94,56 @@ class TaskState(str, Enum): IGNORED = "ignored" +STAGES = ("context", "doc", "ppt", "rehearse") + + +# 合法转移图（PRD §10）： +# suggested → assigned/ignored +# assigned → context_pending/planning（信息已足时直接 planning）/ignored +# context_pending → planning/ignored +# planning → doc_generating/ppt_generating/failed +# doc_generating → ppt_generating/reviewing/failed +# ppt_generating → reviewing/failed +# reviewing → delivered/failed/paused +# delivered → reviewing（重做）/ignored +# paused → planning/doc_generating/ppt_generating/reviewing/ignored +# failed → planning（重试）/ignored +# ignored → suggested（重新激活） +LEGAL_TRANSITIONS: dict["TaskState", set["TaskState"]] = { + TaskState.SUGGESTED: {TaskState.ASSIGNED, TaskState.IGNORED}, + TaskState.ASSIGNED: {TaskState.CONTEXT_PENDING, TaskState.PLANNING, TaskState.IGNORED, TaskState.PAUSED}, + TaskState.CONTEXT_PENDING: {TaskState.PLANNING, TaskState.IGNORED, TaskState.PAUSED}, + TaskState.PLANNING: { + TaskState.DOC_GENERATING, + TaskState.PPT_GENERATING, + TaskState.FAILED, + TaskState.PAUSED, + }, + TaskState.DOC_GENERATING: { + TaskState.PPT_GENERATING, + TaskState.REVIEWING, + TaskState.FAILED, + TaskState.PAUSED, + }, + TaskState.PPT_GENERATING: {TaskState.REVIEWING, TaskState.FAILED, TaskState.PAUSED}, + TaskState.REVIEWING: {TaskState.DELIVERED, TaskState.FAILED, TaskState.PAUSED}, + TaskState.DELIVERED: {TaskState.REVIEWING, TaskState.IGNORED}, + TaskState.PAUSED: { + TaskState.PLANNING, + TaskState.DOC_GENERATING, + TaskState.PPT_GENERATING, + TaskState.REVIEWING, + TaskState.IGNORED, + }, + TaskState.FAILED: {TaskState.PLANNING, TaskState.IGNORED}, + TaskState.IGNORED: {TaskState.SUGGESTED}, +} + + +class IllegalTransitionError(ValueError): + """非法状态转移；调用方需根据业务决定降级 / 报错.""" + + @dataclass class Task: """A task 是协调对象. @@ -125,10 +175,33 @@ class Task: meta: dict[str, Any] = field(default_factory=dict) - def transition(self, new_state: TaskState) -> None: + def transition(self, new_state: TaskState, *, force: bool = False) -> None: + """状态迁移；非法转移默认抛 IllegalTransitionError，可用 force=True 跳过校验.""" + if not force: + allowed = LEGAL_TRANSITIONS.get(self.state, set()) + if new_state == self.state: + self.updated_at = _ts() + return + if new_state not in allowed: + raise IllegalTransitionError( + f"非法转移 {self.state.value} → {new_state.value}；合法目标={[s.value for s in allowed]}" + ) self.state = new_state self.updated_at = _ts() + def transition_to(self, new_state: TaskState) -> None: + """transition() 的别名，匹配 PRD §10 命名.""" + self.transition(new_state) + + def can_transition_to(self, new_state: TaskState) -> bool: + return new_state in LEGAL_TRANSITIONS.get(self.state, set()) + + def set_stage_owner(self, stage: str, owner_open_id: str) -> None: + if stage not in STAGES: + raise ValueError(f"未知 stage={stage}；合法值={STAGES}") + self.stage_owners[stage] = owner_open_id + self.updated_at = _ts() + def lock_owner(self, owner_open_id: str) -> None: self.owner_open_id = owner_open_id self.owner_locked = True diff --git a/pilot/surface/dashboard/server.py b/pilot/surface/dashboard/server.py index 7954e83..ff1f926 100644 --- a/pilot/surface/dashboard/server.py +++ b/pilot/surface/dashboard/server.py @@ -114,18 +114,26 @@ async def session_detail(session_id: str): @app.get("/api/events/{session_id}") async def event_stream(session_id: str): - """SSE 事件流（前端 EventSource 订阅）.""" + """SSE 事件流（前端 EventSource 订阅）. + + V1.5 加 30s heartbeat 保持代理 / nginx / 飞书 hubs 不掐线。 + """ from pilot.context.event_log import EventLog async def gen(): log = EventLog(session_id) offset = 0 + last_ping = time.monotonic() while True: events = log.read_all() new = events[offset:] for evt in new: yield f"data: {json.dumps(evt, ensure_ascii=False)}\n\n" offset = len(events) + now = time.monotonic() + if now - last_ping >= 30.0: + yield f"event: heartbeat\ndata: {json.dumps({'ts': int(time.time())})}\n\n" + last_ping = now await asyncio.sleep(1.0) return StreamingResponse(gen(), media_type="text/event-stream", diff --git a/pilot/surface/dashboard/static/dashboard.html b/pilot/surface/dashboard/static/dashboard.html index a985dbd..173547a 100644 --- a/pilot/surface/dashboard/static/dashboard.html +++ b/pilot/surface/dashboard/static/dashboard.html @@ -3,9 +3,8 @@ <head> <meta charset="UTF-8" /> <meta name="viewport" content="width=device-width, initial-scale=1" /> -<title>仪表盘 · Agent-Pilot V1 +仪表盘 · Agent-Pilot V1.5 - @@ -28,11 +29,12 @@
🛫
-
Agent-Pilot V1 仪表盘
+
Agent-Pilot V1.5 仪表盘
plan_id: {{PLAN_ID}}
-
+
+ 已用时 0s 连接中
@@ -40,37 +42,33 @@
- -
-

Agent thinking 流

-
+
+

执行进度

+ 0 / 0 步完成 +
+
+ +

事件流

+
-
@@ -82,6 +80,90 @@

工具调用

document.getElementById("plan-id-display").textContent = planId || "(未指定)"; +// ── i18n: 事件 kind 与 工具名 ── +const KIND_LABELS = { + "plan_start": "🛫 任务启动", + "plan.start": "🛫 任务启动", + "plan_done": "🎉 任务交付", + "plan.done": "🎉 任务交付", + "plan_error": "❌ 任务失败", + "step.start": "🚀 步骤开始", + "step.done": "✅ 步骤完成", + "step.failed": "❌ 步骤失败", + "step.skipped": "⏭️ 步骤跳过", + "user_message": "🗣️ 用户消息", + "assistant_text": "💬 AI 回复", + "tool_result": "🛠️ 工具返回", + "harness.assemble": "🔧 组装上下文", + "harness.llm_call.start": "🤖 调用 LLM", + "harness.llm_call.done": "✅ LLM 完成", + "harness.parse": "📝 解析响应", + "harness.permit": "🔒 权限检查", + "harness.tools.read.start":"🔍 读工具", + "harness.tools.write.start":"✍️ 写工具", + "harness.feedback": "🔁 反馈结果", + "harness.context_reset": "🧹 上下文重置", + "harness.end": "🏁 终止判定", +}; + +const TOOL_LABELS = { + "doc.create": "📄 创建飞书文档", + "doc.append": "📝 AI 生成文档内容", + "canvas.create": "🎨 创建画布/架构图", + "canvas.add_shape": "✏️ 画布添加形状", + "slide.generate": "📊 生成 PPT 大纲与文件", + "slide.rehearse": "🎤 生成演讲稿", + "voice.transcribe": "🎙️ 语音转文字", + "media.tts": "🔊 文字转语音", + "web.search": "🌐 联网搜索", + "archive.bundle": "📦 汇总归档", + "im.fetch_thread":"💬 拉取群聊", + "lark.im.fetch_thread": "💬 飞书群聊抓取", + "lark.doc.search":"🔎 飞书文档检索", + "lark.bitable.search": "📊 多维表格检索", + "mentor.clarify": "❓ 主动澄清", + "mentor.summarize": "📋 结构化总结", +}; + +function labelOf(kind, fallback="") { return KIND_LABELS[kind] || fallback || kind; } +function toolLabelOf(name) { return TOOL_LABELS[name] || name; } + +// ── 状态 ── +let planStartedAt = null; // unix sec +let stepTotal = 0; +let stepCompleted = 0; +let receivedKinds = []; + +setInterval(() => { + if (!planStartedAt) return; + const sec = Math.floor(Date.now() / 1000 - planStartedAt); + const m = Math.floor(sec / 60); + const s = sec % 60; + document.getElementById("elapsed").textContent = (m > 0 ? `${m}m ` : "") + `${s}s`; +}, 1000); + +function updateProgress() { + document.getElementById("step-total").textContent = stepTotal; + document.getElementById("step-completed").textContent = stepCompleted; + const pct = stepTotal > 0 ? Math.min(100, Math.round(stepCompleted / stepTotal * 100)) : 0; + document.getElementById("progress-fill").style.width = pct + "%"; +} + +function pushArtifact(a) { + const dom = document.getElementById("artifact-list"); + if (dom.querySelector(".text-slate-500")) dom.innerHTML = ""; + const it = document.createElement("a"); + it.className = "block p-2 rounded hover:bg-white/5 slide-in"; + const url = a.url || a.uri || "#"; + const kind = a.kind || a.type || "artifact"; + const ttl = a.title || kind; + const emoji = {doc: "📄", canvas: "🎨", slide: "📊", tts: "🔊"}[kind] || "📦"; + it.href = url; + it.target = "_blank"; + it.innerHTML = `
${emoji} ${ttl}
${url}
`; + dom.appendChild(it); +} + // ── Sessions ── async function loadSessions() { try { @@ -102,9 +184,7 @@

工具调用

`; dom.appendChild(card); } - } catch (e) { - console.warn(e); - } + } catch (e) { console.warn(e); } } // ── Tools ── @@ -115,11 +195,12 @@

工具调用

dom.innerHTML = ""; for (const t of tools) { const it = document.createElement("div"); - it.className = "flex items-center gap-2 p-2 rounded hover:bg-white/5"; + it.className = "flex items-center gap-2 p-1 rounded hover:bg-white/5"; const dot = t.read_only ? "bg-blue-400" : "bg-orange-400"; + const cn = toolLabelOf(t.name); it.innerHTML = ` - ${t.name} + ${cn} ${t.read_only ? "读" : "写"} `; dom.appendChild(it); @@ -127,7 +208,7 @@

工具调用

} catch (e) { console.warn(e); } } -// ── SSE 事件流（如果 plan_id 有效）── +// ── SSE ── function subscribeEvents() { if (!planId) return; const dom = document.getElementById("thinking-stream"); @@ -138,9 +219,42 @@

工具调用

es.onmessage = (e) => { try { const evt = JSON.parse(e.data); + receivedKinds.push(evt.kind); + + if (evt.kind === "plan_start" || evt.kind === "plan.start") { + planStartedAt = evt.ts || Math.floor(Date.now() / 1000); + stepTotal = (evt.payload?.steps || []).length || stepTotal; + stepCompleted = 0; + updateProgress(); + } + if (evt.kind === "step.done") { + stepCompleted += 1; + updateProgress(); + // 工具产出 → artifacts + const tool = evt.payload?.tool || ""; + const r = evt.payload?.result || evt.payload || {}; + if (tool === "doc.create" || tool === "doc.append") { + if (r.url || r.doc_token) pushArtifact({kind: "doc", title: r.title || "飞书文档", url: r.url || ""}); + } else if (tool === "canvas.create") { + if (r.tldraw_url || r.url) pushArtifact({kind: "canvas", title: r.title || "画布", url: r.tldraw_url || r.url}); + } else if (tool === "slide.generate") { + const u = r.pptx_url_absolute || r.pptx_url || ""; + if (u) pushArtifact({kind: "slide", title: r.title || "演示稿", url: u}); + } else if (tool === "media.tts") { + const u = r.mp3_url_absolute || r.mp3_url || ""; + if (u) pushArtifact({kind: "tts", title: "语音", url: u}); + } + } + if (evt.kind === "plan_done" || evt.kind === "plan.done") { + for (const a of (evt.payload?.artifacts || [])) { + pushArtifact(a); + } + document.getElementById("ws-status").textContent = "完成"; + } + const item = document.createElement("div"); item.className = "p-2 rounded slide-in flex gap-2"; - const t = new Date(evt.ts * 1000); + const t = new Date((evt.ts || Math.floor(Date.now()/1000)) * 1000); const tStr = t.toTimeString().slice(0, 8); const kindColor = { "user_message": "text-cyan-300", @@ -149,57 +263,36 @@

工具调用

"step.start": "text-yellow-300", "step.done": "text-green-300", "step.failed": "text-red-300", - "harness.assemble": "text-blue-300", - "harness.llm_call.start": "text-blue-400", - "harness.llm_call.done": "text-green-400", - "harness.tools.read.start": "text-orange-300", - "harness.tools.write.start": "text-pink-300", + "plan_start": "text-blue-300", + "plan_done": "text-emerald-300", + "plan_error": "text-red-300", }[evt.kind] || "text-slate-400"; + const tool = evt.payload?.tool ? `${toolLabelOf(evt.payload.tool)}` : ""; + const detail = JSON.stringify(evt.payload || {}).slice(0, 200); + item.innerHTML = ` ${tStr} - [${evt.kind}] - ${JSON.stringify(evt.payload).slice(0, 200)} + ${labelOf(evt.kind)} + ${tool} + ${detail} `; dom.insertBefore(item, dom.firstChild); - // 高亮对应 harness step - highlightStep(evt.kind); - } catch {} + } catch (err) { console.warn(err); } }; es.onerror = () => { - document.getElementById("ws-status").textContent = "断开"; + document.getElementById("ws-status").textContent = "断开重连"; }; + es.addEventListener("heartbeat", () => { + document.getElementById("ws-status").textContent = "实时（心跳）"; + }); } catch (e) { console.warn(e); } } -function highlightStep(kind) { - const map = { - "harness.assemble": 0, - "harness.llm_call.start": 1, - "harness.llm_call.done": 1, - "harness.parse": 2, - "harness.permit": 3, - "harness.tools.read.start": 4, - "harness.tools.write.start": 4, - "harness.feedback": 5, - "harness.context_reset": 6, - "harness.end": 7, - }; - const idx = map[kind]; - if (idx === undefined) return; - const items = document.getElementById("harness-steps").children; - for (let i = 0; i < items.length; i++) { - items[i].className = i < idx ? "step-done pl-3 py-2" - : i === idx ? "step-running pl-3 py-2" - : "step-pending pl-3 py-2"; - } -} - -// ── 初始加载 plan 信息 ── async function loadPlanInfo() { if (!planId) { - const dom = document.getElementById("thinking-stream"); - dom.innerHTML = '
请从飞书发送消息触发任务，dashboard 将实时展示 Agent 思维流。

示例：/pilot 关于 AI Agent 发展的汇报 PPT
'; + document.getElementById("thinking-stream").innerHTML = + '
请从飞书发送消息触发任务，dashboard 将实时展示 Agent 思维流。

示例：OpenClaw 三件套
'; return; } } diff --git a/pilot/surface/dashboard/static/index.html b/pilot/surface/dashboard/static/index.html index 800a368..15ddb0b 100644 --- a/pilot/surface/dashboard/static/index.html +++ b/pilot/surface/dashboard/static/index.html @@ -84,8 +84,8 @@

5 层 Harness 架构

—
-
飞书 SKILL
-
29
+
飞书 OpenAPI
+
IM·Doc·Bitable
Uptime
@@ -146,7 +146,7 @@

评分维度

const LAYERS = [ {emoji: "🚂", name: "Runtime", desc: "8 步 Claude Code harness loop", color: "from-blue-500 to-cyan-500"}, {emoji: "📚", name: "Context", desc: "append-only event log + filesystem memory", color: "from-cyan-500 to-teal-500"}, - {emoji: "🛠️", name: "Capability", desc: "29 飞书 SKILL + 4 pilot SKILL + 三 Agent harness", color: "from-purple-500 to-pink-500"}, + {emoji: "🛠️", name: "Capability", desc: "10+ 内置工具 · 飞书 IM/Doc/Bitable · web.search 联网", color: "from-purple-500 to-pink-500"}, {emoji: "🛡️", name: "Governance", desc: "4 级权限 + owner_lock + 沙箱 + 审计", color: "from-orange-500 to-red-500"}, {emoji: "🌐", name: "Surface", desc: "飞书 IM + Web Dashboard + Flutter + MCP/ACP", color: "from-pink-500 to-rose-500"}, ]; diff --git a/pilot/surface/feishu/bot.py b/pilot/surface/feishu/bot.py index 284bbf7..6cd6b6e 100644 --- a/pilot/surface/feishu/bot.py +++ b/pilot/surface/feishu/bot.py @@ -1,28 +1,68 @@ -"""飞书 lark-oapi WebSocket 长连接 Bot 入口. +"""飞书 lark-oapi WebSocket 长连接 Bot 入口（V1.5）. 启动: python -m pilot bot -设计: - - 用 lark-oapi 监听 IM 消息 + 卡片回调 - - 把消息打进 FeishuRouter（asyncio） - - 把回调结果（text / card / 任务启动）回写飞书 +V1 → V1.5 关键演化: + - 注入 LLM judge（MiniMax）到 IntentRouter 闸门 4。 + - 内存版 idempotency：60s 内同 (sender, md5(text)) 去重，避免重复创建任务。 + - 删除所有硬编码 IP；URL 走 DASHBOARD_PUBLIC_BASE，留空则用相对路径。 + - artifacts 收集去重 + 过滤空 URL（修 V1 卡片里出现 [](　) 的空链接 bug）。 + - plan_launcher 透传 needs_web_search → Planner 可决定是否插 web.search 第 0 步。 """ from __future__ import annotations import asyncio +import hashlib import json import logging import os import threading +import time from typing import Any logger = logging.getLogger("pilot.surface.feishu.bot") +JUDGE_PROMPT = ( + "你是飞书办公助手 Agent-Pilot 的意图分类器。\n" + "分类规则：\n" + "- ready: 用户在表达明确的任务意图（要做文档/PPT/画布/三件套等），且信息够（有目标 + 有形态）\n" + "- chat: 闲聊、打招呼、感谢、表情、问与办公任务无关的事\n" + "- clarify: 是任务但信息不够（缺目标/缺受众/缺形态/缺时间）\n" + "- not_intent: 空消息或纯符号\n\n" + "只输出 JSON，不要任何额外文字：\n" + "{\n" + ' "verdict": "ready|chat|clarify|not_intent",\n' + ' "task_type": "doc|ppt|canvas|trio|none",\n' + ' "summary": "任务一句话归纳，<=20 字",\n' + ' "missing": ["audience","form","goal","time"],\n' + ' "friendly_reply": "如果是 chat，给一句友好回复，<=40 字。否则空字符串",\n' + ' "needs_web_search": false\n' + "}\n" +) + + +def _public_dashboard_url(plan_id: str) -> str: + """Dashboard 链接生成器；DASHBOARD_PUBLIC_BASE 留空则只给相对路径.""" + base = (os.getenv("DASHBOARD_PUBLIC_BASE") or "").rstrip("/") + return f"{base}/dashboard?plan_id={plan_id}" if base else f"/dashboard?plan_id={plan_id}" + + +def _absolute_artifact_url(rel_or_abs: str) -> str: + """如果是相对 /artifacts/... 路径且配了 base，就拼成绝对 URL；否则原样返回.""" + if not rel_or_abs: + return "" + if rel_or_abs.startswith(("http://", "https://")): + return rel_or_abs + base = (os.getenv("DASHBOARD_PUBLIC_BASE") or "").rstrip("/") + if rel_or_abs.startswith("/") and base: + return f"{base}{rel_or_abs}" + return rel_or_abs + + def run() -> None: - """阻塞启动飞书机器人.""" if not os.getenv("FEISHU_APP_ID") or os.getenv("FEISHU_APP_ID") == "cli_your_app_id_here": logger.error("未配置 FEISHU_APP_ID，无法启动 bot") return @@ -33,37 +73,118 @@ def run() -> None: logger.error("lark-oapi 未安装：pip install lark-oapi") return + from pilot.capability.tools.registry import default_registry + from pilot.llm.client import default_client + from pilot.llm.safe_json import safe_json_parse + from pilot.runtime.intent_router import ChatMessage, IntentRouter, LLMJudgement + from pilot.runtime.orchestrator import Orchestrator + from pilot.runtime.planner import plan_from_intent from pilot.surface.feishu.client import get_feishu_client from pilot.surface.feishu.router import FeishuRouter - from pilot.runtime.intent_router import IntentRouter - from pilot.runtime.planner import plan_from_intent - from pilot.runtime.orchestrator import Orchestrator - from pilot.capability.tools.registry import default_registry feishu = get_feishu_client() - # 注入 plan_launcher - async def _plan_launcher(*, intent: str, chat_id: str, sender_open_id: str) -> dict[str, Any]: - plan = plan_from_intent(intent, user_open_id=sender_open_id) + # ── LLM Judge（闸门 4）+ 内存 LRU 缓存 ── + _judge_cache: dict[str, tuple[float, LLMJudgement]] = {} + _judge_cache_ttl = 600.0 + + async def _llm_judge(text: str, history: list[ChatMessage]) -> LLMJudgement: + cache_key = hashlib.md5(text.encode("utf-8")).hexdigest()[:16] + now = time.time() + cached = _judge_cache.get(cache_key) + if cached and (now - cached[0] < _judge_cache_ttl): + return cached[1] + + history_str = "\n".join(f"- {m.text[:120]}" for m in history[-5:] if m.text) or f"- {text[:120]}" + user_prompt = f"用户消息历史：\n{history_str}\n\n请输出 JSON 判断结果。" + + try: + resp = await asyncio.wait_for( + default_client().chat( + system=JUDGE_PROMPT, + messages=[{"role": "user", "content": user_prompt}], + temperature=0.0, + max_tokens=256, + response_format={"type": "json_object"}, + ), + timeout=8.0, + ) + except asyncio.TimeoutError: + logger.warning("LLM judge timeout (8s)") + return LLMJudgement(verdict="not_intent") + except Exception as e: + logger.warning("LLM judge failed: %s", e) + return LLMJudgement(verdict="not_intent") + + text_resp = resp.get("text", "") or "" + if not text_resp: + for blk in resp.get("content", []) or []: + if isinstance(blk, dict) and blk.get("type") == "text": + text_resp = blk.get("text", "") + break + + obj = safe_json_parse(text_resp) or {} + j = LLMJudgement( + verdict=obj.get("verdict", "not_intent"), + is_task=obj.get("verdict") in ("ready", "clarify"), + task_type=obj.get("task_type", "none"), + summary=str(obj.get("summary", ""))[:30], + missing=obj.get("missing") or [], + friendly_reply=str(obj.get("friendly_reply", ""))[:60], + needs_web_search=bool(obj.get("needs_web_search", False)), + ) + _judge_cache[cache_key] = (now, j) + return j + + # ── idempotency：60s 内同 (sender, text-hash) 去重 ── + _idempotency: dict[str, float] = {} + + def _is_dup(sender: str, text: str) -> bool: + key = f"{sender}::{hashlib.md5(text.encode('utf-8')).hexdigest()[:12]}" + now = time.time() + for k in [k for k, t in _idempotency.items() if now - t > 120]: + _idempotency.pop(k, None) + if key in _idempotency and now - _idempotency[key] < 60: + return True + _idempotency[key] = now + return False + + async def _plan_launcher( + *, + intent: str, + chat_id: str, + sender_open_id: str, + needs_web_search: bool = False, + **kwargs: Any, + ) -> dict[str, Any]: + plan = plan_from_intent( + intent, + user_open_id=sender_open_id, + meta={"needs_web_search": needs_web_search}, + ) ack = ( - f"🛫 **Agent-Pilot V1 已启动**\n" + f"🛫 **Agent-Pilot V1.5 已启动**\n" f"Plan: `{plan.plan_id}`\n" f"意图：{intent[:80]}\n\n" f"📋 计划（共 {len(plan.steps)} 步）：\n" - + "\n".join(f" {i + 1}. [{s.tool}] {s.description}" for i, s in enumerate(plan.steps[:6])) - + f"\n\n实时进度：http://118.178.242.26/dashboard?plan_id={plan.plan_id}" + + "\n".join( + f" {i + 1}. [{s.tool}] {s.description}" + for i, s in enumerate(plan.steps[:6]) + ) ) + dash = _public_dashboard_url(plan.plan_id) + if dash: + ack += f"\n\n实时进度：{dash}" - # 启动后台执行 - def _bg(): + def _bg() -> None: asyncio.run(_run_plan_in_bg(plan, chat_id)) threading.Thread(target=_bg, daemon=True).start() - return {"plan_id": plan.plan_id, "ack_text": ack} - async def _run_plan_in_bg(plan, chat_id: str): + async def _run_plan_in_bg(plan, chat_id: str) -> None: from pilot.context.event_log import EventLog + from pilot.surface.feishu.cards import task_delivered_card event_log = EventLog(session_id=plan.plan_id) await event_log.append("plan_start", { @@ -72,26 +193,13 @@ async def _run_plan_in_bg(plan, chat_id: str): "steps": [{"step_id": s.step_id, "tool": s.tool, "description": s.description} for s in plan.steps], }) - async def _on_event(ev): + async def _on_event(ev) -> None: await event_log.append(ev.kind, {"step_id": ev.step_id, "tool": ev.tool, **ev.payload}) - registry = default_registry() - orch = Orchestrator(registry, on_event=_on_event) try: - summary = await orch.run(plan) - # 完成回写 - from pilot.surface.feishu.cards import task_delivered_card - - artifacts = [] - for sid, r in (summary.get("step_results") or {}).items(): - if not isinstance(r, dict): - continue - if "doc_token" in r: - artifacts.append({"kind": "doc", "title": r.get("title", ""), "url": r.get("url", "")}) - if "canvas_id" in r: - artifacts.append({"kind": "canvas", "title": r.get("title", ""), "url": r.get("tldraw_url", "")}) - if "slide_id" in r and r.get("pptx_url"): - artifacts.append({"kind": "slide", "title": r.get("title", ""), "url": r["pptx_url"]}) + summary = await Orchestrator(default_registry(), on_event=_on_event).run(plan) + + artifacts = _collect_artifacts(summary) await event_log.append("plan_done", { "plan_id": plan.plan_id, @@ -100,16 +208,27 @@ async def _on_event(ev): "artifacts": artifacts, }) - card = task_delivered_card(task_id=plan.plan_id, title=plan.intent[:40], artifacts=artifacts) - await feishu.send_card(receive_id=chat_id, card=card, - receive_id_type="chat_id" if chat_id.startswith("oc_") else "open_id") + card = task_delivered_card( + task_id=plan.plan_id, + title=plan.intent[:40], + artifacts=artifacts, + ) + await feishu.send_card( + receive_id=chat_id, + card=card, + receive_id_type="chat_id" if chat_id.startswith("oc_") else "open_id", + ) except Exception as e: logger.exception("background plan failed: %s", e) await event_log.append("plan_error", {"error": str(e)[:500]}) - await feishu.send_text(receive_id=chat_id, text=f"❌ 任务失败：{e}", - receive_id_type="chat_id" if chat_id.startswith("oc_") else "open_id") + await feishu.send_text( + receive_id=chat_id, + text=f"❌ 任务失败：{e}", + receive_id_type="chat_id" if chat_id.startswith("oc_") else "open_id", + ) - router = FeishuRouter(plan_launcher=_plan_launcher) + intent_router = IntentRouter(llm_judge=_llm_judge) + router = FeishuRouter(intent_router=intent_router, plan_launcher=_plan_launcher) # ── lark-oapi 事件分发 ── def _on_message(data) -> None: @@ -128,7 +247,6 @@ def _handle_message(data) -> None: if sender_type != "user": return - # 提取文本 content_raw = message.content or "{}" text = "" try: @@ -137,7 +255,6 @@ def _handle_message(data) -> None: except Exception: text = "" - # 语音转写 if not text and getattr(message, "message_type", "") == "audio": file_key = (json.loads(message.content) or {}).get("file_key", "") if file_key: @@ -147,13 +264,21 @@ def _handle_message(data) -> None: if not text: return + if _is_dup(sender_open_id, text): + logger.info("duplicate msg ignored: sender=%s text=%s", sender_open_id[-6:], text[:40]) + return + chat_id = message.chat_id if chat_type != "p2p" else sender_open_id + is_p2p = chat_type == "p2p" + res = asyncio.run(router.handle_message( sender_open_id=sender_open_id, text=text, chat_id=chat_id, msg_id=message_id, + is_p2p=is_p2p, )) + if res.text_reply: asyncio.run(feishu.reply_text(message_id=message_id, text=res.text_reply)) if res.card: @@ -165,22 +290,26 @@ def _handle_message(data) -> None: except Exception as e: logger.exception("on_message error: %s", e) - async def _voice_transcribe(message_id: str, file_key: str, sender: str, chat_id: str, chat_type: str): + async def _voice_transcribe(message_id: str, file_key: str, sender: str, chat_id: str, chat_type: str) -> None: text = await feishu.transcribe_audio(message_id=message_id, file_key=file_key) if not text: await feishu.reply_text(message_id=message_id, text="🎤 没听清，请再发一次或直接发文字") return + if _is_dup(sender, text): + return + target_chat = chat_id if chat_type != "p2p" else sender res = await router.handle_message( sender_open_id=sender, text=text, - chat_id=chat_id if chat_type != "p2p" else sender, + chat_id=target_chat, msg_id=message_id, + is_p2p=(chat_type == "p2p"), ) if res.text_reply: await feishu.reply_text(message_id=message_id, text=f"🎤 [识别] {text}\n\n{res.text_reply}") if res.card: await feishu.send_card( - receive_id=chat_id if chat_type != "p2p" else sender, + receive_id=target_chat, card=res.card, receive_id_type="chat_id" if chat_type != "p2p" else "open_id", ) @@ -214,7 +343,6 @@ def _on_card_action(data): .build() ) - # lark-oapi 不同版本 LogLevel 枚举不同，做兼容处理 log_level = None for cand in ("WARNING", "WARN", "INFO", "ERROR"): if hasattr(lark.LogLevel, cand): @@ -227,5 +355,49 @@ def _on_card_action(data): event_handler=handler, log_level=log_level, ) - logger.info("正在连接飞书长连接服务...") + base = (os.getenv("DASHBOARD_PUBLIC_BASE") or "").rstrip("/") or "(未配置 DASHBOARD_PUBLIC_BASE)" + logger.info("Agent-Pilot V1.5 bot 启动；公网入口 = %s", base) cli.start() + + +def _collect_artifacts(summary: dict[str, Any]) -> list[dict[str, str]]: + """从 orchestrator summary.step_results 抽取产物，去重 + 过滤空 URL. + + 输出格式：[{"kind":"doc|canvas|slide", "title":..., "url":...}, ...] + """ + artifacts: list[dict[str, str]] = [] + seen: set[tuple[str, str]] = set() + for _sid, r in (summary.get("step_results") or {}).items(): + if not isinstance(r, dict): + continue + + if r.get("doc_token"): + url = (r.get("url") or "").strip() + if not url and r.get("markdown_artifact"): + url = str((r["markdown_artifact"] or {}).get("uri", "") or "") + url = _absolute_artifact_url(url) + ttl = str(r.get("title", "") or "飞书文档") + key = ("doc", url) + if url and key not in seen: + seen.add(key) + artifacts.append({"kind": "doc", "title": ttl, "url": url}) + + if r.get("canvas_id"): + cu = (r.get("tldraw_url") or r.get("url") or "").strip() + cu = _absolute_artifact_url(cu) + ttl = str(r.get("title", "") or "画布") + key = ("canvas", cu) + if cu and key not in seen: + seen.add(key) + artifacts.append({"kind": "canvas", "title": ttl, "url": cu}) + + if r.get("slide_id"): + pu = (r.get("pptx_url_absolute") or r.get("pptx_url") or r.get("url") or "").strip() + pu = _absolute_artifact_url(pu) + ttl = str(r.get("title", "") or "演示稿") + key = ("slide", pu) + if pu and key not in seen: + seen.add(key) + artifacts.append({"kind": "slide", "title": ttl, "url": pu}) + + return artifacts diff --git a/pilot/surface/feishu/cards/__init__.py b/pilot/surface/feishu/cards/__init__.py index 2a7f655..729dc52 100644 --- a/pilot/surface/feishu/cards/__init__.py +++ b/pilot/surface/feishu/cards/__init__.py @@ -8,6 +8,10 @@ task_progress_card, task_suggested_card, ) +from pilot.surface.feishu.cards.context_confirm import ( # noqa: F401 + ContextSummary, + build as build_context_confirm_card, +) __all__ = [ "context_confirm_card", @@ -16,4 +20,6 @@ "task_delivered_card", "task_progress_card", "task_suggested_card", + "ContextSummary", + "build_context_confirm_card", ] diff --git a/pilot/surface/feishu/cards/builder.py b/pilot/surface/feishu/cards/builder.py index cf5ffb2..3c3d279 100644 --- a/pilot/surface/feishu/cards/builder.py +++ b/pilot/surface/feishu/cards/builder.py @@ -59,25 +59,31 @@ def context_confirm_card( task_id: str, summary: dict[str, Any], ) -> dict[str, Any]: - """PRD §7.2 上下文确认卡片.""" + """PRD §7.2 上下文确认卡片（V1.5：3 按钮 + "调整目标"）.""" used = summary.get("used", []) missing = summary.get("missing", []) - elements = [ + task_goal = str(summary.get("task_goal", "") or "")[:120] + task_summary = str(summary.get("task_summary", "") or "")[:120] + + elements: list[dict[str, Any]] = [ {"tag": "div", "text": {"tag": "lark_md", - "content": f"**📦 上下文确认**\n\n任务目标：{summary.get('task_goal', '')[:100]}"}}, + "content": f"**📦 上下文确认**\n\n**已理解任务**：{task_summary or task_goal or '（无）'}"}}, {"tag": "hr"}, ] if used: used_md = "\n".join(f"- {u}" for u in used) elements.append({"tag": "div", "text": {"tag": "lark_md", "content": f"**已用资料**\n{used_md}"}}) + else: + elements.append({"tag": "div", "text": {"tag": "lark_md", "content": "**已用资料**\n_（暂无）_"}}) + if missing: missing_md = "\n".join(f"- {m}" for m in missing) - elements.append({"tag": "div", "text": {"tag": "lark_md", "content": f"**建议补充**\n{missing_md}"}}) + elements.append({"tag": "div", "text": {"tag": "lark_md", "content": f"**缺失资料 / 建议补充**\n{missing_md}"}}) elements.append({"tag": "action", "actions": [ - _btn("✅ 确认上下文", "pilot.ctx.confirm", task_id, primary=True), - _btn("📎 继续补充", "pilot.ctx.add_more", task_id), - _btn("⏸ 暂停", "pilot.task.pause", task_id), + _btn("📎 添加资料", "pilot.ctx.add", task_id), + _btn("✅ 确认生成", "pilot.ctx.confirm", task_id, primary=True), + _btn("📝 调整目标", "pilot.ctx.adjust", task_id), ]}) return { @@ -123,25 +129,39 @@ def task_delivered_card( artifacts: list[dict[str, Any]] | None = None, share_url: str = "", ) -> dict[str, Any]: - """任务交付卡（PRD §F-13）.""" - elements = [ + """任务交付卡（PRD §F-13；V1.5 修复：URL 为空跳过避免 [](　) 渲染异常）.""" + elements: list[dict[str, Any]] = [ {"tag": "div", "text": {"tag": "lark_md", "content": f"**🛬 任务完成**\n\n{title or '产物已生成'}"}}, {"tag": "hr"}, ] + valid_count = 0 for a in (artifacts or [])[:6]: kind = a.get("kind", "") - url = a.get("url", "") or a.get("uri", "") - ttl = a.get("title", "") - emoji = {"doc": "📄", "canvas": "🎨", "slide": "📊"}.get(kind, "📦") + url = (a.get("url") or a.get("uri") or "").strip() + ttl = a.get("title", "") or kind + if not url: + continue # 过滤空 URL，避免飞书卡片出现 [](　) 这种空链接 + valid_count += 1 + emoji = {"doc": "📄", "canvas": "🎨", "slide": "📊", "tts": "🔊"}.get(kind, "📦") + kind_cn = {"doc": "文档", "canvas": "画布", "slide": "演示稿", "tts": "语音"}.get(kind, kind) elements.append({"tag": "div", "text": {"tag": "lark_md", - "content": f"{emoji} **{kind}** {ttl}：[{url}]({url})"}}) + "content": f"{emoji} **{kind_cn}** {ttl}：[打开]({url})"}}) + if valid_count == 0: + elements.append({"tag": "div", "text": {"tag": "lark_md", + "content": "_（产物列表暂时为空，请稍候或查看 dashboard 进度）_"}}) + + actions: list[dict[str, Any]] = [] if share_url: - elements.append({"tag": "action", "actions": [ - {"tag": "button", "text": {"tag": "plain_text", "content": "🔗 打开分享链接"}, - "type": "primary", "url": share_url}, - _btn("📁 归档", "pilot.task.archive", task_id), - ]}) + actions.append({ + "tag": "button", + "text": {"tag": "plain_text", "content": "🔗 打开分享链接"}, + "type": "primary", + "url": share_url, + }) + actions.append(_btn("📁 归档", "pilot.task.archive", task_id)) + elements.append({"tag": "action", "actions": actions}) + return { "header": {"title": {"tag": "plain_text", "content": "🛬 Agent-Pilot · 任务完成"}, "template": "green"}, "elements": elements, diff --git a/pilot/surface/feishu/cards/context_confirm.py b/pilot/surface/feishu/cards/context_confirm.py new file mode 100644 index 0000000..b2e0b27 --- /dev/null +++ b/pilot/surface/feishu/cards/context_confirm.py @@ -0,0 +1,56 @@ +"""上下文确认卡片便利构造器（PRD §7.2）. + +V1.5 设计要点： + - 显式区分"已理解任务摘要" / "已用资料" / "缺失资料" 三段 + - 3 个动作按钮：📎 添加资料 / ✅ 确认生成 / 📝 调整目标 + - 与 builder.py 中 context_confirm_card() 行为完全一致；本模块提供更强类型 + 中转便利 + +用法： + from pilot.surface.feishu.cards.context_confirm_card import build, ContextSummary + card = build(task_id="task_xxx", summary=ContextSummary( + task_summary="为 Q4 OKR 撰写汇报材料", + used=["飞书文档：Q3 OKR 复盘", "群聊纪要 2026-04-30"], + missing=["audience", "time"], + )) +""" + +from __future__ import annotations + +from dataclasses import asdict, dataclass, field +from typing import Any + +from pilot.surface.feishu.cards.builder import context_confirm_card + +MISSING_LABELS = { + "audience": "受众（给谁看）", + "form": "形态（文档 / PPT / 三件套）", + "goal": "核心目标", + "time": "截止时间", +} + + +@dataclass +class ContextSummary: + task_summary: str = "" + task_goal: str = "" + used: list[str] = field(default_factory=list) + missing: list[str] = field(default_factory=list) + + def to_card_kwargs(self) -> dict[str, Any]: + return { + "task_summary": self.task_summary, + "task_goal": self.task_goal, + "used": list(self.used), + "missing": [MISSING_LABELS.get(m, m) for m in self.missing], + } + + def to_dict(self) -> dict[str, Any]: + return asdict(self) + + +def build(*, task_id: str, summary: ContextSummary | dict[str, Any]) -> dict[str, Any]: + if isinstance(summary, ContextSummary): + return context_confirm_card(task_id=task_id, summary=summary.to_card_kwargs()) + if isinstance(summary, dict): + return context_confirm_card(task_id=task_id, summary=summary) + raise TypeError(f"summary 必须是 ContextSummary 或 dict，收到 {type(summary).__name__}") diff --git a/pilot/surface/feishu/client.py b/pilot/surface/feishu/client.py index 3eee744..022483f 100644 --- a/pilot/surface/feishu/client.py +++ b/pilot/surface/feishu/client.py @@ -290,12 +290,101 @@ async def get_chat_messages(self, *, chat_id: str, limit: int = 50) -> list[dict }) return out + # ── Drive 文档检索 ── + async def drive_search(self, *, query: str, count: int = 10) -> list[dict[str, Any]]: + """检索用户云文档（POST /drive/v1/files/search）. + + 返回 [{token, name, type, url}] 简化结构。 + """ + token = await self._ensure_token() + client = await self._client() + try: + r = await client.post( + f"{self.BASE_URL}/drive/v1/files/search", + headers=self._headers(token), + json={"query": query, "count": min(int(count), 50)}, + ) + data = r.json() + except Exception as e: + logger.warning("drive_search failed: %s", e) + return [] + items = (data.get("data") or {}).get("files", []) or [] + out = [] + for it in items: + tk = it.get("token") or it.get("doc_token") or "" + ttype = it.get("type") or "doc" + url = it.get("url") or _fmt_drive_url(tk, ttype) + out.append({ + "token": tk, + "name": it.get("name", ""), + "type": ttype, + "url": url, + }) + return out + + # ── Bitable（多维表格）记录检索 ── + async def bitable_search( + self, + *, + app_token: str = "", + table_id: str = "", + query: str = "", + page_size: int = 20, + ) -> list[dict[str, Any]]: + """检索 bitable 记录（POST /bitable/v1/apps/{app}/tables/{table}/records/search）. + + 参数缺失时返回空列表（不抛）；上层调用方可根据 query 自动选 default app。 + """ + app_token = app_token or os.getenv("FEISHU_BITABLE_APP_TOKEN", "") + if not app_token or not table_id: + return [] + token = await self._ensure_token() + client = await self._client() + try: + body: dict[str, Any] = {"page_size": min(int(page_size), 100)} + if query: + body["filter"] = { + "conjunction": "or", + "conditions": [{"operator": "contains", "value": [query]}], + } + r = await client.post( + f"{self.BASE_URL}/bitable/v1/apps/{app_token}/tables/{table_id}/records/search", + headers=self._headers(token), + json=body, + ) + data = r.json() + except Exception as e: + logger.warning("bitable_search failed: %s", e) + return [] + items = (data.get("data") or {}).get("items", []) or [] + return [ + { + "record_id": it.get("record_id", ""), + "fields": it.get("fields", {}) or {}, + } + for it in items + ] + async def aclose(self) -> None: if self._http: await self._http.aclose() self._http = None +def _fmt_drive_url(token: str, type_: str) -> str: + if not token: + return "" + if type_ in ("docx",): + return f"https://feishu.cn/docx/{token}" + if type_ == "doc": + return f"https://feishu.cn/doc/{token}" + if type_ == "sheet": + return f"https://feishu.cn/sheets/{token}" + if type_ == "bitable": + return f"https://feishu.cn/base/{token}" + return f"https://feishu.cn/file/{token}" + + _default: FeishuClient | None = None diff --git a/pilot/surface/feishu/router.py b/pilot/surface/feishu/router.py index 7eb0aa8..bc095a9 100644 --- a/pilot/surface/feishu/router.py +++ b/pilot/surface/feishu/router.py @@ -1,12 +1,14 @@ -"""飞书消息 + 卡片回调统一路由. +"""飞书消息 + 卡片回调统一路由（V1.5）. -修复 v13 P0 Bug：澄清卡按钮 `clarify_answer/clarify_skip` 失效的问题 -→ 统一到 `pilot.clarify.*` 命名空间，单一 router 处理所有 pilot.* action。 +V1 → V1.5 关键演化: + - IntentRouter 升级到 5 闸门，新增 CHAT verdict（绝不沉默）→ 在此分发为 text_reply。 + - COMMAND verdict 在 router 层处理，避免 bot.py 重复字符串匹配。 + - 卡片 actions 扩到 PRD §6/§7 全集（task / ctx / clarify）。 + - plan_launcher 签名增加 `needs_web_search` 透传，由 Planner 决定是否插 web.search 第 0 步。 """ from __future__ import annotations -import asyncio import logging import time from dataclasses import dataclass @@ -18,7 +20,6 @@ IntentRouter, IntentVerdict, ) -from pilot.runtime.session import Session, Task logger = logging.getLogger("pilot.surface.feishu.router") @@ -34,12 +35,11 @@ class RouterResult: error: str = "" -# 启动 plan 的回调签名 PlanLauncher = Callable[..., Awaitable[dict[str, Any]]] class FeishuRouter: - """单一入口路由：消息 → 三闸门 → 创建任务 / 澄清 / 直接执行 .""" + """5 闸门 + 卡片 action 单一路由.""" def __init__( self, @@ -53,9 +53,7 @@ def __init__( self.plan_launcher = plan_launcher self._recent: dict[str, list[ChatMessage]] = {} self._max_recent = 30 - self._sessions: dict[str, Session] = {} # chat_id -> Session - # ── 文本消息入口 ── async def handle_message( self, *, @@ -64,36 +62,36 @@ async def handle_message( chat_id: str = "", msg_id: str = "", is_explicit: bool = False, + is_p2p: bool = True, ) -> RouterResult: - """处理一条 IM 文本消息.""" text = (text or "").strip() if not text: return RouterResult(handled=False, verdict="empty") chat_id = chat_id or sender_open_id - # 命令路径 - if text.lower() in ("帮助", "/help", "help"): - from pilot.surface.feishu.cards import help_card - return RouterResult(handled=True, verdict="help_command", card=help_card()) - - if text.lower() in ("状态", "status", "/status"): - return RouterResult(handled=True, verdict="status", - text_reply="当前没有正在执行的任务（V1 简化版）") - - # 累积上下文 - msg = ChatMessage(sender_open_id=sender_open_id, text=text, chat_id=chat_id, msg_id=msg_id, ts=int(time.time())) + msg = ChatMessage( + sender_open_id=sender_open_id, + text=text, + chat_id=chat_id, + msg_id=msg_id, + ts=int(time.time()), + ) buf = self._recent.setdefault(chat_id, []) buf.append(msg) if len(buf) > self._max_recent: del buf[: len(buf) - self._max_recent] - # 显式触发 - if is_explicit or text.lower().startswith(("/pilot", "@pilot")): - return await self._launch(intent=_strip_prefix(text), chat_id=chat_id, sender_open_id=sender_open_id) + # is_explicit 调用方可强制走启动路径（用于卡片回调里组装的"启动意图"） + if is_explicit: + return await self._launch( + intent=_strip_prefix(text), + chat_id=chat_id, + sender_open_id=sender_open_id, + needs_web_search=False, + ) - # 三闸门 - result = await self.intent_router.detect(buf) + result = await self.intent_router.detect(buf, is_p2p=is_p2p) if result.verdict == IntentVerdict.NOT_INTENT: return RouterResult(handled=False, verdict="not_intent") @@ -101,15 +99,34 @@ async def handle_message( if result.verdict in (IntentVerdict.COOLDOWN, IntentVerdict.IGNORED): return RouterResult(handled=True, verdict=result.verdict.value, next_action="silent") + if result.verdict == IntentVerdict.COMMAND: + return await self._handle_command(result.command_kind) + + if result.verdict == IntentVerdict.CHAT: + return RouterResult( + handled=True, + verdict="chat", + text_reply=result.chat_reply or "我在哦～需要帮你做点什么？发`帮助`看示例", + ) + if result.verdict == IntentVerdict.NEEDS_CLARIFY: req = self.clarifier.build_request(intent=text, questions=result.clarify_questions) - return RouterResult(handled=True, verdict="clarify", card=req.to_card(), - next_action="awaiting_user_clarify_answer") + return RouterResult( + handled=True, + verdict="clarify", + card=req.to_card(), + next_action="awaiting_user_clarify_answer", + ) # READY - return await self._launch(intent=text, chat_id=chat_id, sender_open_id=sender_open_id) + intent = _strip_prefix(text) if result.rule_hits and "explicit_pilot" in result.rule_hits else text + return await self._launch( + intent=intent, + chat_id=chat_id, + sender_open_id=sender_open_id, + needs_web_search=result.needs_web_search, + ) - # ── 卡片回调入口 ── async def handle_card_action( self, *, @@ -117,54 +134,97 @@ async def handle_card_action( action: str, value: dict[str, Any], ) -> RouterResult: - """处理飞书卡片按钮回调.""" if not action: return RouterResult(handled=False, error="empty_action") - # 修复 v13 P0：clarify 按钮路由 + # 澄清卡按钮（V1 修复保留） if action == "pilot.clarify.choose": choice = value.get("choice", "doc") intent = value.get("intent", "") expanded = self.clarifier.expand_choice(intent=intent, choice=choice) - return await self._launch(intent=expanded, chat_id=actor_open_id, sender_open_id=actor_open_id) + return await self._launch( + intent=expanded, + chat_id=actor_open_id, + sender_open_id=actor_open_id, + needs_web_search=False, + ) if action == "pilot.clarify.skip": intent = value.get("intent", "") or "Agent-Pilot 任务" - return await self._launch(intent=intent, chat_id=actor_open_id, sender_open_id=actor_open_id) + return await self._launch( + intent=intent, + chat_id=actor_open_id, + sender_open_id=actor_open_id, + needs_web_search=False, + ) - # PRD §6 owner 流转 + §F-10 指派 + # 任务卡片按钮（PRD §F-04 / §6） if action == "pilot.task.confirm": - return RouterResult(handled=True, verdict="confirmed", task_id=value.get("task_id", ""), - next_action="orchestrator_running", - text_reply="✅ 已确认，开始执行") - + return RouterResult( + handled=True, + verdict="confirmed", + task_id=value.get("task_id", ""), + next_action="orchestrator_running", + text_reply="✅ 已确认，开始执行", + ) if action == "pilot.task.ignore": - return RouterResult(handled=True, verdict="ignored", task_id=value.get("task_id", ""), - text_reply="🙅 已忽略本次建议") - + return RouterResult( + handled=True, + verdict="ignored", + task_id=value.get("task_id", ""), + text_reply="🙅 已忽略本次建议", + ) if action == "pilot.task.assign": - return RouterResult(handled=True, verdict="assign_pending", task_id=value.get("task_id", ""), - text_reply="👤 请 @ 一位群成员，回复 `指派 @某人` 完成转交") - + return RouterResult( + handled=True, + verdict="assign_pending", + task_id=value.get("task_id", ""), + text_reply="👤 请 @ 一位群成员，回复 `指派 @某人` 完成转交", + ) if action == "pilot.task.claim": - return RouterResult(handled=True, verdict="claimed", task_id=value.get("task_id", ""), - text_reply=f"✋ 已由 {actor_open_id[-6:]} 接管") - - if action == "pilot.task.add_context": - return RouterResult(handled=True, verdict="add_context", task_id=value.get("task_id", ""), - text_reply="📎 请直接发送补充资料的链接或文件，我会自动拼到上下文包") - + return RouterResult( + handled=True, + verdict="claimed", + task_id=value.get("task_id", ""), + text_reply=f"✋ 已由 {actor_open_id[-6:]} 接管", + ) if action == "pilot.task.archive": - return RouterResult(handled=True, verdict="archived", task_id=value.get("task_id", ""), - text_reply="📁 已归档") - + return RouterResult( + handled=True, + verdict="archived", + task_id=value.get("task_id", ""), + text_reply="📁 已归档", + ) if action == "pilot.task.pause": - return RouterResult(handled=True, verdict="paused", task_id=value.get("task_id", ""), - text_reply="⏸ 已暂停，发送 `继续` 恢复") + return RouterResult( + handled=True, + verdict="paused", + task_id=value.get("task_id", ""), + text_reply="⏸ 已暂停，发送 `继续` 恢复", + ) + # 上下文确认卡片按钮（PRD §7.2） + if action in ("pilot.ctx.add", "pilot.task.add_context"): + return RouterResult( + handled=True, + verdict="ctx_add", + task_id=value.get("task_id", ""), + text_reply="📎 请直接发送补充资料的链接或文件，我会自动加入上下文包", + ) if action == "pilot.ctx.confirm": - return RouterResult(handled=True, verdict="ctx_confirmed", task_id=value.get("task_id", ""), - text_reply="✅ 上下文已确认，正在生成产物...") + return RouterResult( + handled=True, + verdict="ctx_confirmed", + task_id=value.get("task_id", ""), + text_reply="✅ 上下文已确认，正在生成产物...", + ) + if action == "pilot.ctx.adjust": + return RouterResult( + handled=True, + verdict="ctx_adjust", + task_id=value.get("task_id", ""), + text_reply="📝 请直接发新的目标描述，我会重置规划并重新启动", + ) if action == "pilot.help": from pilot.surface.feishu.cards import help_card @@ -172,35 +232,70 @@ async def handle_card_action( return RouterResult(handled=False, error=f"unknown_action: {action}") - # ── 内部 ── + async def _handle_command(self, kind: str) -> RouterResult: + if kind == "help": + from pilot.surface.feishu.cards import help_card + return RouterResult(handled=True, verdict="help_command", card=help_card()) + if kind == "status": + return RouterResult( + handled=True, + verdict="status", + text_reply="📊 当前没有正在执行的任务。发送任务描述即可启动新计划。", + ) + if kind == "claim": + return RouterResult(handled=True, verdict="claim", text_reply="✋ 已记录认领，请确认任务卡里的 task_id") + if kind == "pause": + return RouterResult(handled=True, verdict="pause", text_reply="⏸ 已暂停（需带 task_id 才能精确定位）") + if kind == "resume": + return RouterResult(handled=True, verdict="resume", text_reply="▶️ 收到，请告诉我要恢复的 task_id") + if kind == "ignore": + return RouterResult(handled=True, verdict="ignore", text_reply="🙅 已忽略本次") + return RouterResult(handled=True, verdict=f"command:{kind}") + async def _launch( self, *, intent: str, chat_id: str, sender_open_id: str, + needs_web_search: bool = False, ) -> RouterResult: if self.plan_launcher is None: - return RouterResult(handled=True, verdict="ready", text_reply=f"🛫 收到意图：{intent[:60]}\n（V1 plan launcher 未注入）") + return RouterResult( + handled=True, + verdict="ready", + text_reply=f"🛫 收到意图：{intent[:60]}\n（plan_launcher 未注入）", + ) try: res = await self.plan_launcher( - intent=intent, chat_id=chat_id, sender_open_id=sender_open_id, + intent=intent, + chat_id=chat_id, + sender_open_id=sender_open_id, + needs_web_search=needs_web_search, ) - return RouterResult( - handled=True, - verdict="ready", - task_id=res.get("plan_id", ""), - text_reply=res.get("ack_text", f"🛫 已启动 Agent-Pilot · {intent[:30]}"), - card=res.get("card"), + except TypeError: + # 兼容旧签名（无 needs_web_search） + res = await self.plan_launcher( + intent=intent, + chat_id=chat_id, + sender_open_id=sender_open_id, ) except Exception as e: logger.exception("launch failed: %s", e) return RouterResult(handled=True, verdict="error", text_reply=f"❌ 启动失败: {e}", error=str(e)) + return RouterResult( + handled=True, + verdict="ready", + task_id=res.get("plan_id", ""), + text_reply=res.get("ack_text", f"🛫 已启动 Agent-Pilot · {intent[:30]}"), + card=res.get("card"), + ) + def _strip_prefix(text: str) -> str: - text = text.strip() + text = (text or "").strip() for p in ("/pilot", "@pilot", "/Pilot", "@Pilot"): if text.lower().startswith(p.lower()): return text[len(p):].strip(":：、 ").strip() diff --git a/pilot/surface/lark_mcp_runner.py b/pilot/surface/lark_mcp_runner.py new file mode 100644 index 0000000..c86f4c1 --- /dev/null +++ b/pilot/surface/lark_mcp_runner.py @@ -0,0 +1,227 @@ +"""V1.5 — Agent-Pilot 反向 MCP server（HTTP + SSE，端口 8003）. + +目的: + 把 Agent-Pilot 的核心工具反向暴露给 Cursor / Claude Desktop / Trae 等外部 AI client， + 评委可在自己的 IDE 里直接调用我们的工具，作为差异化展示点。 + +为什么不用完整 MCP SDK? + - mcp 官方包的 SSE/streamable 协议改动频繁，绑死特定版本反而脆弱； + - 这里实现 HTTP/JSON 子集 + 心跳 SSE，兼容 Cursor 0.x 的 SSE transport； + - 完整协议升级时只改本文件即可。 + +公开 4 个核心工具（不暴露 destructive 工具）: + - pilot.doc.create / pilot.doc.append + - pilot.slide.generate + - pilot.web.search + +启动: + python -m pilot mcp # 用 pilot CLI（如已注册） + python -c "from pilot.surface.lark_mcp_runner import run; run()" +""" + +from __future__ import annotations + +import asyncio +import json +import logging +import time +from typing import Any + +logger = logging.getLogger("pilot.surface.lark_mcp_runner") + + +EXPOSED_TOOLS = { + "doc.create": "创建飞书 Docx 文档", + "doc.append": "向 Docx 追加 LLM 自动生成的 Markdown 内容", + "slide.generate": "基于上游文档生成 .pptx 演示稿 + Slidev md + 演讲稿", + "web.search": "联网搜索（DDG + Bing CN 兜底）", +} + + +def _filter_tools_for_mcp(specs): + """只暴露 EXPOSED_TOOLS 集合里的工具，避免外部 client 误调 destructive 工具.""" + return [s for s in specs if s.name in EXPOSED_TOOLS] + + +def create_app(): + from fastapi import Body, FastAPI, Request + from fastapi.middleware.cors import CORSMiddleware + from fastapi.responses import JSONResponse, StreamingResponse + + app = FastAPI( + title="Agent-Pilot V1.5 · 反向 MCP Server", + description="Reverse MCP — 把 Agent-Pilot 核心工具暴露给 Cursor/Claude Desktop/Trae", + version="1.5.0", + ) + app.add_middleware( + CORSMiddleware, + allow_origins=["*"], + allow_methods=["*"], + allow_headers=["*"], + ) + + @app.get("/") + async def index(): + return { + "name": "Agent-Pilot V1.5 MCP Server", + "version": "1.5.0", + "protocol": "MCP-compatible HTTP+SSE subset", + "exposed_tools": list(EXPOSED_TOOLS.keys()), + "endpoints": { + "tools_list": "GET /tools/list", + "tools_call": "POST /tools/call", + "sse": "GET /sse", + "health": "GET /health", + }, + "client_config_hint": ( + "在 Cursor 的 ~/.cursor/mcp.json 加：\n" + ' {"mcpServers":{"agent-pilot":{"url":"http://:8003/sse"}}}' + ), + } + + @app.get("/health") + async def health(): + return {"status": "healthy", "ts": int(time.time())} + + @app.get("/tools/list") + @app.post("/tools/list") + async def tools_list(): + from pilot.capability.tools.registry import default_registry + + specs = _filter_tools_for_mcp(default_registry().list_specs()) + return { + "tools": [ + { + "name": s.name, + "description": s.description, + "inputSchema": s.input_schema, + } + for s in specs + ] + } + + @app.post("/tools/call") + async def tools_call(body: dict = Body(...)): + name = body.get("name", "") + args = body.get("arguments") or body.get("args") or {} + + if name not in EXPOSED_TOOLS: + return JSONResponse( + { + "isError": True, + "content": [{"type": "text", "text": f"工具 {name} 未暴露给 MCP（白名单：{list(EXPOSED_TOOLS.keys())}）"}], + }, + status_code=400, + ) + + try: + from pilot.capability.tools.registry import default_registry + + result = await default_registry().execute( + tool_name=name, + tool_input=args, + ctx={"_via_mcp": True}, + ) + except Exception as e: + logger.exception("MCP tools/call %s failed", name) + return JSONResponse( + {"isError": True, "content": [{"type": "text", "text": str(e)}]}, + status_code=200, + ) + + return { + "isError": False, + "content": [{"type": "json", "json": result}], + } + + @app.get("/sse") + async def sse(request: Request): + """Cursor / Claude Desktop 的 SSE transport 兼容端点. + + - 客户端 GET /sse 后，server 周期性 emit `event: ping`，保持连接 + - 客户端 POST /messages 写入指令；这里简化为只支持 `tools/list` 和 `tools/call` + - 真完整的 MCP 双向消息建议升级到 streamable HTTP（Cursor 1.x 默认） + """ + + async def gen(): + yield "event: ready\ndata: {\"server\":\"agent-pilot-mcp\",\"version\":\"1.5.0\"}\n\n" + try: + while True: + if await request.is_disconnected(): + break + yield f"event: ping\ndata: {json.dumps({'ts': int(time.time())})}\n\n" + await asyncio.sleep(15) + except asyncio.CancelledError: + return + + return StreamingResponse( + gen(), + media_type="text/event-stream", + headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"}, + ) + + @app.post("/messages") + async def messages(body: dict = Body(...)): + """SSE 反向通道：客户端 POST 调用工具/列表，server 直接 JSON 回复. + + 简化协议（不是完整 MCP JSON-RPC 2.0），适合 demo 演示。 + """ + method = body.get("method", "") + + if method == "tools/list": + from pilot.capability.tools.registry import default_registry + + specs = _filter_tools_for_mcp(default_registry().list_specs()) + return { + "jsonrpc": "2.0", + "id": body.get("id", 0), + "result": { + "tools": [ + {"name": s.name, "description": s.description, "inputSchema": s.input_schema} + for s in specs + ] + }, + } + + if method == "tools/call": + params = body.get("params") or {} + name = params.get("name", "") + args = params.get("arguments", {}) + if name not in EXPOSED_TOOLS: + return { + "jsonrpc": "2.0", + "id": body.get("id", 0), + "error": {"code": -32601, "message": f"tool not exposed: {name}"}, + } + from pilot.capability.tools.registry import default_registry + + try: + result = await default_registry().execute( + tool_name=name, tool_input=args, ctx={"_via_mcp": True}, + ) + except Exception as e: + return { + "jsonrpc": "2.0", + "id": body.get("id", 0), + "error": {"code": -32603, "message": str(e)[:200]}, + } + return { + "jsonrpc": "2.0", + "id": body.get("id", 0), + "result": {"content": [{"type": "json", "json": result}], "isError": False}, + } + + return { + "jsonrpc": "2.0", + "id": body.get("id", 0), + "error": {"code": -32601, "message": f"unknown method: {method}"}, + } + + return app + + +def run(*, host: str = "0.0.0.0", port: int = 8003) -> None: + import uvicorn + + app = create_app() + uvicorn.run(app, host=host, port=port, log_level="info") diff --git a/scripts/nginx/agent-pilot.conf b/scripts/nginx/agent-pilot.conf new file mode 100644 index 0000000..5287241 --- /dev/null +++ b/scripts/nginx/agent-pilot.conf @@ -0,0 +1,76 @@ +# Agent-Pilot V1.5 · nginx 反代 +# / → :8001 dashboard +# /sse、/messages → :8003 反向 MCP server（Cursor / Claude Desktop 接入） +# 不暴露 :8001 / :8003 公网端口（UFW deny） + +upstream agent_pilot_dashboard { + server 127.0.0.1:8001; + keepalive 16; +} + +upstream agent_pilot_mcp { + server 127.0.0.1:8003; + keepalive 16; +} + +server { + listen 80 default_server; + listen [::]:80 default_server; + server_name _; + + client_max_body_size 50m; + + # ── MCP SSE（必须关 buffering） ── + location /sse { + proxy_pass http://agent_pilot_mcp; + proxy_http_version 1.1; + proxy_set_header Connection ""; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_buffering off; + proxy_cache off; + proxy_read_timeout 24h; + chunked_transfer_encoding off; + } + + location /messages { + proxy_pass http://agent_pilot_mcp; + proxy_http_version 1.1; + proxy_set_header Host $host; + } + + location /tools/ { + proxy_pass http://agent_pilot_mcp; + proxy_http_version 1.1; + proxy_set_header Host $host; + } + + # ── Dashboard SSE（实时事件流） ── + location ~ ^/api/events/ { + proxy_pass http://agent_pilot_dashboard; + proxy_http_version 1.1; + proxy_set_header Connection ""; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_buffering off; + proxy_cache off; + proxy_read_timeout 24h; + chunked_transfer_encoding off; + } + + # ── Dashboard 主体（HTML / JSON / 静态） ── + location / { + proxy_pass http://agent_pilot_dashboard; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + proxy_read_timeout 600; + } + + location = /health { + proxy_pass http://agent_pilot_dashboard/health; + access_log off; + } +} diff --git a/scripts/run_t20_smoke.py b/scripts/run_t20_smoke.py new file mode 100644 index 0000000..9080c20 --- /dev/null +++ b/scripts/run_t20_smoke.py @@ -0,0 +1,134 @@ +"""T1-T20 真机/烟雾测试入口（不发飞书消息，模拟同链路）. + +设计哲学: + - 不能模拟真实飞书事件订阅（需要真 App secret 和云回调），但能跑「IntentRouter → Planner → Orchestrator → 工具」全链路； + - 用例输入 = 飞书用户文本，断言 = 关键路径属性（intent verdict / plan steps / 是否插 web.search）； + - LLM_MOCK=1 默认开，避免烧 MiniMax 配额；如要测真 LLM，export AGENT_PILOT_REAL_LLM=1。 + +输出 result/T20_RESULT.json，给 docs/JUDGE_TEST_REPORT.md 自动填表用。 +""" + +from __future__ import annotations + +import asyncio +import json +import os +import time +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any + + +@dataclass +class TestCase: + tid: str + category: str + text: str + expect_verdict: str # COMMAND / EXPLICIT / READY / NEEDS_CLARIFY / CHAT + expect_web_search: bool = False + notes: str = "" + + # 填充后: + actual_verdict: str = "" + actual_steps: list[str] = field(default_factory=list) + actual_has_web_search: bool = False + elapsed_ms: int = 0 + pass_: bool = False + reason: str = "" + + +CASES: list[TestCase] = [ + TestCase("T1", "基础响应", "你好", "CHAT", notes="不可沉默"), + TestCase("T2", "基础响应", "谢谢", "CHAT"), + TestCase("T3", "基础响应", "今天天气怎么样", "CHAT", notes="闲聊兜底"), + TestCase("T4", "基础响应", "/pilot 帮助", "COMMAND", notes="/pilot 显式命令"), + TestCase("T5", "基础响应", "状态", "COMMAND"), + TestCase("T6", "任务识别", "OpenClaw 三件套", "READY", notes="关键字直接命中"), + TestCase("T7", "任务识别", "做 8 页 PPT 关于 RAG 系统", "READY"), + TestCase("T8", "任务识别", "帮我做个汇报", "NEEDS_CLARIFY", notes="弱词无主题"), + TestCase("T9", "任务识别", "/pilot 测试一下", "READY", notes="显式 /pilot"), + TestCase("T10", "任务识别", "pilot 帮我写文档", "READY"), + TestCase("T11", "联网", "今年最新 AI Agent 进展文档", "READY", expect_web_search=True), + TestCase("T12", "联网", "做关于 2026 RAG 趋势的汇报", "READY", expect_web_search=True), + TestCase("T13", "飞书生态", "整理本周群讨论给我做个总结", "READY", notes="需 web.search + im.fetch_thread"), + TestCase("T14", "飞书生态", "用多维表格做月度汇报", "READY", notes="需 lark.bitable.search"), + TestCase("T15", "用户旅程", "三件套 关于公司 H1 战略复盘", "READY"), + TestCase("T16", "用户旅程", "做一份产品架构图", "READY"), + TestCase("T17", "用户旅程", "@pilot 写文档 + 出 PPT", "READY"), + TestCase("T18", "多端", "/pilot 状态", "COMMAND"), + TestCase("T19", "富媒体", "[语音输入文本] 做一份周报", "READY"), + TestCase("T20", "富媒体", "把这张图分析一下", "NEEDS_CLARIFY", notes="单图需澄清"), +] + + +async def _run_one(case: TestCase) -> TestCase: + from pilot.runtime.intent_router import ChatMessage, IntentRouter + + router = IntentRouter() + t0 = time.perf_counter() + msg = ChatMessage(sender_open_id="judge_smoke", text=case.text, chat_id="p2p_judge", msg_id=f"m_{case.tid}") + result = await router.detect([msg], is_p2p=True) + case.elapsed_ms = int((time.perf_counter() - t0) * 1000) + case.actual_verdict = result.verdict.name # 枚举名 (COMMAND/READY/CHAT/...) + + if result.verdict.name == "READY": + try: + from pilot.runtime.planner import plan_from_intent + + plan = plan_from_intent( + case.text, + meta={"needs_web_search": getattr(result, "needs_web_search", False)}, + ) + case.actual_steps = [s.tool for s in plan.steps] + case.actual_has_web_search = "web.search" in case.actual_steps + except Exception as e: + case.reason = f"planner_error: {e}" + + case.pass_ = case.actual_verdict.upper() == case.expect_verdict.upper() + if case.expect_web_search and not case.actual_has_web_search: + case.pass_ = False + case.reason = (case.reason + ";" if case.reason else "") + "missing web.search" + + return case + + +async def main() -> int: + os.environ.setdefault("LLM_MOCK", "1") + print(f"=== T1-T20 烟雾测试（LLM_MOCK={os.getenv('LLM_MOCK')}）===\n") + results: list[TestCase] = [] + for c in CASES: + try: + r = await _run_one(c) + except Exception as e: + c.reason = f"unexpected_error: {e}" + c.pass_ = False + r = c + results.append(r) + flag = "✓" if r.pass_ else "✗" + print(f" {flag} {r.tid:>3} {r.category:6} {r.actual_verdict:24} {r.elapsed_ms:>4}ms {r.text[:30]}{'…' if len(r.text)>30 else ''}") + if not r.pass_: + print(f" ↳ expected={r.expect_verdict} reason={r.reason or '-'} steps={r.actual_steps}") + + passed = sum(1 for r in results if r.pass_) + print(f"\n通过：{passed}/{len(results)}") + + out = Path("data/test_reports/T20_RESULT.json") + out.parent.mkdir(parents=True, exist_ok=True) + out.write_text( + json.dumps( + [{ + "tid": r.tid, "category": r.category, "text": r.text, + "expect_verdict": r.expect_verdict, "actual_verdict": r.actual_verdict, + "expect_web_search": r.expect_web_search, "actual_has_web_search": r.actual_has_web_search, + "actual_steps": r.actual_steps, + "elapsed_ms": r.elapsed_ms, "pass": r.pass_, "reason": r.reason, "notes": r.notes, + } for r in results], ensure_ascii=False, indent=2, + ), + encoding="utf-8", + ) + print(f"结果写入 {out}") + return 0 if passed == len(results) else 1 + + +if __name__ == "__main__": + raise SystemExit(asyncio.run(main())) diff --git a/scripts/server/install.sh b/scripts/server/install.sh new file mode 100755 index 0000000..0c9c1b2 --- /dev/null +++ b/scripts/server/install.sh @@ -0,0 +1,111 @@ +#!/usr/bin/env bash +# Agent-Pilot V1.5 · 服务器一键部署（Ubuntu 22.04 / Debian 12） +# Idempotent：可重复执行，已存在的步骤会跳过。 +# +# 用法（在服务器 root）： +# curl -fsSL https://raw.githubusercontent.com/bcefghj/Agent-Pilot/v1.5-clean/scripts/server/install.sh | bash +# 或： +# bash /opt/agent-pilot/scripts/server/install.sh + +set -euo pipefail + +APP_DIR="${APP_DIR:-/opt/agent-pilot}" +APP_USER="${APP_USER:-root}" +# Ubuntu 22.04 自带 python3.10；如需 3.11 设 PY=python3.11 并自行装 deadsnakes PPA +PY="${PY:-python3}" +REPO="${REPO:-https://github.com/bcefghj/Agent-Pilot.git}" +BRANCH="${BRANCH:-v1.5-clean}" + +log() { echo -e "\033[1;32m[install]\033[0m $*"; } +warn() { echo -e "\033[1;33m[warn]\033[0m $*"; } + +# ── 1. 系统包 ── +log "apt 安装基础包..." +export DEBIAN_FRONTEND=noninteractive +apt-get update -y +apt-get install -y --no-install-recommends \ + curl ca-certificates git build-essential pkg-config \ + python3 python3-venv python3-dev python3-pip \ + redis-server nginx ufw \ + fonts-noto-cjk fonts-noto-color-emoji + +systemctl enable --now redis-server || true + +# ── 2. 拉取代码 ── +if [ ! -d "$APP_DIR/.git" ]; then + log "首次 clone 到 $APP_DIR (branch=$BRANCH)..." + git clone --branch "$BRANCH" --depth 1 "$REPO" "$APP_DIR" +else + log "更新已有仓库 $APP_DIR..." + cd "$APP_DIR" + git fetch origin "$BRANCH" + git checkout "$BRANCH" || git checkout -B "$BRANCH" "origin/$BRANCH" + git reset --hard "origin/$BRANCH" +fi + +cd "$APP_DIR" + +# ── 3. Python 虚拟环境 ── +if [ ! -d "$APP_DIR/.venv" ]; then + log "创建 venv..." + "$PY" -m venv "$APP_DIR/.venv" +fi +# shellcheck disable=SC1091 +source "$APP_DIR/.venv/bin/activate" +pip install -U pip wheel setuptools +log "安装 Python 依赖..." +pip install -e ".[bot,dashboard]" || pip install -e . + +# ── 4. .env 模板 ── +if [ ! -f "$APP_DIR/.env" ]; then + log "拷贝 .env.example → .env，请填飞书 + MiniMax 密钥" + cp .env.example .env + warn "记得编辑 $APP_DIR/.env：FEISHU_APP_ID / FEISHU_APP_SECRET / MINIMAX_API_KEY / DASHBOARD_PUBLIC_BASE" +else + log ".env 已存在，跳过" +fi + +# ── 5. 数据目录 ── +mkdir -p "$APP_DIR/data" "$APP_DIR/data/artifacts" "$APP_DIR/logs" +chown -R "$APP_USER:$APP_USER" "$APP_DIR/data" "$APP_DIR/logs" + +# ── 6. systemd units ── +log "安装 systemd unit..." +install -m 0644 scripts/systemd/agent-pilot-bot.service /etc/systemd/system/ +install -m 0644 scripts/systemd/agent-pilot-dashboard.service /etc/systemd/system/ +install -m 0644 scripts/systemd/agent-pilot-mcp.service /etc/systemd/system/ +systemctl daemon-reload + +# ── 7. nginx ── +log "配置 nginx..." +install -m 0644 scripts/nginx/agent-pilot.conf /etc/nginx/sites-available/agent-pilot.conf +ln -sf /etc/nginx/sites-available/agent-pilot.conf /etc/nginx/sites-enabled/agent-pilot.conf +rm -f /etc/nginx/sites-enabled/default +nginx -t && systemctl reload nginx + +# ── 8. 防火墙 ── +log "UFW 规则..." +ufw allow 22/tcp || true +ufw allow 80/tcp || true +ufw allow 443/tcp || true +ufw deny 8001/tcp || true +ufw deny 8002/tcp || true +ufw deny 8003/tcp || true +ufw --force enable || true + +# ── 9. 启动 ── +log "启动 Agent-Pilot 三件套..." +systemctl enable --now agent-pilot-dashboard.service +systemctl enable --now agent-pilot-mcp.service +# bot 最后启动（依赖 .env 已配） +if grep -q "your_app_secret_here" "$APP_DIR/.env" 2>/dev/null || ! grep -q "FEISHU_APP_SECRET=." "$APP_DIR/.env"; then + warn ".env 还没填飞书 secret，bot 暂不启动；编辑后跑：systemctl start agent-pilot-bot" +else + systemctl enable --now agent-pilot-bot.service +fi + +log "完成！健康检查：" +echo " curl http://localhost/health" +echo " curl http://localhost/api/health" +echo " curl http://localhost:8003/health" +echo " systemctl status agent-pilot-*.service" diff --git a/scripts/systemd/agent-pilot-bot.service b/scripts/systemd/agent-pilot-bot.service new file mode 100644 index 0000000..7be526f --- /dev/null +++ b/scripts/systemd/agent-pilot-bot.service @@ -0,0 +1,20 @@ +[Unit] +Description=Agent-Pilot · Feishu Bot (V1.5) +After=network-online.target redis-server.service +Wants=network-online.target + +[Service] +Type=simple +User=root +WorkingDirectory=/opt/agent-pilot +EnvironmentFile=/opt/agent-pilot/.env +ExecStart=/opt/agent-pilot/.venv/bin/python -m pilot.surface.feishu.bot +Restart=always +RestartSec=5 +StandardOutput=append:/opt/agent-pilot/logs/bot.log +StandardError=append:/opt/agent-pilot/logs/bot.log +KillSignal=SIGINT +TimeoutStopSec=10 + +[Install] +WantedBy=multi-user.target diff --git a/scripts/systemd/agent-pilot-dashboard.service b/scripts/systemd/agent-pilot-dashboard.service new file mode 100644 index 0000000..681f3c5 --- /dev/null +++ b/scripts/systemd/agent-pilot-dashboard.service @@ -0,0 +1,20 @@ +[Unit] +Description=Agent-Pilot · Dashboard (V1.5, port 8001) +After=network-online.target redis-server.service +Wants=network-online.target + +[Service] +Type=simple +User=root +WorkingDirectory=/opt/agent-pilot +EnvironmentFile=/opt/agent-pilot/.env +ExecStart=/opt/agent-pilot/.venv/bin/python -c "from pilot.surface.dashboard.server import run; run(host='0.0.0.0', port=8001)" +Restart=always +RestartSec=5 +StandardOutput=append:/opt/agent-pilot/logs/dashboard.log +StandardError=append:/opt/agent-pilot/logs/dashboard.log +KillSignal=SIGINT +TimeoutStopSec=10 + +[Install] +WantedBy=multi-user.target diff --git a/scripts/systemd/agent-pilot-mcp.service b/scripts/systemd/agent-pilot-mcp.service new file mode 100644 index 0000000..31a0a5f --- /dev/null +++ b/scripts/systemd/agent-pilot-mcp.service @@ -0,0 +1,20 @@ +[Unit] +Description=Agent-Pilot · Reverse MCP Server (V1.5, port 8003) +After=network-online.target +Wants=network-online.target + +[Service] +Type=simple +User=root +WorkingDirectory=/opt/agent-pilot +EnvironmentFile=/opt/agent-pilot/.env +ExecStart=/opt/agent-pilot/.venv/bin/python -c "from pilot.surface.lark_mcp_runner import run; run(host='0.0.0.0', port=8003)" +Restart=always +RestartSec=5 +StandardOutput=append:/opt/agent-pilot/logs/mcp.log +StandardError=append:/opt/agent-pilot/logs/mcp.log +KillSignal=SIGINT +TimeoutStopSec=10 + +[Install] +WantedBy=multi-user.target diff --git a/tests/unit/test_cards.py b/tests/unit/test_cards.py new file mode 100644 index 0000000..fd30572 --- /dev/null +++ b/tests/unit/test_cards.py @@ -0,0 +1,65 @@ +"""V1.5 — 卡片构造器回归（task_delivered 过滤空 URL + context_confirm 3 按钮）.""" + +from __future__ import annotations + +import json + +from pilot.surface.feishu.cards import ( + ContextSummary, + build_context_confirm_card, + context_confirm_card, + task_delivered_card, +) + + +def _walk_text(card: dict) -> str: + return json.dumps(card, ensure_ascii=False) + + +def test_task_delivered_skips_empty_url() -> None: + card = task_delivered_card( + task_id="task_x", + title="测试", + artifacts=[ + {"kind": "doc", "title": "正常文档", "url": "https://feishu.cn/docx/abc"}, + {"kind": "slide", "title": "空 URL 应该跳过", "url": ""}, + {"kind": "canvas", "title": "也跳过", "url": " "}, + ], + ) + text = _walk_text(card) + assert "正常文档" in text + assert "空 URL 应该跳过" not in text + assert "也跳过" not in text + # 不应该出现空链接的渲染 + assert "[]()" not in text + assert "[打开]()" not in text + + +def test_task_delivered_all_empty_shows_placeholder() -> None: + card = task_delivered_card(task_id="t", title="x", artifacts=[ + {"kind": "doc", "url": ""}, + ]) + assert "产物列表暂时为空" in _walk_text(card) + + +def test_context_confirm_card_has_three_actions() -> None: + card = context_confirm_card( + task_id="task_a", + summary={"task_summary": "Q4 OKR 汇报", "used": ["doc1"], "missing": ["audience", "time"]}, + ) + text = _walk_text(card) + assert "📎 添加资料" in text + assert "✅ 确认生成" in text + assert "📝 调整目标" in text + # 按钮 action 命名 + assert "pilot.ctx.add" in text + assert "pilot.ctx.confirm" in text + assert "pilot.ctx.adjust" in text + + +def test_context_summary_dataclass_translates_missing() -> None: + s = ContextSummary(task_summary="x", missing=["audience", "form"]) + card = build_context_confirm_card(task_id="t", summary=s) + text = _walk_text(card) + assert "受众" in text + assert "形态" in text diff --git a/tests/unit/test_intent_router_v15.py b/tests/unit/test_intent_router_v15.py new file mode 100644 index 0000000..104e649 --- /dev/null +++ b/tests/unit/test_intent_router_v15.py @@ -0,0 +1,135 @@ +"""V1.5 IntentRouter 5 闸门完整覆盖测试.""" + +from __future__ import annotations + +import pytest + +from pilot.runtime.intent_router import ( + ChatMessage, + CooldownStore, + IntentRouter, + IntentVerdict, + LLMJudgement, +) + + +@pytest.mark.asyncio +async def test_g1_command_help() -> None: + r = await IntentRouter().detect([ChatMessage("u1", "帮助", "c1")]) + assert r.verdict == IntentVerdict.COMMAND + assert r.command_kind == "help" + + +@pytest.mark.asyncio +async def test_g1_command_status_slash() -> None: + r = await IntentRouter().detect([ChatMessage("u1", "/status", "c1")]) + assert r.verdict == IntentVerdict.COMMAND + assert r.command_kind == "status" + + +@pytest.mark.asyncio +async def test_g1_command_claim_chinese() -> None: + r = await IntentRouter().detect([ChatMessage("u1", "我来执行", "c1")]) + assert r.verdict == IntentVerdict.COMMAND + assert r.command_kind == "claim" + + +@pytest.mark.asyncio +async def test_g2_explicit_pilot_prefix() -> None: + r = await IntentRouter().detect([ChatMessage("u1", "/pilot 写个文档", "c1")]) + assert r.verdict == IntentVerdict.READY + assert "explicit_pilot" in r.rule_hits + + +@pytest.mark.asyncio +async def test_g3_strong_form_with_topic_short_circuit() -> None: + """强 form 词 + 主题（OpenClaw）即使没动词也直接 READY.""" + r = await IntentRouter().detect([ChatMessage("u1", "OpenClaw 三件套", "c1")]) + assert r.verdict == IntentVerdict.READY + + +@pytest.mark.asyncio +async def test_g3_timely_word_sets_web_search_flag() -> None: + r = await IntentRouter().detect([ChatMessage("u1", "今年最新 AI Agent 进展报告", "c1")]) + assert r.verdict == IntentVerdict.READY + assert r.needs_web_search is True + + +@pytest.mark.asyncio +async def test_g3_form_word_alone_falls_through_to_clarify() -> None: + """单出 form 词、无主题、无 LLM → NEEDS_CLARIFY 避免空启.""" + r = await IntentRouter().detect([ChatMessage("u1", "帮我做个 PPT", "c1")]) + assert r.verdict == IntentVerdict.NEEDS_CLARIFY + + +@pytest.mark.asyncio +async def test_g4_llm_ready_overrides() -> None: + async def fake(text, history): + return LLMJudgement(verdict="ready", is_task=True, summary="任务概要", confidence=0.9) + + r = await IntentRouter(llm_judge=fake).detect([ChatMessage("u1", "搞个东西", "c1")]) + assert r.verdict == IntentVerdict.READY + assert r.llm_judgement is not None + + +@pytest.mark.asyncio +async def test_g4_llm_clarify_with_missing_fields() -> None: + async def fake(text, history): + return LLMJudgement(verdict="clarify", is_task=True, missing=["audience", "form"]) + + r = await IntentRouter(llm_judge=fake).detect([ChatMessage("u1", "需要个东西", "c1")]) + assert r.verdict == IntentVerdict.NEEDS_CLARIFY + assert any("给谁看" in q for q in r.clarify_questions) + assert any("文档" in q for q in r.clarify_questions) + + +@pytest.mark.asyncio +async def test_g4_llm_chat_returns_friendly_reply() -> None: + async def fake(text, history): + return LLMJudgement(verdict="chat", friendly_reply="哈哈，我不会算命") + + r = await IntentRouter(llm_judge=fake).detect([ChatMessage("u1", "明天股市涨吗", "c1")]) + assert r.verdict == IntentVerdict.CHAT + assert r.chat_reply == "哈哈，我不会算命" + + +@pytest.mark.asyncio +async def test_g4_llm_timeout_falls_to_g5() -> None: + async def boom(text, history): + raise TimeoutError("8s") + + r = await IntentRouter(llm_judge=boom).detect([ChatMessage("u1", "你好", "c1")]) + # greeting 命中 G5 闲聊兜底 + assert r.verdict == IntentVerdict.CHAT + assert "你好" in r.chat_reply or "Agent-Pilot" in r.chat_reply + + +@pytest.mark.asyncio +async def test_g5_greeting_fallback() -> None: + r = await IntentRouter().detect([ChatMessage("u1", "Hi", "c1")]) + assert r.verdict == IntentVerdict.CHAT + + +@pytest.mark.asyncio +async def test_g5_unknown_text_never_silent() -> None: + """未识别也不沉默，给 CHAT 引导.""" + r = await IntentRouter().detect([ChatMessage("u1", "我啦啦啦", "c1")]) + assert r.verdict == IntentVerdict.CHAT + assert r.chat_reply # 必有回复 + + +@pytest.mark.asyncio +async def test_cooldown_p2p_short() -> None: + cd = CooldownStore(p2p_cooldown_sec=10, group_cooldown_sec=300) + router = IntentRouter(cooldown=cd) + history = [ChatMessage("u1", "OpenClaw 三件套", "c1")] + r1 = await router.detect(history, is_p2p=True) + assert r1.verdict == IntentVerdict.READY + r2 = await router.detect(history, is_p2p=True) + assert r2.verdict == IntentVerdict.COOLDOWN + + +@pytest.mark.asyncio +async def test_empty_message_returns_not_intent() -> None: + r = await IntentRouter().detect([ChatMessage("u1", " ", "c1")]) + assert r.verdict == IntentVerdict.NOT_INTENT diff --git a/tests/unit/test_lark_mcp_runner.py b/tests/unit/test_lark_mcp_runner.py new file mode 100644 index 0000000..a5d26d6 --- /dev/null +++ b/tests/unit/test_lark_mcp_runner.py @@ -0,0 +1,78 @@ +"""Phase 2.1 — 反向 MCP server (lark_mcp_runner) 单测. + +只验证： + 1. tools/list 只暴露白名单工具 + 2. tools/call 拒绝白名单外的工具（防止评委 client 误调 archive.bundle） + 3. /messages tools/call 正常路径 + 4. /health +""" + +from __future__ import annotations + +import os + +import pytest + + +@pytest.fixture(autouse=True) +def _llm_mock(monkeypatch): + monkeypatch.setenv("LLM_MOCK", "1") + + +def _client(): + from fastapi.testclient import TestClient + + from pilot.surface.lark_mcp_runner import create_app + + return TestClient(create_app()) + + +def test_health(): + r = _client().get("/health") + assert r.status_code == 200 + assert r.json()["status"] == "healthy" + + +def test_index_lists_exposed_tools(): + r = _client().get("/") + body = r.json() + assert r.status_code == 200 + exposed = set(body["exposed_tools"]) + assert {"doc.create", "doc.append", "slide.generate", "web.search"} <= exposed + + +def test_tools_list_only_whitelist(): + r = _client().get("/tools/list") + assert r.status_code == 200 + names = {t["name"] for t in r.json()["tools"]} + assert names <= {"doc.create", "doc.append", "slide.generate", "web.search"} + assert "archive.bundle" not in names + assert "slide.rehearse" not in names + + +def test_tools_call_rejects_non_whitelist(): + r = _client().post( + "/tools/call", + json={"name": "archive.bundle", "arguments": {}}, + ) + assert r.status_code == 400 + assert r.json()["isError"] is True + + +def test_messages_jsonrpc_unknown_method(): + r = _client().post("/messages", json={"jsonrpc": "2.0", "id": 1, "method": "foo/bar"}) + assert r.status_code == 200 + body = r.json() + assert body["error"]["code"] == -32601 + + +def test_messages_tools_list_returns_whitelist(): + r = _client().post( + "/messages", + json={"jsonrpc": "2.0", "id": 7, "method": "tools/list"}, + ) + assert r.status_code == 200 + body = r.json() + assert body["id"] == 7 + names = {t["name"] for t in body["result"]["tools"]} + assert names <= {"doc.create", "doc.append", "slide.generate", "web.search"} diff --git a/tests/unit/test_lark_tools.py b/tests/unit/test_lark_tools.py new file mode 100644 index 0000000..3515e4b --- /dev/null +++ b/tests/unit/test_lark_tools.py @@ -0,0 +1,54 @@ +"""V1.5 — lark.* 工具注册 + 缺凭据降级回归.""" + +from __future__ import annotations + +import pytest + +from pilot.capability.tools.registry import default_registry + + +@pytest.mark.asyncio +async def test_lark_tools_registered() -> None: + reg = default_registry() + for name in ("lark.im.fetch_thread", "lark.doc.search", "lark.bitable.search"): + spec = reg.get(name) + assert spec is not None, name + assert spec.namespace == "lark" + + +@pytest.mark.asyncio +async def test_lark_im_fetch_thread_no_credentials(monkeypatch) -> None: + monkeypatch.setenv("FEISHU_APP_ID", "cli_your_app_id_here") + reg = default_registry() + res = await reg.execute(tool_name="lark.im.fetch_thread", tool_input={"chat_id": "oc_xxx"}, ctx={}) + assert res["ok"] is False + assert res["reason"] == "no_feishu_credentials" + + +@pytest.mark.asyncio +async def test_lark_doc_search_no_credentials(monkeypatch) -> None: + monkeypatch.setenv("FEISHU_APP_ID", "cli_your_app_id_here") + reg = default_registry() + res = await reg.execute(tool_name="lark.doc.search", tool_input={"query": "PRD"}, ctx={}) + assert res["ok"] is False + assert res["reason"] == "no_feishu_credentials" + + +@pytest.mark.asyncio +async def test_lark_bitable_search_missing_table_id(monkeypatch) -> None: + monkeypatch.setenv("FEISHU_APP_ID", "cli_real_app_id") + monkeypatch.setenv("FEISHU_APP_SECRET", "real_secret") + reg = default_registry() + res = await reg.execute(tool_name="lark.bitable.search", tool_input={}, ctx={}) + assert res["ok"] is False + assert res["reason"] == "missing_table_id" + + +@pytest.mark.asyncio +async def test_lark_doc_search_empty_query(monkeypatch) -> None: + monkeypatch.setenv("FEISHU_APP_ID", "cli_real") + monkeypatch.setenv("FEISHU_APP_SECRET", "real_secret") + reg = default_registry() + res = await reg.execute(tool_name="lark.doc.search", tool_input={"query": ""}, ctx={}) + assert res["ok"] is False + assert res["reason"] == "empty_query" diff --git a/tests/unit/test_runtime_basic.py b/tests/unit/test_runtime_basic.py index 64dff2a..0a21d0a 100644 --- a/tests/unit/test_runtime_basic.py +++ b/tests/unit/test_runtime_basic.py @@ -30,6 +30,8 @@ def test_session_create(): def test_task_state_transition(): t = Task(intent="帮我写个文档") assert t.state == TaskState.SUGGESTED + # V1.5：必须按 LEGAL_TRANSITIONS 走合法路径 + t.transition(TaskState.ASSIGNED) t.transition(TaskState.PLANNING) assert t.state == TaskState.PLANNING t.lock_owner("ou_xxx") @@ -60,41 +62,53 @@ async def test_intent_explicit_pilot(): @pytest.mark.asyncio -async def test_intent_not_intent(): +async def test_intent_chat_not_silent_for_smalltalk(): + """V1.5 业务变更：闲聊不沉默，给友好回复（绝不沉默原则）.""" router = IntentRouter() msg = ChatMessage(sender_open_id="u1", text="今天天气真好啊", chat_id="c1") r = await router.detect([msg]) - assert r.verdict == IntentVerdict.NOT_INTENT + assert r.verdict == IntentVerdict.CHAT + assert r.chat_reply # 一定有回复文本 @pytest.mark.asyncio async def test_intent_clarify_when_no_llm(): + """信息不足且无 LLM 判定时走 NEEDS_CLARIFY，避免空启 plan.""" router = IntentRouter() msg = ChatMessage(sender_open_id="u1", text="帮我做个 PPT", chat_id="c1") r = await router.detect([msg]) - # 没 LLM 判断器，规则命中 → NEEDS_CLARIFY assert r.verdict == IntentVerdict.NEEDS_CLARIFY assert len(r.clarify_questions) >= 1 @pytest.mark.asyncio -async def test_intent_ready_with_full_info(): +async def test_intent_ready_short_circuit_when_info_rich(): + """信息充分（form 词 + 主题 + 长度）时闸门 3 短路 READY，不必走 LLM.""" + router = IntentRouter() # 不注入 LLM 也应 READY + msg = ChatMessage( + sender_open_id="u1", + text="帮我写一份关于 AI Agent 发展趋势的报告，给老板看", + chat_id="c1", + ) + r = await router.detect([msg]) + assert r.verdict == IntentVerdict.READY + + +@pytest.mark.asyncio +async def test_intent_llm_judge_overrides_when_short_text(): + """短文本 + 弱信号 → 走闸门 4，LLM 给出 ready 直接 READY.""" async def fake_llm(text, history): return LLMJudgement( + verdict="ready", is_task=True, task_type="report", - goal="AI Agent 发展趋势", - resources=["文档"], - next_step="生成文档", + goal="AI Agent", + summary="AI Agent 报告", confidence=0.9, ) router = IntentRouter(llm_judge=fake_llm) - msg = ChatMessage( - sender_open_id="u1", - text="帮我写一份关于 AI Agent 发展趋势的报告，给老板看", - chat_id="c1", - ) + msg = ChatMessage(sender_open_id="u1", text="搞个东西", chat_id="c1") r = await router.detect([msg]) assert r.verdict == IntentVerdict.READY assert r.llm_judgement is not None @@ -136,6 +150,28 @@ def fake_planner(prompt: str): assert p.steps[1].tool == "archive.bundle" +def test_plan_timely_keyword_triggers_web_search(): + """V1.5：意图含"今年/最新"等时效词，启发式自动插 web.search 第 0 步.""" + p = plan_from_intent("今年最新 AI Agent 趋势汇报 PPT") + tools = [s.tool for s in p.steps] + assert tools[0] == "web.search" + # slide.generate 接收 ${s1.results} 参数 + slide_step = next(s for s in p.steps if s.tool == "slide.generate") + assert slide_step.args.get("search_results") == "${s1.results}" + + +def test_plan_meta_forces_web_search_even_without_timely(): + """meta.needs_web_search=True 强制注入 web.search.""" + p = plan_from_intent("产品方案", meta={"needs_web_search": True}) + assert any(s.tool == "web.search" for s in p.steps) + + +def test_plan_no_web_search_when_no_timely(): + """普通意图不应自动插 web.search，避免无谓联网.""" + p = plan_from_intent("帮我写一份产品方案") + assert not any(s.tool == "web.search" for s in p.steps) + + # ── Orchestrator ───────────────────────────────────────────────────────────── diff --git a/tests/unit/test_task_state_machine.py b/tests/unit/test_task_state_machine.py new file mode 100644 index 0000000..0fdb319 --- /dev/null +++ b/tests/unit/test_task_state_machine.py @@ -0,0 +1,103 @@ +"""V1.5 — Task 状态机合法/非法转移 + stage_owners 测试.""" + +from __future__ import annotations + +import pytest + +from pilot.runtime.session import ( + STAGES, + IllegalTransitionError, + Task, + TaskState, +) + + +def _new_task(state: TaskState = TaskState.SUGGESTED) -> Task: + t = Task(intent="x") + t.state = state + return t + + +def test_initial_state_is_suggested() -> None: + assert Task(intent="x").state == TaskState.SUGGESTED + + +def test_legal_path_full_journey() -> None: + t = _new_task() + for s in ( + TaskState.ASSIGNED, + TaskState.CONTEXT_PENDING, + TaskState.PLANNING, + TaskState.DOC_GENERATING, + TaskState.PPT_GENERATING, + TaskState.REVIEWING, + TaskState.DELIVERED, + ): + t.transition_to(s) + assert t.state == s + + +def test_illegal_skip_to_delivered_raises() -> None: + t = _new_task() + with pytest.raises(IllegalTransitionError): + t.transition_to(TaskState.DELIVERED) + + +def test_illegal_skip_planning_to_ppt_directly_is_legal() -> None: + """PLANNING → PPT_GENERATING 是合法（短路径，仅 PPT 任务）.""" + t = _new_task(TaskState.PLANNING) + t.transition_to(TaskState.PPT_GENERATING) + assert t.state == TaskState.PPT_GENERATING + + +def test_paused_can_resume_to_planning_or_doc() -> None: + t = _new_task(TaskState.PAUSED) + t.transition_to(TaskState.PLANNING) + t = _new_task(TaskState.PAUSED) + t.transition_to(TaskState.DOC_GENERATING) + + +def test_failed_can_retry_to_planning() -> None: + t = _new_task(TaskState.FAILED) + t.transition_to(TaskState.PLANNING) + assert t.state == TaskState.PLANNING + + +def test_force_bypass_legal_check() -> None: + t = _new_task() + t.transition(TaskState.DELIVERED, force=True) + assert t.state == TaskState.DELIVERED + + +def test_can_transition_to() -> None: + t = _new_task(TaskState.PLANNING) + assert t.can_transition_to(TaskState.DOC_GENERATING) + assert not t.can_transition_to(TaskState.SUGGESTED) + + +def test_same_state_idempotent() -> None: + t = _new_task(TaskState.PLANNING) + t.transition_to(TaskState.PLANNING) + assert t.state == TaskState.PLANNING + + +def test_stage_owners_only_known_stages() -> None: + t = _new_task() + for stage in STAGES: + t.set_stage_owner(stage, f"ou_{stage}") + assert t.stage_owners[stage] == f"ou_{stage}" + + with pytest.raises(ValueError): + t.set_stage_owner("unknown_stage", "ou_x") + + +def test_ignored_can_revive_to_suggested() -> None: + t = _new_task(TaskState.IGNORED) + t.transition_to(TaskState.SUGGESTED) + assert t.state == TaskState.SUGGESTED + + +def test_delivered_can_loop_back_to_reviewing() -> None: + t = _new_task(TaskState.DELIVERED) + t.transition_to(TaskState.REVIEWING) + assert t.state == TaskState.REVIEWING diff --git a/tests/unit/test_web_media_tool.py b/tests/unit/test_web_media_tool.py new file mode 100644 index 0000000..fbe14c9 --- /dev/null +++ b/tests/unit/test_web_media_tool.py @@ -0,0 +1,56 @@ +"""V1.5 — web.search / media.tts 工具注册与执行回归.""" + +from __future__ import annotations + +import os + +import pytest + +from pilot.capability.tools.registry import default_registry + + +@pytest.mark.asyncio +async def test_web_search_registered() -> None: + reg = default_registry() + spec = reg.get("web.search") + assert spec is not None + assert "query" in spec.input_schema["properties"] + + +@pytest.mark.asyncio +async def test_web_search_execute_with_mocked_searcher(monkeypatch) -> None: + from pilot.llm import web_search as ws + + async def fake_search(self, query, *, k=5): + return [ + {"title": "A", "url": "https://a.com", "snippet": "a"}, + {"title": "B", "url": "https://b.com", "snippet": "b"}, + ] + + monkeypatch.setattr(ws.WebSearcher, "search", fake_search) + + reg = default_registry() + res = await reg.execute(tool_name="web.search", tool_input={"query": "AI", "k": 2}, ctx={}) + assert res["ok"] is True + assert res["count"] == 2 + assert res["results"][0]["url"] == "https://a.com" + + +@pytest.mark.asyncio +async def test_media_tts_disabled_by_default(monkeypatch) -> None: + monkeypatch.delenv("AGENT_PILOT_ENABLE_TTS", raising=False) + reg = default_registry() + res = await reg.execute(tool_name="media.tts", tool_input={"text": "hi"}, ctx={}) + assert res["ok"] is False + assert res["reason"] == "tts_disabled" + + +@pytest.mark.asyncio +async def test_media_tts_missing_credentials(monkeypatch) -> None: + monkeypatch.setenv("AGENT_PILOT_ENABLE_TTS", "1") + monkeypatch.delenv("MINIMAX_API_KEY", raising=False) + monkeypatch.delenv("MINIMAX_GROUP_ID", raising=False) + reg = default_registry() + res = await reg.execute(tool_name="media.tts", tool_input={"text": "hi"}, ctx={}) + assert res["ok"] is False + assert "credentials" in res["reason"] diff --git a/tests/unit/test_web_search.py b/tests/unit/test_web_search.py new file mode 100644 index 0000000..70ab2c2 --- /dev/null +++ b/tests/unit/test_web_search.py @@ -0,0 +1,109 @@ +"""V1.5 — web_search HTML 解析回归（不依赖网络）.""" + +from __future__ import annotations + +import asyncio +from unittest.mock import AsyncMock, patch + +import httpx +import pytest + +from pilot.llm import web_search + + +DDG_FIXTURE = """ + +
+ 第一个 标题 + 这是 第一个 摘要片段。 +
+
+ Title B + Snippet B +
+ +""" + + +BING_FIXTURE = """ + +
  • +

    News X

    +

    News X 摘要。

    +
    • +
  • +

    Blog Y

    +

    Blog Y snippet

    +
    • + +""" + + +def test_parse_ddg_html_extracts_top_k() -> None: + res = web_search.parse_ddg_html(DDG_FIXTURE, k=5) + assert len(res) == 2 + assert res[0]["url"] == "https://example.com/a" + assert "第一个" in res[0]["title"] + assert res[0]["snippet"].startswith("这是") + assert res[1]["url"] == "https://example.com/b" + + +def test_parse_bing_html_extracts_top_k() -> None: + res = web_search.parse_bing_html(BING_FIXTURE, k=5) + assert len(res) == 2 + assert res[0]["title"] == "News X" + assert res[0]["url"] == "https://news.example.com/x" + + +def test_parse_ddg_respects_k_limit() -> None: + res = web_search.parse_ddg_html(DDG_FIXTURE, k=1) + assert len(res) == 1 + + +def test_searcher_falls_back_to_bing_when_ddg_fails() -> None: + async def fake_get(self, *args, **kwargs): + request = httpx.Request("GET", BING_CN := "https://cn.bing.com/search") + return httpx.Response(200, text=BING_FIXTURE, request=request) + + async def fake_post(self, *args, **kwargs): + raise httpx.TimeoutException("ddg down") + + async def run() -> None: + searcher = web_search.WebSearcher(timeout=1.0) + with patch.object(httpx.AsyncClient, "post", new=fake_post), patch.object( + httpx.AsyncClient, "get", new=fake_get + ): + results = await searcher.search("test query", k=2) + assert results, "fallback should produce results" + assert results[0]["title"] == "News X" + await searcher.aclose() + + asyncio.run(run()) + + +def test_searcher_returns_empty_when_both_fail() -> None: + async def boom_post(self, *args, **kwargs): + raise httpx.TimeoutException("ddg down") + + async def boom_get(self, *args, **kwargs): + raise httpx.TimeoutException("bing down") + + async def run() -> None: + searcher = web_search.WebSearcher(timeout=1.0) + with patch.object(httpx.AsyncClient, "post", new=boom_post), patch.object( + httpx.AsyncClient, "get", new=boom_get + ): + results = await searcher.search("test query") + assert results == [] + await searcher.aclose() + + asyncio.run(run()) + + +def test_searcher_empty_query_short_circuits() -> None: + async def run() -> None: + searcher = web_search.WebSearcher() + assert await searcher.search("") == [] + assert await searcher.search(" ") == [] + + asyncio.run(run())