diff --git a/.gitignore b/.gitignore index 6bbef20..76190cc 100644 --- a/.gitignore +++ b/.gitignore @@ -34,4 +34,7 @@ debug-knowledge-chat-401.md # ===== 操作系统 ===== .DS_Store Thumbs.db -.ollama_models/ \ No newline at end of file +.ollama_models/ +# ===== 外部下载物（模型权重 / wheelhouse，见 G19）===== +# 本机资产库，不是源码；体积以 GB 计，禁止提交 +external_download/ diff --git a/Docs_Model_Train_raw_materials/01-共享底座素材/01-顾问通用方法论/01-理论主文/论垂直大模型训练中的语料不充分性与业务边界的重要性.tx b/Docs_Model_Train_raw_materials/01-共享底座素材/01-顾问通用方法论/01-理论主文/论垂直大模型训练中的语料不充分性与业务边界的重要性.md similarity index 100% rename from Docs_Model_Train_raw_materials/01-共享底座素材/01-顾问通用方法论/01-理论主文/论垂直大模型训练中的语料不充分性与业务边界的重要性.tx rename to Docs_Model_Train_raw_materials/01-共享底座素材/01-顾问通用方法论/01-理论主文/论垂直大模型训练中的语料不充分性与业务边界的重要性.md diff --git a/TOP_CODING_RULES.md b/TOP_CODING_RULES.md index 6fbe4f3..4941cb2 100644 --- a/TOP_CODING_RULES.md +++ b/TOP_CODING_RULES.md @@ -1,7 +1,7 @@ # eai_agentplatform 博昇 AI 数字员工平台（EAI Agent Platform）— 编码与调试最高准则 -> **版本：V1.2** -> **日期：2026-09-18** +> **版本：V1.3** +> **日期：2026-09-26** > **状态：必须强制执行 (Highest Priority)** > **适用范围：eai_agentplatform（EAI 数字员工平台）后端(Go)、前端(Vue3)、数据库(SQLite)、AI 检索/对话、考试引擎、素材上传与审批** > **AI 助手启动任何任务前必须先读取并确认本文件。** @@ -17,10 +17,24 @@ > 不适用的部分——如 Python 虚拟环境、Playwright E2E、OSS 多租户——明确不抄）； > G04 补充第 6-10 条（来自两个项目共同踩过的坑）；本项目新增 P06 常见技术陷阱清单。 > -> **V1.2 补充说明**：把命名前缀从「一条要求」扩成「一套规则」，全部落在 **G03**（不新开 G19，避免命名规则被拆到两处）。 +> **V1.2 补充说明**：把命名前缀从「一条要求」扩成「一套规则」，全部落在 **G03**（当时不新开编号，避免命名规则被拆到两处）。 > 仍只做加法：G03 原第 1-4 条正文一字未改，只在其后新增第 5-10 条 + 关联节；标题由「变量命名锚定」放宽为「命名锚定」 > （前缀要管表名、API 路径、文件名），索引行同步更新。 > 展开与可执行化版本在 `docs/02_Architecture/AR09_对象命名规范.md` §5.7 + §6.2 守卫 G–J + §7.6。 +> +> **V1.3 补充说明**：新增 **G19（外部下载物统一存放 `external_download/raw/`）**，仍只做加法。 +> 起因是本地 ASR 落地时下了 4.1GB 模型与一整套 CUDA 依赖，散在 `~` 与 `/tmp` 里 —— +> 换个会话、换个人就没人知道那是什么、能不能删、要不要重下。规则要求 +> 「**原始件进只读的 `raw/`（一份）+ 一份清单 + 一份 `SHA256SUMS`； +> 解压/转换/配置后的加工件放同级目录，可删可重建，没改过的大文件用软链指回 `raw/`**」。 +> +> **V1.4 补充说明**：P06 增补 7 条（P06.12–P06.18），并在 P06.1 补两条延伸；仍只做加法。 +> 收录标准是「**以后还会再踩**」，不是「修过一次就好了」—— +> 已经修完、且不会以同样形状复发的过程性修复不收录（那些留在提交记录与代码注释里）。 +> 本次来源：把仓库里散落在代码注释、架构文档、历史会话中的事故做了一次普查， +> 按「是否属于工具/语言/框架的固有性质、是否会换个场景再犯」筛过后才进来。 +> 另：本地 ASR 落地中遇到的版本与依赖坑（`torchaudio>=2.9` 删 API 等）记在仓库根 +> `bugs_and_errors.md`，不重复进 P06 —— 那份文件管「一次性的错」，P06 管「会复发的坑」。 --- @@ -49,6 +63,7 @@ - G16：Windows 侧 .ps1 脚本统一 UTF-8 with BOM - G17：脚本内禁止兼容式依赖回退，必须固定单一工具链 - G18：仓库应尽量支持拷贝后直接运行 +- G19：外部下载物统一存放 `external_download/raw/`（原始件只读 + `SHA256SUMS`，加工件另置同级目录），一次下载永久复用 --- @@ -382,6 +397,92 @@ --- +## G19 最高原则：外部下载物统一存放 `external_download/raw/`，一次下载永久复用 + +> 起因：本地 ASR 落地时下了 4.1GB 模型 + 一整套 CUDA 依赖（合计约 6GB）。 +> 这些文件散在 `~` 和 `/tmp` 里时，下一个会话 / 下一个人只知道「磁盘少了 6G」， +> 不知道那是什么、能不能删、要不要重下 —— 于是又下一遍。 +> +> 目录形状（`raw/` 是原始件，只读；`asr-local/` 是从它生成的加工件，可删可重建）： +> +> ``` +> external_download/ +> ├── raw/ +> │ └── asr-local/ 原始件 ★ 磁盘上只有这一份 +> │ ├── README.md 来源 / 许可 / 清单 +> │ ├── SHA256SUMS 逐文件校验和 +> │ ├── models/ 模型权重（下下来那一刻的字节） +> │ └── wheels/ 依赖的 .whl（同属原始件） +> └── asr-local/ 加工件：解压 / 转换 / 配置后的可用件 +> └── models/ 权重按原样引用；被改写过的 config.yaml 放这里 +> ``` + +1. **一切从外部下载的原始文件必须放仓库根的 `external_download/raw/`**：模型权重、wheel、 + 数据集、字体、预编译二进制、第三方发行包都算。禁止散落在 `~`、`/tmp`、`/opt` + 或各人自己的家目录里 —— 那些位置要么会被清理（`/tmp`），要么别人找不到（`~`）。 +2. **原始件与加工件分开：`raw/` 只放下载下来的那套，解压 / 转换 / 配置的结果放 `raw/` 之外的 + 同级目录**（`external_download/raw/<批次>/` ↔ `external_download/<批次>/`）。 + 一个批次一个子目录，命名带用途与来源。 + `raw/` 是**只读区** —— 里面存的必须是「下载下来那一刻」的字节， + 任何程序都不得就地改写、解包、改名或生成中间产物。 + 加工件必须**可丢弃、可重建**（一条脚本能从 `raw/` 再生成一遍），否则它就成了第二份真本， + 两边一旦不一致就没人说得清哪份是对的。 + **大文件不复制**：加工件里没被改过的权重用软链指回 `raw/`，别为了「看起来完整」把 4GB 存两遍 —— + 存两遍的结果是两份都会漂移。只有真正被改写过的文件（如指向 HF repo id 的 `config.yaml` + 要改成本地路径）才在加工件里落成真实文件。 +3. **每个批次必须有一份清单**（`raw/<批次>/README.md`，加工件目录里也放一份说明它是什么、 + 怎么重建），写明： + **下载时间、来源站点 / repo ID、版本或 commit、文件清单与大小、许可**。 + 没有清单的下载物按不可用处理 —— 没人知道它是什么，就没人敢删也没人敢用。 +4. **每个批次必须有一份校验和清单**（`raw/<批次>/SHA256SUMS`），由下载/导出脚本在收尾时自动重算， + 并可用 `sha256sum -c SHA256SUMS` 一条命令自证。**"文件还在"不等于"文件还是当初那份"** —— + 被覆盖、拷坏、下到一半续传错位，只有校验和能发现（关联 G04：完成判定靠事实，不靠印象）。 + 校验和只算 `raw/`；加工件可重建，不需要单独记账。 +5. **禁止重复下载**：动手下之前先 `ls external_download/raw/`。已有就用已有的。 + 真需要新版本时，**新开一个批次子目录**（`raw/` 与加工目录各一个），不要覆盖旧的 + （关联 G11：不可静默修改）。 +6. **下载脚本必须幂等且必须校验**：已存在且大小正确的跳过；每个文件校验 + **HTTP 状态码 + 落盘字节数**，不完整即失败并报出是哪个文件。 + 禁止「下不到就跳过」式的静默兜底（关联 G02）。 +7. **依赖要能离线重建**：Python 依赖除装进虚拟环境外，还须用 `pip download` 导出 + wheelhouse 到该批次的 `raw/<批次>/wheels/`（`.whl` 是依赖的原始件，和模型同级）。 + 虚拟环境本身是加工件，留在工作区即可 —— 有 wheelhouse 就能离线重建它。 + 只留一个虚拟环境，换机器就得重下。 +8. **`external_download/` 不进 git**：在仓库根 `.gitignore` 排除。它是本机资产库，不是源码； + 体积以 GB 计，提交一次就永久留在历史里（关联 G14.5 提交前扫大文件）。 +9. **不得放密钥**：清单里写来源 URL，不写 token；需要鉴权的下载把凭据放环境变量 + （关联 G01 脱敏红线、P06.10）。 +10. **许可必须记录并核对**：引入任何外部素材前先读 LICENSE，把许可写进清单。 + 特别注意：**HF 上的 gated（需登录/接受条款）不等于许可变更**，但通过镜像绕过 gated + 拿到的文件，其许可要与官方来源核对后再写进清单（关联 P06.11）。 +11. **与交付物划清边界**：`external_download/` 是本机开发资产，**不是交付物**。 + 交付走 `eai_agentplatform/backend-go/deploy/`（D14 单二进制 + systemd + 整盘克隆）； + 整盘克隆时本目录随镜像一起过去，这正是它要放仓库根、让脚本能定位到的原因。 + +### 反例与正例 + +| | 反例 ❌ | 正例 ✅ | +|---|---|---| +| A | `~/models/whisper/` 下 3GB 权重，无清单，作者离职后无人敢动 | `external_download/raw/asr-local/models/` + 同目录 `README.md` 写明来源与许可 | +| B | 换个会话发现「好像下过」，不确定，于是又下 3GB | 先 `ls external_download/raw/`，命中即复用 | +| C | 下载脚本 `curl -o f ... \|\| true`，静默跳过半个文件 | 校验 HTTP 码 + 字节数，不对就报出文件名并整体失败 | +| D | 只装了 venv，换机器重装时又拉一遍 2GB CUDA 库 | 同批次目录里带 wheelhouse，`--no-index --find-links` 离线重装 | +| E | 在 `raw/` 里就地解包、改名、跑脚本生成中间文件 | `raw/` 只读；加工结果写到同级目录，且一条脚本能重建 | +| F | 文件都在，就认为「还是当初那份」 | `sha256sum -c SHA256SUMS` 全 OK 才算数 | +| G | 为了「保险」把 4GB 权重在 raw 和加工目录各存一份，之后两边不一致 | 加工件里的权重用软链指回 `raw/`，只有改过的文件才落真实副本 | + +### 关联 + +- 关联 G02：下载不完整是错误状态，不是可跳过状态 +- 关联 G04：完成判定靠事实 —— 「文件还在」不等于「还是当初那份」，用 `SHA256SUMS` 自证 +- 关联 G10：路径不写死在代码里，**由脚本从仓库根派生** +- 关联 G11：新版本新目录，不覆盖旧的 +- 关联 G14：提交前扫大文件与密钥，本目录整目录排除 +- 关联 G18：拷到新机器能跑，前提就是依赖有本地来源 +- 关联 P06.11：引入第三方素材前先读 LICENSE + +--- + # 第二部分：eai_agentplatform 项目专用规则 > **适用范围**：仅适用于博昇 AI 数字员工平台项目。 @@ -492,6 +593,15 @@ - **后果**：以为"改了 model 就完事"，实际老列一直留在库里，代码与库结构悄悄分叉。 - **正确做法**：加字段 → 确认 model 在 `AutoMigrate` 列表里；删字段 / 改类型 → 写一次性迁移，或明确保留旧列并在文档里写明原因。 - **验证方式**：**改库结构后必须在数据库副本上跑一遍升级探测**，确认列真的加上、seed 真的填对，再动真库（动用户数据前先备份，见 P06.7）。 +- **延伸一 · 删列会先撞上索引**：SQLite **拒绝删除仍被索引引用的列**，而 GORM AutoMigrate + **只建新索引、不清理旧模型遗留的索引**（如 `idx_skill_definition_role_kind`）。 + 于是手写的 `DROP COLUMN` 会以 `error in index ... after drop column` 失败， + **直接让 `store.Init` 崩在启动** —— 不是迁移没生效那么温和，是服务起不来。 + 正确做法：删列前先 `dropIndexesOnColumn` 把该列上的索引摘掉（`store/db.go` 的 `dropColumn` 已内置）。 +- **延伸二 · 全局 `sed` 改名会改坏迁移本身**：改名时禁止 `sed -i 's/worker_/task_/g'` 式的全局替换 —— + `migrateLegacyTaskRuntimeSchema` 和它的迁移测试里出现的旧名**是必须保留的** + （它们的工作就是「认旧名、迁到新名」），改掉之后迁移永远不生效，而且没有任何报错。 + 判据一句话：**看这行是在「改」名字还是在「用」名字** —— 改名字的留旧名，用名字的改新名。 ### P06.2 一次性探测脚本用完即删，别留成测试 @@ -557,12 +667,100 @@ - **规则**：该目录目前已不在仓库中；**不得重新引入，也不得改写成"我们的 pdf 技能"**。需要 PDF 能力时自己实现或选许可允许的方案。 - **引申**：引入任何第三方素材/代码前，先读它的 LICENSE——"能用"和"能合法地用并交付"是两件事。 +### P06.12 同一步的产物必须取「最后一次」的 run —— 否则用户对着作废产物点确认 + +- **事实**：取某一步的产出时如果用 `find()` / `[0]` 取**第一条** run，重跑之后「产出」区 + 仍然指向**上一版**。用户对着一份已经作废的名单点确认，而**界面上完全看不出这是旧的**。 +- **后果**：不是显示错误，是**用户基于过期内容做了决定**。公众号面板与专员面板各自踩过一次。 +- **正确做法**：取**同一步最后一次**跑出来的那条 run（`latestRunOfActionKey` / `latestArtifactOfStep`）。 + 凡是「同一步可重跑」的流程都适用，不限于这两个面板。 +- **配套**：后端的闸门也不能只看「历史上有没有确认过」——那会拿**上一版**的身份去写新稿子； + 闸门必须锚定到当前生效的那一版（`audio_speakers_gate_test.go` 有对应断言）。 +- **为什么**：「重跑」在本平台是常态操作，而不是异常路径。 + +### P06.13 备份会自己毁掉备份 —— 三条自毁路径 + +- **事实**：内置备份（D24）有三处会让「保护数据的机制」反过来损害数据： + 1. **主库不存在或是空的，仍然去备** —— 会拿一份**空快照顶掉保留窗口里的好备份** + （被人误删、或还没初始化时最危险，那时恰恰最需要旧备份）。正确做法：主库为空直接跳过。 + 2. **每次启动都备** —— 进程反复重启（crashloop）时每次产一份新备份，**把保留窗口撑爆**， + 反而把有价值的旧备份挤出去。正确做法：走 `BackupIfDue`，按间隔补齐。 + 3. **解析备份文件名时去找「-2」** —— 时间戳 `20260914-200000` **本身就含 `-2`**。 + 正确做法：时间戳长度固定，按**长度**切前一段（`raw[:len(backupLayout)]`）。 +- **为什么**：备份是「出事之后才用」的东西，它的失败**在正常路径上完全看不见**， + 等真要用的时候才发现窗口里全是空快照 —— 这是最典型的「看起来完成了，其实没有」（G04）。 + +### P06.14 上游返回 HTTP 200 不等于这次调用成功 + +- **事实**：两种「200 但没用」的报文都真实出现过： + - **网关回 200，报文里却没有 `choices`**。实测背景：某技能第 3 步要连打 11 次模型 + （逐字稿按 1200 字分块），**第 4 次**撞上这个，整步就此失败。 + - **`finish_reason=length` + 半截正文** —— 改之前是**原样返回、落库成产物**， + 用户拿到一份被截断的稿子，且系统认为它成功了。 +- **正确做法**： + - 判成功要判**报文结构**，不能只判状态码； + - **重试与否必须由类型决定，不能由文案猜**：模型确实写不出正文（预算被思考吃光、拒答） + 重发一百次都是同一结果，重试只是再花一次钱 —— 这类用 `EmptyCompletionError`； + 协议/链路抖动（无 choices、限流、上游 5xx、连接被掐断）重发有机会成 —— 用 `TransientUpstreamError`。 + - 超长导致的截断必须**报错**，报错要带上路由名与该路由的 `max_tokens`（否则不知道往哪调）。 +- **引申 · 计费的真实性**：转写技能曾有「无论成败都写 `Success: true`」，**用量与计费都是假的**。 + 凡是要计点/计量的调用，成功标志必须来自真实结果，不能来自「函数返回了」。 + +### P06.15 同步长任务的超时上限，就是整套流程的真实长度上限 + +- **事实**：`audioSkill.js` 里 structure/minutes 的超时值**不是随手填的护栏，是这套流程的长度天花板**。 + 实测一条 26:41 的录音（11936 字 → 10 块）：**全程 589.54s**， + 原来的 5 分钟上限**已经被吃到 ≥89%**，稍慢一点就会被前端自己掐断。 +- **后果**：前端超时了，**但后端还在跑、产物也已经落库** —— + 用户看到的却是「失败」，然后重跑一次，产出一份重复的。 +- **正确做法**：把超时当**容量参数**对待，按实测最长耗时的余量来定，不要凭感觉写整数； + 更长的输入应当走异步（G12），而不是继续加超时。 +- **为什么**：这是「前后端对同一件事的成功判定不一致」，与 G04 同源。 + +### P06.16 授权边界必须「失败即最小权限」 + +- **事实**：两条真实存在、且**方向相反**的边界约定： + - `GetByIDForOwners`：**owners 为空时查不到任何东西（而不是查到全部）** —— + 归属标识缺失时必须退化成「什么都看不到」，**绝不能反过来退化成「看所有人的」**。 + - 前端 `deleteTaskCascade`（按 id 级联删、**不校验归属**）与 `deleteMyTask` + （限定 owner、不级联）**两条不能合并**：侧边栏对所有人可见， + 改调前者等于**给任何登录用户一个按 id 删任意任务的口子**；工作台只对管理员开放， + 用不校验归属的那条才是它原本的语义。 +- **正确做法**：权限参数缺失/为空时，默认落到**权限最小**的那一侧； + 两条语义不同的删除路径**不要为了「统一」而合并**。 +- **为什么**：这类代码在正常路径上永远是对的，只有边界输入才透光 —— 而边界输入正是攻击者的入口。 + +### P06.17 整盘克隆会把原型机的历史数据带到客户机上 + +- **事实**：原型机的 `data/backups/` 里会有**原型机自己的历史数据**（测试账号、演示素材）。 + 交付走整盘克隆（D14）时，这些会被**原样带到客户机器上**。 +- **正确做法**：`clonezilla-cleanup.sh` 清理时一并**删空 `data/backups/`**，让客户机从干净状态开始。 +- **为什么**：「删了主库」不等于「删了数据」—— 备份目录是数据的第二份副本， + 清理脚本漏掉它，等于数据没清干净就交付了。 + +### P06.18 过滤条件与判定逻辑必须共用一份实现 + +- **事实**：`resolveChunkMeta` 只认已审批的来源（素材 `status=approved`、知识源 `audit_status=approved`）。 + 上游批量加载元信息时，**如果传了空 map，所有带 `media_file_id` / `knowledge_source_id` 的分片 + 会被整段丢弃** —— 检索候选集只剩「无指针」的那些，**不报错，只是结果悄悄变少**。 +- **正确做法**：过滤条件与内部判定**共用同一个方法**（`ApprovedMetaMaps()`）， + 两处各自手写过滤条件必然漂移；且「过滤结果为空」与「本来就没有」必须能区分开。 +- **为什么**：这是「两处实现同一个判据」的必然结局 —— 与 P06.12 / P06.14 同源： + **静默的错误比报错难查一个量级**。 + ### 关联 - 关联 G04：这些坑的共同点是"看起来完成了，其实没有"——完成判定必须靠事实 - 关联 G11 / P04：数据可追溯、只补空字段，同属"不可静默修改" - 关联 G12：异步任务的失败与进度不能靠 `worker_run.status` - 关联 G14：提交前扫密钥与大文件（P06.10） +- 关联 D14：交付走整盘克隆，清理必须覆盖 `data/backups/`（P06.17） +- **P06.12–P06.18 的共同形状**：失败不报错，只是**结果悄悄变少或变旧** —— + 过期产物、空快照、无 `choices` 的 200、被丢弃的分片。 + 遇到「结果看着对但就是不对」时，先按这几条查，别从头推。 +- **收录标准**：本清单只收「**以后还会再踩**」的坑 —— 工具/语言/框架的固有性质、 + 或换个场景就会复发的失误模式。**已经修完且不会以同样形状复发的过程性修复不收录** + （那些属于提交记录与代码注释）。一次性的报错、版本事故记在 `bugs_and_errors.md`。 --- diff --git a/bugs_and_errors.md b/bugs_and_errors.md new file mode 100644 index 0000000..49acbfc --- /dev/null +++ b/bugs_and_errors.md @@ -0,0 +1,366 @@ +# bugs and errors + +> **用途**：记录开发过程中**真实发生过**的错误与坑。 +> 每条必须能回答四件事：**症状 → 根因 → 怎么修 → 怎么早点发现**。 +> +> 不写流水账，不写「今天很顺利」。这份文件的价值只在于：下一个踩同一个坑的人， +> 能在五分钟内认出自己遇到的是同一件事，而不是花两小时重新推导一遍。 +> +> 关联 `TOP_CODING_RULES.md`（G02 错误不得静默、G04 完成判定靠事实）。 + +## 索引 + +| # | 日期 | 区域 | 一句话 | +|---|---|---|---| +| E01 | 2026-09-26 | 本地 ASR 依赖 | `torchaudio>=2.9` 删了 pyannote 3.x 要的三个 API，装完 `import` 才炸 | +| E02 | 2026-09-26 | 模型下载 | HuggingFace 不通 + pyannote repo gated，hf-mirror 403，只有魔搭能下 | +| E03 | 2026-09-26 | 模型下载 | `jonatasgrosman/…-chinese-zh-cn` 没有 `model.safetensors`，只有 `.bin` | +| E04 | 2026-09-26 | 依赖安装 | whisperx 的依赖树（lightning/optuna/opentelemetry）解析十几分钟不收敛 | +| E05 | 2026-09-26 | 进度测量 | `/proc/PID/io` 的 `read_bytes` **不算 socket 读**，据此误判「下载卡死」 | +| E06 | 2026-09-26 | 本地 ASR 显存 | 8G 卡被 llama-server 占了 5G，large-v3 的 float16 一加载就 CUDA OOM | +| E07 | 2026-09-26 | 本地 ASR 加载 | pyannote 的 `from_pretrained` **只认文件不认目录**，给目录被当成 HF repo id | +| E08 | 2026-09-26 | 本地 ASR 加载 | torch≥2.6 把 `weights_only` 默认翻成 True，pyannote 旧权重直接拒载 | + +--- + +## E01 `torchaudio>=2.9` 删了 pyannote 3.x 要的 API + +**日期**：2026-09-26　**区域**：`~/asr-poc` 本地 ASR 环境　**影响**：整个本地 ASR 跑不起来 + +### 症状 + +装完一切正常（`Successfully installed …` 无任何警告），第一次导入就硬失败： + +``` +$ ./venv/bin/python -c "import pyannote.audio" + File ".../pyannote/audio/__init__.py", line 29, in + from .core.inference import Inference + File ".../pyannote/audio/core/inference.py", line 35, in + from pyannote.audio.core.io import AudioFile + File ".../pyannote/audio/core/io.py", line 60, in + ) -> torchaudio.AudioMetaData: +AttributeError: module 'torchaudio' has no attribute 'AudioMetaData' +``` + +当时的版本：`torch 2.14.0` / `torchaudio 2.11.0` / `pyannote.audio 3.4.0`。 + +### 根因 + +`pyannote.audio` 3.x 有三处依赖 torchaudio 的 **backend-dispatch I/O API**： + +| 位置 | 用的是 | +|---|---| +| `pyannote/audio/core/io.py:60` | `torchaudio.AudioMetaData` 作返回注解 | +| `pyannote/audio/core/io.py:81` | `torchaudio.list_audio_backends()` | +| `pyannote/audio/core/io.py:85` | `torchaudio.info(...)` | + +而 **torchaudio 从 2.9 起把这套 API 整体移除了**（I/O 交给 `torchcodec`），只留下 `load`。 +本机实测 torchaudio 2.11.0： + +```python +>>> [n for n in ('load','info','list_audio_backends','AudioMetaData') if hasattr(torchaudio,n)] +['load'] +``` + +**修复后拿到了 torchaudio 官方的一手佐证** —— 降到 2.8.0 之后 import pyannote.audio， +它自己把这条弃用警告打了出来，等于承认了根因： + +``` +UserWarning: torchaudio._backend.list_audio_backends has been deprecated. This deprecation +is part of a large refactoring effort to transition TorchAudio into a maintenance phase. +The decoding and encoding capabilities of PyTorch for both audio and video are being +consolidated into TorchCodec. ... It will be removed from the 2.9 release. +``` + +「It will be removed from the 2.9 release」—— 正是我们装的 2.11 里发生的事。 + +两个放大伤害的细节： + +1. `io.py` 没有 `from __future__ import annotations`，所以第 60 行的**注解在 import 时求值** —— + 不是用到才炸，是 `import pyannote.audio` 这一行就炸。 +2. 这决定了 **任何 pyannote.audio 3.x 都没救**，不是某个小版本的问题。 + 要么降 torchaudio，要么整个换到 pyannote 4。 + +### 为什么会踩 + +- 最初是裸装：`pip install torch torchaudio faster-whisper "pyannote.audio>=3.1,<4" …` + —— **torch/torchaudio 没钉版本**，拿到当时最新的 2.14.0 / 2.11.0。 +- pip 全程没有任何警告，`Successfully installed` 一长串看着完全正常。 +- 讽刺的是：正因为**绕开 whisperx 手工装**（见 E04）才丢掉了版本约束 —— + 而 whisperx 自己钉的是 `torch~=2.8.0`，等于生态早就知道该用 2.8。 + +### 修法 + +钉到 pyannote 3.4 那一代的组合： + +```bash +pip install --index-url https://mirrors.aliyun.com/pypi/simple \ + "torch==2.8.0" "torchaudio==2.8.0" +``` + +**没走的那条路**：升到 `pyannote.audio 4.0.7`（它已不再依赖 torchaudio）。 +`pip install --dry-run` 的结果： + +``` +Would install … opentelemetry-api/-sdk/-proto/-exporter-*（10 个） + pyannoteai-sdk-0.4.0 torchcodec-0.16.0 safetensors-0.8.0 + pyannote-core-6.0.1 pyannote-database-6.1.1 pyannote-metrics-4.1 +``` + +否决理由：多出十几个包，其中 **`pyannoteai-sdk` 是厂商云 SDK、opentelemetry 是遥测上报** —— +与「100% 本地化部署」的原则相抵；且 4.x 吃不吃 `version: 3.1.0` 的 config **没验证过**， +正好是当初选 pyannote 3.x 时就想避开的那个未知数。 + +### 怎么早点发现 + +**装完立刻 import 一遍，别等跑数据。** + +```bash +./venv/bin/python -c "import torch, faster_whisper, pyannote.audio; print(torch.__version__, pyannote.audio.__version__)" +``` + +一秒的事，能省掉 4.2GB venv + 4.1GB pip 缓存 + 约 2.5GB 重下的往返。 +已固化成 `~/asr-poc/selfcheck.sh`，装完/重建后跑一次。 + +**通用教训**：GPU 生态里「装成功」和「能用」是两件事 —— +`pip install` 只证明包落盘了，不证明 ABI/API 对得上。 +凡是带 C 扩展的包（torch / torchaudio / ctranslate2 / torchcodec），装完必须真 import 一次。 + +--- + +## E02 HuggingFace 不通 + gated，只有魔搭能下 + +**日期**：2026-09-26　**区域**：模型下载 + +**症状**：`huggingface.co` 上 `pyannote/segmentation-3.0` 等 repo 是 **gated**（需登录并接受条款）， +本机连 `huggingface.co` 都连不上（curl 返回 `000`）；退而用 `hf-mirror.com` 代理，**一律 403**。 + +**根因**：gated 是账号态的授权，代理站点没有你的 HF 账号，自然过不了。 + +**修法**：改用 **`modelscope.cn`（魔搭）** —— 它把这些 gated repo 整个镜像到了**官方命名空间** +（路径就是 `pyannote/segmentation-3.0`），且在魔搭上不 gated。 + +同一文件同一时刻的实测： + +| 站点 | 结果 | +|---|---| +| `huggingface.co` | `000`（不通） | +| `hf-mirror.com` | `403` | +| `www.modelscope.cn` | `206`（分片续传正常） | + +**注意**：**gated 不等于许可变更**（许可仍是 MIT / CC-BY-4.0）， +但镜像确实绕过了「在 HF 上点接受条款」那一步，交付前值得再确认一次（关联 G19.10 / P06.11）。 + +**怎么早点发现**：探测顺序应该是「官方 → 官方镜像 → 国内镜像」，而不是「官方失败就放弃」。 +且要用**具体文件**去探，不是探首页 —— 首页 200 不代表文件可下（hf-mirror 就是首页通、文件 403）。 + +--- + +## E03 这个中文对齐 repo 没有 `model.safetensors` + +**日期**：2026-09-26　**区域**：模型下载 + +**症状**：按惯例去取 `model.safetensors` → 404。 + +**根因**：`jonatasgrosman/wav2vec2-large-xlsr-53-chinese-zh-cn` +**只发布了 `pytorch_model.bin`**，没有 safetensors 版本。 + +**修法**：下 `pytorch_model.bin`。已写进 `download_models.sh` 的注释与下载清单， +免得下一个人照 safetensors 的惯例又踩一次。 + +**怎么早点发现**：下之前先列 repo 文件清单 +（魔搭 `…/repo/files?Revision=master`），别按别的 repo 的文件名去猜。 + +--- + +## E04 whisperx 的依赖树解析不收敛 + +**日期**：2026-09-26　**区域**：依赖安装 + +**症状**：`pip install whisperx` 跑了 **16 分钟以上**仍在 `Resolving dependencies`， +没有失败、没有输出进度，看起来像卡死。 + +**根因**：whisperx 3.8.6 依赖 `pyannote-audio>=4.0.0` 与 `torch~=2.8.0`， +连带拖进 `lightning` / `optuna` / `opentelemetry` / `aiohttp` 一大棵树，回溯空间极大。 + +**修法**：放弃 whisperx，只装实际用到的那几个，并**逐条钉版本**： + +``` +torch==2.8.0 torchaudio==2.8.0 faster-whisper pyannote.audio>=3.1,<4 +fastapi uvicorn python-multipart +``` + +说话人分离用 pyannote 直接做，不需要 whisperx 那层封装。 + +**怎么早点发现**：`pip install` 长时间无输出就是危险信号。此时应看 +`/tmp/pip-unpack-*/` 目录是否在长（见 E05），而不是凭感觉判断「卡死了」。 + +--- + +## E05 `/proc/PID/io` 的 `read_bytes` 不算 socket 读 + +**日期**：2026-09-26　**区域**：进度测量（**我自己犯的错**） + +**症状**：pip 下载中，我读 `/proc//io` 的 `read_bytes` 得到 0 KB/s， +据此向用户报告「下载卡死了」，并切了一次源。 + +**根因**：`read_bytes` 统计的是**块设备 I/O**，即真正落到磁盘的字节。 +pip 是边下边写临时文件，套接字收包不计入该字段 —— 这个数字在下载期间本来就接近 0， +它**不是**一个「下载进度」指标。 + +**修法**：量 pip 的下载进度要看**临时目录体积的增长**： + +```bash +du -sb /tmp/pip-unpack-*/ # 隔几秒看两次，差值才是真实速度 +``` + +**后果**：因这一次误判，我多发了一次无谓的切换（源其实没问题）。 +结论是「源慢」而不是「源死」，两者的处置完全不同。 + +**怎么早点发现**：用指标前先确认这个指标**定义的是什么**。 +一个恒为 0 的读数，先怀疑指标选错了，再怀疑被测对象。 + +--- + +## E06 8G 显存被 llama-server 占掉 5G，large-v3 装不下 + +**日期**：2026-09-26　**区域**：本地 ASR（`~/asr-poc`） + +**症状**：`selfcheck.sh` 全绿、模型文件也都在位，一跑就炸： + +``` +File "/home/eaiadmin/asr-poc/asr_core.py", line 71, in _fw_model + _FW_CACHE["m"] = WhisperModel(str(FW_DIR), device="cuda", compute_type="float16", ...) +File ".../faster_whisper/transcribe.py", line 689, in __init__ + self.model = ctranslate2.models.Whisper(...) +RuntimeError: CUDA failed with error out of memory +``` + +**根因**：不是代码问题，是卡上真的没地方了。`nvidia-smi` 实测： + +``` +memory.total 8192 MiB, memory.used 5106 MiB, memory.free 2681 MiB +3418, /app/llama-server, 4778 MiB +3449, /app/llama-server, 232 MiB +``` + +那 5 GiB 是仓库 README 里 8080/8081 那两个**常驻 llama.cpp 服务**占的 —— +属于用户的服务，不是我们这次起的。而 large-v3 的 float16 权重本身就要 3 GB。 + +**修法**：不动别人的进程，改自己的取用方式（默认 `int8_float16`，实测 2.5 GiB 空闲下装得下， +质量损失可接受；`ASR_COMPUTE_TYPE=float16` 可在显存宽裕时调回）： + +```python +_COMPUTE_LADDER = [os.environ.get("ASR_COMPUTE_TYPE", "int8_float16"), "int8"] +``` + +连带的第二个坑：**whisper 和 pyannote 不能同时在卡上**。 +只剩两三百 MB 余量，两个都驻留必炸 —— 而这两步本来就是先后关系。 +所以转写完立刻 `_free_fw()`（`gc.collect()` + `torch.cuda.empty_cache()`）再上 pyannote。 +实测释放后空闲回到 2.50 GiB，分离正常。 + +**怎么早点发现**：**报「CUDA out of memory」时第一件事是 `nvidia-smi` 看谁占着**， +而不是去调自己的 batch size。本机只有 8G 且常年被别的服务占着， +「模型本身装不下」这种情况会反复出现，值得一开始就把 `mem_get_info()` 打进日志 +（现在加载前会打一行 `当前空闲显存 x.xx GiB`）。 + +--- + +## E07 pyannote 的 `from_pretrained` 只认文件，不认目录 + +**日期**：2026-09-26　**区域**：本地 ASR 加载 + +**症状**：把 HF repo id 换成本地绝对路径（一个**目录**）之后，加载报的错看着像路径写错了， +其实完全不是那个意思： + +``` +HFValidationError: Repo id must be in the form 'repo_name' or 'namespace/repo_name': +'/home/.../models/pyannote/segmentation-3.0'. Use `repo_type` argument if needed. +``` + +**根因**：pyannote 判「这是本地路径还是 HF repo id」**只看它是不是一个文件**： + +- `core/model.py:588` —— `if os.path.isfile(checkpoint): path_for_pl = checkpoint` +- `core/pipeline.py:78` —— `if os.path.isfile(checkpoint_path): config_yml = checkpoint_path` + +目录两条都不成立，于是落到 else 分支去当 repo id 校验，报出上面那句 +「repo id 格式不对」——**它压根没打算读目录**。 + +**修法**：给到**文件**。管线给 `config.yaml`，子模型给 `pytorch_model.bin`： + +```python +Pipeline.from_pretrained(str(DIA_DIR / "config.yaml")) # 管线：config 文件 +Model.from_pretrained(checkpoint=str(SEG_DIR / "pytorch_model.bin")) # 子模型：权重文件 +``` + +config.yaml 里那两项也得跟着变成 dict 形式（`getter.py:81` 走 +`Model.from_pretrained(**dict)` 那一支）： + +```yaml + segmentation: + checkpoint: /pytorch_model.bin +``` + +**而且不能给 `hparams_file`** —— 权重里自带 pytorch-lightning 的 hparams， +repo 里那份 `config.yaml` 是模型结构配置、没有 `task:` 段，塞进去只会换来 +`ConfigAttributeError: Missing key setup / full_key: task.setup`。 + +**怎么早点发现**：**路径参数报「格式不对」，先去看那个函数的判定条件是什么**， +别顺着报错字面去改路径写法（我第一反应是路径要加引号/要相对路径，全错）。 +另外：`Pipeline.from_pretrained` 有**两个**同名参数路径，管线和模型各判各的文件类型， +改了一处不代表另一处也通了 —— 这次就是改完管线还在模型那处炸。 + +--- + +## E08 torch≥2.6 的 `weights_only` 默认值翻了个面 + +**日期**：2026-09-26　**区域**：本地 ASR 加载 + +**症状**：路径问题解决后，加载 pyannote 权重时换了一个完全不同的错： + +``` +_pickle.UnpicklingError: Weights only load failed. ... + (1) In PyTorch 2.6, we changed the default value of the `weights_only` argument + in `torch.load` from `False` to `True`. ... + WeightsUnpickler error: Unsupported global: GLOBAL torch.torch_version.TorchVersion + was not an allowed global by default. +``` + +**根因**：torch 2.6 起 `torch.load` 的 `weights_only` 默认由 `False` 翻成 `True`， +pickle 里没在白名单上的全局符号一律拒载。pyannote 3.4 的 `.bin` 里存着 4 个数据类， +逐个不在默认白名单里 —— 而且它是**一次只报一个**，放行一个再报下一个。 + +**修法**：不要图省事用 `weights_only=False`（那等于把反序列化变成任意代码执行）， +而是把这 4 个**数据类**逐个放行： + +```python +torch.serialization.add_safe_globals([ + torch.torch_version.TorchVersion, + pyannote.audio.core.task.Specifications, + pyannote.audio.core.task.Problem, + pyannote.audio.core.task.Resolution, +]) +``` + +放行的全是数据类、没有可调用对象；权重是我们自己下的、过了 SHA256SUMS， +不存在「不可信来源」的问题。 + +**怎么早点发现**：这 4 个是**实测枚举出来的**（捕获异常 → 正则抠出 `GLOBAL x.y.Z` → +import 回来 → 再放行 → 重试，直到加载成功），不是猜的。下次遇到同类拒载， +可以用同一招把清单跑出来，别一个个手试。 + +**遗留疑问**：这 4 个是**这一次加载路径**上遇到的；换模型/换 pyannote 版本可能还要加。 +所以 `selfcheck.sh` 里那条「模型文件在位」之外，**首次加载必须真跑一次 diarize** —— +只 import 不加载是查不出来的（import 一路都是好的）。 + +--- + +## 待沉淀（还没写进规则的） + +- [ ] **装完必须导入自检**：带 C 扩展的包（torch / torchaudio / ctranslate2）装完立刻 import 一次（见 E01）。 + 是否升格为 `TOP_CODING_RULES.md` 的一条（放在 G19 依赖那节，或新开一条「依赖装完必须自检」）待定。 +- [ ] **E08 的通用形状**：`torch.load(weights_only=True)` 是 2.6 之后的默认行为， + 凡是加载 2.6 之前产出的 `.bin` / `.ckpt` 都会撞上，且与具体项目无关 —— + 候选升格为 P06 的一条（「旧权重在新 torch 上要先放行 unpickle 白名单」）。 +- [ ] **E06 的通用形状**：GPU 是共享资源，跑之前先 `nvidia-smi` 看**别人**占了多少， + 再决定自己的精度档位 —— 候选升格为 P06 的一条。 diff --git a/deploy/searxng/docker-compose.yml b/deploy/searxng/docker-compose.yml new file mode 100644 index 0000000..f79f36f --- /dev/null +++ b/deploy/searxng/docker-compose.yml @@ -0,0 +1,33 @@ +services: + # 使用 host 网络：容器与宿主机共享网络栈。 + # 原因：本机环境 Docker bridge 模式的 NAT 出站被阻断，容器无法访问外网； + # host 模式下 searxng 直接复用宿主网络可正常联网（已验证 python host-net 连 baidu:443 OK）。 + searxng-valkey: + image: ${SEARXNG_VALKEY_IMAGE:-ghcr.io/valkey-io/valkey:8.1.4} + container_name: eai-searxng-valkey + command: ["valkey-server", "--save", "", "--appendonly", "no"] + restart: unless-stopped + network_mode: host + volumes: + - searxng-valkey-data:/data + + searxng: + image: ${SEARXNG_IMAGE:-ghcr.io/searxng/searxng:latest} + container_name: eai-searxng + restart: unless-stopped + network_mode: host + environment: + SEARXNG_BASE_URL: ${SEARXNG_PUBLIC_BASE_URL:-http://127.0.0.1:18080/} + SEARXNG_SECRET: ${SEARXNG_SECRET:-eai-agentplatform-searxng-change-me} + SEARXNG_VALKEY_URL: valkey://127.0.0.1:6379/0 + SEARXNG_PORT: ${SEARXNG_PORT:-18080} + UWSGI_THREADS: 4 + volumes: + - ./searxng:/etc/searxng:ro + - searxng-cache:/var/cache/searxng + depends_on: + - searxng-valkey + +volumes: + searxng-cache: + searxng-valkey-data: \ No newline at end of file diff --git a/deploy/searxng/searxng/settings.yml b/deploy/searxng/searxng/settings.yml new file mode 100644 index 0000000..16572df --- /dev/null +++ b/deploy/searxng/searxng/settings.yml @@ -0,0 +1,47 @@ +# SearXNG settings for pj0235 eai_agentplatform +use_default_settings: + engines: + keep_only: + - baidu + - 360search + - sogou + - bing + - wikipedia + - bilibili + +general: + debug: false + instance_name: "pj0235 SearXNG" + +search: + safe_search: 0 + autocomplete: "" + formats: + - html + - json + +server: + secret_key: "eai-agentplatform-searxng-change-me" + limiter: false + image_proxy: true + +valkey: + url: valkey://127.0.0.1:6379/0 + +engines: + - name: baidu + disabled: false + timeout: 5.0 + - name: 360search + disabled: false + timeout: 5.0 + - name: sogou + disabled: false + timeout: 6.0 + - name: bing + disabled: false + timeout: 5.0 + - name: wikipedia + disabled: false + - name: bilibili + disabled: false \ No newline at end of file diff --git a/docs/02_Architecture/AR04_部署架构.md b/docs/02_Architecture/AR04_部署架构.md index 508ec50..084a830 100644 --- a/docs/02_Architecture/AR04_部署架构.md +++ b/docs/02_Architecture/AR04_部署架构.md @@ -1,7 +1,8 @@ # AR04 — 部署架构设计 > **版本：V1.3 | 部署模式：纯本地离线 · Go 单二进制 + SQLite · systemd** -> **当前实现**：**Go 单二进制 + SQLite(eai_agentplatform.db) + 内网 Ollama(LLM/embedding) + systemd**，无 Docker、无 MySQL、无 FAISS、无 Python 运行时。 +> **当前实现**：**Go 单二进制 + SQLite(eai_agentplatform.db) + 内网 Ollama(LLM/embedding) + systemd**，无 Docker、无 MySQL、无 FAISS。 +> **平台本体无 Python 运行时**；本地语音转写是**独立的 Python 边车进程**（`eai_agentplatform-asr.service`，监听 127.0.0.1:8090，用户不可见），详见部署文档与 `backend-go/deploy/DELIVERY.md` 第 0/2.5 节。 > **知识链路**：检索为 Go 原生实施（embed_gen 路由嵌入候选块 + 余弦召回，对齐 D07/D13）；分类/入库已彻底迁移到 Go，Python 的 `knowledge_service` 已删除。 > **完整部署步骤请见 docs/02_Architecture/部署文档.md。** @@ -61,8 +62,9 @@ | SQLite | data/eai_agentplatform.db | 内嵌 | 单文件关系数据（glebarez/sqlite 纯 Go 驱动，无需 CGO） | | LibreOffice + pdftotext | 裸进程 | exec 调用 | 文档转 PDF/文本预览（非容器，不监听端口） | | LLM 服务 | 11434 | 外置 | 内网 OpenAI 兼容接口（Ollama / vLLM / 网关） | +| 本地语音转写（边车） | 127.0.0.1:8090 | 本机可选 | faster-whisper large-v3 + pyannote 3.1；仅回环监听，不对外 | -**核心特征**：无 Docker、无 Python 运行时、无 MySQL、无 FAISS。后端为 Go 单二进制，数据为 SQLite 单文件；知识检索为 Go 原生向量/关键词召回（align D07/D13）。 +**核心特征**：无 Docker、无 MySQL、无 FAISS。后端为 Go 单二进制（本体无 Python 运行时），数据为 SQLite 单文件；知识检索为 Go 原生向量/关键词召回（align D07/D13）。语音转写另有一个本地 Python 边车服务（见上表末行），它是可选件：不装则转写走云端路由。 ## 3. Nginx 关键配置 diff --git a/docs/02_Architecture/部署文档.md b/docs/02_Architecture/部署文档.md index d155edf..22528e9 100644 --- a/docs/02_Architecture/部署文档.md +++ b/docs/02_Architecture/部署文档.md @@ -61,7 +61,9 @@ | LibreOffice + pdftotext | 进程内调用 | 裸进程，非容器，文档转文本 | | LLM 服务 | 11434 | 内网 OpenAI 兼容接口（Ollama / vLLM） | -**无 Docker、无 Python、无 MySQL、无 FAISS 运行时。** 后端为 Go 单二进制，数据为 SQLite 单文件（`data/eai_agentplatform.db`），知识检索为 Go 原生向量/关键词召回（embed_gen 嵌入 + 余弦，对齐 D07/D13），不依赖外部向量库。 +**无 Docker、无 MySQL、无 FAISS 运行时；平台本体无 Python 运行时。** 后端为 Go 单二进制，数据为 SQLite 单文件（`data/eai_agentplatform.db`），知识检索为 Go 原生向量/关键词召回（embed_gen 嵌入 + 余弦，对齐 D07/D13），不依赖外部向量库。 + +> **例外：本地语音转写（ASR）是独立的 Python 服务**，`eai_agentplatform-asr.service` 常驻在 127.0.0.1:8090，占用约 13.5 GB 磁盘（venv + 模型）。它是**可选件**：不装则转写自动走云端路由，界面会在结果上标注「音频已离开本机」。安装与验证见 `backend-go/deploy/DELIVERY.md` 第 2.5 节。 --- diff --git a/eai_agentplatform/backend-go/config/ai_config.json b/eai_agentplatform/backend-go/config/ai_config.json index 871c548..b4828a0 100644 --- a/eai_agentplatform/backend-go/config/ai_config.json +++ b/eai_agentplatform/backend-go/config/ai_config.json @@ -4,19 +4,64 @@ "image_gen": "image_route_openrouter_gpt_image_2", "video_gen": "video_route_openrouter_veo_3", "path_coach": "chat_route_lmuai_deepseek_v4_flash", - "title_gen": "chat_route_lmuai_deepseek_v4_flash" + "title_gen": "chat_route_lmuai_deepseek_v4_flash", + "audio_transcribe": "audio_route_auto", + "audio_transcribe_llm": "chat_route_lmuai_deepseek_v4_flash_doc" + }, + "audio_routes": { + "audio_route_local_whisper": { + "base_url": "http://127.0.0.1:8090/v1", + "description": "语音转写 · 本机 faster-whisper large-v3 + pyannote 3.1（音频不出本机）。由 deploy/eai_agentplatform-asr.service 常驻在 127.0.0.1:8090；服务不在时 audio_route_auto 会改走 fallback_routes 里的云端路由，并在转写产物里标注「音频已出本机」。timeout 定在 840s 而不是一小时：前端 api/audioSkill.js 给这一步的上限是 15 分钟，后端必须在它之前自己收手（否则用户看到的是 axios 超时，而后端还在跑），同时 840s 里还留得下云端那 600s 的回退预算", + "endpoint": "/audio/transcriptions", + "model": "large-v3", + "provider": "local_asr", + "short_model_name": "whisper large-v3", + "short_route_name": "本地", + "supports_speakers": true, + "timeout_seconds": 840 + }, + "audio_route_siliconflow_diarize": { + "description": "语音转写 · SiliconFlow / XingChen ASR Diarize（云端，音频会出本机；本地服务不可用时的回退，也可由管理员手动指定）", + "endpoint": "/audio/transcriptions", + "model": "XingChenAGI/XingChenASR-Diarize-V3.0", + "provider": "siliconflow", + "short_model_name": "XingChen ASR Diarize", + "short_route_name": "SiliconFlow", + "supports_speakers": true, + "timeout_seconds": 600 + }, + "audio_route_siliconflow_qwen3": { + "description": "语音转写 · SiliconFlow / Qwen3-ASR（云端，音频会出公网；无说话人分离）", + "endpoint": "/audio/transcriptions", + "model": "Qwen/Qwen3-ASR-1.7B", + "provider": "siliconflow", + "short_model_name": "Qwen3 ASR", + "short_route_name": "SiliconFlow", + "supports_speakers": false, + "timeout_seconds": 600 + } }, "chat_routes": { "chat_route_lmuai_deepseek_v4_flash": { - "description": "LMUAI / DeepSeek Flash", + "description": "LMUAI / DeepSeek Flash。max_tokens 从 4096 提到 32768（2026-09-26）：4096 是当初只按「聊天」估的，但这条路由是 default_route，用户在对话框里选过模型后这个选择会被记进 localStorage 并**一路带到技能内部的加工步骤**（全仓库只有语音转写的第 3、4 步消费 ai_route_id，见 skills/api/audio_handlers.go 的 resolveAudioChatRoute）。于是它会顶掉技能自带的 _doc 路由，让「整理段落」在推理模型思考完之前就把预算耗光、正文 0 字。上限是天花板不是配额，模型写完就停，抬高不会让聊天变慢变贵（实测见 _doc 那条的说明）", "endpoint": "/chat/completions", - "max_tokens": 4096, + "max_tokens": 32768, "model": "deepseek-v4-flash", "provider": "lmuai", "short_model_name": "DeepSeek V4 Flash", "short_route_name": "LMUAI", "temperature": 0.7 }, + "chat_route_lmuai_deepseek_v4_flash_doc": { + "description": "LMUAI / DeepSeek Flash（长文输出档，max_tokens=32768）· 供逐字稿整理这类要产出一整篇文档的技能使用。为什么不复用上面那条 4096 的：这是推理模型，思考与正文共用 max_tokens，而思考的长度跟输入几乎不成比例（实测 1200 字的输入，思考照样写到 7169 字）。4096 下正文一个字都写不出来（六次实测只有一次成功）。再说为什么是 32768 而不是 8192：纪要步骤最后要把各段结果**归并**成一份，那是全流程最长的一次输入（实测 8628 字），8192 下 finish_reason=length、正文 0 字，16384 才出稿、32768 又快又稳。上限提高**不会**让逐块调用变慢或变贵——上限是天花板不是配额，模型写完就停：实测同一批 11 段，8192 与 32768 两档的用时（18.6s / 19.2s）与 completion token（均 4928 / 5094）基本一致。调小这个值之前请先看 audio_transcribe/prompts.go 里的实测表", + "endpoint": "/chat/completions", + "max_tokens": 32768, + "model": "deepseek-v4-flash", + "provider": "lmuai", + "short_model_name": "DeepSeek V4 Flash（长文档）", + "short_route_name": "LMUAI", + "temperature": 0.7 + }, "chat_route_ollama_qwen": { "description": "本地对话 · llama.cpp / Qwen3.5 4B", "endpoint": "/chat/completions", @@ -89,6 +134,7 @@ "temperature": 0.7 } }, + "default_audio_route": "audio_route_local_whisper", "default_embed_route": "embed_route_llamacpp_nomic", "default_route": "chat_route_lmuai_deepseek_v4_flash", "description": "eai_agentplatform AI 路由配置 — 按场景分类定义多条路由，支持 provider/模型切换", @@ -141,6 +187,9 @@ "chat_route_ollama_qwen_fast", "chat_route_ollama_qwen" ], + "audio_route_local_whisper": [ + "audio_route_siliconflow_diarize" + ], "embed_route_llamacpp_nomic": [ "embed_route_openrouter_text_v3" ], diff --git a/eai_agentplatform/backend-go/config/search_config.json b/eai_agentplatform/backend-go/config/search_config.json new file mode 100644 index 0000000..e183723 --- /dev/null +++ b/eai_agentplatform/backend-go/config/search_config.json @@ -0,0 +1,46 @@ +{ + "version": 1, + "active": ["dtsai", "serpapi", "searxng", "sogou", "browser"], + "engines": { + "serpapi": { + "type": "serpapi", + "enabled": true, + "api_key_env": "SERPAPI_API_KEY", + "engine": "google", + "language": "zh-cn", + "max_results": 8, + "timeout_sec": 15 + }, + "dtsai": { + "type": "dtsai", + "enabled": true, + "api_key_env": "DTS_AI_API_KEY", + "region": "cn-beijing", + "language": "zh-cn", + "max_results": 8, + "timeout_sec": 15 + }, + "searxng": { + "type": "searxng", + "enabled": true, + "base_url": "http://127.0.0.1:18080", + "language": "zh", + "max_results": 8, + "timeout_sec": 25 + }, + "sogou": { + "type": "sogou", + "enabled": true, + "language": "zh-cn", + "max_results": 8, + "timeout_sec": 15 + }, + "browser": { + "type": "browser", + "enabled": true, + "language": "zh-cn", + "max_results": 8, + "timeout_sec": 25 + } + } +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/deploy/DELIVERY.md b/eai_agentplatform/backend-go/deploy/DELIVERY.md index 7bbd7d8..27939f3 100644 --- a/eai_agentplatform/backend-go/deploy/DELIVERY.md +++ b/eai_agentplatform/backend-go/deploy/DELIVERY.md @@ -1,4 +1,4 @@ -# 交付手册（Go 单二进制 + Clonezilla 整盘克隆） +# 交付手册（静态单二进制 + 本地语音转写 + Clonezilla 整盘克隆） > 面向交付工程师。目标：把一台配置好的原型机整盘克隆到客户同型号机器， > 客户拿到手即用，机器上**无源代码、无开发痕迹、无测试数据、无默认口令**。 @@ -12,13 +12,35 @@ | `eai_agentplatform-server` | 单二进制（CGO 关闭，静态链接，约 38MB，无任何运行时依赖） | | `eai_agentplatform.service` | systemd 单元文件 | | `eai_agentplatform.env` | 环境变量样例 | +| `eai_agentplatform-asr.service` | 本地语音转写服务的 systemd 单元（**需要 Python，见下**） | +| `asr.env` | 本地语音转写服务的环境变量样例 | | `clonezilla-cleanup.sh` | 克隆前清理脚本（DRY-RUN 默认） | | `data/eai_agentplatform.db` | SQLite 数据库（首启自动建表） | | `data/kb_data/` | 已审批素材目录 | | `assets/knowledge/source/` | 知识源 Markdown（待入库，由管理员审批） | | `assets/training/materials/` | 培训资料资产（课程种子、PDF、视频、脚本） | -**不需要**：Go 运行时、Python、Docker、MySQL、任何 pip/npm 依赖。 +**不需要**：Go 运行时、Docker、MySQL、任何 npm 依赖。 + +> **平台本体确实不需要 Python**：`eai_agentplatform-server` 是静态单二进制， +> `ldd` 输出 `not a dynamic executable`，这条一直成立。 +> +> **但语音转写是另一个进程，它需要。** 转写默认走本机（faster-whisper large-v3 + +> pyannote 3.1），由一个独立的 Python 服务（`eai_agentplatform-asr.service`， +> 监听 127.0.0.1:8090）提供。客户机器上因此会多出： +> +> | 组件 | 体积 | 说明 | +> |---|---|---| +> | `/opt/eai_agentplatform-asr/venv` | 约 9.4 GB | Python 环境（含 CUDA 版 PyTorch） | +> | `/opt/eai_agentplatform-asr/models` | 约 4.1 GB | 模型权重，随整盘克隆带过去，不重新下载 | +> +> 合计约 **13.5 GB**，交付前请确认目标机磁盘够用。 +> +> 这**不是**「为了本地化而放弃轻交付」——恰恰相反：把转写留在本机，是为了不让 +> 客户会议的录音被送到公网 ASR。此处与「单二进制交付」的出入是明知并接受的取舍， +> 记在案。若某台客户机确实装不了 Python，可以把默认语音路由切到云端 +> （后台 → AI 路由 → 默认语音路由），代价是**录音会离开本机**， +> 界面在转写结果上会明确标注「音频已离开本机」。 --- @@ -38,8 +60,23 @@ │ ├── backups/ # 定期备份（服务自动维护，见第 7 节） │ └── kb_data/ # 素材 + 提取缓存 └── (前端静态资源由 Nginx 托管，见 ../docs/02_Architecture/部署文档.md) + +/opt/eai_agentplatform-asr/ # 本地语音转写（独立进程，独立单元） +├── serve.py # OpenAI 兼容 HTTP 端点（/v1/audio/transcriptions、/v1/models） +├── asr_core.py # 转写 + 说话人分离 +├── asr.env # 环境变量（精度档位、离线开关） +├── venv/ # Python 环境（约 9.4 GB） +├── models/ # 模型权重（约 4.1 GB，实体目录） +│ ├── Systran/faster-whisper-large-v3/ +│ └── pyannote/{segmentation-3.0,wespeaker-voxceleb-resnet34-LM,speaker-diarization-3.1}/ +└── cache/ # 运行时缓存（HF_HOME 指到这里） ``` +> `serve.py` 按 `脚本所在目录/models` 找模型，所以 `models/` 必须是它的同级目录 +> （符号链接也行，但交付机上建议放实体目录，少一层依赖）。 +> 原型机上 `~/asr-poc/models` 是指向仓库 `external_download/` 的软链 —— 那是开发期的 +> 组织方式，克隆到客户机之前必须把权重**拷成实体目录**，客户机上没有仓库。 + --- ## 2. 交付前准备（原型机） @@ -66,8 +103,34 @@ sudo sed -i "s|^JWT_SECRET=.*|JWT_SECRET=$NEW_SECRET|" /opt/eai_agentplatform/.e sudo systemctl daemon-reload sudo systemctl enable --now eai_agentplatform curl http://127.0.0.1:8080/api/health # {"status":"ok",...} + +# 2.5 本地语音转写服务（ASR） +# 环境本身随原型机整盘克隆过来，这一步只是把它装到交付位置 + 起服务。 +# venv 与模型都很大（9.4G + 4.1G），用 mv 而不是 cp —— 两台机器上各留一份没意义。 +sudo mkdir -p /opt/eai_agentplatform-asr +sudo cp -a ~/asr-poc/{serve.py,asr_core.py} /opt/eai_agentplatform-asr/ +sudo mv ~/asr-poc/venv /opt/eai_agentplatform-asr/venv +sudo cp -aL ~/asr-poc/models /opt/eai_agentplatform-asr/models # -L 解开软链，客户机上没有仓库可指 +sudo install -m 0644 deploy/asr.env /opt/eai_agentplatform-asr/asr.env +sudo install -m 0644 deploy/eai_agentplatform-asr.service /etc/systemd/system/ +sudo chown -R eai_agentplatform:eai_agentplatform /opt/eai_agentplatform-asr +sudo mkdir -p /opt/eai_agentplatform-asr/cache && sudo chown eai_agentplatform:eai_agentplatform /opt/eai_agentplatform-asr/cache + +sudo systemctl daemon-reload +sudo systemctl enable --now eai_agentplatform-asr + +# 2.6 验证：模型加载要几十秒，起来之前 /v1/models 是连不上的 +systemctl is-active eai_agentplatform-asr # active +curl -s http://127.0.0.1:8090/v1/models | head -c 200 +# 再确认平台侧认它：后台 → AI 路由 → 语音转写，应显示「本地转写 · Whisper large-v3」 ``` +> **转写模型与平台是强耦合的吗？** 不是。平台启动时读 `config/ai_config.json`， +> `audio_route_local_whisper` 指向 `http://127.0.0.1:8090/v1`。ASR 服务没起来 +> **不影响平台启动**：转写会自动回退到 `fallback_routes` 里的云端路由， +> 并在转写产物的日志与界面警示区写明「已回退到云端，音频已离开本机」。 +> 这正是让 ASR 单独成一个 systemd 单元（而不是塞进主进程）的原因。 + --- ## 3. 克隆前清理（不可逆，务必先 DRY-RUN） @@ -81,6 +144,8 @@ sudo bash clonezilla-cleanup.sh --confirm # 确认后真实清理 - 删除所有 Go 源代码（`cmd/` `internal/` `go.mod` `go.sum`） - 清除 `.git` / 版本控制痕迹 - 清空日志与 shell 历史 +- 删除本地 ASR 工作区里的**原型机数据**：`~/asr-poc/audio`（真实会议录音）、 + `~/asr-poc/out`（完整逐字稿与说话人分离结果，含一份云端转写对照稿）、安装日志 脚本**不**负责（需手工确认，见下）： @@ -91,6 +156,7 @@ sudo bash clonezilla-cleanup.sh --confirm # 确认后真实清理 | A | **重置管理员密码** | `sudo -u eai_agentplatform /opt/eai_agentplatform/eai_agentplatform-server -reset-admin '<强密码>'` | | B | **确认 JWT 密钥随机** | `grep -c '__CHANGE_ME__' /opt/eai_agentplatform/.env`（应为 0） | | C | **清空测试数据** | Web 后台删除演示用户/素材/考试记录，或用 sqlite3（见第 4 节） | +| D | **删掉 ASR 工作区，只留一份 venv** | 装好 `/opt/eai_agentplatform-asr` 并确认服务能起后，`rm -rf ~/asr-poc`（清理脚本会给提示，不代删） | > 默认种子账号为 `admin / admin123`，**克隆前必须改密**（A 项），否则客户拿到默认口令。 @@ -138,6 +204,10 @@ SQL - [ ] `.bash_history` 已清空、无 `.git` - [ ] 测试账号（zhangsan 等）、演示素材、演示考试记录已删除 - [ ] `data/backups/` 里没有**原型机自己的**数据备份（见第 7 节末） +- [ ] `~/asr-poc/audio`、`~/asr-poc/out` 已删（真实录音与逐字稿） +- [ ] 全盘只有一份 `venv`（在 `/opt/eai_agentplatform-asr`），`~/asr-poc` 已删 +- [ ] `/opt/eai_agentplatform-asr/models` 是实体目录，不是指向仓库的软链 +- [ ] `systemctl is-active eai_agentplatform-asr` 为 `active`，且转写可选到「本地转写」路由 --- diff --git a/eai_agentplatform/backend-go/deploy/asr.env b/eai_agentplatform/backend-go/deploy/asr.env new file mode 100644 index 0000000..f5418df --- /dev/null +++ b/eai_agentplatform/backend-go/deploy/asr.env @@ -0,0 +1,30 @@ +# 本地语音转写服务（eai_agentplatform-asr.service）的环境变量样例。 +# +# 装机：sudo cp deploy/asr.env /opt/eai_agentplatform-asr/asr.env +# 端口不在这里配 —— 它写在 unit 的 ExecStart 上（--port 8090）， +# 与后端 config/ai_config.json 里 audio_route_local_whisper.base_url 的 8090 +# 是同一个值。改端口要同时改这两处，否则后端起不来时界面会显示 +# 「本地路由不健康」，而真实原因是对不上端口。 +# 这里注释掉的那行只是记录这个耦合，别指望它生效： +# ASR_PORT=8090 + +# 计算精度。8G 显存要和 llama-server 共用，float16 会 OOM（原型机实测， +# 见 bugs_and_errors.md E06）。int8_float16 是这台机器的可用档位。 +ASR_COMPUTE_TYPE=int8_float16 + +# 模型目录**不在这里配**：serve.py 按 `脚本所在目录/models` 找，也就是 +# /opt/eai_agentplatform-asr/models（软链或实体目录都行，见 DELIVERY.md 第 1 节）。 +# 把模型放到别处就得改 asr_core.py，不如把目录放对。 + +# 离线开关。权重全部是本地文件（faster-whisper 直接读目录、pyannote 的 +# config.yaml 已改写成本地文件路径），正常情况下一个网络请求都不发。 +# 这两个开关是安全网：万一哪条分支想回 huggingface.co，本机到那边是**不通**的， +# 表现会是挂起几分钟而不是报错 —— 加上开关，它立刻失败，日志里一眼能看出来。 +HF_HOME=/opt/eai_agentplatform-asr/cache/huggingface +HF_HUB_OFFLINE=1 +TRANSFORMERS_OFFLINE=1 + +# 故意没有 PYTORCH_CUDA_ALLOC_CONF 之类的分配器开关：这台机器的显存配置 +# （int8_float16 + 转写前后释放模型）是实测调出来的，见 bugs_and_errors.md E06。 +# 没在这台机器上验过的旋钮不要加进来 —— 加错了表现是 OOM， +# 而 OOM 看起来又像「模型太大」，很容易往错误的方向查。 diff --git a/eai_agentplatform/backend-go/deploy/clonezilla-cleanup.sh b/eai_agentplatform/backend-go/deploy/clonezilla-cleanup.sh index 981b845..bc8c53c 100644 --- a/eai_agentplatform/backend-go/deploy/clonezilla-cleanup.sh +++ b/eai_agentplatform/backend-go/deploy/clonezilla-cleanup.sh @@ -46,7 +46,42 @@ echo " 或在克隆前用 sqlite3 执行（见 DELIVERY.md 第 4 节）。脚 echo " - 别漏了 $APP_DIR/data/backups/ ：里面是原型机自己的历史快照，含同一批测试数据，" echo " 整盘克隆会一起带到客户机器上。确认无用后手工清空该目录（见 DELIVERY.md 第 7 节）。" -step "4. 清空日志与 shell 历史" +step "4. 清理本地 ASR 工作区的原型机数据（录音与逐字稿）" +ASR_DIR="/opt/eai_agentplatform-asr" + +# 为什么这一步必须做，而不是「顺手清个缓存」： +# 原型机的 ~/asr-poc/audio/ 里是**真实会议录音**，~/asr-poc/out/ 里是它的完整逐字稿 +# 与说话人分离结果（还有一份云端转写的对照稿）。整盘克隆会把它们原样带到客户机器上。 +# 与 data/backups/ 同一类问题：不是程序数据，是原型机自己的业务内容。 +for ws in /home/*/asr-poc; do + [[ -d "$ws" ]] || continue + echo " 工作区: $ws" + for sub in out audio __pycache__; do + [[ -e "$ws/$sub" ]] || continue + echo " 将删除: $ws/$sub（录音 / 逐字稿 / 缓存）" + [[ $DRY -eq 0 ]] && rm -rf "$ws/$sub" + done + # requirements.lock.txt 留着：它是这套环境精确版本的唯一记录， + # 属于离线重建的工具件，不是开发痕迹（venv 里 pip freeze 也能再生成）。 + for f in "$ws"/*.log; do + [[ -e "$f" ]] || continue + echo " 将删除: $f" + [[ $DRY -eq 0 ]] && rm -f "$f" + done +done + +# 工作区本身能不能删，取决于它是否已经**装到**交付位置。 +# 删早了服务就起不来，而且没有源码可以重建 —— 所以只提示，不自动删。 +if [[ -d "$ASR_DIR" ]]; then + echo " 已安装到交付位置：$ASR_DIR" + echo " 确认下面这些都在，就可以删掉 ~/asr-poc（其中 venv 有 9G，别在两处各留一份）：" + echo " $ASR_DIR/serve.py $ASR_DIR/asr_core.py $ASR_DIR/venv/ $ASR_DIR/models/ $ASR_DIR/asr.env" + echo " 删之前先确认服务能起来：systemctl restart eai_agentplatform-asr && curl -sI http://127.0.0.1:8090/v1/models" +else + warn " 未发现 $ASR_DIR —— 本地 ASR 还没装到交付位置，先别动 ~/asr-poc。" +fi + +step "5. 清空日志与 shell 历史" for f in "$APP_DIR/logs" "$APP_DIR"/*.log /var/log/eai_agentplatform*.log; do if compgen -G "$f" >/dev/null 2>&1; then echo " 将清空: $f" @@ -60,7 +95,7 @@ for h in /root/.bash_history /home/*/.bash_history; do fi done -step "5. 提示：以下必须手工完成（脚本无法替你决定口令）" +step "6. 提示：以下必须手工完成（脚本无法替你决定口令）" cat <<'EOF' [A] 重置管理员密码： sudo -u eai_agentplatform /opt/eai_agentplatform/eai_agentplatform-server -reset-admin '<新强密码>' @@ -70,13 +105,14 @@ cat <<'EOF' grep -n '__CHANGE_ME__' /opt/eai_agentplatform/.env && echo '!! 存在未替换占位符' || echo '无占位符' EOF -step "6. 移除本清理脚本自身（交付物不含脚本）" +step "7. 移除本清理脚本自身（交付物不含脚本）" echo " 将删除: $0" [[ $DRY -eq 0 ]] && rm -f "$0" echo if [[ $DRY -eq 0 ]]; then log "清理完成。请复核 [A][B][C] 三项，再执行 Clonezilla 整盘克隆。" + warn "本地 ASR 工作区（~/asr-poc）是否已删、是否只剩一份 venv，请手工确认（见上面第 4 步的提示）。" else warn "DRY-RUN 结束，未做任何修改。确认后：sudo bash $0 --confirm" fi diff --git a/eai_agentplatform/backend-go/deploy/eai_agentplatform-asr.service b/eai_agentplatform/backend-go/deploy/eai_agentplatform-asr.service new file mode 100644 index 0000000..1472d3b --- /dev/null +++ b/eai_agentplatform/backend-go/deploy/eai_agentplatform-asr.service @@ -0,0 +1,40 @@ +[Unit] +Description=eai_agentplatform 本地语音转写服务（faster-whisper large-v3 + pyannote 3.1） +Documentation=file:/opt/eai_agentplatform-asr/OFFLINE.md +After=network.target +Wants=network.target + +[Service] +Type=simple +User=eai_agentplatform +Group=eai_agentplatform +WorkingDirectory=/opt/eai_agentplatform-asr +EnvironmentFile=-/opt/eai_agentplatform-asr/asr.env +ExecStart=/opt/eai_agentplatform-asr/venv/bin/python /opt/eai_agentplatform-asr/serve.py --host 127.0.0.1 --port 8090 +# 模型加载要几十秒，第一次失败多半是显存被占（和 llama-server 抢 8G 卡）。 +# 不要因为一次失败就让本地转写彻底消失 —— 后端起不来时平台会回退云端， +# 而用户并不知道自己失去了「音频不出本机」，所以这里必须一直重试。 +Restart=always +RestartSec=10 + +# 交付专用设备：最小权限加固。 +# 与 eai_agentplatform.service 的差异有两处，都是必需的： +# 1) 没有 PrivateDevices=true —— 它会隐藏 /dev/nvidia*，本服务要跑 CUDA，一设就起不来； +# 2) ReadWritePaths 指向自己的 cache，venv 与模型目录保持只读。 +NoNewPrivileges=true +ProtectSystem=strict +ProtectHome=true +ReadWritePaths=/opt/eai_agentplatform-asr/cache +PrivateTmp=true +ProtectKernelTunables=true +ProtectKernelModules=true +ProtectControlGroups=true +RestrictSUIDSGID=true + +# 显存只有 8G，还要和 llama-server 共用。杀进程时给它留出释放显存的时间， +# 否则紧接着的重启会撞上「显存没还回来」而再失败一次。 +KillMode=mixed +TimeoutStopSec=30 + +[Install] +WantedBy=multi-user.target diff --git a/eai_agentplatform/backend-go/go.mod b/eai_agentplatform/backend-go/go.mod index 5ac500a..0045767 100644 --- a/eai_agentplatform/backend-go/go.mod +++ b/eai_agentplatform/backend-go/go.mod @@ -15,13 +15,16 @@ require ( github.com/bytedance/sonic v1.15.0 // indirect github.com/bytedance/sonic/loader v0.5.0 // indirect github.com/cloudwego/base64x v0.1.6 // indirect + github.com/deckarep/golang-set/v2 v2.8.0 // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/gabriel-vasile/mimetype v1.4.12 // indirect github.com/gin-contrib/sse v1.1.0 // indirect github.com/glebarez/go-sqlite v1.21.2 // indirect + github.com/go-jose/go-jose/v3 v3.0.5 // indirect github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/validator/v10 v10.30.1 // indirect + github.com/go-stack/stack v1.8.1 // indirect github.com/goccy/go-json v0.10.5 // indirect github.com/goccy/go-yaml v1.19.2 // indirect github.com/google/uuid v1.3.0 // indirect @@ -35,6 +38,7 @@ require ( github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect github.com/modern-go/reflect2 v1.0.2 // indirect github.com/pelletier/go-toml/v2 v2.2.4 // indirect + github.com/playwright-community/playwright-go v0.6000.0 // indirect github.com/quic-go/qpack v0.6.0 // indirect github.com/quic-go/quic-go v0.59.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect diff --git a/eai_agentplatform/backend-go/go.sum b/eai_agentplatform/backend-go/go.sum index 2883d8f..1d44998 100644 --- a/eai_agentplatform/backend-go/go.sum +++ b/eai_agentplatform/backend-go/go.sum @@ -9,6 +9,8 @@ github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gE github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/deckarep/golang-set/v2 v2.8.0 h1:swm0rlPCmdWn9mESxKOjWk8hXSqoxOp+ZlfuyaAdFlQ= +github.com/deckarep/golang-set/v2 v2.8.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw= @@ -21,6 +23,8 @@ github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9g github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k= github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw= github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ= +github.com/go-jose/go-jose/v3 v3.0.5 h1:BLLJWbC4nMZOfuPVxoZIxeYsn6Nl2r1fITaJ78UQlVQ= +github.com/go-jose/go-jose/v3 v3.0.5/go.mod h1:5b+7YgP7ZICgJDBdfjZaIt+H/9L9T/YQrVfLAMboGkQ= github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= @@ -29,12 +33,15 @@ github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJn github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= github.com/go-playground/validator/v10 v10.30.1 h1:f3zDSN/zOma+w6+1Wswgd9fLkdwy06ntQJp0BBvFG0w= github.com/go-playground/validator/v10 v10.30.1/go.mod h1:oSuBIQzuJxL//3MelwSLD5hc2Tu889bF0Idm9Dg26cM= +github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw= +github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4= github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4= github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM= github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA= github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY= github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= @@ -65,6 +72,8 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4= github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= +github.com/playwright-community/playwright-go v0.6000.0 h1:R7sENcRI6n0Zd5ZoW8EKdVF1ZVJgvTubfJeqKHNGvsw= +github.com/playwright-community/playwright-go v0.6000.0/go.mod h1:z/YpFVdU4LAi+0f9VPOCkGvmdH6dCrtza9nxnXFXgiE= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8= @@ -79,6 +88,7 @@ github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSS github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= @@ -89,21 +99,59 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY= github.com/ugorji/go/codec v1.3.1/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE= go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= golang.org/x/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI= golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE= golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= +golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/eai_agentplatform/backend-go/internal/ai/agent.go b/eai_agentplatform/backend-go/internal/ai/agent.go new file mode 100644 index 0000000..8ac61d0 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/ai/agent.go @@ -0,0 +1,438 @@ +package ai + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + "os" + "regexp" + "strings" + "time" + + "eai_agentplatform/backend/internal/config" +) + +// debugWriter 默认丢弃；当 AI_AGENT_DEBUG=1 时输出到 stdout，便于临时诊断多轮工具调用。 +var debugWriter io.Writer = io.Discard + +func init() { + if v, ok := os.LookupEnv("AI_AGENT_DEBUG"); ok && v != "" && v != "0" { + debugWriter = os.Stdout + } +} + +// Tool 一个可被 LLM 调用的工具。 +type Tool interface { + // Schema 返回 OpenAI 兼容的 function schema，用于随请求提交给 LLM。 + Schema() ToolSchema + // Execute 执行工具，args 为模型传入的原始 JSON 参数，返回给模型的纯文本结果。 + Execute(ctx context.Context, args json.RawMessage) (string, error) +} + +// Agent 带工具执行能力的对话代理。 +// +// Agent 采用 OpenAI 兼容的 tool_calls 环形调用： +// 1. 携带 tools 调用 LLM +// 2. 若模型返回 tool_calls，逐一执行并把结果以 role=tool 消息回填 +// 3. 再次调用 LLM，直到模型返回纯文本（无新 tool_calls） +// +// 相比裸 Client，Agent 让 LLM 能按需自主调用搜索等工具。 +type Agent struct { + client *Client + tools map[string]Tool + toolSchemas []ToolSchema + maxRounds int +} + +// NewAgent 基于指定 AI 路由创建带工具能力的 Agent。 +func NewAgent(route *config.RouteConfig) *Agent { + return &Agent{ + client: NewClient(route), + tools: make(map[string]Tool), + maxRounds: 8, + } +} + +// RegisterTool 注册一个可供 LLM 调用的工具。 +func (a *Agent) RegisterTool(t Tool) { + a.tools[t.Schema().Function.Name] = t + a.toolSchemas = append(a.toolSchemas, t.Schema()) +} + +// SetMaxRounds 调整最大工具调用轮数，避免死循环。 +func (a *Agent) SetMaxRounds(n int) { + if n > 0 { + a.maxRounds = n + } +} + +// Run 执行一轮带工具的多轮对话，返回最终文本。 +// +// messages 会被克隆后追加历史，不作为参数直接变更，避免污染调用方。 +func (a *Agent) Run(ctx context.Context, messages []Message) (string, error) { + content, _, _, err := a.RunWithUsage(ctx, messages) + return content, err +} + +// RunWithUsage 与 Run 相同，额外累计多轮 token 消耗，便于审计计费。 +// +// 返回最终文本、累计 usage 与最终模型信息。usage 为多轮 tool_calls 的各次 +// PromptTokens / CompletionTokens 累加（TotalTokens 仅为参考，不累加）。 +func (a *Agent) RunWithUsage(ctx context.Context, messages []Message) (string, ChatResult, *config.RouteConfig, error) { + // 复制消息历史，防止调用方切片被并发修改 + var history []Message + history = append(history, messages...) + + var usage ChatResult + var toolRounds int // 已执行的工具调用轮数，用于打断 tool_calls 轮转过量/死循环 + for round := 0; round < a.maxRounds; round++ { + // 轮次间检查上层上下文（如编排 150s 兜底）是否已取消： + // 若已取消，立即退出，避免已发起的慢调用/死循环续命拖死 wg.Wait()。 + if err := ctx.Err(); err != nil { + return "", usage, a.client.Route(), fmt.Errorf("上下文已取消，终止工具调用: %w", err) + } + out, err := a.roundWithEmptyRecovery(ctx, history) + if err != nil { + return "", usage, a.client.Route(), err + } + // 累计 token 消耗（多轮加总） + usage.Usage.PromptTokens += out.Usage.PromptTokens + usage.Usage.CompletionTokens += out.Usage.CompletionTokens + if out.Model != "" { + usage.Model = out.Model + } + // 记录模型回复 + history = append(history, Message{Role: "assistant", Content: out.Content, ToolCalls: out.ToolCalls}) + + // 无工具调用 → 返回最终文本 + if len(out.ToolCalls) == 0 { + // 部分 provider（如 LMUAI/DeepSeek 兼容 Anthropic）会把工具调用意图以 + //「文本格式」输出（<｜｜ calls> 这类 Anthropic tool_use 转义标签），而不是 + // OpenAI 规范的 tool_calls JSON。此时 ToolCalls 为空、Content 便是那串原始标签， + // 若直接返回会把 <｜｜ invoke name="web_search"> 之类的噪声原文展示给用户。 + // 识别到这类「工具回显」后，不保留原样：先尝试无工具纯文本收敛；若模型惯性 + // 仍输出标签（历史里已存在 assistant 工具标签消息，易诱导），则剥离标签， + // 只把其中可读的自然语言/兜底文案交给用户。 + if out.Content != "" && looksLikeToolEcho(out.Content) && len(a.toolSchemas) > 0 { + // 先剥离工具标签提取正文：若模型在本轮已写出正文（只是混入了工具回显标签）， + // 直接返回正文，避免接下来的无谓收敛覆盖掉真实产出（worker 尤其如此）。 + if s := stripToolEcho(out.Content); s != "" { + return s, usage, a.client.Route(), nil + } + // 纯工具回显、无任何正文：才做一次无工具纯文本收敛；若收敛仍剥空，返回诚实兜底。 + if c, cerr := a.client.Generate(ctx, history); cerr == nil { + c = strings.TrimSpace(c) + if looksLikeToolEcho(c) { + c = stripToolEcho(c) + } + if c != "" { + return c, usage, a.client.Route(), nil + } + } + // 模型在「文本回显工具调用」上打转且未产出任何结论文本：低风险下不能凭空生成 + // 数据（那会违背诚实性），因此返回明确的兜底说明，而不是把原始工具标签抛给用户， + // 也避免伪装成成功结果。 + return toolEchoFallback, usage, a.client.Route(), nil + } + if out.Content == "" { + return "", usage, a.client.Route(), fmt.Errorf("模型最终回复为空") + } + return out.Content, usage, a.client.Route(), nil + } + + // 工具死循环收敛：阻止模型反复发工具调用却迟迟不写结论文本。 + // 即使每轮也带部分 content（如大纲标题），超过阈值轮仍未产出最终正文，即视为轮转过量， + // 先一步中断并走末尾的无工具纯文本收敛，避免在 240s 预算内空耗搜索轮次。 + toolRounds++ + if toolRounds >= 5 { + break + } + + // 依次执行工具并回填结果 + for _, tc := range out.ToolCalls { + tool, ok := a.tools[tc.Function.Name] + if !ok { + return "", usage, a.client.Route(), fmt.Errorf("模型请求了未注册的工具: %s", tc.Function.Name) + } + argsBytes := normalizeToolArguments(tc.Function.Arguments) + fmt.Fprintf(debugWriter, "[agent][diag] 执行工具 %s args=%s\n", tc.Function.Name, truncate(string(argsBytes), 160)) + result, execErr := tool.Execute(ctx, argsBytes) + fmt.Fprintf(debugWriter, "[agent][diag] -> err=%v result_head=%q\n", execErr, truncate(result, 120)) + if execErr != nil { + result = fmt.Sprintf("工具执行失败: %v", execErr) + } + history = append(history, Message{ + Role: "tool", + ToolCallID: tc.ID, + Content: result, + }) + } + } + // 工具死循环/超轮收敛：用无工具纯文本基于「已完成工具结果」重生成一次，作为最终结论， + // 避免 worker 或单问联网因模型反复 tool_calls 而不产文本。受 ctx 约束。 + // 与上方的工具回显收敛同对待：模型惯性可能使收敛结果仍是 <｜｜ …> 标签，需剥除再返回。 + if len(a.toolSchemas) > 0 { + if content, cerr := a.client.Generate(ctx, history); cerr == nil { + content = strings.TrimSpace(content) + if looksLikeToolEcho(content) { + content = stripToolEcho(content) + } + if content != "" { + return content, usage, a.client.Route(), nil + } + // Generate 成功却只剩工具标签/空白：不凭空编造，返回诚实兜底而非升级 error。 + return toolEchoFallback, usage, a.client.Route(), nil + } + } + return "", usage, a.client.Route(), fmt.Errorf("工具调用超过最大轮数 %d，可能死循环", a.maxRounds) +} + +// looksLikeToolEcho 判断文本是否「工具调用回显」——即模型把工具调用意图以 +// 文本/标签形式输出（Anthropic style tool_use 或其转义），而非规范 tool_calls。 +// 命中后调用方应避免把这串原始标签当最终答案返回。 +// +// 判据保持保守：必须命中强特征才判定，避免误伤正常含这些词组的正文。 +// - 「<｜」（DeepSeek 对 Anthropic tool_use 块的非标准 Unicode 转义）几乎不会 +// 出现在正常中文自然语言里，出现即基本确定为工具回显； +// - invoke name="..."（Anthropic 工具调用块的标准文本形式）。 +func looksLikeToolEcho(s string) bool { + if strings.Contains(s, "｜") { + return true + } + if strings.Contains(s, "invoke name=") { + return true + } + return false +} + +// 工具回显剥离用的正则： +// - line：任何以 <｜｜>（转义形式，含开闭标签 <｜｜/>、<｜｜ invoke/…）开头的整行， +// 逐行删除（工具标签通常独占一行，不留可见噪声）； +// - invokePara：标准 Anthropic 文本形式 …、… 行； +// - blank：折叠连续空行。 +var ( + reToolEchoLine = regexp.MustCompile(`(?m)^\s*]*>.*$`) + reToolInvoke = regexp.MustCompile(`(?m)^\s*…（DeepSeek 对 Anthropic 文本 +// tool_use 的非标准转义）；同时也兼容标准 …。 +// - param：块内的 <｜｜ parameter name="K"…>V。 +var ( + reToolInvokeEcho = regexp.MustCompile(`(?s)<[｜|][｜|]?\s*invoke\b.*?`) + reToolParamEcho = regexp.MustCompile(`(?s)<[｜|][｜|]?\s*parameter\s+name="([^"]+)"[^>]*>(.*?)`) + reToolNameInEcho = regexp.MustCompile(`name="([^"]+)"`) +) + +// parseToolEcho 把 Anthropic 文本格式的工具调用块（<｜｜ invoke name="…">…） +// 解析成规范 tool_calls（真正触发工具执行），并从 content 中移除这些块只留自然语言。 +// 仅当被调用的工具名存在于 allowed（已注册工具集）时才转为 tool_call；未注册的保留原文， +// 避免执行到未知工具而报错。 +func parseToolEcho(content string, allowed map[string]bool) (string, []ToolCall) { + var calls []ToolCall + clean := reToolInvokeEcho.ReplaceAllStringFunc(content, func(block string) string { + m := reToolNameInEcho.FindStringSubmatch(block) + if len(m) < 2 { + return block // 解析不出 name，保留 + } + if !allowed[strings.TrimSpace(m[1])] { + return block // 未注册工具，保留原文，不进执行环 + } + args := map[string]string{} + for _, pm := range reToolParamEcho.FindAllStringSubmatch(block, -1) { + args[strings.TrimSpace(pm[1])] = pm[2] + } + argsJSON, err := json.Marshal(args) + if err != nil { + return block + } + calls = append(calls, ToolCall{ + ID: fmt.Sprintf("call_echo_%d", len(calls)), + Type: "function", + Function: ToolFuncCall{ + Name: strings.TrimSpace(m[1]), + Arguments: argsJSON, + }, + }) + return "" // 删除该工具块，只留纯文本 + }) + // 收尾：移除残余的工具包裹标签（如 <｜｜ calls>…）及其它行级标签， + // 只留下自然语言正文。 + clean = stripToolEcho(clean) + return clean, calls +} + +// stripToolEcho 从文本中剥除 Anthropic 风格的工具调用标签（DeepSeek 转义 <｜｜> 或 +// 标准 /），只保留自然语言正文。全部为标签时返回空串。 +func stripToolEcho(s string) string { + s = reToolEchoLine.ReplaceAllString(s, "") + s = reToolInvoke.ReplaceAllString(s, "") + s = reToolPara.ReplaceAllString(s, "") + s = reToolBlank.ReplaceAllString(s, "\n\n") + return strings.TrimSpace(s) +} + +// normalizeToolArguments 处理 arguments 的两种形态： +// - 标准：{"query": "..."}，直接返回； +// - 部分 provider 把 arguments 作为 JSON 字符串返回，即 "{\"query\":\"...\"}"， +// 此时先 Unmarshal 成 raw 字节再加解析。存在 key 形如 query 的直接对象即可。 +func normalizeToolArguments(raw json.RawMessage) json.RawMessage { + if len(raw) == 0 { + return raw + } + trimmed := bytes.TrimSpace(raw) + // 若非字符串字面量（不以 " 开头），视为已是对象 + if len(trimmed) == 0 || trimmed[0] != '"' { + return trimmed + } + // arguments 是 JSON 字符串 → 解开一层 + var s string + if err := json.Unmarshal(trimmed, &s); err == nil { + return json.RawMessage(s) + } + return trimmed +} + +// roundWithEmptyRecovery 发起一轮带工具的模型调用，并对「空响应」做多策略恢复： +// +// 1. 策略一：原始带工具调用。只要模型返回内容或工具调用即为合法响应，直接返回； +// 2. 策略二：仍为空则带工具重试一次（极轻退避，吸收偶发空回复）； +// 3. 策略三：仍为空则降级为「不带工具」的纯文本重试一次，兼容「带工具即空、纯文本正常」 +// 的路由（如部分模型对 web_search tools 支持性差）。这是保底，保证调用方拿到非空文本。 +// +// 所有策略均受 ctx 约束，ctx 取消立即返回，不阻塞上层（编排 150s 兜底）。 +func (a *Agent) roundWithEmptyRecovery(ctx context.Context, history []Message) (*ChatResult, error) { + // 策略一：原始带工具调用 + out, err := a.client.generateWithTools(ctx, history, a.toolSchemas) + if err != nil { + return nil, err + } + if out.Content != "" || len(out.ToolCalls) > 0 { + return out, nil + } + lastErr := fmt.Errorf("模型返回空响应") + + // 策略二：带工具重试一次 + if len(a.toolSchemas) > 0 { + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-time.After(300 * time.Millisecond): + } + if out2, err2 := a.client.generateWithTools(ctx, history, a.toolSchemas); err2 == nil && (out2.Content != "" || len(out2.ToolCalls) > 0) { + return out2, nil + } else if err2 != nil { + lastErr = err2 + } + } + + // 策略三：降级为不带工具的纯文本重试 + if len(a.toolSchemas) > 0 { + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-time.After(300 * time.Millisecond): + } + if content, err3 := a.client.Generate(ctx, history); err3 == nil && strings.TrimSpace(content) != "" { + return &ChatResult{Content: content}, nil + } else if err3 != nil { + lastErr = err3 + } + } + + return nil, fmt.Errorf("模型最终回复为空（带工具重试与无工具降级均未产出内容）: %v", lastErr) +} + +// generateWithTools 单轮调用：携带 tools 并解析 tool_calls。 +// ctx 贯穿到 HTTP 请求，使 Agent 的多轮 tool_calls 都能被上层超时（如编排 150s 兜底）真正取消。 +func (c *Client) generateWithTools(ctx context.Context, messages []Message, toolSchemas []ToolSchema) (*ChatResult, error) { + reqBody := map[string]any{ + "model": c.model, + "messages": messages, + "stream": false, + "temperature": c.temperature, + "max_tokens": c.maxTokens, + } + if len(toolSchemas) > 0 { + reqBody["tools"] = toolSchemas + } + + resp, err := c.post(ctx, "/chat/completions", reqBody) + if err != nil { + return nil, fmt.Errorf("LLM 服务不可达: %w", err) + } + defer resp.Body.Close() + + body, err := io.ReadAll(resp.Body) + if err != nil { + return nil, fmt.Errorf("读取 LLM 响应失败: %w", err) + } + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("LLM 返回 %d: %s", resp.StatusCode, truncate(string(body), 200)) + } + + var raw struct { + Model string `json:"model"` + Choices []struct { + Message struct { + Content string `json:"content"` + ToolCalls []ToolCall `json:"tool_calls"` + } `json:"message"` + FinishReason string `json:"finish_reason"` + } `json:"choices"` + Usage *struct { + PromptTokens int `json:"prompt_tokens"` + CompletionTokens int `json:"completion_tokens"` + TotalTokens int `json:"total_tokens"` + } `json:"usage"` + } + if err := json.Unmarshal(body, &raw); err != nil { + return nil, fmt.Errorf("LLM 响应解析失败: %w", err) + } + if len(raw.Choices) == 0 { + return nil, fmt.Errorf("LLM 未返回任何 choice") + } + + msg := raw.Choices[0].Message + content := msg.Content + toolCalls := msg.ToolCalls + + // 兜底解析「文本格式工具调用」：LMUAI/DeepSeek 等兼容 Anthropic 的 provider 常把工具 + // 调用以 <｜｜ invoke name="…">… 文本而非规范 tool_calls JSON 返回。 + // 此时 ToolCalls 为空、Content 是原始标签，若直接返回就把噪声抛给用户、搜索也未真正执行。 + // 这里把文本块解析回规范 tool_calls（触发 Agent 真正运行 web_search），并清理出纯文本。 + if len(toolCalls) == 0 && content != "" && looksLikeToolEcho(content) { + allowed := make(map[string]bool, len(toolSchemas)) + for _, ts := range toolSchemas { + allowed[ts.Function.Name] = true + } + clean, parsed := parseToolEcho(content, allowed) + if len(parsed) > 0 { + content = clean + toolCalls = parsed + } + } + + result := &ChatResult{ + Content: content, + Model: raw.Model, + FinishReason: raw.Choices[0].FinishReason, + ToolCalls: toolCalls, + } + if raw.Usage != nil { + result.Usage.PromptTokens = raw.Usage.PromptTokens + result.Usage.CompletionTokens = raw.Usage.CompletionTokens + result.Usage.TotalTokens = raw.Usage.TotalTokens + } + return result, nil +} diff --git a/eai_agentplatform/backend-go/internal/ai/agent_test.go b/eai_agentplatform/backend-go/internal/ai/agent_test.go new file mode 100644 index 0000000..c52eb0f --- /dev/null +++ b/eai_agentplatform/backend-go/internal/ai/agent_test.go @@ -0,0 +1,37 @@ +package ai + +import ( + "encoding/json" + "testing" +) + +func TestNormalizeToolArguments(t *testing.T) { + cases := []struct { + name string + in string + want string + }{ + {"标准对象", `{"query":"外骨骼"}`, `{"query":"外骨骼"}`}, + {"JSON字符串", `"{\"query\":\"外骨骼\"}"`, `{"query":"外骨骼"}`}, + {"空", ``, ``}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + got := string(normalizeToolArguments(json.RawMessage(c.in))) + if got != c.want { + t.Errorf("normalizeToolArguments(%q) = %q, want %q", c.in, got, c.want) + } + }) + } +} + +func TestWebSearchToolSchema(t *testing.T) { + tool := NewWebSearchTool(nil) + s := tool.Schema() + if s.Type != "function" || s.Function.Name != "web_search" { + t.Fatalf("unexpected schema: type=%s name=%s", s.Type, s.Function.Name) + } + if _, err := json.Marshal(s); err != nil { + t.Fatalf("schema not marshallable: %v", err) + } +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/ai/agent_tool_echo_test.go b/eai_agentplatform/backend-go/internal/ai/agent_tool_echo_test.go new file mode 100644 index 0000000..dfe12e8 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/ai/agent_tool_echo_test.go @@ -0,0 +1,134 @@ +package ai + +import ( + "encoding/json" + "strings" + "testing" +) + +// TestLooksLikeToolEcho 验证工具回显指纹的判定：命中（Anthropic 转义标签 / invoke 文本） +// 应返回 true，正常自然语言正文不应误伤。 +func TestLooksLikeToolEcho(t *testing.T) { + positive := []string{ + // LMUAI/DeepSeek 实测泄漏的原始转义 + "<｜｜DSML｜｜ calls>\n<｜｜DSML｜｜ invoke name=\"web_search\">\n<｜｜DSML｜｜ parameter name=\"query\"", + "<｜｜ calls>\n<｜｜ invoke name=\"web_search\">", + // 标准 Anthropic 文本工具调用 + ` +汇率 +`, + } + for _, s := range positive { + if !looksLikeToolEcho(s) { + t.Errorf("应判定为工具回显，实际 false: %q", truncateGo(s, 60)) + } + } + + negative := []string{ + "汇率是重要的经济指标。", + "关于人民币对美元汇率，请参考央行官网。", + `{"query":"web_search 调用测试"}`, + } + for _, s := range negative { + if looksLikeToolEcho(s) { + t.Errorf("正常文本被误判为工具回显: %q", truncateGo(s, 60)) + } + } +} + +// TestStripToolEcho 验证把工具回显标签剥除后只留自然语言，纯标签应清空。 +func TestStripToolEcho(t *testing.T) { + cases := []struct { + name string + in string + want string + }{ + { + name: "整块工具回显被剥离", + in: "<｜｜ calls>\n<｜｜ invoke name=\"web_search\">\n<｜｜ parameter name=\"query\" string=\"true\">汇率\n<｜｜ /invoke>\n<｜｜ /calls>", + want: "", + }, + { + name: "块前自然语言保留", + in: "我需要先查一下汇率\n<｜｜ calls>\n<｜｜ invoke name=\"web_search\">", + want: "我需要先查一下汇率", + }, + { + name: "块后自然语言保留", + in: "<｜｜ calls>\n<｜｜ invoke name=\"web_search\">\n<｜｜ parameter name=\"query\" string=\"true\">汇率\n<｜｜ /invoke>\n<｜｜ /calls>\n这是根据检索整理的汇率结论。", + want: "这是根据检索整理的汇率结论。", + }, + { + name: "残留闭合标签被清空", + in: "\n\n\n\n", + want: "", + }, + { + name: "正常文本不动", + in: "人民币对美元汇率请参考央行官网。", + want: "人民币对美元汇率请参考央行官网。", + }, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + if got := stripToolEcho(c.in); got != c.want { + t.Errorf("stripToolEcho 不符：\n got=%q\nwant=%q", got, c.want) + } + }) + } +} + +// TestParseToolEcho 验证把 Anthropic 文本格式工具调用解析成规范 tool_calls， +// 且清理出纯文本、未注册工具不被误转换。 +func TestParseToolEcho(t *testing.T) { + allowed := map[string]bool{"web_search": true} + // 真实场景输出样式 + in := `我需要先确认最新汇率 +<｜｜ calls> +<｜｜ invoke name="web_search"> +<｜｜ parameter name="query" string="true">"9月25日" "人民币" 中间价 2026 + +<｜｜ /calls>` + clean, calls := parseToolEcho(in, allowed) + if len(calls) != 1 { + t.Fatalf("应解析出 1 个 tool_call，实得 %d", len(calls)) + } + if calls[0].Function.Name != "web_search" { + t.Errorf("工具名应为 web_search，实得 %s", calls[0].Function.Name) + } + var args struct { + Query string `json:"query"` + } + if err := json.Unmarshal(calls[0].Function.Arguments, &args); err != nil { + t.Fatalf("arguments 解析失败: %v", err) + } + if !strings.Contains(args.Query, "人民币") { + t.Errorf("query 应含『人民币』，实得 %q", args.Query) + } + if strings.Contains(clean, "｜") { + t.Errorf("clean 不应残留工具标签: %q", clean) + } + if !strings.Contains(clean, "最新汇率") { + t.Errorf("clean 应保留块前自然语言: %q", clean) + } + + // 未注册工具：不产生 tool_call，且其标签块应被剥离（不得把噪声暴露给用户）。 + unknown := `<｜｜ invoke name="browser_open"> +<｜｜ parameter name="url">https://x.com +` + clean2, calls2 := parseToolEcho(unknown, allowed) + if len(calls2) != 0 { + t.Errorf("未注册工具不应转 tool_call，实得 %d", len(calls2)) + } + if strings.Contains(clean2, "｜") || strings.Contains(clean2, "invoke") { + t.Errorf("未注册工具块不应残留标签噪声: %q", clean2) + } +} + +func truncateGo(s string, n int) string { + r := []rune(s) + if len(r) <= n { + return s + } + return string(r[:n]) + "…" +} diff --git a/eai_agentplatform/backend-go/internal/ai/credits.go b/eai_agentplatform/backend-go/internal/ai/credits.go index a5ab6f7..19dfb7a 100644 --- a/eai_agentplatform/backend-go/internal/ai/credits.go +++ b/eai_agentplatform/backend-go/internal/ai/credits.go @@ -15,29 +15,29 @@ import ( // AI 用量类型常量 const ( - UsageKindAIChat = "ai_chat" // PathCoach 对话（每轮扣 1 点） - UsageKindTextGen = "text_gen" // 快捷动作（情景演练/查佣金/产品对比，扣 1 点） - UsageKindImageGen = "image_gen" // 文生图（按次扣点） - UsageKindEmbed = "embed" // 知识检索内部 embedding（不扣点，仅审计） - UsageKindEssayGrade = "essay_grade" // 简答题 LLM 评分（系统自动，不扣点，仅审计） + UsageKindAIChat = "ai_chat" // PathCoach 对话（每轮扣 1 点） + UsageKindTextGen = "text_gen" // 快捷动作（情景演练/查佣金/产品对比，扣 1 点） + UsageKindImageGen = "image_gen" // 文生图（按次扣点） + UsageKindEmbed = "embed" // 知识检索内部 embedding（不扣点，仅审计） + UsageKindEssayGrade = "essay_grade" // 简答题 LLM 评分（系统自动，不扣点，仅审计） - // 以下 5 类为工具型 AI 调用，当前只审计、不扣点： - // 它们不在 UsageKindCredits 表里，ComputeCredits 查不到即返回 0。 - // 将来若要计费，只需把它们加进 UsageKindCredits，扣点逻辑自动生效。 - UsageKindBatchExtract = "batch_extract" - UsageKindContractReview = "contract_review" - UsageKindAudioTranscribe = "audio_transcribe" - UsageKindCopyProofread = "copy_proofread" - UsageKindDocumentTranslate = "document_translate" + // 以下 5 类为工具型 AI 调用，当前只审计、不扣点： + // 它们不在 UsageKindCredits 表里，ComputeCredits 查不到即返回 0。 + // 将来若要计费，只需把它们加进 UsageKindCredits，扣点逻辑自动生效。 + UsageKindBatchExtract = "batch_extract" + UsageKindContractReview = "contract_review" + UsageKindAudioTranscribe = "audio_transcribe" + UsageKindCopyProofread = "copy_proofread" + UsageKindDocumentTranslate = "document_translate" ) // UsageKindCredits 各用量类型扣点成本 var UsageKindCredits = map[string]int{ - UsageKindAIChat: 1, - UsageKindTextGen: 1, - UsageKindImageGen: 1, - UsageKindEmbed: 0, - UsageKindEssayGrade: 0, + UsageKindAIChat: 1, + UsageKindTextGen: 1, + UsageKindImageGen: 1, + UsageKindEmbed: 0, + UsageKindEssayGrade: 0, } // ComputeCredits 扣点决策：仅「成功」才扣点；失败不扣。 @@ -45,13 +45,13 @@ func ComputeCredits(usageKind string, success bool) int { if !success { return 0 } - return UsageKindCredits[usageKind] + return UsageKindCredits[usageKind] } // LogEntry 一次 AI 调用的审计入参 type LogEntry struct { - UserID uint - UsageKind string + UserID uint + UsageKind string // SpecialistKey 本次调用以哪个专员的身份进行；空 = 通用助手 SpecialistKey string Provider string @@ -66,14 +66,19 @@ type LogEntry struct { // LogCall 写 ai_call_log；成功且需扣点时从用户余额扣点。审计写入失败不阻断主流程。 func LogCall(e LogEntry) { - credits := ComputeCredits(e.UsageKind, e.Success) + // 数据库尚未初始化（如测试、独立 worker、无 DB 的嵌入场景）时直接跳过审计， + // 绝不因写入 ai_call_log 的指针解引用而 panic 拖垮 AI 主链路。 + if store.DB == nil { + return + } + credits := ComputeCredits(e.UsageKind, e.Success) status := "success" if !e.Success { status = "failed" } rec := model.AiCallLog{ UserID: e.UserID, - UsageKind: e.UsageKind, + UsageKind: e.UsageKind, SpecialistKey: e.SpecialistKey, Provider: e.Provider, AIRouteID: e.AIRouteID, diff --git a/eai_agentplatform/backend-go/internal/ai/llm.go b/eai_agentplatform/backend-go/internal/ai/llm.go index 565442f..578e6e6 100644 --- a/eai_agentplatform/backend-go/internal/ai/llm.go +++ b/eai_agentplatform/backend-go/internal/ai/llm.go @@ -3,7 +3,9 @@ package ai import ( "bufio" "bytes" + "context" "encoding/json" + "errors" "fmt" "io" "net/http" @@ -18,9 +20,37 @@ import ( // ────────────────────────────────────────────── // Message OpenAI 兼容消息 +// Role: system / user / assistant / tool。 +// 普通对话仅需 Role+Content；工具调用场景可带 ToolCalls（assistant 发起） +// 与 ToolCallID（回填 tool 结果时使用）。 type Message struct { - Role string `json:"role"` - Content string `json:"content"` + Role string `json:"role"` + Content string `json:"content"` + ToolCalls []ToolCall `json:"tool_calls,omitempty"` + ToolCallID string `json:"tool_call_id,omitempty"` +} + +// ToolCall 模型发起的工具调用。 +type ToolCall struct { + ID string `json:"id"` + Type string `json:"type,omitempty"` + Function ToolFuncCall `json:"function"` +} + +// ToolFuncCall 工具调用的函数名与参数（json.RawMessage 以保持参数原文）。 +type ToolFuncCall struct { + Name string `json:"name"` + Arguments json.RawMessage `json:"arguments"` +} + +// ToolSchema OpenAI 兼容 function tool 定义，随请求一并提交给 LLM。 +type ToolSchema struct { + Type string `json:"type"` // "function" + Function struct { + Name string `json:"name"` + Description string `json:"description"` + Parameters interface{} `json:"parameters"` + } `json:"function"` } // ChatResult 非流式调用结果 @@ -29,6 +59,7 @@ type ChatResult struct { Model string Provider string FinishReason string + ToolCalls []ToolCall Usage struct { PromptTokens int `json:"prompt_tokens"` CompletionTokens int `json:"completion_tokens"` @@ -42,6 +73,7 @@ type ChatResult struct { // Client 低层 HTTP 客户端（基于 RouteConfig） type Client struct { + route *config.RouteConfig baseURL string apiKey string model string @@ -50,6 +82,11 @@ type Client struct { hc *http.Client } +// Route 返回创建本客户端的路由（可能为 nil）。 +func (c *Client) Route() *config.RouteConfig { + return c.route +} + // defaultHTTPTimeout 默认 HTTP 整体超时；路由可用 timeout_seconds 单独覆盖 const defaultHTTPTimeout = 60 * time.Second @@ -60,6 +97,7 @@ func NewClient(aiRoute *config.RouteConfig) *Client { timeout = time.Duration(aiRoute.TimeoutSeconds) * time.Second } return &Client{ + route: aiRoute, baseURL: strings.TrimRight(aiRoute.BaseURL, "/"), apiKey: aiRoute.APIKey, model: aiRoute.Model, @@ -81,12 +119,14 @@ func (c *Client) headers() map[string]string { return h } -func (c *Client) post(path string, body any) (*http.Response, error) { +// post 发起 OpenAI 兼容请求。ctx 可被上层（如编排 150s 兜底）用 WithTimeout 取消， +// 使 LLM 调用真正中断，而不是只能等死的 http.Client.Timeout。 +func (c *Client) post(ctx context.Context, path string, body any) (*http.Response, error) { j, err := json.Marshal(body) if err != nil { return nil, err } - req, err := http.NewRequest(http.MethodPost, c.url(path), bytes.NewReader(j)) + req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.url(path), bytes.NewReader(j)) if err != nil { return nil, err } @@ -102,11 +142,81 @@ func (c *Client) post(path string, body any) (*http.Response, error) { // ────────────────────────────────────────────── // 非流式调用 +// EmptyCompletionError 上游回了 200，但正文是空的。 +// +// 为什么要单独成类型：**「空正文」有好几种成因，处置完全不同，而 finish_reason +// 是唯一能把它们分开的东西**。 +// +// 最要命的一种是推理模型把 max_tokens 全花在思考上 —— 此时响应里**根本没有 +// content 字段**（不是空串，是不存在），finish_reason=length。实测某对话路由 +// （max_tokens=4096）对 2500 字的密集中文输入，reasoning_content 写了 7187 字、 +// 正文 0 字；把预算提到 8192 才有正文（2470 字，reasoning 9590 字）。 +// 这种情况报「空正文」会把人引去查模型名和密钥，而真正该做的是调大预算； +// 报「思考吃光了预算」才能一眼看到病根。 +// +// 只由 GenerateFull 返回（Generate 只回字符串，拿不到 finish_reason）。 +type EmptyCompletionError struct { + FinishReason string + CompletionTokens int +} + +// Error 保留「LLM 返回空正文」前缀：这是这条例外此前的文案，外部可能有按 +// 子串匹配的地方，补上诊断信息不该顺手改掉已经存在的说法。 +func (e *EmptyCompletionError) Error() string { + if e.FinishReason == "" { + return "LLM 返回空正文（响应里没有 finish_reason）" + } + if strings.EqualFold(e.FinishReason, "length") { + return fmt.Sprintf( + "LLM 返回空正文（finish_reason=length，completion_tokens=%d）：预算被思考用光了，"+ + "推理模型写正文之前就把 max_tokens 花完了，调大该路由的 max_tokens 才可能写出正文", + e.CompletionTokens) + } + return fmt.Sprintf("LLM 返回空正文（finish_reason=%q，completion_tokens=%d）", e.FinishReason, e.CompletionTokens) +} + +// TransientUpstreamError 上游这一次没成，但**同样的请求重发有机会成**。 +// +// 与 EmptyCompletionError 的区别就是「要不要重试」这一件事，而这件事必须由类型 +// 决定、不能由文案猜： +// +// - EmptyCompletionError 是模型确实写不出正文（预算被思考吃光、模型拒答）， +// 重发一百次都是同一个结果，重试只是再花一次钱； +// - 本类型是**协议或链路层面的抖动** —— 网关回了 200 却给一个没有 choices 的 +// 报文、限流、上游 5xx、连接被掐断。这些重发就有机会成，不重发则整步白跑。 +// +// 实测背景：某技能的第 3 步要连打 11 次模型（逐字稿按 1200 字分块），第 4 次 +// 撞上的就是这个 —— 网关 HTTP 200，报文里却没有 choices，整步就此失败。 +type TransientUpstreamError struct { + // StatusCode 0 表示压根没拿到状态码（连接就没建起来）。 + // 目前只用来说明情况，重试决策在构造处就定了。 + StatusCode int + // Message 是**原样的**错误文案。故意不做二次拼装：这些文案是既有说法， + // 记录日志、前端提示都可能在看，加个类型标记没理由顺手改动它们。 + Message string + // Err 保留底层错误，让 errors.Is/As 还能穿透下去 + // （例如上层要判 context.DeadlineExceeded）。此前靠 %w 提供的这条链不能断。 + Err error +} + +func (e *TransientUpstreamError) Error() string { return e.Message } + +func (e *TransientUpstreamError) Unwrap() error { return e.Err } + +// IsTransient 判断 err 值不值得重发。 +// +// 走 errors.As，所以**经过 %w 包装后依然认得出** —— 回退链会给错误套上 +// 「所有路由均失败: [路由 id] …」两层包装，调用方拿到的是最外层那个。 +func IsTransient(err error) bool { + var transient *TransientUpstreamError + return errors.As(err, &transient) +} + // ────────────────────────────────────────────── // Generate 非流式对话，返回完整正文 -func (c *Client) Generate(messages []Message) (string, error) { - resp, err := c.post("/chat/completions", map[string]any{ +func (c *Client) Generate(ctx context.Context, messages []Message) (string, error) { + resp, err := c.post(ctx, "/chat/completions", map[string]any{ "model": c.model, "messages": messages, "stream": false, @@ -143,8 +253,8 @@ func (c *Client) Generate(messages []Message) (string, error) { } // GenerateFull 非流式调用，返回完整 ChatResult（含 usage） -func (c *Client) GenerateFull(messages []Message) (*ChatResult, error) { - resp, err := c.post("/chat/completions", map[string]any{ +func (c *Client) GenerateFull(ctx context.Context, messages []Message) (*ChatResult, error) { + resp, err := c.post(ctx, "/chat/completions", map[string]any{ "model": c.model, "messages": messages, "stream": false, @@ -152,16 +262,30 @@ func (c *Client) GenerateFull(messages []Message) (*ChatResult, error) { "max_tokens": c.maxTokens, }) if err != nil { - return nil, fmt.Errorf("LLM 服务不可达: %w", err) + // 连接建不起来 / 被掐断 / 超时：重发有意义。 + return nil, &TransientUpstreamError{ + Message: fmt.Sprintf("LLM 服务不可达: %v", err), + Err: err, + } } defer resp.Body.Close() data, err := io.ReadAll(resp.Body) if err != nil { - return nil, fmt.Errorf("读取 LLM 响应失败: %w", err) + // 正文读到一半断了，同样属于这一趟的抖动。 + return nil, &TransientUpstreamError{ + Message: fmt.Sprintf("读取 LLM 响应失败: %v", err), + Err: err, + } } if resp.StatusCode != http.StatusOK { - return nil, fmt.Errorf("LLM 返回 %d: %s", resp.StatusCode, truncate(string(data), 200)) + msg := fmt.Sprintf("LLM 返回 %d: %s", resp.StatusCode, truncate(string(data), 200)) + // 限流和上游 5xx 是**这一趟**的问题，重发可能就过了； + // 4xx（模型名写错、密钥无效、参数非法）重发一百次也是同一个结果，不标可重试。 + if resp.StatusCode == http.StatusTooManyRequests || resp.StatusCode >= 500 { + return nil, &TransientUpstreamError{StatusCode: resp.StatusCode, Message: msg} + } + return nil, errors.New(msg) } var raw struct { @@ -179,10 +303,34 @@ func (c *Client) GenerateFull(messages []Message) (*ChatResult, error) { } `json:"usage"` } if err := json.Unmarshal(data, &raw); err != nil { - return nil, fmt.Errorf("LLM 响应解析失败: %w", err) + // 报文根本不是 JSON：与「没有 choices」同一种病 —— 网关塞了别的东西进来。 + return nil, &TransientUpstreamError{ + StatusCode: resp.StatusCode, + Message: fmt.Sprintf("LLM 响应解析失败: %v", err), + Err: err, + } } - if len(raw.Choices) == 0 || strings.TrimSpace(raw.Choices[0].Message.Content) == "" { - return nil, fmt.Errorf("LLM 返回空正文") + if len(raw.Choices) == 0 { + // 没有 choices 是**协议层面**的异常，跟「模型没写出正文」不是一回事： + // 网关回 200 却是别的报文形状（限流、上游报错包在 200 里等）都会落到这里。 + // 所以把原始报文带上 —— 只说一句「空正文」，拿到的人根本无从下手。 + // 与上面状态码分支一样截断，且保留「LLM 返回空正文」这个前缀。 + // + // 标成可重试：报文形状不对是**这一趟**的事，不是模型对这个输入的回答。 + return nil, &TransientUpstreamError{ + StatusCode: resp.StatusCode, + Message: fmt.Sprintf("LLM 返回空正文（响应里没有 choices）：%s", truncate(string(data), 300)), + } + } + if strings.TrimSpace(raw.Choices[0].Message.Content) == "" { + completionTokens := 0 + if raw.Usage != nil { + completionTokens = raw.Usage.CompletionTokens + } + return nil, &EmptyCompletionError{ + FinishReason: raw.Choices[0].FinishReason, + CompletionTokens: completionTokens, + } } result := &ChatResult{ @@ -203,8 +351,8 @@ func (c *Client) GenerateFull(messages []Message) (*ChatResult, error) { // ────────────────────────────────────────────── // GenerateStream SSE 流式调用，逐 chunk 回调 -func (c *Client) GenerateStream(messages []Message, onChunk func(string)) error { - resp, err := c.post("/chat/completions", map[string]any{ +func (c *Client) GenerateStream(ctx context.Context, messages []Message, onChunk func(string)) error { + resp, err := c.post(ctx, "/chat/completions", map[string]any{ "model": c.model, "messages": messages, "stream": true, @@ -283,8 +431,8 @@ func (c *Client) GenerateStream(messages []Message, onChunk func(string)) error // ────────────────────────────────────────────── // Embed 批量向量化 -func (c *Client) Embed(inputs []string) ([][]float64, error) { - resp, err := c.post("/embeddings", map[string]any{ +func (c *Client) Embed(ctx context.Context, inputs []string) ([][]float64, error) { + resp, err := c.post(ctx, "/embeddings", map[string]any{ "model": c.model, "input": inputs, }) if err != nil { @@ -335,8 +483,9 @@ func buildRouteChain(primary *config.RouteConfig) ([]*config.RouteConfig, error) return aiRouteChain, nil } -// GenerateWithFallback 依次尝试主路由 + 回退链，首个成功返回 -func GenerateWithFallback(primary *config.RouteConfig, messages []Message) (string, error) { +// GenerateWithFallback 依次尝试主路由 + 回退链，首个成功返回。 +// ctx 贯穿到各路由的 HTTP 请求，使上层超时（如编排 150s 兜底）真正能取消 LLM 调用。 +func GenerateWithFallback(ctx context.Context, primary *config.RouteConfig, messages []Message) (string, error) { aiRouteChain, err := buildRouteChain(primary) if err != nil { return "", err @@ -346,7 +495,7 @@ func GenerateWithFallback(primary *config.RouteConfig, messages []Message) (stri for _, aiRoute := range aiRouteChain { client := NewClient(aiRoute) start := time.Now() - content, err := client.Generate(messages) + content, err := client.Generate(ctx, messages) if err == nil { config.ReportRouteHealth(config.RouteHealth{ AIRouteID: aiRoute.RouteID, @@ -372,8 +521,9 @@ func GenerateWithFallback(primary *config.RouteConfig, messages []Message) (stri return "", fmt.Errorf("所有路由均失败: %w", lastErr) } -// GenerateFullWithFallback 非流式 + 回退链：返回结果与「实际命中」的路由（用于审计） -func GenerateFullWithFallback(primary *config.RouteConfig, messages []Message) (*ChatResult, *config.RouteConfig, error) { +// GenerateFullWithFallback 非流式 + 回退链：返回结果与「实际命中」的路由（用于审计）。 +// ctx 贯穿到各路由的 HTTP 请求，使上层超时真正能取消 LLM 调用。 +func GenerateFullWithFallback(ctx context.Context, primary *config.RouteConfig, messages []Message) (*ChatResult, *config.RouteConfig, error) { aiRouteChain, err := buildRouteChain(primary) if err != nil { return nil, nil, err @@ -383,7 +533,7 @@ func GenerateFullWithFallback(primary *config.RouteConfig, messages []Message) ( for _, aiRoute := range aiRouteChain { client := NewClient(aiRoute) start := time.Now() - res, err := client.GenerateFull(messages) + res, err := client.GenerateFull(ctx, messages) if err == nil { config.ReportRouteHealth(config.RouteHealth{ AIRouteID: aiRoute.RouteID, @@ -410,8 +560,9 @@ func GenerateFullWithFallback(primary *config.RouteConfig, messages []Message) ( return nil, nil, fmt.Errorf("所有路由均失败: %w", lastErr) } -// GenerateStreamWithFallback 流式 + 回退链：返回实际命中的路由 -func GenerateStreamWithFallback(primary *config.RouteConfig, messages []Message, onChunk func(string)) (*config.RouteConfig, error) { +// GenerateStreamWithFallback 流式 + 回退链：返回实际命中的路由。 +// ctx 贯穿到各路由的 SSE 请求，使上层超时（如前端断开）真正能取消 LLM 调用。 +func GenerateStreamWithFallback(ctx context.Context, primary *config.RouteConfig, messages []Message, onChunk func(string)) (*config.RouteConfig, error) { aiRouteChain, err := buildRouteChain(primary) if err != nil { return nil, err @@ -419,7 +570,8 @@ func GenerateStreamWithFallback(primary *config.RouteConfig, messages []Message, var lastErr error for _, aiRoute := range aiRouteChain { - if requiresAPIKey(aiRoute) && strings.TrimSpace(aiRoute.APIKey) == "" { + // 判据只有 config 那一处，本文件原先自己抄了一份（缺「回环地址免密钥」）。 + if config.RequiresRouteAPIKey(aiRoute) && strings.TrimSpace(aiRoute.APIKey) == "" { config.ReportRouteHealth(config.RouteHealth{ AIRouteID: aiRoute.RouteID, Category: aiRoute.Category, @@ -433,7 +585,7 @@ func GenerateStreamWithFallback(primary *config.RouteConfig, messages []Message, } client := NewClient(aiRoute) start := time.Now() - if err := client.GenerateStream(messages, onChunk); err == nil { + if err := client.GenerateStream(ctx, messages, onChunk); err == nil { config.ReportRouteHealth(config.RouteHealth{ AIRouteID: aiRoute.RouteID, Category: aiRoute.Category, @@ -459,18 +611,6 @@ func GenerateStreamWithFallback(primary *config.RouteConfig, messages []Message, return nil, fmt.Errorf("所有路由均失败: %w", lastErr) } -func requiresAPIKey(aiRoute *config.RouteConfig) bool { - if aiRoute == nil { - return false - } - baseURL := strings.ToLower(strings.TrimSpace(aiRoute.BaseURL)) - if strings.Contains(baseURL, "openrouter.ai") || strings.Contains(baseURL, "openai.com") { - return true - } - provider := strings.ToLower(strings.TrimSpace(aiRoute.Provider)) - return provider == "openrouter" || provider == "openai" -} - func truncate(s string, n int) string { r := []rune(s) if len(r) <= n { diff --git a/eai_agentplatform/backend-go/internal/ai/llm_route_chain_test.go b/eai_agentplatform/backend-go/internal/ai/llm_route_chain_test.go index 9fa279b..a6b3ce8 100644 --- a/eai_agentplatform/backend-go/internal/ai/llm_route_chain_test.go +++ b/eai_agentplatform/backend-go/internal/ai/llm_route_chain_test.go @@ -1,6 +1,7 @@ package ai import ( + "context" "strings" "testing" @@ -47,13 +48,13 @@ func TestGenerateWithFallbackNilPrimary(t *testing.T) { msgs := []Message{{Role: "user", Content: "ping"}} t.Run("GenerateWithFallback", func(t *testing.T) { - if _, err := GenerateWithFallback(nil, msgs); err == nil { + if _, err := GenerateWithFallback(context.Background(), nil, msgs); err == nil { t.Error("期望返回错误，实际 nil") } }) t.Run("GenerateFullWithFallback", func(t *testing.T) { - res, route, err := GenerateFullWithFallback(nil, msgs) + res, route, err := GenerateFullWithFallback(context.Background(), nil, msgs) if err == nil { t.Error("期望返回错误，实际 nil") } @@ -63,7 +64,7 @@ func TestGenerateWithFallbackNilPrimary(t *testing.T) { }) t.Run("GenerateStreamWithFallback", func(t *testing.T) { - if _, err := GenerateStreamWithFallback(nil, msgs, func(string) {}); err == nil { + if _, err := GenerateStreamWithFallback(context.Background(), nil, msgs, func(string) {}); err == nil { t.Error("期望返回错误，实际 nil") } }) diff --git a/eai_agentplatform/backend-go/internal/ai/llm_transient_test.go b/eai_agentplatform/backend-go/internal/ai/llm_transient_test.go new file mode 100644 index 0000000..3847071 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/ai/llm_transient_test.go @@ -0,0 +1,183 @@ +package ai + +import ( + "context" + "errors" + "net/http" + "net/http/httptest" + "strings" + "testing" + + "eai_agentplatform/backend/internal/config" +) + +// newRouteServer 起一个把固定状态码与报文原样吐回的服务，并返回指向它的路由。 +// +// 用真实 HTTP 而不是构造 error 再断言：分类动作就长在 GenerateFull 的分支里， +// 绕开它去测 IsTransient 等于什么都没验。 +func newRouteServer(t *testing.T, status int, body string) *config.RouteConfig { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(status) + _, _ = w.Write([]byte(body)) + })) + t.Cleanup(srv.Close) + return &config.RouteConfig{RouteID: "chat_route_transient_test", BaseURL: srv.URL, Model: "test-model"} +} + +// TestGenerateFullClassifiesTransientUpstreamFailures 钉住「哪些失败值得重发」这条分界。 +// +// 分界的两种错法代价都很实在： +// - 该重试的没重试 → 第 3 步 11 段里挂 1 段，整步白跑（实测发生过，见下）； +// - 不该重试的标成可重试 → 每次重发都在花钱，而确定性的失败重发一百次也一样。 +func TestGenerateFullClassifiesTransientUpstreamFailures(t *testing.T) { + cases := []struct { + name string + // 实测第 3 步就是在第 4/11 段撞上这个：网关 HTTP 200，报文里却没有 choices。 + status int + body string + wantTransient bool + wantInMsg string // 文案要保持原样，日志与前端提示都在看它 + }{ + { + name: "网关回 200 却没有 choices", + status: http.StatusOK, + body: `{"error":{"message":"upstream timeout","type":"upstream_error"}}`, + wantTransient: true, + wantInMsg: "LLM 返回空正文（响应里没有 choices）", + }, + { + name: "网关回 200 但根本不是 JSON", + status: http.StatusOK, + body: `502 Bad Gateway`, + wantTransient: true, + wantInMsg: "LLM 响应解析失败", + }, + { + name: "限流 429", + status: http.StatusTooManyRequests, + body: `{"error":"rate limited"}`, + wantTransient: true, + wantInMsg: "LLM 返回 429", + }, + { + name: "上游 500", + status: http.StatusInternalServerError, + body: `{"error":"internal"}`, + wantTransient: true, + wantInMsg: "LLM 返回 500", + }, + { + name: "上游 503", + status: http.StatusServiceUnavailable, + body: `{"error":"overloaded"}`, + wantTransient: true, + wantInMsg: "LLM 返回 503", + }, + { + // 4xx 是「这个请求本身就不对」—— 模型名、密钥、参数。 + // 重发一百次也是同一个结果，标成可重试只会白花钱。 + name: "模型名写错 404", + status: http.StatusNotFound, + body: `{"error":"model not found"}`, + wantTransient: false, + wantInMsg: "LLM 返回 404", + }, + { + name: "密钥无效 401", + status: http.StatusUnauthorized, + body: `{"error":"invalid key"}`, + wantTransient: false, + wantInMsg: "LLM 返回 401", + }, + { + name: "参数非法 400", + status: http.StatusBadRequest, + body: `{"error":"bad request"}`, + wantTransient: false, + wantInMsg: "LLM 返回 400", + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + route := newRouteServer(t, tc.status, tc.body) + + _, err := NewClient(route).GenerateFull(context.Background(), + []Message{{Role: "user", Content: "ping"}}) + if err == nil { + t.Fatal("期望失败，实际成功") + } + if got := IsTransient(err); got != tc.wantTransient { + t.Errorf("IsTransient = %v，期望 %v（错误：%v）", got, tc.wantTransient, err) + } + if !strings.Contains(err.Error(), tc.wantInMsg) { + t.Errorf("文案里应保留 %q，实际为：%v", tc.wantInMsg, err) + } + }) + } +} + +// TestSuccessIsNotTransient 成功时不该有任何错误，这条是上面所有断言的对照组。 +func TestSuccessIsNotTransient(t *testing.T) { + route := newRouteServer(t, http.StatusOK, + `{"model":"m","choices":[{"message":{"content":"正文"},"finish_reason":"stop"}]}`) + + res, err := NewClient(route).GenerateFull(context.Background(), + []Message{{Role: "user", Content: "ping"}}) + if err != nil { + t.Fatalf("正常报文不该报错：%v", err) + } + if res.Content != "正文" { + t.Errorf("正文 = %q，期望 %q", res.Content, "正文") + } + if IsTransient(err) { + t.Error("nil 错误不该被判为可重试") + } +} + +// TestBudgetExhaustionIsNotTransient 预算被思考吃光是**确定性**失败： +// choices 在、finish_reason=length，只是正文没有。它必须落进 EmptyCompletionError +// 而不是可重试那一类 —— 否则重试循环会对着同一个写不出正文的请求连打三次，白花三次钱。 +func TestBudgetExhaustionIsNotTransient(t *testing.T) { + route := newRouteServer(t, http.StatusOK, + `{"model":"m","choices":[{"message":{"content":"","reasoning_content":"想了很多"},"finish_reason":"length"}],`+ + `"usage":{"completion_tokens":4096}}`) + + _, err := NewClient(route).GenerateFull(context.Background(), + []Message{{Role: "user", Content: "ping"}}) + if err == nil { + t.Fatal("预算耗尽且正文为空时应报错，实际成功") + } + var empty *EmptyCompletionError + if !errors.As(err, &empty) { + t.Fatalf("期望 EmptyCompletionError，实际 %T：%v", err, err) + } + if empty.CompletionTokens != 4096 { + t.Errorf("completion_tokens = %d，期望 4096", empty.CompletionTokens) + } + if IsTransient(err) { + t.Error("预算耗尽不该被判为可重试：重发拿的是同一个结果，只是再花一次钱") + } +} + +// TestTransientSurvivesFallbackChainWrapping 回退链会给错误套上两层 %w 包装 +// （「所有路由均失败: [路由 id] …」），而技能的重试循环拿到的就是最外层那个。 +// 分类必须穿透包装 —— 穿透不了，重试就等于没加。 +func TestTransientSurvivesFallbackChainWrapping(t *testing.T) { + route := newRouteServer(t, http.StatusOK, `{"error":"upstream exploded"}`) + // 用一个必然不存在的路由 id，链上就只有主路由这一条。 + route.RouteID = "chat_route_does_not_exist_for_test" + + _, _, err := GenerateFullWithFallback(context.Background(), route, + []Message{{Role: "user", Content: "ping"}}) + if err == nil { + t.Fatal("期望失败，实际成功") + } + if !strings.Contains(err.Error(), "所有路由均失败") { + t.Fatalf("错误应经回退链包装，实际：%v", err) + } + if !IsTransient(err) { + t.Errorf("包装后仍应判为可重试，实际不可重试：%v", err) + } +} diff --git a/eai_agentplatform/backend-go/internal/ai/retrieve.go b/eai_agentplatform/backend-go/internal/ai/retrieve.go index 8cf4c67..c1863ed 100644 --- a/eai_agentplatform/backend-go/internal/ai/retrieve.go +++ b/eai_agentplatform/backend-go/internal/ai/retrieve.go @@ -1,6 +1,7 @@ package ai import ( + "context" "math" "sort" "strings" @@ -52,7 +53,7 @@ func vectorRetrieve(aiRoute *config.RouteConfig, query string, topK int) ([]stri for _, ch := range chunks { inputs = append(inputs, ch.Content) } - vecs, err := client.Embed(inputs) + vecs, err := client.Embed(context.Background(), inputs) if err != nil || len(vecs) != len(inputs) { if err != nil { return nil, err diff --git a/eai_agentplatform/backend-go/internal/ai/routetest/audio_test.go b/eai_agentplatform/backend-go/internal/ai/routetest/audio_test.go new file mode 100644 index 0000000..d2055b4 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/ai/routetest/audio_test.go @@ -0,0 +1,253 @@ +package routetest + +import ( + "net/http" + "net/http/httptest" + "strings" + "testing" + + "eai_agentplatform/backend/internal/config" +) + +// 这一组用例钉的是语音路由的通路测试。 +// +// 背景：routetest 原先按 Category 分发，但只认 chat/embed/image/video， +// audio 落到 default，于是「测试语音路由」会把一个 /chat/completions 请求 +// 打到 ASR 服务上。报回来的错（模型不存在、参数不合法）与真实原因 +// （走错接口）毫无关系，而这个红叉会让人去改一条本来没问题的路由。 +// +// 所以第一条断言就是「打到了转写终点」——不是「没报错」。 + +// audioStub 起一个桩，记录收到的请求，能同时应答转写与 chat 两种终点。 +type audioStub struct { + srv *httptest.Server + audioCalls int + chatCalls int + lastPath string + lastAuth string + lastCt string + lastFormFile string + audioStatus int +} + +func newAudioStub(t *testing.T) *audioStub { + t.Helper() + s := &audioStub{audioStatus: http.StatusOK} + s.srv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + switch { + // 按后缀认转写终点，这样用例可以换一个 Endpoint 验证它确实来自配置。 + case strings.HasSuffix(r.URL.Path, "/transcriptions"): + s.audioCalls++ + s.lastPath = r.URL.Path + s.lastAuth = r.Header.Get("Authorization") + s.lastCt = r.Header.Get("Content-Type") + s.lastFormFile = formFileName(r) + if s.audioStatus != http.StatusOK { + w.WriteHeader(s.audioStatus) + _, _ = w.Write([]byte(`{"error":{"message":"no speech detected"}}`)) + return + } + _, _ = w.Write([]byte(`{"text":"","segments":[],"duration":1.0}`)) + case strings.HasSuffix(r.URL.Path, "/chat/completions"): + s.chatCalls++ + _, _ = w.Write([]byte(`{"choices":[{"message":{"content":"pong"}}]}`)) + default: + w.WriteHeader(http.StatusNotFound) + _, _ = w.Write([]byte(`{"error":"unexpected path"}`)) + } + })) + t.Cleanup(s.srv.Close) + return s +} + +// formFileName 从 multipart 请求里取出文件部件的文件名。 +func formFileName(r *http.Request) string { + mr, err := r.MultipartReader() + if err != nil { + return "" + } + for { + part, err := mr.NextPart() + if err != nil { + return "" + } + if part.FormName() == "file" { + return part.FileName() + } + } +} + +// audioRoute 造一条指向桩的语音路由（回环地址 → IsLocalRoute 判为本地）。 +func audioRoute(s *audioStub) *config.RouteConfig { + return &config.RouteConfig{ + RouteID: "audio_route_stub", + Provider: "local_asr", + Category: "audio", + BaseURL: s.srv.URL, + Endpoint: "/audio/transcriptions", + FullURL: s.srv.URL + "/audio/transcriptions", + Model: "large-v3", + TimeoutSeconds: 30, + } +} + +// TestAudioRouteTestHitsTranscriptionsEndpoint 是最重要的一条： +// audio 必须打到转写终点，绝不能落到 chat 的 default 分支。 +func TestAudioRouteTestHitsTranscriptionsEndpoint(t *testing.T) { + stub := newAudioStub(t) + res := Do(audioRoute(stub), &TestOptions{}) + + if stub.chatCalls != 0 { + t.Errorf("语音路由被打了一个 chat 请求（%d 次）—— audio 落到了 default 分支", stub.chatCalls) + } + if stub.audioCalls != 1 { + t.Fatalf("转写终点被打了 %d 次，期望 1 次", stub.audioCalls) + } + if !res.Succeeded || len(res.Items) != 1 || !res.Items[0].Ok { + t.Fatalf("期望测试成功，实际 %+v", res.Items) + } + if !strings.HasPrefix(stub.lastCt, "multipart/form-data") { + t.Errorf("Content-Type = %q，期望 multipart/form-data", stub.lastCt) + } + if stub.lastFormFile != "silence-1s.wav" { + t.Errorf("文件部件名 = %q，期望 silence-1s.wav", stub.lastFormFile) + } + if !strings.Contains(res.Items[0].Summary, "静音") { + t.Errorf("摘要没说明样本是静音，会被读成「转写质量已验证」：%q", res.Items[0].Summary) + } +} + +// TestAudioRouteTestUsesConfiguredEndpoint 终点取配置里的 Endpoint。 +// 写死 /audio/transcriptions 会让这个可配置字段失效（云端中转路径未必一致）。 +func TestAudioRouteTestUsesConfiguredEndpoint(t *testing.T) { + stub := newAudioStub(t) + route := audioRoute(stub) + route.Endpoint = "/v1/custom/transcriptions" + + res := Do(route, &TestOptions{}) + if !res.Items[0].Ok { + t.Fatalf("按 Endpoint 拼接的请求应当成功：%s", res.Items[0].Error) + } + if stub.lastPath != "/v1/custom/transcriptions" { + t.Errorf("打到了 %q —— 终点没有取自配置的 Endpoint", stub.lastPath) + } +} + +// TestAudioRouteTestSendsBearerForLocalRoute 本地服务没有密钥也要带鉴权头。 +// +// serve.py 不校验密钥的值，但收不到 Authorization 就回 401。通路测试若跳过这个头， +// 本地 ASR 会稳定测红 —— 而真实转写是通的（transcribe.go 里就写死 "local"）。 +func TestAudioRouteTestSendsBearerForLocalRoute(t *testing.T) { + stub := newAudioStub(t) + route := audioRoute(stub) + if route.APIKey != "" { + t.Fatal("用例前提：这条路由没有密钥") + } + res := Do(route, &TestOptions{}) + + if !res.Items[0].Ok { + t.Fatalf("本地无密钥路由应当能测通，实际：%s", res.Items[0].Error) + } + if stub.lastAuth != "Bearer local" { + t.Errorf("Authorization = %q，期望 \"Bearer local\"", stub.lastAuth) + } +} + +// TestAudioRouteTestLocalWinsOverProviderName 是「回环地址免密钥」这条规则 +// 在通路测试里也生效的证据 —— 也正是三份 requiresAPIKey 副本会走偏的那一格。 +// +// 场景：内网有人用 OpenAI 兼容的壳把本地 ASR 包了一层，provider 于是写成 openai， +// base_url 仍是 127.0.0.1。判据若看 provider 名（旧副本就是这么写的）， +// 就会报「API Key 未配置」；而真实调用根本不需要密钥。 +// 判据应当是「流量去哪」——回环地址就是不需要。 +func TestAudioRouteTestLocalWinsOverProviderName(t *testing.T) { + stub := newAudioStub(t) + route := audioRoute(stub) + route.Provider = "openai" // 名字像云端，地址是回环 + res := Do(route, &TestOptions{}) + + if !res.Items[0].Ok { + t.Fatalf("回环地址的路由不该因为 provider 名像云端就被要求密钥：%s", res.Items[0].Error) + } + if stub.audioCalls != 1 { + t.Errorf("转写终点被打了 %d 次，期望 1 次", stub.audioCalls) + } +} + +// TestAudioRouteTestTreatsEmptyTextAsSuccess 静音样本转出空文本是**预期**，不是失败。 +// +// 判成功只看「200 + 合法 JSON」。把空文本当失败，一条完全正常的本地 whisper +// 路由（静音就返回 text=""）会被测红，然后有人去改配置。 +func TestAudioRouteTestTreatsEmptyTextAsSuccess(t *testing.T) { + stub := newAudioStub(t) + res := Do(audioRoute(stub), &TestOptions{}) + + item := res.Items[0] + if !item.Ok { + t.Fatalf("空文本被当成了失败：%s", item.Error) + } + if !strings.Contains(item.OutputPreview, "静音样本") { + t.Errorf("产物预览应说明空文本是静音所致，实际：%q", item.OutputPreview) + } +} + +// TestAudioRouteTestExplainsClientRejection 4xx 的报错要说清「可能是静音被拒」。 +// 否则读的人只会看到「返回 400」，然后把一条好路由当成坏的。 +func TestAudioRouteTestExplainsClientRejection(t *testing.T) { + stub := newAudioStub(t) + stub.audioStatus = http.StatusBadRequest + res := Do(audioRoute(stub), &TestOptions{}) + + item := res.Items[0] + if item.Ok { + t.Fatal("400 不该算通过") + } + if !strings.Contains(item.Error, "静音") || !strings.Contains(item.Error, "不代表路由不可用") { + t.Errorf("4xx 的报错没解释静音这一层：%q", item.Error) + } + if item.StatusCode != http.StatusBadRequest { + t.Errorf("StatusCode = %d，期望 400", item.StatusCode) + } +} + +// TestSilentWAVIsWellFormed WAV 头写错的话服务端多半直接 400， +// 上面那些用例会以「4xx」的形式红，而不会告诉你「样本本身不合法」。 +func TestSilentWAVIsWellFormed(t *testing.T) { + const dataBytes = 16000 * 2 // 1 秒 × 16kHz × 16bit + data := silentWAV(1000) + if len(data) != 44+dataBytes { + t.Errorf("长度 = %d，期望 %d（44 字节头 + 1 秒采样）", len(data), 44+dataBytes) + } + if string(data[0:4]) != "RIFF" || string(data[8:12]) != "WAVE" || string(data[36:40]) != "data" { + t.Fatalf("RIFF/WAVE/data 标识不对：%q %q %q", data[0:4], data[8:12], data[36:40]) + } + le := func(off int, n int) uint32 { + var v uint32 + for i := 0; i < n; i++ { + v |= uint32(data[off+i]) << (8 * i) + } + return v + } + if got := le(24, 4); got != 16000 { + t.Errorf("采样率 = %d，期望 16000", got) + } + if got := le(22, 2); got != 1 { + t.Errorf("声道数 = %d，期望 1（单声道）", got) + } + if got := le(34, 2); got != 16 { + t.Errorf("位深 = %d，期望 16", got) + } + if got := le(40, 4); got != dataBytes { + t.Errorf("data 块长度 = %d，期望 %d", got, dataBytes) + } + if got := le(4, 4); got != uint32(36+dataBytes) { + t.Errorf("RIFF 长度 = %d，期望 %d", got, 36+dataBytes) + } + // 采样必须全零，否则「静音样本」这个名字就是假的。 + for i, b := range data[44:] { + if b != 0 { + t.Fatalf("第 %d 个采样字节非零 —— 这不是静音样本", i) + } + } +} diff --git a/eai_agentplatform/backend-go/internal/ai/routetest/routetest.go b/eai_agentplatform/backend-go/internal/ai/routetest/routetest.go index 34e19ba..7f306a3 100644 --- a/eai_agentplatform/backend-go/internal/ai/routetest/routetest.go +++ b/eai_agentplatform/backend-go/internal/ai/routetest/routetest.go @@ -11,9 +11,11 @@ package routetest import ( "bytes" + "encoding/binary" "encoding/json" "fmt" "io" + "mime/multipart" "net/http" "sort" "strings" @@ -114,7 +116,10 @@ func testOne(route *config.RouteConfig, model string, prompt, size string) Resul item.Error = "base_url 未配置" return item } - if requiresAPIKey(route) && strings.TrimSpace(route.APIKey) == "" { + // 判据与健康探测、真实调用共用 config 的那一份：本包原先自己抄了一遍。 + // 两份在今天的配置上恰好同结论，但只有 config 那份知道「回环地址免密钥」； + // 抄出来的第二份一旦漏跟，症状是「通路测试说缺密钥，真实调用却是通的」。 + if config.RequiresRouteAPIKey(route) && strings.TrimSpace(route.APIKey) == "" { item.Error = "API Key 未配置" return item } @@ -127,6 +132,11 @@ func testOne(route *config.RouteConfig, model string, prompt, size string) Resul testVideo(route, model, prompt, &item) case "embed": testEmbed(route, model, prompt, &item) + case "audio": + // 必须单独一支：audio 的终点是 /audio/transcriptions、请求体是 multipart， + // 落到 default 会把一个 chat 请求打到 ASR 服务上，报回来的错 + // （模型不存在 / 参数不对）与真实原因（走错接口）毫无关系。 + testAudio(route, model, prompt, &item) default: testChat(route, model, prompt, &item) } @@ -374,6 +384,169 @@ func testVideo(route *config.RouteConfig, model, prompt string, item *ResultItem item.Error = "响应缺少 url / b64_json" } +// testAudio 语音转写类单模型测试。 +// +// 拿一段**程序生成的静音 WAV** 去打真实的 /audio/transcriptions，验的是 +// 「这条路走不走得通」：终点对不对、密钥收不收、multipart 字段名对不对、 +// 返回的是不是转写那套结构。**不验转写质量** —— 静音样本本来就没什么可转的， +// 把「没转出字」当失败会让一条好路由被测红。 +// +// 所以判成功的标准只有一条：HTTP 200 且响应是合法 JSON。摘要里会写明 +// 「静音样本」，避免被读成「转写质量已验证」。 +// +// 静音是现算的，不内嵌音频文件：P06.11 不允许引入第三方受限素材， +// 而原型机的真实录音属于用户数据，更不能编进二进制。 +func testAudio(route *config.RouteConfig, model, prompt string, item *ResultItem) { + // audio 的终点在配置里（route.Endpoint），不像 chat/embed/image 是固定路径。 + endpoint := strings.TrimSpace(route.Endpoint) + if endpoint == "" { + endpoint = "/audio/transcriptions" + } + sample := silentWAV(1000) + item.RawRequest = fmt.Sprintf( + `{"endpoint":%q,"model":%q,"file":"silence-1s.wav","bytes":%d,"note":"程序生成的静音样本，仅验证接口连通性"}`, + endpoint, model, len(sample)) + + var out struct { + Text string `json:"text"` + Segments []struct { + Speaker string `json:"speaker"` + Text string `json:"text"` + } `json:"segments"` + Duration float64 `json:"duration"` + Model string `json:"model"` + Error any `json:"error"` + } + code, rawRes, err := httpPostFile(route, endpoint, "silence-1s.wav", sample, map[string]string{ + "model": model, + }, &out) + item.StatusCode = code + item.RawResponse = truncate(rawRes, 4000) + if err != nil { + // 4xx 要单独说清楚：静音被拒是这一类接口的常见反应，不能让人以为 + // 路由坏了。真正的转写能力得用一份真实录音走一次语音转写技能才算数。 + if code >= 400 && code < 500 { + item.Error = fmt.Sprintf("%v（样本是 1 秒静音，若服务方拒收无语音音频，此结果不代表路由不可用；"+ + "请用一份真实录音跑一次「语音转写」技能确认）", err) + return + } + item.Error = err.Error() + return + } + item.ModelEcho = firstNonEmpty(out.Model, model) + item.Summary = fmt.Sprintf("转写接口应答正常（1 秒静音样本，返回 %d 段，未检验转写质量）", len(out.Segments)) + if strings.TrimSpace(out.Text) != "" { + item.OutputPreview = truncate(out.Text, 2000) + } else { + item.OutputPreview = "（静音样本，文本为空属预期）" + } +} + +// httpPostFile 发一次 multipart/form-data 的 POST。 +// +// 鉴权头与真实转写**逐字对齐**：没有密钥时也要发 `Bearer local`。 +// 本地 serve.py 不校验密钥的值，但收不到这个头就回 401 —— 这里若图省事跳过， +// 本地 ASR 在通路测试里会稳定报 401，而真实转写明明是通的。 +func httpPostFile(route *config.RouteConfig, path, filename string, content []byte, fields map[string]string, out any) (int, string, error) { + buf := bytes.NewBuffer(nil) + w := multipart.NewWriter(buf) + for _, key := range sortedKeys(fields) { + fw, err := w.CreateFormField(key) + if err != nil { + return 0, "", fmt.Errorf("构建请求失败: %w", err) + } + if _, err := fw.Write([]byte(fields[key])); err != nil { + return 0, "", fmt.Errorf("构建请求失败: %w", err) + } + } + fw, err := w.CreateFormFile("file", filename) + if err != nil { + return 0, "", fmt.Errorf("构建请求失败: %w", err) + } + if _, err := fw.Write(content); err != nil { + return 0, "", fmt.Errorf("写入样本失败: %w", err) + } + if err := w.Close(); err != nil { + return 0, "", fmt.Errorf("构建请求失败: %w", err) + } + + fullURL := strings.TrimRight(route.BaseURL, "/") + path + req, err := http.NewRequest(http.MethodPost, fullURL, buf) + if err != nil { + return 0, "", fmt.Errorf("构造请求失败: %w", err) + } + req.Header.Set("Content-Type", w.FormDataContentType()) + authKey := route.APIKey + if strings.TrimSpace(authKey) == "" { + authKey = "local" + } + req.Header.Set("Authorization", "Bearer "+authKey) + + client := &http.Client{Timeout: defaultTestTimeout} + resp, err := client.Do(req) + if err != nil { + return 0, "", fmt.Errorf("服务不可达: %w", err) + } + defer resp.Body.Close() + data, err := io.ReadAll(resp.Body) + if err != nil { + return resp.StatusCode, "", fmt.Errorf("读取响应失败: %w", err) + } + rawStr := string(data) + if resp.StatusCode != http.StatusOK { + return resp.StatusCode, rawStr, fmt.Errorf("返回 %d: %s", resp.StatusCode, truncate(rawStr, 200)) + } + if len(data) > 0 && out != nil { + if err := json.Unmarshal(data, out); err != nil { + return resp.StatusCode, rawStr, fmt.Errorf("响应解析失败: %w", err) + } + } + return resp.StatusCode, rawStr, nil +} + +// silentWAV 生成一段 ms 毫秒的 16kHz 单声道 16bit 静音 WAV。 +// 标准 44 字节 RIFF 头 + 全零采样，任何 ASR 服务都认这个容器格式。 +func silentWAV(ms int) []byte { + const sampleRate = 16000 + samples := sampleRate * ms / 1000 + dataSize := samples * 2 + + var buf bytes.Buffer + write := func(v any) { _ = binary.Write(&buf, binary.LittleEndian, v) } + buf.WriteString("RIFF") + write(uint32(36 + dataSize)) + buf.WriteString("WAVEfmt ") + write(uint32(16)) // fmt chunk 长度 + write(uint16(1)) // PCM + write(uint16(1)) // 单声道 + write(uint32(sampleRate)) // 采样率 + write(uint32(sampleRate * 2)) // 字节率 = 采样率 × 声道 × 位深/8 + write(uint16(2)) // 块对齐 = 声道 × 位深/8 + write(uint16(16)) // 位深 + buf.WriteString("data") + write(uint32(dataSize)) + buf.Write(make([]byte, dataSize)) + return buf.Bytes() +} + +func sortedKeys(m map[string]string) []string { + keys := make([]string, 0, len(m)) + for k := range m { + keys = append(keys, k) + } + sort.Strings(keys) + return keys +} + +func firstNonEmpty(values ...string) string { + for _, v := range values { + if strings.TrimSpace(v) != "" { + return v + } + } + return "" +} + // DiscoverModels 拉取 provider 端 /models 获取可用模型列表（自动发现）。 // 返回按字母排序的模型 ID 列表；不可达或失败时返回 nil + error。 func DiscoverModels(route *config.RouteConfig) ([]string, error) { @@ -404,20 +577,6 @@ func MergeCandidates(known, discovered []string) []string { return out } -// requiresAPIKey 判断该路由是否必须携带 API Key（只有云端 provider 才强制）。 -// 本地服务（ollama / llamacpp 等）无需 key 也应能完成测试。 -func requiresAPIKey(route *config.RouteConfig) bool { - if route == nil { - return false - } - baseURL := strings.ToLower(strings.TrimSpace(route.BaseURL)) - if strings.Contains(baseURL, "openrouter.ai") || strings.Contains(baseURL, "openai.com") { - return true - } - provider := strings.ToLower(strings.TrimSpace(route.Provider)) - return provider == "openrouter" || provider == "openai" -} - func truncate(s string, n int) string { s = strings.TrimSpace(s) if n <= 0 || len(s) <= n { diff --git a/eai_agentplatform/backend-go/internal/ai/web_search_tool.go b/eai_agentplatform/backend-go/internal/ai/web_search_tool.go new file mode 100644 index 0000000..3a26ebf --- /dev/null +++ b/eai_agentplatform/backend-go/internal/ai/web_search_tool.go @@ -0,0 +1,79 @@ +package ai + +import ( + "context" + "encoding/json" + "fmt" + "strings" + + "eai_agentplatform/backend/internal/search" +) + +// webSearchTool 让 LLM 通过 SearXNG 搜索实时信息。 +type webSearchTool struct { + client *search.Client +} + +// NewWebSearchTool 创建网页搜索工具。client 可为 nil（使用全局默认客户端）。 +func NewWebSearchTool(client *search.Client) Tool { + if client == nil { + client = search.GetClient() + } + return &webSearchTool{client: client} +} + +// args webSearchTool 的参数结构。 +type args struct { + Query string `json:"query"` +} + +// Schema 返回 OpenAI 兼容的 function schema。 +func (t *webSearchTool) Schema() ToolSchema { + var s ToolSchema + s.Type = "function" + s.Function.Name = "web_search" + s.Function.Description = "搜索互联网获取最新的文章、数据、报告与案例。当你需要引用最新市场数据、行业案例、政策信息或验证事实时调用本工具。返回若干条带标题、链接与摘要的结果。" + s.Function.Parameters = map[string]any{ + "type": "object", + "properties": map[string]any{ + "query": map[string]any{ + "type": "string", + "description": "搜索关键词，尽量具体，可含行业、年份、数据点等，例如「2025年中国外骨骼机器人市场规模」", + }, + }, + "required": []string{"query"}, + } + return s +} + +// Execute 执行搜索并把结果格式化为 LLM 易读的文本。 +func (t *webSearchTool) Execute(ctx context.Context, rawArgs json.RawMessage) (string, error) { + var a args + if err := json.Unmarshal(rawArgs, &a); err != nil { + return "", fmt.Errorf("解析 web_search 参数失败: %w", err) + } + a.Query = strings.TrimSpace(a.Query) + if a.Query == "" { + return "", fmt.Errorf("web_search 缺少 query 参数") + } + + results, err := t.client.Search(a.Query) + if err != nil { + return "", err + } + if len(results) == 0 { + return fmt.Sprintf("搜索「%s」无结果。", a.Query), nil + } + + var b strings.Builder + for i, r := range results { + b.WriteString(fmt.Sprintf("%d. %s\n", i+1, r.Title)) + if r.URL != "" { + b.WriteString(fmt.Sprintf(" 链接: %s\n", r.URL)) + } + if r.Content != "" { + b.WriteString(fmt.Sprintf(" 摘要: %s\n", r.Content)) + } + } + return strings.TrimSpace(b.String()), nil +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/api/ai_chat.go b/eai_agentplatform/backend-go/internal/api/ai_chat.go index d2e6bef..eb938e5 100644 --- a/eai_agentplatform/backend-go/internal/api/ai_chat.go +++ b/eai_agentplatform/backend-go/internal/api/ai_chat.go @@ -106,7 +106,7 @@ func ChatMessage(c *gin.Context) { } start := time.Now() var replyBuilder strings.Builder - usedAiRoute, err := ai.GenerateStreamWithFallback(aiRoute, plan.LLMMessages, func(chunk string) { + usedAiRoute, err := ai.GenerateStreamWithFallback(c.Request.Context(), aiRoute, plan.LLMMessages, func(chunk string) { replyBuilder.WriteString(chunk) writeEvent(gin.H{"type": "text", "content": chunk}) }) @@ -281,7 +281,7 @@ func QuickAction(c *gin.Context) { } start := time.Now() - result, usedAiRoute, err := ai.GenerateFullWithFallback(aiRoute, aiMessages) + result, usedAiRoute, err := ai.GenerateFullWithFallback(c.Request.Context(), aiRoute, aiMessages) if err != nil { ai.LogCall(ai.LogEntry{ UserID: user.ID, UsageKind: ai.UsageKindTextGen, Provider: aiRoute.Provider, diff --git a/eai_agentplatform/backend-go/internal/api/ai_routes.go b/eai_agentplatform/backend-go/internal/api/ai_routes.go index 035be7c..0b7d193 100644 --- a/eai_agentplatform/backend-go/internal/api/ai_routes.go +++ b/eai_agentplatform/backend-go/internal/api/ai_routes.go @@ -21,6 +21,7 @@ type routeItem struct { Description string `json:"description"` ShortRouteName string `json:"short_route_name,omitempty"` ShortModelName string `json:"short_model_name,omitempty"` + IsLocal bool `json:"is_local"` // base_url 是回环即本地，见 config.IsLocalRoute Healthy bool `json:"healthy"` Checked bool `json:"checked"` LatencyMs int64 `json:"latency_ms,omitempty"` @@ -41,6 +42,7 @@ func toRouteItems(routes []*config.RouteConfig) []routeItem { Description: r.Description, ShortRouteName: r.ShortRouteName, ShortModelName: r.ShortModelName, + IsLocal: config.IsLocalRoute(r), Healthy: health.Healthy, Checked: health.Checked, LatencyMs: health.LatencyMs, @@ -59,12 +61,14 @@ func autoRouteItem(routeID string, category string) routeItem { ShortModelName: "检测中", } - resolved, err := config.GetRoute(routeID) + // 按分类解析：audio 走 GetAudioRoute，见 config.GetRouteForCategory。 + resolved, err := config.GetRouteForCategory(routeID, category) if err == nil && resolved != nil { health, _ := config.GetRouteHealth(resolved.RouteID) item.Provider = resolved.Provider item.Model = resolved.Model item.BaseURL = resolved.BaseURL + item.IsLocal = config.IsLocalRoute(resolved) item.ShortModelName = resolved.ShortModelName if item.ShortModelName == "" { item.ShortModelName = "优选" @@ -85,6 +89,9 @@ func autoRouteItem(routeID string, category string) routeItem { if category == "embed" { item.ShortModelName = "Emb" } + if category == "audio" { + item.ShortModelName = "ASR" + } return item } @@ -118,3 +125,18 @@ func ListEmbedRoutes(c *gin.Context) { items = append(items, toRouteItems(routes)...) web.OK(c, gin.H{"routes": items}) } + +// ListAudioRoutes 返回可用语音转写（ASR）路由列表。 +// +// 与 chat/embed 两份是同一形状，多出来的是 base_url 里已经能看出本地/云端 —— +// 前端据 is_local 标注「音频不出网」，不必自己再去猜 provider 名。 +func ListAudioRoutes(c *gin.Context) { + routes, err := config.GetRoutesByCategory("audio") + if err != nil { + web.Fail(c, web.NewLLMNotConfigured("路由加载失败: "+err.Error())) + return + } + items := []routeItem{autoRouteItem(config.AutoAudioRouteID, "audio")} + items = append(items, toRouteItems(routes)...) + web.OK(c, gin.H{"routes": items}) +} diff --git a/eai_agentplatform/backend-go/internal/api/ai_routetest.go b/eai_agentplatform/backend-go/internal/api/ai_routetest.go index 455b681..ebae56e 100644 --- a/eai_agentplatform/backend-go/internal/api/ai_routetest.go +++ b/eai_agentplatform/backend-go/internal/api/ai_routetest.go @@ -1,14 +1,15 @@ // ai_routetest.go —— 「AI 通路测试」的管理员接口。 // // 用于开发/运维对某个 AI 模型路由/具体模型做一次完整业务验证： -// - 获取某路由的候选模型清单（配置 model ∪ 自动发现 /models） -// - 对单个模型 或 候选模型逐个，发起一次真实请求并记录原始报文 / 产物预览 +// - 获取某路由的候选模型清单（配置 model ∪ 自动发现 /models） +// - 对单个模型 或 候选模型逐个，发起一次真实请求并记录原始报文 / 产物预览 // // 设计约束：本接口的测试调用**不扣算力点、不写 ai_call_log**，纯后台诊断。 package api import ( "encoding/json" + "fmt" "io" "github.com/gin-gonic/gin" @@ -33,6 +34,10 @@ func AIRouteTestModels(c *gin.Context) { web.Fail(c, web.NewBadRequest("路由不存在: "+req.RouteID)) return } + if err := assertRouteResolvedAsRequested(route, req.RouteID); err != nil { + web.Fail(c, web.NewBadRequest(err.Error())) + return + } candidates := []string{route.Model} discovered, _ := routetest.DiscoverModels(route) @@ -42,14 +47,14 @@ func AIRouteTestModels(c *gin.Context) { } web.OK(c, gin.H{ - "route_id": route.RouteID, - "provider": route.Provider, - "category": route.Category, - "base_url": route.BaseURL, - "endpoint": route.Endpoint, + "route_id": route.RouteID, + "provider": route.Provider, + "category": route.Category, + "base_url": route.BaseURL, + "endpoint": route.Endpoint, "config_model": route.Model, - "candidates": candidates, - "discovered": discovered, + "candidates": candidates, + "discovered": discovered, }) } @@ -77,8 +82,27 @@ func AIRouteTestRun(c *gin.Context) { web.Fail(c, web.NewBadRequest("路由不存在: "+req.RouteID)) return } + if err := assertRouteResolvedAsRequested(route, req.RouteID); err != nil { + web.Fail(c, web.NewBadRequest(err.Error())) + return + } opts := &routetest.TestOptions{Prompt: req.Prompt, Models: req.Models, Size: req.Size} result := routetest.Do(route, opts) web.OK(c, gin.H{"result": result}) } + +// assertRouteResolvedAsRequested 确认解析出来的就是请求的那条路由。 +// +// GetRoute 找不到 route_id 时会静默回退 default_route（一条 chat 路由）。 +// 那意味着页面拿着「路由 A」的标题去测路由 B，而结果看起来完全正常 —— +// 这类失败最难发现。auto 占位 id 例外：它本来就会被换成此刻健康的具体路由。 +func assertRouteResolvedAsRequested(route *config.RouteConfig, requested string) error { + if route == nil { + return fmt.Errorf("路由不存在: %s", requested) + } + if config.IsAutoRouteID(requested) || route.RouteID == requested { + return nil + } + return fmt.Errorf("路由不存在: %s（解析成了 %s）", requested, route.RouteID) +} diff --git a/eai_agentplatform/backend-go/internal/api/ai_routetest_guard_test.go b/eai_agentplatform/backend-go/internal/api/ai_routetest_guard_test.go new file mode 100644 index 0000000..9ec06e5 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/api/ai_routetest_guard_test.go @@ -0,0 +1,68 @@ +package api + +import ( + "strings" + "testing" + + "eai_agentplatform/backend/internal/config" +) + +// 这一组钉的是「测试的路由就是你选的那条」。 +// +// GetRoute 找不到 route_id 会静默回退 default_route。通路测试的入参来自前端 +// 路由列表里的具体 id，一旦解析成了别的路由，页面会拿着「路由 A」的标题 +// 去测路由 B，而结果看起来完全正常 —— 这类失败最难发现。 +// +// 但「自动」占位 id 必须放行：它本来就该被换成此刻健康的那条具体路由， +// 拦下来等于把通路测试里「自动」这一项弄坏了。 + +func TestAssertRouteResolvedAsRequestedRejectsFallback(t *testing.T) { + route, err := config.GetRoute("chat_route_lmuai_deepseek_v4_flash") + if err != nil { + t.Fatalf("用例前提：该路由应能解析：%v", err) + } + + // 一个不存在的 id：GetRoute 会回退到 default_route，解析结果不是它。 + got, err := config.GetRoute("audio_route_nope_not_defined") + if err != nil { + t.Fatalf("用例前提：GetRoute 对未知 id 会回退默认路由，不该报错：%v", err) + } + if got.RouteID == "audio_route_nope_not_defined" { + t.Skip("前提不成立：该 id 竟然被解析成了自己") + } + + if err := assertRouteResolvedAsRequested(got, "audio_route_nope_not_defined"); err == nil { + t.Fatalf("未知 id 解析成了 %s，守卫却放行了", got.RouteID) + } else if !strings.Contains(err.Error(), got.RouteID) { + // 报错要说明「解析成了谁」，否则排查时看不出是回退造成的。 + t.Errorf("报错没带上实际解析到的路由 %s：%v", got.RouteID, err) + } + + // 正常情况：解析结果就是请求的那条。 + if err := assertRouteResolvedAsRequested(route, route.RouteID); err != nil { + t.Errorf("请求自己的 id 被拦了：%v", err) + } +} + +// TestAssertRouteResolvedAsRequestedAllowsAutoIds 「自动」占位 id 必须放行。 +// +// 拦下来会让通路测试里的「自动」选项直接报「路由不存在」—— +// 而它恰恰是最该能测的一项（它就是线上真正在走的那条）。 +// +// 这里用构造出来的路由，**不**去 config 里解析 auto id：解析会触发 +// resolveAutoRoute → 健康巡检，而 chat 的巡检是真的发一次 /chat/completions， +// 单测不该去打云端的计费接口。守卫的契约只跟 id 的字面量有关。 +func TestAssertRouteResolvedAsRequestedAllowsAutoIds(t *testing.T) { + resolved := &config.RouteConfig{RouteID: "chat_route_lmuai_deepseek_v4_flash", Category: "chat"} + for _, id := range []string{config.AutoChatRouteID, config.AutoEmbedRouteID, config.AutoAudioRouteID} { + if err := assertRouteResolvedAsRequested(resolved, id); err != nil { + t.Errorf("%s 被守卫拦下了：%v", id, err) + } + } +} + +func TestAssertRouteResolvedAsRequestedRejectsNil(t *testing.T) { + if err := assertRouteResolvedAsRequested(nil, "whatever"); err == nil { + t.Error("nil 路由应当报错") + } +} diff --git a/eai_agentplatform/backend-go/internal/api/assistant_opening.go b/eai_agentplatform/backend-go/internal/api/assistant_opening.go new file mode 100644 index 0000000..8be62e2 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/api/assistant_opening.go @@ -0,0 +1,67 @@ +package api + +import ( + "encoding/json" + + "github.com/gin-gonic/gin" + + generalassistant "eai_agentplatform/backend/internal/specialists/packages/general_assistant" + "eai_agentplatform/backend/internal/web" +) + +// OpeningCard 通用助手开场白身份（单一事实源在后端 InteractionCardJSON）。 +type OpeningCard struct { + Label string `json:"label"` + Meta string `json:"meta"` + Greeting string `json:"greeting"` + Tagline string `json:"tagline"` + OpeningPrompt string `json:"opening_prompt"` + StarterPrompts []string `json:"starter_prompts"` +} + +// GetAssistantOpening GET /api/assistant/opening —— 通用助手开场白身份。 +// +// 为什么单独一个端点而不是走专员列表：通用助手（state=system）按设计不出现在 +// 专员列表/市场上，但它的开场白是对话工作台的欢迎画面数据源。后端 InteractionCardJSON +// 是唯一事实源，前端不再硬编码开场白。 +func GetAssistantOpening(c *gin.Context) { + // 从通用助手 manifest 读取开场白身份（单一事实源）。 + card := parseOpeningCard(generalassistant.Manifest.InteractionCardJSON) + card.Label = generalassistant.Manifest.Label + web.OK(c, card) +} + +// parseOpeningCard 解析 InteractionCardJSON 为 OpeningCard，缺字段给默认兜底。 +func parseOpeningCard(raw string) OpeningCard { + card := OpeningCard{ + Meta: "默认专员 · 通用协作", + Greeting: "博昇AI数字员工，您说，我做", + } + if raw == "" { + return card + } + var m map[string]any + if err := json.Unmarshal([]byte(raw), &m); err != nil { + return card + } + if v, ok := m["greeting"].(string); ok && v != "" { + card.Greeting = v + } + if v, ok := m["tagline"].(string); ok && v != "" { + card.Tagline = v + } + if v, ok := m["opening_prompt"].(string); ok && v != "" { + card.OpeningPrompt = v + } + if v, ok := m["relationship_to_user"].(string); ok && v != "" { + card.Meta = v + } + if v, ok := m["starter_prompts"].([]any); ok { + for _, item := range v { + if s, ok := item.(string); ok { + card.StarterPrompts = append(card.StarterPrompts, s) + } + } + } + return card +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/api/audio_routes_endpoint_test.go b/eai_agentplatform/backend-go/internal/api/audio_routes_endpoint_test.go new file mode 100644 index 0000000..cb0ad30 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/api/audio_routes_endpoint_test.go @@ -0,0 +1,79 @@ +package api + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "testing" +) + +// GET /api/ai/routes/audio 的真实请求验证。 +// +// 走的是真路由 + 真中间件（复用 audioRouteFixture 起的 gin 引擎），不是直接调 +// handler 函数 —— 「go test 全绿测不到 handler」在这里尤其成立：这个接口的意义 +// 就是「语音路由能在后台像 chat/embed 一样被列出来」，只有真发一次请求才验得到 +// 注册、鉴权、序列化这三段。 +// +// 断言不依赖本机 8090 起没起：列出来的是**配置**里的路由，健康字段另算。 +func TestListAudioRoutesEndpoint(t *testing.T) { + fx := newAudioRouteFixture(t) + + req := httptest.NewRequest(http.MethodGet, "/api/ai/routes/audio", nil) + rec := httptest.NewRecorder() + fx.engine.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + t.Fatalf("GET /api/ai/routes/audio = %d，期望 200；body=%s", rec.Code, rec.Body.String()) + } + + var body struct { + Data struct { + Routes []struct { + AIRouteID string `json:"ai_route_id"` + Provider string `json:"provider"` + Model string `json:"model"` + BaseURL string `json:"base_url"` + IsLocal bool `json:"is_local"` + ResolvedAIRouteID string `json:"resolved_ai_route_id"` + } `json:"routes"` + } `json:"data"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { + t.Fatalf("响应不是预期结构：%v；body=%s", err, rec.Body.String()) + } + routes := body.Data.Routes + if len(routes) == 0 { + t.Fatal("routes 为空 —— 语音路由没有出现在后台列表里") + } + + var sawAuto, sawLocal bool + for _, r := range routes { + // id 前缀是这条路由属于哪个分类的唯一外部可见证据（routeItem 不带 category）。 + // 混进一条 chat 路由就会在这里红 —— 那正是 GetRoute 回退 default_route 的症状。 + if !strings.HasPrefix(r.AIRouteID, "audio_route") { + t.Errorf("列表里出现了非语音路由 %q（provider=%s base_url=%s）", r.AIRouteID, r.Provider, r.BaseURL) + } + if r.Model == "" { + t.Errorf("%s 的 model 为空 —— 前台选它之后会拿空模型名去转写", r.AIRouteID) + } + if r.AIRouteID == "audio_route_auto" { + sawAuto = true + if !strings.HasPrefix(r.ResolvedAIRouteID, "audio_route") { + t.Errorf("「自动」解析到了 %q —— 不是语音路由", r.ResolvedAIRouteID) + } + } + if r.IsLocal { + sawLocal = true + if !strings.Contains(r.BaseURL, "127.0.0.1") && !strings.Contains(r.BaseURL, "localhost") { + t.Errorf("%s 被判为本地，base_url 却是 %q", r.AIRouteID, r.BaseURL) + } + } + } + if !sawAuto { + t.Error("列表里没有 audio_route_auto —— 后台就选不了「自动」") + } + if !sawLocal { + t.Error("列表里没有一条 is_local=true 的路由 —— 界面无法标出「本地」") + } +} diff --git a/eai_agentplatform/backend-go/internal/api/audio_skill_route_test.go b/eai_agentplatform/backend-go/internal/api/audio_skill_route_test.go new file mode 100644 index 0000000..918cc67 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/api/audio_skill_route_test.go @@ -0,0 +1,516 @@ +package api + +import ( + "bytes" + "encoding/json" + "fmt" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/gin-gonic/gin" + + "eai_agentplatform/backend/internal/auth" + "eai_agentplatform/backend/internal/config" + "eai_agentplatform/backend/internal/dal" + "eai_agentplatform/backend/internal/model" + specialistruntime "eai_agentplatform/backend/internal/specialists/runtime" + "eai_agentplatform/backend/internal/store" +) + +// TestMain 定位 backend-go 并切换工作目录，让 config/ai_config.json 在测试进程内 +// 可被找到（configDir() 的回退逻辑依赖 CWD/config）。 +func TestMain(m *testing.M) { + if base := locateBackendGoForTest(); base != "" { + _ = os.Chdir(base) + } + os.Exit(m.Run()) +} + +// locateBackendGoForTest 从当前工作目录向上找含 config/ai_config.json 的目录。 +func locateBackendGoForTest() string { + dir, err := os.Getwd() + if err != nil { + return "" + } + for { + if _, err := os.Stat(filepath.Join(dir, "config", "ai_config.json")); err == nil { + return dir + } + parent := filepath.Dir(dir) + if parent == dir { + return "" + } + dir = parent + } +} + +// audioRouteFixture 一套跑真实路由的测试环境：临时库 + 临时 KB 目录 + 两个用户 + 任务 + 音频素材。 +// +// 全部落在 t.TempDir() 下，绝不碰 data/ 里的真实库与素材。 +type audioRouteFixture struct { + engine *gin.Engine + token string + other string // 另一个用户的令牌（用于越权用例） + taskID uint + media uint + rawURL string // 素材的落盘路径，负路径用例要用 +} + +func newAudioRouteFixture(t *testing.T) *audioRouteFixture { + t.Helper() + gin.SetMode(gin.TestMode) + + dir := t.TempDir() + dbPath := filepath.Join(dir, "test.db") + + prevDB := store.DB + prevDalDB := dal.DB + prevCfg := Cfg + db, err := store.Init(dbPath) + if err != nil { + t.Fatalf("初始化测试库失败: %v", err) + } + // dal.DB 是在 dal 包 init() 时从 store.DB 抄过去的，那时 store.DB 还是 nil。 + // 测试里换了库必须同步，否则零值仓库（dal.MediaFileDAO{} 这类）会解引用 nil。 + dal.SetDB(db) + t.Cleanup(func() { + store.DB = prevDB + dal.SetDB(prevDalDB) + Cfg = prevCfg + }) + + kbDir := filepath.Join(dir, "kb_data") + approved := filepath.Join(kbDir, "approved") + if err := os.MkdirAll(approved, 0o755); err != nil { + t.Fatalf("创建素材目录失败: %v", err) + } + + // KB_DATA_DIR 必须**同时**指到临时目录，光在上面那个 cfg 里写不够。 + // + // 技能包（skills/packages/audio_transcribe）读的是 config.Load().KBDataDir， + // 不是 RegisterRoutes 收到的那份 cfg —— 它跨了包，拿不到 api.Cfg，这是分层使然， + // 生产里两者同源于环境变量所以一致，测试里却必须自己对齐。 + // + // 不对齐的后果有两个，第二个更要命： + // 1) config.Load() 会走 backendBaseDir()，测试二进制在 /tmp/go-buildXXXXXX/b001/ + // 下，于是素材目录变成 go-build 的临时目录 —— 第 2 步会以一句 + // 「读取音频文件失败：no such file or directory」失败，跟转写本身毫无关系； + // 2) 万一哪天推出来的正好是真实的 data/，这个用例就会去读**用户的素材**。 + // 所以这里不只设置，还当场断言它真的生效了。 + t.Setenv("KB_DATA_DIR", kbDir) + if resolved := config.Load().KBDataDir; resolved != kbDir { + t.Fatalf("KB_DATA_DIR 没有生效：config.Load() 得到 %q，期望 %q", resolved, kbDir) + } + // 先写一个假的 mp3：只有 scope 步骤读它（用 ffprobe 探时长，探不出就走「未知」分支）。 + // 真正的转写用例会把 ASR_TEST_AUDIO 拷进来覆盖。 + stored := "audio_route_test.mp3" + if err := os.WriteFile(filepath.Join(approved, stored), []byte("ID3-fake-audio"), 0o644); err != nil { + t.Fatalf("写入测试音频失败: %v", err) + } + + owner := model.User{Username: "asr_owner", FullName: "转写测试员", Role: "employee", Status: "active"} + intruder := model.User{Username: "asr_intruder", FullName: "路人甲", Role: "employee", Status: "active"} + if err := store.DB.Create(&owner).Error; err != nil { + t.Fatalf("创建用户失败: %v", err) + } + if err := store.DB.Create(&intruder).Error; err != nil { + t.Fatalf("创建用户失败: %v", err) + } + + task := model.TaskRecord{ + SpecialistKey: "general-assistant", + Title: "转写", + Owner: owner.FullName, + Status: specialistruntime.TaskStatusDraft, + CreatedBy: &owner.ID, + } + if err := store.DB.Create(&task).Error; err != nil { + t.Fatalf("创建任务失败: %v", err) + } + + media := model.MediaFile{ + Filename: "20260925_094810.mp3", + StoredName: stored, + StoredPath: stored, + FileExt: "mp3", + FileSize: 15, + Status: "approved", + Source: "employee", + SubmitterID: owner.ID, + } + if err := store.DB.Create(&media).Error; err != nil { + t.Fatalf("创建素材失败: %v", err) + } + + cfg := &config.Config{ + DBPath: dbPath, + KBDataDir: kbDir, + NetdiskDataDir: filepath.Join(dir, "netdisk"), + JWTSecret: "audio-route-test-secret", + JWTExpireMin: 60, + } + engine := gin.New() + RegisterRoutes(engine, cfg) + + ownerToken, err := auth.CreateToken(owner.Username, owner.Role, cfg.JWTSecret, cfg.JWTExpireMin) + if err != nil { + t.Fatalf("签发令牌失败: %v", err) + } + intruderToken, err := auth.CreateToken(intruder.Username, intruder.Role, cfg.JWTSecret, cfg.JWTExpireMin) + if err != nil { + t.Fatalf("签发令牌失败: %v", err) + } + + fx := &audioRouteFixture{ + engine: engine, + token: ownerToken, + other: intruderToken, + taskID: task.ID, + media: media.ID, + rawURL: filepath.Join(approved, stored), + } + return fx +} + +// post 发一次真实 HTTP 请求（走 gin 引擎与真实鉴权中间件）。 +func (fx *audioRouteFixture) post(t *testing.T, token, path string, body gin.H) (int, map[string]any) { + t.Helper() + payload, _ := json.Marshal(body) + req := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(payload)) + req.Header.Set("Content-Type", "application/json") + if token != "" { + req.Header.Set("Authorization", "Bearer "+token) + } + rec := httptest.NewRecorder() + fx.engine.ServeHTTP(rec, req) + + var decoded map[string]any + if err := json.Unmarshal(rec.Body.Bytes(), &decoded); err != nil { + t.Fatalf("%s 返回的不是 JSON：%s", path, rec.Body.String()) + } + return rec.Code, decoded +} + +// dataOf 取出响应信封里的 data 段。 +func dataOf(t *testing.T, body map[string]any) map[string]any { + t.Helper() + data, ok := body["data"].(map[string]any) + if !ok { + t.Fatalf("响应没有 data 段：%v", body) + } + return data +} + +// errorMessageOf 取出错误信封里的用户可见消息。 +func errorMessageOf(t *testing.T, body map[string]any) string { + t.Helper() + msg, _ := body["message"].(string) + return msg +} + +// TestAudioSkillScopeStepWritesRunAndArtifact 是「工作流 x/4 会不会动」的根： +// 第 1 步必须真的落一条 action_key = audio-transcribe:scope 的 task_run 与一条产物， +// 否则右栏的计数与产物区永远停在原地（这正是用户报的现象）。 +func TestAudioSkillScopeStepWritesRunAndArtifact(t *testing.T) { + fx := newAudioRouteFixture(t) + + code, body := fx.post(t, fx.token, "/api/skills/audio/scope", gin.H{ + "task_id": fx.taskID, + "media_id": fx.media, + "language": "zh", + }) + if code != http.StatusOK { + t.Fatalf("scope 步骤返回 %d：%s", code, errorMessageOf(t, body)) + } + data := dataOf(t, body) + if got := data["action_key"]; got != "audio-transcribe:scope" { + t.Errorf("action_key = %v，期望 audio-transcribe:scope", got) + } + + var runs []model.TaskRun + store.DB.Where("task_id = ?", fx.taskID).Find(&runs) + if len(runs) != 1 { + t.Fatalf("task_run 数 = %d，期望 1", len(runs)) + } + if runs[0].ActionKey != "audio-transcribe:scope" || runs[0].Status != "done" { + t.Errorf("task_run 落库不对：action_key=%q status=%q", runs[0].ActionKey, runs[0].Status) + } + + var artifacts []model.TaskArtifact + store.DB.Where("task_id = ?", fx.taskID).Find(&artifacts) + if len(artifacts) != 1 { + t.Fatalf("task_artifact 数 = %d，期望 1", len(artifacts)) + } + if artifacts[0].ArtifactType != "text" || artifacts[0].Title != "转写要求" { + t.Errorf("产物不对：type=%q title=%q", artifacts[0].ArtifactType, artifacts[0].Title) + } + if strings.TrimSpace(artifacts[0].ContentText) == "" { + t.Error("产物正文为空 —— 右栏点开会是一片空白") + } + if artifacts[0].CreatedByRunID == nil || *artifacts[0].CreatedByRunID != runs[0].ID { + t.Error("产物的 created_by_run_id 没有指向本次 run —— 右栏按 run 取产物会取不到") + } + + var task model.TaskRecord + store.DB.First(&task, fx.taskID) + if strings.TrimSpace(task.CurrentResult) == "" { + t.Error("task.current_result 为空") + } + if task.CurrentRunID == nil || *task.CurrentRunID != runs[0].ID { + t.Error("task.current_run_id 没有指向本次 run") + } +} + +// TestAudioSkillKeepsStepsIndependent 断言第二步不会把第一步的 run 顶掉： +// 四步各写各的 run，前端才数得出 x/4。 +func TestAudioSkillKeepsStepsIndependent(t *testing.T) { + fx := newAudioRouteFixture(t) + + if code, body := fx.post(t, fx.token, "/api/skills/audio/scope", gin.H{ + "task_id": fx.taskID, "media_id": fx.media, + }); code != http.StatusOK { + t.Fatalf("scope 返回 %d：%s", code, errorMessageOf(t, body)) + } + // 第 3 步依赖第 2 步的产物，这里没有，必须报错且不留痕。 + code, body := fx.post(t, fx.token, "/api/skills/audio/structure", gin.H{"task_id": fx.taskID}) + if code != http.StatusBadRequest { + t.Fatalf("缺上一步产物时 structure 返回 %d，期望 400：%v", code, body) + } + if msg := errorMessageOf(t, body); !strings.Contains(msg, "逐字转写稿") { + t.Errorf("报错没有点明缺哪一份产物：%q", msg) + } + + var count int64 + store.DB.Model(&model.TaskRun{}).Where("task_id = ?", fx.taskID).Count(&count) + if count != 1 { + t.Errorf("失败的那一步也落了 run（task_run 数 = %d，期望仍是 1）—— 会出现假进度", count) + } + store.DB.Model(&model.TaskArtifact{}).Where("task_id = ?", fx.taskID).Count(&count) + if count != 1 { + t.Errorf("失败的那一步也落了产物（task_artifact 数 = %d，期望仍是 1）", count) + } +} + +// TestAudioSkillRejectsForeignTaskAndMedia 是两条越权路径： +// 别人的任务不能借我的令牌跑，别人的录音也不能拿来转写。 +func TestAudioSkillRejectsForeignTaskAndMedia(t *testing.T) { + fx := newAudioRouteFixture(t) + + code, body := fx.post(t, fx.other, "/api/skills/audio/scope", gin.H{ + "task_id": fx.taskID, "media_id": fx.media, + }) + if code != http.StatusNotFound { + t.Errorf("拿别人的任务调接口返回 %d，期望 404：%v", code, body) + } + + code, body = fx.post(t, fx.token, "/api/skills/audio/scope", gin.H{ + "task_id": fx.taskID, "media_id": 999999, + }) + if code != http.StatusBadRequest { + t.Errorf("不存在的 media_id 返回 %d，期望 400：%v", code, body) + } + if msg := errorMessageOf(t, body); !strings.Contains(msg, "不存在") { + t.Errorf("报错没有点明素材不存在：%q", msg) + } +} + +// TestAudioSkillRejectsMissingParams 断言缺 task_id / media_id 时的报错是可读的， +// 而不是走到一半 panic 或静默返回空稿。 +func TestAudioSkillRejectsMissingParams(t *testing.T) { + fx := newAudioRouteFixture(t) + + code, body := fx.post(t, fx.token, "/api/skills/audio/scope", gin.H{"media_id": fx.media}) + if code != http.StatusBadRequest || !strings.Contains(errorMessageOf(t, body), "task_id") { + t.Errorf("缺 task_id 的响应不对：%d %v", code, body) + } + + code, body = fx.post(t, fx.token, "/api/skills/audio/scope", gin.H{"task_id": fx.taskID}) + if code != http.StatusBadRequest || !strings.Contains(errorMessageOf(t, body), "media_id") { + t.Errorf("缺 media_id 的响应不对：%d %v", code, body) + } +} + +// TestAudioSkillRequiresAuth 断言六个端点都挂了鉴权中间件，不是裸奔的。 +// +// 逐个列出来而不是循环拼前缀：路由表是**写死**在 router.go 里的， +// 真要防的正是「新加了一个端点却忘了挂中间件」—— 用循环拼出来的话， +// 新端点只要不进这个列表就永远测不到。 +func TestAudioSkillRequiresAuth(t *testing.T) { + fx := newAudioRouteFixture(t) + for _, path := range []string{ + "/api/skills/audio/scope", + "/api/skills/audio/transcribe", + "/api/skills/audio/speakers", + "/api/skills/audio/speakers/confirm", + "/api/skills/audio/structure", + "/api/skills/audio/minutes", + } { + code, _ := fx.post(t, "", path, gin.H{"task_id": fx.taskID}) + if code != http.StatusUnauthorized { + t.Errorf("%s 未带令牌返回 %d，期望 401", path, code) + } + } +} + +// TestAudioSkillFourStepsEndToEnd 跑完整四步，断言「工作流 4/4」真的能走满。 +// +// 默认跳过：第 2 步会把音频发到云端 ASR（当前路由是 SiliconFlow），且会真的消耗额度。 +// 显式给音频路径才跑： +// +// ASR_TEST_AUDIO=/tmp/asr_two_speakers.mp3 go test ./internal/api/ -run TestAudioSkillFourStepsEndToEnd -v +func TestAudioSkillFourStepsEndToEnd(t *testing.T) { + audioPath := os.Getenv("ASR_TEST_AUDIO") + if audioPath == "" { + t.Skip("未设置 ASR_TEST_AUDIO，跳过真实转写的四步端到端测试") + } + source, err := os.ReadFile(audioPath) + if err != nil { + t.Fatalf("读取测试音频失败: %v", err) + } + + fx := newAudioRouteFixture(t) + if err := os.WriteFile(fx.rawURL, source, 0o644); err != nil { + t.Fatalf("替换测试音频失败: %v", err) + } + + steps := []string{"scope", "transcribe", "structure", "minutes"} + wantActions := []string{ + "audio-transcribe:scope", + "audio-transcribe:transcribe", + "audio-transcribe:structure", + "audio-transcribe:minutes", + } + wantTypes := []string{"text", "transcript", "document", "checklist"} + + for index, step := range steps { + body := gin.H{"task_id": fx.taskID} + if step == "scope" || step == "transcribe" { + body["media_id"] = fx.media + body["language"] = "zh" + } else { + // 空串 = 界面上没选模型，走技能自带那条大预算路由（不是 default_route）。 + // 传空串而非写死某条路由 id，是为了让这条端到端验的正是线上默认走法。 + body["ai_route_id"] = "" + } + code, resp := fx.post(t, fx.token, "/api/skills/audio/"+step, body) + if code != http.StatusOK { + t.Fatalf("第 %d 步 %s 返回 %d：%s", index+1, step, code, errorMessageOf(t, resp)) + } + data := dataOf(t, resp) + if got := data["action_key"]; got != wantActions[index] { + t.Errorf("第 %d 步 action_key = %v，期望 %s", index+1, got, wantActions[index]) + } + if content, _ := data["content"].(string); strings.TrimSpace(content) == "" { + t.Errorf("第 %d 步 %s 的内容为空", index+1, step) + } + t.Logf("第 %d 步 %s 完成：%v", index+1, step, data["summary"]) + } + + var runs []model.TaskRun + store.DB.Where("task_id = ?", fx.taskID).Order("id ASC").Find(&runs) + if len(runs) != 4 { + t.Fatalf("task_run 数 = %d，期望 4（右栏 x/4 走不满）", len(runs)) + } + for index, run := range runs { + if run.ActionKey != wantActions[index] { + t.Errorf("第 %d 条 run 的 action_key = %q，期望 %q", index+1, run.ActionKey, wantActions[index]) + } + } + + var artifacts []model.TaskArtifact + store.DB.Where("task_id = ?", fx.taskID).Order("id ASC").Find(&artifacts) + if len(artifacts) != 4 { + t.Fatalf("task_artifact 数 = %d，期望 4", len(artifacts)) + } + for index, artifact := range artifacts { + if artifact.ArtifactType != wantTypes[index] { + t.Errorf("第 %d 个产物 type = %q，期望 %q", index+1, artifact.ArtifactType, wantTypes[index]) + } + if strings.TrimSpace(artifact.ContentText) == "" { + t.Errorf("第 %d 个产物（%s）正文为空", index+1, artifact.Title) + } + t.Logf("产物 %d：%s / %s（%d 字）", index+1, artifact.Title, artifact.ArtifactType, + len([]rune(artifact.ContentText))) + } + fmt.Printf("四步端到端完成：%d runs / %d artifacts\n", len(runs), len(artifacts)) +} + +// TestAudioSkillLLMStepsAcceptAutoRoute 验第 3、4 步在「界面上选的是自动路由」时也能跑通。 +// +// 为什么单独一条：界面把 selectedAiChatRouteId 原样当 ai_route_id 传下来，而它的默认值 +// 是 chat_route_auto —— 一个**虚拟路由 id**，在 ai_config.json 的 chat_routes 里查不到 +// 同名条目（GetRoute 见到它才转去 resolveAutoRoute）。resolveAudioChatRoute 要是只做 +// 「表里找不找得到」的检查，用户一进页面（没手动切过线路）就会撞上「分类不是 chat」。 +// 这里用真实请求把这条路径钉死，而不是靠读代码推断。 +// +// 第 2 步不在这里：ASR 要真实音频，见 TestAudioSkillFourStepsEndToEnd。 +// 本用例直接往库里种一份逐字稿，把「取上一步产物 → 调 LLM → 落库」这条链路单独验掉。 +// +// 默认跳过（会真的调 LLM，消耗额度）： +// +// AUDIO_SKILL_LLM_TEST=1 go test ./internal/api/ -run TestAudioSkillLLMStepsAcceptAutoRoute -v +func TestAudioSkillLLMStepsAcceptAutoRoute(t *testing.T) { + if os.Getenv("AUDIO_SKILL_LLM_TEST") == "" { + t.Skip("未设置 AUDIO_SKILL_LLM_TEST，跳过真实调用 LLM 的第 3/4 步测试") + } + + fx := newAudioRouteFixture(t) + + // 种一份逐字稿，替代第 2 步。内容刻意带两个人的对话，好看出模型有没有真的读懂。 + transcript := strings.Join([]string{ + "【00:00 说话人1】我们先过一下这周的进度，主要是三件事：素材审批、知识库检索、还有转写。", + "【00:12 说话人2】素材审批这块我这边周四之前能提测，但还差一个驳回理由的必填校验。", + "【00:35 说话人1】那就周四提测，驳回理由必填这周必须加上，不然审批记录看不出来为什么退。", + "【01:02 说话人2】转写我建议先用云端跑通，本地 whisper 的部署下周再排。", + "【01:20 说话人1】同意，云端先跑通，但配置要能一键切回本地，不能写死。", + }, "\n") + seeded := model.TaskArtifact{ + TaskID: fx.taskID, + Title: "逐字转写稿", + ArtifactType: "transcript", + ContentText: transcript, + Status: specialistruntime.ArtifactStatusDraft, + } + if err := store.DB.Create(&seeded).Error; err != nil { + t.Fatalf("种入逐字稿失败: %v", err) + } + + wantActions := map[string]string{ + "structure": "audio-transcribe:structure", + "minutes": "audio-transcribe:minutes", + } + for _, step := range []string{"structure", "minutes"} { + code, body := fx.post(t, fx.token, "/api/skills/audio/"+step, gin.H{ + "task_id": fx.taskID, + "ai_route_id": "chat_route_auto", + }) + if code != http.StatusOK { + t.Fatalf("%s 返回 %d：%s", step, code, errorMessageOf(t, body)) + } + data := dataOf(t, body) + if got := data["action_key"]; got != wantActions[step] { + t.Errorf("%s 的 action_key = %v，期望 %s", step, got, wantActions[step]) + } + content, _ := data["content"].(string) + if strings.TrimSpace(content) == "" { + t.Errorf("%s 的正文为空 —— 右栏产物点开会是空白", step) + } + t.Logf("%s 完成：%v（正文 %d 字）", step, data["summary"], len([]rune(content))) + } + + var runs []model.TaskRun + store.DB.Where("task_id = ?", fx.taskID).Order("id ASC").Find(&runs) + if len(runs) != 2 { + t.Fatalf("task_run 数 = %d，期望 2（只跑了第 3、4 步）", len(runs)) + } + for index, run := range runs { + want := []string{wantActions["structure"], wantActions["minutes"]}[index] + if run.ActionKey != want { + t.Errorf("第 %d 条 run 的 action_key = %q，期望 %q", index+1, run.ActionKey, want) + } + } +} diff --git a/eai_agentplatform/backend-go/internal/api/audio_speaker_confirm_test.go b/eai_agentplatform/backend-go/internal/api/audio_speaker_confirm_test.go new file mode 100644 index 0000000..895e03d --- /dev/null +++ b/eai_agentplatform/backend-go/internal/api/audio_speaker_confirm_test.go @@ -0,0 +1,309 @@ +package api + +import ( + "fmt" + "net/http" + "strings" + "testing" + + "github.com/gin-gonic/gin" + + "eai_agentplatform/backend/internal/model" + specialistruntime "eai_agentplatform/backend/internal/specialists/runtime" + "eai_agentplatform/backend/internal/store" +) + +// 这一组用例走**真实路由 + 真实鉴权中间件**，钉住「核对说话人姓名」这条流程的接口面。 +// +// 为什么不能只测函数：这道闸门与确认端点分处两层，中间还隔着 gin 的绑定与鉴权。 +// 只测函数的话，路由少注册一行、或 handler 里少调一次闸门，函数级的用例全绿而 +// 线上照样能越过确认 —— 仓库里已有的教训（go test 全绿测不到 handler）。 + +// seedTranscriptAndSpeakers 在任务下铺好「已经转写完、身份已推断待确认」的现场。 +// +// 这个现场是这一步的**全部前提**：没有逐字稿，第 3 步根本跑不起来； +// 没有名单，就没什么可确认的。现场由用例自己铺，而不是靠先跑一遍真转写 —— +// 那会把云端 ASR 拉进单元测试。 +func seedTranscriptAndSpeakers(t *testing.T, taskID uint, speakersJSON string) model.TaskArtifact { + t.Helper() + + transcript := model.TaskArtifact{ + TaskID: taskID, + SpecialistKey: "general-assistant", + Title: "逐字转写稿", + ArtifactType: "transcript", + Status: specialistruntime.ArtifactStatusDraft, + ContentText: "说话人 0：这个方案我同意。\n说话人 1：我也同意。", + ContentJSON: `{"segments":[{"speaker":"0","text":"这个方案我同意。"},` + + `{"speaker":"1","text":"我也同意。"}]}`, + } + if err := store.DB.Create(&transcript).Error; err != nil { + t.Fatalf("铺逐字稿失败：%v", err) + } + + speakers := model.TaskArtifact{ + TaskID: taskID, + SpecialistKey: "general-assistant", + Title: "说话人名单", + ArtifactType: "speakers", + Status: specialistruntime.ArtifactStatusReady, + ContentText: "## 说话人名单（AI 推断，待确认）\n", + ContentJSON: speakersJSON, + } + if err := store.DB.Create(&speakers).Error; err != nil { + t.Fatalf("铺说话人名单失败：%v", err) + } + return speakers +} + +// 一份两人名单，形状与 runAudioSpeakersStep 写进 ContentJSON 的一致。 +const twoSpeakersJSON = `{"source_type":"transcript","speakers":[` + + `{"key":"0","org":"某某局","title":"处长","name":"张三","evidence":"我是某某局的张三"},` + + `{"key":"1","title":"记录员","name":"","evidence":""}]}` + +// TestAudioSpeakersGateBlocksStructureThroughRealRoute 是这道闸门的**真身**用例： +// 名单还是「待确认」时，直接把第 5 步的请求打进去，必须被拦住且不留痕。 +// +// 拦住的是「绕过前端」这条路：前端把按钮灰掉只是 UX，请求照样能构造出来。 +// 而这里要防的后果是「没人核对过，AI 猜的身份被当成事实写进正式纪要」。 +func TestAudioSpeakersGateBlocksStructureThroughRealRoute(t *testing.T) { + fx := newAudioRouteFixture(t) + seedTranscriptAndSpeakers(t, fx.taskID, twoSpeakersJSON) + + code, body := fx.post(t, fx.token, "/api/skills/audio/structure", gin.H{ + "task_id": fx.taskID, + }) + if code != http.StatusBadRequest { + t.Fatalf("名单未确认时 structure 返回 %d，期望 400：%v", code, body) + } + if msg := errorMessageOf(t, body); !strings.Contains(msg, "确认") { + t.Errorf("报错没有点明要先确认说话人身份：%q", msg) + } + + // 被拦住的那一步不许留痕：落了 run 会让右栏的「工作流 x/6」凭空往前走一格， + // 显示成「已经整理过了」，而实际上一个字都没生成。 + var runs int64 + store.DB.Model(&model.TaskRun{}).Where("task_id = ?", fx.taskID).Count(&runs) + if runs != 0 { + t.Errorf("被闸门拦下的那一步落了 %d 条 task_run，期望 0 —— 会出现假进度", runs) + } +} + +// TestAudioSpeakersConfirmUnlocksAndRecordsDecision 走一遍完整确认： +// 提交一份改过一处的名单 → 产物转 approved、写一条确认 run、任务不再是「待确认」， +// 且**每一位的 decided_by 由服务端算出来**（改过的那位 user_edited，没改的 +// user_confirmed）。 +// +// decided_by 是这条流程的留痕：事后要能回答「这份稿子里的身份，哪些是人拍板的、 +// 哪些是机器猜的」。让客户端自报这个标志位是无法核验的，所以这里连 +// 「客户端硬塞一个 decided_by」的情形一起钉住。 +func TestAudioSpeakersConfirmUnlocksAndRecordsDecision(t *testing.T) { + fx := newAudioRouteFixture(t) + seedTranscriptAndSpeakers(t, fx.taskID, twoSpeakersJSON) + + code, body := fx.post(t, fx.token, "/api/skills/audio/speakers/confirm", gin.H{ + "task_id": fx.taskID, + "speakers": []gin.H{ + // 一字未改，还带上一个客户端自报的 decided_by —— 必须被服务端覆盖掉。 + {"key": "0", "org": "某某局", "title": "处长", "name": "张三", + "decided_by": "user_confirmed"}, + // 用户把「记录员」改成了真名。 + {"key": "1", "title": "记录员", "name": "李四"}, + }, + }) + if code != http.StatusOK { + t.Fatalf("确认返回 %d：%s", code, errorMessageOf(t, body)) + } + data := dataOf(t, body) + if got := data["action_key"]; got != "audio-transcribe:speakers-confirm" { + t.Errorf("action_key = %v，期望 audio-transcribe:speakers-confirm", got) + } + + var run model.TaskRun + if err := store.DB.Where("task_id = ? AND action_key = ?", fx.taskID, + "audio-transcribe:speakers-confirm").First(&run).Error; err != nil { + t.Fatalf("没有落下确认这一步的 task_run：%v", err) + } + + var artifact model.TaskArtifact + if err := store.DB.Where("task_id = ? AND artifact_type = ?", fx.taskID, "speakers"). + Order("id DESC").First(&artifact).Error; err != nil { + t.Fatalf("读不到说话人名单产物：%v", err) + } + if artifact.Status != specialistruntime.ArtifactStatusApproved { + t.Errorf("确认后产物状态 = %q，期望 %q", artifact.Status, specialistruntime.ArtifactStatusApproved) + } + if !strings.Contains(artifact.ContentText, "已确认") { + t.Errorf("确认后的产物正文没有标记为已确认：\n%s", artifact.ContentText) + } + if artifact.CreatedByRunID != nil && *artifact.CreatedByRunID == run.ID { + // 产物是第 3 步写的，确认这一步只改状态、不新造产物。若指向了确认这条 run， + // 说明有人把它当新产物重建了 —— 右栏会出现两份同名产物。 + t.Error("确认这一步重建了产物，而不是就地改状态") + } + + var task model.TaskRecord + store.DB.First(&task, fx.taskID) + if task.Status == specialistruntime.TaskStatusPendingReview { + t.Error("确认之后任务还停在「待确认」") + } + if task.Status != specialistruntime.TaskStatusDraft { + t.Errorf("确认后任务状态 = %q，期望 %q（还有整理与纪要两步没跑）", + task.Status, specialistruntime.TaskStatusDraft) + } + + // 服务端算出来的 decided_by：改过的 user_edited，没改的 user_confirmed。 + speakers, _ := data["speakers"].([]any) + if len(speakers) != 2 { + t.Fatalf("返回的名单有 %d 位，期望 2", len(speakers)) + } + byKey := map[string]map[string]any{} + for _, item := range speakers { + entry, _ := item.(map[string]any) + byKey[asText(entry["key"])] = entry + } + if got := asText(byKey["0"]["decided_by"]); got != "user_confirmed" { + t.Errorf("说话人 0 一字未改，decided_by = %q，期望 user_confirmed", got) + } + if got := asText(byKey["1"]["decided_by"]); got != "user_edited" { + t.Errorf("说话人 1 被改过，decided_by = %q，期望 user_edited", got) + } + // Evidence 是 AI 给的依据。客户端没提交它，服务端要从库里那份带回来 —— + // 它正是用户核对时唯一的凭据。 + if got := asText(byKey["0"]["evidence"]); got != "我是某某局的张三" { + t.Errorf("依据没有从库里带回来：%q", got) + } +} + +// TestAudioSpeakersConfirmRejectsMismatchedKeys 钉住「名单必须与稿里的人一一对应」。 +// +// 多一个：凭空多出一位不存在的与会者，下游替换会把一个没人说过的名字写进稿子。 +// 少一个：那位被静默漏掉，稿子里留着「说话人 1」而没人会注意到。 +// 两种都不能靠「前端不会这么传」来防 —— 请求是可以构造的。 +func TestAudioSpeakersConfirmRejectsMismatchedKeys(t *testing.T) { + fx := newAudioRouteFixture(t) + seedTranscriptAndSpeakers(t, fx.taskID, twoSpeakersJSON) + + cases := []struct { + name string + speakers []gin.H + }{ + { + name: "少一位", + speakers: []gin.H{ + {"key": "0", "name": "张三"}, + }, + }, + { + name: "多一位", + speakers: []gin.H{ + {"key": "0", "name": "张三"}, + {"key": "1", "name": "李四"}, + {"key": "2", "name": "凭空多出来的王五"}, + }, + }, + { + name: "换成稿里没有的标签", + speakers: []gin.H{ + {"key": "0", "name": "张三"}, + {"key": "SPEAKER_09", "name": "李四"}, + }, + }, + { + name: "空名单", + speakers: []gin.H{}, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + code, body := fx.post(t, fx.token, "/api/skills/audio/speakers/confirm", gin.H{ + "task_id": fx.taskID, + "speakers": tc.speakers, + }) + if code != http.StatusBadRequest { + t.Fatalf("返回 %d，期望 400：%v", code, body) + } + // 名单必须原封不动：被拒的那次不许把状态改成已确认。 + var artifact model.TaskArtifact + store.DB.Where("task_id = ? AND artifact_type = ?", fx.taskID, "speakers"). + Order("id DESC").First(&artifact) + if artifact.Status != specialistruntime.ArtifactStatusReady { + t.Errorf("被拒的确认改动了产物状态：%q", artifact.Status) + } + }) + } +} + +// TestAudioSpeakersConfirmIsNotRepeatable 钉住「确认过就不能再确认一次」。 +// +// 双击、或拿着一个过期的页面再点一次，都不该悄悄覆盖掉刚才那份确认 —— +// 要改就得重新跑一遍识别，让新的推断结果重新摆在人面前。 +func TestAudioSpeakersConfirmIsNotRepeatable(t *testing.T) { + fx := newAudioRouteFixture(t) + seedTranscriptAndSpeakers(t, fx.taskID, twoSpeakersJSON) + + payload := gin.H{ + "task_id": fx.taskID, + "speakers": []gin.H{ + {"key": "0", "name": "张三"}, + {"key": "1", "name": "李四"}, + }, + } + if code, body := fx.post(t, fx.token, "/api/skills/audio/speakers/confirm", payload); code != http.StatusOK { + t.Fatalf("第一次确认返回 %d：%s", code, errorMessageOf(t, body)) + } + + code, body := fx.post(t, fx.token, "/api/skills/audio/speakers/confirm", payload) + if code != http.StatusConflict { + t.Fatalf("重复确认返回 %d，期望 409：%v", code, body) + } + + var count int64 + store.DB.Model(&model.TaskRun{}). + Where("task_id = ? AND action_key = ?", fx.taskID, "audio-transcribe:speakers-confirm"). + Count(&count) + if count != 1 { + t.Errorf("重复确认落了 %d 条 task_run，期望 1 —— 右栏会数出一步没干过的活", count) + } +} + +// TestAudioSpeakersConfirmRejectsMissingArtifactAndForeignTask 两条前提不满足的路径： +// 还没有名单就确认、拿别人的任务确认。两条都必须明确报错，不许静默成功。 +func TestAudioSpeakersConfirmRejectsMissingArtifactAndForeignTask(t *testing.T) { + fx := newAudioRouteFixture(t) + + // 任务里连逐字稿都没有，更没有名单。 + code, body := fx.post(t, fx.token, "/api/skills/audio/speakers/confirm", gin.H{ + "task_id": fx.taskID, + "speakers": []gin.H{{"key": "0", "name": "张三"}}, + }) + if code != http.StatusBadRequest || !strings.Contains(errorMessageOf(t, body), "说话人名单") { + t.Errorf("没有名单时的响应不对：%d %v", code, body) + } + + seedTranscriptAndSpeakers(t, fx.taskID, twoSpeakersJSON) + code, body = fx.post(t, fx.other, "/api/skills/audio/speakers/confirm", gin.H{ + "task_id": fx.taskID, + "speakers": []gin.H{{"key": "0", "name": "张三"}, {"key": "1", "name": "李四"}}, + }) + if code != http.StatusNotFound { + t.Errorf("拿别人的任务确认返回 %d，期望 404：%v", code, body) + } +} + +// asText 把 JSON 解出来的任意值读成字符串。 +// +// 不直接 `value.(string)`：JSON 里的数字在这一层是 float64，断言写死了类型的话， +// 一个本该比较的值会被静默读成空串，而空串恰好不等于期望值 —— 用例会红， +// 但报出来的是「值不对」而不是「类型不对」，排查要绕一圈。 +func asText(value any) string { + switch v := value.(type) { + case nil: + return "" + case string: + return v + default: + return fmt.Sprintf("%v", v) + } +} diff --git a/eai_agentplatform/backend-go/internal/api/audio_transcribe.go b/eai_agentplatform/backend-go/internal/api/audio_transcribe.go index f1b7758..e0e001e 100644 --- a/eai_agentplatform/backend-go/internal/api/audio_transcribe.go +++ b/eai_agentplatform/backend-go/internal/api/audio_transcribe.go @@ -1,32 +1,21 @@ package api import ( - "bytes" - "encoding/json" - "fmt" "io" - "mime/multipart" - "net/http" - "strings" - "time" "github.com/gin-gonic/gin" - "eai_agentplatform/backend/internal/ai" - "eai_agentplatform/backend/internal/config" + audiotranscribe "eai_agentplatform/backend/internal/skills/packages/audio_transcribe" + "eai_agentplatform/backend/internal/middleware" "eai_agentplatform/backend/internal/web" ) -// AudioTranscribeResult 语音转录结果 -type AudioTranscribeResult struct { - Text string `json:"text"` // 转录文字 - Language string `json:"language"` // 语言 - Duration float64 `json:"duration"` // 时长(秒) - CreatedAt string `json:"created_at"` // 时间 -} - -// TranscribeAudio POST /api/audio/transcribe —— 语音转文字 +// TranscribeAudio POST /api/audio/transcribe —— 语音转文字（multipart 直传）。 +// +// 这里是薄壳：转写内核在 skills/packages/audio_transcribe，因为技能工作流的 +// 第 2 步（从 media_id 读盘转写）也要用它，而那个包拿不到本包的不导出函数。 +// 本端点的价值只剩「浏览器直接传字节」这一条路径。 func TranscribeAudio(c *gin.Context) { user := middleware.CurrentUser(c) if user == nil { @@ -34,23 +23,18 @@ func TranscribeAudio(c *gin.Context) { return } - // 解析 multipart 表单 file, fileHeader, err := c.Request.FormFile("file") if err != nil { web.Fail(c, web.NewBadRequest("请上传音频文件")) return } + defer file.Close() - // 检查扩展名 - ext := extractExt(fileHeader.Filename) + ext := audiotranscribe.ExtractExt(fileHeader.Filename) if ext == "" { ext = "mp3" } - allowedExt := map[string]bool{ - "mp3": true, "wav": true, "m4a": true, - "ogg": true, "flac": true, "aac": true, "wma": true, - } - if !allowedExt[ext] { + if !audiotranscribe.IsAudioExt(ext) { web.Fail(c, web.NewBadRequest("不支持的音频格式，仅支持 MP3/WAV/M4A/OGG/FLAC")) return } @@ -60,115 +44,17 @@ func TranscribeAudio(c *gin.Context) { language = "zh" // 默认中文 } - // 读取文件内容 fileData, err := io.ReadAll(file) if err != nil { web.Fail(c, web.NewBadRequest("读取音频文件失败")) return } - file.Close() - result := transcribeAudio(fileData, ext, language) - logTranscription(user.ID) + result, err := audiotranscribe.TranscribeBytes( + user.ID, fileData, fileHeader.Filename, ext, language, "") + if err != nil { + web.Fail(c, web.NewBadRequest(err.Error())) + return + } web.OK(c, result) } - -// extractExt 从文件名提取扩展名 -func extractExt(filename string) string { - for i := len(filename) - 1; i >= 0; i-- { - if filename[i] == '.' { - return strings.ToLower(filename[i+1:]) - } - } - return "" -} - -// transcribeAudio 调用 Ollama whisper 进行语音转录 -func transcribeAudio(fileData []byte, ext, language string) AudioTranscribeResult { - // 尝试从路由配置获取 LLM baseURL，降级到 Ollama 默认 - baseURL := "http://127.0.0.1:11434" - if aiRoute, err := config.GetRoute("title_gen"); err == nil && aiRoute != nil && aiRoute.BaseURL != "" { - baseURL = aiRoute.BaseURL - // 去掉 /v1 后缀，确保路径正确 - baseURL = strings.TrimSuffix(baseURL, "/v1") - } - - // 调用 Ollama /v1/audio/transcriptions - url := baseURL + "/v1/audio/transcriptions" - - // 构建 multipart body - buf := bytes.NewBuffer(nil) - w := multipart.NewWriter(buf) - - // model field - modelField, _ := w.CreateFormField("model") - modelField.Write([]byte("whisper")) - - // language field - langField, _ := w.CreateFormField("language") - langField.Write([]byte(language)) - - // audio file - filePart, _ := w.CreateFormFile("file", "audio."+ext) - filePart.Write(fileData) - - w.Close() - - req, err := http.NewRequest("POST", url, buf) - if err != nil { - return AudioTranscribeResult{ - Text: "请求构建失败", - CreatedAt: time.Now().Format("2006-01-02 15:04:05"), - } - } - req.Header.Set("Content-Type", w.FormDataContentType()) - req.Header.Set("Authorization", "Bearer placeholder") // Ollama 通常不需要 key - - client := &http.Client{Timeout: 120 * time.Second} - resp, err := client.Do(req) - if err != nil { - return AudioTranscribeResult{ - Text: fmt.Sprintf("Ollama 服务不可达 (%s)，请确认 whisper 模型已加载", baseURL), - CreatedAt: time.Now().Format("2006-01-02 15:04:05"), - } - } - defer resp.Body.Close() - - body, err := io.ReadAll(resp.Body) - if err != nil { - return AudioTranscribeResult{ - Text: "读取响应失败", - CreatedAt: time.Now().Format("2006-01-02 15:04:05"), - } - } - - if resp.StatusCode != http.StatusOK { - return AudioTranscribeResult{ - Text: fmt.Sprintf("转录失败 (HTTP %d): %s", resp.StatusCode, string(body)), - CreatedAt: time.Now().Format("2006-01-02 15:04:05"), - } - } - - // 解析 {"text": "..."} - var out struct { - Text string `json:"text"` - } - if err := json.Unmarshal(body, &out); err != nil { - return AudioTranscribeResult{ - Text: "响应解析失败", - CreatedAt: time.Now().Format("2006-01-02 15:04:05"), - } - } - - return AudioTranscribeResult{ - Text: out.Text, - Language: language, - Duration: 0, // Ollama whisper 不返回时长 - CreatedAt: time.Now().Format("2006-01-02 15:04:05"), - } -} - -// logTranscription 记录语音转录日志 -func logTranscription(userID uint) { - ai.LogCall(ai.LogEntry{UserID: userID, UsageKind: ai.UsageKindAudioTranscribe, Success: true}) -} diff --git a/eai_agentplatform/backend-go/internal/api/batch_extract.go b/eai_agentplatform/backend-go/internal/api/batch_extract.go index 78fbf00..1641f1d 100644 --- a/eai_agentplatform/backend-go/internal/api/batch_extract.go +++ b/eai_agentplatform/backend-go/internal/api/batch_extract.go @@ -1,6 +1,7 @@ package api import ( + "context" "encoding/json" "strings" "time" @@ -57,7 +58,7 @@ func runBatchExtract(req BatchExtractRequest) BatchExtractResult { fieldDesc := buildFieldDescription(req.Fields) // 调用 AI 提取（此前传 nil 会让 AI 层空指针，见 helpers.generateWithDefaultRoute） - content, err := generateWithDefaultRoute([]ai.Message{ + content, err := generateWithDefaultRoute(context.Background(), []ai.Message{ {Role: "system", Content: "你是一个字段提取专家。请从用户输入的内容中提取以下字段信息，以JSON格式返回：\n" + fieldDesc}, {Role: "user", Content: req.Content}, }) diff --git a/eai_agentplatform/backend-go/internal/api/chat_message.go b/eai_agentplatform/backend-go/internal/api/chat_message.go index 65f4350..9964008 100644 --- a/eai_agentplatform/backend-go/internal/api/chat_message.go +++ b/eai_agentplatform/backend-go/internal/api/chat_message.go @@ -1,7 +1,9 @@ package api import ( + "context" "fmt" + "strings" "time" "github.com/gin-gonic/gin" @@ -9,6 +11,7 @@ import ( "eai_agentplatform/backend/internal/ai" "eai_agentplatform/backend/internal/config" "eai_agentplatform/backend/internal/middleware" + generalassistant "eai_agentplatform/backend/internal/specialists/packages/general_assistant" specialistmodel "eai_agentplatform/backend/internal/specialists/model" "eai_agentplatform/backend/internal/web" ) @@ -153,6 +156,10 @@ func handleExpert(userID uint, req ChatMessageRequest, specialist *specialistmod // // system prompt 由 buildAssistantSystemPrompt 组装：基础角色 + 专员岗位说明书。 // 没解析到专员时（未指定 / key 失效）与改动前逐字一致。 +// +// 普通对话现在也具备「联网搜索」能力：优先用带 web_search 工具的 Agent 生成， +// 让模型按需检索实时数据/政策/新闻，避免空写或编造；若 Agent 因模型/服务异常失败， +// 回退到原纯文本生成以保底。 func callChatModel(userID uint, req ChatMessageRequest, specialist *specialistmodel.Specialist, enableThinking bool) (string, ai.LogEntry) { systemPrompt := buildAssistantSystemPrompt(specialist, enableThinking) logEntry := ai.LogEntry{ @@ -177,7 +184,64 @@ func callChatModel(userID uint, req ChatMessageRequest, specialist *specialistmo logEntry.Model = aiRoute.Model start := time.Now() - result, usedRoute, err := ai.GenerateFullWithFallback(aiRoute, []ai.Message{ + + // 通用助手（未挂载具体专员，或挂的就是 general-assistant 专员）→ 走多 Agent 编排运行时。 + // 通用助手的定位是「平台编排中枢」——相比公众号等专员的静态步骤， + // 它由 LLM 动态拆解子任务、并行执行 worker（可联网）、并发 Merge Gate 收敛。 + // 注意：当用户把对话挂载到 general-assistant 的事由上时，specialist 此时并非 nil + // （resolveSpecialist 会命中它的记录），但语义上它仍是通用助手，必须走编排， + // 否则会退化成普通专员 agent（丢分 Agent 产物与落库）。 + if specialist == nil || specialist.Key == generalassistant.Manifest.Key { + orchestrator := generalassistant.NewOrchestrator(aiRouteID) + finalContent, artifacts, orchErr := orchestrator.Run(context.Background(), req.Message, nil, req.TaskID) + logEntry.LatencyMs = int(time.Since(start).Milliseconds()) + if orchErr == nil { + logEntry.Success = true + return attachOrchestration(finalContent, artifacts), logEntry + } + logEntry.ErrorMessage = orchErr.Error() + // 编排失败则回退到下方纯文本生成保底 + start = time.Now() + result, usedRoute, ferr := ai.GenerateFullWithFallback(context.Background(), aiRoute, []ai.Message{ + {Role: "system", Content: systemPrompt}, + {Role: "user", Content: req.Message}, + }) + logEntry.LatencyMs = int(time.Since(start).Milliseconds()) + if ferr != nil { + logEntry.ErrorMessage = ferr.Error() + return "抱歉，AI 服务暂时不可用，请稍后重试。", logEntry + } + if usedRoute != nil { + logEntry.Provider = usedRoute.Provider + logEntry.AIRouteID = usedRoute.RouteID + logEntry.Model = usedRoute.Model + } + logEntry.TokensInput = result.Usage.PromptTokens + logEntry.TokensOutput = result.Usage.CompletionTokens + logEntry.Success = true + return result.Content, logEntry + } + + // 优先走带搜索的 Agent：模型可按需调用 web_search 检索实时信息。 + searchPrompt := systemPrompt + "\n\n如需获取最新数据、政策、新闻或事实细节，可调用 web_search 工具搜索后再作答，并标注信息出处。不要编造数字或事实。" + agent := ai.NewAgent(aiRoute) + agent.RegisterTool(ai.NewWebSearchTool(nil)) + content, usage, _, agentErr := agent.RunWithUsage(context.Background(), []ai.Message{ + {Role: "system", Content: searchPrompt}, + {Role: "user", Content: req.Message}, + }) + + logEntry.LatencyMs = int(time.Since(start).Milliseconds()) + if agentErr == nil { + logEntry.TokensInput = usage.Usage.PromptTokens + logEntry.TokensOutput = usage.Usage.CompletionTokens + logEntry.Success = true + return content, logEntry + } + + // Agent 失败（模型不支持 tools / 服务异常）→ 回退到原纯文本生成 + 回退链 + start = time.Now() + result, usedRoute, err := ai.GenerateFullWithFallback(context.Background(), aiRoute, []ai.Message{ {Role: "system", Content: systemPrompt}, {Role: "user", Content: req.Message}, }) @@ -197,6 +261,32 @@ func callChatModel(userID uint, req ChatMessageRequest, specialist *specialistmo return result.Content, logEntry } +// attachOrchestration 把多 Agent 编排的最终回复与子任务产物拼接到一起返回。 +// 产物以折叠块追加在正文末尾，便于查验与追溯，不破坏现有消息 schema。 +func attachOrchestration(finalContent string, artifacts []generalassistant.StepArtifact) string { + if len(artifacts) == 0 { + return finalContent + } + var b strings.Builder + b.WriteString(finalContent) + b.WriteString("\n\n
📋 本次由通用编排拆分执行\n\n") + for _, a := range artifacts { + title := a.Title + if title == "" { + title = a.Key + } + if a.Content == "" { + b.WriteString("##### " + title + "\n\n（本子任务结果为空）\n\n") + continue + } + b.WriteString("##### " + title + "\n\n") + b.WriteString(a.Content) + b.WriteString("\n\n") + } + b.WriteString("
") + return b.String() +} + // generateTaskPlan 生成任务拆解 func generateTaskPlan(prompt string) *TaskPlan { plan := &TaskPlan{ diff --git a/eai_agentplatform/backend-go/internal/api/contract_review.go b/eai_agentplatform/backend-go/internal/api/contract_review.go index b55b492..7895071 100644 --- a/eai_agentplatform/backend-go/internal/api/contract_review.go +++ b/eai_agentplatform/backend-go/internal/api/contract_review.go @@ -1,6 +1,7 @@ package api import ( + "context" "strings" "time" @@ -356,7 +357,7 @@ func checkRisks(sections []ContractSection) []RiskItem { func aiDeepReview(req ContractReviewRequest) []RiskItem { // 此前传 nil 会让 AI 层空指针（见 helpers.generateWithDefaultRoute）； // 失败时返回 nil，由调用方只保留规则引擎结果。 - content, err := generateWithDefaultRoute([]ai.Message{ + content, err := generateWithDefaultRoute(context.Background(), []ai.Message{ {Role: "system", Content: "你是一位资深法务专家。请审查以下合同文本，识别法律风险。" + "重点关注：条款完整性、权责对等性、违约责任、争议解决、不可抗力、保密条款、知识产权。"}, {Role: "user", Content: req.Content}, diff --git a/eai_agentplatform/backend-go/internal/api/document_translate.go b/eai_agentplatform/backend-go/internal/api/document_translate.go index 5c81661..a07d0df 100644 --- a/eai_agentplatform/backend-go/internal/api/document_translate.go +++ b/eai_agentplatform/backend-go/internal/api/document_translate.go @@ -3,6 +3,7 @@ package api import ( "archive/zip" "bytes" + "context" "fmt" "strings" "time" @@ -119,7 +120,7 @@ func translateText(content, source, target string) string { 5. 直接输出翻译结果，不要包含解释说明`, srcName, tgtName) aiRoute, _ := config.GetRoute("title_gen") - translatedContent, err := ai.GenerateWithFallback(aiRoute, []ai.Message{ + translatedContent, err := ai.GenerateWithFallback(context.Background(), aiRoute, []ai.Message{ {Role: "system", Content: systemPrompt}, {Role: "user", Content: content}, }) diff --git a/eai_agentplatform/backend-go/internal/api/essay_grade.go b/eai_agentplatform/backend-go/internal/api/essay_grade.go index fc04b4d..1e07aea 100644 --- a/eai_agentplatform/backend-go/internal/api/essay_grade.go +++ b/eai_agentplatform/backend-go/internal/api/essay_grade.go @@ -1,6 +1,7 @@ package api import ( + "context" "encoding/json" "fmt" "strings" @@ -27,7 +28,7 @@ func gradeEssay(userID uint, stem, rubric, userAnswer string) (float64, string, } start := time.Now() - result, usedAiRoute, err := ai.GenerateFullWithFallback(aiRoute, aiMessages) + result, usedAiRoute, err := ai.GenerateFullWithFallback(context.Background(), aiRoute, aiMessages) if err != nil { ai.LogCall(ai.LogEntry{ UserID: userID, UsageKind: ai.UsageKindEssayGrade, Provider: aiRoute.Provider, diff --git a/eai_agentplatform/backend-go/internal/api/helpers.go b/eai_agentplatform/backend-go/internal/api/helpers.go index 1cbd830..c6cca13 100644 --- a/eai_agentplatform/backend-go/internal/api/helpers.go +++ b/eai_agentplatform/backend-go/internal/api/helpers.go @@ -1,6 +1,7 @@ package api import ( + "context" "fmt" "strconv" @@ -29,10 +30,10 @@ func parseID(c *gin.Context, name string) (uint, bool) { // // 存在的意义：取代此前 ai.GenerateWithFallback(nil, …) 的写法。传 nil 会让 // ai.buildRouteChain 直接报错——历史上前者会让调用方必 500。 -func generateWithDefaultRoute(messages []ai.Message) (string, error) { +func generateWithDefaultRoute(ctx context.Context, messages []ai.Message) (string, error) { aiRoute, err := config.GetRoute("title_gen") if err != nil || aiRoute == nil { return "", fmt.Errorf("通用文本生成路由不可用: %w", err) } - return ai.GenerateWithFallback(aiRoute, messages) + return ai.GenerateWithFallback(ctx, aiRoute, messages) } diff --git a/eai_agentplatform/backend-go/internal/api/knowledge_pipeline.go b/eai_agentplatform/backend-go/internal/api/knowledge_pipeline.go index b798445..c7dd104 100644 --- a/eai_agentplatform/backend-go/internal/api/knowledge_pipeline.go +++ b/eai_agentplatform/backend-go/internal/api/knowledge_pipeline.go @@ -1,6 +1,7 @@ package api import ( + "context" "encoding/json" "fmt" "math" @@ -329,7 +330,7 @@ func vectorRetrieveCitations(aiRoute *config.RouteConfig, query string, candidat for _, item := range candidates { inputs = append(inputs, item.Chunk.Content) } - vecs, err := client.Embed(inputs) + vecs, err := client.Embed(context.Background(), inputs) if err != nil || len(vecs) != len(inputs) { return nil, false } diff --git a/eai_agentplatform/backend-go/internal/api/netdisk.go b/eai_agentplatform/backend-go/internal/api/netdisk.go new file mode 100644 index 0000000..2d30ffb --- /dev/null +++ b/eai_agentplatform/backend-go/internal/api/netdisk.go @@ -0,0 +1,575 @@ +package api + +import ( + "crypto/rand" + "encoding/hex" + "errors" + "io" + "mime" + "os" + "path/filepath" + "strconv" + "strings" + "time" + + "github.com/gin-gonic/gin" + + "eai_agentplatform/backend/internal/dal" + "eai_agentplatform/backend/internal/middleware" + "eai_agentplatform/backend/internal/model" + "eai_agentplatform/backend/internal/web" +) + +// 团队共享网盘：全公司共享一套目录与文件，company_id 固定为 1（单公司平台）。 +const netdiskCompanyID = 1 + +// 目录 path 合法性相关常量（对齐 pj0034 asset_folder 红线）。 +// 不可删除/改名的 system folder：根目录 `/`。 +const netdiskRootPath = "/" + +func init() { + netdiskFolderDAO = dal.NetdiskFolderDAO{} + netdiskFileDAO = dal.NetdiskFileDAO{} +} + +var ( + netdiskFolderDAO dal.NetdiskFolderDAO + netdiskFileDAO dal.NetdiskFileDAO +) + +// netdiskRoot 返回网盘物理存储根目录（不存在则创建）。 +func netdiskRoot() string { + dir := Cfg.NetdiskDataDir + if dir == "" { + dir = filepath.Join("data", "netdisk") + } + _ = os.MkdirAll(dir, 0o755) + return dir +} + +// netdiskFilePath 由 StoredName 得到物理绝对路径。 +func netdiskFilePath(storedName string) string { + return filepath.Join(netdiskRoot(), filepath.Base(storedName)) +} + +// ──────────────────────────────────────────────────────────── +// 目录 path 工具（参考 pj0034 app/services/dam/folder.py） +// ──────────────────────────────────────────────────────────── + +var netdiskInvalidSegChars = func() func(r rune) bool { + invalid := "\\:*?\"<>|" + return func(r rune) bool { return strings.ContainsRune(invalid, r) } +}() + +// netdiskNormalizePath 规范化：去尾 `/`、压缩多 `/`、去段内空白；返 `/` 起的绝对路径。 +func netdiskNormalizePath(raw string) string { + s := strings.TrimSpace(strings.ReplaceAll(raw, "\\", "/")) + if s == "" { + return "/" + } + if !strings.HasPrefix(s, "/") { + s = "/" + s + } + for strings.Contains(s, "//") { + s = strings.ReplaceAll(s, "//", "/") + } + if len(s) > 1 { + s = strings.TrimRight(s, "/") + } + return s +} + +// netdiskValidatePath 校验并返回规范化 path；不合法返回错误。 +func netdiskValidatePath(raw string) (string, error) { + if strings.TrimSpace(raw) == "" { + return "", errors.New("目录路径不能为空") + } + p := netdiskNormalizePath(raw) + for _, seg := range strings.Split(p, "/") { + if seg == "" { + continue + } + if seg == "." || seg == ".." { + return "", errors.New("目录路径不允许 '.' 或 '..'") + } + if strings.ContainsFunc(seg, netdiskInvalidSegChars) { + return "", errors.New("目录名含非法字符 \\ : * ? \" < > |") + } + if len(seg) > 100 { + return "", errors.New("目录名「" + seg + "」超 100 字符") + } + } + if len(p) > 500 { + return "", errors.New("目录路径总长超 500 字符") + } + return p, nil +} + +// netdiskIsRoot 是否根目录（system folder，不可删/改名）。 +func netdiskIsRoot(path string) bool { + return netdiskNormalizePath(path) == netdiskRootPath +} + +// netdiskDeriveDisplayName 由 path 末段派生显示名。 +func netdiskDeriveDisplayName(path string) string { + p := netdiskNormalizePath(path) + if p == "/" { + return "/" + } + segs := strings.Split(p, "/") + return segs[len(segs)-1] +} + +// netdiskReplacePrefix 把老前缀整体替换为新前缀（用于目录改名时联动后代）。 +func netdiskReplacePrefix(path, oldPrefix, newPrefix string) string { + if path == oldPrefix { + return newPrefix + } + if strings.HasPrefix(path, oldPrefix+"/") { + return newPrefix + path[len(oldPrefix):] + } + return path +} + +// netdiskParentPath 返回父目录路径（根为 "/"）。 +func netdiskParentPath(path string) string { + p := netdiskNormalizePath(path) + if p == "/" { + return "/" + } + if idx := strings.LastIndex(p, "/"); idx > 0 { + return p[:idx] + } + return "/" +} + +// ──────────────────────────────────────────────────────────── +// 目录 CRUD +// ──────────────────────────────────────────────────────────── + +// netdiskListFolders GET /api/netdisk/folders —— 列全部目录 +func netdiskListFolders(c *gin.Context) { + folders := netdiskFolderDAO.ListDescendants(netdiskCompanyID, "") + web.OK(c, gin.H{"items": folders, "total": len(folders)}) +} + +// netdiskCreateFolder POST /api/netdisk/folders —— 新建目录 (mkdir) +func netdiskCreateFolder(c *gin.Context) { + u := middleware.CurrentUser(c) + var req struct { + Path string `json:"path"` + DisplayName string `json:"display_name"` + } + if err := c.ShouldBindJSON(&req); err != nil { + web.Fail(c, web.NewBadRequest("请求参数错误")) + return + } + path, err := netdiskValidatePath(req.Path) + if err != nil { + web.Fail(c, web.NewBadRequest(err.Error())) + return + } + if netdiskIsRoot(path) { + web.Fail(c, web.NewBadRequest("根目录已存在，无需创建")) + return + } + if _, found := netdiskFolderDAO.GetByPath(netdiskCompanyID, path); found { + web.Fail(c, web.NewBadRequest("目录「" + path + "」已存在")) + return + } + name := req.DisplayName + if name == "" { + name = netdiskDeriveDisplayName(path) + } + folder := model.NetdiskFolder{ + CompanyID: netdiskCompanyID, + Path: path, + DisplayName: name, + CreatedByID: u.ID, + CreatedAt: time.Now(), + } + if !netdiskFolderDAO.Insert(&folder) { + web.Fail(c, web.NewBadRequest("创建目录失败")) + return + } + web.OK(c, folder) +} + +// netdiskPatchFolder PATCH /api/netdisk/folders/:id —— 重命名 / 移动（联动后代与文件） +func netdiskPatchFolder(c *gin.Context) { + id, ok := parseID(c, "id") + if !ok { + return + } + var req struct { + Path *string `json:"path"` + DisplayName *string `json:"display_name"` + } + if err := c.ShouldBindJSON(&req); err != nil { + web.Fail(c, web.NewBadRequest("请求参数错误")) + return + } + folder, found := netdiskFolderDAO.GetByID(id) + if !found { + web.Fail(c, web.NewNotFoundError("目录不存在")) + return + } + if netdiskIsRoot(folder.Path) { + web.Fail(c, web.NewBadRequest("根目录不可改名或移动")) + return + } + + if req.Path != nil { + newPath, err := netdiskValidatePath(*req.Path) + if err != nil { + web.Fail(c, web.NewBadRequest(err.Error())) + return + } + if netdiskNormalizePath(newPath) == netdiskNormalizePath(folder.Path) { + // 同名，跳过移动 + } else { + if strings.HasPrefix(newPath+"/", folder.Path+"/") { + web.Fail(c, web.NewBadRequest("不能把目录移动到自己的子目录下")) + return + } + if _, dup := netdiskFolderDAO.GetByPath(netdiskCompanyID, newPath); dup { + web.Fail(c, web.NewBadRequest("目标目录「" + newPath + "」已存在")) + return + } + // 联动后代目录 + desc := netdiskFolderDAO.ListDescendants(netdiskCompanyID, folder.Path) + for i := range desc { + if desc[i].ID == folder.ID { + continue + } + next := netdiskReplacePrefix(desc[i].Path, folder.Path, newPath) + if next != desc[i].Path { + desc[i].Path = next + netdiskFolderDAO.Update(&desc[i]) + } + } + // 联动该目录下（含后代）的文件 folder_path + netdiskMigrateFilesOnFolderMove(folder.Path, newPath) + folder.Path = newPath + } + } + if req.DisplayName != nil && strings.TrimSpace(*req.DisplayName) != "" { + folder.DisplayName = strings.TrimSpace(*req.DisplayName) + } + if !netdiskFolderDAO.Update(&folder) { + web.Fail(c, web.NewBadRequest("更新目录失败")) + return + } + web.OK(c, folder) +} + +// netdiskMigrateFilesOnFolderMove 目录改名/移动后，把落在该目录及其后代的文件 folder_path 同步改前缀。 +func netdiskMigrateFilesOnFolderMove(oldPrefix, newPrefix string) { + // 取所有未被回收站软删的文件，逐个修正前缀。 + folders := netdiskFolderDAO.ListDescendants(netdiskCompanyID, "") + affected := map[string]bool{} + for _, f := range folders { + if f.Path == oldPrefix || strings.HasPrefix(f.Path, oldPrefix+"/") { + affected[f.Path] = true + } + } + if len(affected) == 0 { + return + } + var files []model.NetdiskFile + var all []model.NetdiskFile + dal.New(&all).Find(&all) + for i := range all { + nf := all[i] + if nf.CompanyID != netdiskCompanyID || nf.DeletedAt != nil { + continue + } + next := netdiskReplacePrefix(nf.FolderPath, oldPrefix, newPrefix) + if next != nf.FolderPath { + nf.FolderPath = next + files = append(files, nf) + } + } + for i := range files { + netdiskFileDAO.Update(&files[i]) + } +} + +// netdiskDeleteFolder DELETE /api/netdisk/folders/:id —— 删除空目录（非空 409） +func netdiskDeleteFolder(c *gin.Context) { + id, ok := parseID(c, "id") + if !ok { + return + } + folder, found := netdiskFolderDAO.GetByID(id) + if !found { + web.Fail(c, web.NewNotFoundError("目录不存在")) + return + } + if netdiskIsRoot(folder.Path) { + web.Fail(c, web.NewBadRequest("根目录不可删除")) + return + } + if children := netdiskFolderDAO.CountChildren(netdiskCompanyID, folder.Path); children > 0 { + web.Fail(c, web.NewBadRequest("该目录下还有子目录，请先清空再删除")) + return + } + // 统计该目录下非回收站文件数 + cnt := netdiskCountLiveFilesUnder(folder.Path) + if cnt > 0 { + web.Fail(c, web.NewBadRequest("该目录下还有 "+strconv.FormatInt(cnt, 10)+" 个文件，请先移走或删除")) + return + } + if !netdiskFolderDAO.Delete(id) { + web.Fail(c, web.NewBadRequest("删除失败")) + return + } + web.OK(c, gin.H{"deleted": id}) +} + +// netdiskCountLiveFilesUnder 统计某目录（含后代路径）下未软删除的文件数。 +func netdiskCountLiveFilesUnder(folderPath string) int64 { + var all []model.NetdiskFile + dal.New(&all).Find(&all) + var n int64 + for _, f := range all { + if f.CompanyID != netdiskCompanyID || f.DeletedAt != nil { + continue + } + if f.FolderPath == folderPath { + n++ + } + } + return n +} + +// ──────────────────────────────────────────────────────────── +// 文件：列表 / 上传 +// ──────────────────────────────────────────────────────────── + +// netdiskListFiles GET /api/netdisk/files?path=&status= —— 列某目录文件（默认只看 approved） +func netdiskListFiles(c *gin.Context) { + path := c.DefaultQuery("path", "/") + norm := netdiskNormalizePath(path) + status := c.DefaultQuery("status", "approved") + files := netdiskFileDAO.ListByFolder(netdiskCompanyID, norm, status) + web.OK(c, gin.H{"items": files, "total": len(files), "path": norm}) +} + +var blockedNetdiskExt = map[string]bool{ + "exe": true, "bin": true, "dll": true, "so": true, "dylib": true, + "msi": true, "apk": true, "ipa": true, "deb": true, "rpm": true, "pkg": true, "appimage": true, + "bat": true, "cmd": true, "com": true, "scr": true, "sys": true, "drv": true, + "ps1": true, "psm1": true, "vbs": true, "vbe": true, "js": true, "jse": true, "wsf": true, "wsh": true, + "reg": true, "lnk": true, "iso": true, "img": true, "dmg": true, +} + +func netdiskIsUploadable(ext string) bool { + return !blockedNetdiskExt[strings.ToLower(strings.TrimPrefix(ext, "."))] +} + +func netdiskSizeLimit(ext string) int64 { + ext = strings.ToLower(strings.TrimPrefix(ext, ".")) + switch ext { + case "mp4", "mov", "avi", "mkv", "webm", "m4v", "wmv", "flv": + return Cfg.FileMaxVideo + default: + return Cfg.FileMaxDoc + } +} + +func netdiskRandomID() string { + b := make([]byte, 16) + if _, err := rand.Read(b); err != nil { + return strconv.FormatInt(time.Now().UnixNano(), 36) + } + return hex.EncodeToString(b) +} + +// netdiskUpload POST /api/netdisk/upload —— 直传 +func netdiskUpload(c *gin.Context) { + u := middleware.CurrentUser(c) + folderPath := netdiskNormalizePath(c.PostForm("folder_path")) + if _, err := netdiskValidatePath(folderPath); err != nil { + folderPath = "/" + } + // 若指定了不存在的目录，回退根目录 + if folderPath != "/" { + if _, ok := netdiskFolderDAO.GetByPath(netdiskCompanyID, folderPath); !ok { + folderPath = "/" + } + } + + file, header, err := c.Request.FormFile("file") + if err != nil { + web.Fail(c, web.NewBadRequest("缺少文件字段 file")) + return + } + defer file.Close() + + ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(header.Filename), ".")) + if !netdiskIsUploadable(ext) { + web.Fail(c, web.NewBadRequest("不支持的文件类型")) + return + } + if header.Size > netdiskSizeLimit(ext) { + web.Fail(c, web.NewBadRequest("文件超过大小限制")) + return + } + + source := "employee" + status := "pending" + if u.Role == "admin" { + source = "admin" + status = "approved" // 管理员上传自动通过 + } + + storedName := netdiskRandomID() + "." + ext + dst := filepath.Join(netdiskRoot(), storedName) + out, err := os.Create(dst) + if err != nil { + web.Fail(c, web.NewBadRequest("保存文件失败")) + return + } + if _, err := io.Copy(out, file); err != nil { + out.Close() + os.Remove(dst) + web.Fail(c, web.NewBadRequest("写入文件失败")) + return + } + out.Close() + + m := model.NetdiskFile{ + CompanyID: netdiskCompanyID, + FolderPath: folderPath, + Filename: header.Filename, + StoredName: storedName, + FileExt: ext, + MimeType: mime.TypeByExtension("." + ext), + FileSize: header.Size, + Status: status, + Source: source, + SubmitterID: u.ID, + CreatedAt: time.Now(), + } + if !netdiskFileDAO.Insert(&m) { + os.Remove(dst) + web.Fail(c, web.NewBadRequest("创建文件记录失败")) + return + } + web.OK(c, gin.H{"file_id": m.ID, "status": m.Status, "filename": m.Filename}) +} + +// netdiskDownload GET /api/netdisk/files/:id/download —— 下载（仅 approved） +func netdiskDownload(c *gin.Context) { + id, ok := parseID(c, "id") + if !ok { + return + } + f, found := netdiskFileDAO.GetByID(id) + if !found { + web.Fail(c, web.NewNotFoundError("文件不存在")) + return + } + if f.Status != "approved" { + web.Fail(c, web.NewForbiddenError("文件未通过审批，不可下载")) + return + } + c.FileAttachment(netdiskFilePath(f.StoredName), f.Filename) +} + +// netdiskPreview GET /api/netdisk/files/:id/preview —— 在线预览（仅 approved） +func netdiskPreview(c *gin.Context) { + id, ok := parseID(c, "id") + if !ok { + return + } + f, found := netdiskFileDAO.GetByID(id) + if !found { + web.Fail(c, web.NewNotFoundError("文件不存在")) + return + } + if f.Status != "approved" { + web.Fail(c, web.NewForbiddenError("文件未通过审批，不可预览")) + return + } + web.OK(c, gin.H{ + "preview_url": "/netdisk-file/" + f.StoredName, + "file_ext": f.FileExt, + "mime_type": f.MimeType, + }) +} + +// netdiskRenameFile PUT /api/netdisk/files/:id/rename —— 重命名（仅改名，不移动） +func netdiskRenameFile(c *gin.Context) { + id, ok := parseID(c, "id") + if !ok { + return + } + var req struct { + Filename string `json:"filename"` + } + if err := c.ShouldBindJSON(&req); err != nil || strings.TrimSpace(req.Filename) == "" { + web.Fail(c, web.NewBadRequest("文件名不能为空")) + return + } + f, found := netdiskFileDAO.GetByID(id) + if !found { + web.Fail(c, web.NewNotFoundError("文件不存在")) + return + } + if f.DeletedAt != nil { + web.Fail(c, web.NewBadRequest("文件在回收站中")) + return + } + name := strings.TrimSpace(req.Filename) + if netdiskNormalizePath(name) == "/" || strings.Contains(name, "/") || strings.Contains(name, "\\") { + web.Fail(c, web.NewBadRequest("文件名不合法")) + return + } + f.Filename = name + if !netdiskFileDAO.Update(&f) { + web.Fail(c, web.NewBadRequest("重命名失败")) + return + } + web.OK(c, f) +} + +// netdiskMoveFile PUT /api/netdisk/files/:id/move —— 移动到目标目录 +func netdiskMoveFile(c *gin.Context) { + id, ok := parseID(c, "id") + if !ok { + return + } + var req struct { + FolderPath string `json:"folder_path"` + } + if err := c.ShouldBindJSON(&req); err != nil { + web.Fail(c, web.NewBadRequest("请求参数错误")) + return + } + target, err := netdiskValidatePath(req.FolderPath) + if err != nil { + web.Fail(c, web.NewBadRequest(err.Error())) + return + } + if _, found := netdiskFolderDAO.GetByPath(netdiskCompanyID, target); !found && target != "/" { + web.Fail(c, web.NewNotFoundError("目标目录不存在")) + return + } + f, found := netdiskFileDAO.GetByID(id) + if !found { + web.Fail(c, web.NewNotFoundError("文件不存在")) + return + } + if f.DeletedAt != nil { + web.Fail(c, web.NewBadRequest("文件在回收站中")) + return + } + f.FolderPath = target + if !netdiskFileDAO.Update(&f) { + web.Fail(c, web.NewBadRequest("移动失败")) + return + } + web.OK(c, f) +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/api/netdisk_recycle.go b/eai_agentplatform/backend-go/internal/api/netdisk_recycle.go new file mode 100644 index 0000000..1dcffea --- /dev/null +++ b/eai_agentplatform/backend-go/internal/api/netdisk_recycle.go @@ -0,0 +1,194 @@ +package api + +import ( + "os" + "time" + + "github.com/gin-gonic/gin" + + "eai_agentplatform/backend/internal/middleware" + "eai_agentplatform/backend/internal/web" +) + +// ──────────────────────────────────────────────────────────── +// 回收站 +// ──────────────────────────────────────────────────────────── + +// netdiskRecycleList GET /api/netdisk/recycle —— 回收站列表 +func netdiskRecycleList(c *gin.Context) { + files := netdiskFileDAO.ListInRecycle(netdiskCompanyID) + web.OK(c, gin.H{"items": files, "total": len(files)}) +} + +// netdiskRecycleFile DELETE /api/netdisk/files/:id —— 移入回收站（软删除） +func netdiskRecycleFile(c *gin.Context) { + u := middleware.CurrentUser(c) + id, ok := parseID(c, "id") + if !ok { + return + } + f, found := netdiskFileDAO.GetByID(id) + if !found { + web.Fail(c, web.NewNotFoundError("文件不存在")) + return + } + if f.DeletedAt != nil { + web.Fail(c, web.NewBadRequest("文件已在回收站中")) + return + } + now := time.Now() + f.DeletedAt = &now + f.DeletedBy = &u.ID + if !netdiskFileDAO.Update(&f) { + web.Fail(c, web.NewBadRequest("移入回收站失败")) + return + } + web.OK(c, gin.H{"id": f.ID, "recycled": true}) +} + +// netdiskRestoreFile POST /api/netdisk/recycle/:id/restore —— 从回收站恢复 +func netdiskRestoreFile(c *gin.Context) { + id, ok := parseID(c, "id") + if !ok { + return + } + f, found := netdiskFileDAO.GetByID(id) + if !found { + web.Fail(c, web.NewNotFoundError("文件不存在")) + return + } + if f.DeletedAt == nil { + web.Fail(c, web.NewBadRequest("文件不在回收站中")) + return + } + f.DeletedAt = nil + f.DeletedBy = nil + if !netdiskFileDAO.Update(&f) { + web.Fail(c, web.NewBadRequest("恢复失败")) + return + } + web.OK(c, f) +} + +// netdiskPurgeFile DELETE /api/netdisk/recycle/:id —— 彻底删除（物理删文件+记录） +func netdiskPurgeFile(c *gin.Context) { + id, ok := parseID(c, "id") + if !ok { + return + } + f, found := netdiskFileDAO.GetByID(id) + if !found { + web.Fail(c, web.NewNotFoundError("文件不存在")) + return + } + if f.DeletedAt == nil { + web.Fail(c, web.NewBadRequest("仅回收站中的文件可彻底删除")) + return + } + // 物理删除 + _ = os.Remove(netdiskFilePath(f.StoredName)) + if !netdiskFileDAO.HardDelete(id) { + web.Fail(c, web.NewBadRequest("彻底删除失败")) + return + } + web.OK(c, gin.H{"purged": id}) +} + +// ──────────────────────────────────────────────────────────── +// 审批（并行几秒的列表用 status 过滤） +// ──────────────────────────────────────────────────────────── + +// netdiskAuditList GET /api/netdisk/audit-list?status=&page=&size= —— 审批列表 +func netdiskAuditList(c *gin.Context) { + page := atoiDefault(c.DefaultQuery("page", "1"), 1) + size := atoiDefault(c.DefaultQuery("size", "20"), 20) + if page < 1 { + page = 1 + } + if size < 1 || size > 100 { + size = 20 + } + total, items := netdiskFileDAO.ListForAudit(netdiskCompanyID, c.Query("status"), page, size) + web.OK(c, gin.H{"total": total, "items": items}) +} + +// netdiskAuditFile POST /api/netdisk/audit/:id —— 审批（approve / reject） +func netdiskAuditFile(c *gin.Context) { + u := middleware.CurrentUser(c) + id, ok := parseID(c, "id") + if !ok { + return + } + var req struct { + Action string `json:"action"` + RejectReason string `json:"reject_reason"` + } + if err := c.ShouldBindJSON(&req); err != nil { + web.Fail(c, web.NewBadRequest("请求参数错误")) + return + } + f, found := netdiskFileDAO.GetByID(id) + if !found { + web.Fail(c, web.NewNotFoundError("文件不存在")) + return + } + if f.Status != "pending" { + web.Fail(c, web.NewConflictError("该文件已审批，不可重复操作")) + return + } + now := time.Now() + switch req.Action { + case "approve": + f.Status = "approved" + f.AuditBy = &u.ID + f.AuditAt = &now + f.RejectReason = "" + case "reject": + if spaceTrim(req.RejectReason) == "" { + web.Fail(c, web.NewBadRequest("驳回理由必填")) + return + } + f.Status = "rejected" + f.RejectReason = req.RejectReason + f.AuditBy = &u.ID + f.AuditAt = &now + default: + web.Fail(c, web.NewBadRequest("action 必须为 approve 或 reject")) + return + } + if !netdiskFileDAO.Update(&f) { + web.Fail(c, web.NewBadRequest("审批失败")) + return + } + web.OK(c, gin.H{"id": f.ID, "status": f.Status}) +} + +// ──────────────────────────────────────────────────────────── +// 小工具 +// ──────────────────────────────────────────────────────────── + +func atoiDefault(s string, def int) int { + n := 0 + for _, r := range s { + if r < '0' || r > '9' { + return def + } + n = n*10 + int(r-'0') + } + if s == "" { + return def + } + return n +} + +func spaceTrim(s string) string { + start := 0 + end := len(s) + for start < end && (s[start] == ' ' || s[start] == '\t' || s[start] == '\n' || s[start] == '\r') { + start++ + } + for end > start && (s[end-1] == ' ' || s[end-1] == '\t' || s[end-1] == '\n' || s[end-1] == '\r') { + end-- + } + return s[start:end] +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/api/router.go b/eai_agentplatform/backend-go/internal/api/router.go index f5db095..535125b 100644 --- a/eai_agentplatform/backend-go/internal/api/router.go +++ b/eai_agentplatform/backend-go/internal/api/router.go @@ -30,6 +30,11 @@ func RegisterRoutes(r *gin.Engine, cfg *config.Config) { if err := os.MkdirAll(filepath.Join(cfg.KBDataDir, "approved"), 0o755); err == nil { r.Static("/media", filepath.Join(cfg.KBDataDir, "approved")) } + // 网盘物理文件静态预览（只读）：仅 approved 文件通过 Preview 接口取 URL， + // 未审批文件不对外暴露，落实「审批前置」。 + if err := os.MkdirAll(cfg.NetdiskDataDir, 0o755); err == nil { + r.Static("/netdisk-file", cfg.NetdiskDataDir) + } r.GET("/api/health", func(c *gin.Context) { ver := "1.1.0" @@ -117,6 +122,21 @@ func RegisterRoutes(r *gin.Engine, cfg *config.Config) { r.GET("/api/media/preview/:media_id", middleware.Auth(cfg), Preview) r.GET("/api/media/status/:media_id", middleware.Auth(cfg), MediaStatus) + // ── 团队共享网盘（目录 / 文件 / 预览 / 下载）── + r.GET("/api/netdisk/folders", middleware.Auth(cfg), netdiskListFolders) + r.POST("/api/netdisk/folders", middleware.Auth(cfg), netdiskCreateFolder) + r.PATCH("/api/netdisk/folders/:id", middleware.Auth(cfg), netdiskPatchFolder) + r.GET("/api/netdisk/files", middleware.Auth(cfg), netdiskListFiles) + r.POST("/api/netdisk/upload", middleware.Auth(cfg), netdiskUpload) + r.GET("/api/netdisk/files/:id/download", middleware.Auth(cfg), netdiskDownload) + r.GET("/api/netdisk/files/:id/preview", middleware.Auth(cfg), netdiskPreview) + r.PUT("/api/netdisk/files/:id/rename", middleware.Auth(cfg), netdiskRenameFile) + r.PUT("/api/netdisk/files/:id/move", middleware.Auth(cfg), netdiskMoveFile) + r.DELETE("/api/netdisk/files/:id", middleware.Auth(cfg), netdiskRecycleFile) + // 回收站 + r.GET("/api/netdisk/recycle", middleware.Auth(cfg), netdiskRecycleList) + r.POST("/api/netdisk/recycle/:id/restore", middleware.Auth(cfg), netdiskRestoreFile) + r.GET("/api/knowledge/spaces", middleware.Auth(cfg), ListKnowledgeSpaces) r.GET("/api/knowledge/search", middleware.Auth(cfg), SearchKnowledge) r.GET("/api/knowledge/status/:source_id", middleware.Auth(cfg), KnowledgeStatus) @@ -130,6 +150,8 @@ func RegisterRoutes(r *gin.Engine, cfg *config.Config) { r.GET("/api/ai/usage", middleware.Auth(cfg), AIUsage) r.GET("/api/ai/routes/chat", ListChatRoutes) r.GET("/api/ai/routes/embed", ListEmbedRoutes) + r.GET("/api/ai/routes/audio", ListAudioRoutes) + r.GET("/api/assistant/opening", middleware.Auth(cfg), GetAssistantOpening) // 学习进度（员工上报 + 本人查询） r.POST("/api/learning/progress", middleware.Auth(cfg), RecordLearningProgress) @@ -159,6 +181,19 @@ func RegisterRoutes(r *gin.Engine, cfg *config.Config) { r.POST("/api/skills/office/execute", middleware.Auth(cfg), skillapi.ExecuteOfficeSkill) r.POST("/api/skills/office/ocr", middleware.Auth(cfg), skillapi.ExecuteOfficeSkillOCR) r.POST("/api/skills/office/tts", middleware.Auth(cfg), skillapi.ExecuteOfficeSkillTTS) + + // 语音转写技能的四步。**不复用 /api/skills/office/execute**：office 的运行时 + // 是纯产物构造器（不发网络请求），转写必须真的调 ASR 与 LLM。 + // 每步一条路由 = 每步一条 task_run，右栏「工作流 x/4」据此推进。 + // 语音转写：一步一个端点、一步一条 task_run，右栏的「工作流 x/6」靠这个推进。 + // speakers 与 speakers/confirm 是**两步**：前者只推断（产物落 ready、任务落待确认）， + // 后者是用户拍板。中间停多久由用户决定，后端不设超时。 + r.POST("/api/skills/audio/scope", middleware.Auth(cfg), skillapi.ExecuteAudioScope) + r.POST("/api/skills/audio/transcribe", middleware.Auth(cfg), skillapi.ExecuteAudioTranscribe) + r.POST("/api/skills/audio/speakers", middleware.Auth(cfg), skillapi.ExecuteAudioSpeakers) + r.POST("/api/skills/audio/speakers/confirm", middleware.Auth(cfg), skillapi.ExecuteAudioSpeakersConfirm) + r.POST("/api/skills/audio/structure", middleware.Auth(cfg), skillapi.ExecuteAudioStructure) + r.POST("/api/skills/audio/minutes", middleware.Auth(cfg), skillapi.ExecuteAudioMinutes) r.GET("/api/tts/audio/:filename", middleware.Auth(cfg), skillapi.ServeTTSAudio) r.POST("/api/chat/message", middleware.Auth(cfg), HandleChatMessage) @@ -189,6 +224,12 @@ func RegisterRoutes(r *gin.Engine, cfg *config.Config) { admin.GET("/media/audit-list", AuditList) admin.POST("/media/audit/:media_id", AuditMedia) + // 网盘管理：删目录、审批、回收站彻底删除 + admin.DELETE("/netdisk/folders/:id", netdiskDeleteFolder) + admin.GET("/netdisk/audit-list", netdiskAuditList) + admin.POST("/netdisk/audit/:id", netdiskAuditFile) + admin.DELETE("/netdisk/recycle/:id", netdiskPurgeFile) + admin.POST("/knowledge/scan", KnowledgeScan) admin.POST("/knowledge/index/rebuild", RebuildKnowledgeIndex) admin.POST("/knowledge/spaces", CreateKnowledgeSpace) diff --git a/eai_agentplatform/backend-go/internal/config/audio_route_test.go b/eai_agentplatform/backend-go/internal/config/audio_route_test.go new file mode 100644 index 0000000..d93a781 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/config/audio_route_test.go @@ -0,0 +1,182 @@ +package config + +import ( + "os" + "path/filepath" + "strings" + "testing" +) + +// TestMain 定位 backend-go 目录并切换工作目录，保证 config/ai_config.json 与 +// config/ai_secrets.json 在测试进程内可被发现（configDir() 的回退逻辑依赖 CWD/config）。 +// +// go test 默认把工作目录设为包目录，因此在 internal/config 下直接跑会找不到 +// ai_config.json —— 切到 backend-go 再运行，模拟真实进程环境。 +func TestMain(m *testing.M) { + if base := locateBackendGo(); base != "" { + _ = os.Chdir(base) + } + os.Exit(m.Run()) +} + +// locateBackendGo 从当前工作目录向上探测，找到含 config/ai_config.json 的目录 +// （即 backend-go）；找不到返回空串。 +func locateBackendGo() string { + dir, err := os.Getwd() + if err != nil { + return "" + } + for { + if _, err := os.Stat(filepath.Join(dir, "config", "ai_config.json")); err == nil { + return dir + } + parent := filepath.Dir(dir) + if parent == dir { + return "" + } + dir = parent + } +} + +// TestGetAudioRouteResolves 断言语音转写路由能解析成一条真正的 ASR 路由： +// category 必须是 audio，终点必须是 /audio/transcriptions（而不是 chat 的 +// /chat/completions），且密钥必须已从 ai_secrets.json 注入。 +func TestGetAudioRouteResolves(t *testing.T) { + rc, err := GetAudioRoute("audio_transcribe") + if err != nil { + t.Fatalf("GetAudioRoute(audio_transcribe) 报错: %v", err) + } + if rc.Category != "audio" { + t.Errorf("Category = %q，期望 audio", rc.Category) + } + if rc.Model == "" { + t.Error("Model 为空 —— 会把空模型名发给 ASR 服务") + } + if !strings.HasSuffix(rc.FullURL, "/audio/transcriptions") { + t.Errorf("FullURL = %q，期望以 /audio/transcriptions 结尾", rc.FullURL) + } + if strings.Contains(rc.FullURL, "/chat/completions") { + t.Errorf("FullURL = %q 指到了 chat 接口 —— 音频必须走 ASR 接口", rc.FullURL) + } + // 密钥只对**非本地**路由要求：本机服务（回环地址）本来就不需要密钥， + // 判据与运行期共用 IsLocalRoute。这里原来是无条件断言，于是这条用例的 + // 红绿取决于跑测试的机器上 8090 有没有在监听 —— 本地 ASR 一启动， + // 解析结果变成 audio_route_local_whisper，断言就红。那不是「发现了问题」， + // 是把「机器状态」当成了「代码错误」。实测过：起个只回 200 的桩就翻红。 + if !IsLocalRoute(rc) { + if rc.APIKey == "" { + t.Error("APIKey 为空 —— 会像旧实现那样带着占位密钥去请求，必然 401") + } + if rc.APIKey == "placeholder" { + t.Error("APIKey 是占位值 placeholder —— 正是旧实现的三处写死之一") + } + } + t.Logf("解析结果: route=%s provider=%s model=%s url=%s timeout=%ds is_local=%v", + rc.RouteID, rc.Provider, rc.Model, rc.FullURL, rc.TimeoutSeconds, IsLocalRoute(rc)) +} + +// TestAudioRouteCapabilityIsDeclared 钉住「这次转写有没有说话人标签」是个常量。 +// +// 为什么必须单独钉：audio_transcribe 现在指向 audio_route_auto，auto 会按此刻 +// 哪台服务活着挑一条路由。若不加约束，本地 ASR 一挂就会退到 +// audio_route_siliconflow_qwen3（不支持说话人分离）—— 于是「有没有标签」随 +// 进程启停变化：第 1 步说要区分说话人、第 2 步落到的路由不输出标签，下游 +// 第 3 步硬失败；更坏的是闸门读到 false 后放行，模型猜的身份进正式纪要。 +// +// 所以断言两件事，而且都**不依赖本机 8090 起没起**： +// 1. auto 解析出的路由，说话人能力必须与声明路由（default_audio_route）一致； +// 2. 声明路由本身必须存在且能解析。 +func TestAudioRouteCapabilityIsDeclared(t *testing.T) { + declared, err := GetDeclaredAudioRoute() + if err != nil { + t.Fatalf("声明路由（default_audio_route）解析失败：%v", err) + } + + resolved, err := GetAudioRoute("audio_transcribe") + if err != nil { + t.Fatalf("GetAudioRoute(audio_transcribe) 报错: %v", err) + } + if resolved.SupportsSpeakers != declared.SupportsSpeakers { + t.Errorf("auto 解析到 %s（supports_speakers=%v），而声明路由 %s 是 %v："+ + "说话人能力被静默换掉了", resolved.RouteID, resolved.SupportsSpeakers, + declared.RouteID, declared.SupportsSpeakers) + } + if resolved.Category != "audio" { + t.Errorf("auto 解析到 %s，分类是 %q —— 不是音频路由", resolved.RouteID, resolved.Category) + } + t.Logf("声明路由=%s（speakers=%v）auto 解析=%s", + declared.RouteID, declared.SupportsSpeakers, resolved.RouteID) +} + +// TestAudioFallbackKeepsSpeakerCapability 钉住回退链不会换掉说话人能力。 +// +// 回退是为了「这条路此刻不行」，不是为了「悄悄换个能力」。链上一条 +// supports_speakers 不同的路由，等于让一次网络抖动改掉整个任务的下游行为。 +func TestAudioFallbackKeepsSpeakerCapability(t *testing.T) { + primary, err := GetDeclaredAudioRoute() + if err != nil { + t.Fatalf("声明路由解析失败：%v", err) + } + chain := GetFallbackAudioRoutes(primary.RouteID) + if len(chain) == 0 { + // 没有配回退不是错误（云端可能本就没开通），但要说清「本地挂了没有退路」。 + t.Logf("路由 %s 没有配置回退链：本地不可用时这次转写会直接失败", primary.RouteID) + return + } + for _, r := range chain { + if r.Category != "audio" { + t.Errorf("回退链里的 %s 分类是 %q —— 会把音频发到非 ASR 终点", r.RouteID, r.Category) + } + if r.SupportsSpeakers != primary.SupportsSpeakers { + t.Errorf("回退链里的 %s 的 supports_speakers=%v，与主路由 %s 的 %v 不同："+ + "回退会静默换掉说话人能力", r.RouteID, r.SupportsSpeakers, + primary.RouteID, primary.SupportsSpeakers) + } + t.Logf("回退: %s (%s)", r.RouteID, r.Model) + } +} + +// TestGetAudioRouteDoesNotFallBackToChat 是本包最重要的一条断言。 +// +// GetRoute 的回退链会在找不到路由时静默返回 default_route（一条 chat 路由）。 +// 对音频而言这是最坏的失败方式：拿 /chat/completions 去打 ASR 模型，报错会指向 +// 模型或密钥，与真实原因（路由配错）毫无关系。GetAudioRoute 必须直接报错。 +func TestGetAudioRouteDoesNotFallBackToChat(t *testing.T) { + // 传一个确实存在于 chat_routes 的 id：它不是音频路由，必须被拒绝， + // 而不是"找不到就拿个默认的凑合"。 + rc, err := GetAudioRoute("chat_route_lmuai_deepseek_v4_flash") + if err == nil { + t.Fatalf("把 chat 路由当音频路由返回了（route=%s url=%s）—— 必须报错", + rc.RouteID, rc.FullURL) + } + if rc != nil { + t.Errorf("报错时仍返回了非 nil 的 RouteConfig: %+v", rc) + } + t.Logf("按预期拒绝: %v", err) + + // 配错的路由名同样必须报错，且不得回退到 default_route。 + if _, err := GetAudioRoute("audio_route_does_not_exist"); err == nil { + t.Error("不存在的音频路由名没有报错 —— 回退链没有被拦住") + } +} + +// TestGetRoutesByCategoryAudio 断言 audio 类别可被枚举（管理/诊断页面用）， +// 且枚举出的每一条都真的是音频路由。 +func TestGetRoutesByCategoryAudio(t *testing.T) { + routes, err := GetRoutesByCategory("audio") + if err != nil { + t.Fatalf("GetRoutesByCategory(audio) 报错: %v", err) + } + if len(routes) == 0 { + t.Fatal("audio 类别下没有任何路由") + } + for _, rc := range routes { + if rc.Category != "audio" { + t.Errorf("路由 %s 的 Category = %q，期望 audio", rc.RouteID, rc.Category) + } + if !strings.HasSuffix(rc.FullURL, "/audio/transcriptions") { + t.Errorf("路由 %s 的 FullURL = %q，不是 ASR 终点", rc.RouteID, rc.FullURL) + } + t.Logf("音频路由: %s (%s)", rc.RouteID, rc.Model) + } +} diff --git a/eai_agentplatform/backend-go/internal/config/config.go b/eai_agentplatform/backend-go/internal/config/config.go index 47c92c7..eed92e0 100644 --- a/eai_agentplatform/backend-go/internal/config/config.go +++ b/eai_agentplatform/backend-go/internal/config/config.go @@ -24,6 +24,7 @@ type Config struct { KBDataDir string KnowledgeSourceDir string TrainingMaterialsDir string + NetdiskDataDir string // 网盘物理文件根目录（独立于知识库媒体） // 定期备份。SQLite 是单文件、又没有任何外部主从，坏一份就是全丢， // 所以默认开着：启动补一次，之后每 BackupIntervalHours 小时一次，保留最近 N 份。 @@ -67,6 +68,7 @@ func Load() *Config { KBDataDir: getenv("KB_DATA_DIR", filepath.Join(baseDir, "data", "kb_data")), KnowledgeSourceDir: getenv("KNOWLEDGE_SOURCE_DIR", filepath.Join(assetRootDir, "knowledge", "source")), TrainingMaterialsDir: getenv("TRAINING_MATERIALS_DIR", filepath.Join(assetRootDir, "training", "materials")), + NetdiskDataDir: getenv("NETDISK_DATA_DIR", filepath.Join(baseDir, "data", "netdisk")), // 备份目录必须落在 data/ 下：systemd 单元是 ProtectSystem=strict， // 只有 data/ 可写（ReadWritePaths），换到别处会静默失败。 diff --git a/eai_agentplatform/backend-go/internal/config/json_loader.go b/eai_agentplatform/backend-go/internal/config/json_loader.go index 0bd23f0..d708b94 100644 --- a/eai_agentplatform/backend-go/internal/config/json_loader.go +++ b/eai_agentplatform/backend-go/internal/config/json_loader.go @@ -3,6 +3,7 @@ package config import ( "encoding/json" "fmt" + "net/url" "os" "path/filepath" "sort" @@ -27,6 +28,10 @@ type RouteInfo struct { Description string `json:"description,omitempty"` ShortRouteName string `json:"short_route_name,omitempty"` ShortModelName string `json:"short_model_name,omitempty"` + // SupportsSpeakers 仅 audio_routes 有意义：该 ASR 模型是否输出说话人分离。 + // 由配置显式声明而非按模型名猜——第 1 步要据此告诉用户「这次转写会不会有说话人标签」， + // 猜错就是对着用户说了句假话。 + SupportsSpeakers bool `json:"supports_speakers,omitempty"` } // RouteConfig 运行时完整路由配置（合并 secrets 后） @@ -40,25 +45,33 @@ type RouteConfig struct { APIKey string MaxTokens int Temperature float64 - TimeoutSeconds int // HTTP 超时（秒），0 表示使用默认 - Category string // chat / embed / image + TimeoutSeconds int // HTTP 超时（秒），0 表示使用默认 + Category string // chat / embed / image / video / audio Description string ShortRouteName string ShortModelName string + // SupportsSpeakers 见 RouteInfo 上的同名说明（仅 audio 类别有意义）。 + SupportsSpeakers bool } // AIConfig 顶层结构（支持分类路由） type AIConfig struct { - Version string `json:"version"` - Description string `json:"description"` - DefaultRoute string `json:"default_route"` - DefaultEmbedRoute string `json:"default_embed_route"` + Version string `json:"version"` + Description string `json:"description"` + DefaultRoute string `json:"default_route"` + DefaultEmbedRoute string `json:"default_embed_route"` + // DefaultAudioRoute 语音转写的兜底路由，参与 AutoAudioRouteID 的「优先」排序 + // （见 route_health.go 的 pickBestHealthyRoute）。出厂指向本地，即「优先本地路由」。 + DefaultAudioRoute string `json:"default_audio_route,omitempty"` AgentRoutes map[string]string `json:"agent_routes"` ChatRoutes map[string]RouteInfo `json:"chat_routes"` EmbedRoutes map[string]RouteInfo `json:"embed_routes"` ImageRoutes map[string]RouteInfo `json:"image_routes"` VideoRoutes map[string]RouteInfo `json:"video_routes"` - FallbackRoutes map[string][]string `json:"fallback_routes"` + // AudioRoutes 语音转写（ASR）路由。与上面四类的区别是它**不走 chat/completions**： + // endpoint 是 /audio/transcriptions，请求体是 multipart 而非 JSON。 + AudioRoutes map[string]RouteInfo `json:"audio_routes"` + FallbackRoutes map[string][]string `json:"fallback_routes"` // 兼容旧版平铺 routes（若有则回退） Routes map[string]RouteInfo `json:"routes,omitempty"` } @@ -67,7 +80,7 @@ type AIConfig struct { type AISecrets struct { VECTORENGINE_API_KEY string `json:"VECTORENGINE_API_KEY,omitempty"` OPENROUTER_API_KEY string `json:"OPENROUTER_API_KEY,omitempty"` - SILICONFLOW_API_KEY string `json:"SILICONFLOW_API_KEY,omitempty"` + SILICONFLOW_API_KEY string `json:"SILICONFLOW_API_KEY,omitempty"` VOLCES_API_KEY string `json:"VOLCES_API_KEY,omitempty"` LMUAI_API_KEY string `json:"LMUAI_API_KEY,omitempty"` ALIYUN_API_KEY string `json:"ALIYUN_API_KEY,omitempty"` @@ -76,6 +89,9 @@ type AISecrets struct { ANTHROPIC_API_KEY string `json:"ANTHROPIC_API_KEY,omitempty"` OPENAI_API_KEY string `json:"OPENAI_API_KEY,omitempty"` BRAVE_SEARCH_API_KEY string `json:"BRAVE_SEARCH_API_KEY,omitempty"` + // LOCAL_ASR_API_KEY 走本地回环的 ASR 服务本就不需要鉴权，这里只是给 + // 「密钥状态」面板一个可显示的条目；留空也能正常工作（见 IsLocalRoute）。 + LOCAL_ASR_API_KEY string `json:"LOCAL_ASR_API_KEY,omitempty"` } // PlatformConfig 平台静态配置 @@ -96,7 +112,7 @@ type PlatformConfig struct { var ProviderSecretKey = map[string]string{ "vectorengine": "VECTORENGINE_API_KEY", "openrouter": "OPENROUTER_API_KEY", - "siliconflow": "SILICONFLOW_API_KEY", + "siliconflow": "SILICONFLOW_API_KEY", "volces": "VOLCES_API_KEY", "lmuai": "LMUAI_API_KEY", "aliyun": "ALIYUN_API_KEY", @@ -105,18 +121,58 @@ var ProviderSecretKey = map[string]string{ "remove_bg": "REMOVE_BG_API_KEY", "anthropic": "ANTHROPIC_API_KEY", "openai": "OPENAI_API_KEY", + "local_asr": "LOCAL_ASR_API_KEY", } // ProviderDefaultBaseURL provider 默认 base_url（当 secrets 未提供时） var ProviderDefaultBaseURL = map[string]string{ "ollama": "http://127.0.0.1:11434/v1", - "llamacpp": "http://127.0.0.1:8080/v1", + "llamacpp": "http://127.0.0.1:8080/v1", "openrouter": "https://openrouter.ai/api/v1", - "siliconflow": "https://api.siliconflow.cn/v1", + "siliconflow": "https://api.siliconflow.cn/v1", "openai": "https://api.openai.com/v1", "vectorengine": "https://api.vectorengine.ai/v1", "volces": "https://ark.cn-beijing.volces.com/api/v3", "lmuai": "https://api.lmuai.com/v1", + "local_asr": "http://127.0.0.1:8090/v1", +} + +// IsLocalRoute 判断这条路由的流量是不是只在本机打转。 +// +// 判据是 **base_url 的 host 是不是回环地址**，而不是 provider 名或一张白名单： +// 要保护的正是「字节到底去了哪」，那就直接看它去哪，别用间接指标去猜。 +// 副产品是本机 llama.cpp / Ollama 也会被判为本地 —— 这是对的。 +// +// 一处实现三处共用（P06.18 的教训：判定逻辑各写一份必然走偏）： +// - buildRouteConfig：本地路由不要求配密钥 +// - RequiresRouteAPIKey：健康探测与通路测试同上 +// - audio_transcribe：据此在产物里标注「音频是否出网」 +func IsLocalRoute(route *RouteConfig) bool { + if route == nil { + return false + } + return isLoopbackURL(route.BaseURL) +} + +// isLoopbackURL 解析 URL 取 host，判断是否为回环地址。 +// 解析不了（空串、缺 scheme）一律当**非**本地 —— 判不准的时候按「会出网」处理， +// 宁可多要一次确认，也不要漏报一次出网。 +func isLoopbackURL(raw string) bool { + raw = strings.TrimSpace(raw) + if raw == "" { + return false + } + u, err := url.Parse(raw) + if err != nil || u.Host == "" { + return false + } + host := u.Hostname() // 自动剥掉端口，也自动处理 [::1] 的方括号 + switch strings.ToLower(host) { + case "127.0.0.1", "localhost", "::1": + return true + } + // 127.0.0.0/8 整段都是回环，不只 .0.1 + return strings.HasPrefix(host, "127.") } // ────────────────────────────────────────────── @@ -213,7 +269,8 @@ func LoadAIConfig(forceReload ...bool) (*AIConfig, error) { // 注意：本文件及 config/ai_config.json 保持多行、带缩进的普通格式。 // 严禁把 JSON 或本函数折叠成单行——单行会让格式错误难定位、diff 难读。 // （历史教训：ai_config.json 曾因缺一个右花括号导致整个 AI 路由不可用， -// 且文件原本被压成单行 5KB，错误极难排查。） +// +// 且文件原本被压成单行 5KB，错误极难排查。） func ValidateAIConfig() error { aiCfg, err := LoadAIConfig() if err != nil { @@ -231,9 +288,29 @@ func ValidateAIConfig() error { return fmt.Errorf("默认路由 %q 不可用: %w", id, err) } } + // 校验 default_audio_route。不校验的话写错一个字母也能启动，然后 + // audio_route_auto 会静默按延迟挑一条 —— 「优先本地」就这么没了， + // 而界面上看不出任何异常（这正是 G02 说的「配置缺失即报错」要拦的）。 + if id := strings.TrimSpace(aiCfg.DefaultAudioRoute); id != "" && id != AutoAudioRouteID { + if _, err := GetAudioRoute(id); err != nil { + return fmt.Errorf("默认语音路由 %q 不可用: %w", id, err) + } + } // 校验 agent_routes 中每个映射目标均可解析 for agent, rid := range aiCfg.AgentRoutes { - if _, err := GetRoute(rid); err != nil { + var err error + if agent == "audio_transcribe" { + // 转写这一条必须落在 audio_routes 里。用 GetRoute 校验它等于没校验： + // GetRoute 找不到会回退 default_route，于是一条拼错的音频路由能被 + // 一条 chat 路由「校验通过」，直到运行时才发现拿 ASR 请求打了聊天接口。 + // + // 只认这一个精确名字，不认 audio_ 前缀：audio_transcribe_llm 是**逐字稿 + // 加工**（chat 路由），跟 ASR 是两回事，按前缀一刀切会把它一起判错。 + _, err = GetAudioRoute(rid) + } else { + _, err = GetRoute(rid) + } + if err != nil { return fmt.Errorf("agent[%q] -> 路由 %q 不可用: %w", agent, rid, err) } } @@ -315,6 +392,12 @@ func GetRoute(agentOrRouteID string) (*RouteConfig, error) { if routeID == AutoEmbedRouteID { return resolveAutoRoute("embed") } + // audio 的 auto 也认，别让 GetRoute("audio_route_auto") 走到下面去 —— + // findRoute 找不到它会回退 default_route，于是「音频路由」变成一条 chat 路由。 + // 认它之后，这个 id 在任何入口都不会被解错（正经取音频路由仍推荐 GetAudioRoute）。 + if routeID == AutoAudioRouteID { + return resolveAutoRoute("audio") + } // 2) 在分类路由中查找 info, category, found := findRoute(aiCfg, routeID) @@ -330,6 +413,118 @@ func GetRoute(agentOrRouteID string) (*RouteConfig, error) { } // 4) 从 secrets 注入 base_url / api_key + return buildRouteConfig(routeID, info, category) +} + +// GetAudioRoute 解析语音转写（ASR）路由。 +// +// 与 GetRoute 的唯一区别，也是它存在的全部理由：**只**在 audio_routes 里找， +// 找不到就报错，**绝不回退 default_route**。GetRoute 的回退链是为 chat 设计的， +// 拿它取音频路由会在配置写错时静默返回一条 chat 路由，然后用 /chat/completions +// 去打 ASR 模型 —— 报错信息会指向模型或密钥，与真实原因（路由配错）毫无关系。 +func GetAudioRoute(agentOrRouteID string) (*RouteConfig, error) { + aiCfg, err := LoadAIConfig() + if err != nil { + return nil, fmt.Errorf("AI 配置加载失败: %w", err) + } + + routeID := agentOrRouteID + if r, ok := aiCfg.AgentRoutes[agentOrRouteID]; ok { + routeID = r + } + + // auto 也走 resolveAutoRoute，但传的是 "audio" —— 返回的一定是 audio 路由， + // 不会顺手把 chat 路由塞进来。 + if routeID == AutoAudioRouteID { + return resolveAutoRoute("audio") + } + + info, ok := aiCfg.AudioRoutes[routeID] + if !ok { + return nil, fmt.Errorf( + "音频路由 %q（agent %q）未在 ai_config.json 的 audio_routes 中定义；语音转写不回退默认 chat 路由", + routeID, agentOrRouteID) + } + return buildRouteConfig(routeID, info, "audio") +} + +// GetRouteForCategory 按分类解析路由 id。 +// +// 存在的唯一理由：audio 必须走 GetAudioRoute。GetRoute 找不到路由时会回退 +// default_route，那条链是为 chat 设计的 —— 拿它解析音频 id，写错一个字母就会 +// 静默返回一条 chat 路由，而症状是「拿 /chat/completions 去打 ASR 服务」， +// 报错指向模型或密钥，与真实原因（路由配错）毫无关系。 +// +// 一处实现，三个调用方（auto 选路的兜底、路由列表的 auto 项、健康探测的过滤）， +// 各写一份必然走偏。 +func GetRouteForCategory(routeID, category string) (*RouteConfig, error) { + if category == "audio" { + return GetAudioRoute(routeID) + } + return GetRoute(routeID) +} + +// GetDeclaredAudioRoute 取「按配置声明该用的」那条音频路由，**不看健康状态**。 +// +// 与 GetAudioRoute 的区别只有这一点，但它是必需的：audio_transcribe 现在指向 +// auto，而 auto 会按此刻哪台服务活着挑一条。对「真的去转写」这是对的；对 +// 「这次转写有没有说话人标签」这种**能力问题**就不行了 —— 第 1 步（确认范围）、 +// 第 2 步（转写）、第 5/6 步（闸门）是三次独立解析，中间隔着几分钟， +// 用 auto 会出现「第 1 步说要区分说话人、第 2 步落到一条不区分的路由」， +// 或者更糟：闸门以为没有标签而放行，模型猜的身份就这样进了正式纪要。 +// +// 声明值（default_audio_route）是这一问的权威答案，而且它不随进程启停变化。 +// 配套约束见 route_health.go 的 resolveAutoRoute：auto 只在与声明路由**同样的 +// 说话人能力**的候选里挑，所以「声明值」和「实际跑的那条」在这个维度上恒等。 +// +// 没声明（留空或写成 auto）时退回 GetAudioRoute —— 此时确实没有声明可依。 +func GetDeclaredAudioRoute() (*RouteConfig, error) { + aiCfg, err := LoadAIConfig() + if err != nil { + return nil, fmt.Errorf("AI 配置加载失败: %w", err) + } + id := strings.TrimSpace(aiCfg.DefaultAudioRoute) + if id == "" || id == AutoAudioRouteID { + return GetAudioRoute("audio_transcribe") + } + return GetAudioRoute(id) +} + +// GetFallbackAudioRoutes 取音频路由的回退链（主路由不可用时依次尝试）。 +// +// 为什么不用 GetFallbackRoutes：它内部用 GetRoute(fid)，而 GetRoute 找不到时 +// 会回退 default_route —— 一条拼错的 audio 回退 id 会被静默换成一条 chat 路由， +// 直到 TranscribeBytes 的分类检查才报错，报错文案指向「分类不对」而不是 +// 「配置写错了」。这与 GetAudioRoute 当初存在的理由完全同构。 +// +// 额外过滤掉**说话人能力不同**的候选：回退是为了「这条路由此刻不行」， +// 不是为了「悄悄换掉能力」。默认路由带说话人分离时退到一条不带的， +// 下游第 3 步会硬失败，而闸门还会因为读到 false 而放行。宁可不回退。 +func GetFallbackAudioRoutes(primaryRouteID string) []*RouteConfig { + aiCfg, err := LoadAIConfig() + if err != nil { + return nil + } + primary, err := GetAudioRoute(primaryRouteID) + if err != nil { + return nil + } + var result []*RouteConfig + for _, fid := range aiCfg.FallbackRoutes[primaryRouteID] { + r, err := GetAudioRoute(fid) + if err != nil { + continue + } + if r.SupportsSpeakers != primary.SupportsSpeakers { + continue + } + result = append(result, r) + } + return result +} + +// buildRouteConfig 把 RouteInfo 组装成 RouteConfig，并注入 base_url / api_key。 +func buildRouteConfig(routeID string, info RouteInfo, category string) (*RouteConfig, error) { baseURL := "" apiKey := "" secrets, _ := LoadAISecrets() @@ -353,20 +548,21 @@ func GetRoute(agentOrRouteID string) (*RouteConfig, error) { fullURL := strings.TrimRight(baseURL, "/") + info.Endpoint rc := &RouteConfig{ - RouteID: routeID, - Provider: info.Provider, - Model: info.Model, - BaseURL: baseURL, - Endpoint: info.Endpoint, - FullURL: fullURL, - APIKey: apiKey, - MaxTokens: info.MaxTokens, - Temperature: info.Temperature, - TimeoutSeconds: info.TimeoutSeconds, - Category: category, - Description: info.Description, - ShortRouteName: info.ShortRouteName, - ShortModelName: info.ShortModelName, + RouteID: routeID, + Provider: info.Provider, + Model: info.Model, + BaseURL: baseURL, + Endpoint: info.Endpoint, + FullURL: fullURL, + APIKey: apiKey, + MaxTokens: info.MaxTokens, + Temperature: info.Temperature, + TimeoutSeconds: info.TimeoutSeconds, + Category: category, + Description: info.Description, + ShortRouteName: info.ShortRouteName, + ShortModelName: info.ShortModelName, + SupportsSpeakers: info.SupportsSpeakers, } if rc.MaxTokens <= 0 { rc.MaxTokens = 2048 @@ -399,6 +595,11 @@ func findRoute(cfg *AIConfig, routeID string) (RouteInfo, string, bool) { return info, "video", true } } + if cfg.AudioRoutes != nil { + if info, ok := cfg.AudioRoutes[routeID]; ok { + return info, "audio", true + } + } // 兼容旧版平铺 routes if cfg.Routes != nil { if info, ok := cfg.Routes[routeID]; ok { @@ -415,8 +616,8 @@ func getSecretByField(s *AISecrets, field string) string { return s.VECTORENGINE_API_KEY case "OPENROUTER_API_KEY": return s.OPENROUTER_API_KEY - case "SILICONFLOW_API_KEY": - return s.SILICONFLOW_API_KEY + case "SILICONFLOW_API_KEY": + return s.SILICONFLOW_API_KEY case "VOLCES_API_KEY": return s.VOLCES_API_KEY case "LMUAI_API_KEY": @@ -480,6 +681,8 @@ func GetRoutesByCategory(category string) ([]*RouteConfig, error) { routeMap = aiCfg.ImageRoutes case "video": routeMap = aiCfg.VideoRoutes + case "audio": + routeMap = aiCfg.AudioRoutes default: return nil, fmt.Errorf("未知路由分类: %s", category) } @@ -492,7 +695,15 @@ func GetRoutesByCategory(category string) ([]*RouteConfig, error) { var result []*RouteConfig for _, rid := range keys { - r, err := GetRoute(rid) + // audio 走 GetAudioRoute：GetRoute 找不到时会回退 default_route， + // 那条链是为 chat 设计的，会把一条 chat 路由当成音频路由返回。 + var r *RouteConfig + var err error + if category == "audio" { + r, err = GetAudioRoute(rid) + } else { + r, err = GetRoute(rid) + } if err != nil { continue } diff --git a/eai_agentplatform/backend-go/internal/config/route_health.go b/eai_agentplatform/backend-go/internal/config/route_health.go index b810c63..a64c9cd 100644 --- a/eai_agentplatform/backend-go/internal/config/route_health.go +++ b/eai_agentplatform/backend-go/internal/config/route_health.go @@ -15,11 +15,25 @@ import ( const ( AutoChatRouteID = "chat_route_auto" AutoEmbedRouteID = "embed_route_auto" + AutoAudioRouteID = "audio_route_auto" defaultAIRouteProbeInterval = 30 * time.Minute defaultAIRouteProbeTimeout = 20 * time.Second ) +// IsAutoRouteID 判断这个 id 是不是「自动选择」占位符。 +// +// 它解析出来的永远**不是**自己：resolveAutoRoute 会换成此刻健康的那条具体路由。 +// 于是任何「解析结果应当等于请求的 id」的校验都必须先放行这一类 id， +// 否则通路测试里选「自动」就会报「路由不存在」。 +func IsAutoRouteID(routeID string) bool { + switch routeID { + case AutoChatRouteID, AutoEmbedRouteID, AutoAudioRouteID: + return true + } + return false +} + type RouteHealth struct { AIRouteID string `json:"ai_route_id"` Category string `json:"category"` @@ -55,6 +69,7 @@ func StartAIRouteHealthLoop(interval time.Duration) { func RefreshAIRouteHealthNow() { refreshAIRouteHealthForCategory("chat") refreshAIRouteHealthForCategory("embed") + refreshAIRouteHealthForCategory("audio") } func GetRouteHealth(routeID string) (RouteHealth, bool) { @@ -77,12 +92,35 @@ func resolveAutoRoute(category string) (*RouteConfig, error) { } defaultRouteID := getDefaultRouteIDForCategory(category) + // audio 的能力约束：只在**说话人能力与声明路由相同**的候选里挑。 + // + // 默认路由（本地 whisper+pyannote）带说话人分离，而它一旦不健康， + // 现有排序会把候选里唯一还活着的 audio_route_siliconflow_qwen3 选出来 —— + // 那条不支持说话人分离。这不是「降级可用」：下游第 3 步会硬失败， + // 而闸门读到 supports_speakers=false 后直接放行，模型猜的身份就进了正式纪要。 + // 宁可这次转写失败（用户看得见，可以去修本地服务），也不要静默换掉能力。 + if category == "audio" && defaultRouteID != "" { + if declared, err := GetAudioRoute(defaultRouteID); err == nil && declared != nil { + kept := routes[:0:0] + for _, r := range routes { + if r != nil && r.SupportsSpeakers == declared.SupportsSpeakers { + kept = append(kept, r) + } + } + if len(kept) > 0 { + routes = kept + } + } + } + best := pickBestHealthyRoute(routes, defaultRouteID) if best != nil { return best, nil } if defaultRouteID != "" { - if route, err := GetRoute(defaultRouteID); err == nil && route != nil { + // 按分类取：GetRoute 对 audio 会回退到 chat 的 default_route， + // 于是「音频路由」会变成一条 chat 路由返回给调用方。 + if route, err := GetRouteForCategory(defaultRouteID, category); err == nil && route != nil { return route, nil } } @@ -180,6 +218,13 @@ func getDefaultRouteIDForCategory(category string) string { if aiCfg.DefaultEmbedRoute != AutoEmbedRouteID { return aiCfg.DefaultEmbedRoute } + case "audio": + // 「优先本地路由」就是靠这一支实现的：default_audio_route 出厂指向本地， + // pickBestHealthyRoute 先按 isDefault 排序，本地健康就赢；本地不健康时才 + // 轮到云端。不新造机制，与 chat/embed 同一套。 + if aiCfg.DefaultAudioRoute != AutoAudioRouteID { + return aiCfg.DefaultAudioRoute + } } return "" } @@ -203,7 +248,7 @@ func probeRoute(route *RouteConfig) RouteHealth { status.LastError = "base_url 未配置" return status } - if requiresRouteAPIKey(route) && strings.TrimSpace(route.APIKey) == "" { + if RequiresRouteAPIKey(route) && strings.TrimSpace(route.APIKey) == "" { status.LastError = "API Key 未配置" return status } @@ -213,6 +258,8 @@ func probeRoute(route *RouteConfig) RouteHealth { switch route.Category { case "embed": err = probeEmbedRoute(client, route) + case "audio": + err = probeAudioRoute(client, route) default: err = probeChatRoute(client, route) } @@ -268,6 +315,55 @@ func probeEmbedRoute(client *http.Client, route *RouteConfig) error { return nil } +// probeAudioRoute 探 ASR 路由。 +// +// 探的是 `GET {base_url}/models`，**不是**「发一小段音频试转」：转写要跑 GPU、 +// 分钟级、在云端还计费，30 分钟一轮的巡检绝不能这么干。/v1/models 是 OpenAI +// 兼容服务的标准发现端点（本地 serve.py 与云端中转都实现了），几毫秒就回来。 +// +// 404/405 不算失败：那只说明这个服务没实现 /v1/models，不代表它不能转写。 +// 此时只断言「连得上」，并在注释里说清楚这一步验到哪为止 —— 宁可弱一点， +// 也不能因为探测手段缺失把一条好路由判死。判死的代价是回退链上少一个候选： +// 本机 ASR 一挂，就再没有云端可退了（这正是「自动回退云端」要保住的东西）。 +func probeAudioRoute(client *http.Client, route *RouteConfig) error { + if strings.TrimSpace(route.BaseURL) == "" { + return fmt.Errorf("base_url 未配置") + } + url := strings.TrimRight(strings.TrimSpace(route.BaseURL), "/") + "/models" + req, err := http.NewRequest(http.MethodGet, url, nil) + if err != nil { + return err + } + if strings.TrimSpace(route.APIKey) != "" { + req.Header.Set("Authorization", "Bearer "+route.APIKey) + } + resp, err := client.Do(req) + if err != nil { + return fmt.Errorf("服务不可达: %w", err) + } + defer resp.Body.Close() + + data, err := io.ReadAll(resp.Body) + if err != nil { + return fmt.Errorf("读取响应失败: %w", err) + } + if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusMethodNotAllowed { + // 只验到「连得上」，没验转写能力。不撒谎说探过了。 + return nil + } + if resp.StatusCode != http.StatusOK { + return fmt.Errorf("返回 %d: %s", resp.StatusCode, truncateProbeText(string(data), 160)) + } + // 200 必须是 JSON：公网门户/劫持页也会回 200，回 HTML 就说明没打到真服务。 + var out struct { + Data []json.RawMessage `json:"data"` + } + if err := json.Unmarshal(data, &out); err != nil { + return fmt.Errorf("响应不是 JSON: %w", err) + } + return nil +} + func doRouteProbeRequest(client *http.Client, route *RouteConfig, body any, out any) error { raw, err := json.Marshal(body) if err != nil { @@ -300,10 +396,26 @@ func doRouteProbeRequest(client *http.Client, route *RouteConfig, body any, out return nil } -func requiresRouteAPIKey(route *RouteConfig) bool { +// RequiresRouteAPIKey 这条路由是否必须带密钥（探测与调用共用同一个判据）。 +// +// 回环路由直接免检：本机服务（本地 ASR、本地 llama.cpp）绑在 127.0.0.1 上， +// 本来就不对外，要密钥是无意义的门槛。判据与转写侧共用 IsLocalRoute， +// 不各写一份 —— 两份判定走偏时的症状是「探测说健康、转写却报缺密钥」。 +// +// 注意**没有**改成「非本地一律要密钥」：那会顺带把 siliconflow / volces 这些 +// 本来不检查的路由也变成必须配密钥，属于本次改动之外的回归。 +// +// 导出是因为 routetest 与 ai/llm 各抄了一份同样的逻辑。三份在今天的配置上 +// 恰好同结论（本地路由的 provider 不是 openai/openrouter），但只有这一份知道 +// 「回环地址免密钥」——另两份一旦需要这条规则就得再改一遍，漏改的那份会以 +// 「测试说缺密钥、真实调用却通」的形式表现，最难查。 +func RequiresRouteAPIKey(route *RouteConfig) bool { if route == nil { return false } + if IsLocalRoute(route) { + return false + } baseURL := strings.ToLower(strings.TrimSpace(route.BaseURL)) if strings.Contains(baseURL, "openrouter.ai") || strings.Contains(baseURL, "openai.com") { return true diff --git a/eai_agentplatform/backend-go/internal/config/validate_audio_config_test.go b/eai_agentplatform/backend-go/internal/config/validate_audio_config_test.go new file mode 100644 index 0000000..8de4817 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/config/validate_audio_config_test.go @@ -0,0 +1,77 @@ +package config + +import ( + "encoding/json" + "os" + "path/filepath" + "testing" +) + +// TestValidateAIConfigRejectsBrokenAudioRoutes 钉住「配错的路由在启动时就报错」。 +// +// 为什么值得钉：这两种写错都**不会**在运行期报出像样的错。 +// - default_audio_route 拼错：auto 会退化成按延迟挑一条，「优先本地」无声失效； +// - audio_transcribe 指到 chat 路由：拿 ASR 请求打聊天接口，报错指向模型或密钥。 +// +// GetRoute 的兜底回退（找不到就返回 default_route）本来是这两个的帮凶 —— +// 它让「一条拼错的音频路由」能被一条 chat 路由校验通过。 +// +// 在临时目录里改一份配置副本，不碰线上那份（与 audio_route_test.go 的 TestMain +// 配合：它已把 CWD 切到 backend-go，这里靠 Chdir + ResetCache 换到临时配置）。 +func TestValidateAIConfigRejectsBrokenAudioRoutes(t *testing.T) { + real, err := os.ReadFile("config/ai_config.json") + if err != nil { + t.Fatal(err) + } + for _, tc := range []struct { + name string + mutate func(map[string]any) + wantErr bool + }{ + {"default_audio_route 拼错", func(m map[string]any) { + m["default_audio_route"] = "audio_route_local_whispper" + }, true}, + {"agent audio_transcribe 指向 chat", func(m map[string]any) { + m["agent_routes"].(map[string]any)["audio_transcribe"] = "chat_route_lmuai_deepseek_v4_flash" + }, true}, + {"原样", func(map[string]any) {}, false}, + } { + t.Run(tc.name, func(t *testing.T) { + var m map[string]any + if err := json.Unmarshal(real, &m); err != nil { + t.Fatal(err) + } + tc.mutate(m) + raw, _ := json.Marshal(m) + + dir := t.TempDir() + if err := os.MkdirAll(filepath.Join(dir, "config"), 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(dir, "config", "ai_config.json"), raw, 0o644); err != nil { + t.Fatal(err) + } + // ai_secrets.json 也带上，否则云端路由会被判成「缺密钥」 + sec, _ := os.ReadFile("config/ai_secrets.json") + _ = os.WriteFile(filepath.Join(dir, "config", "ai_secrets.json"), sec, 0o644) + + prev, _ := os.Getwd() + if err := os.Chdir(dir); err != nil { + t.Fatal(err) + } + ResetCache() + got := ValidateAIConfig() + _ = os.Chdir(prev) + ResetCache() + os.RemoveAll(dir) + + t.Logf("%s → err=%v", tc.name, got) + if tc.wantErr && got == nil { + t.Errorf("期望报错，却校验通过") + } + if !tc.wantErr && got != nil { + t.Errorf("期望通过，却报错：%v", got) + } + }) + } +} diff --git a/eai_agentplatform/backend-go/internal/dal/netdisk.go b/eai_agentplatform/backend-go/internal/dal/netdisk.go new file mode 100644 index 0000000..52722b4 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/dal/netdisk.go @@ -0,0 +1,129 @@ +package dal + +import ( + "eai_agentplatform/backend/internal/model" +) + +// NetdiskFolderDAO 网盘目录仓库。 +type NetdiskFolderDAO struct{ *QueryBuilder } + +// GetByID 按 ID 获取目录。 +func (r NetdiskFolderDAO) GetByID(id uint) (model.NetdiskFolder, bool) { + var m model.NetdiskFolder + if r.Type(&m).Where("id = ?", id).First(&m) { + return m, true + } + return model.NetdiskFolder{}, false +} + +// Insert 创建目录。 +func (r NetdiskFolderDAO) Insert(m *model.NetdiskFolder) bool { + return r.QueryBuilder.Insert(m) +} + +// Update 更新目录。 +func (r NetdiskFolderDAO) Update(m *model.NetdiskFolder) bool { + return r.Save(m) +} + +// Delete 物理删除目录。 +func (r NetdiskFolderDAO) Delete(id uint) bool { + return r.DeleteByID(&model.NetdiskFolder{}, id) +} + +// GetByPath 按全等路径查目录（目录名唯一）。 +func (r NetdiskFolderDAO) GetByPath(companyID uint, path string) (model.NetdiskFolder, bool) { + var m model.NetdiskFolder + if r.Type(&m).Where("company_id = ? AND path = ?", companyID, path).First(&m) { + return m, true + } + return model.NetdiskFolder{}, false +} + +// ListDescendants 按 company 返回全部目录（含子目录），按 path 升序。 +func (r NetdiskFolderDAO) ListDescendants(companyID uint, prefix string) []model.NetdiskFolder { + var items []model.NetdiskFolder + if prefix == "" { + r.Type(&items).Where("company_id = ?", companyID).Order("path ASC").Find(&items) + } else { + r.Type(&items).Where("company_id = ? AND (path = ? OR path LIKE ?)", + companyID, prefix, prefix+"/%"). + Order("path ASC").Find(&items) + } + return items +} + +// CountChildren 统计某目录直属子目录数量。 +func (r NetdiskFolderDAO) CountChildren(companyID uint, parentPath string) int64 { + return r.Type(&model.NetdiskFolder{}). + Where("company_id = ? AND path LIKE ?", + companyID, parentPath+"/%"). + Count() +} + +// NetdiskFileDAO 网盘文件仓库。 +type NetdiskFileDAO struct{ *QueryBuilder } + +// GetByID 按 ID 获取文件。 +func (r NetdiskFileDAO) GetByID(id uint) (model.NetdiskFile, bool) { + var m model.NetdiskFile + if r.Type(&m).Where("id = ?", id).First(&m) { + return m, true + } + return model.NetdiskFile{}, false +} + +// Insert 创建文件记录。 +func (r NetdiskFileDAO) Insert(m *model.NetdiskFile) bool { + return r.QueryBuilder.Insert(m) +} + +// Update 更新文件记录。 +func (r NetdiskFileDAO) Update(m *model.NetdiskFile) bool { + return r.Save(m) +} + +// HardDelete 彻底删除文件记录。 +func (r NetdiskFileDAO) HardDelete(id uint) bool { + return r.DeleteByID(&model.NetdiskFile{}, id) +} + +// ListByFolder 列出某目录下、指定状态、且不在回收站的文件（按 id 降序）。 +func (r NetdiskFileDAO) ListByFolder(companyID uint, folderPath, status string) []model.NetdiskFile { + var items []model.NetdiskFile + q := r.Type(&model.NetdiskFile{}). + Where("company_id = ? AND folder_path = ? AND deleted_at IS NULL", + companyID, folderPath) + if status != "" { + q = q.Where("status = ?", status) + } + if q.Order("id DESC").Find(&items) { + return items + } + return nil +} + +// ListInRecycle 回收站列表（软删除标记非空），按删除时间倒序。 +func (r NetdiskFileDAO) ListInRecycle(companyID uint) []model.NetdiskFile { + var items []model.NetdiskFile + if r.Type(&items). + Where("company_id = ? AND deleted_at IS NOT NULL", companyID). + Order("deleted_at DESC").Find(&items) { + return items + } + return nil +} + +// ListForAudit 审批列表（分页，含待审批/最近已处理），不在回收站，created_at 倒序。 +func (r NetdiskFileDAO) ListForAudit(companyID uint, status string, page, size int) (int64, []model.NetdiskFile) { + q := r.Inner().Model(&model.NetdiskFile{}). + Where("company_id = ? AND deleted_at IS NULL", companyID) + if status != "" { + q = q.Where("status = ?", status) + } + var total int64 + q.Count(&total) + var items []model.NetdiskFile + q.Order("created_at DESC").Offset((page - 1) * size).Limit(size).Find(&items) + return total, items +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/model/netdisk.go b/eai_agentplatform/backend-go/internal/model/netdisk.go new file mode 100644 index 0000000..007991d --- /dev/null +++ b/eai_agentplatform/backend-go/internal/model/netdisk.go @@ -0,0 +1,52 @@ +package model + +import "time" + +// NetdiskFolder 网盘目录（团队共享，路径式组织）。 +// +// 设计对齐 pj0034 的 asset_folder：path 为 `/` 分隔的绝对路径（如 `/市场部/2026Q1`）， +// 用唯一约束 (company_id, path) 防重名。`/` 根目录是 system folder，不可删/改名。 +// 团队共享盘：全公司共用一套目录树，company_id 统一取创始公司 Id，跨部门共享。 +type NetdiskFolder struct { + ID uint `gorm:"primaryKey" json:"id"` + CompanyID uint `gorm:"not null;index" json:"company_id"` + Path string `gorm:"size:500;not null;index" json:"path"` + DisplayName string `gorm:"size:100;not null" json:"display_name"` + CreatedByID uint `gorm:"not null" json:"created_by_id"` + CreatedAt time.Time `json:"created_at"` +} + +func (NetdiskFolder) TableName() string { return "netdisk_folder" } + +// NetdiskFile 网盘文件（团队共享，审批前置）。 +// +// 状态流转： +// - Status: pending(待审批) / approved(已通过) / rejected(已驳回) +// - Recycle: deleted_at/deleted_by 非空表示已移入回收站（软删除），可恢复或彻底删除 +// +// 审批前置（对齐现有素材管理制度）：员工上传进入 pending，需管理员审批通过后才对团队可见； +// 管理员上传自动 approved。已 approved 的文件才对其它成员暴露。 +// FolderPath 记录文件所在的目录路径（冗余自目录表，便于按路径列出与移动）。 +type NetdiskFile struct { + ID uint `gorm:"primaryKey" json:"id"` + CompanyID uint `gorm:"not null;index" json:"company_id"` + FolderPath string `gorm:"size:500;not null;default:/;index" json:"folder_path"` + Filename string `gorm:"size:256;not null" json:"filename"` + StoredName string `gorm:"size:64;not null" json:"stored_name"` + FileExt string `gorm:"size:16;not null" json:"file_ext"` + MimeType string `gorm:"size:128" json:"mime_type"` + FileSize int64 `gorm:"not null" json:"file_size"` + Status string `gorm:"size:16;not null;default:pending;index" json:"status"` // pending / approved / rejected + Source string `gorm:"size:16;not null" json:"source"` // employee / admin + SubmitterID uint `gorm:"not null;index" json:"submitter_id"` + RejectReason string `gorm:"size:512" json:"reject_reason"` + AuditBy *uint `json:"audit_by"` + AuditAt *time.Time `json:"audit_at"` + // 回收站软删除 + DeletedAt *time.Time `gorm:"index" json:"deleted_at"` + DeletedBy *uint `json:"deleted_by"` + CreatedAt time.Time `json:"created_at"` + UpdatedAt time.Time `json:"updated_at"` +} + +func (NetdiskFile) TableName() string { return "netdisk_file" } \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/search/browser_search.go b/eai_agentplatform/backend-go/internal/search/browser_search.go new file mode 100644 index 0000000..72a165e --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/browser_search.go @@ -0,0 +1,192 @@ +package search + +import ( + "context" + "fmt" + "net/url" + "strings" + "sync" + "time" + + "github.com/playwright-community/playwright-go" +) + +// browserSearchTimeout 单次浏览器搜索的整体上限。 +const browserSearchTimeout = 25 * time.Second + +// browserSearchMaxResult 浏览器源单次最多返回结果数。 +const browserSearchMaxResult = 8 + +// BrowserSearcher 用 Playwright + 系统 Chrome 驱动真实浏览器抓取搜索结果。 +// +// 背景：SearXNG / 纯 HTTP 抓取都会被百度和搜狗的反爬（checkSNUID、验证码、UA 检测） +// 拦截，无法稳定取到按关键词匹配的真实结果。真实浏览器（本机 google-chrome， +// channel="chrome"）可天然通过 JS 反爬，是「通用可搜」闭环的最终兜底来源。 +// +// 设计要点（单进程、懒加载、并发安全）： +// - 浏览器实例全局懒加载，只启动一次，进程内复用； +// - Search 用互斥锁串行化，避免多个并发 worker 同时驱动同一浏览器导致页面串扰； +// - 每次查询用独立 BrowserContext+Page，查询间相互隔离； +// - 浏览器不可用时优雅失败（返回错误而非 panic），由上层回退到已有逻辑。 +// +// 运行期依赖（新环境需先就绪）： +// - 系统必须装有 google-chrome（channel="chrome" 复用，免下载 Chromium）； +// - playwright 驱动需先就绪：上游 CDN 已失效，故用 npm 装 playwright-core@1.60.0， +// 将 node_modules/playwright-core 复制为 ~/.cache/ms-playwright-go/1.60.0/package， +// 并 ln -s /usr/bin/node ~/.cache/ms-playwright-go/1.60.0/node。 +// 装好即可，Search() 只调用 playwright.Run()，不做浏览器下载。 +type BrowserSearcher struct { + startOnce sync.Once + startErr error + browser playwright.Browser + + mu sync.Mutex +} + +var browserSearcher *BrowserSearcher + +func init() { + browserSearcher = &BrowserSearcher{} +} + +// GetBrowserSearcher 返回全局单例浏览器搜索器。 +func GetBrowserSearcher() *BrowserSearcher { + return browserSearcher +} + +// Search 用真实浏览器抓取并解析结果，返回 []Result。 +func (b *BrowserSearcher) Search(query string) ([]Result, error) { + b.mu.Lock() + defer b.mu.Unlock() + + if err := b.ensureBrowser(); err != nil { + return nil, err + } + + ctx, cancel := context.WithTimeout(context.Background(), browserSearchTimeout) + defer cancel() + + // 每查询独立 context+page，隔离 cookies 与反爬指纹。 + page, err := b.newPage(ctx) + if err != nil { + return nil, fmt.Errorf("创建浏览器页失败: %w", err) + } + defer func() { _ = page.Close() }() + + // 依次尝试百度、搜狗，任一成功即返回。 + if res, err := b.searchBaidu(ctx, page, query); err == nil && len(res) > 0 { + return res, nil + } + if res, err := b.searchSogou(ctx, page, query); err == nil && len(res) > 0 { + return res, nil + } + return nil, fmt.Errorf("浏览器搜索无结果（百度/搜狗均未命中）") +} + +// ensureBrowser 懒加载并启动系统 Chrome（channel=chrome，复用系统浏览器，免下载 Chromium）。 +func (b *BrowserSearcher) ensureBrowser() error { + b.startOnce.Do(func() { + pw, err := playwright.Run() + if err != nil { + b.startErr = fmt.Errorf("启动 playwright 驱动失败: %w", err) + return + } + browser, err := pw.Chromium.Launch(playwright.BrowserTypeLaunchOptions{ + Channel: playwright.String("chrome"), // 使用系统已装的 google-chrome，免下载 Chromium + Headless: playwright.Bool(true), + Args: []string{"--no-sandbox", "--disable-dev-shm-usage", "--disable-gpu"}, + IgnoreDefaultArgs: []string{"--enable-automation"}, + }) + if err != nil { + b.startErr = fmt.Errorf("启动系统 Chrome 失败: %w", err) + return + } + b.browser = browser + }) + return b.startErr +} + +const browserUA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36" + +// newPage 创建隔离的浏览器页面。 +func (b *BrowserSearcher) newPage(ctx context.Context) (playwright.Page, error) { + bctx, err := b.browser.NewContext(playwright.BrowserNewContextOptions{ + Locale: playwright.String("zh-CN"), + UserAgent: playwright.String(browserUA), + Viewport: &playwright.Size{Width: 1366, Height: 900}, + Permissions: []string{"geolocation"}, + }) + if err != nil { + return nil, err + } + page, err := bctx.NewPage() + if err != nil { + _ = bctx.Close() + return nil, err + } + return page, nil +} + +// searchBaidu 抓取百度搜索结果。

标题。 +func (b *BrowserSearcher) searchBaidu(ctx context.Context, page playwright.Page, query string) ([]Result, error) { + if _, err := page.Goto("https://www.baidu.com/s?wd="+url.QueryEscape(query), playwright.PageGotoOptions{ + Timeout: playwright.Float(20000), + WaitUntil: playwright.WaitUntilStateDomcontentloaded, + }); err != nil { + return nil, err + } + // 等若干条结果标题元素出现。 + if _, err := page.WaitForSelector("h3", playwright.PageWaitForSelectorOptions{Timeout: playwright.Float(15000)}); err != nil { + return nil, fmt.Errorf("百度结果未渲染: %w", err) + } + + items, err := page.Locator("h3").All() + if err != nil { + return nil, err + } + var res []Result + for _, h := range items { + a := h.Locator("a").First() + title, _ := a.InnerText() + href, _ := a.GetAttribute("href") + if strings.TrimSpace(title) == "" || href == "" { + continue + } + res = append(res, Result{Title: strings.TrimSpace(title), URL: href, Content: "", Engine: "baidu_browser"}) + if len(res) >= browserSearchMaxResult { + break + } + } + return res, nil +} + +// searchSogou 抓取搜狗搜索结果（真实浏览器可过 checkSNUID）。 +func (b *BrowserSearcher) searchSogou(ctx context.Context, page playwright.Page, query string) ([]Result, error) { + if _, err := page.Goto("https://www.sogou.com/web?query="+url.QueryEscape(query), playwright.PageGotoOptions{ + Timeout: playwright.Float(20000), + WaitUntil: playwright.WaitUntilStateDomcontentloaded, + }); err != nil { + return nil, err + } + if _, err := page.WaitForSelector("h3", playwright.PageWaitForSelectorOptions{Timeout: playwright.Float(15000)}); err != nil { + return nil, fmt.Errorf("搜狗结果未渲染: %w", err) + } + items, err := page.Locator("h3").All() + if err != nil { + return nil, err + } + var res []Result + for _, h := range items { + a := h.Locator("a").First() + title, _ := a.InnerText() + href, _ := a.GetAttribute("href") + if strings.TrimSpace(title) == "" || href == "" { + continue + } + res = append(res, Result{Title: strings.TrimSpace(title), URL: href, Content: "", Engine: "sogou_browser"}) + if len(res) >= browserSearchMaxResult { + break + } + } + return res, nil +} diff --git a/eai_agentplatform/backend-go/internal/search/client.go b/eai_agentplatform/backend-go/internal/search/client.go new file mode 100644 index 0000000..9aac298 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/client.go @@ -0,0 +1,105 @@ +package search + +import ( + "fmt" + "strings" +) + +// Result 单个搜索结果。 +type Result struct { + Title string `json:"title"` + URL string `json:"url"` + Content string `json:"content"` + Engine string `json:"engine"` +} + +// Response SearXNG /search?format=json 的标准响应（兼容旧响应结构）。 +type Response struct { + Query string `json:"query"` + Results []Result `json:"results"` +} + +// Client 搜索引擎聚合编排器。 +// +// 持有一组按优先级排序的 Engine，Search 按顺序逐个调用，命中（成功且有结果）即返回； +// 单个引擎失败/无结果时降级到下一引擎，全部失败再汇总根因。启用的引擎与顺序由 +// search_config.json 的 active 列表声明，替代此前写死代码里的硬编码回退链。 +type Client struct { + engines []Engine +} + +// NewConfiguredClient 按配置构建聚合 Client。 +// +// - cfg 为 nil（无配置文件）时使用默认硬编码链：SearXNG → 搜狗 HTTP → 真实浏览器， +// 保证旧行为不因缺配置而改变。 +// - cfg 非 nil 时按 active 列表顺序构建引擎，跳过 disabled 或未知类型者。 +func NewConfiguredClient(cfg *SearchConfig) *Client { + if cfg == nil { + return &Client{engines: defaultEngines()} + } + c := &Client{} + for _, name := range cfg.Active { + ec, ok := cfg.Engines[name] + if !ok || !ec.Enabled { + continue + } + if e, err := engineFromConfig(name, ec); err != nil { + // 未知类型直接跳过，不阻塞整链。 + continue + } else { + c.engines = append(c.engines, e) + } + } + // 配置全被跳过时回退默认链，避免空组织。 + if len(c.engines) == 0 { + c.engines = defaultEngines() + } + return c +} + +// defaultEngines 无配置时的默认硬编码链（保持旧行为）。 +func defaultEngines() []Engine { + return []Engine{ + &searxngEngine{client: NewSearXNGClient("")}, + &sogouEngine{client: NewSogouClient()}, + &browserEngine{searcher: GetBrowserSearcher()}, + } +} + +// EngineNames 返回当前生效的引擎名（有序），供诊断/展示。 +func (c *Client) EngineNames() []string { + names := make([]string, 0, len(c.engines)) + for _, e := range c.engines { + names = append(names, e.Name()) + } + return names +} + +// Search 按配置顺序逐个调用引擎，命中即返回首个有结果的引擎。 +// 全部引擎失败时聚合各引擎错误。 +func (c *Client) Search(query string) ([]Result, error) { + var errParts []string + for _, e := range c.engines { + res, err := e.Search(query) + if err == nil && len(res) > 0 { + return res, nil + } + errParts = append(errParts, fmt.Sprintf("%s:%v", e.Name(), orNil(err))) + } + return nil, fmt.Errorf("全部搜索引擎无结果：[%s]", strings.Join(errParts, "；")) +} + +func orNil(err error) any { + if err == nil { + return "无结果" + } + return err +} + +func truncate(s string, n int) string { + r := []rune(s) + if len(r) <= n { + return s + } + return string(r[:n]) + "..." +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/search/config.go b/eai_agentplatform/backend-go/internal/search/config.go new file mode 100644 index 0000000..1a39abc --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/config.go @@ -0,0 +1,29 @@ +package search + +import ( + "sync" +) + +const ( + // DefaultBaseURL 本机 SearXNG 服务默认地址（deploy/searxng docker-compose 映射）。 + DefaultBaseURL = "http://127.0.0.1:18080" + + // EnvBaseURL 环境变量名，可覆盖 SearXNG 地址（仅无 search_config.json 时的默认链有效）。 + EnvBaseURL = "SEARXNG_BASE_URL" +) + +var ( + defaultClient *Client + clientOnce sync.Once +) + +// GetClient 返回全局默认搜索客户端。 +// +// 实现：懒加载，读 search_config.json 构建聚合 Client（多引擎、有序、可配置）； +// 无配置文件时回退默认链（SearXNG → 搜狗 HTTP → 真实浏览器），保证旧行为不破功。 +func GetClient() *Client { + clientOnce.Do(func() { + defaultClient = NewConfiguredClient(GetSearchConfig()) + }) + return defaultClient +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/search/dtsai.go b/eai_agentplatform/backend-go/internal/search/dtsai.go new file mode 100644 index 0000000..9dd8319 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/dtsai.go @@ -0,0 +1,185 @@ +package search + +import ( + "bytes" + "crypto/rand" + "encoding/hex" + "encoding/json" + "fmt" + "io" + "net/http" + "os" + "strings" + "time" +) + +// DtsAIClient 调用阿里云 DTS-AI 服务（DtsAI, Version 2026-04-01）的 WebSearch 获取搜索结果。 +// +// 背景：SerpApi 是境外付费源，个别企业网络或跨境场景下连通性/合规受限。阿里云 DTS-AI +// 是部署在国内（cn-beijing）的官方搜索服务，服务器端完成检索，返回结构化 JSON、无验证码， +// 公测期间免费。可作为「通用可搜」闭环在国内的稳定补充源。 +// +// 认证：DTS-AI 支持两种凭据，本实现采用官方推荐的 API Key 方式——通过请求头 +// `X-Acs-ApiKey` 透传，无需计算 OpenAPI 签名，便于轻量集成。key 从环境变量 +// `DTS_AI_API_KEY` 读取（可在 search_config.json 的 api_key_env 覆盖）。未配置 key 时 +// Search 返回 (nil, skipDtsAIError) 让上层回退到下一引擎，保证无 key 也能跑。 +// +// 调用方式（curl 实测对等）： +// +// POST https://dtsai.cn-beijing.aliyuncs.com?Action=WebSearch&Version=2026-04-01&SignatureNonce= +// Header: X-Acs-ApiKey: Content-Type: application/json +// Body: {"RegionId":"cn-beijing","Query":"...","MaxResults":N} +type DtsAIClient struct { + apiKey string + region string + endpoint string + maxResults int + timeout time.Duration + hc *http.Client +} + +// skipDtsAIError 表示未配置 DTS-AI API key，调用方应跳过本源继续回退。 +type skipDtsAIError struct{} + +func (skipDtsAIError) Error() string { return "DTS-AI 未配置 API key，跳过该源" } + +// NewDtsAIClient 创建 DTS-AI 客户端。 +// - apiKeyEnv: 读取 API key 的环境变量名（空串时默认 DTS_AI_API_KEY） +// - region: 地域 ID（默认 cn-beijing，官方另支持 ap-southeast-1） +// - endpoint: 服务入口；推荐 dtsai..aliyuncs.com，空串时按 region 推导 +// - maxResults: 单次最多返回条数（官方默认 10，最大 50） +// - timeoutSec: 单次请求超时秒数 +func NewDtsAIClient(apiKeyEnv, region, endpoint string, maxResults, timeoutSec int) *DtsAIClient { + envName := "DTS_AI_API_KEY" + if apiKeyEnv != "" { + envName = apiKeyEnv + } + if region == "" { + region = "cn-beijing" + } + if endpoint == "" { + endpoint = fmt.Sprintf("https://dtsai.%s.aliyuncs.com", region) + } + if maxResults <= 0 { + maxResults = 10 + } + if timeoutSec <= 0 { + timeoutSec = 15 + } + c := &DtsAIClient{ + apiKey: strings.TrimSpace(os.Getenv(envName)), + region: region, + endpoint: strings.TrimRight(endpoint, "/"), + maxResults: maxResults, + } + c.hc = &http.Client{Timeout: time.Duration(timeoutSec) * time.Second} + return c +} + +// randNonce 生成请求签名随机数（SignatureNonce），保持请求唯一性。 +func randNonce() string { + b := make([]byte, 16) + if _, err := rand.Read(b); err != nil { + return fmt.Sprintf("%d", time.Now().UnixNano()) + } + return hex.EncodeToString(b) +} + +// dtsAIRequest DTS-AI WebSearch 请求体（对齐 cargo 各字段部分可选）。 +type dtsAIRequest struct { + RegionId string `json:"RegionId"` + Query string `json:"Query"` + MaxResults int `json:"MaxResults"` +} + +// dtsAIItem 单个搜索结果。 +type dtsAIItem struct { + Title string `json:"Title"` + Url string `json:"Url"` + Snippet string `json:"Snippet"` +} + +// dtsAIResponse DTS-AI WebSearch 响应体。 +type dtsAIResponse struct { + RequestId string `json:"RequestId"` + Query string `json:"Query"` + HttpStatusCode int `json:"HttpStatusCode"` + TotalResults int `json:"TotalResults"` + Success bool `json:"Success"` + ErrorMessage string `json:"ErrorMessage"` + Code string `json:"Code"` + SearchResult []dtsAIItem `json:"SearchResult"` +} + +// Search 调用 DTS-AI WebSearch 搜索。未配置 key 时返回 skipDtsAIError。 +func (c *DtsAIClient) Search(query string) ([]Result, error) { + if c.apiKey == "" { + return nil, skipDtsAIError{} + } + + payload, err := json.Marshal(dtsAIRequest{ + RegionId: c.region, + Query: query, + MaxResults: c.maxResults, + }) + if err != nil { + return nil, fmt.Errorf("构建 DTS-AI 请求体失败: %w", err) + } + + endpoint := fmt.Sprintf("%s?Action=WebSearch&Version=2026-04-01&SignatureNonce=%s", + c.endpoint, randNonce()) + req, err := http.NewRequest(http.MethodPost, endpoint, bytes.NewReader(payload)) + if err != nil { + return nil, fmt.Errorf("构建 DTS-AI 请求失败: %w", err) + } + req.Header.Set("X-Acs-ApiKey", c.apiKey) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Accept", "application/json") + + resp, err := c.hc.Do(req) + if err != nil { + return nil, fmt.Errorf("DTS-AI 不可达: %w", err) + } + defer resp.Body.Close() + + body, err := io.ReadAll(resp.Body) + if err != nil { + return nil, fmt.Errorf("读取 DTS-AI 响应失败: %w", err) + } + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("DTS-AI 返回 %d: %s", resp.StatusCode, truncate(string(body), 200)) + } + + var out dtsAIResponse + if err := json.Unmarshal(body, &out); err != nil { + return nil, fmt.Errorf("DTS-AI 响应解析失败: %w", err) + } + if !out.Success { + if out.ErrorMessage != "" { + return nil, fmt.Errorf("DTS-AI 业务错误: %s", out.ErrorMessage) + } + if out.Code != "" { + return nil, fmt.Errorf("DTS-AI 业务错误 code=%s", out.Code) + } + return nil, fmt.Errorf("DTS-AI 业务错误: Success=false") + } + + var res []Result + for _, r := range out.SearchResult { + title := strings.TrimSpace(r.Title) + link := strings.TrimSpace(r.Url) + if title == "" || link == "" { + continue + } + res = append(res, Result{ + Title: title, + URL: link, + Content: strings.TrimSpace(r.Snippet), + Engine: "dtsai", + }) + if len(res) >= c.maxResults { + break + } + } + return res, nil +} diff --git a/eai_agentplatform/backend-go/internal/search/dtsai_test.go b/eai_agentplatform/backend-go/internal/search/dtsai_test.go new file mode 100644 index 0000000..8eb6369 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/dtsai_test.go @@ -0,0 +1,43 @@ +package search + +import ( + "os" + "testing" +) + +// TestDtsAIUnconfiguredKey 未配置 API key 时应返回 skipDtsAIError（可被聚合 Client 降级）， +// 确保无 key 也能跑，不阻塞链路。 +func TestDtsAIUnconfiguredKey(t *testing.T) { + // 显式覆盖一个空环境变量，保证本测试不依赖宿主 .env。 + t.Setenv("DTS_AI_API_KEY", "") + c := NewDtsAIClient("DTS_AI_API_KEY", "cn-beijing", "", 8, 15) + _, err := c.Search("测试") + if err == nil { + t.Fatal("未配置 key 时应返回 skipDtsAIError") + } + if _, ok := err.(skipDtsAIError); !ok { + t.Fatalf("应返回 skipDtsAIError，实得 %T: %v", err, err) + } +} + +// TestDtsAIIntegration 端到端联调 DTS-AI WebSearch（仅在配置了 DTS_AI_API_KEY 时执行， +// 避免无 key 的 CI 环境因网络调用而失败）。 +func TestDtsAIIntegration(t *testing.T) { + if os.Getenv("DTS_AI_API_KEY") == "" { + t.Skip("未配置 DTS_AI_API_KEY，跳过 DTS-AI 网络联调") + } + c := NewDtsAIClient("DTS_AI_API_KEY", "cn-beijing", "", 5, 20) + res, err := c.Search("外骨骼机器人 市场规模") + if err != nil { + t.Fatalf("DTS-AI 搜索失败: %v", err) + } + if len(res) == 0 { + t.Fatal("DTS-AI 应返回至少 1 条结果") + } + for _, r := range res { + if r.Title == "" || r.URL == "" { + t.Errorf("存在空标题/空链接: %+v", r) + } + } + t.Logf("DTS-AI 返回 %d 条；首条: %s -> %s", len(res), res[0].Title, res[0].URL) +} diff --git a/eai_agentplatform/backend-go/internal/search/engine.go b/eai_agentplatform/backend-go/internal/search/engine.go new file mode 100644 index 0000000..ab68015 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/engine.go @@ -0,0 +1,82 @@ +package search + +import "fmt" + +// Engine 一个可插拔的搜索引擎源。 +// +// 各源（SearXNG、搜狗 HTTP、真实浏览器、付费 SerpApi 等）通过实现该接口接入聚合 Client， +// 由 search_config.json 声明启用顺序与参数，替代此前写死在 Client.Search 里的硬编码回退链。 +type Engine interface { + // Name 引擎唯一标识（与 search_config.json 中 engines 的 key 对应）。 + Name() string + // Search 执行一次搜索。失败或无结果时返回 (nil, err)，由聚合 Client 降级到下一引擎。 + Search(query string) ([]Result, error) +} + +// searxngEngine 基于 SearXNG /search?format=json 的引擎。 +type searxngEngine struct { + client *SearXNGClient +} + +func (e *searxngEngine) Name() string { return "searxng" } +func (e *searxngEngine) Search(q string) ([]Result, error) { + return e.client.searchSearXNG(q) +} + +// sogouEngine 基于搜狗 HTTP 抓取的引擎。 +type sogouEngine struct { + client *SogouClient +} + +func (e *sogouEngine) Name() string { return "sogou" } +func (e *sogouEngine) Search(q string) ([]Result, error) { + return e.client.Search(q) +} + +// browserEngine 基于真实浏览器（Playwright + 系统 Chrome）的引擎。 +type browserEngine struct { + searcher *BrowserSearcher +} + +func (e *browserEngine) Name() string { return "browser" } +func (e *browserEngine) Search(q string) ([]Result, error) { + return e.searcher.Search(q) +} + +// serpapiEngine 基于付费 SerpApi 的引擎。 +type serpapiEngine struct { + client *SerpApiClient +} + +func (e *serpapiEngine) Name() string { return "serpapi" } +func (e *serpapiEngine) Search(q string) ([]Result, error) { + return e.client.Search(q) +} + +// dtsAIEngine 基于阿里云 DTS-AI WebSearch 的引擎。 +type dtsAIEngine struct { + client *DtsAIClient +} + +func (e *dtsAIEngine) Name() string { return "dtsai" } +func (e *dtsAIEngine) Search(q string) ([]Result, error) { + return e.client.Search(q) +} + +// engineFromConfig 根据一条 EngineConfig 构建对应引擎；type 未知返回 error。 +func engineFromConfig(name string, ec EngineConfig) (Engine, error) { + switch ec.Type { + case "searxng": + return &searxngEngine{client: NewSearXNGClient(ec.BaseURL)}, nil + case "sogou": + return &sogouEngine{client: NewSogouClient()}, nil + case "browser": + return &browserEngine{searcher: GetBrowserSearcher()}, nil + case "serpapi": + return &serpapiEngine{client: NewSerpApiClient(ec.APIKeyEnv)}, nil + case "dtsai": + return &dtsAIEngine{client: NewDtsAIClient(ec.APIKeyEnv, ec.Region, ec.BaseURL, ec.MaxResults, ec.TimeoutSec)}, nil + default: + return nil, fmt.Errorf("未知搜索引擎类型 %q（引擎 %q）", ec.Type, name) + } +} diff --git a/eai_agentplatform/backend-go/internal/search/search_config.go b/eai_agentplatform/backend-go/internal/search/search_config.go new file mode 100644 index 0000000..761faa8 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/search_config.go @@ -0,0 +1,100 @@ +package search + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" + "sync" +) + +// 本文件实现搜索引擎的 JSON 配置驱动。 +// +// 背景：此前搜索源（SearXNG→搜狗HTTP→浏览器）是写死在 Client.Search 里的硬编码回退链。 +// 现在改成由 config/search_config.json 声明「启用哪些引擎、按什么顺序、各自参数」， +// Client 按配置顺序逐个调用，命中即返回。这样新增/停用/调整引擎只需改配置，无需改代码， +// 对齐项目「JSON 配置驱动」的约束。 + +// EngineConfig 单个搜索引擎的配置。 +type EngineConfig struct { + Type string `json:"type"` // searxng | sogou | browser | serpapi | dtsai + Enabled bool `json:"enabled"` // 是否启用 + BaseURL string `json:"base_url"` // searxng / html 类引擎的入口地址；dtsai 作为服务端入口（可空，按 region 推导） + APIKeyEnv string `json:"api_key_env"` // serpapi / dtsai 的 API key 所在环境变量名 + Engine string `json:"engine"` // serpapi 具体用哪个后端引擎 google/bing/baidu + Language string `json:"language"` // 搜索语言（zh / zh-cn / en ...） + Region string `json:"region"` // dtsai 服务地域（cn-beijing 等） + MaxResults int `json:"max_results"` // 单引擎最多返回条数（0 表示用默认） + TimeoutSec int `json:"timeout_sec"` // 单次搜索超时秒数（0 表示用默认） + Retry int `json:"retry"` // 失败重试次数（0 表示不重试） +} + +// SearchConfig 对外暴露的搜索引擎编排配置。 +type SearchConfig struct { + Version int `json:"version"` + Active []string `json:"active"` // 生效的引擎名（有序 = 尝试优先级） + Engines map[string]EngineConfig `json:"engines"` +} + +const ( + // DefaultSearchConfigName 默认配置文件（放在可执行文件旁的 config/ 目录）。 + DefaultSearchConfigName = "search_config.json" + + // EnvSearchConfig 环境变量，可覆盖配置文件完整路径。 + EnvSearchConfig = "SEARCH_CONFIG" +) + +var ( + searchCfgMu sync.RWMutex + searchCfgOnce sync.Once + searchCfgVal *SearchConfig +) + +// searchConfigPath 定位 search_config.json：优先 SEARCH_CONFIG 环境变量，其次可执行文件旁 config/。 +func searchConfigPath(name string) string { + if p := os.Getenv(EnvSearchConfig); p != "" { + return p + } + if exe, err := os.Executable(); err == nil { + exeDir := filepath.Dir(exe) + candidates := []string{ + filepath.Join(exeDir, "config", name), + filepath.Join(exeDir, "..", "config", name), + } + for _, d := range candidates { + if fi, err := os.Stat(d); err == nil && !fi.IsDir() { + return d + } + } + } + return name +} + +// loadSearchConfig 从配置文件解析为 SearchConfig。 +func loadSearchConfig(path string) (*SearchConfig, error) { + data, err := os.ReadFile(path) + if err != nil { + return nil, fmt.Errorf("读取 %s 失败: %w", path, err) + } + var cfg SearchConfig + if err := json.Unmarshal(data, &cfg); err != nil { + return nil, fmt.Errorf("解析 %s 失败: %w", path, err) + } + return &cfg, nil +} + +// GetSearchConfig 返回全局搜索引擎配置（懒加载 + 缓存）。 +// 配置文件不存在时返回 nil（不报错），由调用方回退到默认硬编码链，保证旧行为不破功。 +func GetSearchConfig() *SearchConfig { + searchCfgOnce.Do(func() { + path := searchConfigPath(DefaultSearchConfigName) + cfg, err := loadSearchConfig(path) + if err != nil { + // 无配置不是致命错误：Search() 会走默认链。 + searchCfgVal = nil + return + } + searchCfgVal = cfg + }) + return searchCfgVal +} diff --git a/eai_agentplatform/backend-go/internal/search/searxng_client.go b/eai_agentplatform/backend-go/internal/search/searxng_client.go new file mode 100644 index 0000000..43b3ee8 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/searxng_client.go @@ -0,0 +1,74 @@ +package search + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + "net/url" + "strings" + "time" +) + +// SearXNGClient 单引擎客户端：查询自建 SearXNG 的 /search?format=json。 +type SearXNGClient struct { + baseURL string + language string + maxResults int + timeout time.Duration + hc *http.Client +} + +// NewSearXNGClient 创建 SearXNG 单引擎客户端。baseURL 形如 http://127.0.0.1:18080。 +// 传空串时使用默认本地网关地址。 +func NewSearXNGClient(baseURL string) *SearXNGClient { + if baseURL == "" { + baseURL = DefaultBaseURL + } + return &SearXNGClient{ + baseURL: strings.TrimRight(baseURL, "/"), + language: "zh", + maxResults: 8, + timeout: 25 * time.Second, + hc: &http.Client{Timeout: 25 * time.Second}, + } +} + +// searchSearXNG 单次 SearXNG 查询（不含兜底）。 +func (c *SearXNGClient) searchSearXNG(query string) ([]Result, error) { + params := url.Values{} + params.Set("q", query) + params.Set("format", "json") + params.Set("language", c.language) + params.Set("safesearch", "0") + searchURL := c.baseURL + "/search?" + params.Encode() + + req, err := http.NewRequest(http.MethodGet, searchURL, nil) + if err != nil { + return nil, fmt.Errorf("构建搜索请求失败: %w", err) + } + req.Header.Set("Accept", "application/json") + + resp, err := c.hc.Do(req) + if err != nil { + return nil, fmt.Errorf("SearXNG 不可达: %w", err) + } + defer resp.Body.Close() + + body, err := io.ReadAll(resp.Body) + if err != nil { + return nil, fmt.Errorf("读取搜索响应失败: %w", err) + } + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("SearXNG 返回 %d: %s", resp.StatusCode, truncate(string(body), 200)) + } + + var out Response + if err := json.Unmarshal(body, &out); err != nil { + return nil, fmt.Errorf("搜索响应解析失败: %w", err) + } + if len(out.Results) > c.maxResults { + out.Results = out.Results[:c.maxResults] + } + return out.Results, nil +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/search/serpapi.go b/eai_agentplatform/backend-go/internal/search/serpapi.go new file mode 100644 index 0000000..2c2a9f4 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/serpapi.go @@ -0,0 +1,125 @@ +package search + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + "net/url" + "os" + "strings" + "time" +) + +// SerpApiClient 调用付费的 SerpApi（https://serpapi.com）获取搜索结果。 +// +// 背景：SearXNG / 搜狗 HTTP / 真实浏览器都会被百度和搜狗对数据中心 IP 的反爬拦截， +// 无法稳定取得按关键词匹配的真实结果。SerpApi 是商业搜索 API，服务端负责抓取 +// （本机只连 serpapi.com，连通性好），返回结构化 JSON，无验证码，是「通用可搜」 +// 闭环的稳定主源。 +// +// 配置：API key 从环境变量 SERPAPI_API_KEY 读取。未配置 key 时 Search 返回 +// (nil, errSkipSerp) 让上层回退到既有的 SearXNG→搜狗→浏览器链，保证无 key 也能跑。 +// +// 设计说明：engine 用 google（SerpApi 默认），检索在 SerpApi 服务端完成，不受本机 +// 出口 IP 反爬影响；hl=zh-cn 让中文结果更相关。 +type SerpApiClient struct { + apiKey string + maxResults int + timeout time.Duration + hc *http.Client +} + +// errSkipSerp 表示未配置 SerpApi key，调用方应跳过本源继续回退。 +type skipSerpError struct{} + +func (skipSerpError) Error() string { return "SerpApi 未配置 API key，跳过该源" } + +// NewSerpApiClient 创建 SerpApi 客户端；key 从指定环境变量读取（空串时默认 SERPAPI_API_KEY）。 +func NewSerpApiClient(apiKeyEnv ...string) *SerpApiClient { + envName := "SERPAPI_API_KEY" + if len(apiKeyEnv) > 0 && apiKeyEnv[0] != "" { + envName = apiKeyEnv[0] + } + c := &SerpApiClient{ + apiKey: strings.TrimSpace(os.Getenv(envName)), + maxResults: 8, + timeout: 15 * time.Second, + } + c.hc = &http.Client{Timeout: c.timeout} + return c +} + +// serpAPIURL SerpApi 搜索端点。 +const serpAPIURL = "https://serpapi.com/search.json" + +// serpAPIResponse SerpApi /search.json 的有机结果片段。 +type serpAPIResponse struct { + OrganicResults []struct { + Title string `json:"title"` + Link string `json:"link"` + Snippet string `json:"snippet"` + } `json:"organic_results"` + Error string `json:"error"` +} + +// Search 调用 SerpApi 搜索。未配置 key 时返回 skipSerpError。 +func (c *SerpApiClient) Search(query string) ([]Result, error) { + if c.apiKey == "" { + return nil, skipSerpError{} + } + + params := url.Values{} + params.Set("q", query) + params.Set("engine", "google") + params.Set("hl", "zh-cn") + params.Set("num", fmt.Sprintf("%d", c.maxResults)) + params.Set("api_key", c.apiKey) + + req, err := http.NewRequest(http.MethodGet, serpAPIURL+"?"+params.Encode(), nil) + if err != nil { + return nil, fmt.Errorf("构建 SerpApi 请求失败: %w", err) + } + req.Header.Set("Accept", "application/json") + + resp, err := c.hc.Do(req) + if err != nil { + return nil, fmt.Errorf("SerpApi 不可达: %w", err) + } + defer resp.Body.Close() + + body, err := io.ReadAll(resp.Body) + if err != nil { + return nil, fmt.Errorf("读取 SerpApi 响应失败: %w", err) + } + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("SerpApi 返回 %d: %s", resp.StatusCode, truncate(string(body), 200)) + } + + var out serpAPIResponse + if err := json.Unmarshal(body, &out); err != nil { + return nil, fmt.Errorf("SerpApi 响应解析失败: %w", err) + } + if out.Error != "" { + return nil, fmt.Errorf("SerpApi 业务错误: %s", out.Error) + } + + var res []Result + for _, r := range out.OrganicResults { + title := strings.TrimSpace(r.Title) + link := strings.TrimSpace(r.Link) + if title == "" || link == "" { + continue + } + res = append(res, Result{ + Title: title, + URL: link, + Content: strings.TrimSpace(r.Snippet), + Engine: "serpapi_google", + }) + if len(res) >= c.maxResults { + break + } + } + return res, nil +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/search/sogou.go b/eai_agentplatform/backend-go/internal/search/sogou.go new file mode 100644 index 0000000..7386526 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/sogou.go @@ -0,0 +1,160 @@ +package search + +import ( + "crypto/rand" + "fmt" + "html" + "io" + "net/http" + "net/url" + "regexp" + "strings" + "time" +) + +// SogouBaseURL 搜狗网页搜索地址（墙内可直连、按关键词真实返回结果， +// 用于在 SearXNG 上游失效时作为第三方搜索源兜底）。 +const SogouBaseURL = "https://www.sogou.com/web" + +const ( + sogouTimeout = 12 * time.Second + sogouMaxResult = 8 +) + +// SogouUserAgent 避免触发反爬降级的真实浏览器 UA。 +const SogouUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0 Safari/537.36" + +var ( + // sogouItemRe 匹配搜狗结果条目。实际结构（实测）： + // + //

标题 + //

摘要

+ //

+ // + // 取 的 href 作 URL，h3 内文本作标题。 + sogouItemRe = regexp.MustCompile(`(?s)]*href="([^"]+)"[^>]*>.*?]*class="[^"]*vr-title[^"]*"[^>]*>.*?]*>(.*?)`) + // sogouDescRe 匹配结果摘要（title-summary / str_info / space-txt 等文本容器）。 + sogouDescRe = regexp.MustCompile(`(?s)<(?:p|span|div)[^>]*class="[^"]*(?:title-summary|str_info|space-txt|fb fz-mid|text-info)[^"]*"[^>]*>(.*?)`) + anyTagRe = regexp.MustCompile(`<[^>]+>`) +) + +// SogouClient 搜狗网页搜索客户端。随机化部分请求头，降低连续查询触发 +// 人机校验的概率（已验证源响应按关键词真实匹配，而非缓存页）。 +type SogouClient struct { + timeout time.Duration + hc *http.Client +} + +// NewSogouClient 创建搜狗搜索客户端。 +func NewSogouClient() *SogouClient { + return &SogouClient{timeout: sogouTimeout, hc: &http.Client{Timeout: sogouTimeout}} +} + +// Search 抓取并解析搜狗网页搜索结果，映射为 []Result。 +// 搜狗对数据中心 IP 的连续快速查询偶发人机校验（返回验证码页）， +// 此处做一次短暂退避重试，降低瞬时校验导致的空结果概率。 +func (s *SogouClient) Search(query string) ([]Result, error) { + for attempt := 0; ; attempt++ { + res, err := s.searchOnce(query) + if (err == nil && len(res) > 0) || attempt >= 1 { + return res, err + } + // 空结果或错误：等一小段再试一次 + time.Sleep(1200 * time.Millisecond) + } +} + +func (s *SogouClient) searchOnce(query string) ([]Result, error) { + params := url.Values{} + params.Set("query", query) + searchURL := SogouBaseURL + "?" + params.Encode() + + req, err := http.NewRequest(http.MethodGet, searchURL, nil) + if err != nil { + return nil, fmt.Errorf("构建搜狗请求失败: %w", err) + } + req.Header.Set("User-Agent", SogouUserAgent) + req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8") + req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8") + req.Header.Set("Referer", "https://www.sogou.com/") + req.Header.Set("X-Forwarded-For", randomIP()) + req.Header.Set("X-Real-IP", randomIP()) + + resp, err := s.hc.Do(req) + if err != nil { + return nil, fmt.Errorf("搜狗不可达: %w", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("搜狗返回 %d", resp.StatusCode) + } + body, err := io.ReadAll(resp.Body) + if err != nil { + return nil, fmt.Errorf("读取搜狗响应失败: %w", err) + } + return parseSogou(body), nil +} + +// parseSogou 从搜狗结果页提取标题/链接/摘要。 +func parseSogou(page []byte) []Result { + raw := string(page) + // 命中人机校验页则明确返回空（触发上层回退），不产出伪结果。 + if strings.Contains(raw, "请输入验证码") || strings.Contains(raw, "antispider") || strings.Contains(raw, "访问过于频繁") { + return nil + } + + matches := sogouItemRe.FindAllStringSubmatch(raw, -1) + results := make([]Result, 0, len(matches)) + for _, m := range matches { + if len(m) < 3 { + continue + } + href := m[1] + title := cleanText(m[2]) + if title == "" { + continue + } + // 跳过非可访问协议（如 javascript:void(0) 的分享桩），只保留 http(s) 结果链接。 + if !strings.HasPrefix(href, "http") && !strings.HasPrefix(href, "/link?") { + continue + } + // 结果链接多为搜狗跳转封装 (/link?url=...)，保留源标题/摘要， + // 跳转链接可由调用方按需跟进，不影响 LLM 引用来源。 + urlText := href + if strings.HasPrefix(href, "/link?") || strings.HasPrefix(href, "/weixin") { + urlText = "https://www.sogou.com" + href + } + results = append(results, Result{ + Title: title, + URL: urlText, + Content: extractSogouDesc(raw), + Engine: "sogou", + }) + if len(results) >= sogouMaxResult { + break + } + } + return results +} + +// extractSogouDesc 提取搜狗摘要段；无法精确定位时返回空。 +func extractSogouDesc(raw string) string { + m := sogouDescRe.FindStringSubmatch(raw) + if len(m) < 2 { + return "" + } + return cleanText(m[1]) +} + +func cleanText(s string) string { + s = anyTagRe.ReplaceAllString(s, "") + s = html.UnescapeString(s) + return strings.TrimSpace(s) +} + +func randomIP() string { + b := make([]byte, 4) + _, _ = rand.Read(b) + return fmt.Sprintf("%d.%d.%d.%d", b[0], b[1], b[2], b[3]) +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/search/sogou_test.go b/eai_agentplatform/backend-go/internal/search/sogou_test.go new file mode 100644 index 0000000..ba67fbf --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/sogou_test.go @@ -0,0 +1,40 @@ +package search + +import ( + "os" + "path/filepath" + "strings" + "testing" +) + +func TestParseSogouRejectsCaptcha(t *testing.T) { + if got := parseSogou([]byte(`请输入验证码`)); got != nil { + t.Fatalf("验证码页应返回 nil，实得 %d 条", len(got)) + } + if got := parseSogou([]byte(`antispider`)); got != nil { + t.Fatalf("反爬页应返回 nil，实得 %d 条", len(got)) + } +} + +// TestParseSogouFixture 用真实抓取的搜狗结果页验证解析器提取标题/链接/摘要。 +func TestParseSogouFixture(t *testing.T) { + fixture := filepath.Join("testdata", "sogou_result.html") + // 编译前若 fixture 不存在则跳过（保持 go test 在无网络/无 fixture 时可过）。 + if _, err := os.Stat(fixture); err != nil { + t.Skip("testdata/sogou_result.html 不存在，跳过 fixture 断言") + } + raw, _ := os.ReadFile(fixture) + got := parseSogou(raw) + if len(got) == 0 { + t.Fatal("fixture 应解析出至少 1 条结果") + } + for _, r := range got { + if strings.TrimSpace(r.Title) == "" { + t.Errorf("存在空标题: %+v", r) + } + if !strings.HasPrefix(r.URL, "http") { + t.Errorf("URL 异常: %q", r.URL) + } + } + t.Logf("解析 %d 条；首条: %s -> %s", len(got), got[0].Title, got[0].URL) +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/search/testdata/sogou_result.html b/eai_agentplatform/backend-go/internal/search/testdata/sogou_result.html new file mode 100644 index 0000000..2fee4dc --- /dev/null +++ b/eai_agentplatform/backend-go/internal/search/testdata/sogou_result.html @@ -0,0 +1,2484 @@ + 科拓智能机器人 - 搜狗搜索 +
全部结果

搜狗已为您找到约22,041条相关结果

+ + +
+ + + + +

+ + + + 赣州中科拓又达智能装备科技有限公司 + +

2018年02月06日成立

+ +

+ + + + + + + + + + + + +
+ + +
+
+ + + + + + + + + + + + + + + + +
+ +
+
+ + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + + + +
+ +
+ + +
+ +
工商信息 + 股东信息 + 变更记录 + 财务信息 +
+ +
+ + +

+ + + 3位相关人员 更多 + + + +

+ + + + +
+ 企查查 + +
+ + +
+
+ + +
+ + +
+ +
+
+

+ + 福州科拓智能科技有限公司 + + + +

+ + + + + + +
+ + +
+
+ + + + + + + + + + + + + + + + +
+ +
+
+ + + + + + + + + + + + +

福州科拓智能科技有限公司是中国智慧停车场缔造者,致力于研发并提供多元全面的智慧停车场应用解决方案,包括全视频智慧停车场解决方案、多样化停车场车位引导解决方案、城市停车诱导解决方案,构成了一套各有针对性的完整的解决方案体系,为增加停车场使用率,提升经营者经济效益,改善城市交通状况,提高驾驶人员停车效率提供了有效的技术支持....

+ + + + + + + + + + + + + + + + +公众号http://mp.weixin.qq.com/s...2017-03-29 +
+ +
+ +
+
+

科拓股份_停车场收费管理系统_车牌识别系统_停车场道闸

科拓股份专注智慧停车逾10年,旗下具有速泊、速停车、泊视等子品牌,服务遍布全球60多个国家及地区,方案实力覆盖全部业态类型停车场的需求,涵盖城市停车,智慧商业,智...
cite http://www.keytop.com.cn/ 1天前

浙江科钛机器人股份有限公司

浙江科钛机器人股份有限公司公司总部和技术研发中心坐落于杭州滨江高新软件园内,是一家以浙江大学为依托,以机器人独有技术为核心,致力于智能仓储、智慧工厂等相关产品...
cite http://zjkt.robot-china.c... 2026-08-27
+ +
+

+ + 中科拓又达工业机器人在高速连续测试,是不是像极了多动症的你？_... + + + +

+ + + + + + +
+ + +
+
+ + + + + + + + + + + + + + + + +
+ +
+
+ + + + + + + +
机器人连续测试：每一台机器人都是经过96小时高速连续测试，以确保客户使用的精度、高效性、稳定性。#中科拓又达 #焊接机器人 #WPTYD #智能焊接...
+ + + + + + + + + + + + + + + + + + + + + +哔哩哔哩https://www.bilibili.com/v...2022-11-29 +
+ +
+ +
+
+ +
+

+ + 智慧停车 - 厦门科拓通讯技术股份有限公司 + + + +

+ + + + + + +
+ + +
+
+ + + + + + + + + + + + + + + + +
+ +
+
+ + + + + + + +
科拓智能停车引导系统 为了提高停车场的信息化、智能化管理水平，给车主提供一种更加安全、舒适、方便、快捷和开放的环境，实现停车场运行的高效化、节能化、环保化，...
+ + + + + + + + + + + + + + + + + + + + + +DAV数字音视工程网http://keytop.corp.dav01.com/p...2026-06-08 +
+ +
+ +
+
+ +
+

+ + 科拓智能摆闸机：提升人行安全性与效率,降低管理成本、优化体验|... + + + +

+ + + + + + +
+ + +
+
+ + + + + + + + + + + + + + + + +
+ +
+
+ + + + + + + +
科拓智能摆闸是一家专业从事智能门禁设备研发与制造的公司。作为行业领先者，科拓智能摆闸致力于提供高品质、智能化的门禁解决方案。科拓智能摆...
+ + + + + + + + + + + + + + + + + + + + + +网易https://www.163.com/d...2023-10-17 +
+ +
+ +
+

福州科拓智能科技有限公司-福州科拓

福州科拓智能科技有限公司招标采购专栏，每天实时更新有关福州科拓智能科技有限公司招标公告、企业采购、拟在建项目等一系列商业信息，查询更多福州...
cite 比地招标 http://www.bidizhaobiao.com/c... 2025-11-11
+ +
+

+ + 智能道闸_科拓_中出网 + + + +

+ + + + + + +
+ + +
+
+ + + + + + + + + + + + + + + + +
+ +
+
+ + + + + + + +
科拓独立自主研发，外观荣获工业设计大赛大奖，道闸起落杆标配只需1.6s，具双向自锁及放砸车砸人功能，同时具有遥控器、按钮、机械摇杆和电脑控制...
+ + + + + + + + + + + + + + + + + + + + + +中出网https://m.86crk.com/p...2026-08-10 +
+ +
+ +
+
+ +
+

+ + 科拓-停车场智能道闸起落杆/折臂杆/圆杆/直杆-智能道闸-厦门科拓通讯... + + + +

+ + + + + + +
+ + +
+
+ + + + + + + + + + + + + + + + +
+ +
+
+ + + + + + + +
停车场智能道闸起落杆，科拓智慧停车是一家具有多年行业运营经验的智慧停车价值运营商，集研发、设计、生产、服务于一体的高科技...
+ + + + + + + + + + + + + + + + + + + + + +智慧城市网https://www.afzhan.com/s...2025-01-02 +
+ +
+ +
+
+ +
+

+ + ...工业机器人_产品_中国AGV网（www.chinaagv.com）_AMR网-专业智... + + + +

+ + + + + + +
+ + +
+
+ + + + + + + + + + + + + + + + +
+ +
+
+ + + + + + + +
广西智拓科技有限公司 经营模式： 产研销综合服务商 地区： 中国广西柳州市 电话： 400-003-8030 进入店铺 联系方式 该台套焊接机器人系统是专门应用...
+ + + + + + + + + + + + + + + + + + + + + +AGV网https://www.chinaagv.com/s...2020-09-27 +
+ +
+ +
+
+ + + + +
+ + +
+
相关搜索

小笨智能机器人官网

最新ai智能机器人

最新人工智能机器人

科拓智慧停车官网

优必选智能机器人官网

智能机器人app官网

科拓道闸软件系统

科拓官网

大白智能机器人官网

嘉拓智能官网
这段探索已经结束，然而总有新的开始
尝试使用不同的关键词，去发现不一样的世界。
\ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/skills/api/audio_handlers.go b/eai_agentplatform/backend-go/internal/skills/api/audio_handlers.go new file mode 100644 index 0000000..10a5e93 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/api/audio_handlers.go @@ -0,0 +1,1126 @@ +package skillapi + +import ( + "encoding/json" + "fmt" + "os" + "strings" + "time" + + "github.com/gin-gonic/gin" + "gorm.io/gorm" + + "eai_agentplatform/backend/internal/config" + "eai_agentplatform/backend/internal/dal" + "eai_agentplatform/backend/internal/middleware" + "eai_agentplatform/backend/internal/model" + audiotranscribe "eai_agentplatform/backend/internal/skills/packages/audio_transcribe" + specialistruntime "eai_agentplatform/backend/internal/specialists/runtime" + "eai_agentplatform/backend/internal/store" + "eai_agentplatform/backend/internal/web" +) + +// audioSkillKey 技能 key，与前端 manifest 的 key 一致。 +// 每次执行落一条 action_key = ":" 的 task_run —— 前端右栏的 +// 「工作流 x/4」就是靠这个后缀逐步推进的（见 SpecialistPanel.vue 的 steps）。 +const audioSkillKey = "audio-transcribe" + +// audioStepSpec 一个步骤的固定文案与落库口径。 +// +// 产物 title / type 与前端 manifest 的 artifactSchema 逐字对齐， +// 这样右栏「标准产物」与「任务产物」说的是一回事。 +type audioStepSpec struct { + Step string + ActionTitle string + ArtifactTitle string + ArtifactType string +} + +var audioStepSpecs = map[string]audioStepSpec{ + "scope": { + Step: "scope", + ActionTitle: "确认音频范围与语言", + ArtifactTitle: "转写要求", + ArtifactType: "text", + }, + "transcribe": { + Step: "transcribe", + ActionTitle: "生成逐字转写文本", + ArtifactTitle: "逐字转写稿", + ArtifactType: "transcript", + }, + "speakers": { + Step: "speakers", + ActionTitle: "识别说话人身份", + ArtifactTitle: "说话人名单", + ArtifactType: "speakers", + }, + "speakers-confirm": { + Step: "speakers-confirm", + ActionTitle: "确认说话人身份", + // 这一步**不产生产物**，只是把上一步那份 draft 改成 approved， + // 所以这两个字段只为对齐形状而存在，落库路径不走 persistAudioStep + // （走了会多写一条空产物，把右栏产物区撑出一条没内容的记录）。 + ArtifactTitle: "说话人名单", + ArtifactType: "speakers", + }, + "structure": { + Step: "structure", + ActionTitle: "整理段落与重点", + ArtifactTitle: "结构化纪要", + ArtifactType: "document", + }, + "minutes": { + Step: "minutes", + ActionTitle: "提炼可交付纪要", + ArtifactTitle: "行动项清单", + ArtifactType: "checklist", + }, +} + +// audioStepReq 四步共用的请求体。每一步只读自己需要的字段，缺什么报什么。 +type audioStepReq struct { + TaskID uint `json:"task_id"` + MediaID uint `json:"media_id"` // 第 1、2 步必填：要处理的音频附件 + Language string `json:"language"` // 第 1、2 步用；空 / auto 表示交给模型判断 + // AiRouteID 第 5、6 步用（界面上选的模型）。空表示「用户没选」， + // 此时走技能自带的 audioLLMAgentRoute —— 不是 default_route，理由见 resolveAudioChatRoute。 + AiRouteID string `json:"ai_route_id"` +} + +// audioStepOutcome 一步执行完要落库/回传的东西。 +type audioStepOutcome struct { + Summary string // 写入 task.current_result + ContentText string // 产物正文（右栏预览、导出用） + Input gin.H // 这一步吃了什么（入参留痕） + Output gin.H // 产物结构化内容，同时作为接口返回值 + Logs []string + SourceRefs []gin.H + Extra gin.H // 额外回传前端的字段（如 ASR 的 model / route） + + // ArtifactStatus / TaskStatus 覆盖落库状态。留空即沿用默认值 + // （产物 draft、任务「草案已生成」），也就是其余几步的现状。 + // + // 只有「识别说话人身份」这一步需要覆盖：它产出的是**待用户确认**的推断结果， + // 落成 draft 的话右栏会显示「草案已生成」，看不出这件事正卡在等人确认。 + ArtifactStatus string + TaskStatus string +} + +// ExecuteAudioScope POST /api/skills/audio/scope —— 第 1 步：确认音频范围与语言。 +func ExecuteAudioScope(c *gin.Context) { executeAudioStep(c, "scope") } + +// ExecuteAudioTranscribe POST /api/skills/audio/transcribe —— 第 2 步：逐字转写。 +func ExecuteAudioTranscribe(c *gin.Context) { executeAudioStep(c, "transcribe") } + +// ExecuteAudioSpeakers POST /api/skills/audio/speakers —— 第 3 步：识别说话人身份。 +// +// 这一步只**推断**，不拍板：产物落成 ready（右栏显示「待确认」）、任务落成「待确认」， +// 然后停下等用户确认。确认走 ExecuteAudioSpeakersConfirm。 +func ExecuteAudioSpeakers(c *gin.Context) { executeAudioStep(c, "speakers") } + +// ExecuteAudioStructure POST /api/skills/audio/structure —— 第 5 步：整理段落与重点。 +func ExecuteAudioStructure(c *gin.Context) { executeAudioStep(c, "structure") } + +// ExecuteAudioMinutes POST /api/skills/audio/minutes —— 第 6 步：提炼可交付纪要。 +func ExecuteAudioMinutes(c *gin.Context) { executeAudioStep(c, "minutes") } + +// executeAudioStep 四步的公共外壳：校验入参 → 校验任务归属 → 执行 → 单事务落库。 +// +// 每步一次 HTTP 请求而不是一次长请求，是为了让每步各写一条 task_run： +// 前端右栏的工作流进度与产物区都读 task_run / task_artifact， +// 一次长请求会让「工作流 x/4」永远停在 1。 +func executeAudioStep(c *gin.Context, step string) { + spec, ok := audioStepSpecs[step] + if !ok { + // 路由是写死的，走不到这里；留着是为了将来加步骤时漏配时直接吵。 + web.Fail(c, web.NewNotFoundError("未知的音频技能步骤："+step)) + return + } + + user := middleware.CurrentUser(c) + if user == nil { + web.Fail(c, web.NewAuthError("未登录")) + return + } + + var req audioStepReq + if err := c.ShouldBindJSON(&req); err != nil { + web.Fail(c, web.NewBadRequest("请求参数错误")) + return + } + if req.TaskID == 0 { + web.Fail(c, web.NewBadRequest("task_id 必填")) + return + } + + task, found := loadMyOwnedTask(c, user, req.TaskID) + if !found { + return + } + + var ( + outcome *audioStepOutcome + err error + ) + switch step { + case "scope": + outcome, err = runAudioScopeStep(user, req) + case "transcribe": + outcome, err = runAudioTranscribeStep(user, req) + case "speakers": + outcome, err = runAudioSpeakersStep(c, task, req) + case "structure": + outcome, err = runAudioTextStep(c, task, req, audiotranscribe.KindStructure) + case "minutes": + outcome, err = runAudioTextStep(c, task, req, audiotranscribe.KindMinutes) + } + if err != nil { + web.Fail(c, web.NewBadRequest(err.Error())) + return + } + + run, artifact, err := persistAudioStep(task, spec, outcome) + if err != nil { + web.Fail(c, web.NewBadRequest("保存结果失败："+err.Error())) + return + } + + freshTask, _ := reloadTask(task.ID) + payload := gin.H{ + "step": spec.Step, + "action_key": audioSkillKey + ":" + spec.Step, + "summary": outcome.Summary, + "content": outcome.ContentText, + "result": outcome.Output, + "run": run, + "artifact": artifact, + "task": freshTask, + } + for key, value := range outcome.Extra { + payload[key] = value + } + web.OK(c, payload) +} + +// runAudioScopeStep 第 1 步：不做转写，只把「这次要转什么、按什么口径转」定下来。 +// +// 路由在这一步就要解析一次并校验：配错的话现在吵，比让用户等一次几十秒的 +// 转写请求再拿到一句莫名其妙的报错要好。 +func runAudioScopeStep(user *model.User, req audioStepReq) (*audioStepOutcome, error) { + media, err := loadOwnedAudioMedia(user, req.MediaID) + if err != nil { + return nil, err + } + path, err := audiotranscribe.MediaFilePath(media) + if err != nil { + return nil, err + } + route, err := config.GetAudioRoute("audio_transcribe") + if err != nil { + return nil, fmt.Errorf("音频路由不可用：%w", err) + } + if route.Category != "audio" { + return nil, fmt.Errorf("路由 %s 的分类是 %q，不是 audio", route.RouteID, route.Category) + } + + // 第 5、6 步要用对话路由把逐字稿加工成整篇文档，那是**长文输出**。 + // 这里提前把它解析出来验一次预算，理由和上面验音频路由一样，只是代价更大： + // 预算不够的症状是「等完一次完整的转写（本例 4 分钟），第 5 步才正文 0 字」。 + // 报错信息本身没错，但发现得太晚； + // + // 顺带把这条路由写进第 1 步的产物，让用户在开跑之前就能看见 + // 「这次加工用的是哪个模型」—— 对话框里选的模型确实会带进来，不该是隐形的。 + llmRoute, err := resolveAudioChatRoute(req.AiRouteID) + if err != nil { + return nil, err + } + if llmRoute.MaxTokens < audioLLMMinTokens { + return nil, fmt.Errorf( + "对话路由 %s 的 max_tokens 是 %d，低于逐字稿整理所需的 %d —— 这是推理模型，"+ + "思考与正文共用这份预算，预算不够时正文会是 0 字。请在对话框的模型选择里"+ + "换一条预算更大的路由，或清空模型选择改用技能自带的路由", + llmRoute.RouteID, llmRoute.MaxTokens, audioLLMMinTokens) + } + + duration := audiotranscribe.ProbeDuration(path) + durationText := "未知（ffprobe 不可用或文件头异常）" + if duration > 0 { + durationText = audiotranscribe.FormatDuration(duration) + } + + language := normalizeAudioLanguage(req.Language) + languageText := "自动识别" + if language != "" { + languageText = audioLanguageLabel(language) + } + speakerText := "不区分（当前音频路由的模型不输出说话人）" + if route.SupportsSpeakers { + speakerText = "区分（当前音频路由的模型输出说话人标签）" + } + + lines := []string{ + fmt.Sprintf("- 音频文件：%s", media.Filename), + fmt.Sprintf("- 格式与大小：%s / %s", strings.ToUpper(strings.TrimPrefix(media.FileExt, ".")), humanFileSize(media.FileSize)), + fmt.Sprintf("- 时长：%s", durationText), + fmt.Sprintf("- 目标语言：%s", languageText), + fmt.Sprintf("- 转写路由：%s · %s", route.ShortRouteName, route.ShortModelName), + fmt.Sprintf("- 说话人分离：%s", speakerText), + fmt.Sprintf("- 音频去向：%s", audioEgressLabel(config.IsLocalRoute(route))), + fmt.Sprintf("- 文本加工路由：%s · %s（max_tokens %d）", llmRoute.ShortRouteName, llmRoute.ShortModelName, llmRoute.MaxTokens), + } + // 出网提示必须按路由分岔。原先这句是无条件的「请确认内容可以出网」， + // 在默认走本机的现在就是一句假话 —— 而它恰恰是用户唯一能事先看到 + // 「录音会不会离开这台机器」的地方。 + egress := "\n\n> 本次转写在本机完成，音频不会离开这台机器。" + if !config.IsLocalRoute(route) { + egress = "\n\n> ⚠ 音频会上传到该路由对应的云端转写服务，请确认内容可以出网。" + } + content := "## 转写要求\n\n" + strings.Join(lines, "\n") + egress + + output := gin.H{ + "media_id": media.ID, + "file_name": media.Filename, + "file_ext": media.FileExt, + "file_size": media.FileSize, + "duration": duration, + "duration_text": durationText, + "language": language, + "route_id": route.RouteID, + "provider": route.Provider, + "model": route.Model, + "speakers": route.SupportsSpeakers, + "is_local": config.IsLocalRoute(route), + "llm_route_id": llmRoute.RouteID, + "llm_model": llmRoute.Model, + "llm_max_tokens": llmRoute.MaxTokens, + } + + return &audioStepOutcome{ + Summary: fmt.Sprintf("已确认转写范围：%s，目标语言%s，将使用 %s 转写。", + media.Filename, languageText, route.ShortModelName), + ContentText: content, + Input: gin.H{ + "task_id": req.TaskID, + "media_id": media.ID, + "language": req.Language, + }, + Output: output, + Logs: []string{ + fmt.Sprintf("读取音频附件：%s", media.Filename), + fmt.Sprintf("时长：%s", durationText), + fmt.Sprintf("转写路由：%s（%s）", route.RouteID, route.Model), + audioEgressLabel(config.IsLocalRoute(route)), + }, + SourceRefs: []gin.H{{"type": "upload", "title": media.Filename, "media_id": media.ID}}, + Extra: gin.H{ + "media_id": media.ID, + "route_id": route.RouteID, + "model": route.Model, + "duration": duration, + "is_local": config.IsLocalRoute(route), + }, + }, nil +} + +// runAudioTranscribeStep 第 2 步：真正把音频送去 ASR。 +func runAudioTranscribeStep(user *model.User, req audioStepReq) (*audioStepOutcome, error) { + media, err := loadOwnedAudioMedia(user, req.MediaID) + if err != nil { + return nil, err + } + path, err := audiotranscribe.MediaFilePath(media) + if err != nil { + return nil, err + } + fileData, err := os.ReadFile(path) + if err != nil { + return nil, fmt.Errorf("读取音频文件失败：%w", err) + } + + language := normalizeAudioLanguage(req.Language) + result, err := audiotranscribe.TranscribeBytes( + user.ID, fileData, media.Filename, audiotranscribe.ExtractExt(media.Filename), language, "") + if err != nil { + return nil, err + } + + transcript := audiotranscribe.FormatTranscriptWithSpeakers(result) + durationText := audiotranscribe.FormatDuration(result.Duration) + speakerText := "未识别出说话人" + if result.HasSpeakers { + speakerText = fmt.Sprintf("已区分 %d 类说话人", countSpeakers(result.Segments)) + } + + return &audioStepOutcome{ + Summary: fmt.Sprintf("已完成转写：时长 %s，%d 个分段，%s。", + durationText, len(result.Segments), speakerText), + ContentText: transcript, + Input: gin.H{ + "task_id": req.TaskID, + "media_id": media.ID, + "language": language, + }, + Output: gin.H{ + "media_id": media.ID, + "file_name": media.Filename, + "text": result.Text, + "transcript": transcript, + "language": result.Language, + "duration": result.Duration, + "segments": result.Segments, + "has_speakers": result.HasSpeakers, + "model": result.Model, + "route_id": result.RouteID, + "is_local": result.IsLocal, + "fell_back": result.FellBack, + }, + Logs: transcribeLogs(result, media, durationText), + SourceRefs: []gin.H{{"type": "upload", "title": media.Filename, "media_id": media.ID}}, + Extra: gin.H{ + "media_id": media.ID, + "route_id": result.RouteID, + "model": result.Model, + "duration": result.Duration, + "has_speakers": result.HasSpeakers, + "segments": len(result.Segments), + // is_local 一路带到前端：本地 ASR 不可用时会静默回退云端， + // 用户有权知道这一次的录音被送出了本机。 + "is_local": result.IsLocal, + "is_local_zh": audioEgressLabel(result.IsLocal), + "fell_back": result.FellBack, + "primary_route_id": result.PrimaryRouteID, + // fell_back_zh 是给用户看的成品句子，界面直接显示即可。 + // fallback_reason 是原始错误串，留作排障，不往用户脸上摆。 + "fell_back_zh": audioFallbackLabel(result), + "fallback_reason": result.FallbackReason, + }, + }, nil +} + +// audioEgressLabel 把「音频去了哪」说成人话。一处措辞，日志与界面共用。 +// +// 说「未离开本机」而不是「未出网」：判据是回环地址（config.IsLocalRoute）， +// 它只证明音频没离开这台机器，不证明它没离开内网 —— ASR 若部署在内网另一台 +// 机器上，这里也会是 false。对一个宣称 100% 内网部署的平台， +// 把「没出公网」说成「没出网」是在对用户撒谎，方向还正好是最不该错的那一边。 +func audioEgressLabel(isLocal bool) string { + if isLocal { + return "本机转写，音频未离开本机" + } + return "⚠ 走的是云端路由，音频已离开本机" +} + +// audioRouteDisplayName 把路由 id 换成人读得懂的名字，换不到就回落到 id 本身。 +// +// 界面上的回退提示要写成「本地 不可用，已改用 SiliconFlow」； +// 直接塞 id 会变成「audio_route_local_whisper 不可用」—— 那是配置里的内部标识， +// 说给用户听等于没说。 +func audioRouteDisplayName(routeID string) string { + routeID = strings.TrimSpace(routeID) + if routeID == "" { + return "" + } + if route, err := config.GetRouteForCategory(routeID, "audio"); err == nil && route != nil { + if name := strings.TrimSpace(route.ShortRouteName); name != "" { + return name + } + } + return routeID +} + +// audioFallbackLabel 把「换了一条路由」说成人话，没换则返回空串。 +// +// 与 audioEgressLabel 同一个理由：措辞只有这一处，日志和界面不会各说各的。 +// 前端拿到的是成品句子，不再自己拼路由名 —— 拼装所需的配置在前端根本拿不到。 +func audioFallbackLabel(result *audiotranscribe.Result) string { + if result == nil || !result.FellBack { + return "" + } + return fmt.Sprintf("主路由「%s」本次不可用，已改用「%s」完成转写。", + audioRouteDisplayName(result.PrimaryRouteID), audioRouteDisplayName(result.RouteID)) +} + +// transcribeLogs 第 2 步的日志行。 +// +// 出网那一行只在本地的没走成时出现：本地转写是这个平台的常态，不该每次 +// 都刷一行「没出网」；而回退云端是异常，必须显眼 —— 用户可能正是为了 +// 「录音不出门」才选的本地方案，静默出网是最不能接受的一种失败。 +func transcribeLogs(result *audiotranscribe.Result, media model.MediaFile, durationText string) []string { + logs := []string{ + fmt.Sprintf("读取音频附件：%s（%s）", media.Filename, humanFileSize(media.FileSize)), + fmt.Sprintf("调用转写路由：%s（%s）", result.RouteID, result.Model), + } + if result.FellBack { + logs = append(logs, fmt.Sprintf( + "⚠ 主路由 %s 不可用（%s），已回退到 %s", + result.PrimaryRouteID, result.FallbackReason, result.RouteID)) + } + if !result.IsLocal { + logs = append(logs, audioEgressLabel(false)) + } + return append(logs, fmt.Sprintf("转写完成：时长 %s，%d 个分段", + durationText, len(result.Segments))) +} + +// runAudioSpeakersStep 第 3 步：从逐字稿里推断每位说话人的身份，然后**停下来等确认**。 +// +// 说话人清单由这一步自己从第 2 步的产物里取（分段里的 speaker 字段），不接受前端传： +// 前端传的话，一份被改过的清单就能让下游把身份安到别人头上。 +// +// 这一步是整个技能里唯一产出「待确认」状态的步骤，落库时把产物写成 ready、 +// 任务写成「待确认」—— 两处都是既有枚举，界面上也已经有对应的展示（右栏产物区 +// 显示「待确认」，左侧任务列表显示「待确认」），不需要任何新的展示代码。 +func runAudioSpeakersStep(c *gin.Context, task model.TaskRecord, req audioStepReq) (*audioStepOutcome, error) { + transcript, found := latestArtifact(task.ID, "transcript") + if !found || strings.TrimSpace(transcript.ContentText) == "" { + return nil, fmt.Errorf("本任务还没有「逐字转写稿」，请先完成转写再来识别说话人") + } + + keys := audiotranscribe.SpeakerKeysOf(transcript.ContentJSON) + if len(keys) == 0 { + // 硬失败，不当作「没有说话人」自动放行。 + // + // 这里对应 G02 反例 A 的形状：「状态未知就默认视为通过」。当前音频路由是 + // 开着说话人分离的（audio_route_siliconflow_diarize 的 supports_speakers + // 为 true），配了却没吐出说话人标签，只可能是转写出了问题 —— 那种情况下 + // 悄悄跳过身份确认，会让后面几步把「说话人 0」当成一个人名写进纪要。 + return nil, fmt.Errorf("逐字稿里没有说话人标签：当前音频路由配了说话人分离却没输出，" + + "请检查第 2 步的转写结果，或换一条音频路由后重跑") + } + + route, err := resolveAudioChatRoute(req.AiRouteID) + if err != nil { + return nil, err + } + + // 截断是会影响结论的事实：只看了前半段稿子推出来的身份，可信度与看完全稿 + // 不是一回事。所以它由推断那一步顺带报出来，写进正文与日志， + // 让用户在确认时知道自己核对的依据有多全。 + roster, clipped, err := audiotranscribe.InferSpeakerIdentities( + c.Request.Context(), transcript.ContentText, keys, route) + if err != nil { + return nil, err + } + + content := audiotranscribe.RenderSpeakerRoster(roster, false) + if clipped { + content += fmt.Sprintf("\n> ⚠️ 逐字稿过长，本次只把前 %d 字交给了模型，结论可能不完整。\n", + audiotranscribe.SpeakerInferMaxChars) + } + + logs := []string{ + fmt.Sprintf("读取上一步产物：逐字转写稿（%d 字）", len([]rune(transcript.ContentText))), + fmt.Sprintf("稿中共 %d 位说话人：%s", len(keys), strings.Join(keys, "、")), + fmt.Sprintf("调用对话路由推断身份：%s（%s）", route.RouteID, route.Model), + "推断结果已落库，等待用户确认后才继续整理与纪要", + } + if clipped { + logs = append(logs, fmt.Sprintf("逐字稿超过 %d 字，已截断后推断", + audiotranscribe.SpeakerInferMaxChars)) + } + + return &audioStepOutcome{ + Summary: fmt.Sprintf("已推断出 %d 位说话人的身份，等待确认后继续。", len(roster)), + // 产物落 ready：右栏把它显示成「待确认」，这正是这一步的真实状态。 + ArtifactStatus: specialistruntime.ArtifactStatusReady, + TaskStatus: specialistruntime.TaskStatusPendingReview, + ContentText: content, + Input: gin.H{ + "task_id": req.TaskID, + "source_type": "transcript", + "source_chars": len([]rune(transcript.ContentText)), + "speaker_keys": keys, + "ai_route_id": route.RouteID, + "transcript_clipped": clipped, + }, + Output: gin.H{ + "source_type": "transcript", + "speakers": roster, + "speaker_keys": keys, + "model": route.Model, + "route_id": route.RouteID, + "transcript_clipped": clipped, + }, + Logs: logs, + SourceRefs: []gin.H{{"type": "artifact", "artifact_type": "transcript"}}, + Extra: gin.H{ + "route_id": route.RouteID, + "model": route.Model, + "speakers": roster, + }, + }, nil +} + +// runAudioTextStep 第 5、6 步：拿上一步的产物喂给模型再加工。 +// +// 逐字稿从库里读而不是让前端传回来：一小时会议的稿子几万字， +// 在浏览器里往返两趟既慢又给了「传了个被截断的版本」的机会。 +// 读不到就直接报错，不拿空字符串去问模型 —— 那样会得到一个看着像模像样的空纪要。 +func runAudioTextStep(c *gin.Context, task model.TaskRecord, req audioStepReq, kind audiotranscribe.Kind) (*audioStepOutcome, error) { + var sourceType, sourceLabel string + switch kind { + case audiotranscribe.KindStructure: + sourceType, sourceLabel = "transcript", "逐字转写稿" + case audiotranscribe.KindMinutes: + sourceType, sourceLabel = "document", "结构化纪要" + default: + return nil, fmt.Errorf("未知的加工步骤：%q", kind) + } + + source, err := latestArtifactText(task.ID, sourceType, sourceLabel) + if err != nil { + return nil, err + } + + // 闸门。放在这里而不是放在前端：前端禁用按钮只是 UX，直接把请求打到这个 + // 端点照样能绕过 —— 而这道闸门要拦的正是「没人确认过，AI 就把推断出来的 + // 身份当成事实写进正式纪要」。 + if err := ensureAudioSpeakersConfirmed(task.ID); err != nil { + return nil, err + } + // 确认过之后才轮到把身份写进正文。注意是内存里替换，不回写逐字稿产物。 + source = applyAudioSpeakerNames(task.ID, source) + + route, err := resolveAudioChatRoute(req.AiRouteID) + if err != nil { + return nil, err + } + + content, err := audiotranscribe.RunLLMStep(c.Request.Context(), kind, source, route) + if err != nil { + return nil, err + } + + title := "结构化纪要" + if kind == audiotranscribe.KindMinutes { + title = "行动项清单" + } + + return &audioStepOutcome{ + Summary: fmt.Sprintf("已根据%s生成%s（模型：%s）。", sourceLabel, title, route.ShortModelName), + ContentText: content, + Input: gin.H{ + "task_id": req.TaskID, + "source_type": sourceType, + "source_chars": len([]rune(source)), + "ai_route_id": route.RouteID, + }, + Output: gin.H{ + "source_type": sourceType, + "source_label": sourceLabel, + "content": content, + "model": route.Model, + "route_id": route.RouteID, + }, + Logs: []string{ + fmt.Sprintf("读取上一步产物：%s（%d 字）", sourceLabel, len([]rune(source))), + fmt.Sprintf("调用对话路由：%s（%s）", route.RouteID, route.Model), + fmt.Sprintf("已生成%s", title), + }, + SourceRefs: []gin.H{{"type": "artifact", "artifact_type": sourceType}}, + Extra: gin.H{ + "route_id": route.RouteID, + "model": route.Model, + }, + }, nil +} + +// persistAudioStep 单事务写一条 task_run + 一条 task_artifact，并更新任务本身。 +// +// 与 persistOfficeExecution 的形状不同所以没有合并：那边是从一个 result map 里 +// 派生出 N 条产物（还带一堆字段回退），这边每一步恰好一条产物、title/type 写死。 +// 硬套一个「通用 helper」只会让两边都多一层没必要的间接。 +func persistAudioStep(task model.TaskRecord, spec audioStepSpec, outcome *audioStepOutcome) (model.TaskRun, model.TaskArtifact, error) { + now := time.Now() + actionKey := audioSkillKey + ":" + spec.Step + inputJSON, _ := json.Marshal(outcome.Input) + outputJSON, _ := json.Marshal(outcome.Output) + logsJSON, _ := json.Marshal(outcome.Logs) + sourceRefsJSON, _ := json.Marshal(outcome.SourceRefs) + if outcome.SourceRefs == nil { + sourceRefsJSON = []byte("[]") + } + + run := model.TaskRun{} + artifact := model.TaskArtifact{} + + err := store.DB.Transaction(func(tx *gorm.DB) error { + run = model.TaskRun{ + TaskID: task.ID, + SpecialistKey: task.SpecialistKey, + ActionKey: actionKey, + ActionTitle: spec.ActionTitle, + ActionType: "audio", + Status: "done", + InputJSON: string(inputJSON), + OutputJSON: string(outputJSON), + LogsJSON: string(logsJSON), + StartedAt: now, + FinishedAt: &now, + } + if err := tx.Create(&run).Error; err != nil { + return err + } + + artifactStatus := outcome.ArtifactStatus + if artifactStatus == "" { + artifactStatus = specialistruntime.ArtifactStatusDraft + } + artifact = model.TaskArtifact{ + TaskID: task.ID, + SpecialistKey: task.SpecialistKey, + Title: spec.ArtifactTitle, + ArtifactType: spec.ArtifactType, + Status: artifactStatus, + ContentText: outcome.ContentText, + ContentJSON: string(outputJSON), + SourceRefsJSON: string(sourceRefsJSON), + CreatedByRunID: &run.ID, + } + if err := tx.Create(&artifact).Error; err != nil { + return err + } + + taskStatus := outcome.TaskStatus + if taskStatus == "" { + taskStatus = specialistruntime.TaskStatusDraft + } + task.CurrentRunID = &run.ID + task.CurrentResult = outcome.Summary + task.Status = taskStatus + task.LastTriggeredAt = &now + return tx.Save(&task).Error + }) + if err != nil { + return model.TaskRun{}, model.TaskArtifact{}, err + } + return run, artifact, nil +} + +// loadOwnedAudioMedia 取一个属于当前用户的音频素材。 +// +// 归属校验不能省：media_id 是前端传上来的，没有这一道就能拿别人的录音去转写。 +// 管理员放行，与素材审批页的口径一致。 +func loadOwnedAudioMedia(user *model.User, mediaID uint) (model.MediaFile, error) { + if mediaID == 0 { + return model.MediaFile{}, fmt.Errorf("缺少 media_id：这一步需要指定要处理的音频附件") + } + m, found := mediaFileDAO.GetByID(mediaID) + if !found { + return model.MediaFile{}, fmt.Errorf("音频附件不存在（media_id=%d）", mediaID) + } + if m.SubmitterID != user.ID && user.Role != "admin" { + return model.MediaFile{}, fmt.Errorf("音频附件不属于当前用户（media_id=%d）", mediaID) + } + if !audiotranscribe.IsAudioExt(m.FileExt) { + return model.MediaFile{}, fmt.Errorf("附件「%s」不是可转写的音频（格式 %q）", m.Filename, m.FileExt) + } + return m, nil +} + +// latestArtifactText 取本任务最近一条指定类型的产物正文。 +func latestArtifactText(taskID uint, artifactType, label string) (string, error) { + var artifact model.TaskArtifact + err := store.DB. + Where("task_id = ? AND artifact_type = ?", taskID, artifactType). + Order("id DESC"). + First(&artifact).Error + if err != nil { + return "", fmt.Errorf("本任务还没有「%s」，请先完成上一步", label) + } + text := strings.TrimSpace(artifact.ContentText) + if text == "" { + return "", fmt.Errorf("本任务的「%s」是空的，无法继续加工", label) + } + return text, nil +} + +// latestArtifact 取本任务内某类型最新的一条产物**整行**。 +// +// 与 latestArtifactText 的区别是它还要 ContentJSON 与 Status：说话人名单的结构化 +// 数据在 ContentJSON 里（正文那份是给人看的），而「确认没确认」只能看 Status。 +func latestArtifact(taskID uint, artifactType string) (model.TaskArtifact, bool) { + var artifact model.TaskArtifact + err := store.DB. + Where("task_id = ? AND artifact_type = ?", taskID, artifactType). + Order("id DESC"). + First(&artifact).Error + if err != nil { + return model.TaskArtifact{}, false + } + return artifact, true +} + +// audioSpeakerArtifactType 「说话人名单」产物的类型。 +// +// 单独拎出来是因为有三处要用同一个字面量：识别那一步写它、确认那一步读它、 +// 闸门也读它。三处各写一遍的话，改类型名时只有一处会漏，而漏掉的那处的症状是 +// 「闸门永远说没确认过」—— 任务卡死，且看不出为什么。 +const audioSpeakerArtifactType = "speakers" + +// audioRouteSupportsSpeakers 单独拎成变量，只为让测试能覆盖「这条音频路由不输出 +// 说话人分离」那一支。音频路由读的是 config/ai_config.json，没有环境变量可以改写 +// 它指向的文件，测试里没法安全地换一条路由（那是用户线上正在用的配置）。 +// +// 这一支必须被测到：它是**唯一的放行口**，写反了（比如把取反写掉）会让所有 +// 用 Qwen3-ASR 这类无说话人分离路由的任务永久卡死在第 5 步，没有任何办法绕过去。 +// 同一个模式见 internal/skills/core/allowed_skills.go 的 allowedSkillKeyProvider。 +// 读的是**声明路由**（default_audio_route）而不是解析 audio_transcribe： +// 后者现在指向 auto，会按此刻哪台服务活着挑一条，于是这一问的答案会随着 +// 本机 ASR 起没起而变化 —— 而这个答案必须是常量。第 1 步（确认范围）、 +// 第 2 步（转写）、第 5/6 步（本闸门）是三次独立解析，中间隔着几分钟， +// 用 auto 就会出现「闸门以为有标签、稿子里其实没有」这种最坏的自相矛盾。 +// auto 侧的配套约束见 config/route_health.go 的 resolveAutoRoute： +// 它只在说话人能力相同的候选里挑，所以声明值就是实际会跑的那一类。 +var audioRouteSupportsSpeakers = func() (bool, error) { + route, err := config.GetDeclaredAudioRoute() + if err != nil { + return false, fmt.Errorf("音频路由不可用：%w", err) + } + return route.SupportsSpeakers, nil +} + +// ensureAudioSpeakersConfirmed 闸门：说话人身份没被用户确认过，下游两步不许跑。 +// +// 为什么是一道硬闸门而不是界面上的一句提示：推断出来的身份会被写进正式纪要 +// （runAudioTextStep 里的 applyAudioSpeakerNames），而**推断可能是错的** —— +// 模型听见一句「张局」就给人安上「张局长」，用户不核对就看不出来。纪要一旦 +// 以这个身份发出去，「张三说」和「李四说」就换了人。所以这一步不放行， +// 而不是放行后补一句「仅供参考」——后者是 AR05 §6.6 明确不接受的做法。 +// +// 音频路由不支持说话人分离时直接放行：那种情况下第 3 步根本跑不起来， +// 不存在「有一个待确认的身份」这件事，卡在这里就成了死锁。 +func ensureAudioSpeakersConfirmed(taskID uint) error { + supports, err := audioRouteSupportsSpeakers() + if err != nil { + return err + } + if !supports { + return nil + } + + artifact, found := latestArtifact(taskID, audioSpeakerArtifactType) + if !found { + return fmt.Errorf( + "本任务还没有「说话人名单」：当前音频路由输出说话人标签，" + + "请先执行「识别说话人身份」并确认后再继续") + } + if specialistruntime.NormalizeArtifactStatus(artifact.Status) != specialistruntime.ArtifactStatusApproved { + return fmt.Errorf( + "说话人身份尚未确认：请在「说话人名单」上核对机构名、头衔与姓名并确认，" + + "确认之后才能继续整理与生成纪要") + } + return nil +} + +// applyAudioSpeakerNames 把确认过的身份替换进正文。 +// +// 只改**内存里的这一份**，不回写 transcript 产物：那份稿子的价值恰恰在于它是 +// ASR 没被动过的原始记录。查到没确认过（或名单读不出来）就原样返回 —— +// 这个函数是被闸门放行之后才调用的，此刻正常路径上一定读得到已确认的名单； +// 读不到只可能是别处改了数据，那种情况下「不改」比「改一半」安全。 +func applyAudioSpeakerNames(taskID uint, text string) string { + artifact, found := latestArtifact(taskID, audioSpeakerArtifactType) + if !found { + return text + } + if specialistruntime.NormalizeArtifactStatus(artifact.Status) != specialistruntime.ArtifactStatusApproved { + return text + } + return audiotranscribe.ApplySpeakerNames(text, audiotranscribe.SpeakerRosterOf(artifact.ContentJSON)) +} + +// audioSpeakerConfirmReq 确认说话人身份的请求体。 +// +// 只收名单本身，**不收 decided_by**：那个标志位由服务端比对「AI 推断值 vs 提交值」 +// 算出来（audiotranscribe.MarkDecidedBy）。让客户端自报「我没改过」是无法核验的， +// 而那正是这个字段要记录的事。 +type audioSpeakerConfirmReq struct { + TaskID uint `json:"task_id"` + Speakers []audiotranscribe.SpeakerIdentity `json:"speakers"` +} + +// ExecuteAudioSpeakersConfirm POST /api/skills/audio/speakers/confirm —— 第 4 步： +// 用户核对完身份后确认，把名单从 ready 推到 approved，下游两步这才解锁。 +// +// 这一步**不产生产物**（名单本身就是产物，只是改了状态），所以不走 +// persistAudioStep —— 走的话会多写一条标题同样叫「说话人名单」、正文却为空的 +// 记录，右栏产物区里就会出现两份同名产物、其中一份点开是空的。 +func ExecuteAudioSpeakersConfirm(c *gin.Context) { + spec := audioStepSpecs["speakers-confirm"] + + user := middleware.CurrentUser(c) + if user == nil { + web.Fail(c, web.NewAuthError("未登录")) + return + } + + var req audioSpeakerConfirmReq + if err := c.ShouldBindJSON(&req); err != nil { + web.Fail(c, web.NewBadRequest("请求参数错误")) + return + } + if req.TaskID == 0 { + web.Fail(c, web.NewBadRequest("task_id 必填")) + return + } + if len(req.Speakers) == 0 { + web.Fail(c, web.NewBadRequest("说话人名单是空的：请至少保留识别出来的每一位说话人")) + return + } + + task, found := loadMyOwnedTask(c, user, req.TaskID) + if !found { + return + } + + artifact, found := latestArtifact(task.ID, audioSpeakerArtifactType) + if !found { + web.Fail(c, web.NewBadRequest("本任务还没有「说话人名单」，请先执行识别说话人身份")) + return + } + // 已经确认过就不再来一次：这一步会改写下游要用的身份，重复提交要么是双击、 + // 要么是拿着一个过期的页面在改 —— 两种都不该悄悄覆盖掉刚才那份确认。 + if specialistruntime.NormalizeArtifactStatus(artifact.Status) == specialistruntime.ArtifactStatusApproved { + web.Fail(c, web.NewConflictError( + "说话人身份已经确认过了。要改请重新执行「识别说话人身份」，再对新的名单确认")) + return + } + if !specialistruntime.CanTransitionArtifactStatus(artifact.Status, specialistruntime.ArtifactStatusApproved) { + web.Fail(c, web.NewBadRequest(fmt.Sprintf( + "当前名单的状态是 %q，不允许确认为已确认", artifact.Status))) + return + } + + // 键集合以**库里那份 AI 推断结果**为准，不以本次提交的为准 —— 拿提交的当基准 + // 等于没校验：提交几个就认几个，多出来的那位会一路进到纪要里。 + inferred := audiotranscribe.SpeakerRosterOf(artifact.ContentJSON) + if len(inferred) == 0 { + web.Fail(c, web.NewBadRequest("库里这份说话人名单读不出结构化内容，请重新执行识别说话人身份")) + return + } + if err := audiotranscribe.ValidateSpeakerRosterKeys(req.Speakers, inferred); err != nil { + web.Fail(c, web.NewBadRequest(err.Error())) + return + } + + marked := audiotranscribe.MarkDecidedBy(req.Speakers, inferred) + edited := 0 + for _, item := range marked { + if item.DecidedBy == audiotranscribe.SpeakerDecidedByUserEdited { + edited++ + } + } + + now := time.Now() + output := gin.H{ + "source_type": audioSpeakerArtifactType, + "source_label": "说话人名单", + "speakers": marked, + "edited_count": edited, + "confirmed_at": now.Format(time.RFC3339), + "confirmed_by": user.ID, + "speaker_count": len(marked), + } + outputJSON, _ := json.Marshal(output) + content := audiotranscribe.RenderSpeakerRoster(marked, true) + inputJSON, _ := json.Marshal(gin.H{ + "task_id": req.TaskID, + "speakers": req.Speakers, + }) + logsJSON, _ := json.Marshal([]string{ + fmt.Sprintf("用户确认了 %d 位说话人的身份（其中 %d 位经过修改）", len(marked), edited), + "下游「整理段落与重点」「提炼可交付纪要」从这一步解锁", + }) + + run := model.TaskRun{} + err := store.DB.Transaction(func(tx *gorm.DB) error { + run = model.TaskRun{ + TaskID: task.ID, + SpecialistKey: task.SpecialistKey, + ActionKey: audioSkillKey + ":" + spec.Step, + ActionTitle: spec.ActionTitle, + ActionType: "audio", + Status: "done", + InputJSON: string(inputJSON), + OutputJSON: string(outputJSON), + LogsJSON: string(logsJSON), + StartedAt: now, + FinishedAt: &now, + } + if err := tx.Create(&run).Error; err != nil { + return err + } + + // 名单本体跟着改：产物是这份文档的**当前有效版本**，用户确认的就是这一版。 + // 推断的那一版不会丢 —— 它还在上一条 task_run 的 OutputJSON 里，留痕是齐的。 + artifact.Status = specialistruntime.ArtifactStatusApproved + artifact.ContentJSON = string(outputJSON) + artifact.ContentText = content + if err := tx.Save(&artifact).Error; err != nil { + return err + } + + // 任务状态回到「草案已生成」而不是让它跟着产物变成「已完成」： + // 确认身份只是解锁了下游，活还没干完（还有整理与纪要两步）。 + task.CurrentRunID = &run.ID + task.CurrentResult = fmt.Sprintf("已确认 %d 位说话人的身份，可以继续整理与生成纪要。", len(marked)) + task.Status = specialistruntime.TaskStatusDraft + task.LastTriggeredAt = &now + return tx.Save(&task).Error + }) + if err != nil { + web.Fail(c, web.NewBadRequest("保存确认结果失败："+err.Error())) + return + } + + freshTask, _ := reloadTask(task.ID) + web.OK(c, gin.H{ + "step": spec.Step, + "action_key": audioSkillKey + ":" + spec.Step, + "summary": task.CurrentResult, + "content": content, + "result": output, + "run": run, + "artifact": artifact, + "task": freshTask, + "speakers": marked, + }) +} + +// audioLLMAgentRoute 第 5、6 步（整理 / 纪要）默认用的路由，值是 ai_config.json +// 里 agent_routes 的名字。 +// +// 为什么这两步要单独有一条路由，而不是跟着 default_route 走：它们和聊天不是一类 +// 负载 —— 要**产出一整篇文档**。而当前的路由是推理模型，思考与正文共用 max_tokens， +// 实测 4096 的预算下思考能把预算吃光、正文一个字都写不出来（六次实测只有一次写出 +// 正文），8192 下四次全成（数据见 audio_transcribe/prompts.go 的 llmChunkChars）。 +// 挂在 default_route 上就等于把「聊天要多少预算」和「整理逐字稿要多少预算」绑死成 +// 同一个数字，而这两件事对预算的要求差了一倍。 +const audioLLMAgentRoute = "audio_transcribe_llm" + +// audioLLMMinTokens 第 5、6 步能跑起来的 max_tokens 下限。 +// +// 16384 这个数字来自实测，不是估的：同一批逐字稿，8192 下纪要步骤归并时 +// finish_reason=length、正文 0 字，16384 才出稿，32768 又快又稳 +// （完整数据见 ai_config.json 里 chat_route_lmuai_deepseek_v4_flash_doc 的说明）。 +// +// 它是一道**预检**而不是硬性要求：真正卡住的是模型自己，这里只是把 +// 「等完一次完整转写才发现」提前成「几秒内就吵」，所以取的是实测的临界值 +// 而不是留出余量 —— 刚好卡在临界上的路由本来就该被提醒。 +const audioLLMMinTokens = 16384 + +// ensureAudioLLMAgentRouteConfigured 确认上面那条路由真的配了。 +// +// 非查不可，因为 GetRoute 对认不出的名字会**静默回退 default_route** +// （json_loader.go 的第 3 步，见 GetRoute 的注释）。少了这道检查， +// 「agent_routes 里漏配了这一行」会伪装成「用了默认路由」，症状是整理步骤 +// 又写出空稿 —— 而排查会从提示词、模型名、密钥一路查到天边，就是想不到 +// 是配置里缺了一行。这里把缺的那一行直接指出来。 +func ensureAudioLLMAgentRouteConfigured() error { + aiCfg, err := config.LoadAIConfig() + if err != nil { + return fmt.Errorf("AI 配置加载失败：%w", err) + } + target, ok := aiCfg.AgentRoutes[audioLLMAgentRoute] + if !ok { + return fmt.Errorf( + "ai_config.json 的 agent_routes 里缺少 %q：第 5、6 步要产出一整篇文档，"+ + "需要一条 max_tokens 足够大的对话路由（推理模型的思考会占掉大部分预算）", + audioLLMAgentRoute) + } + if _, ok := aiCfg.ChatRoutes[target]; !ok { + return fmt.Errorf( + "ai_config.json 的 agent_routes.%s 指向 %q，但 chat_routes 里没有这条路由；"+ + "照这样配就只能静默退到 default_route，而它的预算通常写不完一整篇文档", + audioLLMAgentRoute, target) + } + return nil +} + +// resolveAudioChatRoute 解析第 5、6 步用的对话路由。 +// +// override 为空（用户在界面上没选模型）时用技能自带的那条；用户在界面上明确选了 +// 就按用户选的走 —— 明确指定了就不该被悄悄换掉，哪怕那条路由的预算不够：那种情况下 +// 调用方会报出带 max_tokens 的错误，用户看得见原因，比被暗中换模型好。 +// 指到非 chat 路由直接报错，不拿它去发对话请求。 +func resolveAudioChatRoute(override string) (*config.RouteConfig, error) { + routeID := strings.TrimSpace(override) + if routeID == "" { + if err := ensureAudioLLMAgentRouteConfigured(); err != nil { + return nil, err + } + routeID = audioLLMAgentRoute + } + route, err := config.GetRoute(routeID) + if err != nil { + return nil, fmt.Errorf("对话路由不可用：%w", err) + } + if route.Category != "chat" { + return nil, fmt.Errorf("路由 %s 的分类是 %q，不是 chat，不能用于文本加工", route.RouteID, route.Category) + } + if route.APIKey == "" { + return nil, fmt.Errorf("对话路由 %s（provider %s）缺少 API Key", route.RouteID, route.Provider) + } + return route, nil +} + +// normalizeAudioLanguage 归一化语言入参：空、"auto"、"自动" 一律视为交给模型判断。 +func normalizeAudioLanguage(value string) string { + lang := strings.ToLower(strings.TrimSpace(value)) + switch lang { + case "", "auto", "自动", "自动识别": + return "" + } + return lang +} + +// audioLanguageLabel 把语言码渲染成中文，未知的码原样返回（不硬编一张全量表）。 +func audioLanguageLabel(code string) string { + switch code { + case "zh": + return "中文" + case "en": + return "英文" + case "yue": + return "粤语" + case "ja": + return "日语" + case "ko": + return "韩语" + default: + return code + } +} + +// countSpeakers 统计分段里出现过几类说话人。 +func countSpeakers(segments []audiotranscribe.Segment) int { + seen := map[string]bool{} + for _, s := range segments { + if s.Speaker != "" { + seen[s.Speaker] = true + } + } + return len(seen) +} + +// humanFileSize 把字节数渲染成人读的大小。 +func humanFileSize(size int64) string { + const unit = 1024 + if size < unit { + return fmt.Sprintf("%d B", size) + } + value := float64(size) + units := []string{"KB", "MB", "GB"} + for _, suffix := range units { + value /= unit + if value < unit { + return fmt.Sprintf("%.1f %s", value, suffix) + } + } + return fmt.Sprintf("%.1f TB", value/unit) +} + +// mediaFileDAO 素材仓库（与 office_handlers.go 的 taskRecordDAO 同款声明方式）。 +var mediaFileDAO dal.MediaFileDAO diff --git a/eai_agentplatform/backend-go/internal/skills/api/audio_route_test.go b/eai_agentplatform/backend-go/internal/skills/api/audio_route_test.go new file mode 100644 index 0000000..d305c11 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/api/audio_route_test.go @@ -0,0 +1,102 @@ +package skillapi + +import ( + "os" + "path/filepath" + "testing" + + "eai_agentplatform/backend/internal/config" +) + +// TestMain 定位 backend-go 并切换工作目录，让 config/ai_config.json 在测试进程内 +// 可被找到（LoadAIConfig 的相对路径回退依赖 CWD）。 +func TestMain(m *testing.M) { + if base := locateBackendGoForTest(); base != "" { + _ = os.Chdir(base) + } + os.Exit(m.Run()) +} + +// locateBackendGoForTest 从当前工作目录向上找含 config/ai_config.json 的目录。 +func locateBackendGoForTest() string { + dir, err := os.Getwd() + if err != nil { + return "" + } + for { + if _, err := os.Stat(filepath.Join(dir, "config", "ai_config.json")); err == nil { + return dir + } + parent := filepath.Dir(dir) + if parent == dir { + return "" + } + dir = parent + } +} + +// TestAudioLLMRouteIsConfiguredWithEnoughBudget 钉住「第 3、4 步默认那条路由的 +// 预算是够的」。 +// +// 这是整套改动的落点。转写功能原先跑不通，根因既不是提示词也不是模型名，而是这类 +// 「要产出一整篇文档」的步骤被挂在了给聊天用的 4096 预算上：这些是推理模型，思考与 +// 正文共用 max_tokens，而**思考的长度跟输入几乎不成比例**（实测 1200 字的输入， +// 思考照样写到 7169 字）。4096 下正文一个字都写不出来（六次实测只成一次）， +// 8192 下四次全成。 +// +// 这一行配置很容易被当成冗余删掉：agent_routes 里少一行、或把那条 8192 的路由调回 +// 4096，功能都会**悄悄**退回「写不出来」——GetRoute 对认不出的名字会静默回退 +// default_route，Go 侧一个错都不报，只有拿到空产物的人才知道出了事。 +func TestAudioLLMRouteIsConfiguredWithEnoughBudget(t *testing.T) { + if err := ensureAudioLLMAgentRouteConfigured(); err != nil { + t.Fatalf("第 3、4 步的默认路由没配好：%v", err) + } + + aiCfg, err := config.LoadAIConfig() + if err != nil { + t.Fatalf("加载 ai_config.json 失败：%v", err) + } + target := aiCfg.AgentRoutes[audioLLMAgentRoute] + info := aiCfg.ChatRoutes[target] + + // 16384 不是个好看的整数，是实测出来的下限，而且是由**归并**那一步定的： + // 逐块加工 1200 字在 8192 下实测 11/11 正常，但纪要步骤最后要把各段结果归并成 + // 一份，那是最长的一次输入（实测 8628 字）——8192 下 finish_reason=length、 + // 正文 0 字（思考写了 14678 字），16384 才出稿，32768 又快又稳。 + // 逐块那一步其实用不到这么高，但上限是天花板不是配额：实测 8192 与 32768 两档下 + // 同一批 11 段的用时与 completion token 基本一致，抬高的余量是白拿的。 + const wantMaxTokens = 16384 + if info.MaxTokens < wantMaxTokens { + t.Errorf("路由 %s 的 max_tokens=%d，低于实测下限 %d：整理逐字稿会写出空稿或半截稿，"+ + "长稿更会卡在归并那一步上（归并要产出一整篇纪要，预算需求比逐块加工更高）。"+ + "这个值由实测倒推（见 audio_transcribe/prompts.go 的注释），调小之前请先复测", + target, info.MaxTokens, wantMaxTokens) + } + t.Logf("第 3、4 步默认路由：%s（max_tokens=%d，model=%s）", target, info.MaxTokens, info.Model) +} + +// TestResolveAudioChatRouteUsesSkillRouteWhenNotChosen 钉住「用户在界面上没选模型时， +// 第 3、4 步用的是技能自带那条大预算路由」。 +// +// 上面那条只验了**配置写对**，写对了不等于**用上了**：resolveAudioChatRoute 里少一步、 +// 或把 override 的处理写反，都会静默退回 default_route（4096）—— 而 Go 侧一个错都不报， +// 症状要到某一段随机写不出正文时才显形，正是这次要根除的那种「悄悄坏掉」。 +func TestResolveAudioChatRouteUsesSkillRouteWhenNotChosen(t *testing.T) { + // 界面没选模型时传下来的就是空串（见 audioStepReq.AiRouteID）；带空白的串一并覆盖， + // 因为「空」是靠 TrimSpace 判的，只测纯空串会漏掉另一种写法。 + for _, override := range []string{"", " "} { + route, err := resolveAudioChatRoute(override) + if err != nil { + t.Fatalf("override=%q 时应解析出技能自带路由，实际报错：%v", override, err) + } + if route.Category != "chat" { + t.Errorf("override=%q 解析到 %s，分类是 %q，期望 chat", override, route.RouteID, route.Category) + } + if route.MaxTokens < 16384 { + t.Errorf("override=%q 解析到 %s（max_tokens=%d），低于实测下限 16384："+ + "这个预算写不完整理稿，长稿还会卡在归并那一步上", + override, route.RouteID, route.MaxTokens) + } + t.Logf("override=%q → %s（max_tokens=%d）", override, route.RouteID, route.MaxTokens) + } +} diff --git a/eai_agentplatform/backend-go/internal/skills/api/audio_speakers_gate_test.go b/eai_agentplatform/backend-go/internal/skills/api/audio_speakers_gate_test.go new file mode 100644 index 0000000..d8070cd --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/api/audio_speakers_gate_test.go @@ -0,0 +1,278 @@ +package skillapi + +import ( + "fmt" + "path/filepath" + "strings" + "testing" + + "eai_agentplatform/backend/internal/config" + "eai_agentplatform/backend/internal/model" + audiotranscribe "eai_agentplatform/backend/internal/skills/packages/audio_transcribe" + specialistruntime "eai_agentplatform/backend/internal/specialists/runtime" + "eai_agentplatform/backend/internal/store" +) + +// 这一组用例钉的是「说话人身份没被用户确认过，下游两步不许跑」这道闸门。 +// +// 为什么值得单独写：这道闸门的失效**不会报任何错**。它一旦不生效，第 5、6 步照跑， +// 纪要里就会出现「张局说……李处说……」这种看着完全正常的句子 —— 而稿子里其实 +// 只有「说话人 0」和「说话人 1」，那些身份是模型猜的。用户不会在一份通顺的纪要里 +// 发现自己被安了个假名字，这正是它比缺一个名字有害得多的地方。 + +// setupSpeakerGateDB 起一个进程内的临时库给本文件用。 +// +// 只换 store.DB：这几个函数读的产物全部经 latestArtifact 走 store.DB， +// 不碰 dal 的零值仓库（与 internal/api 那套 fixture 需要的 dal.SetDB 不是一回事）。 +func setupSpeakerGateDB(t *testing.T) { + t.Helper() + prev := store.DB + db, err := store.Init(filepath.Join(t.TempDir(), "speaker_gate.db")) + if err != nil { + t.Fatalf("初始化测试库失败：%v", err) + } + store.DB = db + t.Cleanup(func() { store.DB = prev }) +} + +// newSpeakerGateTask 建一个任务并返回它。 +func newSpeakerGateTask(t *testing.T) model.TaskRecord { + t.Helper() + task := model.TaskRecord{ + SpecialistKey: "general-assistant", + Title: "说话人闸门用例", + Status: specialistruntime.TaskStatusDraft, + } + if err := store.DB.Create(&task).Error; err != nil { + t.Fatalf("创建任务失败：%v", err) + } + return task +} + +// writeSpeakerArtifact 往库里塞一条「说话人名单」产物，状态由调用方指定。 +func writeSpeakerArtifact(t *testing.T, taskID uint, status, contentJSON string) model.TaskArtifact { + t.Helper() + artifact := model.TaskArtifact{ + TaskID: taskID, + SpecialistKey: "general-assistant", + Title: "说话人名单", + ArtifactType: audioSpeakerArtifactType, + Status: status, + ContentText: "## 说话人名单\n", + ContentJSON: contentJSON, + } + if err := store.DB.Create(&artifact).Error; err != nil { + t.Fatalf("创建产物失败：%v", err) + } + return artifact +} + +// requireDiarizingAudioRoute 确认当前音频路由真的输出说话人标签。 +// +// 不 Skip 而 Fatal，是因为「路由不输出了」正是这个功能整体失效的方式： +// 换一条没有说话人分离的 ASR（比如 Qwen3-ASR），第 3 步会硬失败、闸门会直接放行， +// 于是这几个用例会全部变绿而什么都没测。那种绿比红危险得多。 +// 读**声明路由**（default_audio_route），与 audioRouteSupportsSpeakers 用同一个 +// 来源。不能读 GetAudioRoute("audio_transcribe")：那条现在指向 auto，会按本机 +// ASR 此刻起没起挑路由，于是这套用例的成败取决于跑测试的机器上 8090 有没有在监听 +// —— 那是一种「绿得毫无意义、红得莫名其妙」的测试。声明值才是与机器状态无关的事实。 +func requireDiarizingAudioRoute(t *testing.T) { + t.Helper() + route, err := config.GetDeclaredAudioRoute() + if err != nil { + t.Fatalf("音频路由不可用：%v", err) + } + if !route.SupportsSpeakers { + t.Fatalf("当前音频路由 %s 的 supports_speakers=false："+ + "「识别说话人身份」这一步跑不起来，本文件所有断言都会退化成空断言。"+ + "若确实要换掉带说话人分离的路由，请连同这套确认流程一起重新评估", route.RouteID) + } +} + +// rosterJSON 造一份「说话人名单」产物的 ContentJSON（形状与 runAudioSpeakersStep 写的一致）。 +func rosterJSON(roster ...audiotranscribe.SpeakerIdentity) string { + parts := make([]string, 0, len(roster)) + for _, item := range roster { + parts = append(parts, fmt.Sprintf( + `{"key":%q,"org":%q,"title":%q,"name":%q,"evidence":%q}`, + item.Key, item.Org, item.Title, item.Name, item.Evidence)) + } + return fmt.Sprintf(`{"source_type":"transcript","speakers":[%s]}`, strings.Join(parts, ",")) +} + +func TestAudioSpeakersGateBlocksWithoutConfirmation(t *testing.T) { + setupSpeakerGateDB(t) + requireDiarizingAudioRoute(t) + task := newSpeakerGateTask(t) + + // 1) 连名单都还没有 —— 这一步没跑过，下游不能跑。 + // （走不到这里的正常路径：人在第 3 步就停住了；但直接把请求打到第 5 步就能绕过前端。） + if err := ensureAudioSpeakersConfirmed(task.ID); err == nil { + t.Error("名单都还没生成，闸门却放行了 —— 直接把请求打到 /structure 就能绕过确认") + } else if !strings.Contains(err.Error(), "说话人名单") { + t.Errorf("报错没点明缺的是哪份产物：%v", err) + } + + // 2) 名单有了，但还是待确认 —— 这正是「AI 已经猜了、人还没看」的那一刻， + // 也是这道闸门存在的全部理由。 + writeSpeakerArtifact(t, task.ID, specialistruntime.ArtifactStatusReady, rosterJSON( + audiotranscribe.SpeakerIdentity{Key: "0", Org: "某某局", Title: "处长", Name: "张三"}, + )) + err := ensureAudioSpeakersConfirmed(task.ID) + if err == nil { + t.Fatal("名单还是「待确认」，闸门却放行了 —— 未确认的身份会直接写进正式纪要") + } + if !strings.Contains(err.Error(), "确认") { + t.Errorf("报错没有告诉用户该做什么：%v", err) + } + + // 3) 确认过 —— 放行。 + if err := store.DB.Model(&model.TaskArtifact{}). + Where("task_id = ? AND artifact_type = ?", task.ID, audioSpeakerArtifactType). + Update("status", specialistruntime.ArtifactStatusApproved).Error; err != nil { + t.Fatalf("更新产物状态失败：%v", err) + } + if err := ensureAudioSpeakersConfirmed(task.ID); err != nil { + t.Fatalf("已确认的名单仍被闸门拦住：%v", err) + } +} + +// TestAudioSpeakersGateReopensWhenReinferred 钉住「重新识别一次，旧的确认作废」。 +// +// 不钉的话会漏掉这条路径：用户确认了 → 觉得不对 → 重跑第 3 步（新产物落 ready） +// → 闸门如果只看「历史上有没有确认过」，就会拿**上一版**的身份去写新稿子。 +func TestAudioSpeakersGateReopensWhenReinferred(t *testing.T) { + setupSpeakerGateDB(t) + requireDiarizingAudioRoute(t) + task := newSpeakerGateTask(t) + + writeSpeakerArtifact(t, task.ID, specialistruntime.ArtifactStatusApproved, rosterJSON( + audiotranscribe.SpeakerIdentity{Key: "0", Name: "张三"}, + )) + if err := ensureAudioSpeakersConfirmed(task.ID); err != nil { + t.Fatalf("已确认时不该拦：%v", err) + } + + // 重跑一次第 3 步：新产物同样是「说话人名单」，落 ready。 + writeSpeakerArtifact(t, task.ID, specialistruntime.ArtifactStatusReady, rosterJSON( + audiotranscribe.SpeakerIdentity{Key: "0", Name: "李四"}, + )) + if err := ensureAudioSpeakersConfirmed(task.ID); err == nil { + t.Error("重新识别出的一版还没确认，闸门却拿上一版的确认放行了") + } +} + +// TestAudioSpeakersGatePassesThroughWhenRouteHasNoDiarization 钉住闸门的唯一放行口。 +// +// 换一条不输出说话人分离的 ASR（如 Qwen3-ASR）时，「识别说话人身份」这一步 +// 根本没有对象可做，闸门必须直接放行。这一支写反的后果不是少一道校验， +// 而是**所有这类任务永久卡死**：第 3 步跑不出名单 → 闸门说没有名单 → 不许跑第 5 步， +// 而用户无论如何也变不出那份名单。没有别的路可以绕过去。 +// +// 断言的是「一个名单都没有的情况下也放行」：若改成先查名单，这条会红。 +func TestAudioSpeakersGatePassesThroughWhenRouteHasNoDiarization(t *testing.T) { + setupSpeakerGateDB(t) + task := newSpeakerGateTask(t) + + // 换上「这条路由不输出说话人标签」。测试替身必须在断言之前换好， + // 换晚了等于没换（测的还是线上那条真路由）。 + original := audioRouteSupportsSpeakers + audioRouteSupportsSpeakers = func() (bool, error) { return false, nil } + t.Cleanup(func() { audioRouteSupportsSpeakers = original }) + + // 刻意不写任何产物：没有名单、没有确认，什么都不该拦。 + if err := ensureAudioSpeakersConfirmed(task.ID); err != nil { + t.Fatalf("音频路由不输出说话人分离时，闸门仍把后续步骤拦住了（这类任务将永远卡死）：%v", err) + } +} + +// TestAudioSpeakersGateFailsClosedWhenRouteUnavailable 钉住「路由读不出来时不放行」。 +// +// 与上一条相反的方向：读不到路由配置（ai_config.json 被改坏、audio_routes 缺项） +// 时**不能**当作「不支持说话人分离」而放行。放行等于跳过确认，正是这道闸门 +// 要防的事；而报错会让用户看见问题在哪。 +func TestAudioSpeakersGateFailsClosedWhenRouteUnavailable(t *testing.T) { + setupSpeakerGateDB(t) + task := newSpeakerGateTask(t) + + original := audioRouteSupportsSpeakers + audioRouteSupportsSpeakers = func() (bool, error) { + return false, fmt.Errorf("音频路由 %q 未在 ai_config.json 的 audio_routes 中定义", "x") + } + t.Cleanup(func() { audioRouteSupportsSpeakers = original }) + + err := ensureAudioSpeakersConfirmed(task.ID) + if err == nil { + t.Fatal("路由读不出来时闸门放行了 —— 配置坏掉会静默跳过说话人确认") + } + if !strings.Contains(err.Error(), "audio_routes") { + t.Errorf("报错没有把真实原因（路由配置）带出来：%v", err) + } +} + +// TestApplyAudioSpeakerNamesUsesConfirmedRoster 钉住「确认过的身份真的写进了正文」。 +// +// 闸门只解决「不许跑」，这个函数解决「跑起来之后用的是不是那份确认值」。 +// 少了它，闸门放行、模型照样只看见「说话人 0」——功能看着做完了，纪要里还是序号。 +func TestApplyAudioSpeakerNamesUsesConfirmedRoster(t *testing.T) { + setupSpeakerGateDB(t) + task := newSpeakerGateTask(t) + + source := "说话人 1：这个方案我同意。\n说话人 10：我也同意。\n说话人 2：那就这么定。" + + // 没确认过：一个字都不许动。 + if got := applyAudioSpeakerNames(task.ID, source); got != source { + t.Errorf("名单还没确认，正文却被改了：\n%s", got) + } + + writeSpeakerArtifact(t, task.ID, specialistruntime.ArtifactStatusApproved, rosterJSON( + audiotranscribe.SpeakerIdentity{Key: "1", Org: "某某局", Title: "处长", Name: "张三"}, + audiotranscribe.SpeakerIdentity{Key: "10", Name: "李四"}, + // 三个字段全空：稿里没有依据。该保持原样，不许塞占位符假装认出来了。 + audiotranscribe.SpeakerIdentity{Key: "2"}, + )) + + got := applyAudioSpeakerNames(task.ID, source) + if !strings.Contains(got, "张三：这个方案我同意。") { + t.Errorf("确认过的姓名没有写进正文：\n%s", got) + } + // 「说话人 1」是「说话人 10」的前缀。按名单原顺序替换会把这一行改成「李四0」， + // 所以这里同时钉住替换顺序。 + if !strings.Contains(got, "李四：我也同意。") { + t.Errorf("「说话人 10」被「说话人 1」的替换破坏了：\n%s", got) + } + if strings.Contains(got, "李四0") { + t.Errorf("出现「李四0」：替换没有按标签长度从长到短做：\n%s", got) + } + // 没有依据的那位保持原样，而不是变成空或占位符。 + if !strings.Contains(got, "说话人 2：那就这么定。") { + t.Errorf("没有依据的说话人被动过了（应保持原样）：\n%s", got) + } +} + +// TestApplyAudioSpeakerNamesFallsBackToOrgTitle 钉住「没有姓名时用机构·头衔」。 +// +// 这不是锦上添花：一次会议里真正有用的是「谁在说话」，而「某某局·处长」在纪要里 +// 已经比「说话人 0」有用得多。而三者全空时必须**跳过**，不许硬塞占位符 —— +// 那会让一份没认出来的稿子看起来像认出来了。 +func TestApplyAudioSpeakerNamesFallsBackToOrgTitle(t *testing.T) { + setupSpeakerGateDB(t) + task := newSpeakerGateTask(t) + + writeSpeakerArtifact(t, task.ID, specialistruntime.ArtifactStatusApproved, rosterJSON( + audiotranscribe.SpeakerIdentity{Key: "0", Org: "某某局", Title: "处长"}, + audiotranscribe.SpeakerIdentity{Key: "1", Title: "记录员"}, + audiotranscribe.SpeakerIdentity{Key: "2"}, + )) + + got := applyAudioSpeakerNames(task.ID, "说话人 0：开场。\n说话人 1：在。\n说话人 2：嗯。") + if !strings.Contains(got, "某某局·处长：开场。") { + t.Errorf("只有机构与头衔时没有拼成「机构·头衔」：\n%s", got) + } + if !strings.Contains(got, "记录员：在。") { + t.Errorf("只有头衔时没有用它：\n%s", got) + } + if !strings.Contains(got, "说话人 2：嗯。") { + t.Errorf("三者全空的那位被改动了（应跳过，保持原样）：\n%s", got) + } +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/fallback_test.go b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/fallback_test.go new file mode 100644 index 0000000..a47eb5f --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/fallback_test.go @@ -0,0 +1,283 @@ +package audiotranscribe + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "strings" + "sync/atomic" + "testing" + "time" + + "eai_agentplatform/backend/internal/config" +) + +// 这一组用例钉的是「主路由不行时换一条，但不是什么情况都换」。 +// +// 为什么值得单独写：回退是这个功能里**唯一会把音频多送一次出门**的地方。 +// 判定写宽了，一个格式不对的文件会被白送一次到公网 ASR（隐私代价换不到成功率）； +// 写窄了，本地 ASR 一挂用户就拿到硬失败，而「本地不可用时自动回退云端」 +// 正是当初选这个方案的全部理由。 +// +// 全程留在本机：链是注入的（transcribeChainFn），两个终点都是 httptest。 +// 真实配置里的回退目标是公网 ASR，拿它来测等于把用户的录音当测试数据发出去。 + +// audioOKBody 是后端认得的 ASR 响应形状（transcribe.go 顶部注释里那份）。 +const audioOKBody = `{"duration":12.5,"text":"说话人0：测试转写内容", + "segments":[{"speaker":"0","start":0,"end":12.5,"text":"测试转写内容"}], + "usage":{"type":"duration","seconds":12.5}}` + +// stubRoute 造一条指向本机 httptest 的路由。 +// BaseURL 取服务地址（127.0.0.1:port），于是 IsLocalRoute 判为本地 —— +// 这既省掉密钥要求，也让「音频没出本机」这条断言同时也是对 IsLocalRoute 的检验。 +func stubRoute(id string, srv *httptest.Server) *config.RouteConfig { + return &config.RouteConfig{ + RouteID: id, + Provider: "local_asr", + Model: "large-v3", + BaseURL: srv.URL, + Endpoint: "/audio/transcriptions", + FullURL: srv.URL + "/audio/transcriptions", + Category: "audio", + TimeoutSeconds: 10, + } +} + +// withChain 把 TranscribeBytes 用的链路换成给定的几条，并在用例结束后还原。 +func withChain(t *testing.T, routes ...*config.RouteConfig) { + t.Helper() + prev := transcribeChainFn + transcribeChainFn = func(string) ([]*config.RouteConfig, error) { return routes, nil } + t.Cleanup(func() { transcribeChainFn = prev }) +} + +// newStub 起一个桩：按 status 作答，200 时回 audioOKBody；delay > 0 则先睡一下 +// （用来造超时）。hits 非 nil 时累计被打次数。 +func newStub(t *testing.T, status int, hits *int32, delay time.Duration) *httptest.Server { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if hits != nil { + atomic.AddInt32(hits, 1) + } + if delay > 0 { + time.Sleep(delay) + } + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) + if status == http.StatusOK { + _, _ = w.Write([]byte(audioOKBody)) + return + } + _, _ = w.Write([]byte(`{"error":"stub"}`)) + })) + t.Cleanup(srv.Close) + return srv +} + +// deadRoute 造一条「连不上」的路由：起一个 httptest 再立刻关掉，端口就没人听了。 +// 这比随便挑一个端口可靠 —— 那个端口可能真的被别的东西占着。 +func deadRoute(t *testing.T, id string) *config.RouteConfig { + t.Helper() + srv := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) + url := srv.URL + srv.Close() + return &config.RouteConfig{ + RouteID: id, Provider: "local_asr", Model: "large-v3", + BaseURL: url, Endpoint: "/audio/transcriptions", + FullURL: url + "/audio/transcriptions", Category: "audio", + TimeoutSeconds: 5, + } +} + +func TestTranscribeFallsBackWhenPrimaryIsUnreachable(t *testing.T) { + var secondaryHits int32 + secondary := newStub(t, http.StatusOK, &secondaryHits, 0) + primary := deadRoute(t, "audio_route_dead_local") + + withChain(t, primary, stubRoute("audio_route_backup", secondary)) + + res, err := TranscribeBytes(0, []byte("fake-audio"), "a.mp3", "mp3", "zh", "") + if err != nil { + t.Fatalf("主路由连不上时应该回退并成功，却报错：%v", err) + } + if res.RouteID != "audio_route_backup" { + t.Errorf("RouteID = %q，期望回退到 audio_route_backup", res.RouteID) + } + if !res.FellBack { + t.Error("FellBack = false，但这次确实换了路由 —— 界面据它提示用户，不能漏") + } + if res.PrimaryRouteID != "audio_route_dead_local" { + t.Errorf("PrimaryRouteID = %q，期望 audio_route_dead_local", res.PrimaryRouteID) + } + if res.FallbackReason == "" { + t.Error("FallbackReason 为空 —— 主路由为什么不行必须留痕，否则没法排障") + } + if !res.IsLocal { + t.Error("IsLocal = false，但回退到的那条是回环地址 —— 判据应取实际服务的那条路由") + } + if atomic.LoadInt32(&secondaryHits) != 1 { + t.Errorf("回退路由被打了 %d 次，期望 1 次", secondaryHits) + } +} + +func TestTranscribeFallsBackOnServerError(t *testing.T) { + var secondaryHits int32 + secondary := newStub(t, http.StatusOK, &secondaryHits, 0) + primary := newStub(t, http.StatusServiceUnavailable, nil, 0) + + withChain(t, stubRoute("audio_route_503", primary), stubRoute("audio_route_backup", secondary)) + + res, err := TranscribeBytes(0, []byte("fake-audio"), "a.mp3", "mp3", "zh", "") + if err != nil { + t.Fatalf("主路由 503 时应回退，却报错：%v", err) + } + if !res.FellBack || res.RouteID != "audio_route_backup" { + t.Errorf("期望回退到 backup，实际 route=%s fell_back=%v", res.RouteID, res.FellBack) + } +} + +// TestTranscribeDoesNotFallBackOnBadRequest 是这一组里最重要的一条。 +// +// 400 意味着「这份文件本身不行」。换一条路由重发同一个文件不会变好， +// 唯一确定的后果是这份录音又出本机一次 —— 拿隐私换不到任何成功率。 +func TestTranscribeDoesNotFallBackOnBadRequest(t *testing.T) { + var secondaryHits int32 + secondary := newStub(t, http.StatusOK, &secondaryHits, 0) + primary := newStub(t, http.StatusBadRequest, nil, 0) + + withChain(t, stubRoute("audio_route_400", primary), stubRoute("audio_route_backup", secondary)) + + _, err := TranscribeBytes(0, []byte("fake-audio"), "a.mp3", "mp3", "zh", "") + if err == nil { + t.Fatal("400 应当直接报错，不该回退") + } + if !strings.Contains(err.Error(), "400") { + t.Errorf("错误里应带上原始状态码，实际：%v", err) + } + if n := atomic.LoadInt32(&secondaryHits); n != 0 { + t.Errorf("回退路由被打了 %d 次 —— 400 时音频不该再出一次本机", n) + } +} + +// TestTranscribeDoesNotFallBackOnEmptyText 空白音频由主路由判定即可。 +// 换一条大概率还是同一句话，而代价是把音频再送一次出去。 +func TestTranscribeDoesNotFallBackOnEmptyText(t *testing.T) { + var secondaryHits int32 + secondary := newStub(t, http.StatusOK, &secondaryHits, 0) + empty := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"duration":0,"text":"","segments":[]}`)) + })) + t.Cleanup(empty.Close) + + withChain(t, stubRoute("audio_route_empty", empty), stubRoute("audio_route_backup", secondary)) + + if _, err := TranscribeBytes(0, []byte("fake-audio"), "a.mp3", "mp3", "zh", ""); err == nil { + t.Fatal("空文本应当报错") + } + if n := atomic.LoadInt32(&secondaryHits); n != 0 { + t.Errorf("回退路由被打了 %d 次 —— 空文本不该触发回退", n) + } +} + +// TestTranscribeDoesNotFallBackOnTimeout 超时不吃回退。 +// +// 一次超时意味着主路由的预算是整段耗尽的；接着把同一份长音频发给下一条， +// 结果多半是用户那边先超时（前端 axios 15 分钟），而音频已经出门了。 +func TestTranscribeDoesNotFallBackOnTimeout(t *testing.T) { + var secondaryHits int32 + secondary := newStub(t, http.StatusOK, &secondaryHits, 0) + slow := newStub(t, http.StatusOK, nil, 1500*time.Millisecond) + primary := stubRoute("audio_route_slow", slow) + primary.TimeoutSeconds = 1 + + withChain(t, primary, stubRoute("audio_route_backup", secondary)) + + start := time.Now() + if _, err := TranscribeBytes(0, []byte("fake-audio"), "a.mp3", "mp3", "zh", ""); err == nil { + t.Fatal("超时应当报错") + } + if n := atomic.LoadInt32(&secondaryHits); n != 0 { + t.Errorf("回退路由被打了 %d 次 —— 超时不该触发回退", n) + } + if elapsed := time.Since(start); elapsed > 1400*time.Millisecond { + t.Errorf("耗时 %v：超时后还在等别的路由", elapsed) + } +} + +// TestTranscribeReportsEveryRouteTriedWhenAllFail 全部失败时，错误要列出试过哪些。 +// 只说「服务不可达」而不说试过哪几条，排障时看不出回退链有没有真的跑起来。 +func TestTranscribeReportsEveryRouteTriedWhenAllFail(t *testing.T) { + withChain(t, + deadRoute(t, "audio_route_dead_a"), + deadRoute(t, "audio_route_dead_b"), + ) + _, err := TranscribeBytes(0, []byte("fake-audio"), "a.mp3", "mp3", "zh", "") + if err == nil { + t.Fatal("两条都连不上时应当报错") + } + for _, want := range []string{"audio_route_dead_a", "audio_route_dead_b"} { + if !strings.Contains(err.Error(), want) { + t.Errorf("错误里没提到试过的路由 %s：%v", want, err) + } + } +} + +// TestTranscribeLocalRouteNeedsNoAPIKey 本地回环路由不该因为「没有密钥」被拦下。 +// 这是接入本地 ASR 时必须松掉的那一处硬检查（原实现是 route.APIKey == "" 直接报错）。 +func TestTranscribeLocalRouteNeedsNoAPIKey(t *testing.T) { + srv := newStub(t, http.StatusOK, nil, 0) + r := stubRoute("audio_route_local_nokey", srv) + if r.APIKey != "" { + t.Fatal("用例前提：这条路由不该有密钥") + } + withChain(t, r) + + res, err := TranscribeBytes(0, []byte("fake-audio"), "a.mp3", "mp3", "zh", "") + if err != nil { + t.Fatalf("本地回环路由无密钥应当放行，却报错：%v", err) + } + if !res.IsLocal { + t.Error("IsLocal = false，但这条路由的 base_url 是回环地址") + } + // 顺带确认响应被真的解析了，而不是「没报错所以算过」。 + if res.Text == "" || len(res.Segments) == 0 { + t.Errorf("转写结果没解析出来：text=%q segments=%d", res.Text, len(res.Segments)) + } +} + +// TestTranscribeRemoteRouteStillNeedsAPIKey 非本地路由缺密钥仍要提前报错： +// 打过去只会拿到 401，提前报错比让用户等一轮网络往返好。 +func TestTranscribeRemoteRouteStillNeedsAPIKey(t *testing.T) { + r := &config.RouteConfig{ + RouteID: "audio_route_remote_nokey", Provider: "siliconflow", Model: "x", + BaseURL: "https://api.example.com/v1", Endpoint: "/audio/transcriptions", + FullURL: "https://api.example.com/v1/audio/transcriptions", + Category: "audio", TimeoutSeconds: 10, + } + withChain(t, r) + _, err := TranscribeBytes(0, []byte("fake-audio"), "a.mp3", "mp3", "zh", "") + if err == nil { + t.Fatal("非本地路由缺密钥应当报错") + } + if !strings.Contains(err.Error(), "API Key") { + t.Errorf("错误应说明缺密钥，实际：%v", err) + } +} + +// 保证 audioOKBody 与解析结构一致：改了响应形状而没改这里，上面那些用例 +// 会以「解析失败」的形式红，而不是悄悄变绿。 +func TestAudioOKBodyParses(t *testing.T) { + var out struct { + Text string `json:"text"` + Segments []struct { + Speaker string `json:"speaker"` + } `json:"segments"` + } + if err := json.Unmarshal([]byte(audioOKBody), &out); err != nil { + t.Fatalf("桩响应不是合法 JSON：%v", err) + } + if out.Text == "" || len(out.Segments) == 0 || out.Segments[0].Speaker == "" { + t.Fatalf("桩响应缺少 text/segments/speaker：%+v", out) + } +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/media.go b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/media.go new file mode 100644 index 0000000..bbafd48 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/media.go @@ -0,0 +1,40 @@ +package audiotranscribe + +import ( + "fmt" + "path/filepath" + "strings" + + "eai_agentplatform/backend/internal/config" + "eai_agentplatform/backend/internal/model" +) + +// MediaFilePath 按素材审批状态返回磁盘物理路径。 +// +// 与 internal/api/media.go 的 mediaPathFor 同口径（approved / pending / rejected +// 三个子目录）。没有直接复用是因为那边不导出、且属于 HTTP 层； +// 两处若将来分叉，读到的就是「审批后消失」的素材，这里刻意保持同构。 +func MediaFilePath(m model.MediaFile) (string, error) { + name := strings.TrimSpace(m.StoredName) + if name == "" { + // 老记录可能只写了 StoredPath；上传时两者写的是同一个值（media.go 的上传分支）。 + name = strings.TrimSpace(m.StoredPath) + } + if name == "" { + return "", fmt.Errorf("素材 %d 没有记录存储文件名", m.ID) + } + // 只接受纯基名：StoredName 来自数据库，正常不含分隔符，但拼路径前必须挡一道， + // 否则一条脏记录就能让接口读到 KBDataDir 之外的文件。 + if filepath.Base(name) != name || name == "." || name == ".." { + return "", fmt.Errorf("素材 %d 的存储文件名非法：%q", m.ID, name) + } + + sub := "pending" + switch strings.TrimSpace(m.Status) { + case "approved": + sub = "approved" + case "rejected": + sub = "rejected" + } + return filepath.Join(config.Load().KBDataDir, sub, name), nil +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/prompts.go b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/prompts.go new file mode 100644 index 0000000..f5fe810 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/prompts.go @@ -0,0 +1,367 @@ +package audiotranscribe + +import ( + "context" + "errors" + "fmt" + "strings" + "time" + + "eai_agentplatform/backend/internal/ai" + "eai_agentplatform/backend/internal/config" +) + +// Kind 逐字稿之后的两个 LLM 加工步骤。 +type Kind string + +const ( + // KindStructure 第 3 步：整理段落与重点 → 结构化纪要 + KindStructure Kind = "structure" + // KindMinutes 第 4 步：提炼可交付纪要 → 纪要 + 行动项 + KindMinutes Kind = "minutes" +) + +// llmChunkChars 单次喂给模型的逐字稿字数上限。 +// +// 一小时中文会议逐字稿约两万字，整段塞进去既慢又容易撞上游上下文上限； +// 按段落切块逐块加工，多块时再做一次归并。 +// +// 这个数字由**实测的完成预算**倒推，不是拍脑袋定的。测量对象是当前的默认对话路由 +// （LMUAI / deepseek-v4-flash）—— 它是个推理模型，思考与正文共用 max_tokens， +// 而**思考的长度跟输入几乎不成比例**，这是整件事最反直觉的地方： +// +// 输入 max_tokens 思考 正文 finish_reason +// 2500 字 4096 7187 字 0 字 length +// 2500 字 4096 7332 字 0 字 length +// 1200 字 4096 7169 字 56 字 length +// 1200 字 4096 4509 字 1161 字 stop +// 600 字 4096 3972 字 612 字 stop +// 600 字 4096 5667 字 583 字 stop +// 1200 字 8192 6030 字 1209 字 stop +// 2500 字 8192 11286 字 2528 字 stop +// +// 三条结论，都反直觉，写在这里免得后人重走一遍： +// +// 1. **把块切小救不了预算**。输入从 2500 字砍到 1200 字，思考仍是 7169 字 —— +// 思考有个约 4000 字的地板，而且会随预算水涨船高（给到 8192 就涨到 11286 字）。 +// 所以「失败就把这一块对半切了重试」在这种模型上是白费调用，不要加。 +// 2. **4096 的预算根本不够**：六次里只有一次写出正文，其余全被思考吃光， +// 响应里连 content 字段都没有。这类步骤要产出一整篇文档，必须给到 8192 以上。 +// 3. **1200 是按当时 8192 的天花板定的，不是这个模型的性质**：1200 字连打 11 段， +// 完成 token 落在 3699–6861（均值 4928），最坏一次吃掉 8192 的 84%，只剩 16% 余量； +// 而思考的实测跨度有近两倍（4942–10913 字），16% 的余量挡不住下一次波动。 +// 2500 字在 8192 下曾用掉 7722（94%），离截断只差一次思考波动。 +// —— 后来归并那一步逼着把天花板抬到了 32768（见 kindSpec.joinOnly）， +// 同一批 11 段在 32768 下重测：用时 19.2s、completion 均 5094，与 8192 档 +// （18.6s / 4928）基本一致 —— **上限是天花板不是配额**，抬高它不会让每次调用变贵。 +// 也就是说现在余量足了，llmChunkChars 若要调大是可以的；本轮没动它， +// 是为了让「抬高上限」这一个改动单独可验。真要调，请连 32768 一起复测。 +// +// 所以：**调小这个数之前，先确认路由的 max_tokens 够**（要 16384 以上：归并那一步 +// 比逐块加工更吃预算），否则拿到的是断稿，或者干脆什么都没有。 +// +// 还有一条与预算无关的耦合：**这个数直接决定前端要等多久** —— 块数 = 逐字稿字数 / +// llmChunkChars，而第 3、4 步是同步 HTTP，前端只能干等。一次真实的 26:41 录音 +// （11936 字 → 10 块）跑完四步共 589.54s，其中第 3、4 步合计 532s；前端的超时上限 +// 因此从 5 分钟放宽到了 10 分钟（见 frontend/src/api/audioSkill.js）。 +// 把这个数改小会让块数变多、总时长变长，改大则相反 —— 两头都会动到那条上限。 +const llmChunkChars = 1200 + +// kindSpec 一个加工步骤的文案（分块提示词 + 归并提示词）。 +// +// joinOnly 决定多块时怎么收口，这是**按步骤性质**分的，不是省一次调用： +// - 结构化稿：输出与输入等长。让模型归并 N 段的结果，等于要它一次吐出整篇 +// 逐字稿那么长的正文 —— 26 分钟的会议稿约 9500 字，光正文就要约 5700 token， +// 再叠加思考，8192 的预算根本不够。而这些分段结果**本身已经是结构化的**， +// 直接按序拼起来就是一份完整稿，信息一点不少 —— 代价只是跨块的同一个议题 +// 可能各起了一个小标题，属于观感问题，远好过截断。 +// - 纪要：输出远短于输入，归并正是它的价值（跨段去重、按时序排序）， +// 所以照旧让模型归并。 +// +// 但「纪要输出短」推不出「归并这一步不费预算」—— 费的是**输入**：归并的输入是 +// N 段结果全文拼接，是全流程最长的一次。实测 14 段（8628 字输入）： +// +// 归并一次（14 段拼接，8628 字输入） +// max_tokens=8192 finish=length 思考 14678 字 正文 0 字 ← 整步就此失败 +// max_tokens=16384 finish=stop 思考 12576 字 正文 5294 字 +// max_tokens=32768 finish=stop 思考 3139 字 正文 6927 字 ← 更快、更省 +// +// 这就是「第 3 步能过、第 4 步必挂」的原因：第 3 步是 joinOnly 不收口， +// 第 4 步要收口，而收口那一次撞在旧天花板上。天花板已按这张表抬到 32768。 +type kindSpec struct { + system string + instruction string + joinOnly bool + mergeSystem string + mergeRequest string +} + +func specFor(kind Kind) (kindSpec, error) { + switch kind { + case KindStructure: + return kindSpec{ + system: "你是会议音频整理助手。你会收到一段语音转写的逐字稿，它的断句和标点可能有误。", + instruction: `请把这段逐字稿整理成可阅读的结构化稿。要求： +1. 按议题或话题重新分段，每段起一个简短小标题； +2. 保留结论、数字、人名、产品名、时间等关键信息，不要概括掉； +3. 可以修正明显的同音错别字（人名、术语），但不得添加原文没有的内容； +4. 直接输出整理后的 Markdown 正文，不要写「以下是整理结果」这类开场说明。`, + joinOnly: true, + }, nil + case KindMinutes: + return kindSpec{ + system: "你是会议纪要助手。你会收到一份会议/访谈的整理稿。", + instruction: `请把它提炼成可以直接分发的会议纪要。要求： +1. 开头用「## 核心结论」列出 3-5 条最重要的结论； +2. 用「## 决议事项」逐条列出已达成的决定； +3. 用「## 行动项」输出 Markdown 复选列表，格式为「- [ ] 事项 —— 负责人 —— 截止时间」； + 原文没有提到负责人或时间时写「待定」，**不要编造**； +4. 只输出 Markdown 正文，不要写开场说明。`, + mergeSystem: "你是会议纪要助手。你会收到同一场会议分段提炼出的多份纪要草稿。", + mergeRequest: "请把它们合并成一份最终纪要：核心结论去重后按重要性排序，决议事项与行动项合并去重。「行动项」保持 Markdown 复选列表格式。只输出 Markdown 正文。", + }, nil + default: + return kindSpec{}, fmt.Errorf("未知的加工步骤：%q", kind) + } +} + +// ChunkTranscript 按行把逐字稿切成不超过 maxChars 的块。 +// +// 优先在行边界切（逐字稿每段一行），保证不会把一个说话人的半句话劈开； +// 单行本身超长（没有分段信息的纯文本）时才硬切。 +func ChunkTranscript(transcript string, maxChars int) []string { + text := strings.TrimSpace(transcript) + if text == "" { + return nil + } + if maxChars <= 0 { + maxChars = llmChunkChars + } + if len([]rune(text)) <= maxChars { + return []string{text} + } + + chunks := make([]string, 0, 4) + var current strings.Builder + currentLen := 0 + + flush := func() { + if currentLen > 0 { + chunks = append(chunks, strings.TrimSpace(current.String())) + current.Reset() + currentLen = 0 + } + } + + for _, line := range strings.Split(text, "\n") { + line = strings.TrimRight(line, "\r") + lineLen := len([]rune(line)) + if lineLen == 0 { + continue + } + if lineLen > maxChars { + // 单行就超限：先结算已攒的内容，再把这一行硬切成若干块。 + flush() + runes := []rune(line) + for start := 0; start < len(runes); start += maxChars { + end := start + maxChars + if end > len(runes) { + end = len(runes) + } + chunks = append(chunks, string(runes[start:end])) + } + continue + } + if currentLen+lineLen+1 > maxChars { + flush() + } + if currentLen > 0 { + current.WriteString("\n") + currentLen++ + } + current.WriteString(line) + currentLen += lineLen + } + flush() + + // 归并过程会把内容重新组织，空块没有意义。 + out := chunks[:0] + for _, chunk := range chunks { + if strings.TrimSpace(chunk) != "" { + out = append(out, chunk) + } + } + return out +} + +// RunLLMStep 对逐字稿做一次 LLM 加工（整理 / 纪要）。 +// +// 短稿一次调用；长稿按块加工后再归并一次，避免把两万字的稿子整段塞进单次请求。 +// kind 只影响提示词，路由与回退由调用方通过 route 决定。 +func RunLLMStep(ctx context.Context, kind Kind, transcript string, route *config.RouteConfig) (string, error) { + spec, err := specFor(kind) + if err != nil { + return "", err + } + if route == nil { + return "", fmt.Errorf("没有可用的对话路由，无法执行 %s 步骤", kind) + } + + chunks := ChunkTranscript(transcript, llmChunkChars) + if len(chunks) == 0 { + return "", fmt.Errorf("逐字稿为空，无法执行 %s 步骤", kind) + } + + if len(chunks) == 1 { + text, err := callModel(ctx, route, spec.system, spec.instruction+"\n\n逐字稿：\n"+chunks[0]) + if err != nil { + return "", fmt.Errorf("%s 步骤调用模型失败：%w", kind, err) + } + return text, nil + } + + partials := make([]string, 0, len(chunks)) + for index, chunk := range chunks { + header := fmt.Sprintf("这是逐字稿的第 %d/%d 段。\n\n", index+1, len(chunks)) + text, err := callModel(ctx, route, spec.system, header+spec.instruction+"\n\n逐字稿：\n"+chunk) + if err != nil { + return "", fmt.Errorf("%s 步骤第 %d/%d 段调用模型失败：%w", kind, index+1, len(chunks), err) + } + partials = append(partials, text) + } + + if spec.joinOnly { + // 按序拼起来就算完成，不再让模型过一遍（理由见 kindSpec.joinOnly）。 + // 各段自带小标题，所以只留空行分隔，不加「【第 N 段】」这类是给人添乱、 + // 又会被后续加工当成正文的标签。 + return strings.Join(partials, "\n\n"), nil + } + + var merged strings.Builder + merged.WriteString(spec.mergeRequest) + merged.WriteString("\n\n") + for index, partial := range partials { + fmt.Fprintf(&merged, "【第 %d 段】\n%s\n\n", index+1, partial) + } + + // 归并的输入是各段全文拼接，比单段更长，最容易撞预算；这里同样只收完整输出。 + text, err := callModel(ctx, route, spec.mergeSystem, merged.String()) + if err != nil { + return "", fmt.Errorf("%s 步骤归并失败：%w", kind, err) + } + return text, nil +} + +// maxModelAttempts 单次调用在**可重试**失败下的最大尝试次数。 +// +// 为什么非要有重试：第 3、4 步各自要连打 8–11 次模型（逐字稿按 llmChunkChars 分块）， +// **其中任何一次抖动都会让整步前功尽弃** —— 就算每次只有 5% 的抖动量，11 次下来 +// 整步失败率也有 43%。这不是假设：实测第 3 步就在第 4/11 段挂过一次，网关回了 +// HTTP 200、报文里却没有 choices，前三段的成果一起作废。 +// +// **只重试 ai.TransientUpstreamError**，见 ai.IsTransient。预算不够 +// （finish_reason=length）是确定性的，重发只是再花一次钱拿同一个结果 —— +// 那种要把「预算不够」讲给用户听，不是重试。 +const maxModelAttempts = 3 + +// modelRetryBackoff 重试间隔的基数，第 n 次重试等 n 倍。 +// 抖动多半是上游的瞬时状态，隔几秒再打比立刻重打有用。 +const modelRetryBackoff = 3 * time.Second + +// callModel 调一次模型，对**瞬时抖动**做有限重试。 +// +// 重试与「把这一块对半切了重试」是两回事：后者已被实测否定 +// （思考的长度不随输入变小，见 llmChunkChars 结论 1）。这里重发的是**同一个**请求。 +func callModel(ctx context.Context, route *config.RouteConfig, system, user string) (string, error) { + return withTransientRetry(ctx, modelRetryBackoff, func(ctx context.Context) (string, error) { + return callModelOnce(ctx, route, system, user) + }) +} + +// withTransientRetry 是上面那条重试策略本身，不掺网络调用。 +// +// 单独拎出来是为了能直接测：这条策略两种错法代价都很实在 —— 该重试的没重试， +// 整步白跑（11 段里挂 1 段就全废）；不该重试的反复重发，每次都在花钱， +// 而预算类失败重发一百次也是同一个结果。没有理由只靠线上观察来验它。 +func withTransientRetry(ctx context.Context, backoff time.Duration, once func(context.Context) (string, error)) (string, error) { + var lastErr error + for attempt := 1; attempt <= maxModelAttempts; attempt++ { + if attempt > 1 { + select { + case <-ctx.Done(): + // 上层已经取消了就别再等：重试不是无视上层超时的理由。 + return "", fmt.Errorf("重试等待时被取消：%w", ctx.Err()) + case <-time.After(backoff * time.Duration(attempt-1)): + } + } + text, err := once(ctx) + if err == nil { + return text, nil + } + lastErr = err + if !ai.IsTransient(err) { + // 确定性失败：再试也是同一个结果，立刻把原因交出去。 + return "", err + } + } + return "", fmt.Errorf("同一段重试 %d 次仍是瞬时失败：%w", maxModelAttempts, lastErr) +} + +// callModelOnce 调一次模型，并把「输出预算被用光」当成失败。 +// +// 为什么预算问题必须显式判：这些是推理模型，思考与正文共用 max_tokens +// （实测数据见 llmChunkChars）。预算不够时上游照样回 HTTP 200，只是： +// - 思考还没写完 → 响应里**连 content 字段都没有**，finish_reason=length； +// - 正文写了一半 → 正文被拦腰截断，finish_reason=length。 +// +// 两种都「看着像做完了」：前者落库成一个点开什么都没有的产物，后者落库成一份 +// 断在半句话上的纪要。这比报错更糟 —— 报错至少知道没成。 +// +// GenerateFullWithFallback 而不是 GenerateWithFallback：只有前者把 finish_reason +// 带出来。两者都走同一条回退链，行为一致。 +func callModelOnce(ctx context.Context, route *config.RouteConfig, system, user string) (string, error) { + res, hit, err := ai.GenerateFullWithFallback(ctx, route, []ai.Message{ + {Role: "system", Content: system}, + {Role: "user", Content: user}, + }) + routeID, maxTokens := route.RouteID, route.MaxTokens + if hit != nil { + routeID, maxTokens = hit.RouteID, hit.MaxTokens + } + if err != nil { + // 上游把「思考吃光预算、正文一个字没写」也归进「空正文」，而那句 + // 文案会把人引去查模型名和密钥。这里换成讲得清病根的那一条 + // （原因见 ai.EmptyCompletionError），两条路径的说法也就此统一。 + var empty *ai.EmptyCompletionError + if errors.As(err, &empty) { + return checkCompletion(empty.FinishReason, "", routeID, maxTokens) + } + return "", err + } + return checkCompletion(res.FinishReason, res.Content, routeID, maxTokens) +} + +// checkCompletion 是上面那道判断的纯函数部分，单独拎出来是为了能直接测 —— +// 它只依赖几个字符串和一个整数，没有理由非要连一次网络才能验。 +// +// 预算优先于空正文：预算耗尽时正文可能是空的、也可能是半截的，报「预算不够」 +// 比报「空正文」更接近真实原因（后者会让人去查模型和密钥）。 +func checkCompletion(finishReason, content, routeID string, maxTokens int) (string, error) { + text := strings.TrimSpace(content) + if strings.EqualFold(strings.TrimSpace(finishReason), "length") { + // 「只写出 N 字」比「被截断」更有说服力：0 字和 1161 字是同一个病根 + // （思考吃光了预算），只是严重程度不同，报出字数一眼就能看出这一次是哪种。 + return "", fmt.Errorf( + "模型输出预算不够（路由 %s，max_tokens=%d，finish_reason=length）："+ + "这是推理模型，思考与正文共用这份预算，而思考的长度跟输入几乎不成比例"+ + "（实测 1200 字的输入，思考照样能写到 7169 字）。本次正文只写出 %d 字。"+ + "把该路由的 max_tokens 提到 16384 以上（不是 8192：纪要那一步最后要把各段结果"+ + "归并成一份，那是全流程最长的一次输入，实测 8192 下正文 0 字），或者换一条预算够大的路由", + routeID, maxTokens, len([]rune(text))) + } + if text == "" { + // 空内容落库会变成一个点开什么都没有的产物，比报错更难排查。 + return "", fmt.Errorf("模型返回空正文（路由 %s，finish_reason=%q）", routeID, finishReason) + } + return text, nil +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/retry_test.go b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/retry_test.go new file mode 100644 index 0000000..62a4ba5 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/retry_test.go @@ -0,0 +1,165 @@ +package audiotranscribe + +import ( + "context" + "errors" + "strings" + "testing" + "time" + + "eai_agentplatform/backend/internal/ai" +) + +// transientErr 造一个「这一次没成、但重发有机会成」的失败。 +func transientErr() error { + return &ai.TransientUpstreamError{ + StatusCode: 200, + Message: "LLM 返回空正文（响应里没有 choices）：{\"error\":\"upstream timeout\"}", + } +} + +// budgetErr 造一个确定性的失败：预算被思考吃光，重发一百次也是同一个结果。 +func budgetErr() error { + return errors.New("模型输出预算不够（路由 chat_route_test，max_tokens=8192，finish_reason=length）：本次正文只写出 0 字") +} + +// TestWithTransientRetryRetriesOnlyTransientFailures 盯住重试策略的两半。 +// +// 两半都得验，因为两种错法的代价都很实在：漏重试 → 11 段里挂 1 段整步白跑； +// 多重重试 → 每次调用都在花钱，而预算类失败重发一百次也一样。 +func TestWithTransientRetryRetriesOnlyTransientFailures(t *testing.T) { + // 退避压到 1ms：这条测试验的是「打几次」，不是「等多久」。 + const backoff = time.Millisecond + + cases := []struct { + name string + // failTimes 前几次返回 failErr，之后返回成功。 + failTimes int + failErr error + wantCalls int + wantText string + wantErr bool + }{ + { + name: "一次就成，不多打", + failTimes: 0, + wantCalls: 1, + wantText: "正文", + }, + { + name: "瞬时失败一次后成功", + failTimes: 1, + failErr: transientErr(), + wantCalls: 2, + wantText: "正文", + }, + { + name: "瞬时失败两次后成功（用满重试额度）", + failTimes: 2, + failErr: transientErr(), + wantCalls: 3, + wantText: "正文", + }, + { + name: "瞬时失败一直不停，打满就收手", + failTimes: 99, + failErr: transientErr(), + wantCalls: maxModelAttempts, + wantErr: true, + }, + { + // 这条是重点：确定性失败**一次都不许多打**。 + name: "确定性失败立刻收手", + failTimes: 99, + failErr: budgetErr(), + wantCalls: 1, + wantErr: true, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + calls := 0 + text, err := withTransientRetry(context.Background(), backoff, + func(context.Context) (string, error) { + calls++ + if calls <= tc.failTimes { + return "", tc.failErr + } + return "正文", nil + }) + + if calls != tc.wantCalls { + t.Errorf("调用次数 = %d，期望 %d", calls, tc.wantCalls) + } + if tc.wantErr { + if err == nil { + t.Fatal("期望失败，实际成功") + } + return + } + if err != nil { + t.Fatalf("期望成功，实际：%v", err) + } + if text != tc.wantText { + t.Errorf("正文 = %q，期望 %q", text, tc.wantText) + } + }) + } +} + +// TestTransientRetryKeepsDeterministicCauseVerbatim 确定性失败必须**原样**抛出。 +// +// 它会被上层拼进「structure 步骤第 4/11 段调用模型失败：…」，用户看到的就是这句 +// 话；重试逻辑要是在外面又套一层「重试 3 次仍是瞬时失败」，等于把真正的病根 +// （预算不够）埋进一句不相干的文案里 —— 而确定性失败压根没重试过。 +func TestTransientRetryKeepsDeterministicCauseVerbatim(t *testing.T) { + cause := budgetErr() + _, err := withTransientRetry(context.Background(), time.Millisecond, + func(context.Context) (string, error) { return "", cause }) + + if err == nil { + t.Fatal("期望失败，实际成功") + } + if !errors.Is(err, cause) { + t.Errorf("应原样抛出同一个错误，实际：%v", err) + } + if strings.Contains(err.Error(), "重试") { + t.Errorf("没有重试过的失败不该出现「重试」字样，实际：%v", err) + } +} + +// TestTransientRetryGivesUpWhenContextCancelled 上层取消后不得继续等退避。 +// +// 编排层用 ctx 超时兜底（如 150s），退避期间必须能被它打断；否则「取消」只是 +// 一句空话，请求会一直挂到退避走完。 +func TestTransientRetryGivesUpWhenContextCancelled(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + calls := 0 + go func() { + // 第一次调用失败后立刻取消，让退避等待成为被打断的那一步。 + time.Sleep(20 * time.Millisecond) + cancel() + }() + + // 退避给足够长，长到「能等完」和「被打断」结果明显不同。 + start := time.Now() + _, err := withTransientRetry(ctx, 30*time.Second, func(context.Context) (string, error) { + calls++ + return "", transientErr() + }) + elapsed := time.Since(start) + + if err == nil { + t.Fatal("期望失败，实际成功") + } + if !errors.Is(err, context.Canceled) { + t.Errorf("错误里应能认出 context.Canceled，实际：%v", err) + } + if calls != 1 { + t.Errorf("取消后不该再发起调用，实际调用 %d 次", calls) + } + if elapsed > 5*time.Second { + t.Errorf("取消应立刻打断退避，实际等了 %s", elapsed.Round(time.Millisecond)) + } +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/speakers.go b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/speakers.go new file mode 100644 index 0000000..523913c --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/speakers.go @@ -0,0 +1,399 @@ +package audiotranscribe + +import ( + "context" + "encoding/json" + "fmt" + "strings" + + "eai_agentplatform/backend/internal/config" +) + +// SpeakerIdentity 一位说话人的身份名片：机构名 + 头衔 + 姓名。 +// +// 为什么是三个字段而不是一个「名字」：ASR 吐出来的说话人在全链路只是一个裸序号 +// （FormatTranscriptWithSpeakers 把它渲染成「说话人 0」），而平台里**没有任何人员 +// 花名册**可以拿来对照 —— 全库没有人员实体，「参会人」也只是会议纪要办公技能里的 +// 一个自由文本字段。所以身份只能从稿内线索推断出来再请用户确认。 +// 而一次会议里「谁在说话」真正有用的是这三样：纪要点评谁的意见、行动项派给谁， +// 都靠它；只给一个名字，机构与职务照样要用户自己补。 +type SpeakerIdentity struct { + // Key ASR 原样给出的说话人标签，作为配对键（"0" / "1" / "SPEAKER_00"）。 + // 它不参与展示 —— 它只是「这是哪一位」的锚点，改名即静默断链。 + Key string `json:"key"` + // Org 机构名。稿里没有依据时为空：**留空是正确结果，不是失败**。 + Org string `json:"org"` + // Title 头衔。同上。 + Title string `json:"title"` + // Name 姓名。同上。 + Name string `json:"name"` + // Evidence 支撑这次推断的原文片段，让用户能核对而不是只能信。 + Evidence string `json:"evidence,omitempty"` + // DecidedBy 这份值最终是怎么定下来的，取值见 SpeakerDecidedBy* 常量。 + // 由服务端比对「AI 推断值 vs 用户提交值」算出，**不收客户端自报的标志位** —— + // 客户端自报的「我没改过」是无法核验的，而那正是这个字段要记录的事。 + DecidedBy string `json:"decided_by,omitempty"` +} + +// 身份是怎么定下来的。 +// +// 对应 AR12 §5.4 要求记录的「用户显式选择 / 用户手工输入新方案」。该条里的另一档 +// 「系统自动默认」在本流程中**不允许出现**：未确认前下游步骤会被 +// ensureAudioSpeakersConfirmed 拦住，不存在「没人确认也照样往下跑」的路径。 +const ( + // SpeakerDecidedByUserConfirmed 用户看过 AI 的推断值，一字未改直接确认。 + SpeakerDecidedByUserConfirmed = "user_confirmed" + // SpeakerDecidedByUserEdited 用户至少改过一个字段。 + SpeakerDecidedByUserEdited = "user_edited" +) + +// DisplayName 这个人该在正式稿里显示成什么。 +// +// 姓名优先；没有姓名就退回「机构·头衔」——「某某局·处长」在纪要里也比 +// 「说话人 0」有用得多；三样都没有则返回空字符串，调用方据此**跳过替换**， +// 让稿子保持原样，而不是硬塞一个占位符进去假装认出来了。 +func (s SpeakerIdentity) DisplayName() string { + if name := strings.TrimSpace(s.Name); name != "" { + return name + } + parts := make([]string, 0, 2) + if org := strings.TrimSpace(s.Org); org != "" { + parts = append(parts, org) + } + if title := strings.TrimSpace(s.Title); title != "" { + parts = append(parts, title) + } + if len(parts) == 0 { + return "" + } + return strings.Join(parts, "·") +} + +// SpeakerInferMaxChars 推断身份时最多喂给模型多少字的逐字稿。 +// +// 与第 5、6 步的 llmChunkChars（1200）不是一个量级，因为这两件事的约束相反： +// 那两步是**输出**一整篇文档，所以要切块；这一步只输出一小段 JSON，瓶颈在输入。 +// 取 24000 是因为一次真实的 26:41 录音逐字稿是 11936 字，留了一倍余量； +// 再长就截断，且截断这件事会写进产物与日志（见 runAudioSpeakersStep）。 +// +// 不切块再归并的原因：身份判断依赖跨段的线索（后面有人喊了一声「张局」， +// 前面那个自我介绍才坐实），切块会把这类线索切断，归并时也无从判断哪条更可信。 +const SpeakerInferMaxChars = 24000 + +// speakerSystemPrompt 推断说话人身份的提示词。 +// +// 第 2 条是整段提示词的重点。平台没有人员花名册，模型一旦按会议的常见套路开始 +// 编造（「张总」「李经理」），这些名字会一路进到纪要里，而用户很难在一份通顺的 +// 纪要里发现自己被安了个假名字 —— 这比缺一个名字有害得多。仓库里已有同样的口径 +// （纪要提示词要求「原文没有就写待定」），这里与之一致。 +const speakerSystemPrompt = `你是会议记录助理。任务：从一份逐字转写稿里推断每一位说话人的身份名片 —— 机构名、头衔、姓名。 + +必须遵守： +1. 只依据稿内线索推断：自我介绍、互相称呼、职务称谓（如「张局」「李总」）、会前寒暄、会议背景。不做任何外部联想。 +2. 稿里没有依据的字段一律留空字符串。**绝对不许编造**：宁可三个字段全空，也不要填一个听起来合理的名字。留空是正确结果，不是失败。 +3. 同一个人被以不同方式称呼时，取稿里最明确、出现次数最多的那一种。 +4. 每位说话人给一句 evidence，摘录支撑这次推断的原文片段（60 字以内）；没有依据就给空字符串。 + +只输出 JSON，不要 Markdown 代码块、不要任何解释。格式： +{"speakers":[{"key":"","org":"","title":"","name":"","evidence":""}]} + +speakers 数组必须**逐一覆盖**下面给出的每一个说话人标签，不能多、不能少、顺序不限。` + +// InferSpeakerIdentities 让模型从逐字稿里推断每位说话人的身份。 +// +// keys 是 ASR 实际给出的说话人标签，**由调用方从第 2 步的分段里取**， +// 不让模型自己决定有几个人：它少认一个，那个人就会在下游的名字替换里被静默漏掉， +// 而界面上完全看不出来 —— 稿子里还剩着「说话人 2」，没人会注意到。 +// +// 返回值里的 clipped 说明这次是不是只喂了前 SpeakerInferMaxChars 字。 +// 截断在这里做、也在这里报，是因为它是会影响结论的事实，必须让调用方写进产物 —— +// 而调用方自己再截一次的话，两处上限一改一漏，报出来的「没截断」就是假的。 +func InferSpeakerIdentities( + ctx context.Context, + transcript string, + keys []string, + route *config.RouteConfig, +) (roster []SpeakerIdentity, clipped bool, err error) { + if len(keys) == 0 { + return nil, false, fmt.Errorf("逐字稿里没有说话人标签，无法推断身份") + } + if strings.TrimSpace(transcript) == "" { + return nil, false, fmt.Errorf("逐字稿是空的，无法推断说话人身份") + } + if route == nil { + return nil, false, fmt.Errorf("没有可用的对话路由，无法推断说话人身份") + } + + source, clipped := ClipTranscript(transcript, SpeakerInferMaxChars) + user := fmt.Sprintf("本次逐字稿里的说话人标签共 %d 个：%s\n\n逐字稿：\n%s", + len(keys), strings.Join(keys, "、"), source) + + raw, err := callModel(ctx, route, speakerSystemPrompt, user) + if err != nil { + return nil, clipped, fmt.Errorf("推断说话人身份失败：%w", err) + } + + roster, err = parseSpeakerRoster(raw) + if err != nil { + return nil, clipped, err + } + if err := ensureRosterCoversKeys(roster, keys); err != nil { + return nil, clipped, err + } + return roster, clipped, nil +} + +// ClipTranscript 按字数上限截断逐字稿，并告知调用方有没有真的截断过。 +// +// 导出是因为「有没有截断」是会影响结论的事实，得由调用方写进产物与日志 —— +// 一份只看了前 40% 的稿子推出来的身份，和看完全稿推出来的，可信度不是一回事。 +func ClipTranscript(transcript string, maxChars int) (string, bool) { + if maxChars <= 0 { + return transcript, false + } + runes := []rune(transcript) + if len(runes) <= maxChars { + return transcript, false + } + return string(runes[:maxChars]), true +} + +// parseSpeakerRoster 解析模型返回的 JSON。 +// +// 容忍两种情况，因为这两种在实测里都会出现，而它们都不该让整步失败： +// 把 JSON 包在 ```json 代码块里、以及在 JSON 前后带一句客套话。 +func parseSpeakerRoster(raw string) ([]SpeakerIdentity, error) { + text := strings.TrimSpace(raw) + if text == "" { + return nil, fmt.Errorf("模型没有返回内容，无法得到说话人身份") + } + // 掐掉代码块围栏与前后的解释文字，只留最外层的那个 {...}。 + if start := strings.Index(text, "{"); start >= 0 { + if end := strings.LastIndex(text, "}"); end > start { + text = text[start : end+1] + } + } + + var payload struct { + Speakers []SpeakerIdentity `json:"speakers"` + } + if err := json.Unmarshal([]byte(text), &payload); err != nil { + // 原文不截断地贴进错误里：这段 JSON 通常很短，而少了它就没法判断 + // 是模型没按格式输出，还是我们自己的解析写错了。 + return nil, fmt.Errorf("模型的输出不是预期格式的 JSON（%w）：%s", err, text) + } + if len(payload.Speakers) == 0 { + return nil, fmt.Errorf("模型返回的说话人名单是空的：%s", text) + } + + roster := make([]SpeakerIdentity, 0, len(payload.Speakers)) + for _, item := range payload.Speakers { + roster = append(roster, SpeakerIdentity{ + Key: strings.TrimSpace(item.Key), + Org: strings.TrimSpace(item.Org), + Title: strings.TrimSpace(item.Title), + Name: strings.TrimSpace(item.Name), + Evidence: strings.TrimSpace(item.Evidence), + }) + } + return roster, nil +} + +// ensureRosterCoversKeys 校验模型给的名册与稿里实际的说话人**一一对应**。 +// +// 少了：那个人在下游替换里被静默漏掉。多了：凭空多出一位不存在的与会者， +// 且会出现在待确认的名单里让用户以为真有这个人。两种都不能放过， +// 所以这里宁可整步失败 —— 失败会在界面上吵，缺一个说话人不会。 +func ensureRosterCoversKeys(roster []SpeakerIdentity, keys []string) error { + seen := make(map[string]bool, len(roster)) + for _, item := range roster { + if item.Key == "" { + return fmt.Errorf("模型返回的名单里有条目缺少说话人标签（key 为空）") + } + if seen[item.Key] { + return fmt.Errorf("模型返回的名单里说话人 %s 出现了多次", item.Key) + } + seen[item.Key] = true + } + + missing := make([]string, 0) + for _, key := range keys { + if !seen[key] { + missing = append(missing, key) + } + } + extra := make([]string, 0) + for key := range seen { + if !containsString(keys, key) { + extra = append(extra, key) + } + } + if len(missing) > 0 || len(extra) > 0 { + return fmt.Errorf("模型返回的说话人名单与逐字稿对不上：缺少 %v，多出 %v（稿里有 %v）", + missing, extra, keys) + } + return nil +} + +// MarkDecidedBy 比对「AI 推断值」与「用户提交值」，标出每一位是怎么定下来的。 +// +// 放在这一层而不是 handler 里，是因为它是这条业务规则本身，而不是 HTTP 细节； +// 而且它必须与 SpeakerIdentity 的三个字段保持同步 —— 将来加第四个字段 +// （比如「部门」）时，漏改这里会让所有人都被标成「未修改」。 +func MarkDecidedBy(submitted, inferred []SpeakerIdentity) []SpeakerIdentity { + originals := make(map[string]SpeakerIdentity, len(inferred)) + for _, item := range inferred { + originals[item.Key] = item + } + + marked := make([]SpeakerIdentity, 0, len(submitted)) + for _, item := range submitted { + before, ok := originals[item.Key] + switch { + case !ok: + // 到不了这里：调用方已经用 ensureRosterCoversKeys 校验过键集合。 + // 真到了说明校验被绕过，与其静默标一个值，不如标成「改过」—— + // 一个不认识的说话人只可能是人为加进来的。 + item.DecidedBy = SpeakerDecidedByUserEdited + case before.Org == item.Org && before.Title == item.Title && before.Name == item.Name: + item.DecidedBy = SpeakerDecidedByUserConfirmed + default: + item.DecidedBy = SpeakerDecidedByUserEdited + } + // Evidence 是 AI 给的依据，不是用户提交的内容：以库里的原值收口， + // 免得客户端顺手把它改掉，让「依据」变成一条可以伪造的字段。 + if ok { + item.Evidence = before.Evidence + } else { + item.Evidence = "" + } + marked = append(marked, item) + } + return marked +} + +// SpeakerKeysOf 从第 2 步产物的 ContentJSON 里取出说话人标签（去重、保持首次出现顺序）。 +// +// 顺序有含义：稿子里先开口的那位排在前面，界面上按这个顺序列出来， +// 用户对着稿子核对时不用来回找。 +func SpeakerKeysOf(contentJSON string) []string { + var payload struct { + Segments []Segment `json:"segments"` + } + if err := json.Unmarshal([]byte(contentJSON), &payload); err != nil { + return nil + } + keys := make([]string, 0, 4) + for _, seg := range payload.Segments { + key := strings.TrimSpace(seg.Speaker) + if key == "" || containsString(keys, key) { + continue + } + keys = append(keys, key) + } + return keys +} + +// SpeakerRosterOf 从「说话人名单」产物的 ContentJSON 里取回名单。 +// +// 与 SpeakerKeysOf 的区别：那个读的是第 2 步的**逐字稿**（segments[].speaker，只有 +// 裸标签），这个读的是第 3 步的**名单**（speakers[]，带机构名头衔姓名）。 +// 两者都是 JSON，形状不同，所以是两个函数而不是一个带开关的。 +// +// 解析失败返回 nil 而不是报错：调用方拿到的空名单会让下游退化成「保持原样」， +// 而这正是解析不出来时唯一正确的行为 —— 总比把半份名单套上去、给一半人改名、 +// 另一半留着「说话人 3」要好。 +func SpeakerRosterOf(contentJSON string) []SpeakerIdentity { + var payload struct { + Speakers []SpeakerIdentity `json:"speakers"` + } + if err := json.Unmarshal([]byte(contentJSON), &payload); err != nil { + return nil + } + return payload.Speakers +} + +// ValidateSpeakerRosterKeys 校验用户提交的名单与原推断名单**一一对应**。 +// +// 多一个：凭空多出一位不存在的与会者，且下游替换时会把一个没人说过的名字 +// 写进稿子。少一个：那个人被静默漏掉，稿子里留着「说话人 2」而没人会注意到。 +// 两种都在这里拦掉，复用推断那一步的同一份校验，免得两处口径漂移。 +func ValidateSpeakerRosterKeys(submitted, inferred []SpeakerIdentity) error { + keys := make([]string, 0, len(inferred)) + for _, item := range inferred { + keys = append(keys, item.Key) + } + return ensureRosterCoversKeys(submitted, keys) +} + +// ApplySpeakerNames 把稿子里的「说话人 0」换成确认过的称呼。 +// +// 只做内存里的替换，**不回写 transcript 产物**：那份稿子的价值恰恰在于它是 +// ASR 没被动过的原始记录（latestArtifactText 取的也是它），改写之后 +// 「逐字转写稿」就不再等于机器听到的东西了。 +// +// keys 先长后短地替换：「说话人 1」是「说话人 10」的前缀， +// 按原顺序替换会把「说话人 10」改成「张三0」。 +func ApplySpeakerNames(transcript string, roster []SpeakerIdentity) string { + if transcript == "" || len(roster) == 0 { + return transcript + } + sorted := make([]SpeakerIdentity, len(roster)) + copy(sorted, roster) + // 简单的插入排序：说话人个数是个位数，不值得为它引入 sort 包。 + for i := 1; i < len(sorted); i++ { + for j := i; j > 0 && len(sorted[j].Key) > len(sorted[j-1].Key); j-- { + sorted[j], sorted[j-1] = sorted[j-1], sorted[j] + } + } + + for _, item := range sorted { + display := item.DisplayName() + key := strings.TrimSpace(item.Key) + if display == "" || key == "" { + continue + } + // 两种写法都换：FormatTranscriptWithSpeakers 产出的是「说话人 0：」， + // 但用户自己编辑过的稿子、或别的 ASR 输出里可能是「说话人0：」。 + transcript = strings.ReplaceAll(transcript, "说话人 "+key, display) + transcript = strings.ReplaceAll(transcript, "说话人"+key, display) + } + return transcript +} + +// RenderSpeakerRoster 把名单渲染成可读文本，作为产物的正文。 +// +// 正文给人看（右栏预览、导出、以及确认后作为留痕），结构化的那份进 ContentJSON。 +func RenderSpeakerRoster(roster []SpeakerIdentity, confirmed bool) string { + var b strings.Builder + if confirmed { + b.WriteString("## 说话人名单（已确认）\n\n") + } else { + b.WriteString("## 说话人名单（AI 推断，待确认）\n\n") + b.WriteString("> 以下身份是模型从稿内线索推断的，**尚未确认**。确认之前不会继续整理与生成纪要，\n") + b.WriteString("> 以免把推断出来的身份当成事实写进正式稿。稿里没有依据的字段留空，不做编造。\n\n") + } + for _, item := range roster { + display := item.DisplayName() + if display == "" { + display = "（稿中无依据，未能推断出身份）" + } + fmt.Fprintf(&b, "- 说话人 %s：%s\n", item.Key, display) + if item.Evidence != "" { + fmt.Fprintf(&b, " - 依据：%s\n", item.Evidence) + } + if confirmed && item.DecidedBy == SpeakerDecidedByUserEdited { + b.WriteString(" - 用户已修改\n") + } + } + return b.String() +} + +func containsString(list []string, target string) bool { + for _, item := range list { + if item == target { + return true + } + } + return false +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/transcribe.go b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/transcribe.go new file mode 100644 index 0000000..7b47e23 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/transcribe.go @@ -0,0 +1,478 @@ +// Package audiotranscribe 语音转写（ASR）技能内核。 +// +// 内核放在这里而不是 internal/api，是因为它有两个调用方： +// - internal/api.TranscribeAudio —— 裸的 multipart 上传接口； +// - internal/skills/api 的技能工作流第 2 步 —— 从 media_id 读盘再转写。 +// +// 后者的包拿不到 api 包的不导出函数，所以内核必须下沉。 +// 与 report_generation/report_content.go 的归置方式一致。 +// +// 本包只做「拿音频字节 → 拿到转写结果」，不碰数据库、不碰 HTTP 请求上下文， +// 因此可以被单测直接调用（含真实网络那条）。 +package audiotranscribe + +import ( + "bytes" + "encoding/json" + "errors" + "fmt" + "io" + "mime/multipart" + "net/http" + "net/url" + "os/exec" + "strconv" + "strings" + "time" + + "eai_agentplatform/backend/internal/ai" + "eai_agentplatform/backend/internal/config" +) + +// Segment 一段带说话人与时间戳的转写片段。 +// SiliconFlow 的 Diarize 模型会返回 segments，每段带 speaker / start / end。 +type Segment struct { + Speaker string `json:"speaker"` + Start float64 `json:"start"` + End float64 `json:"end"` + Text string `json:"text"` +} + +// Result 一次转写的完整结果。 +type Result struct { + Text string `json:"text"` // 转写文字（含说话人前缀，若有） + Language string `json:"language"` // 语言 + Duration float64 `json:"duration"` // 时长(秒) + Segments []Segment `json:"segments"` // 分段（含说话人），可能为空 + HasSpeakers bool `json:"has_speakers"` // 是否区分了说话人 + Model string `json:"model"` // 实际使用的 ASR 模型 + RouteID string `json:"route_id"` // 实际使用的音频路由 + // IsLocal 本次转写是否全程在本机完成。判据是**实际服务的那条路由**的 + // base_url 是不是回环地址，见 config.IsLocalRoute —— 量的是「字节实际去了哪」。 + // 它存在的理由只有一个：本地 ASR 挂掉时会自动回退云端，用户有权知道 + // 这一次的录音被送出去了。所以这个字段必须一路带到界面，不能只在日志里。 + // + // 措辞按「本机」而不是「内网」：回环只证明音频没离开这台机器， + // 不证明它没离开这栋楼（ASR 若部署在内网另一台机器上，这里也是 false）。 + IsLocal bool `json:"is_local"` + + // FellBack 本次是否用到了回退链（主路由没跑成，换了另一条）。 + // 与 IsLocal 是两件事：主路由是本地、回退到云端，则两个都最有信息量。 + FellBack bool `json:"fell_back"` + PrimaryRouteID string `json:"primary_route_id,omitempty"` // 原本该用的那条 + FallbackReason string `json:"fallback_reason,omitempty"` // 主路由失败的原因 + CreatedAt string `json:"created_at"` // 时间 +} + +// AllowedExt 允许转写的音频扩展名（小写，不含点）。 +var AllowedExt = map[string]bool{ + "mp3": true, "wav": true, "m4a": true, + "ogg": true, "flac": true, "aac": true, "wma": true, +} + +// IsAudioExt 判断扩展名是否为可转写音频（大小写不敏感，容忍前导点）。 +// +// 前端的发送门控与后端的入参校验共用这一张表，避免两边各写一份后走偏。 +func IsAudioExt(ext string) bool { + return AllowedExt[strings.ToLower(strings.TrimPrefix(strings.TrimSpace(ext), "."))] +} + +// ExtractExt 从文件名提取扩展名（小写，不含点）。 +func ExtractExt(filename string) string { + idx := strings.LastIndexByte(filename, '.') + if idx < 0 { + return "" + } + return strings.ToLower(filename[idx+1:]) +} + +// TranscribeBytes 调一次 ASR 并把结果解析成 Result。 +// +// 主路由失败且失败属于「这条路此刻不行」时，依次尝试回退链（见 transcribeChain）。 +// 失败一律返回 error，**不把错误文案塞进 Text 字段返回**： +// 那种「永远 200、正文里写错误」的做法会让调用方把错误当成转写稿落库。 +func TranscribeBytes(userID uint, fileData []byte, filename, ext, language, routeOverride string) (*Result, error) { + chain, err := transcribeChainFn(routeOverride) + if err != nil { + return nil, err + } + + var lastErr error + for i, route := range chain { + result, retriable, err := transcribeOnRoute(userID, route, fileData, filename, ext, language) + if err == nil { + // 成功要如实报健康：本地刚挂、这次退到云端跑通了，这一笔就把 + // 「本地不健康」这个事实就地更新了，不必等下一轮 30 分钟的巡检。 + config.ReportRouteHealth(config.RouteHealth{ + AIRouteID: route.RouteID, + Category: route.Category, + Healthy: true, + Checked: true, + LastCheckedAt: time.Now(), + }) + result.PrimaryRouteID = chain[0].RouteID + result.FellBack = i > 0 + if lastErr != nil { + result.FallbackReason = lastErr.Error() + } + return result, nil + } + lastErr = err + if !retriable { + // 「这个文件/这次请求本身不行」：换一条路由重发同一份文件不会变好， + // 而代价是把这份录音又送出门一次。隐私代价换不到成功率，不回退。 + return nil, err + } + if i < len(chain)-1 { + // 失败的那条就地标不健康，否则下一轮巡检之前所有请求都会先撞它一次。 + config.ReportRouteHealth(config.RouteHealth{ + AIRouteID: route.RouteID, + Category: route.Category, + Healthy: false, + Checked: true, + LastError: err.Error(), + LastCheckedAt: time.Now(), + }) + } + } + // 列出试过的每一条：只说「服务不可达」而不说试过哪几条， + // 排障时分不清「回退链没跑」和「跑了但全都不行」。 + ids := make([]string, 0, len(chain)) + for _, r := range chain { + ids = append(ids, r.RouteID) + } + return nil, fmt.Errorf("语音转写失败，已依次尝试 %s：%w", + strings.Join(ids, " → "), lastErr) +} + +// transcribeChainFn 取路由链。单独拎成变量只为让测试能把链指向本机的 httptest： +// 真实配置里的回退目标是公网 ASR，要测回退就得真把音频发出去 —— 那正是这个功能 +// 要防的事，绝不能拿测试来干。注入之后整条链都留在本机，而回退逻辑仍是真的 +// （真发 HTTP、真读状态码、真走重试判定）。同一模式见 audio_handlers.go 的 +// audioRouteSupportsSpeakers。 +var transcribeChainFn = transcribeChain + +// transcribeChain 组装「主路由 + 回退链」。 +// +// 为什么请求级回退不能省：健康探测是 30 分钟一轮的（route_health.go 的 +// defaultAIRouteProbeInterval），本地服务在这两轮之间挂掉，探测结果还是「健康」， +// 于是请求会先撞一次已经死掉的本地路由 —— 对用户就是一次硬失败。巡检负责 +// 「选谁当主」，回退链负责「主不行时换谁」，两者是叠加关系，不是二选一。 +// +// 只对 audio 分类做这件事：chat/embed 的回退在 internal/ai 那边已有实现。 +func transcribeChain(routeOverride string) ([]*config.RouteConfig, error) { + route, err := getAudioRoute(routeOverride) + if err != nil { + return nil, fmt.Errorf("语音转写路由不可用：%w", err) + } + if route.Category != "audio" { + return nil, fmt.Errorf("路由 %s 的分类是 %q，不是 audio", route.RouteID, route.Category) + } + return append([]*config.RouteConfig{route}, + config.GetFallbackAudioRoutes(route.RouteID)...), nil +} + +// transcribeOnRoute 在**一条**指定路由上跑一次转写。 +// +// 第二个返回值 retriable 表示「换个路由重发有没有意义」： +// - 连不上 / 5xx / 429 —— 这条路此刻不行，换一条有意义； +// - 400/413/415 等 4xx —— 是这份文件或这次请求不行，换谁都不行； +// - 超时 —— 预算已经吃掉了，再换一条大概率还是被掐断，且会把音频再发一次。 +// +// 超时**不**算 retriable 是刻意的。回退只有在「还来得及成功」时才有价值； +// 一次超时意味着主路由的预算是整段耗尽的，接着把同一份长音频发给云端， +// 结果多半是用户那边先超时（前端 axios 15 分钟），而音频已经出门了。 +func transcribeOnRoute(userID uint, route *config.RouteConfig, fileData []byte, + filename, ext, language string) (*Result, bool, error) { + // 本机服务免密钥（判据与健康探测共用，见 config.IsLocalRoute）。 + // 非本地仍要求有密钥：缺密钥的云端路由打过去只会拿到 401， + // 提前报错比让用户等一轮网络往返再看到 401 好。 + isLocal := config.IsLocalRoute(route) + if !isLocal && route.APIKey == "" { + // 请求还没发出去，换一条路由是零成本的（没有音频出网），算可回退。 + return nil, true, fmt.Errorf("音频路由 %s（provider %s）缺少 API Key", route.RouteID, route.Provider) + } + + // 构建 multipart body + buf := bytes.NewBuffer(nil) + w := multipart.NewWriter(buf) + + modelField, err := w.CreateFormField("model") + if err != nil { + return nil, false, fmt.Errorf("构建请求失败：%w", err) + } + if _, err := modelField.Write([]byte(route.Model)); err != nil { + return nil, false, fmt.Errorf("写入 model 失败：%w", err) + } + + // language：中转服务可能忽略该字段，但传上不影响；空值与 "auto" 都不传， + // 交给模型自行判断，避免某些服务把 "auto" 当非法语言码拒掉。 + lang := strings.TrimSpace(language) + if lang != "" && !strings.EqualFold(lang, "auto") { + langField, err := w.CreateFormField("language") + if err != nil { + return nil, false, fmt.Errorf("构建请求失败：%w", err) + } + if _, err := langField.Write([]byte(lang)); err != nil { + return nil, false, fmt.Errorf("写入 language 失败：%w", err) + } + } + + uploadName := strings.TrimSpace(filename) + if uploadName == "" { + uploadName = "audio." + ext + } + filePart, err := w.CreateFormFile("file", uploadName) + if err != nil { + return nil, false, fmt.Errorf("构建请求失败：%w", err) + } + if _, err := filePart.Write(fileData); err != nil { + return nil, false, fmt.Errorf("写入音频失败：%w", err) + } + if err := w.Close(); err != nil { + return nil, false, fmt.Errorf("构建请求失败：%w", err) + } + + timeout := time.Duration(route.TimeoutSeconds) * time.Second + if timeout <= 0 { + timeout = 600 * time.Second // 长音频转写天然慢，默认给足 10 分钟 + } + + req, err := http.NewRequest("POST", route.FullURL, buf) + if err != nil { + return nil, false, fmt.Errorf("请求构建失败：%w", err) + } + req.Header.Set("Content-Type", w.FormDataContentType()) + authKey := route.APIKey + if authKey == "" { + // 本地服务不校验密钥的值，但要求这个头存在（serve.py 收不到就回 401）。 + // 不写 "Bearer " 留个尾空格让对端去 strip —— 显式给个占位值更清楚。 + authKey = "local" + } + req.Header.Set("Authorization", "Bearer "+authKey) + + client := &http.Client{Timeout: timeout} + startedAt := time.Now() + resp, err := client.Do(req) + latencyMs := int(time.Since(startedAt).Milliseconds()) + if err != nil { + LogCall(userID, route, false, err.Error(), latencyMs) + // 超时不回退，理由见函数头注释；连不上则回退 —— 本地服务没起来 + // 正是最常见的那种失败，也正是「自动回退云端」要接住的那一种。 + return nil, !isTimeoutErr(err), fmt.Errorf("ASR 服务不可达（%s）：%w", route.RouteID, err) + } + defer resp.Body.Close() + + body, err := io.ReadAll(resp.Body) + if err != nil { + LogCall(userID, route, false, "读取响应失败", latencyMs) + return nil, true, fmt.Errorf("读取 ASR 响应失败：%w", err) + } + + if resp.StatusCode != http.StatusOK { + msg := fmt.Sprintf("ASR 返回 HTTP %d：%s", resp.StatusCode, truncateForError(body, 300)) + LogCall(userID, route, false, msg, latencyMs) + return nil, isRetriableHTTPStatus(resp.StatusCode), fmt.Errorf("%s", msg) + } + + // 响应：{duration, text, segments:[{speaker,start,end,text}], usage} + var out struct { + Duration float64 `json:"duration"` + Text string `json:"text"` + Segments []struct { + Speaker string `json:"speaker"` + Start float64 `json:"start"` + End float64 `json:"end"` + Text string `json:"text"` + } `json:"segments"` + } + if err := json.Unmarshal(body, &out); err != nil { + LogCall(userID, route, false, "响应解析失败", latencyMs) + // 200 但不是 ASR 的 JSON：这条路由大概率指向了别的服务（比如把 ASR + // 打到了 chat 端点上）。换一条是对的。 + return nil, true, fmt.Errorf("ASR 响应解析失败：%w（原始报文：%s）", err, truncateForError(body, 200)) + } + + segments := make([]Segment, 0, len(out.Segments)) + hasSpeakers := false + for _, s := range out.Segments { + seg := Segment{ + Speaker: strings.TrimSpace(s.Speaker), + Start: s.Start, + End: s.End, + Text: strings.TrimSpace(s.Text), + } + if seg.Speaker != "" { + hasSpeakers = true + } + if seg.Text == "" { + continue + } + segments = append(segments, seg) + } + + text := strings.TrimSpace(out.Text) + if text == "" { + // 有的服务只给 segments 不给 text，这里补一个。 + text = JoinSegments(segments) + } + // 空白音频会得到 200 + 空文本，这不是「成功转写」。 + // 也不回退：这条路由说「这份音频没有人声」，换一条大概率还是同一句话， + // 而代价是把音频再送一次出去。 + if text == "" { + msg := "ASR 返回空文本（音频可能无有效人声，或格式不被识别）" + LogCall(userID, route, false, msg, latencyMs) + return nil, false, fmt.Errorf("%s", msg) + } + + LogCall(userID, route, true, "", latencyMs) + + return &Result{ + Text: text, + Language: lang, + Duration: out.Duration, + Segments: segments, + HasSpeakers: hasSpeakers, + Model: route.Model, + RouteID: route.RouteID, + IsLocal: isLocal, + CreatedAt: time.Now().Format("2006-01-02 15:04:05"), + }, false, nil +} + +// isTimeoutErr 判断传输层错误是不是「等超时了」。 +// +// http.Client 超时抛的是 *url.Error，其 Timeout() 为真；用 errors.As 取它， +// 而不是拿错误文案去 grep "timeout" —— 文案随 Go 版本变，而且网络错误里 +// 出现 timeout 字样的不止超时一种（比如 DNS 超时，那种其实值得回退）。 +func isTimeoutErr(err error) bool { + var ue *url.Error + if errors.As(err, &ue) { + return ue.Timeout() + } + return false +} + +// isRetriableHTTPStatus 换个路由重发有没有意义（HTTP 状态维度）。 +// +// 5xx 是「这条路由此刻坏了」，429 是「这条路由此刻忙」，都值得换一条。 +// 4xx 一律不换：那是「这份请求本身不行」—— 400/415 是音频格式或参数不对， +// 413 是文件太大，401/403 是密钥不对（回退链上的路由在本项目里共用同一份 +// secrets，换一条也是同样的密钥）。把同一份文件再送一次出门，换不到成功率。 +func isRetriableHTTPStatus(code int) bool { + return code >= 500 || code == http.StatusTooManyRequests +} + +// getAudioRoute 取转写用的音频路由。 +// +// override 非空时优先（供后台按路由做通路测试）；为空则用 agent_routes 里的 +// audio_transcribe。取不到即报错，不回退 chat 路由 —— 见 config.GetAudioRoute。 +func getAudioRoute(override string) (*config.RouteConfig, error) { + agent := strings.TrimSpace(override) + if agent == "" { + agent = "audio_transcribe" + } + return config.GetAudioRoute(agent) +} + +// JoinSegments 把分段拼成带说话人前缀的文本；无说话人时按时间顺序直接拼接。 +func JoinSegments(segments []Segment) string { + lines := make([]string, 0, len(segments)) + for _, s := range segments { + if s.Speaker != "" { + lines = append(lines, s.Speaker+": "+s.Text) + } else { + lines = append(lines, s.Text) + } + } + return strings.Join(lines, "\n") +} + +// LogCall 记录一次转写调用。成功才计点（ComputeCredits 内部已判）， +// 失败必须如实记 failed —— 旧实现无论成败都写 Success: true，用量与计费都是假的。 +func LogCall(userID uint, route *config.RouteConfig, success bool, errMsg string, latencyMs int) { + ai.LogCall(ai.LogEntry{ + UserID: userID, + UsageKind: ai.UsageKindAudioTranscribe, + Provider: route.Provider, + AIRouteID: route.RouteID, + Model: route.Model, + Success: success, + ErrorMessage: errMsg, + LatencyMs: latencyMs, + }) +} + +// truncateForError 截断第三方返回的原始报文，避免把整页 HTML 错误塞进用户可见消息。 +func truncateForError(b []byte, max int) string { + s := strings.TrimSpace(string(b)) + if len(s) <= max { + return s + } + return s[:max] + "…" +} + +// FormatTranscriptWithSpeakers 把转写结果渲染成逐字稿正文（技能工作流第 2 步的产物）。 +func FormatTranscriptWithSpeakers(result *Result) string { + if len(result.Segments) == 0 { + return result.Text + } + var b strings.Builder + for _, s := range result.Segments { + who := s.Speaker + if who != "" { + who = "说话人 " + who + } else { + who = "说话人 —" + } + b.WriteString(fmt.Sprintf("[%s - %s] %s：%s\n", + FormatClock(s.Start), FormatClock(s.End), who, s.Text)) + } + return strings.TrimRight(b.String(), "\n") +} + +// FormatClock 把秒数渲染成 mm:ss（分段起止时间用；超过一小时也只显示到分钟）。 +func FormatClock(sec float64) string { + if sec < 0 { + sec = 0 + } + total := int(sec + 0.5) + return strconv.Itoa(total/60) + ":" + fmt.Sprintf("%02d", total%60) +} + +// FormatDuration 把秒数渲染成人读的时长（第 1 步「确认音频范围」展示用）。 +// 一小时以上出小时位，避免出现「62:33」这种要心算的写法；不足一秒按 0 秒处理。 +func FormatDuration(sec float64) string { + if sec < 0 { + sec = 0 + } + total := int(sec + 0.5) + if total < 3600 { + return FormatClock(float64(total)) + } + return fmt.Sprintf("%d:%02d:%02d", total/3600, (total%3600)/60, total%60) +} + +// ProbeDuration 用 ffprobe 读音频时长（秒）。 +// +// 读不到就返回 0 且不报错：时长只是第 1 步的展示信息，缺了不该让整个技能失败。 +// ffprobe 不在 PATH 上同样返回 0（裸进程依赖，缺失降级而非中断）。 +func ProbeDuration(path string) float64 { + if _, err := exec.LookPath("ffprobe"); err != nil { + return 0 + } + out, err := exec.Command("ffprobe", + "-v", "error", + "-show_entries", "format=duration", + "-of", "default=noprint_wrappers=1:nokey=1", + path, + ).Output() + if err != nil { + return 0 + } + seconds, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64) + if err != nil || seconds < 0 { + return 0 + } + return seconds +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/transcribe_test.go b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/transcribe_test.go new file mode 100644 index 0000000..553607a --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/transcribe_test.go @@ -0,0 +1,413 @@ +package audiotranscribe + +import ( + "fmt" + "os" + "path/filepath" + "strings" + "testing" + + "eai_agentplatform/backend/internal/model" +) + +// TestMain 定位 backend-go 并切换工作目录，让 config/ai_config.json 在测试进程内 +// 可被找到（configDir() 的回退逻辑依赖 CWD/config）。 +func TestMain(m *testing.M) { + if base := locateBackendGoForTest(); base != "" { + _ = os.Chdir(base) + } + os.Exit(m.Run()) +} + +// locateBackendGoForTest 从当前工作目录向上找含 config/ai_config.json 的目录。 +func locateBackendGoForTest() string { + dir, err := os.Getwd() + if err != nil { + return "" + } + for { + if _, err := os.Stat(filepath.Join(dir, "config", "ai_config.json")); err == nil { + return dir + } + parent := filepath.Dir(dir) + if parent == dir { + return "" + } + dir = parent + } +} + +func TestExtractExt(t *testing.T) { + cases := map[string]string{ + "meeting.mp3": "mp3", + "MEETING.MP3": "mp3", + "a.b.m4a": "m4a", + "noext": "", + "trailing.": "", + "/path/to/rec.wav": "wav", + } + for in, want := range cases { + if got := ExtractExt(in); got != want { + t.Errorf("ExtractExt(%q) = %q, want %q", in, got, want) + } + } +} + +// TestIsAudioExt 断言前后端共用同一张音频格式表：带点的、大写的、空白的都要认。 +func TestIsAudioExt(t *testing.T) { + for _, in := range []string{"mp3", "MP3", ".m4a", " wav ", "FLAC"} { + if !IsAudioExt(in) { + t.Errorf("IsAudioExt(%q) = false，期望 true", in) + } + } + for _, in := range []string{"", "mp4", "txt", "mp3x", "docx"} { + if IsAudioExt(in) { + t.Errorf("IsAudioExt(%q) = true，期望 false", in) + } + } +} + +func TestFormatClock(t *testing.T) { + cases := map[float64]string{ + 0: "0:00", + 7.499: "0:07", + 59.6: "1:00", // 四舍五入进位 + 60: "1:00", + 143.2: "2:23", + -5: "0:00", // 负值钳到 0，不出现 -0:05 + } + for in, want := range cases { + if got := FormatClock(in); got != want { + t.Errorf("FormatClock(%v) = %q, want %q", in, got, want) + } + } +} + +// TestFormatDuration 断言一小时以上会出小时位，不再显示成要心算的「62:33」。 +func TestFormatDuration(t *testing.T) { + cases := map[float64]string{ + 0: "0:00", + 143.2: "2:23", + 3599: "59:59", + 3600: "1:00:00", + 3753: "1:02:33", + -1: "0:00", + } + for in, want := range cases { + if got := FormatDuration(in); got != want { + t.Errorf("FormatDuration(%v) = %q, want %q", in, got, want) + } + } +} + +func TestJoinSegments(t *testing.T) { + segs := []Segment{ + {Speaker: "1", Text: "第一句"}, + {Speaker: "", Text: "没说话人"}, + {Speaker: "2", Text: "第二句"}, + } + got := JoinSegments(segs) + want := "1: 第一句\n没说话人\n2: 第二句" + if got != want { + t.Errorf("JoinSegments = %q, want %q", got, want) + } +} + +func TestFormatTranscriptWithSpeakersCarriesLabelsAndTimestamps(t *testing.T) { + result := &Result{ + Segments: []Segment{ + {Speaker: "1", Start: 0.14, End: 7.499, Text: "大家好"}, + {Speaker: "2", Start: 8.47, End: 14.73, Text: "我来说第一个议题"}, + }, + } + got := FormatTranscriptWithSpeakers(result) + for _, want := range []string{"说话人 1", "说话人 2", "0:00 - 0:07", "0:08 - 0:15", "大家好"} { + if !strings.Contains(got, want) { + t.Errorf("逐字稿缺少 %q\n实际内容:\n%s", want, got) + } + } +} + +// TestChunkTranscriptLosesNothing 是本包最容易出错的一处：分块是长音频唯一 +// 走得到 LLM 的路径，任何一块被吃掉都会变成纪要里「莫名少了一段」， +// 而且不会有任何报错。所以断言的是「内容无损」，不是「块数对不对」。 +func TestChunkTranscriptLosesNothing(t *testing.T) { + lines := make([]string, 0, 60) + for i := 0; i < 60; i++ { + lines = append(lines, strings.Repeat("这是一句会议发言。", 10)) // 每行 90 字 + } + transcript := strings.Join(lines, "\n") + + chunks := ChunkTranscript(transcript, 500) + if len(chunks) < 2 { + t.Fatalf("分块数 = %d，期望被切成多块（每块上限 500 字）", len(chunks)) + } + for index, chunk := range chunks { + if n := len([]rune(chunk)); n > 500 { + t.Errorf("第 %d 块 %d 字，超过上限 500", index+1, n) + } + } + // 拼回去必须与原文逐字一致（块之间用换行连接，原文也是换行连接）。 + if got := strings.Join(chunks, "\n"); got != transcript { + t.Errorf("分块后拼回的文本与原文不一致：原文 %d 字，拼回 %d 字", + len([]rune(transcript)), len([]rune(got))) + } +} + +// TestChunkTranscriptSplitsOverlongLine 断言单行超长时硬切而不是整行塞进一块， +// 否则纯文本（无分段信息）的逐字稿会绕过上限。 +func TestChunkTranscriptSplitsOverlongLine(t *testing.T) { + transcript := strings.Repeat("啊", 1200) + chunks := ChunkTranscript(transcript, 500) + if len(chunks) != 3 { + t.Fatalf("分块数 = %d，期望 3", len(chunks)) + } + if got := strings.Join(chunks, ""); got != transcript { + t.Error("硬切后内容与原文不一致") + } +} + +func TestChunkTranscriptShortInputIsSingleChunk(t *testing.T) { + if got := ChunkTranscript("只有一句话。", 500); len(got) != 1 { + t.Errorf("短稿被切成 %d 块，期望 1 块", len(got)) + } + if got := ChunkTranscript(" ", 500); got != nil { + t.Errorf("空白稿返回了 %d 块，期望 nil", len(got)) + } +} + +// TestMediaFilePath 断言路径按审批状态分目录，且拒绝越出目录的文件名。 +func TestMediaFilePath(t *testing.T) { + approved, err := MediaFilePath(model.MediaFile{ID: 1, StoredName: "a.mp3", Status: "approved"}) + if err != nil { + t.Fatalf("approved 素材解析失败: %v", err) + } + if filepath.Base(filepath.Dir(approved)) != "approved" { + t.Errorf("approved 素材路径 = %q，期望落在 approved/ 下", approved) + } + pending, err := MediaFilePath(model.MediaFile{ID: 2, StoredName: "b.mp3", Status: "pending"}) + if err != nil { + t.Fatalf("pending 素材解析失败: %v", err) + } + if filepath.Base(filepath.Dir(pending)) != "pending" { + t.Errorf("pending 素材路径 = %q，期望落在 pending/ 下", pending) + } + + // 脏记录（含分隔符 / 只有 StoredPath / 两者都空）必须报错，不得拼出目录外的路径。 + if _, err := MediaFilePath(model.MediaFile{ID: 3, StoredName: "../../etc/passwd"}); err == nil { + t.Error("含路径分隔符的 StoredName 没有被拒绝") + } + if _, err := MediaFilePath(model.MediaFile{ID: 4}); err == nil { + t.Error("既无 StoredName 也无 StoredPath 的素材没有被拒绝") + } + fallback, err := MediaFilePath(model.MediaFile{ID: 5, StoredPath: "c.mp3", Status: "approved"}) + if err != nil || filepath.Base(fallback) != "c.mp3" { + t.Errorf("只有 StoredPath 的旧记录没有被兜住: path=%q err=%v", fallback, err) + } +} + +// TestTranscribeBytesRejectsNonAudioRoute 断言：路由指错时直接报错， +// 不会带着 chat 路由去请求 ASR 服务。这是「配错要吵，不要静默」那条规则的单测。 +func TestTranscribeBytesRejectsNonAudioRoute(t *testing.T) { + _, err := TranscribeBytes(1, []byte("not-audio"), "x.mp3", "mp3", "zh", "chat_route_lmuai_deepseek_v4_flash") + if err == nil { + t.Fatal("把 chat 路由当音频路由使用时没有报错") + } + if !strings.Contains(err.Error(), "audio_routes") { + t.Errorf("错误信息没有点明 audio_routes 配错：%v", err) + } + t.Logf("按预期拒绝: %v", err) +} + +// TestRunLLMStepRejectsUnknownKind 断言未知步骤直接报错，不会静默走某套默认提示词。 +func TestRunLLMStepRejectsUnknownKind(t *testing.T) { + if _, err := RunLLMStep(nil, Kind("nope"), "逐字稿", nil); err == nil { + t.Error("未知 kind 没有报错") + } +} + +// TestTranscribeRealNetwork 用真实 ASR 端点做一次端到端转写（含说话人分离）。 +// +// 默认跳过：它打的是第三方付费接口，且会把音频发到公网。需要显式给音频路径才跑： +// +// ASR_TEST_AUDIO=/tmp/asr_two_speakers.mp3 go test ./internal/skills/packages/audio_transcribe/ -run TestTranscribeRealNetwork -v +// +// 音频应当是「两段不同音色」的合成语音，这样才能同时验证转写文本与说话人分离。 +func TestTranscribeRealNetwork(t *testing.T) { + path := os.Getenv("ASR_TEST_AUDIO") + if path == "" { + t.Skip("未设置 ASR_TEST_AUDIO，跳过真实网络转写测试") + } + data, err := os.ReadFile(path) + if err != nil { + t.Fatalf("读取测试音频失败: %v", err) + } + + result, err := TranscribeBytes(1, data, filepath.Base(path), ExtractExt(path), "zh", "") + if err != nil { + t.Fatalf("真实转写失败: %v", err) + } + if strings.TrimSpace(result.Text) == "" { + t.Fatal("转写文本为空") + } + if result.RouteID == "" || result.Model == "" { + t.Errorf("结果没有带路由/模型信息: route=%q model=%q", result.RouteID, result.Model) + } + if !result.HasSpeakers { + t.Errorf("没有识别出说话人（期望两段不同音色被分开）：%+v", result.Segments) + } + if len(result.Segments) < 2 { + t.Errorf("分段数 = %d，期望至少 2 段", len(result.Segments)) + } + speakers := map[string]bool{} + for _, s := range result.Segments { + speakers[s.Speaker] = true + if s.Text == "" { + t.Error("存在空文本的分段") + } + } + if len(speakers) < 2 { + t.Errorf("只识别出 %d 个说话人，期望 2 个", len(speakers)) + } + t.Logf("route=%s model=%s duration=%.2fs 说话人=%v 分段=%d", + result.RouteID, result.Model, result.Duration, speakers, len(result.Segments)) + t.Logf("逐字稿:\n%s", FormatTranscriptWithSpeakers(result)) +} + +// TestCheckCompletionRejectsBudgetExhaustedAndEmpty 是「绝不把半截稿当成品收下」的守卫测试。 +// +// 为什么用纯函数测而不是打一次真实模型：这道判断只依赖 finish_reason、正文和 +// 一个整数，没有任何理由非要连网才能验。 +// +// 这一条钉的是行为本身： +// - finish_reason=length + 半截正文 → **必须报错**（改之前是原样返回、落库成产物） +// - finish_reason=length + 空正文 → 报「预算不够」，不要报那句会把排查引偏的「空正文」 +// - 报错必须带上**路由名与该路由的 max_tokens** —— 这条错误的全部价值就在于 +// 指出「把 max_tokens 提上去」这个动作，不带这两个数字等于没说 +// - finish_reason=stop + 正常正文 → 放行 +// - finish_reason=stop + 空正文 → 报空正文（这不是预算问题，别指错方向） +// +// 「正文写了多少字」那部分由 TestBudgetErrorReportsHowMuchWasWritten 单独验， +// 因为那个数字应当由输入算出来，写死在表里只会变成一处迟早对不上的手抄本。 +func TestCheckCompletionRejectsBudgetExhaustedAndEmpty(t *testing.T) { + cases := []struct { + name string + finishReason string + content string + maxTokens int + wantErr bool + wantInErr []string + wantText string + }{ + { + "预算耗尽且有半截正文", "length", "# 纪要\n## 议题一\n大家讨论了素材审", 4096, + true, []string{"预算不够", "chat_route_test", "4096", "16384"}, "", + }, + { + "预算耗尽且正文为空", "length", "", 4096, + true, []string{"预算不够", "4096"}, "", + }, + { + "length 的大小写与空白不影响判定", " LENGTH ", "半截", 8192, + true, []string{"预算不够", "8192"}, "", + }, + { + "正常结束", "stop", "## 核心结论\n- 周四提测", 4096, + false, nil, "## 核心结论\n- 周四提测", + }, + { + "正常结束但正文只有空白", "stop", " \n\t ", 4096, + true, []string{"空正文"}, "", + }, + { + "没有 finish_reason 时按正文判断", "", "有正文", 4096, + false, nil, "有正文", + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + text, err := checkCompletion(tc.finishReason, tc.content, "chat_route_test", tc.maxTokens) + if tc.wantErr { + if err == nil { + t.Fatalf("没有报错，返回了 %q —— 半截稿会被当成成品落库", text) + } + for _, want := range tc.wantInErr { + if !strings.Contains(err.Error(), want) { + t.Errorf("错误信息里没有 %q，这句话就白报了：%v", want, err) + } + } + return + } + if err != nil { + t.Fatalf("不该报错却报了：%v", err) + } + if text != tc.wantText { + t.Errorf("正文 = %q，期望 %q", text, tc.wantText) + } + }) + } +} + +// TestBudgetErrorReportsHowMuchWasWritten 验「本次正文只写出 N 字」里的 N 是真的。 +// +// 为什么值得单拎一条：这个数字是判断病情的唯一线索 —— 0 字是「思考还没写完、 +// 正文没开始」，1161 字是「写了一半被砍断」，两者的输入长度和处置都不一样。 +// 数字算错比不报还糟，因为它看起来精确。 +func TestBudgetErrorReportsHowMuchWasWritten(t *testing.T) { + // 注释放上一行而不是行尾：中文注释的行尾对齐会被 gofmt 推来推去， + // 每次格式化都产生一串与内容无关的 diff。 + contents := []string{ + // 思考没写完，正文一个字都没有 + "", + // 刚开了个头 + "半截稿", + // 写了大半被砍断 + strings.Repeat("字", 1161), + // 计的是 TrimSpace 之后的长度 —— 落库的就是这一份 + " 两头的空白不算 ", + } + for _, content := range contents { + _, err := checkCompletion("length", content, "chat_route_test", 4096) + if err == nil { + t.Fatalf("正文 %q 触发了截断却没有报错", content) + } + want := fmt.Sprintf("写出 %d 字", len([]rune(strings.TrimSpace(content)))) + if !strings.Contains(err.Error(), want) { + t.Errorf("正文 %d 字，错误里应当出现 %q：%v", + len([]rune(strings.TrimSpace(content))), want, err) + } + } +} + +// TestMultiChunkSettlementIsPerKind 钉住「多块怎么收口」这个按步骤分的决定。 +// +// 为什么值得单独一条：这不是风格问题，是预算算出来的。 +// 结构化稿的输出与输入等长 —— 一份 9000 字的逐字稿按 2500 字切 4 块后， +// 若再让模型把 4 段结果归并成一篇，等于要它一次写 9000 字（≈5000+ token）， +// 而对话路由的 max_tokens 是 4096，必然截断。分段结果本身已经结构化， +// 按序拼起来信息一点不少。 +// 纪要相反：输出远短于输入，归并才是它的价值（跨段去重、按时序排），拼不了。 +// +// 有人要把 joinOnly 改回 false 时，这条会红 —— 请连带把 max_tokens 提上去， +// 否则用户拿到的是断稿（而 checkCompletion 会把它变成一次失败，不是一份残篇）。 +func TestMultiChunkSettlementIsPerKind(t *testing.T) { + structure, err := specFor(KindStructure) + if err != nil { + t.Fatalf("取 structure 文案失败：%v", err) + } + if !structure.joinOnly { + t.Error("structure 应当是 joinOnly：让模型归并等长输出会撞 max_tokens，得到的是断稿") + } + + minutes, err := specFor(KindMinutes) + if err != nil { + t.Fatalf("取 minutes 文案失败：%v", err) + } + if minutes.joinOnly { + t.Error("minutes 不该是 joinOnly：跨段去重和按时序排正是归并的价值，拼起来做不到") + } + if strings.TrimSpace(minutes.mergeRequest) == "" { + t.Error("minutes 走归并，却没有归并提示词") + } +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/zz_chunk_probe_test.go b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/zz_chunk_probe_test.go new file mode 100644 index 0000000..f55124f --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/zz_chunk_probe_test.go @@ -0,0 +1,164 @@ +package audiotranscribe + +import ( + "bytes" + "encoding/json" + "io" + "net/http" + "os" + "strconv" + "strings" + "testing" + "time" + + "eai_agentplatform/backend/internal/config" +) + +// TestZZChunkProbe 复现「11 段里有一段返回没有 choices 的响应」。 +// +// 背景：四步端到端跑到第 3 步（整理）的第 4/11 段时，上游回了一个 HTTP 200、 +// 但报文里没有 choices 的响应，整步就此失败。这个探针不需要 ASR —— 第 3 步的输入 +// 只是文本，用等长的密集中文替身就能复现同样的调用形状（1200 字分块、同样的 +// 系统/指令提示词、同一条路由），连打若干段，看异常出现的频率以及原始报文长什么样。 +// +// 只读响应、不改数据；会真实计费，所以默认跳过： +// +// LLM_CHUNK_PROBE=1 LLM_CHUNK_PROBE_ROUNDS=2 go test ./internal/skills/packages/audio_transcribe/ -run TestZZChunkProbe -v +func TestZZChunkProbe(t *testing.T) { + if os.Getenv("LLM_CHUNK_PROBE") == "" { + t.Skip("未设置 LLM_CHUNK_PROBE，跳过分块探针") + } + + routeID := os.Getenv("LLM_BUDGET_PROBE_ROUTE") + if routeID == "" { + routeID = "audio_transcribe_llm" + } + route, err := config.GetRoute(routeID) + if err != nil || route == nil { + t.Fatalf("取路由 %s 失败: %v", routeID, err) + } + t.Logf("路由 id=%s model=%s max_tokens=%d", route.RouteID, route.Model, route.MaxTokens) + + raw, err := os.ReadFile("../../TOP_CODING_RULES.md") + if err != nil { + t.Fatalf("读取密集中文样本失败: %v", err) + } + dense := []rune(strings.Join(strings.Fields(string(raw)), " ")) + + // 拼到足够长：一次 11 段，跟端到端里真实的段数一致。 + const chunkChars = 1200 + need := chunkChars * 11 + for len(dense) < need { + dense = append(dense, dense...) + } + + spec, err := specFor(KindStructure) + if err != nil { + t.Fatalf("取 structure 文案失败: %v", err) + } + + rounds := 1 + if v := os.Getenv("LLM_CHUNK_PROBE_ROUNDS"); v != "" { + if n, convErr := strconv.Atoi(v); convErr == nil && n > 0 { + rounds = n + } + } + + // 允许从环境变量压一个 max_tokens，用来回答「把上限抬高之后，逐块调用会不会 + // 反而话变多、更慢」—— 上限抬高的唯一代价就在这里，别靠猜。 + maxTokensOverride := 0 + if v := os.Getenv("LLM_CHUNK_PROBE_MAX_TOKENS"); v != "" { + if n, convErr := strconv.Atoi(v); convErr == nil && n > 0 { + maxTokensOverride = n + } + } + if maxTokensOverride > 0 { + route.MaxTokens = maxTokensOverride + t.Logf("已把本次探针的 max_tokens 压成 %d", maxTokensOverride) + } + + anomalies, attempts := 0, 0 + for round := 1; round <= rounds; round++ { + for index := 0; index < 11; index++ { + chunk := string(dense[index*chunkChars : (index+1)*chunkChars]) + attempts++ + if !probeChunk(t, route, spec, index+1, chunk) { + anomalies++ + } + } + } + t.Logf("共 %d 次调用，异常 %d 次", attempts, anomalies) +} + +// probeChunk 打一次「整理某一段」的调用，正常返回 true。 +func probeChunk(t *testing.T, route *config.RouteConfig, spec kindSpec, seq int, chunk string) bool { + t.Helper() + + body := map[string]any{ + "model": route.Model, + "messages": []map[string]string{ + {"role": "system", "content": spec.system}, + {"role": "user", "content": spec.instruction + "\n\n逐字稿：\n" + chunk}, + }, + "stream": false, + "temperature": route.Temperature, + "max_tokens": route.MaxTokens, + } + payload, _ := json.Marshal(body) + + client := &http.Client{Timeout: 180 * time.Second} + req, err := http.NewRequest(http.MethodPost, route.FullURL, bytes.NewReader(payload)) + if err != nil { + t.Fatalf("构造请求失败: %v", err) + } + req.Header.Set("Content-Type", "application/json") + if route.APIKey != "" { + req.Header.Set("Authorization", "Bearer "+route.APIKey) + } + + start := time.Now() + resp, err := client.Do(req) + if err != nil { + t.Logf("第 %d 段 请求失败: %v", seq, err) + return false + } + defer resp.Body.Close() + rawRes, _ := io.ReadAll(resp.Body) + elapsed := time.Since(start).Round(time.Millisecond) + + var out struct { + Choices []struct { + FinishReason string `json:"finish_reason"` + Message struct { + Content string `json:"content"` + ReasoningContent string `json:"reasoning_content"` + } `json:"message"` + } `json:"choices"` + Usage map[string]any `json:"usage"` + } + if err := json.Unmarshal(rawRes, &out); err != nil { + t.Logf("第 %d 段 http=%d 解析失败（原文 %d 字节）：%s", + seq, resp.StatusCode, len(rawRes), truncateRunes(string(rawRes), 300)) + return false + } + if resp.StatusCode != http.StatusOK || len(out.Choices) == 0 { + // 这就是端到端里把整步打挂的那种响应：原始报文必须原样留下来。 + t.Logf("第 %d 段 异常 http=%d 用时=%s choices=%d 原始报文：%s", + seq, resp.StatusCode, elapsed, len(out.Choices), truncateRunes(string(rawRes), 600)) + return false + } + + c := out.Choices[0] + t.Logf("第 %d 段 ok 用时=%s finish=%q 思考=%d字 正文=%d字 usage=%v", + seq, elapsed, c.FinishReason, len([]rune(c.Message.ReasoningContent)), len([]rune(c.Message.Content)), out.Usage) + return strings.TrimSpace(c.Message.Content) != "" +} + +// truncateRunes 按字数截断，用于把原始报文压进一行日志。 +func truncateRunes(s string, n int) string { + r := []rune(s) + if len(r) <= n { + return s + } + return string(r[:n]) + "…" +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/zz_merge_probe_test.go b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/zz_merge_probe_test.go new file mode 100644 index 0000000..6f39e94 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/zz_merge_probe_test.go @@ -0,0 +1,159 @@ +package audiotranscribe + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "net/http" + "os" + "strconv" + "strings" + "testing" + "time" + + "eai_agentplatform/backend/internal/config" +) + +// TestZZMergeBudgetProbe 找出「纪要归并调用」到底需要多大的预算。 +// +// 背景：14 段的长稿跑到纪要的归并时挂掉，finish_reason=length、正文 0 字 —— +// 归并的输入是各段纪要拼接，是全流程最长的一次输入，8192 的预算被思考吃光。 +// +// 要决定的是「往上要预算」还是「改成多级归并」，而这两条路的分岔点只有一个事实： +// 上游到底认不认比 8192 更大的 max_tokens。不认，就只能在调用次数上想办法； +// 认，加预算是最省事也最不容易再坏的做法。 +// +// 会真实计费，默认跳过： +// +// LLM_MERGE_PROBE=1 go test ./internal/skills/packages/audio_transcribe/ -run TestZZMergeBudgetProbe -v -timeout 20m +func TestZZMergeBudgetProbe(t *testing.T) { + if os.Getenv("LLM_MERGE_PROBE") == "" { + t.Skip("未设置 LLM_MERGE_PROBE，跳过归并预算探针") + } + + route, err := config.GetRoute("audio_transcribe_llm") + if err != nil || route == nil { + t.Fatalf("取路由失败: %v", err) + } + t.Logf("路由 id=%s model=%s 配置内的 max_tokens=%d", route.RouteID, route.Model, route.MaxTokens) + + spec, err := specFor(KindMinutes) + if err != nil { + t.Fatalf("取纪要文案失败: %v", err) + } + + raw, err := os.ReadFile("../../TOP_CODING_RULES.md") + if err != nil { + t.Fatalf("读取密集中文样本失败: %v", err) + } + dense := []rune(strings.Join(strings.Fields(string(raw)), " ")) + + // 按「14 段纪要拼接」的量级造输入：每段约 600 字，共 8400 字。 + // 这个大小是失败的现场量级，也是要先解决的那一档。 + partials := make([]string, 0, 14) + for i := 0; i < 14; i++ { + start := (i * 600) % (len(dense) - 600) + partials = append(partials, string(dense[start:start+600])) + } + var merged strings.Builder + merged.WriteString(spec.mergeRequest) + merged.WriteString("\n\n") + for i, partial := range partials { + fmt.Fprintf(&merged, "【第 %d 段】\n", i+1) + merged.WriteString(partial) + merged.WriteString("\n\n") + } + user := merged.String() + t.Logf("归并输入 %d 字", len([]rune(user))) + + // 8192 是失败现场（对照组），其余是「上游认不认更大预算」的问题。 + for _, maxTokens := range []int{8192, 16384, 32768} { + t.Run("max_tokens="+strconv.Itoa(maxTokens), func(t *testing.T) { + call, err := probeRawCall(route, spec.mergeSystem, user, maxTokens) + if err != nil { + t.Logf("请求层面就失败了：%v", err) + return + } + t.Logf("%s", call) + }) + } +} + +// probeRawCall 直接打一次，把原始结果压成一行日志返回。 +// +// 不走 callModel：它会在预算不够时直接报错，而这里恰恰要看「不够时长什么样」 +// 以及「给更多预算上游认不认」，两个问题都要求把响应原样拿回来。 +func probeRawCall(route *config.RouteConfig, system, user string, maxTokens int) (string, error) { + body := map[string]any{ + "model": route.Model, + "messages": []map[string]string{ + {"role": "system", "content": system}, + {"role": "user", "content": user}, + }, + "stream": false, + "temperature": route.Temperature, + "max_tokens": maxTokens, + } + payload, _ := json.Marshal(body) + + client := &http.Client{Timeout: 300 * time.Second} + req, err := http.NewRequest(http.MethodPost, route.FullURL, bytes.NewReader(payload)) + if err != nil { + return "", err + } + req.Header.Set("Content-Type", "application/json") + if route.APIKey != "" { + req.Header.Set("Authorization", "Bearer "+route.APIKey) + } + + start := time.Now() + resp, err := client.Do(req) + if err != nil { + return "", err + } + defer resp.Body.Close() + rawRes, _ := io.ReadAll(resp.Body) + elapsed := time.Since(start).Round(time.Second) + + var out struct { + Error *struct { + Message string `json:"message"` + Type string `json:"type"` + } `json:"error"` + Choices []struct { + FinishReason string `json:"finish_reason"` + Message struct { + Content string `json:"content"` + ReasoningContent string `json:"reasoning_content"` + } `json:"message"` + } `json:"choices"` + Usage map[string]any `json:"usage"` + } + if err := json.Unmarshal(rawRes, &out); err != nil { + return "http=" + strconv.Itoa(resp.StatusCode) + " 解析失败：" + truncateRunes(string(rawRes), 300), nil + } + if out.Error != nil { + return "http=" + strconv.Itoa(resp.StatusCode) + " 上游报错：" + out.Error.Type + " / " + out.Error.Message, nil + } + if resp.StatusCode != http.StatusOK || len(out.Choices) == 0 { + return "http=" + strconv.Itoa(resp.StatusCode) + " 异常报文：" + truncateRunes(string(rawRes), 300), nil + } + + c := out.Choices[0] + return "用时=" + elapsed.String() + + " finish=" + c.FinishReason + + " 思考=" + strconv.Itoa(len([]rune(c.Message.ReasoningContent))) + "字" + + " 正文=" + strconv.Itoa(len([]rune(c.Message.Content))) + "字" + + " usage=" + briefUsage(out.Usage), nil +} + +// briefUsage 把 usage 压成一行；只关心两个 token 数，不关心嵌套细节。 +func briefUsage(m map[string]any) string { + if m == nil { + return "{}" + } + return "prompt=" + fmt.Sprint(m["prompt_tokens"]) + + " completion=" + fmt.Sprint(m["completion_tokens"]) + + " total=" + fmt.Sprint(m["total_tokens"]) +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/zz_step_probe_test.go b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/zz_step_probe_test.go new file mode 100644 index 0000000..f8d9a40 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/skills/packages/audio_transcribe/zz_step_probe_test.go @@ -0,0 +1,106 @@ +package audiotranscribe + +import ( + "context" + "os" + "strings" + "testing" + "time" + + "eai_agentplatform/backend/internal/config" +) + +// TestZZRunLLMStepAtElevenChunks 用真实代码路径跑一遍「长稿」的第 3、4 步。 +// +// 为什么需要它：四步端到端要花钱调 ASR，而它每次都挂在第 3 步 —— 也就是说第 4 步 +// （纪要）**从来没被真正跑到过**，第 3 步也没跑到过 11 段全通。这两步里最可疑的是 +// 纪要的收口：它是 joinOnly=false，11 段各自出稿后还要再打一次**归并**调用， +// 而归并的输入是 11 段结果全文拼接 —— 是整个流程里最长的一次输入，最容易撞预算。 +// +// 这个探针不发 ASR，只拿一篇等长的密集中文当逐字稿，直接调 RunLLMStep， +// 走的就是线上那条路径（分块、callModel、重试、收口全都一样）。 +// +// 会真实计费，所以默认跳过： +// +// LLM_STEP_PROBE=1 go test ./internal/skills/packages/audio_transcribe/ -run TestZZRunLLMStepAtElevenChunks -v -timeout 30m +func TestZZRunLLMStepAtElevenChunks(t *testing.T) { + if os.Getenv("LLM_STEP_PROBE") == "" { + t.Skip("未设置 LLM_STEP_PROBE，跳过长稿步骤探针") + } + + routeID := os.Getenv("LLM_BUDGET_PROBE_ROUTE") + if routeID == "" { + // 与 audio_handlers.go 里的 audioLLMAgentRoute 同一个名字： + // 那个常量在 skillapi 包里，这里够不着，所以直接写字面量。 + routeID = "audio_transcribe_llm" + } + route, err := config.GetRoute(routeID) + if err != nil || route == nil { + t.Fatalf("取路由 %s 失败: %v", routeID, err) + } + t.Logf("路由 id=%s model=%s max_tokens=%d", route.RouteID, route.Model, route.MaxTokens) + + transcript := syntheticTranscript(t) + chunks := ChunkTranscript(transcript, llmChunkChars) + t.Logf("替身逐字稿 %d 字，切成 %d 段", len([]rune(transcript)), len(chunks)) + if len(chunks) != 11 { + t.Logf("注意：段数是 %d 而不是 11，与端到端里的量级不同", len(chunks)) + } + + // 顺序跑两个步骤，且**不因前一个失败就跳过**后一个 —— 它们要分别定性， + // 一个挂了正好说明另一个也得单独看。 + for _, kind := range []Kind{KindStructure, KindMinutes} { + t.Run(string(kind), func(t *testing.T) { + start := time.Now() + out, err := RunLLMStep(context.Background(), kind, transcript, route) + elapsed := time.Since(start).Round(time.Second) + + if err != nil { + t.Fatalf("%s 步骤失败（用时 %s）：%v", kind, elapsed, err) + } + if strings.TrimSpace(out) == "" { + t.Fatalf("%s 步骤返回空正文（用时 %s）—— 落库会变成一个点开什么都没有的产物", kind, elapsed) + } + t.Logf("%s 步骤完成：用时 %s，输出 %d 字", kind, elapsed, len([]rune(out))) + // 头 120 字留个样子，确认它不是一段自我说明或占位文本。 + t.Logf("%s 输出开头：%s", kind, truncateRunes(strings.TrimSpace(out), 120)) + }) + } +} + +// syntheticTranscript 造一份与真实逐字稿同形的长文本：每段一行、带说话人标签， +// 总长约 13000 字（26 分钟会议的量级）。 +// +// 刻意带上说话人与换行，是因为 ChunkTranscript 优先在行边界切 —— 用一整块无换行的 +// 文本测，切法就跟线上不一样了。 +func syntheticTranscript(t *testing.T) string { + t.Helper() + raw, err := os.ReadFile("../../TOP_CODING_RULES.md") + if err != nil { + t.Fatalf("读取密集中文样本失败: %v", err) + } + dense := []rune(strings.Join(strings.Fields(string(raw)), " ")) + + const lineChars = 40 + var b strings.Builder + written, line := 0, 0 + for written < 14000 { + speaker := line%2 + 1 + end := written + lineChars + if end > len(dense) { + end = len(dense) + } + b.WriteString("[说话人") + b.WriteString(string(rune('0' + speaker))) + b.WriteString("] ") + b.WriteString(string(dense[written:end])) + b.WriteString("\n") + written = end + line++ + if written >= len(dense) { + // 样本用完了就从头接，保证长度够。 + written = 0 + } + } + return b.String() +} diff --git a/eai_agentplatform/backend-go/internal/skills/packages/report_generation/report_content.go b/eai_agentplatform/backend-go/internal/skills/packages/report_generation/report_content.go index 33b1f57..46f4b6e 100644 --- a/eai_agentplatform/backend-go/internal/skills/packages/report_generation/report_content.go +++ b/eai_agentplatform/backend-go/internal/skills/packages/report_generation/report_content.go @@ -1,6 +1,7 @@ package reportgeneration import ( + "context" "encoding/json" "fmt" "strings" @@ -94,7 +95,7 @@ func PromptReportWithSections(req ReportGenRequest, knowledge string) []ReportCh ) aiRoute, _ := config.GetRoute("title_gen") - aiContent, err := ai.GenerateWithFallback(aiRoute, []ai.Message{ + aiContent, err := ai.GenerateWithFallback(context.Background(), aiRoute, []ai.Message{ {Role: "system", Content: systemPrompt}, {Role: "user", Content: userPrompt}, }) @@ -130,7 +131,7 @@ func PromptReportAutoChapters(req ReportGenRequest, knowledge string) []ReportCh ) aiRoute, _ := config.GetRoute("title_gen") - aiContent, err := ai.GenerateWithFallback(aiRoute, []ai.Message{ + aiContent, err := ai.GenerateWithFallback(context.Background(), aiRoute, []ai.Message{ {Role: "system", Content: systemPrompt}, {Role: "user", Content: userPrompt}, }) diff --git a/eai_agentplatform/backend-go/internal/specialists/contracts/manifest.go b/eai_agentplatform/backend-go/internal/specialists/contracts/manifest.go index 3f40678..92e970e 100644 --- a/eai_agentplatform/backend-go/internal/specialists/contracts/manifest.go +++ b/eai_agentplatform/backend-go/internal/specialists/contracts/manifest.go @@ -19,6 +19,7 @@ type Manifest struct { Key string Label string RuleFileMarkdown string + InteractionCardJSON string AllowedSkills []string OwnedDefinitionKeys []string OwnedCatalogEntries []string diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/manifest.go b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/manifest.go index 460d595..6fd90d5 100644 --- a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/manifest.go +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/manifest.go @@ -5,6 +5,18 @@ import specialistcontracts "eai_agentplatform/backend/internal/specialists/contr var Manifest = specialistcontracts.Manifest{ Key: "general-assistant", Label: "通用助手", + InteractionCardJSON: `{ + "greeting": "博昇AI数字员工，您说，我做", + "tagline": "复杂任务我来自动拆解、并行执行、联网检索，最后给你合并结果。", + "opening_prompt": "直接告诉我目标，或把材料贴给我。我能拆解任务、联网搜索、路由到合适的专员或技能。", + "relationship_to_user": "你的通用协作专员", + "starter_prompts": [ + "帮我拆解这个任务，并列出下一步", + "上网查一下最新信息并整理成报告", + "把这段产品介绍整理成正式文案", + "先帮我判断这个问题该找哪个专员或技能" + ] +}`, RuleFileMarkdown: `# 通用助手 ## 你是谁 diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/orchestrate.go b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/orchestrate.go new file mode 100644 index 0000000..070fa6b --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/orchestrate.go @@ -0,0 +1,472 @@ +package generalassistant + +import ( + "context" + "encoding/json" + "fmt" + "log" + "strings" + "sync" + "time" + + "eai_agentplatform/backend/internal/ai" + "eai_agentplatform/backend/internal/config" + "eai_agentplatform/backend/internal/model" +) + +// StepArtifact 单个子任务的产物，供合并与前端展示。 +type StepArtifact struct { + Key string `json:"key"` + Title string `json:"title"` + Role string `json:"role"` + Content string `json:"content"` +} + +// Orchestrator 通用助手的多 Agent 编排运行时。 +// +// 工作流： +// 1. 意图判定（intent_judge）：决定直答还是编排； +// 2. 任务拆解（task_planning）：编排型任务由 LLM 动态产出子任务集； +// 3. 多 Worker 执行（execution）：每个子任务挂一个 ai.Agent（可带 web_search）； +// 4. Merge Gate：把各子任务产物收敛为最终回复。 +// +// 相比公众号专员的静态步骤，这里子任务是运行时动态拆解的， +// 是通用助手「编排能力最强」的体现。 +type Orchestrator struct { + routeID string + maxWork int +} + +// NewOrchestrator 创建编排运行时，routeID 为 AI 路由（可为空，默认 path_coach）。 +func NewOrchestrator(routeID string) *Orchestrator { + if routeID == "" { + routeID = "path_coach" + } + return &Orchestrator{routeID: routeID, maxWork: 6} +} + +// Run 编排一次通用对话任务，返回最终回复与各子任务产物。 +// +// taskID > 0 时会把编排子任务产物持久化到 task_artifact，便于审计与后续复用 +// （学习公众号专员「步骤产物落库」的范式）；taskID == 0（纯对话、无挂载任务） +// 则仅返回内存产物，不写库。 +func (o *Orchestrator) Run(ctx context.Context, message string, user *model.User, taskID uint) (string, []StepArtifact, error) { + // 编排整体设一个上限，防止某一环卡住导致整个请求无限挂起。 + // 240s：为「重度搜索型」报告 worker 预留多轮 web_search 攒素材 + 实际撰写的预算； + // 同时配合 executeSubTasks 的 ctx.Done() 硬截止，到点必返回、不阻塞后续请求。 + const overallTimeout = 240 * time.Second + if _, hasDeadline := ctx.Deadline(); !hasDeadline { + var cancel context.CancelFunc + ctx, cancel = context.WithTimeout(ctx, overallTimeout) + defer cancel() + } + + route, err := config.GetRoute(o.routeID) + if err != nil || route == nil { + return "", nil, fmt.Errorf("AI 路由不可用: %w", err) + } + + // 1. 意图判定 + kind, reason, err := o.judgeIntent(ctx, route, message) + if err != nil { + return "", nil, err + } + _ = reason + // 直答：交给普通单轮生成，不做多 Agent 拆解 + if kind == "direct_answer" { + content, err := ai.GenerateWithFallback(ctx, route, []ai.Message{ + {Role: "system", Content: o.systemPrompt()}, + {Role: "user", Content: message}, + }) + if err != nil { + return "", nil, err + } + return content, nil, nil + } + _ = reason + + // 单问联网检索：需要实时信息但只是单一问答，用一个带 web_search 的 Agent 快答， + // 不必走多 Agent 拆解（那会把简单问题拖慢数倍）。 + // 例外：若消息命中 >=2 个编排信号词（多来源交叉 + 多段/多维度报告）， + // 即便 LLM 判成 single_search，也升级为 orchestrated——保住独立的并行 worker、 + // 产物落库与
进度展示（这是通用助手作为编排中枢的核心价值）。 + if kind == "single_search" { + if looksOrchestrated(message) { + kind = "orchestrated" + } else { + agent := ai.NewAgent(route) + agent.RegisterTool(ai.NewWebSearchTool(nil)) + content, err := agent.Run(ctx, []ai.Message{ + {Role: "system", Content: o.singleSearchSystemPrompt()}, + {Role: "user", Content: message}, + }) + if err != nil { + return "", nil, err + } + return content, nil, nil + } + } + + // 2. 任务拆解 + subtasks, err := o.planSubTasks(ctx, route, message) + if err != nil { + log.Printf("[general_assistant] planSubTasks 失败，降级单问：%v", err) + // 拆解失败则退化为「单问联网快答」：仍用带 web_search 的 Agent 出结果， + // 避免退化成无联网的纯文本（那样会丢实时数据与来源）。 + agent := ai.NewAgent(route) + agent.RegisterTool(ai.NewWebSearchTool(nil)) + content, aerr := agent.Run(ctx, []ai.Message{ + {Role: "system", Content: o.singleSearchSystemPrompt()}, + {Role: "user", Content: message}, + }) + if aerr != nil { + return "", nil, aerr + } + return content, nil, nil + } + + // 3. 多 Worker 执行 + artifacts := o.executeSubTasks(ctx, route, message, subtasks, user) + + // 4. Merge Gate 收敛 + finalContent, err := o.merge(ctx, route, message, artifacts) + if err != nil || strings.TrimSpace(finalContent) == "" { + // 合并失败时，回退到拼接子任务产物，至少返回可读内容 + var b strings.Builder + for _, a := range artifacts { + if a.Content == "" { + continue + } + b.WriteString("## " + a.Title + "\n\n" + a.Content + "\n\n") + } + finalContent = strings.TrimSpace(b.String()) + if finalContent == "" { + finalContent = "已按子任务完成，但结果为空，请重试。" + } + } + + // 产物持久化：挂载了任务时落库到 task_artifact，供产物 Tab / 审计复用。 + persistArtifacts(taskID, message, artifacts) + + return finalContent, artifacts, nil +} + +// singleSearchSystemPrompt 单问联网快答的 system prompt。 +// 关键是用显式「收敛约束」防止 deepseek 等模型拿到结果后陷入无限检索却不写结论： +// 明确限制检索次数、强制「检索到足够信息立即作答」、禁止输出任何 XML/标签形式的工具调用。 +func (o *Orchestrator) singleSearchSystemPrompt() string { + return o.systemPrompt() + "\n\n" + + "如需最新数据/天气/新闻/政策，先调用 web_search 检索，标注来源，不编造。\n" + + "收敛要求：\n" + + "1. 最多检索 3 次。检索到足够信息后，必须立即直接用中文撰写最终答案，不得再次发起搜索。\n" + + "2. 若 3 次内无法确认精确数值，如实说明并给出权威来源链接，而不是继续检索或编数。\n" + + "3. 严格禁止在回复正文里输出任何 XML/标签形式的工具调用（如 、<｜｜ …> 等）；" + + "工具调用只能通过标准 function 调用机制发起。" +} + +// systemPrompt 通用助手的基础角色提示。 +func (o *Orchestrator) systemPrompt() string { + return "你是一位专业的AI通用助手，回答简洁直接。可联网检索实时信息，标注出处，不编造数据。" +} + +// judgeIntent 判定任务类型（direct_answer / single_search / orchestrated）。 +// +// 学习公众号专员的「契约驱动」：解析结果先用 spec/02-intent_judge/validator.json +// 校验（kind 是否在枚举内、有无 reason），校验失败则带纠错提示重试一次； +// 仍未通过才降级为 direct_answer，保证不会把非法 kind 带进下游。 +func (o *Orchestrator) judgeIntent(ctx context.Context, route *config.RouteConfig, message string) (string, string, error) { + prompt := `判断下面用户任务属于哪一类。请基于「结构判据」判定，而不是凭感觉。 + +一、先命中这些强规则（满足任一即直接归类）： +- 任务要求「报告」「简报」「综述」「分析」「对比」「多部分」「分别调研」「拆成N个子任务」「产业链（上中下游）」「多方面/多维度」「写一篇XX文章」且产出是结构化多段内容 → orchestrated +- 任务需要联网取多个独立信息源并交叉（市场数据+政策+公司+投资） → orchestrated +- 任务只是单一具体事实问答（一个确切答案，如某时某地某价格某新闻）、即使要联网 → single_search +- 任务不含这些、且无需联网、一句话能答 → direct_answer + +二、兜底：如果拿不准，优先 single_search（快），绝不为了展示多子任务而升 orchestrated。 + +三、快速启发式：消息里出现下面任一「编排信号词」基本就是 orchestrated： +[报告, 简报, 综述, 分析, 对比, 拆解, 分别, 上中下游, 产业链, 多部分, 分多段, 深度, 行业, 市场, 政策, 投资, 龙头, 格局, 趋势] +若这些词数量 >= 2，倾向 orchestrated；若只有 1 个且是单一问答，仍是 single_search。 + +只输出 JSON：{"kind":"direct_answer|single_search|orchestrated","reason":"一句话说明命中的判据"}` + + resolve := func(ctx context.Context, prompt, message string) (string, string, error) { + out, err := ai.GenerateWithFallback(ctx, route, []ai.Message{ + {Role: "system", Content: prompt}, + {Role: "user", Content: message}, + }) + if err != nil { + return "", "", err + } + var j struct { + Kind string `json:"kind"` + Reason string `json:"reason"` + } + if jsonErr := json.Unmarshal([]byte(extractJSON(out)), &j); jsonErr != nil { + return "", "", jsonErr + } + if j.Kind != "orchestrated" && j.Kind != "single_search" { + j.Kind = "direct_answer" + } + return j.Kind, j.Reason, nil + } + + kind, reason, err := resolve(ctx, prompt, message) + if err != nil { + return "", "", err + } + // 契约校验：kind 是否在枚举内、是否有 reason。不合法则带纠错重试一次。 + if invalid := validateIntent(kind, reason); invalid != "" { + corrected := fmt.Sprintf("%s\n上次输出不合法：%s。请核对 kind 只允许 direct_answer|single_search|orchestrated 之一，并补充 reason。", prompt, invalid) + if retryKind, retryReason, rerr := resolve(ctx, corrected, message); rerr == nil { + if rinvalid := validateIntent(retryKind, retryReason); rinvalid == "" { + return retryKind, retryReason, nil + } + } + // 重试仍未通过：降级为直答，避免非法 kind 流入下游。 + return "direct_answer", "意图判定校验失败，已降级为直答", nil + } + return kind, reason, nil +} + +// subtaskPlan 规划器产出的子任务定义。 +type subtaskPlan struct { + Key string `json:"key"` + Title string `json:"title"` + Role string `json:"role"` + Options struct { + UseWebSearch bool `json:"use_web_search"` + } `json:"options"` + Dependencies []string `json:"depends_on"` +} + +// planSubTasks 让 LLM 动态拆解任务为子任务集。 +// +// 拆解结果同样过契约校验（spec/03-task_planning/validator.json：非空、数量上限、 +// role 合法、依赖可解析），不合法则带纠错重试一次，仍失败返回错误交给上层降级直答。 +func (o *Orchestrator) planSubTasks(ctx context.Context, route *config.RouteConfig, message string) ([]subtaskPlan, error) { + prompt := `把下面任务拆成可并行/串行的子任务集，最多 %d 个。role 限 researcher|writer|planner|judge。 +需要联网时 use_web_search=true。 +只输出 JSON：{"subtasks":[{"key":"subtask_1","title":"...","role":"researcher","options":{"use_web_search":true},"depends_on":[]}],"merge_prompt":"..."}` + + resolve := func(ctx context.Context, prompt, message string) ([]subtaskPlan, error) { + out, err := ai.GenerateWithFallback(ctx, route, []ai.Message{ + {Role: "system", Content: prompt}, + {Role: "user", Content: message}, + }) + if err != nil { + return nil, err + } + var j struct { + SubTasks []subtaskPlan `json:"subtasks"` + } + if jsonErr := json.Unmarshal([]byte(extractJSON(out)), &j); jsonErr != nil { + return nil, jsonErr + } + if len(j.SubTasks) == 0 { + return nil, fmt.Errorf("任务拆解产出为空") + } + return j.SubTasks, nil + } + + subtasks, err := resolve(ctx, fmt.Sprintf(prompt, o.maxWork), message) + if err != nil { + return nil, err + } + // 契约校验：非空、数量上限、role 合法、依赖可解析。不合法则带纠错重试一次。 + if invalid := validatePlan(subtasks); invalid != "" { + corrected := fmt.Sprintf("%s\n上次拆解不合法：%s。请修正后重新输出。", fmt.Sprintf(prompt, o.maxWork), invalid) + if retried, rerr := resolve(ctx, corrected, message); rerr == nil { + if rinvalid := validatePlan(retried); rinvalid == "" { + return retried, nil + } + } + return nil, fmt.Errorf("任务拆解校验失败：%s", invalid) + } + return subtasks, nil +} + +// executeSubTasks 执行所有子任务。支持 depends_on 依赖的有界并发池并行调度。 +// +// 学习公众号专员「前置检查 + 依赖满足」的范式：子任务按依赖关系分批执行—— +// 无依赖或依赖已完成的子任务进入当前批次并行执行；依赖尚未完成的子任务 +// 等其依赖产物落库后再进入下一批。避免 worker 在输入（依赖产物）缺失时空跑。 +// 结果仍按 subtasks 原序收集，并行不改变 merge 看到的产物顺序。 +func (o *Orchestrator) executeSubTasks(ctx context.Context, route *config.RouteConfig, message string, subtasks []subtaskPlan, user *model.User) []StepArtifact { + const maxConcurrent = 3 // 避免并发太高把 SearXNG / LLM 打爆 + artifacts := make([]StepArtifact, len(subtasks)) + byKey := map[string]int{} + for i, st := range subtasks { + byKey[st.Key] = i + } + + done := make([]bool, len(subtasks)) // 标记该子任务是否已成功产出 + remaining := make([]int, 0) + for i := range subtasks { + remaining = append(remaining, i) + } + + runOne := func(i int) { + st := subtasks[i] + agent := ai.NewAgent(route) + if st.Options.UseWebSearch { + agent.RegisterTool(ai.NewWebSearchTool(nil)) + } + // 依赖前置检查：把已完成的依赖产物拼进输入，确保 worker 拿到足够上下文。 + inputs := []ai.Message{{Role: "system", Content: workerRolePrompt(st.Role, message, st.Title)}} + if len(st.Dependencies) > 0 { + var depsCtx strings.Builder + for _, d := range st.Dependencies { + if di, ok := byKey[d]; ok && artifacts[di].Content != "" { + depsCtx.WriteString(fmt.Sprintf("【%s】%s\n%s\n\n", artifacts[di].Title, artifacts[di].Role, artifacts[di].Content)) + } + } + if depsCtx.Len() > 0 { + inputs = append(inputs, ai.Message{Role: "user", Content: "以下是已完成的依赖子任务产物，请基于它们继续：\n" + depsCtx.String()}) + } + } + inputs = append(inputs, ai.Message{Role: "user", Content: message}) + + start := time.Now() + content, aerr := agent.Run(ctx, inputs) + latency := int(time.Since(start).Milliseconds()) + if aerr == nil { + content = strings.TrimSpace(content) + } + // 产物为空/失败时的降级兜底：用无工具的纯文本生成再试一次，保证 worker 至少有可拼合内容。 + // （Agent 内部已对空响应做带工具重试 + 无工具降级，这里作为 worker 层的最后一道保险。） + if aerr != nil || strings.TrimSpace(content) == "" { + if fb, ferr := ai.GenerateWithFallback(ctx, route, inputs); ferr == nil && strings.TrimSpace(fb) != "" { + content = strings.TrimSpace(fb) + aerr = nil + } + } + artifacts[i] = StepArtifact{ + Key: st.Key, + Title: st.Title, + Role: st.Role, + Content: content, + } + if aerr == nil && content != "" { + done[i] = true + } + ai.LogCall(ai.LogEntry{ + UserID: userID(user), + UsageKind: ai.UsageKindTextGen, + Provider: route.Provider, + AIRouteID: route.RouteID, + Model: route.Model, + Success: aerr == nil, + ErrorMessage: errString(aerr), + LatencyMs: latency, + }) + } + + // 按依赖分批执行：每批只调度「依赖已满足」的子任务，直到全部完成或无法推进。 + for { + batch := make([]int, 0) + var pending []int + for _, i := range remaining { + ready := true + for _, d := range subtasks[i].Dependencies { + if di, ok := byKey[d]; ok && !done[di] { + ready = false + break + } + } + if ready { + batch = append(batch, i) + } else { + pending = append(pending, i) + } + } + if len(batch) == 0 { + // 依赖无法满足（如循环依赖/依赖失败），把剩余全部纳入最后一批尽力执行。 + if len(pending) == 0 { + break + } + batch = pending + pending = nil + } + + sem := make(chan struct{}, maxConcurrent) + var wg sync.WaitGroup + for _, i := range batch { + wg.Add(1) + go func(i int) { + defer wg.Done() + sem <- struct{}{} + defer func() { <-sem }() + runOne(i) + }(i) + } + // 本批 worker 全部完成，或上层 ctx（编排 150s 兜底）已取消 → 都不再等待慢 worker。 + // 免去被最慢 worker（可能靠一次已发起的慢 HTTP 续命）拖死 wg.Wait()， + // 保证 executeSubTasks 受整体 wall-clock 截止约束，到点返回当前已完成产物。 + doneCh := make(chan struct{}) + go func() { wg.Wait(); close(doneCh) }() + select { + case <-doneCh: + case <-ctx.Done(): + return artifacts + } + + remaining = pending + if len(remaining) == 0 { + break + } + } + return artifacts +} + +// merge 把子任务产物收敛为最终回复。 +func (o *Orchestrator) merge(ctx context.Context, route *config.RouteConfig, message string, artifacts []StepArtifact) (string, error) { + var b strings.Builder + b.WriteString("总任务：" + message + "\n\n子任务产物：\n") + for _, a := range artifacts { + if a.Content == "" { + continue + } + b.WriteString(fmt.Sprintf("【%s】%s\n%s\n\n", a.Title, a.Role, a.Content)) + } + out, err := ai.GenerateWithFallback(ctx, route, []ai.Message{ + {Role: "system", Content: o.systemPrompt() + "\n把上述子任务产物合并成一份连贯、结构清晰的最终回复，标注关键数据的来源。"}, + {Role: "user", Content: b.String()}, + }) + if err != nil { + return "", err + } + return strings.TrimSpace(out), nil +} + +// extractJSON 从 LLM 输出中截取第一个 JSON 对象（去除 markdown 围栏等噪声）。 +func extractJSON(s string) string { + s = strings.TrimSpace(s) + s = strings.TrimPrefix(s, "```json") + s = strings.TrimPrefix(s, "```") + s = strings.TrimSuffix(s, "```") + start := strings.IndexByte(s, '{') + if start < 0 { + return s + } + end := strings.LastIndexByte(s, '}') + if end < start { + return s + } + return s[start : end+1] +} + +func userID(u *model.User) uint { + if u == nil { + return 0 + } + return u.ID +} + +func errString(err error) string { + if err == nil { + return "" + } + return err.Error() +} diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/orchestrate_integration_test.go b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/orchestrate_integration_test.go new file mode 100644 index 0000000..671dd11 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/orchestrate_integration_test.go @@ -0,0 +1,200 @@ +package generalassistant + +import ( + "context" + "fmt" + "os" + "path/filepath" + "strings" + "testing" + "time" +) + +// 三次面向通用专员（general_assistant）的场景级联调测试。 +// +// 覆盖编排入口 Orchestrator.Run 的三条意图路径： +// 1. direct_answer —— 单一常识问答，走单轮直答，不联网不拆解 +// 2. single_search —— 单一实时事实问答，走带 web_search 的单 Agent 快答 +// 3. orchestrated —— 多来源交叉 + 多维度报告，走多 Agent 拆解并行 + Merge Gate +// +// 这是契约驱动的端到端验证，会真实调用 LLM（path_coach → LMUAI) 与搜索 +// （dtsai 主源）。产物按规范落盘到 test/general_assistant// 独立子目录。 + +var ( + // gaTestRoot 项目根 eai_agentplatform/ 下的 test/general_assistant（TestMain 计算绝对路径）。 + gaTestRoot string +) + +// gaTestRunDirs 三个场景各自独立子目录名。 +const ( + gaTestRunDirect = "run_direct_query" + gaTestRunSingle = "run_single_search" + gaTestRunOrchestrated = "run_orchestrated_report" +) + +// TestMain 定位 backend-go 目录并切换工作目录，保证 config/（ai_config.json、 +// ai_secrets.json、search_config.json）在测试进程内可被发现；同时兜底设置 +// SEARCH_CONFIG 指向该目录下的 search_config.json。 +// +// go test 默认把工作目录设为包目录，而 config 的 configDir() 回退逻辑依赖 +// CWD/config，因此在包目录下直接跑会找不到 ai_config.json。这里把 CWD 切到 +// backend-go 再运行，模拟真实进程环境。 +func TestMain(m *testing.M) { + if base := locateBackendGo(); base != "" { + _ = os.Chdir(base) + gaTestRoot = filepath.Join(base, "..", "test", "general_assistant") + if os.Getenv("SEARCH_CONFIG") == "" { + _ = os.Setenv("SEARCH_CONFIG", filepath.Join(base, "config", "search_config.json")) + } + } + if gaTestRoot == "" { + gaTestRoot = "../../../../../test/general_assistant" + } + os.Exit(m.Run()) +} + +// locateBackendGo 从当前工作目录向上探测，找到含 config/ai_config.json 的目录 +// （即 backend-go）；找不到返回空串。 +func locateBackendGo() string { + dir, err := os.Getwd() + if err != nil { + return "" + } + for { + if _, err := os.Stat(filepath.Join(dir, "config", "ai_config.json")); err == nil { + return dir + } + parent := filepath.Dir(dir) + if parent == dir { + return "" + } + dir = parent + } +} + +// TestCoordinatorDirectAnswer · 场景一：直答路径 +// 常识单问，无需联网、无需拆解，应走 index=0 单轮直答返回。 +func TestCoordinatorDirectAnswer(t *testing.T) { + if skipGAEnv(t) { + return + } + q := "请用一句话说明什么是光合作用？" + out, artifacts, err := runCoordinatorOnce(t, q, gaTestRunDirect) + if err != nil { + t.Fatalf("直答失败: %v", err) + } + if len(artifacts) != 0 { + t.Errorf("直答不应产生子任务产物，实际 %d 个", len(artifacts)) + } + if out == "" { + t.Fatal("直答返回为空") + } + // 软断言：直答应顺理成句、非链路错误文案。 + t.Logf("[direct] 返回：%s", truncateGA(out, 160)) +} + +// TestCoordinatorSingleSearch · 场景二：单问联网路径 +// 单一实时事实（汇率），无编排信号词，应走带 web_search 的单 Agent 快答， +// 应能取到实时数据并标注来源，且不产生多子任务产物。 +func TestCoordinatorSingleSearch(t *testing.T) { + if skipGAEnv(t) { + return + } + q := "查询2026年9月25日人民币兑美元的汇率是多少？" + out, artifacts, err := runCoordinatorOnce(t, q, gaTestRunSingle) + if err != nil { + t.Fatalf("单问联网失败: %v", err) + } + if out == "" { + t.Fatal("单问联网返回为空") + } + t.Logf("[single] 产物数=%d；返回：%s", len(artifacts), truncateGA(out, 200)) +} + +// TestCoordinatorOrchestratedReport · 场景三：多 Agent 编排路径 +// 命中多个编排信号词（市场/政策/龙头/格局/趋势/报告/分析）， +// 应被判定为 orchestrated，拆解出多个子任务并行执行，且 Merge Gate 收敛产出连贯报告。 +func TestCoordinatorOrchestratedReport(t *testing.T) { + if skipGAEnv(t) { + return + } + q := "请写一份2026年中国外骨骼机器人行业的市场分析报告，涵盖市场规模、政策支持、龙头格局与投资趋势。" + out, artifacts, err := runCoordinatorOnce(t, q, gaTestRunOrchestrated) + if err != nil { + t.Fatalf("编排失败: %v", err) + } + if out == "" { + t.Fatal("编排返回为空") + } + if len(artifacts) == 0 { + t.Logf("[warn] 编排未产生独立子任务产物（可能判定为 single_search）") + } else { + t.Logf("[orchestrated] 拆解 %d 个子任务；返回：%s", len(artifacts), truncateGA(out, 200)) + for _, a := range artifacts { + t.Logf(" 产物[%s] %s (%s) len=%d", a.Key, a.Title, a.Role, len(a.Content)) + } + } +} + +// runCoordinatorOnce 执行一次编排并落盘产物到独立子目录。 +func runCoordinatorOnce(t *testing.T, query, runDir string) (string, []StepArtifact, error) { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 260*time.Second) + defer cancel() + + start := time.Now() + out, artifacts, err := NewOrchestrator("path_coach").Run(ctx, query, nil, 0) + latency := time.Since(start) + + // 产物落盘：test/general_assistant// + dir := filepath.Join(gaTestRoot, runDir) + _ = os.MkdirAll(dir, 0o755) + writeGAArtifact(t, filepath.Join(dir, "query.txt"), query) + writeGAArtifact(t, filepath.Join(dir, "reply.md"), out) + writeGAArtifact(t, filepath.Join(dir, "meta.txt"), + fmt.Sprintf("latency_ms=%d\nartifacts=%d\nerr=%v\nfinished=%s\n", + latency.Milliseconds(), len(artifacts), err, time.Now().Format(time.RFC3339))) + var artBuf string + for _, a := range artifacts { + artBuf += fmt.Sprintf("## [%s] %s (%s)\n\n%s\n\n", a.Key, a.Title, a.Role, a.Content) + } + if artBuf != "" { + writeGAArtifact(t, filepath.Join(dir, "artifacts.md"), artBuf) + } + t.Logf("%s 完成：latency=%s", runDir, latency.Round(time.Millisecond)) + return out, artifacts, err +} + +func writeGAArtifact(t *testing.T, path, content string) { + t.Helper() + if err := os.WriteFile(path, []byte(content), 0o644); err != nil { + t.Errorf("写产物 %s 失败: %v", path, err) + } +} + +// skipGAEnv 检测联调前置是否齐备（搜索 key + 可发现的 ai_config.json）；缺失即 Skip。 +func skipGAEnv(t *testing.T) bool { + t.Helper() + if os.Getenv("DTS_AI_API_KEY") == "" && os.Getenv("SERPAPI_API_KEY") == "" { + t.Skip("未配置搜索 key，跳过通用专员场景联调") + return true + } + if _, err := os.Stat(filepath.Join("config", "ai_config.json")); err != nil { + t.Skip("未发现 backend-go/config/ai_config.json（未切换到 backend-go 目录），跳过场景联调") + return true + } + if !strings.HasPrefix(filepath.Clean(gaTestRoot), "/") { + if base := locateBackendGo(); base != "" { + gaTestRoot = filepath.Join(base, "..", "test", "general_assistant") + } + } + return false +} + +func truncateGA(s string, n int) string { + r := []rune(s) + if len(r) <= n { + return s + } + return string(r[:n]) + "…" +} diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/persistence.go b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/persistence.go new file mode 100644 index 0000000..ebc8b8d --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/persistence.go @@ -0,0 +1,46 @@ +package generalassistant + +import ( + "log" + + "eai_agentplatform/backend/internal/dal" + "eai_agentplatform/backend/internal/model" +) + +// 产物持久化的常数值：subtask 表示编排型任务的单个子任务产物。 +const ( + gaArtifactTypeSubtask = "general_assistant_subtask" + gaSpecialistKey = "general-assistant" +) + +// persistArtifacts 把编排子任务产物落库到 task_artifact。 +// +// 仅在 taskID > 0（用户把当前对话挂载到了某条事项上）时写入；纯对话无任务 +// （taskID == 0）静默跳过，不打日志噪音。落库失败不影响本次回复正常返回， +// 持久化是「尽力而为」的增强，不应拖垮主链路。 +func persistArtifacts(taskID uint, message string, artifacts []StepArtifact) { + if taskID == 0 { + return + } + repo := dal.TaskArtifactDAO{} + for _, a := range artifacts { + if a.Content == "" { + continue + } + title := a.Title + if title == "" { + title = a.Key + } + ok := repo.Insert(&model.TaskArtifact{ + TaskID: taskID, + SpecialistKey: gaSpecialistKey, + Title: title, + ArtifactType: gaArtifactTypeSubtask, + Status: "done", + ContentText: a.Content, + }) + if !ok { + log.Printf("[general_assistant] 持久化子任务产物失败 task_id=%d key=%s", taskID, a.Key) + } + } +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/persistence_test.go b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/persistence_test.go new file mode 100644 index 0000000..363a450 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/persistence_test.go @@ -0,0 +1,68 @@ +package generalassistant + +import ( + "testing" + + "github.com/glebarez/sqlite" + "gorm.io/gorm" + + "eai_agentplatform/backend/internal/dal" + "eai_agentplatform/backend/internal/model" +) + +// TestPersistArtifacts asserts that orchestration artifacts are written to +// task_artifact when a taskID is supplied, and skipped when taskID == 0. +func TestPersistArtifacts(t *testing.T) { + db, err := gorm.Open(sqlite.Open("file::memory:?cache=shared"), &gorm.Config{}) + if err != nil { + t.Fatalf("open mem db err: %v", err) + } + if err := db.AutoMigrate(&model.TaskArtifact{}); err != nil { + t.Fatalf("migrate err: %v", err) + } + dal.SetDB(db) + t.Cleanup(func() { dal.SetDB(nil) }) + + // 无任务（taskID==0）时应跳过，不产生任何产物。 + persistArtifacts(0, "msg", []StepArtifact{{Key: "s1", Title: "S1", Content: "x"}}) + if got := countArtifacts(t); got != 0 { + t.Fatalf("taskID==0 不应落库，实际 %d 条", got) + } + + // 挂载任务时应为每个非空产物落一条，空产物跳过。 + persistArtifacts(7, "msg", []StepArtifact{ + {Key: "s1", Title: "S1", Content: "内容A"}, + {Key: "s2", Title: "S2", Content: "内容B"}, + {Key: "s3", Title: "S3", Content: ""}, // 空内容应被忽略 + }) + rows := allArtifacts(t) + if len(rows) != 2 { + t.Fatalf("应为 2 条产物（空内容的 s3 应跳过），实际 %d", len(rows)) + } + for _, r := range rows { + if r.TaskID != 7 { + t.Fatalf("task_id 应为 7，实际 %d", r.TaskID) + } + if r.ArtifactType != gaArtifactTypeSubtask { + t.Fatalf("artifact_type 应 %s，实际 %s", gaArtifactTypeSubtask, r.ArtifactType) + } + } +} + +func countArtifacts(t *testing.T) int64 { + t.Helper() + var c int64 + if err := dal.DB.Model(&model.TaskArtifact{}).Count(&c).Error; err != nil { + t.Fatalf("count err: %v", err) + } + return c +} + +func allArtifacts(t *testing.T) []model.TaskArtifact { + t.Helper() + var rows []model.TaskArtifact + if err := dal.DB.Find(&rows).Error; err != nil { + t.Fatalf("find err: %v", err) + } + return rows +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/00-global/identity.json b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/00-global/identity.json new file mode 100644 index 0000000..4c8531d --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/00-global/identity.json @@ -0,0 +1,17 @@ +{ + "description": "通用助手开场白身份。作为开场白下发的单一事实源，前端不再硬编码。", + "version": "1.0.0", + "identity": { + "label": "通用专员", + "meta": "默认专员 · 通用协作", + "greeting": "博昇AI数字员工，您说，我做", + "tagline": "复杂任务我来自动拆解、并行执行、联网检索，最后给你合并结果。", + "opening_prompt": "直接告诉我目标，或把材料贴给我。我能拆解任务、联网搜索、路由到合适的专员或技能。", + "starter_prompts": [ + "帮我拆解这个任务，并列出下一步", + "上网查一下最新信息并整理成报告", + "把这段产品介绍整理成正式文案", + "先帮我判断这个问题该找哪个专员或技能" + ] + } +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/00-global/planner.json b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/00-global/planner.json new file mode 100644 index 0000000..d3a51d9 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/00-global/planner.json @@ -0,0 +1,23 @@ +{ + "description": "规划器配置：通用助手如何把任务动态拆解为子任务集，并对接多 Agent 执行。", + "version": "1.0.0", + "max_subtasks": 6, + "max_agent_rounds": 8, + "available_tools": [ + "web_search" + ], + "available_roles": [ + "researcher", + "writer", + "planner", + "judge" + ], + "aggregation": { + "mode": "merge_gate", + "judge_agent_key": "wxpa_review_judge_agent" + }, + "routing": { + "fallback_kind": "direct_answer", + "fallback_note": "无法拆解为多子任务时，直接单轮作答。" + } +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/01-task_reception/meta.json b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/01-task_reception/meta.json new file mode 100644 index 0000000..3209b5f --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/01-task_reception/meta.json @@ -0,0 +1,10 @@ +{ + "description": "步骤 0：任务接收。空对话时以此步骤下发开场白身份，等待用户输入。", + "version": "1.0.0", + "step_key": "task_reception", + "type": "form", + "prompt_file": "", + "has_validator": false, + "has_fallback": false, + "is_entry_point": true +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/02-intent_judge/meta.json b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/02-intent_judge/meta.json new file mode 100644 index 0000000..756fc9e --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/02-intent_judge/meta.json @@ -0,0 +1,8 @@ +{ + "description": "步骤 1：意图判定。判断任务类型，决定走直答还是编排。", + "version": "1.0.0", + "step_key": "intent_judge", + "prompt_file": "prompt.md", + "has_validator": true, + "has_fallback": true +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/02-intent_judge/prompt.md b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/02-intent_judge/prompt.md new file mode 100644 index 0000000..a1e63a7 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/02-intent_judge/prompt.md @@ -0,0 +1,41 @@ +# Role +你是 `intent_judge` 步骤的判定者，负责判断用户任务的类型，决定用直答、单问联网检索还是多 Agent 编排。 + +# Goal +对用户输入给出一个单值分类（direct_answer / single_search / orchestrated），供后续规划器决定执行路径。 + +# 输入 +- 用户消息：{{message}} + +# 输出要求 +只输出一个 JSON 对象，不要多余文字： +```json +{ + "kind": "direct_answer | single_search | orchestrated", + "reason": "一句话说明判定依据" +} +``` + +# 判定规则（基于结构判据，而非凭感觉） + +## 一、强规则（满足任一即直接归类） +- 任务要求「报告」「简报」「综述」「分析」「对比」「多部分」「分别调研」「拆成 N 个子任务」「产业链（上中下游）」「多方面/多维度」「写一篇 XX 文章」且产出是**结构化多段内容** → `orchestrated` +- 任务需联网取多个独立信息源并交叉（市场数据 + 政策 + 公司 + 投资） → `orchestrated` +- 任务只是单一具体事实问答（一个确切答案，如某时某地某价格某新闻），即使要联网 → `single_search` +- 任务不含以上、且无需联网、一句话能答 → `direct_answer` + +## 二、兜底 +如果拿不准，优先 `single_search`（快），**绝不**为了展示多子任务而升成 `orchestrated`。 + +## 三、编排信号词启发式 +消息里出现以下任一「编排信号词」基本就是 `orchestrated`： +`[报告, 简报, 综述, 分析, 对比, 拆解, 分别, 上中下游, 产业链, 多部分, 分多段, 深度, 行业, 市场, 政策, 投资, 龙头, 格局, 趋势]` +- 这些词数量 ≥ 2 → 倾向 `orchestrated` +- 只有 1 个且是单一问答 → 仍是 `single_search` + +# 优先级 +如上：拿不准走 `single_search`；但明确是**多段报告/多源交叉分析**时，必须走 `orchestrated`。 + +# 约束 +- kind 只能是上述三个枚举之一。 +- 不要臆造用户没提的信息。 \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/02-intent_judge/validator.json b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/02-intent_judge/validator.json new file mode 100644 index 0000000..572a40a --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/02-intent_judge/validator.json @@ -0,0 +1,10 @@ +{ + "description": "意图判定验证规则。", + "version": "1.1.0", + "step_key": "intent_judge", + "checks": [ + "kind_is_enum", + "has_reason" + ], + "enum_values": ["direct_answer", "single_search", "orchestrated"] +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/03-task_planning/meta.json b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/03-task_planning/meta.json new file mode 100644 index 0000000..ed549bb --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/03-task_planning/meta.json @@ -0,0 +1,8 @@ +{ + "description": "步骤 2：任务拆解。LLM 将编排型任务动态拆解为子任务集。", + "version": "1.0.0", + "step_key": "task_planning", + "prompt_file": "prompt.md", + "has_validator": true, + "has_fallback": true +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/03-task_planning/prompt.md b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/03-task_planning/prompt.md new file mode 100644 index 0000000..6e90f34 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/03-task_planning/prompt.md @@ -0,0 +1,37 @@ +# Role +你是 `task_planning` 步骤的规划者，把用户交给通用助手的编排型任务拆成有序子任务集。 + +# Goal +产出结构化子任务计划，交给多 Agent 分步执行并在最后收敛成最终回复。 + +# 输入 +- 用户任务：{{message}} +- 意图判定：{{intent_kind}} +- 可用工具：{{available_tools}} + +# 输出要求 +只输出一个 JSON 对象，不要多余文字： +```json +{ + "subtasks": [ + { + "key": "subtask_1", + "title": "子任务标题", + "role": "researcher | writer | planner | judge", + "options": { "use_web_search": true }, + "depends_on": [] + } + ], + "merge_prompt": "给最终合并器的总括要求（如何把各子任务产物合成一篇连贯输出）" +} +``` + +# 拆解规则 +1. `role` 决定执行该子任务的 Agent 身份；需要实时数据时把 `use_web_search` 置 true。 +2. `depends_on` 用前面的子任务 key，表达顺序依赖；无依赖的并列子任务可并行。 +3. 子任务数量不超过 {{max_subtasks}}。 +4. 子任务产物需要被用户可见，标题要能直接用作展示文案。 + +# 约束 +- subtasks 至少 1 个；为空则该步骤失败。 +- 不要编造与用户任务无关的子任务。 \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/03-task_planning/validator.json b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/03-task_planning/validator.json new file mode 100644 index 0000000..b86f053 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/03-task_planning/validator.json @@ -0,0 +1,14 @@ +{ + "description": "任务拆解验证规则。", + "version": "1.0.0", + "step_key": "task_planning", + "checks": [ + "has_subtasks", + "subtasks_not_empty", + "subtasks_within_limit", + "role_is_enum", + "depends_on_resolvable" + ], + "max_subtasks": 16, + "role_enum": ["researcher", "writer", "planner", "judge"] +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/04-execution/meta.json b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/04-execution/meta.json new file mode 100644 index 0000000..d7091e8 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/04-execution/meta.json @@ -0,0 +1,9 @@ +{ + "description": "步骤 3：多Agent执行。按规划的子任务集并行/顺序执行，最后经 Merge Gate 收敛。", + "version": "1.0.0", + "step_key": "execution", + "type": "agent", + "prompt_file": "prompt.md", + "has_validator": true, + "has_fallback": false +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/04-execution/prompt.md b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/04-execution/prompt.md new file mode 100644 index 0000000..31293e2 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/04-execution/prompt.md @@ -0,0 +1,20 @@ +# Role +你是 `execution` 步骤的汇总裁决者（Merge Gate）。已有多名 worker（researcher/writer/planner）按子任务分别产出结果，你负责把各子任务产物合并成最终交付给用户的连贯回复。 + +# Goal +把子任务结果收敛为一份结构化、可发布的最终回复，并附来源。 + +# 输入 +- 用户任务：{{message}} +- 子任务产物（key -> 内容）：{{subtask_results}} + +# 输出要求 +- 用清晰结构组织各子任务的贡献（Markdown）。 +- 引用具体数据/来源时必须说明出处（来自 web_search 的结果标来源，查不到的标注「据公开资料」或不写）。 +- 语气与用户任务匹配，专业但好懂。 +- 作为最终回复直接输出，不要输出 JSON 包裹，不要输出多余说明。 + +# 约束 +- 不新增子任务声称但其产物不存在的结论。 +- 子任务相互矛盾时，说明取舍依据。 +- 不编造数据。 \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/04-execution/validator.json b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/04-execution/validator.json new file mode 100644 index 0000000..bdadf9c --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/04-execution/validator.json @@ -0,0 +1,9 @@ +{ + "description": "多Agent执行验证规则。", + "version": "1.0.0", + "step_key": "execution", + "checks": [ + "has_output", + "covers_all_subtasks" + ] +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/judge/prompt.md b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/judge/prompt.md new file mode 100644 index 0000000..93b7817 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/judge/prompt.md @@ -0,0 +1,9 @@ +你是「评审」（judge）。 + +# 职责 +- 负责对材料做取舍、评估与下结论：判断哪些信息可靠、哪些是噪音，哪些该保留。 +- 输出带有判断力，不只罗列，而是给出权衡与建议。 + +# 规则（rule） +- 结论须建立在证据之上，区分「事实」「观点」「推测」。 +- 有矛盾或证据不足时，明确指出不确定性，不强行下断言。 \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/planner/prompt.md b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/planner/prompt.md new file mode 100644 index 0000000..7d115e3 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/planner/prompt.md @@ -0,0 +1,10 @@ +你是「规划者」（planner）。 + +# 职责 +- 负责梳理任务的步骤、先后顺序与依赖关系，产出可执行的结构化拆解。 +- 明确哪些子任务可并行、哪些必须串行（存在依赖），并给出合理的执行优先级。 + +# 规则（rule） +- 拆解粒度要均衡：既不过度切分（超过 6 个单点），也不漏掉必要的中间环节。 +- 需要联网取数的环节明确标注 use_web_search=true。 +- 依赖关系（depends_on）必须真实反映逻辑先后，禁止循环依赖。 \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/researcher/prompt.md b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/researcher/prompt.md new file mode 100644 index 0000000..75d3921 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/researcher/prompt.md @@ -0,0 +1,10 @@ +你是「研究员」（researcher）。 + +# 职责 +- 负责联网检索并整理事实、数据、权威来源。 +- 每个关键结论都要给出可追溯的来源（机构名 / 链接 / 发布时间），并在来源相互矛盾或口径不一致时并列标注，不要把单一来源当作定论。 + +# 规则（rule） +- 优先使用 web_search 获取实时数据（政策、市场、财报、新闻、文献），不凭记忆编造数字。 +- 区分「官方口径」与「泛行业口径」，当两个数字对同一指标说法不同时，明确写出两者来源与差额原因。 +- 数据要可核验：金额带单位、时间带年份、占比标口径。 \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/writer/prompt.md b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/writer/prompt.md new file mode 100644 index 0000000..af60207 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/05-workers/writer/prompt.md @@ -0,0 +1,10 @@ +你是「写作者」（writer）。 + +# 职责 +- 负责把结构化材料打磨成清晰、专业、可读的文字。 +- 输出用 markdown 组织：标题（## 小节为一级）、列表（- ）、必要时用表格。 + +# 规则（rule） +- 结构优先：先结论后论据，段落短，避免口号式空话。 +- 语气自洽且专业，不使用浮夸营销词。 +- 引用或转述的数据保留原文来源，不擅自改写事实。 \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/workflow.json b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/workflow.json new file mode 100644 index 0000000..55f44c7 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec/workflow.json @@ -0,0 +1,10 @@ +{ + "description": "通用助手编排骨架。区别于公众号的静态步骤，本工作流以「动态规划」为核心：01 接收任务、02 判定意图、03 由 LLM 动态拆解出子任务集、04 多 Agent 分步执行并在最后收敛。子任务集不在本文件写死，而是由 03 步骤运行时产出并校验。", + "version": "1.0.0", + "steps": [ + { "key": "task_reception", "label": "任务接收", "type": "form", "order": 0, "is_entry_point": true }, + { "key": "intent_judge", "label": "意图判定", "type": "ai", "order": 1, "preconditions": ["task_reception"] }, + { "key": "task_planning", "label": "任务拆解", "type": "ai", "order": 2, "preconditions": ["intent_judge"] }, + { "key": "execution", "label": "多Agent执行", "type": "agent", "order": 3, "preconditions": ["task_planning"] } + ] +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec_driver.go b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec_driver.go new file mode 100644 index 0000000..b984ec7 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec_driver.go @@ -0,0 +1,213 @@ +package generalassistant + +import ( + "embed" + "encoding/json" + "fmt" + "io/fs" + "strings" +) + +// 契约卡片驱动：参考公众号专员（weixin_public_account）「JSON 配置驱动」的范式， +// 通用助手把自己的 spec/ 下的 validator.json / prompt.md 用 go:embed 嵌入， +// 让这些契约文件从「文档」真正变成「规则」，由 Go 代码在运行时执行校验。 +// +// 文件结构（与公众号 spec 对齐）： +// +// spec/ +// ├── 02-intent_judge/validator.json 意图三分类校验规则 +// ├── 03-task_planning/validator.json 子任务拆解校验规则 +// └── 05-workers//prompt.md 每个 worker 角色的专项提示词（承接 exec-workers 细分） +// +//go:embed spec +var specFS embed.FS + +type intentValidator struct { + Checks []string `json:"checks"` + EnumValues []string `json:"enum_values"` +} + +type planValidator struct { + Checks []string `json:"checks"` + MaxSubTasks int `json:"max_subtasks"` + RoleEnum []string `json:"role_enum"` + DependsOnAll []string `json:"depends_on_all"` +} + +// loadIntentValidator 读取 02 意图判定的 validator.json。 +func loadIntentValidator() (*intentValidator, error) { + data, err := specFS.ReadFile("spec/02-intent_judge/validator.json") + if err != nil { + return nil, err + } + var v intentValidator + if err := json.Unmarshal(data, &v); err != nil { + return nil, err + } + return &v, nil +} + +// loadPlanValidator 读取 03 任务拆解的 validator.json。 +func loadPlanValidator() (*planValidator, error) { + data, err := specFS.ReadFile("spec/03-task_planning/validator.json") + if err != nil { + return nil, err + } + var v planValidator + if err := json.Unmarshal(data, &v); err != nil { + return nil, err + } + return &v, nil +} + +// validateIntent 按契约校验意图判定结果，返回校验失败的原因（空串表示通过）。 +func validateIntent(kind, reason string) string { + v, err := loadIntentValidator() + if err != nil { + return "" + } + for _, c := range v.Checks { + switch c { + case "kind_is_enum": + if !contains(v.EnumValues, kind) { + return fmt.Sprintf("kind 必须为 %s 之一，实际为 %q", strings.Join(v.EnumValues, "/"), kind) + } + case "has_reason": + if strings.TrimSpace(reason) == "" { + return "缺少 reason（意图判定依据）" + } + } + } + return "" +} + +// validatePlan 按契约校验任务拆解结果（子任务集），返回校验失败原因（空串表示通过）。 +func validatePlan(subtasks []subtaskPlan) string { + v, err := loadPlanValidator() + if err != nil { + return "" + } + for _, c := range v.Checks { + switch c { + case "has_subtasks", "subtasks_not_empty": + if len(subtasks) == 0 { + return "任务拆解产出的子任务集为空" + } + case "subtasks_within_limit": + if v.MaxSubTasks > 0 && len(subtasks) > v.MaxSubTasks { + return fmt.Sprintf("子任务数量 %d 超过上限 %d", len(subtasks), v.MaxSubTasks) + } + case "role_is_enum": + for _, st := range subtasks { + if !contains(v.RoleEnum, st.Role) { + return fmt.Sprintf("子任务 %q 的 role %q 不在 %s 之列", st.Key, st.Role, strings.Join(v.RoleEnum, "/")) + } + } + case "depends_on_resolvable": + keys := map[string]bool{} + for _, st := range subtasks { + keys[st.Key] = true + } + for _, st := range subtasks { + for _, d := range st.Dependencies { + if d == st.Key { + return fmt.Sprintf("子任务 %q 不能依赖自身", st.Key) + } + if !keys[d] { + return fmt.Sprintf("子任务 %q 依赖不存在的 %q", st.Key, d) + } + } + } + } + } + return "" +} + +// specFilesUnder 列出 spec 下指定子目录的所有文件（小工具，便于后续扩展）。 +func specFilesUnder(dir string) ([]string, error) { + var out []string + err := fs.WalkDir(specFS, dir, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if !d.IsDir() { + out = append(out, path) + } + return nil + }) + return out, err +} + +// workerRolePrompt 按角色加载 spec/05-workers//prompt.md 的专项提示词。 +// 优先读契约文件（订阅公众号「每步独立 prompt」范式）；文件缺失时回退到内置兜底。 +func workerRolePrompt(role, message, title string) string { + prompt := "" + if p, ok := loadWorkerPrompt(role); ok { + prompt = p + } else { + base := map[string]string{ + "researcher": "你是研究员，负责联网检索并整理事实、数据、来源。引用必须标注来源，不编造。", + "writer": "你是写作者，负责产出结构清晰、语气专业的文字。", + "planner": "你是规划者，负责梳理步骤、优先级与依赖。", + "judge": "你是评审，负责评估、取舍与给出结论。", + }[role] + if base == "" { + base = "你是任务执行者，尽力完成任务。" + } + prompt = base + } + // 研究员承担主要联网检索，若无收敛约束，部分模型（如 deepseek-flash）会陷入 + // 无限 web_search 循环而不落笔成文，最终只回显工具标签。统一追加收敛约束： + // 限制检索次数、强制「检索到足够信息立即撰写结论」、禁止输出工具标签正文。 + if role == "researcher" { + prompt += "\n\n# 收敛要求\n" + + "- 单一指标最多检索 2~3 次。检索到足够信息后，必须立即用中文撰写研究结论，不得再次发起搜索。\n" + + "- 检索结果相互矛盾时并列标注来源与口径，而非继续检索。确实无法确认的，如实写明并给出权威官方入口，绝不编造。\n" + + "- 严格禁止在回复正文里输出任何 XML/标签形式的工具调用（如 、<｜｜ …> 等），工具调用只能通过标准 function 调用机制发起。" + } + return fmt.Sprintf("%s\n# 子任务：%s\n# 总任务：%s", prompt, title, message) +} + +// loadWorkerPrompt 读取某个角色在 spec/05-workers/ 下的专项 prompt.md。 +func loadWorkerPrompt(role string) (string, bool) { + path := fmt.Sprintf("spec/05-workers/%s/prompt.md", role) + data, err := specFS.ReadFile(path) + if err != nil { + return "", false + } + if prompt := strings.TrimSpace(string(data)); prompt != "" { + return prompt, true + } + return "", false +} + +func contains(list []string, s string) bool { + for _, x := range list { + if x == s { + return true + } + } + return false +} + +// orchestrationSignalWords 判定「编排型任务」的强信号词（与 spec/02-intent_judge/prompt.md 对齐）。 +// 命中 >=2 个视为需要多 Agent 编排：多来源交叉 + 多段/多维度产出的任务。 +var orchestrationSignalWords = []string{ + "报告", "简报", "综述", "分析", "对比", "拆解", "分别", "上中下游", + "产业链", "多部分", "分多段", "深度", "行业", "市场", "政策", "投资", + "龙头", "格局", "趋势", +} + +// looksOrchestrated 用信号词计数做确定性判定：消息里命中 >=2 个编排信号词， +// 且不是单一事实问答时，视为需要多 Agent 编排。这是对 LLM 意图判定的一个 +// Go 侧硬兜底——避免模型在「多来源交叉 + 多段报告」这类任务上过度降级成 +// single_search（那会丢掉独立的并行 worker、产物落库与进度展示）。 +func looksOrchestrated(message string) bool { + count := 0 + for _, w := range orchestrationSignalWords { + if strings.Contains(message, w) { + count++ + } + } + return count >= 2 +} diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec_driver_test.go b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec_driver_test.go new file mode 100644 index 0000000..b853ac8 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/general_assistant/spec_driver_test.go @@ -0,0 +1,23 @@ +package generalassistant + +import "testing" + +func TestLooksOrchestrated(t *testing.T) { + cases := []struct { + msg string + want bool + }{ + {"帮我写一份2026年中国人形机器人行业深度分析报告，拆解产业链上中下游并分别调研，覆盖市场、政策、投资与龙头格局", true}, // 大量信号词 + {"分析低空经济产业链上中下游的投资趋势", true}, // 产业链+上中下游+趋势 >=2 + {"对比一下小米和华为的智能家居产品", false}, // 仅 1 个信号词(对比)<2 → 不编排 + {"分别对比小米、华为、苹果的智能家居产品并给出行业趋势", true}, // 分别+对比+趋势 >=2 + {"今天上海的天气怎么样？", false}, // 单一事实问答 + {"帮我搜索一下牛来这个电影", false}, // 单一搜索，无编排信号词 + {"你好", false}, // 闲聊 + } + for _, c := range cases { + if got := looksOrchestrated(c.msg); got != c.want { + t.Errorf("looksOrchestrated(%q) = %v, want %v", c.msg, got, c.want) + } + } +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/weixin_public_account/api/weixin_public_account_agent_content.go b/eai_agentplatform/backend-go/internal/specialists/packages/weixin_public_account/api/weixin_public_account_agent_content.go new file mode 100644 index 0000000..264f815 --- /dev/null +++ b/eai_agentplatform/backend-go/internal/specialists/packages/weixin_public_account/api/weixin_public_account_agent_content.go @@ -0,0 +1,82 @@ +package weixinpublicaccountapi + +import ( + "context" + "fmt" + "strings" + "time" + + "eai_agentplatform/backend/internal/ai" + "eai_agentplatform/backend/internal/config" + "eai_agentplatform/backend/internal/model" +) + +// tryGenerateWeixinPublicAccountContentWithAgent 用带「联网搜索」工具的 Agent 生成正文。 +// +// 相比 generateWeixinPublicAccountText 的纯文本生成，本函数让 LLM 能按需调用 +// web_search 检索最新行业数据与案例，避免空写或编造数据。工具执行失败不影响 +// 整段生成：Agent 内部会把工具错误作为 tool 消息回填，模型可基于已有认知继续， +// 最终仍返回一段正文。 +func tryGenerateWeixinPublicAccountContentWithAgent(form weixinPublicAccountForm, title, outline string, user *model.User) (string, bool) { + if user == nil || user.AiPoints <= 0 { + return "", false + } + aiRoute, err := config.GetRoute("title_gen") + if err != nil { + return "", false + } + + prompt := buildWeixinPublicAccountAgentContentPrompt(form, title, outline) + messages := []ai.Message{ + {Role: "system", Content: "你是一位严谨的公众号行业编辑。写作前，请先调用 web_search 工具检索与主题相关的最新数据、报告、政策或案例（可用中文与英文关键词各搜一次）。正文中引用的具体数字、政策或案例必须来自搜索结果并标注来源，查不到的信息不要编造，可用『根据公开资料』等稳妥表述。直接输出一篇可发布的中文正文草稿，不要输出多余说明。"}, + {Role: "user", Content: prompt}, + } + + agent := ai.NewAgent(aiRoute) + agent.RegisterTool(ai.NewWebSearchTool(nil)) + + start := time.Now() + content, err := agent.Run(context.Background(), messages) + latency := int(time.Since(start).Milliseconds()) + if err != nil { + ai.LogCall(ai.LogEntry{ + UserID: user.ID, + UsageKind: ai.UsageKindTextGen, + Provider: aiRoute.Provider, + AIRouteID: aiRoute.RouteID, + Model: aiRoute.Model, + Success: false, + ErrorMessage: strings.TrimSpace(err.Error()), + LatencyMs: latency, + }) + return "", false + } + content = strings.TrimSpace(content) + if content == "" { + return "", false + } + ai.LogCall(ai.LogEntry{ + UserID: user.ID, + UsageKind: ai.UsageKindTextGen, + Provider: aiRoute.Provider, + AIRouteID: aiRoute.RouteID, + Model: aiRoute.Model, + Success: true, + LatencyMs: latency, + }) + return content, true +} + +// buildWeixinPublicAccountAgentContentPrompt 组装带搜索引导的正文创作提示词。 +func buildWeixinPublicAccountAgentContentPrompt(form weixinPublicAccountForm, title, outline string) string { + return fmt.Sprintf( + "请写一篇可发布的公众号中文正文。\n标题：%s\n受众：%s\n目标：%s\n语气：%s\n提纲：\n%s\n额外要求：%s\n正文字数：约%d字。\n重点：正文需包含至少 2 处来自搜索结果的真实数据/案例并标注来源，不要编造。", + title, + firstNonEmpty(form.Audience, "公众号读者"), + firstNonEmpty(form.Goal, "科普与传播"), + firstNonEmpty(form.Tone, "专业但好懂"), + outline, + firstNonEmpty(form.Requirements, "无"), + normalizeWeixinPublicAccountContentTargetWords(form.ContentTargetWords), + ) +} \ No newline at end of file diff --git a/eai_agentplatform/backend-go/internal/specialists/packages/weixin_public_account/api/weixin_public_account_workflow.go b/eai_agentplatform/backend-go/internal/specialists/packages/weixin_public_account/api/weixin_public_account_workflow.go index c809515..21cf125 100644 --- a/eai_agentplatform/backend-go/internal/specialists/packages/weixin_public_account/api/weixin_public_account_workflow.go +++ b/eai_agentplatform/backend-go/internal/specialists/packages/weixin_public_account/api/weixin_public_account_workflow.go @@ -2,9 +2,10 @@ package weixinpublicaccountapi import ( "bytes" + "context" "encoding/json" "fmt" - "net/http" + "net/http" "sort" "strings" "time" @@ -1308,7 +1309,11 @@ func executeWeixinPublicAccountOutlineStep(workflow *weixinPublicAccountWorkflow func executeWeixinPublicAccountContentStep(workflow *weixinPublicAccountWorkflowState, article *weixinpublicaccountmodel.WeixinPublicAccountArticle, user *model.User, now time.Time) weixinPublicAccountStepExecution { content := buildWeixinPublicAccountContent(workflow.Form, workflow.Shared.SelectedTitle, workflow.Shared.Outline) - aiContent, ok := tryGenerateWeixinPublicAccountContentWithAI(workflow.Form, workflow.Shared.SelectedTitle, workflow.Shared.Outline, user) + // 优先用带「联网搜索」的 Agent 生成正文，让 LLM 主动检索真实数据/案例；失败再回退到纯文本生成。 + aiContent, ok := tryGenerateWeixinPublicAccountContentWithAgent(workflow.Form, workflow.Shared.SelectedTitle, workflow.Shared.Outline, user) + if !ok { + aiContent, ok = tryGenerateWeixinPublicAccountContentWithAI(workflow.Form, workflow.Shared.SelectedTitle, workflow.Shared.Outline, user) + } if ok { content = aiContent } @@ -1323,7 +1328,7 @@ func executeWeixinPublicAccountContentStep(workflow *weixinPublicAccountWorkflow "outline": workflow.Shared.Outline, } return weixinPublicAccountStepExecution{ - Summary: "正文草稿已生成，可继续补齐配图、预览与分页。", + Summary: "正文草稿已生成（优先基于联网检索的真实数据），可继续补齐配图、预览与分页。", TaskStatus: taskStatusInProgress, ArtifactTitle: firstNonEmpty(workflow.Shared.SelectedTitle, "公众号文章草稿"), ArtifactType: "article", @@ -1535,7 +1540,7 @@ func generateWeixinPublicAccountText(prompt string, user *model.User) (string, b return "", false } start := time.Now() - result, usedAiRoute, err := ai.GenerateFullWithFallback(aiRoute, []ai.Message{ + result, usedAiRoute, err := ai.GenerateFullWithFallback(context.Background(), aiRoute, []ai.Message{ {Role: "system", Content: "你是一个擅长公众号内容策划与创作的中文编辑助手，请直接给出结果，不要输出多余说明。"}, {Role: "user", Content: prompt}, }) diff --git a/eai_agentplatform/backend-go/internal/specialists/runtime/task_runtime.go b/eai_agentplatform/backend-go/internal/specialists/runtime/task_runtime.go index 16a4ee9..43de3b8 100644 --- a/eai_agentplatform/backend-go/internal/specialists/runtime/task_runtime.go +++ b/eai_agentplatform/backend-go/internal/specialists/runtime/task_runtime.go @@ -316,7 +316,7 @@ func executeAIStep(task model.TaskRecord, specialist specialistmodel.Specialist, } start := time.Now() - result, usedAiRoute, err := ai.GenerateFullWithFallback(aiRoute, aiMessages) + result, usedAiRoute, err := ai.GenerateFullWithFallback(context.Background(), aiRoute, aiMessages) if err != nil { ai.LogCall(ai.LogEntry{ UserID: user.ID, diff --git a/eai_agentplatform/backend-go/internal/specialists/seeding/seed_specialists.go b/eai_agentplatform/backend-go/internal/specialists/seeding/seed_specialists.go index bbca89a..0c0070d 100644 --- a/eai_agentplatform/backend-go/internal/specialists/seeding/seed_specialists.go +++ b/eai_agentplatform/backend-go/internal/specialists/seeding/seed_specialists.go @@ -10,6 +10,7 @@ import ( specialistcore "eai_agentplatform/backend/internal/specialists/core" specialistmodel "eai_agentplatform/backend/internal/specialists/model" + generalassistant "eai_agentplatform/backend/internal/specialists/packages/general_assistant" weixinpublicaccount "eai_agentplatform/backend/internal/specialists/packages/weixin_public_account" specialistruntime "eai_agentplatform/backend/internal/specialists/runtime" "eai_agentplatform/backend/internal/store" @@ -33,6 +34,7 @@ func SeedSpecialists(db *gorm.DB) error { SpecialistMode: "dw", ObjectEntryRoute: "/home", Summary: "还没指定专员的任务默认落在这里，用输入框的 + 挂上专员或工具", + InteractionCardJSON: generalassistant.Manifest.InteractionCardJSON, Stage: "待处理", Color: "#409eff", MarketTag: "内置", diff --git a/eai_agentplatform/backend-go/internal/store/db.go b/eai_agentplatform/backend-go/internal/store/db.go index cae8860..c8bb1ac 100644 --- a/eai_agentplatform/backend-go/internal/store/db.go +++ b/eai_agentplatform/backend-go/internal/store/db.go @@ -55,6 +55,8 @@ func Init(dbPath string) (*gorm.DB, error) { &model.Course{}, &model.MediaFile{}, &model.KnowledgeSpace{}, + &model.NetdiskFolder{}, + &model.NetdiskFile{}, &model.KnowledgeFAQ{}, &model.KnowledgeChunk{}, &model.Question{}, diff --git a/eai_agentplatform/frontend/src/api/audioSkill.js b/eai_agentplatform/frontend/src/api/audioSkill.js new file mode 100644 index 0000000..cb5aee6 --- /dev/null +++ b/eai_agentplatform/frontend/src/api/audioSkill.js @@ -0,0 +1,43 @@ +import http from './http' + +// 语音转写技能的四步，一步一个端点。 +// +// 为什么不复用 /skills/office/execute：office 的那条链路是纯前端产物构造器 +// （后端不发网络请求），而转写必须真的调 ASR 和 LLM。 +// +// 超时必须逐条覆盖 http 实例的 30s 默认值，否则一小时录音的转写会被前端自己掐断： +// axios 的 timeout 是客户端行为，改 nginx 也没用。 +// +// ⚠️ structure / minutes 的超时**是当前整套流程真正的长度上限**，不是随手填的。 +// 这两步要让模型逐块加工逐字稿（每块 1200 字），endpoint 是同步的，前端只能干等。 +// 一次真实的 26:41 录音（11936 字逐字稿 → 10 块）实测： +// +// 第 1+2 步（确认范围 + 云端 ASR） ≤57s +// 第 3+4 步（两次逐块加工 + 一次归并） 532s，其中**至少一步 ≥266s** +// 全程 589.54s +// +// 也就是说原来的 5 分钟上限，在这份录音上已经被吃到 ≥89% —— 余量不足以覆盖 +// 上游那点正常波动（真实内容比合成稿慢约 1.4 倍），某次稍慢就会被前端自己掐断， +// 而后端还在跑、产物也已经落库，用户看到的却是失败。故放宽到 10 分钟。 +// +// 这只是把悬崖往后挪，不是把悬崖填平：**再长的音频应当走异步** +// （见 TOP_CODING_RULES.md G12），而不是继续往上抬 axios 超时。 +// 10 分钟大约够 50 分钟音频；超过就该改成「提交任务 + 轮询进度」。 +const AUDIO_STEPS = { + scope: { url: '/skills/audio/scope', timeout: 60 * 1000 }, + transcribe: { url: '/skills/audio/transcribe', timeout: 15 * 60 * 1000 }, + // 第 3 步只推断身份，输出一小段 JSON，几十秒的量级；不需要给到分钟级。 + speakers: { url: '/skills/audio/speakers', timeout: 5 * 60 * 1000 }, + // 第 4 步是**用户自己点的那一下**，没有模型调用，只写一条留痕。 + // 超时给到 60s 是给慢网络留的，不是给计算留的。 + 'speakers-confirm': { url: '/skills/audio/speakers/confirm', timeout: 60 * 1000 }, + structure: { url: '/skills/audio/structure', timeout: 10 * 60 * 1000 }, + minutes: { url: '/skills/audio/minutes', timeout: 10 * 60 * 1000 }, +} + +/** 执行一步。step 不在表里就直接抛，不悄悄发到别的端点。 */ +export function runAudioSkillStep(step, data) { + const target = AUDIO_STEPS[step] + if (!target) throw new Error(`未知的语音转写步骤：${step}`) + return http.post(target.url, data, { timeout: target.timeout }) +} diff --git a/eai_agentplatform/frontend/src/api/netdisk.js b/eai_agentplatform/frontend/src/api/netdisk.js new file mode 100644 index 0000000..f239591 --- /dev/null +++ b/eai_agentplatform/frontend/src/api/netdisk.js @@ -0,0 +1,83 @@ +import http from './http' + +// ── 目录 ── +export function listFolders() { + return http.get('/netdisk/folders') +} + +export function createFolder(data) { + return http.post('/netdisk/folders', data) +} + +export function patchFolder(id, data) { + return http.patch(`/netdisk/folders/${id}`, data) +} + +export function deleteFolder(id) { + return http.delete(`/netdisk/folders/${id}`) +} + +// ── 文件 ── +export function listFiles(params) { + return http.get('/netdisk/files', { params }) +} + +export function uploadNetdiskFile(file, folderPath, extra = {}) { + const formData = new FormData() + formData.append('file', file) + formData.append('folder_path', folderPath) + Object.entries(extra).forEach(([k, v]) => { + if (v === undefined || v === null || v === '') return + formData.append(k, v) + }) + return http.post('/netdisk/upload', formData, { + headers: { 'Content-Type': 'multipart/form-data' }, + }) +} + +export function previewFile(id) { + return http.get(`/netdisk/files/${id}/preview`) +} + +export function renameFile(id, filename) { + return http.put(`/netdisk/files/${id}/rename`, { filename }) +} + +export function moveFile(id, folderPath) { + return http.put(`/netdisk/files/${id}/move`, { folder_path: folderPath }) +} + +export function recycleFile(id) { + return http.delete(`/netdisk/files/${id}`) +} + +// ── 回收站 ── +export function listRecycle() { + return http.get('/netdisk/recycle') +} + +export function restoreFile(id) { + return http.post(`/netdisk/recycle/${id}/restore`) +} + +export function purgeFile(id) { + return http.delete(`/netdisk/recycle/${id}`) +} + +// ── 审批（管理员）── +export function auditNetdiskList(params) { + return http.get('/netdisk/audit-list', { params }) +} + +export function auditNetdiskFile(id, data) { + return http.post(`/netdisk/audit/${id}`, data) +} + +// 下载链接（需登录态，走 blob 更稳） +export function downloadUrl(id) { + return `/api/netdisk/files/${id}/download` +} + +export function previewUrl(storedName) { + return `/netdisk-file/${storedName}` +} \ No newline at end of file diff --git a/eai_agentplatform/frontend/src/api/system.js b/eai_agentplatform/frontend/src/api/system.js index ade1947..784e8a8 100644 --- a/eai_agentplatform/frontend/src/api/system.js +++ b/eai_agentplatform/frontend/src/api/system.js @@ -36,6 +36,12 @@ export function listAiEmbedRoutes() { return http.get('/ai/routes/embed') } +// 语音转写（ASR）路由。与 chat/embed 同形，多一个 is_local 字段标明 +// 音频会不会出网（判据是 base_url 是否回环，见后端 config.IsLocalRoute）。 +export function listAiAudioRoutes() { + return http.get('/ai/routes/audio') +} + // —— 管理员统计 —— export function getDashboard() { return http.get('/system/dashboard') diff --git a/eai_agentplatform/frontend/src/components/chat/AudioSpeakerConfirmCard.vue b/eai_agentplatform/frontend/src/components/chat/AudioSpeakerConfirmCard.vue new file mode 100644 index 0000000..3c50d92 --- /dev/null +++ b/eai_agentplatform/frontend/src/components/chat/AudioSpeakerConfirmCard.vue @@ -0,0 +1,227 @@ + + + + + diff --git a/eai_agentplatform/frontend/src/components/chat/CurrentObjectChip.vue b/eai_agentplatform/frontend/src/components/chat/CurrentObjectChip.vue index aca212f..b9d6f3a 100644 --- a/eai_agentplatform/frontend/src/components/chat/CurrentObjectChip.vue +++ b/eai_agentplatform/frontend/src/components/chat/CurrentObjectChip.vue @@ -61,9 +61,15 @@ const isGeneralAssistant = computed(() => { }) const kind = computed(() => { - if (isGeneralAssistant.value) return 'specialist' const focusedKind = currentFocusedObjectKind.value + // 明确聚焦的技能要排在「通用专员」之前判断。 + // + // 通用专员里可以挂技能，挂上之后用户当前操作的其实是那个技能 —— 右栏已经 + // 显示成「语音转写 · 技能工作流」了，这里若还因为 isGeneralAssistant 抢先 + // 返回 'specialist'，同一屏上就会出现「我到底在用什么」的自相矛盾： + // 右栏说语音转写，这个标签说通用专员。 if (focusedKind === 'skill' && skillEntry.value) return 'skill' + if (isGeneralAssistant.value) return 'specialist' if (focusedKind === 'specialist') { const key = currentSpecialistKey.value if (key && key !== GENERAL_ASSISTANT_KEY) return 'specialist' diff --git a/eai_agentplatform/frontend/src/components/chat/NetdiskFilePickerDialog.vue b/eai_agentplatform/frontend/src/components/chat/NetdiskFilePickerDialog.vue new file mode 100644 index 0000000..b11203e --- /dev/null +++ b/eai_agentplatform/frontend/src/components/chat/NetdiskFilePickerDialog.vue @@ -0,0 +1,274 @@ + + + + + \ No newline at end of file diff --git a/eai_agentplatform/frontend/src/components/chat/PlusMenu.vue b/eai_agentplatform/frontend/src/components/chat/PlusMenu.vue index a2450f7..783f18f 100644 --- a/eai_agentplatform/frontend/src/components/chat/PlusMenu.vue +++ b/eai_agentplatform/frontend/src/components/chat/PlusMenu.vue @@ -30,10 +30,11 @@
+ + + + + + + + \ No newline at end of file diff --git a/eai_agentplatform/frontend/src/views/system/AiAdminPage.vue b/eai_agentplatform/frontend/src/views/system/AiAdminPage.vue index 0c62db9..93feacd 100644 --- a/eai_agentplatform/frontend/src/views/system/AiAdminPage.vue +++ b/eai_agentplatform/frontend/src/views/system/AiAdminPage.vue @@ -83,6 +83,22 @@ +
语音
+ + + + +
+ 音频转写走哪条路。默认「自动」＝优先本机（音频不出网）， + 本机服务不可用时才回退云端；回退时转写产物里会标注「音频已出网」。 +
+ +
图片
@@ -132,6 +148,20 @@ /> + + + + +
+ 出厂指向「本地」。当「语音转写」选的是「自动」时， + 这里指向的那条会在健康的前提下优先胜出 —— 这就是「优先本地」的开关。 +
+ @@ -289,6 +319,7 @@ 对话 Embedding 生图 + 语音 路由
+ +
+ 语音测试用一段 1 秒静音样本打真实转写接口，验的是终点、鉴权与返回结构； + 静音转出空文本属预期，不代表路由不可用。转写质量请用真实录音跑一次「语音转写」技能。 +
({ data: { routes: [] } })), listAiEmbedRoutes().catch(() => ({ data: { routes: [] } })), + listAiAudioRoutes().catch(() => ({ data: { routes: [] } })), ]) const cfg = cfgRes.data || {} aiConfig.agent_routes = { ...(cfg.agent_routes || {}) } aiConfig.default_route = cfg.default_route || '' aiConfig.default_embed_route = cfg.default_embed_route || '' + aiConfig.default_audio_route = cfg.default_audio_route || '' aiConfigText.value = JSON.stringify(cfg, null, 2) secrets.value = secretRes.data?.providers || {} aiChatRoutes.value = chatRes.data?.routes || [] aiEmbedRoutes.value = embedRes.data?.routes || [] + aiAudioRoutes.value = audioRes.data?.routes || [] } catch (e) { secrets.value = {} aiChatRoutes.value = [] aiEmbedRoutes.value = [] + aiAudioRoutes.value = [] } finally { routeLoading.value = false syncTestRoutes() @@ -560,6 +603,7 @@ async function saveAi() { config.agent_routes = { ...(config.agent_routes || {}), ...aiConfig.agent_routes } config.default_route = aiConfig.default_route config.default_embed_route = aiConfig.default_embed_route + config.default_audio_route = aiConfig.default_audio_route await putAiConfig(config) aiConfigText.value = JSON.stringify(config, null, 2) ElMessage.success('AI 配置已保存并热生效') @@ -644,6 +688,8 @@ function onTestKindChange() { testRouteOptions.value = aiChatRoutes.value || [] } else if (testKind.value === 'embed') { testRouteOptions.value = aiEmbedRoutes.value || [] + } else if (testKind.value === 'audio') { + testRouteOptions.value = aiAudioRoutes.value || [] } else { testRouteOptions.value = imageTestRoutesFromConfig() } @@ -750,7 +796,7 @@ function applyModel(row) { if (!selectedRouteId.value || !row || row.status !== 'ok') return try { const cfg = JSON.parse(aiConfigText.value) - const key = testKind.value === 'image' ? 'image_routes' : testKind.value === 'embed' ? 'embed_routes' : 'chat_routes' + const key = testKind.value === 'image' ? 'image_routes' : testKind.value === 'embed' ? 'embed_routes' : testKind.value === 'audio' ? 'audio_routes' : 'chat_routes' const routes = cfg[key] if (!routes || !routes[selectedRouteId.value] || Array.isArray(routes[selectedRouteId.value])) { ElMessage.error('未在配置中找到该路由，无法写回 model') @@ -765,10 +811,11 @@ function applyModel(row) { } } -// 同步通路测试路由选项（加载 chat/embed 路由后调用） +// 同步通路测试路由选项（加载 chat/embed/audio 路由后调用） function syncTestRoutes() { if (testKind.value === 'chat') testRouteOptions.value = aiChatRoutes.value || [] else if (testKind.value === 'embed') testRouteOptions.value = aiEmbedRoutes.value || [] + else if (testKind.value === 'audio') testRouteOptions.value = aiAudioRoutes.value || [] } async function loadCharts() { @@ -930,6 +977,15 @@ onMounted(() => { padding: 4px 0 0 0; } +/* 下拉框下面的说明行。用 el-form-item 的默认行距会把提示推得离控件很远， + 这里紧贴控件下方。 */ +.route-hint { + font-size: 12px; + line-height: 1.6; + color: #909399; + margin-top: 4px; +} + .test-pagination { display: flex; justify-content: flex-end; diff --git a/eai_agentplatform/frontend/src/views/workbench/SmartAssistantPage.vue b/eai_agentplatform/frontend/src/views/workbench/SmartAssistantPage.vue index 31a80ce..78c44be 100644 --- a/eai_agentplatform/frontend/src/views/workbench/SmartAssistantPage.vue +++ b/eai_agentplatform/frontend/src/views/workbench/SmartAssistantPage.vue @@ -26,7 +26,7 @@ hero-input :show-panel="showSpecialistPanel" :show-strip="showTopStrip" - :has-messages="messages.length > 0" + :has-messages="messages.length > 0 || Boolean(pendingSpeakerConfirm)" :active-nav-item="activeNavItem" :history-count="5" :task-items="taskItems" @@ -153,6 +153,17 @@
{{ msg.timestamp }}
+ + +
🤖
@@ -202,6 +213,7 @@ import { useRoute, useRouter } from 'vue-router' import { storeToRefs } from 'pinia' import { ElMessage } from 'element-plus' import { sendChatMessage } from '@/api/chatMessage' +import http from '@/api/http' import { createWeixinPublicAccountTask, executeWeixinPublicAccountWorkflowStep, @@ -224,6 +236,14 @@ import { useAiRouteStore } from '@/store/llmRoute' import { useWorkbenchStore } from '@/store/workbench' import { getSkillByKey } from '@/skills/registry' import { buildComposerBlocks, blocksToMountedResources, hasSendableContent } from '@/skills/shared/runtime' +import { + AUDIO_SKILL_KEY, + pickAudioResource, + resumeAudioSkill, + runAudioSkillStep, + skillConsumesAudio, +} from '@/skills/shared/audioSkill' +import AudioSpeakerConfirmCard from '@/components/chat/AudioSpeakerConfirmCard.vue' const route = useRoute() const router = useRouter() @@ -237,6 +257,7 @@ const { currentSpecialist, currentSpecialistKey, currentTaskId, + currentTaskDetail, } = storeToRefs(taskRuntime) // 模式的值存在技能设置里，不在这个页面自己手上 —— @@ -291,6 +312,19 @@ const defaultGeneralSpecialistPresentation = Object.freeze({ meta: '默认专员 · 通用协作', }) +// 通用助手开场白：优先用后端 /api/assistant/opening 的单一事实源， +// 请求失败时才落到上面的静态兜底（避免空白欢迎画面）。 +const generalAssistantOpening = ref(null) + +async function fetchGeneralAssistantOpening() { + try { + const res = await http.get('/assistant/opening') + if (res?.data) generalAssistantOpening.value = res.data + } catch (error) { + console.warn('加载通用助手开场白失败', error) + } +} + const messages = ref([]) const conversationBootstrapped = ref(false) const mountedRegistrySkill = computed(() => { @@ -368,11 +402,27 @@ const currentSkillPresentation = computed(() => { } }) -const currentObjectPresentation = computed(() => ( - currentFocusedObjectKind.value === 'specialist' +const currentObjectPresentation = computed(() => { + const base = currentFocusedObjectKind.value === 'specialist' ? (currentSpecialistPresentation.value || currentSkillPresentation.value || defaultGeneralSpecialistPresentation) : (currentSkillPresentation.value || currentSpecialistPresentation.value || defaultGeneralSpecialistPresentation) -)) + // 通用助手（落在 defaultGeneralSpecialistPresentation）时，用后端开场白单一事实源覆盖。 + if (base === defaultGeneralSpecialistPresentation && generalAssistantOpening.value) { + const o = generalAssistantOpening.value + return { + ...base, + label: o.label || base.label, + greeting: o.greeting || base.greeting, + tagline: o.tagline || base.tagline, + openingPrompt: o.opening_prompt || base.openingPrompt, + starterPrompts: (o.starter_prompts && o.starter_prompts.length) + ? o.starter_prompts + : base.starterPrompts, + meta: o.meta || base.meta, + } + } + return base +}) const welcomeKicker = computed(() => currentObjectPresentation.value.meta) const welcomeTitle = computed(() => currentObjectPresentation.value.greeting) @@ -407,7 +457,20 @@ const composerBlocks = computed(() => buildComposerBlocks({ text: inputText.value, })) -const canSendContent = computed(() => hasSendableContent(composerBlocks.value) && !sending.value) +// 只挂了音频、没打字，而当前技能并不消费音频。 +// +// hasSendableContent 是纯数据判断（「块里有没有内容」），它不知道此刻挂着什么技能， +// 而音频附件只对语音转写那类执行器有意义 —— 附件不进聊天请求体，普通聊天拿它没办法。 +// 这一层把上下文补上：否则在通用助手里挂个音频，发送键亮着，点下去却发不出去。 +const audioNeedsSkill = computed(() => ( + !inputText.value.trim() + && Boolean(pickAudioResource(composerUploads.value)) + && !skillConsumesAudio(currentSkillKey.value) +)) + +const canSendContent = computed( + () => hasSendableContent(composerBlocks.value) && !audioNeedsSkill.value && !sending.value, +) const taskItems = ref([ { id: '1', title: '2026 当中 GPU - 显...' }, @@ -467,53 +530,136 @@ function renderInlineMarkdown(text) { return html } +// 行级 markdown 渲染：逐行判定类型，把相邻同类型行归为一组，输出对应块级标签。 +// 相比"整块必须是单一类型"的旧实现，这里能正确处理真实 LLM 输出的 +// 「标题 + 列表项 + 段落 + 表格」混排（无空行分隔、且标题后紧跟列表等场景）。 function renderMarkdownBlock(block) { const trimmed = String(block || '').trim() if (!trimmed) return '' - const headingMatch = trimmed.match(/^(#{1,3})\s+(.+)$/) - if (headingMatch) { - const level = headingMatch[1].length - const heading = `${renderInlineMarkdown(headingMatch[2])}` - // If the block has more lines after the heading, render them as additional content - const afterHeading = trimmed.split('\n', 2)[1] - if (afterHeading && afterHeading.trim()) { - return heading + ' ' + renderMarkdownBlock(afterHeading.trim()) - } - return heading - } - const lines = trimmed.split('\n') - if (lines.every((line) => /^\s*>\s?/.test(line))) { - const quote = lines.map((line) => line.replace(/^\s*>\s?/, '')).join('
') - return `
${renderInlineMarkdown(quote)}
` + let html = '' + let paragraph = [] + + const flushParagraph = () => { + if (paragraph.length) { + html += `

${paragraph.map(renderInlineMarkdown).join('
')}

` + paragraph = [] + } } - if (lines.every((line) => /^\s*[-*]\s+/.test(line))) { - const items = lines - .map((line) => line.replace(/^\s*[-*]\s+/, '')) - .map((line) => `
  • ${renderInlineMarkdown(line)}
    • `) - .join('') - return `
      ${items}
    ` - } + let i = 0 + while (i < lines.length) { + const line = lines[i] - if (lines.every((line) => /^\s*\d+\.\s+/.test(line))) { - const items = lines - .map((line) => line.replace(/^\s*\d+\.\s+/, '')) - .map((line) => `
  • ${renderInlineMarkdown(line)}
    • `) - .join('') - return `
      ${items}
    ` - } + const headingMatch = line.match(/^(#{1,6})\s+(.+)$/) + if (headingMatch) { + flushParagraph() + html += `${renderInlineMarkdown(headingMatch[2])}` + i++ + continue + } - return `

    ${lines.map((line) => renderInlineMarkdown(line)).join('
    ')}

    ` + const hrMatch = line.match(/^([-*_]\s*){3,}$/) + if (hrMatch) { + flushParagraph() + html += '
    ' + i++ + continue + } + + // 表格：以 | 开头，且下面紧跟 | -- | 分隔行 + if (/^\s*\|/.test(line) && i + 1 < lines.length && /^\s*\|?[\s\-:|]+\|?\s*$/.test(lines[i + 1]) && lines[i + 1].includes('-')) { + flushParagraph() + const headerCells = line.split('|').slice(1, -1).map((c) => c.trim()) + html += '' + headerCells.map((c) => ``).join('') + '' + i += 2 + while (i < lines.length && /^\s*\|/.test(lines[i])) { + const cells = lines[i].split('|').slice(1, -1).map((c) => c.trim()) + html += '' + cells.map((c) => ``).join('') + '' + i++ + } + html += '
    ${renderInlineMarkdown(c)}
    ${renderInlineMarkdown(c)}
    ' + continue + } + + // 无序列表 + const ulMatch = line.match(/^\s*[-*+]\s+(.+)$/) + if (ulMatch) { + flushParagraph() + const items = [] + while (i < lines.length) { + const m = lines[i].match(/^\s*[-*+]\s+(.+)$/) + if (!m) break + items.push(`
  • ${renderInlineMarkdown(m[1])}
    • `) + i++ + } + html += `
      ${items.join('')}
    ` + continue + } + + // 有序列表 + const olMatch = line.match(/^\s*\d+\.\s+(.+)$/) + if (olMatch) { + flushParagraph() + const items = [] + while (i < lines.length) { + const m = lines[i].match(/^\s*\d+\.\s+(.+)$/) + if (!m) break + items.push(`
  • ${renderInlineMarkdown(m[1])}
    • `) + i++ + } + html += `
      ${items.join('')}
    ` + continue + } + + // 引用 + const quoteMatch = line.match(/^\s*>\s?(.*)$/) + if (quoteMatch) { + flushParagraph() + const items = [] + while (i < lines.length) { + const m = lines[i].match(/^\s*>\s?(.*)$/) + if (!m) break + items.push(renderInlineMarkdown(m[1])) + i++ + } + html += `
    ${items.join('
    ')}
    ` + continue + } + + // 普通文本行：先攒进段落，遇到空行或下一类块级元素时统一输出 + paragraph.push(line) + i++ + } + flushParagraph() + + return html } function renderMarkdownToHtml(text) { const raw = String(text || '').replace(/\r\n/g, '\n').trim() if (!raw) return '' + // 先抽出
    …
    这类原生 HTML 容器，保留原生标签，但内部内容继续走 + // 下方 markdown 渲染，否则整套 block 渲染器会把尖括号转义成 <details>， + // 折叠块就变成一坨字面量文本，用户看不到「分 agent」提示。 + const detailBlocks = [] + const withoutDetails = raw.replace(/
    ([\s\S]*?)<\/details>/g, (full, inner) => { + const token = `@@DETAILS_BLOCK_${detailBlocks.length}@@` + const summaryMatch = inner.match(/([\s\S]*?)<\/summary>/) + const summaryHtml = summaryMatch + ? `${renderInlineMarkdown(summaryMatch[1])}` + : '' + const body = inner + .replace(/([\s\S]*?)<\/summary>/, '') + .trim() + detailBlocks.push(`
    ${summaryHtml}${renderMarkdownToHtml(body)}
    `) + return token + }) + const codeBlocks = [] - const withPlaceholders = raw.replace(/```([\w-]*)\n?([\s\S]*?)```/g, (_, lang, code) => { + const withPlaceholders = withoutDetails.replace(/```([\w-]*)\n?([\s\S]*?)```/g, (_, lang, code) => { const token = `@@CODE_BLOCK_${codeBlocks.length}@@` const languageClass = String(lang || '').trim() ? ` class="language-${escapeHtml(lang.trim())}"` : '' codeBlocks.push(`
    ${escapeHtml(code.trim())}
    `) @@ -526,6 +672,7 @@ function renderMarkdownToHtml(text) { const normalized = String(block || '').trim() if (!normalized) return '' if (/^@@CODE_BLOCK_\d+@@$/.test(normalized)) return normalized + if (/^@@DETAILS_BLOCK_\d+@@$/.test(normalized)) return normalized return renderMarkdownBlock(normalized) }) .filter(Boolean) @@ -534,6 +681,9 @@ function renderMarkdownToHtml(text) { codeBlocks.forEach((blockHtml, index) => { html = html.replace(`@@CODE_BLOCK_${index}@@`, blockHtml) }) + detailBlocks.forEach((blockHtml, index) => { + html = html.replace(`@@DETAILS_BLOCK_${index}@@`, blockHtml) + }) return html } @@ -1221,7 +1371,18 @@ async function continueWeixinPublicAccountConversation(text, onProgress = () => } async function send() { - if (!inputText.value.trim() || sending.value) return + // 这条要排在下面的早退**前面**：它本身就让 canSendContent 为假， + // 放后面就是永远走不到的死代码。它主要给回车用 —— 回车不经过按钮， + // 不提示的话按下去毫无反应（旧代码也这样，但那时发送键是暗的，用户知道原因）。 + if (audioNeedsSkill.value) { + ElMessage.warning('挂着的音频要配「会议音频分析（转写）」技能才用得上；或者打一句说明再发。') + return + } + + // 判据必须和发送键用的是同一个（canSendContent）—— 原先是「有没有打字」， + // 于是挂了音频但没打字时发送键亮着、点下去却什么也不发生。 + // 语音转写的输入就是音频本身，用户不该为了让按钮真的能用再手打一句「转写」。 + if (!canSendContent.value) return const text = inputText.value @@ -1371,6 +1532,27 @@ async function send() { inputText.value = '' sending.value = true + // 收到任务先回一句受理话术，并显示实时等待秒数——编排类任务（单问搜索、 + // 多 Agent 拆解）往往要跑几十秒，用户需要先看到「已接单」的即时反馈。 + const progressMessage = { + role: 'assistant', + content: '收到，正在为您处理...', + timestamp: new Date().toLocaleTimeString(), + } + let progressBaseText = progressMessage.content + const progressStartedAt = Date.now() + const syncProgressMessage = () => { + const elapsed = Math.max(0, Math.floor((Date.now() - progressStartedAt) / 1000)) + progressMessage.content = elapsed >= 3 + ? `${progressBaseText}（已等待 ${elapsed} 秒）` + : progressBaseText + progressMessage.timestamp = new Date().toLocaleTimeString() + } + const progressTicker = window.setInterval(syncProgressMessage, 1000) + messages.value.push(progressMessage) + await nextTick() + scrollToEnd() + try { if (mountedRegistrySkill.value?.executor) { const result = await mountedRegistrySkill.value.executor({ @@ -1378,7 +1560,17 @@ async function send() { inputText: text, mode: mode.value, taskId: currentTaskId.value, + // 音频附件要真的进执行链路，否则语音转写只能拿到一句空文本 —— + // 这正是原先「挂了音频却只得到一句 LLM 自由发挥」的原因： + // mediaId 一路都在（composerUploads / 块的 _meta 里都有），只是没人消费。 + mediaId: pickAudioResource(composerUploads.value)?.mediaId || 0, + language: skillSettings.valueOf(currentSkillKey.value, 'language'), + aiRouteId: selectedAiChatRouteId.value, + // 每跑完一步刷一次右栏。转写这类技能一步就要几十秒到几分钟， + // 只在全部跑完后刷一次的话，中间右栏一直停在 0/4，看起来像卡死。 + onStepDone: refreshTaskRail, }) + window.clearInterval(progressTicker) messages.value.push(buildLocalSkillReply(result, mountedRegistrySkill.value)) if (currentTaskId.value) { await taskRuntime.loadTaskDetail(currentTaskId.value) @@ -1396,17 +1588,171 @@ async function send() { }) const reply = res.data.message reply.timestamp = new Date().toLocaleTimeString() + window.clearInterval(progressTicker) messages.value.push(reply) } await nextTick() scrollToEnd() } catch (error) { + window.clearInterval(progressTicker) + // 失败也必须刷一次右栏。前几步的 run 与产物已经落库了，不刷的话右栏连 + // 「前两步做完了、产物在这」都不显示，用户会把一次部分成功当成全部失败， + // 而错误信息里那句「前 N 步的产物已保存」也就无从对照。 + await refreshTaskRail() + progressMessage.content = `执行失败：${error?.message || '请稍后重试'}` + progressMessage.timestamp = new Date().toLocaleTimeString() ElMessage.error(error.message || '发送失败') } finally { + window.clearInterval(progressTicker) sending.value = false } } +/** + * 重新拉一次当前任务详情，让右栏的工作流进度与产物区跟上。 + * + * 刷新失败只记一条警告，不往上抛：那一刻产物已经落库了，把异常冒出去会把 + * 一次成功的执行报成失败。用户下次切回这个任务时会重新拉到。 + */ +async function refreshTaskRail() { + if (!currentTaskId.value) return + try { + await taskRuntime.loadTaskDetail(currentTaskId.value) + } catch (error) { + console.warn('refresh task rail failed', error) + } +} + +// ===== 说话人身份的待确认卡片 ===== + +const speakerConfirmBusy = ref(false) + +/** + * 当前是否有「推断出来的说话人身份，等人点头」。 + * + * 从**任务状态**推，不从消息推： + * - 消息里的 skillResult 不落库，刷新一次就没了，而这件事不能刷新一次问一次； + * - 状态是后端的，前端算出来的「我觉得该确认了」和后端的闸门可能不一致 —— + * 以任务状态为准，卡片在不在就和「第 5 步跑不跑得动」是同一个判据。 + * + * 三个条件缺一不可：任务停在「待确认」、存在说话人名单产物、且那份名单还没被确认。 + */ +const pendingSpeakerConfirm = computed(() => { + const detail = currentTaskDetail.value + if (!detail) return null + if (String(detail?.task?.status || '').trim() !== '待确认') return null + + const artifacts = Array.isArray(detail.artifacts) ? detail.artifacts : [] + // 取最新的一份：重新识别过的话，要确认的是新那版。 + const listArtifact = [...artifacts] + .filter((item) => String(item?.artifact_type || item?.artifactType || '').trim() === 'speakers') + .sort((a, b) => Number(b?.id || 0) - Number(a?.id || 0))[0] + if (!listArtifact) return null + if (String(listArtifact.status || '').trim() !== 'ready') return null + + const speakers = speakerRosterFromArtifact(listArtifact) + if (!speakers.length) return null + + return { + artifactId: listArtifact.id, + taskId: detail?.task?.id || currentTaskId.value, + speakers, + } +}) + +/** 从「说话人名单」产物里取出名单。产物正文是给人看的，结构化那份在 content_json 里。 */ +function speakerRosterFromArtifact(artifact) { + const source = artifact?.content_json ?? artifact?.contentJson + if (!source) return [] + let payload = source + if (typeof source === 'string') { + try { + payload = JSON.parse(source) + } catch { + return [] + } + } + const list = payload?.speakers + return Array.isArray(list) ? list : [] +} + +/** + * 用户确认名单 → 落库 → 接着跑「整理段落与重点」与「提炼可交付纪要」。 + * + * 确认与继续是**两次请求**而不是一次：确认那一下必须独立成功。若合成一次， + * 后面两步跑失败会连带让用户以为「我确认的这个动作也没成」，于是再点一次， + * 而那时名单已经是已确认状态、会被后端按重复提交拒掉。 + */ +async function handleSpeakerConfirm(speakers) { + if (speakerConfirmBusy.value) return + const taskId = Number(currentTaskId.value) || 0 + if (!taskId) { + ElMessage.error('找不到当前任务，请刷新后重试') + return + } + speakerConfirmBusy.value = true + try { + await runAudioSkillStep('speakers-confirm', { task_id: taskId, speakers }) + await refreshTaskRail() + } catch (error) { + ElMessage.error(`确认失败：${error?.message || '请稍后重试'}`) + speakerConfirmBusy.value = false + return + } + + // 确认已经落库了，从这里往后就是「继续跑」—— 失败也不能把上面那次确认说成失败。 + const pendingMessage = { + role: 'assistant', + content: '已记下你确认的说话人身份，正在继续整理段落与生成纪要...', + timestamp: new Date().toLocaleTimeString(), + } + messages.value.push(pendingMessage) + await nextTick() + scrollToEnd() + + try { + const result = await resumeAudioSkill({ + // 按 key 从注册表取，不用 mountedRegistrySkill：刷新页面之后 + // currentSkillKey 会退回默认技能，那个 computed 拿到的就不是转写技能了， + // 结果卡上的流程标题会跟着串味。 + definition: getSkillByKey(AUDIO_SKILL_KEY) || mountedRegistrySkill.value, + taskId, + aiRouteId: selectedAiChatRouteId.value, + // scope 那一步的产物不在这一轮的 results 里（它是确认之前跑的）， + // 用它生成文件名下载才不至于退回默认的「转写稿」。 + fileName: audioFileNameOf(currentTaskDetail.value), + onStepDone: refreshTaskRail, + }) + messages.value.push(buildLocalSkillReply(result, mountedRegistrySkill.value)) + } catch (error) { + pendingMessage.content = `已确认说话人身份，但继续执行失败：${error?.message || '请稍后重试'}` + pendingMessage.timestamp = new Date().toLocaleTimeString() + ElMessage.error(error.message || '继续执行失败') + } finally { + speakerConfirmBusy.value = false + await refreshTaskRail() + await nextTick() + scrollToEnd() + } +} + +/** 从任务产物里找出这次转写的音频文件名（用于下载名）。取不到就交给调用方兜底。 */ +function audioFileNameOf(detail) { + const artifacts = Array.isArray(detail?.artifacts) ? detail.artifacts : [] + const scope = [...artifacts] + .filter((item) => String(item?.artifact_type || item?.artifactType || '').trim() === 'text') + .sort((a, b) => Number(a?.id || 0) - Number(b?.id || 0))[0] + const source = scope?.content_json ?? scope?.contentJson + if (!source) return '' + try { + const payload = typeof source === 'string' ? JSON.parse(source) : source + return String(payload?.file_name || '').trim() + } catch { + return '' + } +} + + function scrollToEnd() { const chatBody = document.querySelector('.chat-body') if (chatBody) { @@ -1668,10 +2014,70 @@ watch( { deep: true }, ) +/** + * 重开一条旧任务时，把「这条任务是哪个技能做的」从库里捡回来。 + * + * 为什么需要：当前技能只按任务挂在内存里（taskSkillKeyById），刷新即丢。 + * 但这件事**本来就落在库里** —— 每一步的 task_run.action_key 就是技能 key + * （多步技能写成 `技能key:步骤`）。丢的是前端的内存，不是事实。 + * 捡不回来，右栏就在重开任务时整块消失 —— 正在等人确认的转写任务会看起来 + * 像从没做过。 + * + * 只在「这条任务在前端还没记住任何技能」时补：用户刚在 + 里选的技能说了算， + * 被这里的推断盖掉的话，「先选技能再点开任务」就会失效。 + * + * 认技能要用 skillCatalog，而它由 onMounted 里的 hydrate() 拉回来。挂载那一瞬间 + * 就到这里的调用会认不出来（目录还空着），代价只是右栏晚一次点击才出现， + * 所以不为此加锁；也不要改成 await hydrate() 假装稳妥 —— hydrate 在 + * 「已经在加载中」时直接 return，await 它换来的是立刻返回，不是等它加载完。 + */ +function restoreSkillFromTaskRuns(taskId, detail) { + const id = String(taskId || '') + if (!id) return + if (taskRuntime.skillKeyOfTask(id)) return + + const runs = Array.isArray(detail?.runs) ? detail.runs : [] + for (const run of runs) { + const key = String(run?.action_key || '').trim().split(':')[0] + if (!key || key === HOME_SKILL) continue + // 认不出来就不认。公众号那几步的 action_key 是**裸步骤名**（content_creation、 + // title_generation），不是技能 key；照单全收会把一个不存在的技能设成当前技能， + // 右栏拿不到 blueprint 就整块空掉 —— 比不恢复更糟。 + if (!skillCatalog.getByKey(key)) continue + taskRuntime.attachSkillToCurrentTask(key) + return + } +} + +// 当前任务一变就把它的详情拉回来。 +// +// 不能只靠右栏（SpecialistPanel）去拉：它挂在 showSpecialistPanel 后面，而那个 +// 条件依赖「当前技能/专员不是默认的那个」，重开一条通用专员名下的任务时整块不渲染， +// 于是没人拉详情，待确认的说话人名单也就跟着不见了 —— 而它恰恰是在这种时候 +// 最需要露出来。所以这一份数据由页面自己保证。 +watch( + currentTaskId, + async (nextId) => { + const taskId = String(nextId || '').trim() + if (!taskId) return + let detail = null + try { + detail = await taskRuntime.loadTaskDetail(taskId) + } catch (error) { + // 拉不到只是右栏和确认卡片空着，不该把重开任务这件事整个报失败。 + console.warn('load task detail failed', error) + return + } + restoreSkillFromTaskRuns(taskId, detail) + }, + { immediate: true }, +) + onMounted(async () => { await Promise.all([ skillCatalog.hydrate(), specialistCatalog.hydrate(), + fetchGeneralAssistantOpening(), ]) await taskRuntime.loadMyTasks() const routeHasPreset = Boolean( diff --git a/eai_agentplatform/test/general_assistant/run_direct_query/meta.txt b/eai_agentplatform/test/general_assistant/run_direct_query/meta.txt new file mode 100644 index 0000000..a4278af --- /dev/null +++ b/eai_agentplatform/test/general_assistant/run_direct_query/meta.txt @@ -0,0 +1,4 @@ +latency_ms=2515 +artifacts=0 +err= +finished=2026-09-25T23:52:25+08:00 diff --git a/eai_agentplatform/test/general_assistant/run_direct_query/query.txt b/eai_agentplatform/test/general_assistant/run_direct_query/query.txt new file mode 100644 index 0000000..f7dd32c --- /dev/null +++ b/eai_agentplatform/test/general_assistant/run_direct_query/query.txt @@ -0,0 +1 @@ +请用一句话说明什么是光合作用？ \ No newline at end of file diff --git a/eai_agentplatform/test/general_assistant/run_direct_query/reply.md b/eai_agentplatform/test/general_assistant/run_direct_query/reply.md new file mode 100644 index 0000000..61883c8 --- /dev/null +++ b/eai_agentplatform/test/general_assistant/run_direct_query/reply.md @@ -0,0 +1 @@ +光合作用是植物、藻类和某些细菌利用光能，将二氧化碳和水转化为有机物并释放氧气的过程。 \ No newline at end of file diff --git a/eai_agentplatform/test/general_assistant/run_orchestrated_report/artifacts.md b/eai_agentplatform/test/general_assistant/run_orchestrated_report/artifacts.md new file mode 100644 index 0000000..34d3835 --- /dev/null +++ b/eai_agentplatform/test/general_assistant/run_orchestrated_report/artifacts.md @@ -0,0 +1,380 @@ +## [subtask_1] 制定报告框架、指标口径与数据采集清单 (planner) + +作为「规划者」，先不直接写全文，而是把总任务拆成可执行结构，并聚焦当前子任务：**制定报告框架、指标口径与数据采集清单**。以下为规划输出。 + +## 一、子任务拆解与依赖关系 + +| ID | 子任务 | 主要产出 | 依赖 | 可并行 | 优先级 | 联网 | +|---|---|---|---|---|---|---| +| T1 | 范围与边界定义 | 产品分类、地域、时间、口径边界 | 无 | 否 | P0 | false | +| T2 | 报告框架搭建 | 章节大纲、核心问题、图表清单 | T1 | + +## [subtask_2] 研究中国外骨骼机器人市场规模、细分结构与2026年预测 (researcher) + +已检索到足够信息（同一指标出现两类口径），按收敛要求停止检索，以下为研究结论。 + +--- + +# 中国外骨骼机器人行业研究结论（用于2026年市场分析报告） + +## 一、市场规模：两套口径必须并列标注 + +| 口径 | 2025年规模 | 增长速度 | 来源 | +|---|---|---|---| +| **IDC（偏官方/统计口径）** | 市场规模**超16亿元**，出货量约**2.6万台** | — | IDC，转引自IT之家《IDC：2025年中国外骨骼机器人市场规模超过16亿元》ithome.com/0/985/443.htm | +| **泛行业/券商口径** | 2025年预计达**42亿元** | 未来五年CAGR约**50%** | 雪球行业梳理 xueqiu.com/2071397530/331411470（**非机构一手数据，需谨慎**） | + +**差额原因提示**：16亿元为IDC"设备销售/出货统计"口径；42亿元多为市场机构对"含服务、租赁、康复项目"广义口径的推算，两者相差约2.6倍。**建议报告主口径采用IDC的16亿元（可核验性更强），并将42亿元作为"广义市场潜力"并列标注**，避免将单一来源当定论。 + +**2026年预测（口径不一）**： +- 共研产业研究院数据：**2026年中国外骨骼机器人需求量预计同比增长31.6%，市场规模同比增长28.7%**（转引自机器人大讲堂 leaderobot.com/news/7335）。若以IDC的2025年16亿元为基数，按+28.7%推算，**2026年约20.6亿元**（此为测算值，非机构直接发布，须标注为本报告推算）。 +- 雪球口径"未来五年CAGR约50%"隐含更激进增长，若成立则2026年远超20亿元 —— 与共研口径不一致，并列标注。 + +**中长期（全球参照）**：开源证券研报认为，外骨骼已从医疗康复、军工拓展至工业与民用，**预计2030年全球市场规模达146.7亿美元，CAGR 42.2%**（转引自中国金融信息网 m.cnfin.com 2025-08-22）。 + +## 二、细分结构：动力下肢主导，"千元消费级"成走量主力 + +- **按技术类型**：动力下肢外骨骼主导（前瞻产业研究院《2026年全球外骨骼机器人行业发展现状：动力下肢主导》）。 +- **按应用场景**（定性，来源36氪/新浪等）： + - **医疗康复**：医院端客单价高、利润厚（"医院赚大钱"），是高端市场的核心； + - **消费级（助行/助老/户外助行"爬山裤"）**：单价下探至千元级，**销量最猛**，是放量主力； + - **工业/军工**：B端场景，标准化程度待提升。 +- **需求侧驱动**：银发经济（报告称"3.23亿老年人"，来源微博文章，须核实口径）+ 消费场景渗透。 + +## 三、政策支持（官方来源，可追溯） + +1. **民政部等14部门联合印发《康复辅助器具产业扩能提质三年行动方案（2026—2028年）》**，明确**支持治疗性康复辅具纳入医保**（民政部官网 gjkfyy.mca.gov.cn；中新经纬2026-07-13报道"14部门：支持治疗性康复辅具纳入医保"）。这是本行业最强政策信号。 +2. **外骨骼首次纳入医保规划**，被媒体表述为"百亿市场空间开启"（21财经2026-08-20、环球网 finance.huanqiu.com/article/4Sry9yPEeW4）。**注意**：媒体"s"百亿"为市场空间预期口径，非当期实际规模。 +3. **以旧换新/消费补贴**：借力以旧换新推动外骨骼进入消费市场（相关微信/媒体文章）。 + +## 四、龙头格局与投资趋势（初步） + +- **代表企业**：程天科技（2026年3月宣布完成**亿元级B+轮融资**，并亮相世界机器人大会消费级新品，来源：机器人大讲堂、新华网浙江2026-08-21）；极壳Hypershell（消费级外骨骼，定价约999美元，来源OFweek 2025-08）；迈步机器人等（企业全景盘点，搜狐2026）。 +- **投资热度信号**：**2026年上半年，智能外骨骼网络零售额同比暴增458.4%**（21财经2026-08-20）。 +- **竞争格局**：目前尚无权威统一的市占率榜单；前瞻、中研普华等机构有《2026年中国外骨骼机器人行业竞争格局及企业布局》类报告，但具体份额数据需付费获取 —— **本报告不得编造具体份额数字**。 + +## 五、数据缺口与权威官方入口（如实说明） + +- **无法从公开免费渠道确认**：①2026年官方市场规模确切值（各机构预测不一）；②龙头企业精确市占率；③IDC与"42亿元"口径的官方对照说明。 +- **建议引用入口**：IDC中国官网、民政部官网（政策）、国家医保局（医保目录）、前瞻/中研普华/智研咨询付费报告（市场规模与格局）。 +- **待核实项**：微博"3.23亿老年人"、雪球"42亿元/CAGR 50%"均属非权威一手数据，引用于报告时须标注"非官方口径，仅供参考"。 + +--- + +**给写作环节的口径建议**：主报告以"IDC 2025年16亿元、2026年约20亿元（+28.7%，共研测算口径）"为主线，将"42亿元/50% CAGR"作为乐观情景并列；政策以民政部14部门方案与外骨骼纳入医保为核心论据；龙头格局以程天科技等案例为主，份额数字留白待补充付费数据。 + +## [subtask_3] 研究中国外骨骼机器人政策支持、监管与标准环境 (researcher) + +# 子任务研究结论：中国外骨骼机器人政策支持、监管与标准环境 + +> 说明：以下结论基于公开检索结果整理。检索中出现的部分媒体文章标题含推测性表述（如"2026外骨骼元年"），已按"官方口径 vs 行业/媒体口径"分别标注。对无法从检索结果中确认具体文号或发布日期的条目，已如实标明"待核实"，并给出官方查询入口，未做数字化臆断。 + +--- + +## 一、需求侧政策：银发经济与养老服务机器人 + +| 时间 | 政策/举措 | 与外骨骼相关口径 | 来源 | +|---|---|---|---| +| 2026年1月 | **八部门联合出台 14 项举措促进银发经济发展**，其中明确"鼓励养老服务机器人产业发展" | 属**官方口径**，为养老场景下助行/康复类机器人（外骨骼主要应用场景之一）提供需求侧牵引 | 武汉市相关部门转发页（whwx.gov.cn，2026-01-14）；sme8718 转载 | +| 2025 年（具体文号待核实） | **14 部门联合发文**，聚焦脑机接口、康养机器人、仿生假肢等，被媒体称为进入"国家级攻坚周期" | 属**政策方向性表述**，检索来自行业专栏（知乎专栏转载），发文字号与全称**未在检索结果中确认，待核实** | 知乎专栏（2025），非官方原文 | + +**要点**：外骨骼机器人本身并非单独被点名的政策品类，而是被纳入"**养老服务机器人 / 康养机器人 / 康复辅助器具**"这一更大政策篮子中获得支持。这意味着政策红利是"搭车式"而非"点名式"，需要在其上层类别文件中寻找依据。 + +--- + +## 二、监管与准入：医疗器械路径 + +- **国家药监局 2025 年第 63 号公告**《关于优化全生命周期监管支持高端医疗器械创新发展有关举措的公告》（2025 年 7 月）——属**官方口径**，为高端医疗器械（含部分康复/外骨骼类产品）提供审评审批加速、全生命周期监管优化的制度基础。 + - 来源：上海市药监局转发页（yjj.sh.gov.cn，2025-07-04）。 +- **医疗器械产品分类界定**：检索到《2025 年第二次医疗器械产品分类界定结果汇总》，涉及新型/康复类器械归类问题（来源：知乎专栏转载）。**具体外骨骼产品的分类界定结论需回到国家药监局官网原文核对，待核实。** + +**关键监管特征（需在报告中厘清）**： +1. **是否按医疗器械监管，取决于产品属性与宣称用途**——用于医疗康复、以治疗/改善功能为目的的，走医疗器械注册（多为 II/III 类）；仅作**消费级助行、户外助力**的，通常不走医疗器械审批。这直接造成"医疗级"与"消费级"两条截然不同的准入与支付路径。 +2. 媒体《上万元的"行走外挂"，竟导致关节炎？》（tech.ifeng.com）反映出**安全性争议**，提示监管与标准建设的紧迫性，但属媒体导向内容，非官方结论。 + +--- + +## 三、标准体系：现状判断 + +- 检索**未能确认**已发布的、专门针对"外骨骼机器人"的国家标准（如 GB/T 编号）原文。检索中出现的 GB/T 相关信息多为噪声结果，无法核实。 +- 可确认的相邻标准/规范线索： + - 《老年人外骨骼机器人安全科普与选购标准》类**团体/科普性**标准提示（来自消费评测平台 post.smzdm.com），属**行业/平台口径**，非国标。 + - 康复机器人领域的**安全防护**已被行业普遍视为"核心红线"（同上来源）。 +- **结论**：中国外骨骼机器人**尚未形成独立、完整的国家级标准体系**，当前更多依赖"**康复辅助器具 + 医用机器人 + 电气安全**"等既有通用标准体系交叉覆盖。**"国家标准缺失"是本行业监管环境的核心短板，也是报告应重点指出的结论。**（此处为基于检索的判断，建议在正式报告中以国家标准化管理委员会官网检索结果为准。） + +--- + +## 四、支付与医保 + +- 检索到《2026 中国康复机器人训练效果评估及**医保支付试点**》相关文档（book118）与《2026 中国康复辅助器具市场需求及政策环境分析报告》（renrendoc），提示**康复机器人/外骨骼的医保支付仍处"试点探索"阶段**，尚未全国性纳入报销目录。 +- 但此类文档多为**第三方研究报告/文档平台内容，非官方文件**，属**泛行业口径**，具体试点地区、报销比例与项目编码**待核实**。 + +--- + +## 五、口径差异与不确定项汇总（供报告谨慎引用） + +| 议题 | 官方口径 | 行业/媒体口径 | 差异原因 | +|---|---|---|---| +| 外骨骼政策定位 | 纳入"养老/康养机器人"大类间接支持 | 媒体称"2026外骨骼元年""国家级攻坚" | 媒体放大趋势，需回归原文文号 | +| 医疗器械准入 | 药监局 63 号公告优化高端器械审评 | 部分报道暗示"外骨骼已获政策绿色通道" | 需区分具体产品分类 | +| 标准 | 无确认的专项国标 | 出现"选购标准"等团体/平台标准 | 团体标准 ≠ 国家标准 | +| 医保支付 | 未见全国性纳入的官方文件 | 出现"医保支付试点"研究文档 | 试点 ≠ 落地，且文档非官方 | + +--- + +## 六、权威官方查询入口（建议后续核实） + +1. **国家药监局**（nmpa.gov.cn）——医疗器械分类界定、2025 年第 63 号公告原文 +2. **国家标准化管理委员会 / 全国标准信息公共服务平台**（std.samr.gov.cn）——检索"外骨骼""康复机器人"现行国标与行标 +3. **工业和信息化部**（miit.gov.cn）——机器人产业、高端装备相关产业政策 +4. **国家医保局**（nhsa.gov.cn）——康复类医疗服务价格项目与医保支付政策 +5. **民政部 / 全国老龄办**——银发经济、养老服务机器人相关政策 + +--- + +### 本子任务核心结论（供总报告引用） +1. **政策支持以"搭车式"为主**：外骨骼未单列，依托银发经济、养老机器人、高端医疗器械三大政策篮子获得支持（2026 年 1 月八部门 14 项举措等）。 +2. **监管呈"双轨制"**：医疗级走药监局器械注册（2025 年 63 号公告优化审评），消费级走普通产品路径，两轨准入与支付逻辑完全不同。 +3. **标准体系是最大短板**：未见确认的专项国家标准，主要依赖康复辅具与医用机器人通用标准交叉覆盖。 +4. **支付侧尚未打通**：医保支付仍处试点探索，缺乏全国性官方落地文件。 +5. **建议在正式报告中**：所有涉及文号、金额、比例的数字，均以第六节官方入口二次核实后定稿，避免引用第三方研究文档的未经证实数据。 + +## [subtask_4] 研究中国外骨骼机器人龙头格局、竞争态势与代表企业 (researcher) + +已检索到足够信息（覆盖市场规模、政策、代表企业与融资 4 个维度，共 15 次检索），现收敛并输出研究结论。 + +--- + +# 研究结论：中国外骨骼机器人龙头格局、竞争态势与代表企业 + +> 说明：本子任务聚焦「龙头格局 + 竞争态势 + 代表企业」，并附市场规模与投资趋势的可用数据，供总报告使用。以下金额/出货量均已标注来源与口径；**凡来源冲突者并列标注，不取单一结论**。 + +## 一、市场规模与口径（先厘清"口径打架"问题） + +| 数据点 | 数值 | 来源与时间 | 口径 | +|---|---|---|---| +| 中国外骨骼机器人出货量 | 约 **2.6 万台** | IDC，转引自同花顺财经（2026-08-04） | IDC 口径，2025 年 | +| 市场规模增速 | **5 年增长约 15 倍** | 36氪 / 澎湃（转引行业口径） | 泛行业口径，未注明基期绝对额 | +| 媒体标题中的规模 | **"16 亿"** | 36氪《16亿外骨骼火了：医院赚大钱，卖得最猛的却是千元"爬山裤"》 | 媒体口径，**该数字具体指向（产值/融资/细分市场）报道未明确界定** | + +**关键矛盾（须在报告中并列呈现，不可调和为单一数字）：** +- IDC 口径"**2025 年全行业出货约 2.6 万台**"，但程天科技创始人王天**预估其单家 2026 年消费级出货即达 6–10 万台**（36氪，2025）。**单一企业次年预测量 > IDC 上一年全行业实际量**，说明二者口径不同： + - IDC 2.6 万台很可能仅覆盖**医疗级/有源康复设备**（单价高、需资质、走医院采购）； + - 程天预估量属**消费级/无源或轻有源助行产品**（单价千元级，走电商），二者不应直接相加。 +- 结论：**中国外骨骼不存在统一的"市场规模"数字**。建议报告分设"医疗康复级（B端/院内）"与"消费级（C端/助行穿戴）"两条口径分别列示。 + +## 二、政策支持（官方口径，权威可溯源） + +1. **首纳医保规划**：媒体（环球网财经）报道"**外骨骼首纳医保规划，百亿市场空间开启**"，但**未给出官方文件编号与具体条目**，属媒体转述，报告中应标注为"待官方文件核实"。 +2. **国家级产业政策（最硬来源）**：**民政部等 14 部门联合印发《康复辅助器具产业扩能提质三年行动方案（2026—2028 年）》**，2026 年 7 月发布，政府网原文可查（gov.cn，2026-07）。这是把外骨骼/康复辅具上升为**国家级产业跃升**的纲领性文件。 +3. **地方落地**：**上海康复辅具租赁实现全覆盖**（上海市政府新闻办），并新增情感陪伴型机器人，说明"租赁+服务"模式在地方财政层面落地。 +4. **价格与支付通道**：北京**为脑机接口定价并纳入甲类医保**（知乎/多家转引），虽非外骨骼直接定价，但反映**创新器械价格立项与医保通道正在打开**，是外骨骼未来进医保的"制度前哨"。 + +## 三、龙头格局与代表企业（双轨竞争） + +### A. 医疗康复级（"深"vs"广"两条路线） +| 企业 | 定位/特征 | 来源 | +|---|---|---| +| **程天科技**（杭州程天科技发展有限公司） | 医疗康复"做深"，2025 年推 C 端消费级（网友称"爬楼机"），获**亿元级融资** | 36氪 / 百度百科 | +| **傅利叶智能** | 康复"做广"，产品线宽 | 知乎《程天做"深"，傅利叶做"广"》 | +| **迈步机器人** | 老牌下肢康复机器人企业，常与傅利叶对比 | 前瞻/搜狐 | +| **大艾机器人**（北京大艾） | 医疗康复代表厂商 | 百度百科 | + +### B. 消费级（爆发主战场） +| 企业 | 数据 | 来源 | +|---|---|---| +| **极壳科技（Hypershell）** | 2021 年成立，自称"全球消费级外骨骼定义者"；**2025 年 Pre-B + B 轮累计 7000 万美元**；累计出货数万台；**2026 年再完成 5000 万美元 B+ 轮（蚂蚁集团、美团龙珠入局）** | 36氪 / MSN / 东方财富 | +| **程天科技（C 端）** | 消费级"爬楼机"，2026 年出货预估 6–10 万台 | 36氪 | +| **精工科技（上市公司）** | 单关节（髋关节）助力机器人，二代外骨骼即将亮相；曾澄清未与京东物流、顺丰签试用协议 | 搜狐/同花顺/36氪 | + +### C. 跨界/生态玩家 +- **家电巨头**："2000 亿市值家电巨头瞄准 3 亿老年人"（腾讯新闻，2026-06），指向大型家电企业切入银发助行赛道。 +- **优必选**：人形机器人企业，团队背景与外骨骼相关（凤凰网）。 +- **罗永浩带货**、**CES 外骨骼扎堆亮相**，标志消费级进入品牌营销阶段。 + +## 四、投资趋势 + +| 事件 | 金额 | 机构 | 来源 | +|---|---|---|---| +| 极壳科技 Pre-B + B 轮 | 7000 万美元 | — | 36氪/MSN | +| 极壳科技 B+ 轮 | 5000 万美元 | 蚂蚁集团、美团龙珠 | 腾讯新闻 | +| 某头部企业融资 | 3.4 亿元 | **IDG、红杉、蚂蚁** | 新浪财经（2026-05-20） | +| 程天科技 | 亿元级 | — | 36氪 | +| 沙特资本、陆奇（奇绩创坛）系 | 入局 | — | 36氪/知乎 | + +**投资特征**：赛道从"医疗康复单轮驱动"转向**"医疗 + 消费双轮"**；**互联网战投（蚂蚁、美团）与美元基金（IDG、红杉）及中东主权资本（沙特）同时入场**，估值进入"几十亿"量级（MSN 报道称"头部公司估值几十亿"），并引发"画大饼还是真愿景"的质疑。 + +## 五、竞争态势总结（供报告结论） + +1. **双轨分化**：医疗级走"资质+医院+医保"（程天、傅利叶、迈步、大艾），消费级走"低价+电商+景区租赁"（极壳、程天 C 端）。 +2. **价格断崖式下探**：从"几十万元级"降至**千元级**（极壳 Hypershell X 系列 6999–13999 元；市场出现 2500 元/台"秒空"），**成本革命是本轮爆发的核心变量**。 +3. **场景由医院扩展到景区/居家**：泰山登山、"80 元租机械腿"、景区租赁成为消费级最早的商业化验证场。 +4. **口径混乱本身是行业早期特征**：市场规模、出货量缺乏统一统计口径，**报告中须明确 "医疗级 / 消费级" 分列**。 + +## 六、尚待核实/官方入口（诚实标注，未编造） + +- "外骨骼首纳医保规划"的**官方文件名称与文号**未能定位，建议核对 **国家医保局**（nhsa.gov.cn）医疗服务价格项目立项指南。 +- 2026 年外骨骼**权威市场规模（亿元）**暂无单一官方口径，建议以 **IDC、工信部、民政部**口径交叉引用。 +- 《康复辅助器具产业扩能提质三年行动方案（2026—2028 年）》为**最权威政策来源**，报告政策章节应以其为主锚点：gov.cn，2026 年 7 月。 + +--- + +**给总报告的建议**：市场规模章节务必**区分两条口径**并注明 IDC 2.6 万台与程天 6–10 万台预估的口径差异；政策章节以 14 部门三年行动方案为骨架；龙头章节按"医疗级 / 消费级 / 跨界"三分法呈现；投资章节突出"蚂蚁、美团、IDG、红杉、沙特资本"的入场结构。 + +## [subtask_5] 研究中国外骨骼机器人投资趋势、融资事件与资本市场动态 (researcher) + +# 中国外骨骼机器人：投资趋势、融资事件与资本市场动态（研究结论） + +> 说明：以下为可追溯的事实整理，标注来源与口径。部分条目来自第三方行业媒体/研究机构转述，**非官方统计**，请注意口径差异与时效。 + +## 一、融资事件梳理（代表性案例） + +| 企业 | 轮次/时间 | 金额 | 投资方 | 来源 | +|---|---|---|---|---| +| 程天科技 | A+轮（2025年前后） | 亿元级 | 达晨财智领投，安信证券、保利资本跟投，蓝驰创投加注 | OFweek 机器人（mp.ofweek.com/robot/a256714627227） | +| 程天科技 | B+轮（2026-03-05） | 亿元级 | 未在摘要中披露 | 投资界（pedaily.cn/202603/561388）、腾讯新闻（20260305A06QH900） | +| 迈步机器人 | 2026-08-27 | 近亿元 | 未披露 | 投资界（pedaily.cn/202608/568172） | +| 荣泰健康 | 2025-07-10 | 2060万元（占认缴出资总额99.52%） | 出资设立/参与基金投资外骨骼领域 | 新浪财经（finance.sina.cn/2025-07-10/detail-infeytkq0241434.d.html） | + +**要点解读** +- **程天科技是融资节奏最密集的标的**：搜索结果明确显示其"一年内连续完成两轮融资"（A+轮→B+轮），且被投资界列为行业样本企业。其产品线从医疗康复延伸至**C端消费级外骨骼**（有源产品被称"爬楼机"），管理层预估 **2026 年消费级出货量 6–10 万台**（36氪/eu.36kr.com 转述）。 +- **赛道并购/产业资本入场信号**：荣泰健康（按摩椅/健康电器上市公司）以基金出资方式切入外骨骼，属"产业资本+概念布局"型投资，规模小（2060万元）但具风向意义。 +- **康复养老方向持续获投**：迈步机器人聚焦"康复养老外骨骼机器人及人机交互"，2026年8月完成近亿元融资。 + +## 二、市场规模与增长口径（投资逻辑基础） + +- **全球口径**：2024年全球可穿戴外骨骼市场规模 **17.6亿美元**，预计 **2032 年复合增长率超 43%**（转引自投资界 pedaily.cn/202603/561388，原始来源为海外研究机构，未直接可核验）。 +- **中国口径（存差异）**： + - 华经/搜狐等媒体口径：预计 **2025 年中国市场规模超 40 亿元**（news.sohu.com/a/726526171）。 + - 另有媒体提及"**16 亿外骨骼市场**"及"千元爬山裤卖得最猛"（雪球 xueqiu.com/2766276381/410533232），口径疑为某细分市场或某平台成交额，**与40亿元口径不一致，需并注**。 +- **结论**：中国市场"40亿元级"为泛行业媒体转述口径，**尚无官方（工信部/统计局）统计背书**；投资测算时应注明口径并给出区间，不建议直接引用单点数字。 + +## 三、资本市场动态 + +- **一级市场热度外溢**：2025年人形机器人行业投融资已超 **100亿元**（gzstv.com 等），外骨骼作为"具身智能/穿戴式机器人"邻近赛道同步升温；媒体将外骨骼与人形、AI沙发并列为"物理AI落地"方向（163.com/dy/article/KN8L24UP0556CAYF）。 +- **A股概念与产业链标的**（媒体梳理，非交易所官方分类）： + - 整机/品牌：**万天控股**携手极索医疗打造外骨骼机器人（雪球）； + - 上游核心部件：**绿的谐波**（谐波减速器）被列入外骨骼机器人概念股（新浪股吧）； + - 三瑞智能新增"人形机器人"概念（东方财富）。 + - ⚠️ 上述"概念股"多为媒体/股吧归类，**不具备官方行业分类效力**，需以公司公告为准。 +- **行业研究服务活跃**：前瞻、智研咨询等机构密集发布《2026年中国外骨骼机器人行业…投资策略/全景图谱》报告（qianzhan.com、caifuhao.eastmoney.com），反映资本市场关注度上升，但此类报告多为商业付费研究，数据口径自成体系。 + +## 四、投资趋势判断（基于以上证据） + +1. **融资从"医疗康复单点"走向"C端消费+多场景"**：程天科技降价至千元级、布局消费级，标志赛道估值逻辑从"医疗器械"向"消费电子+硬件放量"迁移。 +2. **产业资本与健康电器上市公司跨界定投**（荣泰健康），预示"外骨骼+X"整合型投资增多。 +3. **上游零部件是最确定的受益环节**（谐波减速器、柔性驱动器、伺服），投资确定性强于整机品牌。 +4. **政策—资本共振**：银发经济被预测将达 **30 万亿级**（中新网 chinanews.com.cn/cj/2026/07-03/10652235），适老外骨骼被点名"迎风口"，构成投资主题支撑。 + +## 五、局限与核验入口（如实标注) + +- 融资**总笔数/总金额的行业级统计**：本次检索未获得权威汇总数据，现有公开信息以单笔事件为主，**无法给出精确年度总额**，建议以以下入口核验：IT桔子、企查查"杭州程天科技发展有限公司"工商与融资档案（qichacha.com）、投资界（pedaily.cn）。 +- 市场规模缺乏官方口径，建议对照：**国家统计局**（stats.gov.cn）《国民经济和社会发展统计公报》、**工信部**装备工业一司机器人产业数据、**中国残疾人联合会**康复辅具相关统计。 +- 全球市场规模（17.6亿美元/43% CAGR）为二手转述，原始出处需回溯海外研究机构原文后方可引用。 + +## [subtask_6] 整合撰写《2026年中国外骨骼机器人行业市场分析报告》 (writer) + +# 2026年中国外骨骼机器人行业市场分析报告 + +> **报告说明**：本报告数据截止于 2026 年 8 月。全文遵循"口径并列"原则：凡同一指标出现官方口径与泛行业口径冲突者，均并列标注、不取单一结论；凡属本报告推算而非机构直接发布的数据，均标注"本报告推算"；凡未能定位官方文件编号的信息，均标注"待核实"。 + +--- + +## 一、核心结论 + +- **规模尚无统一定论**。IDC 口径 2025 年中国外骨骼机器人市场规模超 16 亿元、出货约 2.6 万台；泛行业口径则为 40—42 亿元。两者相差约 2.6 倍，差额主要来自统计范围（设备出货 vs 含服务、租赁、康复项目的广义市场）。本报告以 IDC 口径为主线，泛行业口径作为乐观情景并列。 +- **2026 年主线预测约 20 亿元**。在 IDC 2025 年 16 亿元基数上，按共研产业研究院"2026 年市场规模同比增长 28.7%"的增速测算，2026 年约为 20.6 亿元（**本报告推算，非机构直接发布**）。 +- **政策支持是"搭车式"而非"点名式"**。外骨骼未作为独立品类被政策单列，而是依托银发经济、养老服务机器人、康复辅助器具三大政策篮子获得牵引；最硬的依据是民政部等 14 部门《康复辅助器具产业扩能提质三年行动方案（2026—2028 年）》。 +- **市场呈"医疗级 / 消费级"双轨分化**。医疗康复级客单价高、走资质与医院采购；消费级单价下探至千元级，是销量增长最快的价格带。两者准入路径、支付逻辑与客户结构完全不同，不应合并统计。 +- **资本从单轮驱动转向双轮驱动**。互联网战投（蚂蚁、美团）、美元基金（IDG、红杉）与中东主权资本同时入场，赛道估值逻辑由"医疗器械"向"消费电子 + 硬件放量"迁移。 +- **最大短板是标准体系**。检索未确认存在专门针对外骨骼机器人的国家级标准，行业主要依赖康复辅助器具、医用机器人、电气安全等既有通用标准交叉覆盖。 + +--- + +## 二、口径说明与研究边界 + +| 维度 | 本报告处理方式 | +|---|---| +| 产品范围 | 涵盖医疗康复级、消费级（助行/助老/户外助力）、工业与军工用外骨骼 | +| 地域范围 | 中国大陆市场为主，全球数据仅作参照 | +| 时间范围 | 以 2025 年实际、2026 年预测为主，含中长期展望 | +| 规模口径 | **主口径**为 IDC 设备销售/出货统计；**并列口径**为泛行业"含服务、租赁、康复项目"的广义推算 | +| 格局口径 | 因无权威统一市占率榜单，本报告**不列示具体份额数字**，仅按路线分类描述竞争态势 | + +--- + +## 三、市场规模与 2026 年预测 + +### 3.1 两套口径并列 + +| 口径 | 2025 年规模 | 增长特征 | 来源 | +|---|---|---|---| +| IDC（设备出货统计） | 市场规模**超 16 亿元**，出货量约 **2.6 万台** | — | IDC，转引自 IT之家 ithome.com/0/985/443.htm | +| 泛行业/券商口径 | 2025 年预计达 **42 亿元** | 未来五年 CAGR 约 **50%** | 雪球行业梳理 xueqiu.com/2071397530/331411470（**非机构一手数据，需谨慎**） | +| 泛行业媒体口径 | 预计 2025 年超 **40 亿元** | — | 华经/搜狐 news.sohu.com/a/726526171 | + +- **差额原因**：16 亿元属"设备销售/出货统计"口径，可核验性更强；40—42 亿元多为机构对含服务、租赁、康复项目的广义市场推算。本报告建议以 16 亿元为主锚点，广义口径仅作潜力参照。 +- **注意**：上述 40 亿元与 42 亿元出自不同来源，数值接近但并非同一份统计，不应相互印证。 + +### 3.2 2026 年预测 + +- 共研产业研究院数据：**2026 年中国外骨骼机器人需求量预计同比增长 31.6%，市场规模同比增长 28.7%**（转引自机器人大讲堂 leaderobot.com/news/7335）。 +- 以 IDC 2025 年 16 亿元为基数、按 +28.7% 推算，**2026 年约 20.6 亿元（本报告推算）**。 +- 若按泛行业口径"未来五年 CAGR 约 50%"推演，2026 年将显著高于 20 亿元。**两套口径的增速假设不一致，本报告并列呈现，不作调和。** + +### 3.3 全球参照 + +- 2024 年全球可穿戴外骨骼市场规模 **17.6 亿美元**，预计 2032 年前复合增长率超 **43%**（转引自投资界 pedaily.cn/202603/561388，原始出处为海外研究机构，**待回溯原文**）。 +- 开源证券研报：预计 **2030 年全球市场规模达 146.7 亿美元，CAGR 42.2%**（转引自中国金融信息网 m.cnfin.com，2025-08-22）。 + +### 3.4 一个必须指出的口径矛盾 + +IDC 口径显示 **2025 年全行业出货约 2.6 万台**；而程天科技创始人王天**预估其单家 2026 年消费级出货即达 6—10 万台**（36氪，2025）。 + +- 单一企业次年预测量 > 上一年全行业实际量，说明两者口径不同： + - IDC 2.6 万台很可能仅覆盖**医疗级/有源康复设备**（单价高、需资质、走医院采购）； + - 程天预估量属**消费级/轻有源助行产品**（单价千元级、走电商）。 +- **结论：中国外骨骼不存在统一的"市场规模"数字，报告应分设"医疗康复级（B 端/院内）"与"消费级（C 端/助行穿戴）"两条口径分别列示。** + +--- + +## 四、细分结构与需求侧驱动 + +### 4.1 按技术类型 + +- **动力下肢外骨骼主导**市场（前瞻产业研究院《2026 年全球外骨骼机器人行业发展现状：动力下肢主导》）。 + +### 4.2 按应用场景（定性判断） + +| 场景 | 特征 | 商业化状态 | +|---|---|---| +| 医疗康复 | 医院端客单价高、利润厚，是高端市场核心 | 成熟度相对最高，走器械注册与院内采购 | +| 消费级（助行/助老/户外"爬山裤"） | 单价下探至千元级，**销量增长最快** | 电商与景区租赁是主要验证场 | +| 工业/军工 | B 端场景，标准化程度待提升 | 尚处早期 | + +### 4.3 需求侧驱动 + +- **银发经济**：2026 年 1 月八部门联合出台 14 项举措促进银发经济发展，明确"鼓励养老服务机器人产业发展"（武汉市相关部门转发页 whwx.gov.cn，2026-01-14）。 +- **场景渗透**：外骨骼使用场景由医院扩展至景区、居家，泰山登山、"80 元租机械腿"、景区租赁成为消费级最早的商业化验证路径。 +- **待核实项**：报告中引用的"3.23 亿老年人"来自微博文章，属**非权威口径**，正式定稿前应以国家统计局数据核实。 + +--- + +## 五、政策支持与监管环境 + +### 5.1 产业政策：三只政策篮子 + +| 时间 | 政策 | 与外骨骼的关系 | 来源 | +|---|---|---|---| +| 2026 年 7 月 | **民政部等 14 部门《康复辅助器具产业扩能提质三年行动方案（2026—2028 年）》** | 明确**支持治疗性康复辅具纳入医保**，是本行业最强政策信号 | gov.cn；中新经纬 2026-07-13 | +| 2026 年 1 月 | 八部门 14 项举措促进银发经济 | 鼓励养老服务机器人产业，为助行/康复场景提供需求牵引 | whwx.gov.cn，2026-01-14 | +| 2025 年 7 月 | 国家药监局 2025 年第 63 号公告 | 优化高端医疗器械全生命周期监管与审评审批 | 上海市药监局转发页 yjj.sh.gov.cn，2025-07-04 | + +- **要点**：外骨骼的政策红利是"搭车式"的——需在其上层类别（康复辅助器具、养老/康养机器人、高端医疗器械）文件中寻找依据。 +- 另有 14 部门联合发文聚焦脑机接口、康养机器人、仿生假肢，被媒体称为进入"国家级攻坚周期"，但**发文字号与全称未在检索结果中确认，待核实**（来源为知乎专栏转载，非官方原文）。 + +### 5.2 支付与医保 + +- **媒体口径**："外骨骼首纳医保规划，百亿市场空间开启"（21 财经 2026-08-20、环球网 finance.huanqiu.com/article/4Sry9yPEeW4）。**未给出官方文件编号与具体条目，属媒体转述，须待官方文件核实**；且"百亿"为市场空间预期，非当期实际规模。 +- **试点层面**：检索到《2026 中国康复机器人训练效果评估及医保支付试点》等文档，提示医保支付仍处**试点探索**阶段，尚未全国性纳入报销目录。此类文档多为第三方研究/文档平台 + diff --git a/eai_agentplatform/test/general_assistant/run_orchestrated_report/meta.txt b/eai_agentplatform/test/general_assistant/run_orchestrated_report/meta.txt new file mode 100644 index 0000000..1543b49 --- /dev/null +++ b/eai_agentplatform/test/general_assistant/run_orchestrated_report/meta.txt @@ -0,0 +1,4 @@ +latency_ms=182074 +artifacts=6 +err= +finished=2026-09-25T23:55:43+08:00 diff --git a/eai_agentplatform/test/general_assistant/run_orchestrated_report/query.txt b/eai_agentplatform/test/general_assistant/run_orchestrated_report/query.txt new file mode 100644 index 0000000..2152e2e --- /dev/null +++ b/eai_agentplatform/test/general_assistant/run_orchestrated_report/query.txt @@ -0,0 +1 @@ +请写一份2026年中国外骨骼机器人行业的市场分析报告，涵盖市场规模、政策支持、龙头格局与投资趋势。 \ No newline at end of file diff --git a/eai_agentplatform/test/general_assistant/run_orchestrated_report/reply.md b/eai_agentplatform/test/general_assistant/run_orchestrated_report/reply.md new file mode 100644 index 0000000..7ef4381 --- /dev/null +++ b/eai_agentplatform/test/general_assistant/run_orchestrated_report/reply.md @@ -0,0 +1,176 @@ +# 2026年中国外骨骼机器人行业市场分析报告 + +> **报告说明** +> 1. **数据截止**：2026年8月。 +> 2. **口径并列原则**：凡同一指标存在官方口径与泛行业口径冲突者，一律并列标注，不取单一结论、不相互印证。 +> 3. **推算标注**：凡属本报告测算而非机构直接发布的数据，均标注"**本报告推算**"。 +> 4. **待核实标注**：凡未能定位官方文件编号、或来源为第三方研究/媒体转述的信息，均标注"**待核实**"，并给出官方核验入口。 +> 5. **份额留白**：因无权威统一市占率榜单，本报告**不列示任何具体市占率数字**。 + +--- + +## 一、核心结论 + +| # | 结论 | 关键依据 | +|---|---|---| +| 1 | **规模尚无统一定论**：IDC口径2025年中国市场规模超16亿元、出货约2.6万台；泛行业口径为40—42亿元，两者相差约2.6倍 | IDC（转引IT之家）；雪球/华经·搜狐（非一手） | +| 2 | **2026年主线预测约20.6亿元（本报告推算）**。以IDC 2025年16亿元为基数，套用共研产业研究院+28.7%的增速 | 共研产业研究院（转引机器人大讲堂） | +| 3 | **政策是"搭车式"而非"点名式"**：外骨骼未单列，依托康复辅助器具、养老/康养机器人、高端医疗器械三只政策篮子 | 民政部等14部门三年行动方案（gov.cn） | +| 4 | **市场呈"医疗级 / 消费级"双轨分化**，准入路径、支付逻辑、客户结构完全不同，不应合并统计 | IDC 2.6万台 vs 程天单家6—10万台预估的口径矛盾 | +| 5 | **资本从单轮驱动转向双轮驱动**：蚂蚁、美团、IDG、红杉、沙特资本同时入场，估值逻辑由"医疗器械"向"消费电子+硬件放量"迁移 | 投资界、腾讯新闻、新浪财经 | +| 6 | **最大短板是标准体系**：未确认存在专门针对外骨骼机器人的国家级标准 | 检索未获得可核验的GB/T原文，**待核实** | + +--- + +## 二、研究边界与口径说明 + +| 维度 | 本报告处理方式 | +|---|---| +| 产品范围 | 医疗康复级、消费级（助行/助老/户外助力）、工业与军工用外骨骼 | +| 地域范围 | 中国大陆市场为主，全球数据仅作参照 | +| 时间范围 | 2025年实际、2026年预测为主，含中长期展望 | +| 规模口径 | **主口径**为IDC设备销售/出货统计；**并列口径**为泛行业"含服务、租赁、康复项目"的广义推算 | +| 格局口径 | 无权威统一市占率榜单，仅按路线分类描述竞争态势，不列示份额数字 | + +--- + +## 三、市场规模与2026年预测 + +### 3.1 两套口径并列 + +| 口径 | 2025年规模 | 增长特征 | 来源 | +|---|---|---|---| +| **IDC（设备出货统计）** | 市场规模**超16亿元**，出货量约**2.6万台** | — | IDC，转引自IT之家 ithome.com/0/985/443.htm | +| 泛行业/券商口径 | 预计达**42亿元** | 未来五年CAGR约**50%** | 雪球行业梳理 xueqiu.com/2071397530/331411470（**非机构一手数据，需谨慎**） | +| 泛行业媒体口径 | 预计超**40亿元** | — | 华经/搜狐 news.sohu.com/a/726526171 | + +- **差额原因**：16亿元属"设备销售/出货统计"口径，可核验性更强；40—42亿元多为机构对含服务、租赁、康复项目的广义市场推算。 +- **重要提示**：上述40亿元与42亿元出自不同来源，数值接近但**并非同一份统计，不应相互印证**。 + +### 3.2 2026年预测 + +- 共研产业研究院：**2026年中国外骨骼机器人需求量预计同比增长31.6%，市场规模同比增长28.7%**（转引自机器人大讲堂 leaderobot.com/news/7335）。 +- 以IDC 2025年16亿元为基数、按+28.7%推算，**2026年约20.6亿元（本报告推算，非机构直接发布）**。 +- 若按泛行业口径"未来五年CAGR约50%"推演，2026年将显著高于20亿元。**两套增速假设不一致，本报告并列呈现，不作调和。** + +### 3.3 全球参照 + +| 指标 | 数值 | 来源 | 备注 | +|---|---|---|---| +| 2024年全球可穿戴外骨骼市场规模 | **17.6亿美元** | 转引自投资界 pedaily.cn/202603/561388 | 原始出处为海外研究机构，**待回溯原文** | +| 2032年前全球CAGR | 超**43%** | 同上 | 同上 | +| 2030年全球市场规模 | **146.7亿美元**，CAGR 42.2% | 开源证券研报，转引自中国金融信息网 m.cnfin.com（2025-08-22） | 券商口径 | + +### 3.4 一个必须指出的口径矛盾 + +- IDC口径显示 **2025年全行业出货约2.6万台**； +- 程天科技创始人王天**预估其单家2026年消费级出货即达6—10万台**（36氪，2025）。 + +**单一企业次年预测量 > 上一年全行业实际量**，说明两者统计对象不同： + +| 维度 | IDC 2.6万台 | 程天 6—10万台预估 | +|---|---|---| +| 产品属性 | 医疗级/有源康复设备 | 消费级/轻有源助行产品 | +| 单价 | 高（数十万元级） | 千元级 | +| 渠道 | 医院采购、需资质 | 电商、景区租赁 | + +**结论：中国外骨骼不存在统一的"市场规模"数字。报告应分设"医疗康复级（B端/院内）"与"消费级（C端/助行穿戴）"两条口径分别列示。** + +--- + +## 四、细分结构与需求侧驱动 + +### 4.1 按技术类型 + +- **动力下肢外骨骼主导**市场（前瞻产业研究院《2026年全球外骨骼机器人行业发展现状：动力下肢主导》）。 + +### 4.2 按应用场景 + +| 场景 | 特征 | 商业化状态 | +|---|---|---| +| **医疗康复** | 医院端客单价高、利润厚，是高端市场核心 | 成熟度相对最高，走器械注册与院内采购 | +| **消费级**（助行/助老/户外"爬山裤""爬楼机"） | 单价下探至千元级，**销量增长最快**，是放量主力 | 电商与景区租赁是主要验证场 | +| **工业/军工** | B端场景，标准化程度待提升 | 尚处早期 | + +### 4.3 需求侧驱动 + +- **银发经济**：2026年1月**八部门联合出台14项举措促进银发经济发展**，明确"鼓励养老服务机器人产业发展"（武汉市相关部门转发页 whwx.gov.cn，2026-01-14）。 +- **场景渗透**：使用场景由医院扩展至景区、居家。泰山登山、"80元租机械腿"、景区租赁成为消费级最早的商业化验证路径。 +- **待核实项**：报告中出现的"3.23亿老年人"来自微博文章，属**非权威口径**，正式定稿前应以国家统计局数据核实。 + +--- + +## 五、政策支持与监管环境 + +### 5.1 产业政策：三只政策篮子 + +| 时间 | 政策 | 与外骨骼的关系 | 来源 | +|---|---|---|---| +| **2026年7月** | **民政部等14部门《康复辅助器具产业扩能提质三年行动方案（2026—2028年）》** | 明确**支持治疗性康复辅具纳入医保**，是本行业最强政策信号 | gov.cn；中新经纬2026-07-13 | +| 2026年1月 | 八部门14项举措促进银发经济 | 鼓励养老服务机器人产业，为助行/康复场景提供需求牵引 | whwx.gov.cn，2026-01-14 | +| 2025年7月 | **国家药监局2025年第63号公告**《关于优化全生命周期监管支持高端医疗器械创新发展有关举措的公告》 | 为高端医疗器械（含部分康复/外骨骼类）提供审评审批加速与全生命周期监管优化 | 上海市药监局转发页 yjj.sh.gov.cn，2025-07-04 | + +- **要点**：外骨骼的政策红利是"**搭车式**"的——需在其上层类别（康复辅助器具、养老/康养机器人、高端医疗器械）文件中寻找依据。 +- 另有14部门联合发文聚焦脑机接口、康养机器人、仿生假肢，被媒体称为进入"国家级攻坚周期"，但**发文字号与全称未在检索结果中确认，待核实**（来源为知乎专栏转载，非官方原文）。 +- **地方落地**：上海康复辅具租赁实现全覆盖（上海市政府新闻办），并新增情感陪伴型机器人，说明"租赁+服务"模式已在地方财政层面落地。 + +### 5.2 支付与医保 + +| 层级 | 现状 | 来源性质 | +|---|---|---| +| 全国性纳入报销 | **未见全国性纳入的官方文件** | — | +| 政策方向 | 《三年行动方案（2026—2028年）》支持治疗性康复辅具纳入医保 | **官方口径，最硬依据** | +| 媒体表述 | "外骨骼首纳医保规划，百亿市场空间开启"（21财经2026-08-20；环球网 finance.huanqiu.com/article/4Sry9yPEeW4） | **媒体转述，未给出官方文件编号与条目，待核实**；且"百亿"为**市场空间预期**，非当期实际规模 | +| 试点探索 | 《2026中国康复机器人训练效果评估及医保支付试点》等文档 | **第三方研究/文档平台内容，非官方文件；试点≠落地**，具体地区、比例、项目编码待核实 | +| 制度前哨 | 北京为脑机接口定价并纳入甲类医保 | 反映创新器械价格立项与医保通道正在打开（多家转引，**待核实**） | + +### 5.3 监管呈"双轨制" + +| 轨道 | 适用产品 | 准入路径 | +|---|---|---| +| **医疗级** | 以治疗、改善功能为目的，宣称医疗康复用途 | 医疗器械注册（多为II/III类），走药监局体系 | +| **消费级** | 仅作助行、户外助力 | 通常不走医疗器械审批，按普通产品路径 | + +- 医疗器械产品分类界定：《2025年第二次医疗器械产品分类界定结果汇总》涉及新型/康复类器械归类问题（来源为知乎专栏转载），**具体外骨骼产品的分类界定结论需回到国家药监局官网原文核对，待核实**。 +- **安全性争议**：媒体《上万元的"行走外挂"，竟导致关节炎？》（tech.ifeng.com）反映安全议题，属**媒体导向内容，非官方结论**，但提示标准与监管建设的紧迫性。 + +--- + +## 六、标准体系：行业最大短板 + +- 检索**未能确认**已发布的、专门针对"外骨骼机器人"的国家标准（如GB/T编号）原文；检索中出现的GB/T相关信息多为噪声结果，无法核实。 +- 可确认的相邻线索： + - 《老年人外骨骼机器人安全科普与选购标准》类**团体/科普性**标准提示（来源：消费评测平台 post.smzdm.com），**属行业/平台口径，非国标**； + - 康复机器人领域的**安全防护**已被行业普遍视为"核心红线"（同上来源）。 +- **结论**：中国外骨骼机器人**尚未形成独立、完整的国家级标准体系**，当前更多依赖"**康复辅助器具 + 医用机器人 + 电气安全**"等既有通用标准交叉覆盖。此结论为基于检索的判断，建议在正式报告中以**全国标准信息公共服务平台（std.samr.gov.cn）**检索结果为准。 + +--- + +## 七、龙头格局与竞争态势 + +> 前置说明：市场不存在权威统一市占率榜单；前瞻、中研普华等机构有《2026年中国外骨骼机器人行业竞争格局及企业布局》类报告，但具体份额数据需付费获取——**本报告不编造份额数字**。 + +### 7.1 三分法格局 + +**A. 医疗康复级（"深" vs "广"两条路线）** + +| 企业 | 定位/特征 | 来源 | +|---|---|---| +| **程天科技**（杭州程天科技发展有限公司） | 医疗康复"做深"，2025年起推C端消费级（"爬楼机"） | 36氪 / 百度百科 | +| **傅利叶智能** | 康复"做广"，产品线宽 | 知乎《程天做"深"，傅利叶做"广"》 | +| **迈步机器人** | 老牌下肢康复机器人企业，常与傅利叶对比；2026-08-27完成近亿元融资 | 前瞻/搜狐；投资界 pedaily.cn/202608/568172 | +| **大艾机器人**（北京大艾） | 医疗康复代表厂商 | 百度百科 | + +**B. 消费级（爆发主战场）** + +| 企业 | 关键数据 | 来源 | +|---|---|---| +| **极壳科技（Hypershell）** | 2021年成立，自称"全球消费级外骨骼定义者"；2025年Pre-B+B轮累计**7000万美元**；2026年再完成**5000万美元B+轮**（蚂蚁集团、美团龙珠入局）；累计出货数万台 | 36氪/MSN/腾讯新闻/东方财富 | +| **程天科技（C端）** | 消费级"爬楼机"，**2026年出货预估6—10万台** | 36氪 | +| **精工科技**（上市公司） | 单关节（髋关节）助力机器人，二代产品即将亮相；曾澄清未与京东物流、顺丰签试用协议 | 搜狐/同花顺/36氪 | + +**C. 跨界/生态玩家** + +- **家电巨头**："2000亿市值家电巨头瞄准3亿老年人"（腾讯新闻，2026-06），指向大型家电企业切入银发助行赛道。 +- **优必选**：人形机器人企业，团队背景与外骨骼相关（凤凰网）。 +- **渠道与营销**：罗永浩带货、CES外骨骼扎堆亮相 \ No newline at end of file diff --git a/eai_agentplatform/test/general_assistant/run_single_search/meta.txt b/eai_agentplatform/test/general_assistant/run_single_search/meta.txt new file mode 100644 index 0000000..e79a8a7 --- /dev/null +++ b/eai_agentplatform/test/general_assistant/run_single_search/meta.txt @@ -0,0 +1,4 @@ +latency_ms=15915 +artifacts=0 +err= +finished=2026-09-25T23:52:41+08:00 diff --git a/eai_agentplatform/test/general_assistant/run_single_search/query.txt b/eai_agentplatform/test/general_assistant/run_single_search/query.txt new file mode 100644 index 0000000..eec9721 --- /dev/null +++ b/eai_agentplatform/test/general_assistant/run_single_search/query.txt @@ -0,0 +1 @@ +查询2026年9月25日人民币兑美元的汇率是多少？ \ No newline at end of file diff --git a/eai_agentplatform/test/general_assistant/run_single_search/reply.md b/eai_agentplatform/test/general_assistant/run_single_search/reply.md new file mode 100644 index 0000000..fa40194 --- /dev/null +++ b/eai_agentplatform/test/general_assistant/run_single_search/reply.md @@ -0,0 +1,15 @@ +很抱歉，我无法给出 2026年9月25日 人民币兑美元汇率的准确数值——检索到的结果只提供页面链接，未返回该日的具体报价/中间价数值，我不会凭猜测填数。 + +**情况说明** +- 9月25日为交易日（周五），中国外汇交易中心每个交易日上午 9:15 左右受权发布当日人民币汇率中间价。 +- 检索到的可核实来源显示：中国外汇交易中心/PBoC 已发布 2026年9月21日、22日、23日等交易日的中间价公告，但页面摘要中未包含具体数值，第三方站点（如 cngold、同花顺）的当日文章同样未返回可用数值。 + +**建议以官方渠道核对（权威、实时）** +1. 中国人民银行·人民币汇率中间价公告（逐日公布）： + https://www.pbc.gov.cn/zhengcehuobisi/125207/125217/125925/index.html +2. 中国货币网（CFETS）人民币汇率中间价公告： + https://www.chinamoney.com.cn/chinese/ccprnoticemain/ +3. 中国银行外汇牌价（含现汇/现钞买卖价，实际换汇适用）： + https://www.cngold.org/fx/boc.html + +**小提示**：若你需要的是"实际换汇价"，请区分三个口径——央行中间价（基准）、银行现汇买入/卖出价（含点差）、以及离岸 CNH 实时价，三者数值不同。告诉我具体用途，我可以说明该看哪一个。 \ No newline at end of file diff --git a/start_dev_10231_10232.sh b/start_dev_10231_10232.sh index d909a50..b382a09 100755 --- a/start_dev_10231_10232.sh +++ b/start_dev_10231_10232.sh @@ -69,7 +69,7 @@ APP_DIR="$REPO_DIR/eai_agentplatform" BACKEND_DIR="$APP_DIR/backend-go" BACKEND_BIN="$BACKEND_DIR/bin/eai_agentplatform-server" FRONTEND_DIR="$APP_DIR/frontend" -DEV_BIND_HOST="${EAI_DEV_BIND_HOST:-127.0.0.1}" +DEV_BIND_HOST="${EAI_DEV_BIND_HOST:-0.0.0.0}" DEBUG_LOG_DIR="$REPO_DIR/debuglog" mkdir -p "$DEBUG_LOG_DIR" @@ -79,6 +79,16 @@ FRONTEND_LOG="$DEBUG_LOG_DIR/frontend_${RUN_ID}.log" BACKEND_PID_FILE="$DEBUG_LOG_DIR/backend.pid" FRONTEND_PID_FILE="$DEBUG_LOG_DIR/frontend.pid" +# 加载本地运行 secrets（.env 已被 .gitignore 忽略，不进版本库）。 +# 例如 SERPAPI_API_KEY 等环境变量，供后端进程继承（backed 用 `env PORT=... $BIN` 启动， +# 会继承本 shell 导出的所有环境变量）。文件不存在时静默跳过。 +if [ -f "$APP_DIR/.env" ]; then + set -a + # shellcheck disable=SC1091 + source "$APP_DIR/.env" + set +a +fi + check() { local label="$1" local fix_hint="$2" diff --git a/test/general_assistant/README.md b/test/general_assistant/README.md new file mode 100644 index 0000000..51bf0f1 --- /dev/null +++ b/test/general_assistant/README.md @@ -0,0 +1,49 @@ +# 通用专员测试归集 + +按轮次组织，每次运行一个独立子目录 `run_<序号>`。 +每个子目录包含： + +| 文件 | 内容 | +|---|---| +| `request.json` | 发送的请求体 | +| `response.json` | 后端完整响应（含正文与产物） | +| `summary.md` | 单次结论（意图类别/耗时/字数/是否编排/落库数） | + +覆盖的三类路径：`direct_answer`(直答) / `single_search`(单问联网) / `orchestrated`(多 Agent 编排)。 + +## 本轮测试记录（2026-09-25） + +| run | 场景 | 意图 | 结果 | 备注 | +|---|---|---|---|---| +| `run_01` | 人形机器人行业报告（挂载 task 94） | orchestrated | ✅ 21 子任务/19547字 + details，落库 11 条 | 编排+落库共生验证 | +| `run_02` | 具身智能行业事件/融资搜索 | single_search | ⚠️ 搜索空，诚实降级 | SearXNG 上游无结果 | +| `run_03` | 周末放松闲聊 | direct_answer | ✅ 302字，无联网 | 快答 | +| `run_04` | 宇树/优必选/智元对比 | orchestrated | ✅ 16 子任务/12593字 + details | 公司对比 | +| `run_05` | Tesla Optimus 定价（英文） | single_search | ⚠️ 搜索空，诚实降级 | SearXNG 上游无结果 | + +## ⚠️ 阻塞发现：SearXNG 上游引擎失效 +编排/直答路径正常；但**单问联网搜索几乎必然"无结果"**。根因不在本项目代码，而在 SearXNG 服务器自身： + +- **baidu / sogou**：`Suspended: CAPTCHA`（被中文搜索引擎验证码封锁） +- **wikipedia**：`ConnectTimeout`（外网超时） +- **bing**：返回 200 但解析 0 条（疑似 CDN/区域校验页） +- **google / duckduckgo**：宿主机不可达（`000` 连接超时，已被墙） +- **bilibili**：✅ 唯一可用，20 条结果 + +→ 可用引擎仅剩 1 个，实时资讯类查询（汇率/行业融资/新闻）在百度/搜狐被封后落到空结果。 + +## 修复尝试与最终结论（2026-09-25） + +按用户方向「接入可用的第三方搜索源」，新建 `search/sogou.go` 搜狗兜底源 + `client.Search` 多源回退（SearXNG 空/失败 → 搜狗），并加了验证码页识别与一次退避重试。解析器针对真实搜狗页面结构（`

    标题`）适配，`TestParseSogouFixture` 用真实抓取页断言 6 条干净结果、通过。 + +**但最终验证发现：所有免费、墙内可访问的搜索源均对「无头 HTTP 抓取」启用反爬，无法稳定作为生产上游：** + +| 源 | 反爬机制 | +|---|---| +| baidu / sogou | JS/SNUID/CAPTCHA 人机校验（需执行 JS 或真实浏览器） | +| bing (cn) | 非浏览器 UA 返回无关缓存页，不按关键词匹配 | +| google / duckduckgo | 宿主机不可达（网络阻断） | +| 360 so.com | 302 反爬重定向 | +| bilibili（经 SearXNG） | ✅ 唯一可用，但结果是视频类内容，非通用网页 | + +**结论**：SearXNG 空结果并非 SearXNG 自身故障，而是其所有上游引擎均对当前数据中心 IP 的 HTTP 抓取封禁。搜狗兜底代码架构就绪、解析可用，但源在持续探触后升级为 `checkSNUID` JS 校验页，无法由纯 Go HTTP 客户端通过。**要恢复通用联网闭环，需在「付费搜索 API / 真实浏览器(Playwright) / 代理池」三选一投入**（属部署/预算决策，见对话）。 \ No newline at end of file diff --git a/test/general_assistant/run_01/request.json b/test/general_assistant/run_01/request.json new file mode 100644 index 0000000..743aa2a --- /dev/null +++ b/test/general_assistant/run_01/request.json @@ -0,0 +1 @@ +{"message":"拆分多个子任务，撰写2026年人形机器人行业深度报告：市场规模、技术路线、主要厂商、投资建议四部分。","mode":"quick","task_id":94,"specialist_key":""} diff --git a/test/general_assistant/run_01/response.json b/test/general_assistant/run_01/response.json new file mode 100644 index 0000000..8dde34d --- /dev/null +++ b/test/general_assistant/run_01/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"# 2026年人形机器人行业深度报告（框架稿·合并终版）\n\n\u003e **⚠️ 数据可信度前置声明**\n\u003e 本次撰写全流程中，**联网检索通道持续不可用**（对中英文、窄词/宽词共 20+ 组关键词测试均返回空结果），**未能取得任何可核验的实时来源**。为保证结论可追溯、不编造，本报告**不填充未经核实的数字**，改以「框架 + 缺口清单」形式交付。\n\u003e 凡标注 `【待核验】`（业内常见引用、本次未确认）、`🔲 待补`（无任何来源）处，**均不得作为投资决策依据**，须待数据核验后升级为终稿。\n\u003e 本报告为行业研究性质，**不构成任何证券买卖建议**。\n\n---\n\n## 一、报告说明与统一口径\n\n| 项目 | 冻结口径 |\n|---|---|\n| 基期／预测区间 | 2025 为基期，重点预测 **2026**，延伸至 2030 |\n| 汇率 | 1 USD = 7.1–7.3 CNY（全文统一） |\n| 金额单位 | 亿美元 / 亿元人民币 |\n| 范围口径 | **口径①「人形机器人本体」**＝双足/轮式类人整机；**口径②「泛具身智能」**＝含四足、机械臂、人形。两者量级差异大，**必须分列，不可混用** |\n| 出货量 | 台/万台，含商用交付；科研赠样单列；**区分「签约/意向」与「实际交付」** |\n| 数据来源优先级 | 公司公告 \u003e 政府文件 \u003e 行业白皮书 \u003e 券商研报 \u003e 权威数据库 |\n\n---\n\n## 二、执行摘要（方向性判断，不含具体数值）\n\n1. **行业处于「从科研样机向小批量交付」过渡的早期阶段**；2026 年核心变量不是需求天花板，而是**头部厂商实际交付能否达到指引**。\n2. **规模测算最敏感变量是 ASP（整机均价）年降幅**，而非出货量本身；金额增速须与出货量增速**分列**，避免口径错配。\n3. **产业链瓶颈集中在少数硬件环节**（业内普遍指向行星滚柱丝杠、六维力/触觉传感器），而非整机集成能力。\n4. **技术路线核心分歧在「大脑」层**：端到端 VLA 与分层「规划＋控制」两条路线尚未收敛，**真实操作数据稀缺**是共同瓶颈。\n5. **投资环节优先级（建议，须按核验后的量产节奏调整）**：本体/执行器 \u003e 减速器与丝杠 \u003e 传感器 \u003e AI 芯片/算法 \u003e 场景应用。\n\n---\n\n## 三、市场规模\n\n### 3.1 测算框架（自下而上，可复现）\n\n$$市场规模_{2026} = \\sum_{场景} (出货量_{场景} \\times ASP_{场景})$$\n\n| 场景 | 2026 出货占比 | ASP 特征 | 说明 |\n|---|---|---|---|\n| 工业制造/汽车产线 | 🔲 待补 | 高 | 主机厂自用为主 |\n| 物流仓储搬运 | 🔲 待补 | 中高 | 与 AMR 竞合 |\n| 商业服务/导览 | 🔲 待补 | 中 | 展示属性强，真实 ROI 弱 |\n| 科研/教育 | 🔲 待补 | 高 | 当前主要「销量」来源，小批量 |\n| 家庭/消费 | 🔲 待补 | 中 | 2026 预计仍难放量 |\n| 特种/危险作业 | 🔲 待补 | 高 | 单价高、量小 |\n\n### 3.2 全球与中国规模（三情景框架）\n\n| 指标 | 悲观 | 基准 | 乐观 | 需核验的锚点来源 |\n|---|---|---|---|---|\n| 2025 全球出货量（台） | 🔲 | 🔲 | 🔲 | 特斯拉/宇树/优必选等出货指引 |\n| 2026 全球出货量（台） | 🔲 | 🔲 | 🔲 | 特斯拉等官方目标量级 |\n| 2026 中国出货量（台） | 🔲 | 🔲 | 🔲 | GGII / 中国电子学会 |\n| 2026 全球规模（亿美元） | 🔲 | 🔲 | 🔲 | 高盛/摩根士丹利/花旗 TAM 口径 |\n| 2026 中国规模（亿元） | 🔲 | 🔲 | 🔲 | 工信部/券商研报 |\n\n**【待核验】公开线索**（引用前必须补齐「机构全名＋报告名＋发布年月＋原始链接」，并核对最新版本）：\n- 高盛曾给出「2035 年全球人形机器人 TAM 约 380 亿美元」（base case），须核对是否已上调；\n- 摩根士丹利长期 TAM 曾给到「2050 年数万亿美元级」，属**远期口径，不可与 2026 短期预测混用**；\n- 工信部《人形机器人创新发展指导意见》（2023 年 11 月）提出「2025 年实现批量生产、2027 年形成安全可靠产业链」，属**政策口径，非市场预测**。\n\n### 3.3 增速口径\n\n$$\\text{CAGR} = \\left(\\frac{V_{2030}}{V_{2025}}\\right)^{1/5} - 1$$\n\n- 出货量 CAGR 与金额 CAGR **分别计算**；因 ASP 大概率下行，**金额 CAGR 通常低于出货量 CAGR**。\n- 须**同时给出短期 YoY（2025→2026）与长期 CAGR（→2030）**，避免用长期 CAGR 描述爆发初速。\n\n### 3.4 下游结构与区域分布\n- **下游结构**：以 3.1 场景表为基础填充饼图数据（🔲 待补）。\n- **区域分布**：建议分区为中国/北美/欧洲/日韩/其他，维度取「出货量＋产能＋供应链（核心零部件国产化率）」（🔲 待补）。\n\n### 3.5 关键假设清单（须在报告显性列出）\n1. **ASP 年降幅** —— 最敏感变量；\n2. 头部厂商 2026 实际交付能否达指引；\n3. 「签约/意向订单」向「实际交付」的转化率；\n4. 泛具身 vs 纯人形的口径边界；\n5. 汇率与统计口径（含/不含零部件）；\n6. 政策变量（补贴、政府采购）的外生拉动。\n\n---\n\n## 四、技术路线与产业链\n\n\u003e 本章为**技术分类与对比框架**（工程通识性判断）；凡涉及成本、用量、效率的具体数值**均标待核验**，不给出未经证实的数字。\n\n### 4.1 分层框架：「大脑—小脑—本体」\n\n| 层级 | 功能 | 关键技术 | 主要路线分歧 |\n|---|---|---|---|\n| 大脑（认知/决策） | 任务规划、语言理解、场景泛化 | VLA 端到端大模型、多模态 LLM | 端到端 VLA vs 分层「LLM 规划＋专用控制」 |\n| 小脑（运动控制） | 全身协调、平衡、步态、操作 | 强化学习、MPC、模仿学习、遥操作采数 | 模型化控制 vs 学习型控制 |\n| 本体（硬件） | 感知—执行物理载体 | 执行器、灵巧手、传感器、减速器、能源 | 电驱 vs 液压/气动；旋转 vs 直线 |\n\n### 4.2 执行器路线\n\n| 维度 | 旋转执行器 | 直线执行器 | 液压/气动 |\n|---|---|---|---|\n| 原理 | 电机＋减速器输出关节扭矩 | 电机＋丝杠转直线 | 流体驱动 |\n| 优势 | 结构、供应链成熟 | 力密度高、抗冲击、契合仿人腿型 | 功率密度高、柔顺 |\n| 劣势 | 力密度受限、膝踝区段偏高 | 丝杠加工难、密封与寿命问题 | 漏油、能效低、维护成本高 |\n| 量产瓶颈 | 减速器精度与一致性 | **行星滚柱丝杠加工设备与良率**（普遍认为最紧环节，待核验） | 供应链窄、成本高 |\n| 单机用量 | 🔲 待补 | 🔲 待补 | — |\n\n### 4.3 灵巧手\n\n| 维度 | 欠驱动 | 全驱动 |\n|---|---|---|\n| 自由度 | 少（常 ≤6） | 高（可达 11–20+） |\n| 成本/复杂度 | 低 | 高 |\n| 触觉传感 | 简单或无 | 阵列式触觉、指尖力觉 |\n| 应用倾向 | 量产优先方案 | 高精度操作方案 |\n\n**路线分歧**：整机厂（成本与可靠性优先）倾向欠驱动；研究机构与高端场景用全驱动。**各厂具体自由度与传感配置待核验。**\n\n### 4.4 传感器\n- **力/扭矩**：关节力控必需，**六维力传感器**为高端方案；\n- **触觉**：指尖阵列触觉是灵巧手「能否抓稳」的核心；\n- **视觉/惯导**：RGB-D ＋多相机 ＋ IMU；\n- **电子皮肤**：成熟度低，🔲 待核验。\n\n### 4.5 减速器与丝杠\n\n| 方案 | 特点 | 适用关节 |\n|---|---|---|\n| 谐波减速器 | 高精度、零背隙、轻 | 腕/手/旋转小关节 |\n| 行星减速器 | 高刚性、成本低、效率高 | 大腿等大扭矩关节 |\n| RV 减速器 | 高刚性、大负载 | 重载关节（人形中用量存疑，待核验） |\n| 行星滚柱丝杠 | 直线执行器核心 | 膝/踝/直线关节 |\n\n**关键变量**：谐波与行星的**单机用量与配比**是成本模型核心，🔲 待核验。\n\n### 4.6 VLA 与具身智能模型\n\n| 路线 | 代表方向 | 优势 | 劣势 |\n|---|---|---|---|\n| 端到端 VLA | 谷歌 RT 系列、Figure 自研、Physical Intelligence 等 | 泛化强、少手工建模 | 数据饥渴、可解释性差、算力要求高 |\n| 分层「大脑＋小脑」 | LLM/VLM 规划 ＋ 传统/RL 控制 | 可控、可工程化 | 泛化上限受限 |\n| 仿真＋遥操作采数 | Isaac 类仿真平台 ＋ 真人遥操作 | 缓解数据稀缺 | 存在 sim-to-real 落差 |\n\n**核心瓶颈**：**真实操作数据稀缺**与 **sim-to-real 迁移**，是当前路线分歧的根源。\n\n### 4.7 能耗与成本曲线\n- **能耗**受三重因素影响：电池能量密度、执行器效率、整机重量与自由度；续航是商业化落地硬约束。\n- **成本下降路径**：规模效应（BOM 摊薄）＋ 零部件国产化替代 ＋ 架构简化（减少自由度/传感器）。\n- **建议建模变量**：单机 BOM 拆分（执行器/减速器/丝杠/传感/芯片/电池），并给出量产 1 万台 vs 10 万台的成本弹性，🔲 均待数据核验。\n\n### 4.8 量产瓶颈与路线分歧汇总\n1. **行星滚柱丝杠**：加工设备、良率、产能（普遍点名的「卡脖子」环节）；\n2. **六维力/触觉传感器**：量产一致性与成本；\n3. **端到端 VLA 的数据**：真实数据采集成本高；\n4. **整机路线分歧**：电驱 vs 液压；旋转 vs 直线；欠驱动 vs 全驱动；端到端 vs 分层；\n5. **能耗/续航**：电池与轻量化的权衡。\n\n---\n\n## 五、主要厂商\n\n\u003e ⚠️ 本部分的厂商名单、产品参数、出货与订单数据**均属待核验**；下述仅给出**分类框架与筛选口径**，不列具体数值。原定 T4 子任务因检索通道失效未能产出可核验的厂商数据。\n\n### 5.1 分类架构（厂商矩阵维度）\n\n| 类别 | 代表方向（须逐家核验） | 关注要点 |\n|---|---|---|\n| 整机厂 | 特斯拉、Figure、Agility、1X；宇树、优必选、智元、傅利叶等 | 量产节点、交付量、订单转化 |\n| 核心零部件 | 谐波/行星减速器、行星滚柱丝杠、无框力矩电机 | 单机用量、单价、产能、良率 |\n| 传感器/执行器 | 六维力传感器、触觉阵列、灵巧手总成 | 量产一致性、国产化率 |\n| AI 平台/芯片 | VLA 模型、算力/边缘芯片 | 数据闭环、算力成本 |\n| 下游应用 | 汽车产线、物流仓储、商业服务 | 真实 ROI 与复购 |\n\n### 5.2 筛选标准（统一口径）\n量产交付实绩 · 订单/融资 · 专利 · 供应链地位 · 生态合作。\n\n### 5.3 输出规格（待数据填充）\n厂商矩阵表（产品/参数/出货/优劣势）＋ 竞争格局图。**每项须可追溯至公司公告或官方发布。**\n\n---\n\n## 六、投资建议\n\n\u003e ⚠️ 本部分为**方法论框架**，不含具体标的推荐，不构成投资建议；结论须待市场规模（第三章）与厂商数据（第五章）核验后重算。\n\n### 6.1 产业链投资地图（环节优先级）\n\n| 优先级 | 环节 | 逻辑（方向性） | 关键数据依赖 |\n|---|---|---|---|\n| 高 | 本体/整机 | 直接受益量产放量 | 出货指引、订单转化率 |\n| 高 | 执行器/丝杠/减速器 | 单机价值量＋瓶颈溢价 | 单机用量、BOM 拆分 |\n| 中高 | 传感器/灵巧手 | 高端方案增量 | 国产化率、价格曲线 |\n| 中 | AI 芯片/算法 | 数据与算力壁垒 | 模型路线收敛度 |\n| 中 | 场景应用 | 需求验证端 | 真实 ROI |\n\n### 6.2 标的筛选逻辑\n量产/交付验证 \u003e 定点/订单 \u003e 技术卡位 \u003e 生态绑定。\n\n### 6.3 估值方法\nPS、PE、EV/EBITDA、**订单/产能市值比**（早期行业 PS 更适用，须注明口径）。\n\n### 6.4 催化剂\n头部厂商量产交付节点 · 大额订单/定点 · 政策与补贴落地 · 关键零部件降本或国产替代突破 · 重磅模型/产品发布。\n\n### 6.5 风险提示\n1. 技术不及预期（VLA 泛化、续航）；2. 量产延迟（丝杠、传感器良率）；3. 政策变化；4. 估值过高；5. 供应链瓶颈；6. ASP 降幅超预期导致金额规模不及预期。\n\n---\n\n## 七、交付状态与待办（关键阻塞点）\n\n| 章节 | 状态 | 阻塞原因 |\n|---|---|---|\n| 三、市场规模 | 框架可交付，**数值缺失** | 检索通道失效，无法核验出货量/TAM |\n| 四、技术路线 | **框架可交付**，数值待核验 | 零部件用量/成本未获来源 |\n| 五、主要厂商 | **仅框架**，厂商数据缺失 | 未产出可核验厂商数据 |\n| 六、投资建议 | **方法论框架** | 依赖三、五章数据 |\n\n**T2 必须补齐的取数清单**：①高盛/摩根士丹利/花旗最新 TAM 原文（含日期版本）；②GGII/中国电子学会/券商中国出货与金额；③特斯拉、宇树、优必选、Figure、Agility 官方出货/产能指引；④工信部及地方政策原文；⑤行星滚柱丝杠、谐波、六维力传感器单机用量与单价；⑥单机 BOM 拆分与量产成本曲线；⑦各厂 VLA 模型版本与性能参数。\n\n**下一步建议（二选一）**：\n- **(a)** 恢复联网通道后，按上表逐项补数并重算第三章、\n\n\u003cdetails\u003e\u003csummary\u003e📋 本次由通用编排拆分执行\u003c/summary\u003e\n\n##### 制定报告框架、数据口径与写作规范（市场规模/技术路线/主要厂商/投资建议四部分）\n\n以下按“6 个子任务”拆解，避免过度切分，同时保留报告四大部分的必要环节。核心路径为：**框架口径 → 数据收集 → 三大内容章并行撰写 → 投资建议 → 统稿交付**。\n\n## 一、子任务拆解表\n\n| 编号 | 子任务 | 核心产出 | 依赖 | 并行性 | 联网取数 | 优先级 |\n|---|---|---|---|---|---|---|\n| T1 | **制定报告框架、数据口径与写作规范** | 四部分大纲：市场规模、技术路线、主要厂商、投资建议；指标定义、数据截止日、引用格式、图表规范、免责声明 | 无 | 串行起点 | 否 | P0 |\n| T2 | **多源数据与资料收集** | 市场规模预测、技术路线资料、厂商信息、政策/融资/下游应用数据库 | T1 | 内部可并行：市场线、技术线、厂商线、政策融资线 | **use_web_search=true** | P1 |\n| T3 | **撰写“市场规模”与“技术路线”章节** | 全球/中国市场规模、出货量、CAGR、竞争格局判断；技术路线分类、成熟度、成本曲线、瓶颈 | T2 | 与 T4 并行；章内市场/技术可并行 | 按需补数时 true | P1 |\n| T4 | **撰写“主要厂商”章节** | 整机厂、核心零部件、AI平台/芯片、传感器/执行器代表企业；产品、量产、订单、供应链、优劣势对比 | T2 | 与 T3 并行 | 按需补数时 true | P1 |\n| T5 | **撰写“投资建议”章节** | 产业链投资地图、环节优先级、标的筛选逻辑、估值方法、催化剂、风险提示 | T3、T4 | 串行，必须等 T3/T4 结论 | 否 | P2 |\n| T6 | **全文统稿、数据交叉校验与交付** | 合并终稿、图表编号、引用核验、逻辑一致性检查、合规审核、版本冻结 | T3、T4、T5 | 串行收口 | 否 | P0 |\n\n## 二、依赖与并行关系\n\n- **必须串行**：T1 → T2 → T3/T4 → T5 → T6 \n- **可并行**：\n - T2 内部四条资料线并行：市场规模、技术路线、主要厂商、政策/融资。\n - T3 与 T4 可并行撰写，因为都只依赖 T2 的数据底稿。\n - T3 内部“市场规模”与“技术路线”可先分头写，再合并统一口径。\n- **不可循环**：T5 依赖 T3、T4 的结论；T6 依赖全部内容。若 T5 发现数据缺口，应回到 T2 补充，而不是反向修改 T1 框架。\n\n## 三、T1 中需先冻结的关键口径\n\n1. **市场规模口径** \n - 范围：全球/中国、整机/核心零部件、人形机器人专用/泛具身智能。 \n - 指标：出货量（台）、市场规模（亿元/亿美元）、ASP、CAGR。 \n - 预测区间：以 2025 为基期，重点预测 2026，并延伸至 2030。 \n - 来源优先级：公司公告、行业白皮书、券商研报、政府文件、权威数据库。\n\n2. **技术路线口径** \n - 按“大脑—小脑—本体”分层。 \n - 本体：旋转执行器、直线执行器、液压、气动、自由度、灵巧手、传感器、能源。 \n - AI：端到端 VLA、分层控制、强化学习、遥操作、仿真训练。 \n - 输出：路线对比、成熟度、成本、量产瓶颈。\n\n3. **主要厂商口径** \n - 分类：整机厂、核心零部件、AI平台/芯片、传感器、执行器、下游应用。 \n - 筛选标准：量产交付、订单/融资、专利、供应链地位、生态合作。 \n - 输出：厂商矩阵、产品参数、优劣势、竞争格局。\n\n4. **投资建议口径** \n - 产业链环节优先级：本体 \u003e 执行器/灵巧手 \u003e 传感器 \u003e AI芯片/算法 \u003e 场景应用，具体按数据调整。 \n - 估值方法：PS、PE、EV/EBITDA、订单/产能市值比等。 \n - 风险：技术不及预期、量产延迟、政策变化、估值过高、供应链瓶颈。\n\n5. **写作规范** \n - 统一数据截止日、汇率、单位、图表编号、引用格式。 \n - 明确免责声明与 AI 辅助声明。 \n - 每章结论需可追溯到数据来源。\n\n## 四、建议执行顺序与里程碑\n\n1. **M1**：T1 完成，框架与口径冻结。 \n2. **M2**：T2 完成，形成数据底稿与来源清单。 \n3. **M3**：T3、T4 并行完成初稿。 \n4. **M4**：T5 完成投资建议，形成核心观点。 \n5. **M5**：T6 完成统稿、校验、交付。\n\n##### 检索并测算2026年人形机器人市场规模：全球/中国出货量与金额、CAGR、下游场景结构、区域分布与关键假设\n\n## ⚠️ 数据可信度声明（必须前置，请勿跳过）\n\n本次子任务要求联网取数，但 **web_search 工具在整个会话中持续返回空结果**——我对「2026人形机器人市场规模」「humanoid robot market size」「人形机器人」乃至「news」「robot」等 12 组关键词（中英文、长尾与通用词）逐一测试，全部返回「无结果」。据此判断**检索通道当前不可用**，我无法取得任何可核验的实时来源。\n\n按\"研究员\"职责规则（不凭记忆编造数字、每结论须可追溯），我**不会把记忆中的数字伪装成已核验数据**。因此本产物按三级可信度分层交付：\n\n| 标记 | 含义 | 可否直接进报告 |\n|---|---|---|\n| 【框架】 | 我自建的可复现测算模型与口径 | ✅ 可交付 |\n| 【待核验】 | 业内公开常引用的数字，**本次未核验**，仅提供线索供复核 | ❌ 须核验后才能引用 |\n| 【待补】 | 必须联网补齐的字段 | ❌ 空缺 |\n\n---\n\n# 子任务产物：2026年人形机器人市场规模 — 检索与测算\n\n## 1. 指标口径定义（对齐 T1）\n\n| 维度 | 定义 | 备注 |\n|---|---|---|\n| **范围口径** | 口径①「人形机器人本体」＝双足/轮式类人形态整机；口径②「泛具身智能」＝含四足、机械臂、人形 | 两者数量级差异大，**必须分列，不可混用** |\n| **出货量** | 单位：台（万台）；含商用交付，科研赠样需单列 | 区分「签约/意向」与「实际交付」 |\n| **市场规模** | ＝出货量 × ASP；单位：亿美元 / 亿元人民币 | 须注明是否含核心零部件 |\n| **ASP** | 整机均价；建议分场景给（工业型 / 消费型） | 人形 ASP 年降幅是关键假设 |\n| **CAGR** | 基期2025 → 目标年（2026、2030），几何平均 | 注明是出货量 CAGR 还是金额 CAGR |\n| **汇率** | 建议冻结 1 USD = 7.1–7.3 CNY，全文统一 | 需与 T1 一致 |\n\n## 2. 自建测算模型（自下而上，可复现）【框架】\n\n$$市场规模_{2026} = \\sum_{场景} (出货量_{场景} \\times ASP_{场景})$$\n\n**分场景拆分（本模型核心）：**\n\n| 场景 | 2026出货占比假设 | ASP 特征 | 说明 |\n|---|---|---|---|\n| 工业制造 / 汽车产线 | 基准最大 | 高（量产刚起步） | 主机厂自用为主 |\n| 物流仓储搬运 | 中 | 中高 | 与 AMR 竞合 |\n| 商业服务 / 导览 | 中 | 中 | 展示属性强，真实ROI弱 |\n| 科研 / 教育 | 早期最大 | 高（小批量） | 当前主要\"销量\"来源 |\n| 家庭 / 消费 | 极低 | 中 | 2026仍难放量 |\n| 特种 / 危险作业 | 低 | 高 | 单价高、量小 |\n\n\u003e ⚠️ 上述**占比为占位假设**，【待补】须用可核验的出货量数据替换后才能作为测算前提。\n\n## 3. 全球 / 中国出货量与金额 — 三情景区间【待补 + 待核验锚点】\n\n因无实时来源，我给出**结构化情景表框架**，并在锚点处标注需核验的公开线索：\n\n| 指标 | 悲观 | 基准 | 乐观 | 需核验的锚点来源 |\n|---|---|---|---|---|\n| 2025 全球出货量（台） | 【待补】 | 【待补】 | 【待补】 | 特斯拉/SH/宇树/优必选出货指引 |\n| 2026 全球出货量（台） | 【待补】 | 【待补】 | 【待补】 | 【待核验】马斯克曾提 Optimus 2026 目标量级 |\n| 2026 中国出货量（台） | 【待补】 | 【待补】 | 【待补】 | 【待核验】GGII / 中国电子学会 |\n| 2026 全球市场规模（亿美元） | 【待补】 | 【待补】 | 【待补】 | 【待核验】高盛、摩根士丹利、花旗 TAM 口径 |\n| 2026 中国市场规模（亿元） | 【待补】 | 【待补】 | 【待补】 | 【待核验】工信部/券商研报 |\n\n**【待核验】公开线索（记忆中，本次未能检索确认，务必复核原文与日期）：**\n- 高盛 一份2024年初研报给出\"2035年全球人形机器人 TAM 约380亿美元\"（base case）——**常被引用的口径，需核对最新是否上调**。\n- 摩根士丹利 长期 TAM 曾给出\"2050年数万亿美元级\"——**远期口径，与2026短期预测不可混用**。\n- 中国工信部《人形机器人创新发展指导意见》（2023年11月）提出\"**2025年实现批量生产、2027年形成安全可靠产业链**\"——**政策口径，非市场预测**。\n- 高工机器人（GGII）、中国电子学会 有年度中国人形机器人市场预测——**须核验具体年份数值**。\n\n\u003e 请 T2 补齐上述每一条的**机构全名 + 报告名 + 发布年月 + 原始链接**。\n\n## 4. CAGR 测算【框架】\n\n$$\\text{CAGR} = \\left(\\frac{V_{2030}}{V_{2025}}\\right)^{1/5} - 1$$\n\n- 出货量 CAGR 与金额 CAGR **分别计算**：因 ASP 下行，金额 CAGR 通常 **低于** 出货量 CAGR。\n- 短期（2025→2026）增速会比长期（→2030）更高，报告须同时给 **短期YoY** 与 **长期CAGR**，避免\"用长期CAGR描述爆发初速\"的口径错配。\n\n## 5. 下游场景结构【待补】\n结构饼图数据需以【第2节场景表】为基础，用可核验出货/金额数据填充。\n\n## 6. 区域分布【待补】\n建议分区：中国 / 北美 / 欧洲 / 日韩 / 其他；分区维度＝出货量 + 产能 + 供应链（核心零部件国产化率）。**须核验**各国政策与厂商产能布局。\n\n## 7. 关键假设清单（须在报告中显性列出）\n\n1. ASP 年降幅假设（决定金额规模）——**最敏感变量**。\n2. 特斯拉 Optimus、宇树、优必选等头部厂商 2026 实际交付能否达指引。\n3. \"签约/意向订单\"转化为\"实际交付\"的比例。\n4. 泛具身 vs 纯人形的口径边界。\n5. 汇率与统计口径（含/不含零部件）。\n6. 政策变量（补贴、采购）对需求的外生拉动。\n\n## 8. ⚠️ 待办：联网补齐清单（T2 必须完成）\n- [ ] 高盛/摩根士丹利/花旗 最新人形机器人 TAM 报告原文（含日期与版本）\n- [ ] GGII / 中国电子学会 / 券商 中国人形机器人 2025–2026 出货量与金额\n- [ ] 特斯拉、宇树、优必选、Figure、Agility 官方出货/产能指引\n- [ ] 工信部及地方政策原文\n- [ ] 2025 年融资/订单事件数据库（用于交叉验证需求端）\n\n---\n\n### 结论（本轮）\n1. **无法交付可核验的2026年市场规模数值**——因检索通道失效，任何具体数字都会违反\"不编造\"规则。\n2. **已交付可直接复用的测算框架**：口径定义、自下而上公式、三情景表结构、CAGR 算法、场景/区域拆分维度、敏感性假设清单。\n3. **阻塞点**：T2 的联网取数未完成，T3「市场规模」章节**无法在本轮定稿**；建议：**重试/恢复 web_search，或改由 T2 人工提供来源链接**后再填充第3–6节。\n\n请确认是否（a）重试联网通道，或（b）先由你方提供来源链接，我将据此完成数值填充与交叉校验。\n\n##### 梳理技术路线与产业链：执行器/灵巧手/传感器/减速器、VLA与具身智能模型、能耗与成本曲线、量产瓶颈与路线分歧\n\n## ⚠️ 检索工具状态说明（必须先说明）\n\n本次任务我已连续发起 **11 组** 联网检索（中文/英文、窄词/宽词、专有名词/泛词），**全部返回「无结果」**：\n\n- `humanoid robot actuator 2025`、`Tesla Optimus 2025`、`robot` → 空\n- `人形机器人`、`人形机器人 市场规模 2025`、`2026 人形机器人 行业报告` → 空\n- `人形机器人 执行器 行星滚柱丝杠`、`灵巧手 触觉传感器`、`具身智能 VLA 大模型`、`谐波减速器 用量` → 空\n\n**结论：当前环境下 `web_search` 工具不可用（连泛词 `robot` 均无返回），无法获取任何实时数据与可追溯来源。**\n\n依据我的工作规则（**不得凭记忆编造数字、每个关键结论须有可追溯来源**），我不会为满足\"有数据\"而虚构行情数字或伪造机构引用。因此本子任务我**分层交付**：\n\n- **A 部分**：可交付的**技术路线/产业链分析框架**（属工程通识与结构化判断，非市场数字）；\n- **B 部分**：**待联网核验的数据清单**（标明每个数字应有的口径与首选来源），供 T2 检索线补齐。\n\n---\n\n# A. 技术路线与产业链框架（可交付部分）\n\n\u003e 说明：以下为**技术分类与对比维度**，凡涉及具体数值（成本、用量、效率）处**均标注「待核验」**，不给出未经证实的数字。\n\n## A1. 分层框架：「大脑—小脑—本体」\n\n| 层级 | 功能 | 关键技术 | 代表路线分歧 |\n|---|---|---|---|\n| 大脑（认知/决策） | 任务规划、语言理解、场景泛化 | VLA 端到端大模型、多模态 LLM | 端到端 VLA vs 分层「LLM 规划+专用控制」 |\n| 小脑（运动控制） | 全身协调、平衡、步态、操作 | 强化学习、MPC、模仿学习、遥操作采数 | 模型化控制 vs 学习型控制 |\n| 本体（硬件） | 感知-执行物理载体 | 执行器、灵巧手、传感器、减速器、能源 | 电驱主导 vs 液压/气动；旋转 vs 直线 |\n\n## A2. 执行器路线对比维度\n\n| 维度 | 旋转执行器 | 直线执行器 | 液压/气动 |\n|---|---|---|---|\n| 原理 | 电机+减速器输出关节扭矩 | 电机+丝杠（含行星滚柱丝杠）转直线 | 流体驱动 |\n| 优势 | 结构成熟、供应链成熟 | 力密度/抗冲击、仿人腿型匹配佳 | 高功率密度、柔顺 |\n| 劣势 | 力密度受限、膝踝区段偏高 | 丝杠加工难、密封与寿命问题 | 漏油/能效低、维护成本高 |\n| 量产瓶颈 | 减速器精度与一致性 | **行星滚柱丝杠加工设备与良率**（普遍认为最紧环节，待核验） | 供应链窄、成本高 |\n| 用量口径 | 待核验（各厂自由度差异大） | 待核验 | 待核验 |\n\n**关注点**：特斯拉 Optimus 早期方案被广泛引用为\"旋转+直线混合\"，但具体各关节方案与用量需以官方发布核验。\n\n## A3. 灵巧手路线对比\n\n| 维度 | 欠驱动 | 全驱动 |\n|---|---|---|\n| 自由度 | 少（常 6 以内） | 高（可达 11–20+） |\n| 成本/复杂度 | 低 | 高 |\n| 触觉传感 | 简单/无 | 阵列式触觉、指尖力觉 |\n| 当前趋势 | 量产优先方案 | 高精度操作方案 |\n\n**关键分歧**：整机厂（成本/可靠性优先）倾向欠驱动；研究机构/高端场景用全驱动。**各厂具体自由度与传感配置待核验**。\n\n## A4. 传感器\n\n- 力/扭矩传感：关节力控必需，**六维力传感器**为高端方案；\n- 触觉：指尖阵列触觉，是灵巧手\"能不能抓稳\"的核心；\n- 视觉：RGB-D + 多相机；IMU；部分方案加**电子皮肤**（成熟度低，待核验）。\n\n## A5. 减速器方案\n\n| 方案 | 特点 | 适用关节 |\n|---|---|---|\n| 谐波减速器 | 高精度、零背隙、轻 | 腕/手/旋转小关节 |\n| 行星减速器 | 高刚性、成本低、效率高 | 大腿等大扭矩关节 |\n| RV 减速器 | 高刚性、大负载 | 重载关节（人形中用量存疑，待核验） |\n| 行星滚柱丝杠 | 直线执行器核心 | 膝/踝/直线关节 |\n\n**路线分歧**：谐波 vs 行星的**单机用量与配比**是成本模型关键变量，需核验。\n\n## A6. VLA / 具身智能模型路线\n\n| 路线 | 代表 | 优势 | 劣势 |\n|---|---|---|---|\n| 端到端 VLA | 谷歌 RT 系列、Figure 自研模型、Physical Intelligence 等 | 泛化强、少手工建模 | 数据饥渴、可解释差、算力高 |\n| 分层「大脑+小脑」 | LLM/VLM 规划 + 传统/RL 控制 | 可控、可工程化 | 泛化上限受限 |\n| 仿真+遥操作采数 | Isaac/仿真平台 + 真人遥操作 | 解决数据稀缺 | sim-to-real gap |\n\n**核心瓶颈**：**真实操作数据稀缺**与 **sim-to-real 迁移**是路线分歧的根源。**各家具体模型版本/性能指标待核验**。\n\n## A7. 能耗与成本曲线（分析框架，数字待核验）\n\n- 能耗：受**电池能量密度、执行器效率、整机重量/自由度**三重影响；续航是商业化落地硬约束。\n- 成本下降路径：规模效应（BOM 摊薄）+ 零部件国产化替代 + 架构简化（如减少自由度/传感器）。\n- **建议建模变量**：单机 BOM 拆分（执行器/减速器/丝杠/传感/芯片/电池），并给出量产 1 万台 vs 10 万台的成本弹性——**均待数据核验**。\n\n## A8. 量产瓶颈与路线分歧（汇总）\n\n1. **行星滚柱丝杠**：加工设备、良率、产能（普遍点名的\"卡脖子\"环节）。\n2. **六维力/触觉传感器**：量产一致性与成本。\n3. **端到端 VLA 的数据**：真实数据采集成本高。\n4. **路线分歧**：电驱 vs 液压；旋转 vs 直线；欠驱动 vs 全驱动；端到端 vs 分层。\n5. **能耗/续航**：电池与轻量化的权衡。\n\n---\n\n# B. 待联网核验的数据清单（供 T2 检索线补齐）\n\n| 编号 | 待核验数据点 | 建议口径 | 首选来源 |\n|---|---|---|---|\n| D1 | 行星滚柱丝杠单机用量、单价、良率 | 台/元/百分比 | 券商深度、厂商招股书 |\n| D2 | 谐波/行星/RV 单机用量与单价 | 台/元 | 绿的谐波等公告、研报 |\n| D3 | 灵巧手自由度与触觉配置 | DOF/传感类型 | 厂商官网、发布会 |\n| D4 | 六维力传感器价格与国产化率 | 元/占比 | 行业白皮书、上市公司 |\n| D5 | 各厂 VLA 模型名称/参数/性能 | 版本/指标 | 论文、官方技术博客 |\n| D6 | 单机续航与电池规格 | 小时/kWh | 厂商参数表 |\n| D7 | 单机 BOM 拆分与量产成本曲线 | 元/台 | 券商拆解报告 |\n| D8 | 各路线代表厂商与量产节点 | 台/时间 | 公司公告、新闻 |\n\n---\n\n## 交付状态与建议\n\n- **A 部分可直接作为 T3「技术路线」章节骨架**，但**所有数值须在 B 部分补齐后才可写入终稿**（遵循 T1 中对\"结论可追溯到来源\"的要求）。\n- **T2 检索线需在工具可用时优先补 D1–D8**；若搜索工具持续不可用，建议**改用人工/其他数据通道**，并据此向 T5/T6 明确标注\"技术路线章数据缺口\"，以免影响投资建议的结论质量。\n\n是否需要我在检索工具恢复后，第一时间按上表 D1–D8 逐项补数并输出带来源的对比表？\n\n##### 调研主要厂商与竞争格局：Tesla、Figure、1X、宇树、智元、优必选、小鹏等本体厂商及核心供应链玩家，含产能、订单、量产节奏与估值\n\n（本子任务结果为空）\n\n##### 撰写完整报告正文：整合四部分内容，输出市场规模、技术路线、主要厂商、投资建议（含标的分类、催化剂、风险提示）\n\n# 2026年人形机器人行业深度报告\n\n\u003e **版本状态：框架稿（数值未填充）**\n\u003e 本稿已完成四部分结构与论述骨架，但**市场规模、零部件用量与成本、厂商交付数据等关键数值尚未完成来源核验**。凡涉及具体数字处均以 `【待补】`／`【待核验】` 标注。请勿将本稿作为投资决策依据，须待数据核验完毕后升级为终稿。\n\n---\n\n## 报告说明与数据可信度声明\n\n- **数据状态**：本次撰写期间，联网检索通道不可用，未取得任何可核验的实时来源。为保证结论可追溯，本报告**不填充未经核实的数字**，改以\"框架 + 缺口清单\"形式交付。\n- **口径基准**：以 2025 年为基期，重点预测 2026 年，并延伸至 2030 年；全文汇率冻结为 1 USD = 7.1–7.3 CNY，金额单位为亿美元／亿元人民币。\n- **分层标记**：\n - ✅ 可交付项：口径定义、测算公式、分析框架、风险清单；\n - ❌ 待核验项：所有来自公开报告的数值、厂商参数与交付量；\n - 🔲 待补项：尚未取得任何来源的字段。\n- **免责声明**：本报告为行业研究性质，不构成任何证券的买卖建议。文末附完整免责与 AI 辅助声明。\n\n---\n\n## 执行摘要\n\n在数值核验完成前，本报告仅给出**方向性判断**，不给出具体规模与增速数值：\n\n1. **行业处于\"从科研样机向小批量交付\"过渡的早期阶段**，2026 年的核心变量不是需求天花板，而是**头部厂商实际交付能否达到指引**。\n2. **规模测算的最大敏感变量是 ASP（整机均价）年降幅**，而非出货量本身；金额增速与出货量增速必须分列，避免口径错配。\n3. **产业链瓶颈集中在少数硬件环节**（普遍指向行星滚柱丝杠、六维力／触觉传感器），而非整机组装能力。\n4. **技术路线的核心分歧在\"大脑\"层**：端到端 VLA 与分层\"规划＋控制\"两条路线尚未收敛，**真实操作数据稀缺**是共同瓶颈。\n5. **投资上，环节优先级建议为**：本体／执行器 \u003e 减速器与丝杠 \u003e 传感器 \u003e AI 芯片／算法 \u003e 场景应用，**具体排序须以核验后的量产节奏数据调整**。\n\n---\n\n## 一、市场规模\n\n### 1.1 口径定义（先行冻结，避免混用）\n\n| 维度 | 定义 | 备注 |\n|---|---|---|\n| 范围口径① | 人形机器人本体：双足／轮式类人形态整机 | 与人形口径②**量级差异大，必须分列** |\n| 范围口径② | 泛具身智能：含四足、机械臂、人形 | 不可与口径①混用 |\n| 出货量 | 单位：台／万台，含商用交付 | 科研赠样单列；区分\"签约／意向\"与\"实际交付\" |\n| 市场规模 | 出货量 × ASP，单位：亿美元／亿元 | 须注明是否含核心零部件 |\n| ASP | 整机均价，建议分工业型／消费型 | 年降幅为核心假设 |\n| CAGR | 基期 2025 → 目标年，几何平均 | 注明是出货量 CAGR 还是金额 CAGR |\n\n### 1.2 测算框架（自下而上，可复现）\n\n$$市场规模_{2026} = \\sum_{场景} (出货量_{场景} \\times ASP_{场景})$$\n\n分场景拆分维度如下（**占比为占位假设，须以核验后的出货数据替换**）：\n\n| 场景 | 2026 出货占比 | ASP 特征 | 说明 |\n|---|---|---|---|\n| 工业制造／汽车产线 | 🔲 待补 | 高 | 主机厂自用为主 |\n| 物流仓储搬运 | 🔲 待补 | 中高 | 与 AMR 存在竞合 |\n| 商业服务／导览 | 🔲 待补 | 中 | 展示属性强，真实 ROI 弱 |\n| 科研／教育 | 🔲 待补 | 高 | 当前主要\"销量\"来源，小批量 |\n| 家庭／消费 | 🔲 待补 | 中 | 2026 年预计仍难放量 |\n| 特种／危险作业 | 🔲 待补 | 高 | 单价高、量小 |\n\n### 1.3 全球与中国规模（三情景框架）\n\n| 指标 | 悲观 | 基准 | 乐观 | 需核验的锚点来源 |\n|---|---|---|---|---|\n| 2025 全球出货量（台） | 🔲 待补 | 🔲 待补 | 🔲 待补 | 头部厂商出货指引 |\n| 2026 全球出货量（台） | 🔲 待补 | 🔲 待补 | 🔲 待补 | 特斯拉等官方目标量级 |\n| 2026 中国出货量（台） | 🔲 待补 | 🔲 待补 | 🔲 待补 | GGII／中国电子学会 |\n| 2026 全球规模（亿美元） | 🔲 待补 | 🔲 待补 | 🔲 待补 | 高盛／摩根士丹利／花旗 TAM 口径 |\n| 2026 中国规模（亿元） | 🔲 待补 | 🔲 待补 | 🔲 待补 | 工信部／券商研报 |\n\n**【待核验】公开线索**（均须核对原文与发布年月后方可引用）：\n- 高盛曾给出\"2035 年全球人形机器人 TAM 约 380 亿美元\"（base case），**须核对是否已上调**；\n- 摩根士丹利长期 TAM 曾给到\"2050 年数万亿美元级\"，属**远期口径，不可与 2026 短期预测混用**；\n- 工信部《人形机器人创新发展指导意见》（2023 年 11 月）提出\"2025 年实现批量生产、2027 年形成安全可靠产业链\"，属**政策口径，非市场预测**。\n\n\u003e ⚠️ 上述线索来自行业常见引用，本次**未获检索确认**，报告中引用前必须补齐\"机构全名＋报告名＋发布年月＋原始链接\"。\n\n### 1.4 增速口径\n\n$$\\text{CAGR} = \\left(\\frac{V_{2030}}{V_{2025}}\\right)^{1/5} - 1$$\n\n- 出货量 CAGR 与金额 CAGR **分别计算**；因 ASP 大概率下行，**金额 CAGR 通常低于出货量 CAGR**。\n- 短期（2025→2026）增速显著高于长期（→2030）年均值，报告须**同时给出短期 YoY 与长期 CAGR**，避免用长期 CAGR 描述爆发初速。\n\n### 1.5 下游结构与区域分布\n\n- **下游结构**：以 1.2 节场景表为基础填充饼图数据，🔲 待补。\n- **区域分布**：建议分区为中国／北美／欧洲／日韩／其他，维度取\"出货量＋产能＋供应链（核心零部件国产化率）\"，🔲 待补。\n\n### 1.6 关键假设清单（须在报告中显性列出）\n\n1. **ASP 年降幅** —— 最敏感变量，直接决定金额规模；\n2. 头部厂商 2026 年实际交付能否达指引；\n3. \"签约／意向订单\"向\"实际交付\"的转化率；\n4. 泛具身口径与纯人形口径的边界；\n5. 汇率与统计口径（是否含零部件）；\n6. 政策变量（补贴、政府采购）对需求的外生拉动。\n\n---\n\n## 二、技术路线与产业链\n\n\u003e 本章为**技术分类与对比框架**，属工程通识性判断；凡涉及成本、用量、效率的具体数值均标 `【待核验】`，不给出未经证实的数字。\n\n### 2.1 分层框架：「大脑—小脑—本体」\n\n| 层级 | 功能 | 关键技术 | 主要路线分歧 |\n|---|---|---|---|\n| 大脑（认知／决策） | 任务规划、语言理解、场景泛化 | VLA 端到端大模型、多模态 LLM | 端到端 VLA vs 分层\"LLM 规划＋专用控制\" |\n| 小脑（运动控制） | 全身协调、平衡、步态、操作 | 强化学习、MPC、模仿学习、遥操作采数 | 模型化控制 vs 学习型控制 |\n| 本体（硬件） | 感知—执行物理载体 | 执行器、灵巧手、传感器、减速器、能源 | 电驱 vs 液压／气动；旋转 vs 直线 |\n\n### 2.2 执行器路线\n\n| 维度 | 旋转执行器 | 直线执行器 | 液压／气动 |\n|---|---|---|---|\n| 原理 | 电机＋减速器输出关节扭矩 | 电机＋丝杠转直线 | 流体驱动 |\n| 优势 | 结构、供应链成熟 | 力密度高、抗冲击、契合仿人腿型 | 功率密度高、柔顺 |\n| 劣势 | 力密度受限、膝踝区段偏高 | 丝杠加工难、密封与寿命问题 | 漏油、能效低、维护成本高 |\n| 量产瓶颈 | 减速器精度与一致性 | **行星滚柱丝杠加工设备与良率**（普遍认为最紧环节，待核验） | 供应链窄、成本高 |\n| 单机用量 | 🔲 待补 | 🔲 待补 | — |\n\n### 2.3 灵巧手\n\n| 维度 | 欠驱动 | 全驱动 |\n|---|---|---|\n| 自由度 | 少（常 ≤6） | 高（可达 11–20+） |\n| 成本／复杂度 | 低 | 高 |\n| 触觉传感 | 简单或无 | 阵列式触觉、指尖力觉 |\n| 应用倾向 | 量产优先方案 | 高精度操作方案 |\n\n**路线分歧**：整机厂（成本与可靠性优先）倾向欠驱动；研究机构与高端场景用全驱动。**各厂具体自由度与传感配置待核验。**\n\n### 2.4 传感器\n\n- **力／扭矩**：关节力控必需，**六维力传感器**为高端方案；\n- **触觉**：指尖阵列触觉是灵巧手\"能否抓稳\"的核心；\n- **视觉／惯导**：RGB-D ＋多相机 ＋ IMU；\n- **电子皮肤**：成熟度低，🔲 待核验。\n\n### 2.5 减速器与丝杠\n\n| 方案 | 特点 | 适用关节 |\n|---|---|---|\n| 谐波减速器 | 高精度、零背隙、轻 | 腕／手／旋转小关节 |\n| 行星减速器 | 高刚性、成本低、效率高 | 大腿等大扭矩关节 |\n| RV 减速器 | 高刚性、大负载 | 重载关节（人形中用量存疑，待核验） |\n| 行星滚柱丝杠 | 直线执行器核心 | 膝／踝／直线关节 |\n\n**关键变量**：谐波与行星的**单机用量与配比**是成本模型的核心，🔲 待核验。\n\n### 2.6 VLA 与具身智能模型\n\n| 路线 | 代表方向 | 优势 | 劣势 |\n|---|---|---|---|\n| 端到端 VLA | 谷歌 RT 系列、Figure 自研、Physical Intelligence 等 | 泛化强、少手工建模 | 数据饥渴、可解释性差、算力要求高 |\n| 分层\"大脑＋小脑\" | LLM／VLM 规划 ＋ 传统／RL 控制 | 可控、可工程化 | 泛化上限受限 |\n| 仿真＋遥操作采数 | Isaac 类仿真平台 ＋ 真人遥操作 | 缓解数据稀缺 | 存在 sim-to-real 落差 |\n\n**核心瓶颈**：**真实操作数据稀缺**与 **sim-to-real 迁移**，是当前路线分歧的根源。\n\n### 2.7 能耗与成本曲线\n\n- **能耗**受三重因素影响：电池能量密度、执行器效率、整机重量与自由度；续航是商业化落地的硬约束。\n- **成本下降路径**：规模效应（BOM 摊薄）＋ 零部件国产化替代 ＋ 架构简化（减少自由度／传感器）。\n- **建议建模变量**：单机 BOM 拆分（执行器／减速器／丝杠／传感／芯片／电池），并给出量产 1 万台 vs 10 万台的成本弹性，🔲 均待数据核验。\n\n### 2.8 量产瓶颈与路线分歧汇总\n\n1. **行星滚柱丝杠\n\n##### 审校与质检：核对数据来源与一致性、逻辑链条、投资建议合规性与风险提示，输出修改意见\n\n（本子任务结果为空）\n\n\u003c/details\u003e","timestamp":"2026-09-25 19:21:00","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_01/summary.md b/test/general_assistant/run_01/summary.md new file mode 100644 index 0000000..e02ff1d --- /dev/null +++ b/test/general_assistant/run_01/summary.md @@ -0,0 +1,8 @@ +# run_01 测试结论 +- 类型：编排型（挂载到 general-assistant 任务 task_id=94） +- 意图分流：orchestrated +- 耗时：一轮（curl），约 2-3 分钟 +- 内容字数：19547 +- 是否含
    编排折叠块：True +- 子任务数：21 +- 时间戳：2026-09-25 19:21:00 diff --git a/test/general_assistant/run_02/request.json b/test/general_assistant/run_02/request.json new file mode 100644 index 0000000..dcb81dc --- /dev/null +++ b/test/general_assistant/run_02/request.json @@ -0,0 +1 @@ +{"message":"帮我搜索一下2026年9月具身智能/人形机器人领域有什么重大行业事件或融资。","mode":"quick","task_id":0,"specialist_key":""} diff --git a/test/general_assistant/run_02/response.json b/test/general_assistant/run_02/response.json new file mode 100644 index 0000000..5afea53 --- /dev/null +++ b/test/general_assistant/run_02/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"我连续尝试了多组中英文关键词检索（「2026年9月 人形机器人 融资」「September 2026 humanoid robot funding」「具身智能 重大事件」等），甚至用最宽泛的「人形机器人」做兜底测试，**搜索结果均返回为空**，无法获取到任何可核实的资料。\n\n因此我无法为你提供2026年9月具身智能/人形机器人领域的具体事件或融资信息。原因可能有几种：\n\n1. **时间问题**：如果当前时间尚未到2026年9月，该月的行业事件和融资自然还不存在，任何\"数据\"都会是编造。\n2. **检索工具异常**：即使是宽泛查询也零结果，可能是搜索服务临时不可用。\n\n我不会凭印象或推测编造事件、公司名和金额——这类信息一旦虚构，对行业研究和决策参考危害很大。\n\n**建议你可以这样做：**\n- 确认一下你要问的时间点（是否是**2025年9月**，或某个已发生的月份？）；\n- 或者告诉我你关注的具体方向（如某家公司、某细分环节、某地区），我可以再针对性地试一次检索。\n\n如果你能补充这两点，我立刻重新帮你搜。","timestamp":"2026-09-25 19:21:32","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_02/summary.md b/test/general_assistant/run_02/summary.md new file mode 100644 index 0000000..e2fa6e9 --- /dev/null +++ b/test/general_assistant/run_02/summary.md @@ -0,0 +1,6 @@ +# run_02 +- 类型：单问联网搜索 +- 意图：single_search +- 字数：459 +- details：False +- 时间：19:21:32 diff --git a/test/general_assistant/run_03/request.json b/test/general_assistant/run_03/request.json new file mode 100644 index 0000000..1b8bc72 --- /dev/null +++ b/test/general_assistant/run_03/request.json @@ -0,0 +1 @@ +{"message":"在吗？能不能简单聊聊周末可以做什么放松。","mode":"quick","task_id":0,"specialist_key":""} diff --git a/test/general_assistant/run_03/response.json b/test/general_assistant/run_03/response.json new file mode 100644 index 0000000..902d90e --- /dev/null +++ b/test/general_assistant/run_03/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"在的。周末放松可以很简单，按你想要的“安静 / 热闹 / 动 / 静”来选：\n\n- **想彻底躺平**：睡到自然醒、做顿慢早餐、追剧、看书、听歌、拼图。\n- **想出门透气**：公园散步、骑车、爬山、逛市集、咖啡馆坐一下午。\n- **想有点社交**：约朋友吃饭、桌游、看展、看电影、短途周边游。\n- **想恢复能量**：瑜伽、冥想、泡澡、按摩、早睡，顺便整理房间。\n\n一个低门槛组合： \n**周六**：上午公园走走 → 下午咖啡馆看书/发呆 → 晚上看部电影。 \n**周日**：睡饱 → 做顿喜欢的饭 → 简单收拾 → 早点休息。\n\n你更想要“安静宅家”还是“出门走走”？我可以帮你排个具体周末计划。","timestamp":"2026-09-25 19:21:40","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_03/summary.md b/test/general_assistant/run_03/summary.md new file mode 100644 index 0000000..d6db9f1 --- /dev/null +++ b/test/general_assistant/run_03/summary.md @@ -0,0 +1,6 @@ +# run_03 +- 类型：直答（闲聊，无联网） +- 意图：direct_answer +- 字数：302 +- details：False +- 时间：19:21:40 diff --git a/test/general_assistant/run_04/request.json b/test/general_assistant/run_04/request.json new file mode 100644 index 0000000..b5c2d3e --- /dev/null +++ b/test/general_assistant/run_04/request.json @@ -0,0 +1 @@ +{"message":"请拆分为多个子任务，分别对比宇树科技、优必选、智元机器人在人形机器人上的技术路线与商业化进展，并给出综合结论。","mode":"quick","task_id":0,"specialist_key":""} diff --git a/test/general_assistant/run_04/response.json b/test/general_assistant/run_04/response.json new file mode 100644 index 0000000..3bfb830 --- /dev/null +++ b/test/general_assistant/run_04/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"# 三家人形机器人对比：宇树科技、优必选、智元机器人（合并版）\n\n**检索与证据状态（前置说明）** \n合并的子任务中，`web_search` 多轮、多关键词均返回空结果，**未取得可引用的实时来源与链接**。因此本回复**不填入未经核验的出货量、订单金额、营收、估值等数字**；涉及产品与判断处标注 `[待核验]`。关键数据请以各公司一手公告为准。\n\n**关键一手来源总表（建议核验渠道）** \n- 宇树科技：A 股 IPO 招股书/上市披露、官网发布会、创始人公开访谈。 \n- 优必选：港交所公告/年报/中报（09880.HK）、业绩发布会。 \n- 智元机器人：官网/官微、投资方与代工方上市公司公告、招投标平台、政府采购网、企业信用信息公示系统。 \n- 行业交叉验证：高工机器人、IDC、GGII 等第三方机构。 \n- 证据等级：交易所/招股书公告 ＞ 政府采购/招投标/上市公司公告 ＞ 官方发布会 ＞ 权威媒体 ＞ 自媒体传闻。\n\n---\n\n## 一、子任务拆分\n\n| 子任务 | 核心问题 | 交付物 |\n|---|---|---|\n| A 宇树科技 | 低成本本体 + 运动控制路线能否转化为规模化出货？科研教育 vs 工业占比？ | 技术路线图 + 出货口径表 |\n| B 优必选 | Walker 系列工业落地深度？订单是确定性采购还是框架/MOU？ | 订单台账 + 财务口径表 |\n| C 智元机器人 | “本体+数据+模型”全栈叙事中，量产与订单兑现能否证实？ | 产品矩阵 + 量产/资本化时间线 |\n| D 第三方交叉验证 | 公司口径与行业口径差多少、差在哪？ | 外部数据对照表 |\n| E 横向结论 | 统一口径后谁领先、领先在哪一环？ | 对比矩阵 + 条件化结论 |\n\n---\n\n## 二、统一口径规则（不做这步，三家数字不可比）\n\n| 指标 | 常见口径分歧 | 统一规则 |\n|---|---|---|\n| 出货量 | 累计/年度；出货/交付/中标/产能规划 | 统一为“已交付台数（含年份）”，其余单列 |\n| 订单金额 | 框架协议/MOU vs 确定性采购合同 | 拆“确定性订单”与“框架意向”两栏 |\n| “量产” | 小批量试产 vs 千台级产线 | 标实际月/年产能，不采信形容词 |\n| 客户结构 | 科研教育/展演 vs 工业真实产线 | 按场景拆分占比，教育科研单列 |\n| 估值/融资 | 投后估值 vs 交割金额 vs 传闻 | 只采信投资方或公司公告口径 |\n\n---\n\n## 三、三家公司技术路线与商业化进展\n\n### 1. 宇树科技 Unitree\n\n- **技术路线**：四足机器人起家，强项在硬件驱动、高动态运动控制、强化学习 sim2real 与低成本电驱关节。代表产品 H1、G1 `[待核验]`；子任务材料称 G1 走低价策略，约 9.9 万元级 `[待核验]`。大脑/具身智能是自研还是外采，待核验。\n- **商业化进展**：四足机器人已形成规模化出货，全球份额靠前 `[待核验具体数字]`；人形机器人以科研教育/展演场景为主，绝对出货量仍小于四足 `[待核验]`；已涉及 IPO/上市辅导相关动作 `[待核验官方披露]`。\n- **关键来源**：宇树 IPO 招股书/上市披露、官网、创始人王兴兴公开访谈。 \n- **主要风险**：低价放量可能影响毛利；人形出货是否等于工业场景渗透，需看客户结构。\n\n### 2. 优必选 UBTech\n\n- **技术路线**：全栈自研取向，覆盖伺服驱动器、运动控制、SLAM 导航；Walker 系列迭代至 Walker S/S2 等 `\n\n\u003cdetails\u003e\u003csummary\u003e📋 本次由通用编排拆分执行\u003c/summary\u003e\n\n##### 调研宇树科技人形机器人技术路线与商业化进展\n\n## 一、检索工具状态说明（前置告知）\n\n我已连续尝试 **11 组不同关键词**（中英文、公司名、行业名、极简词如「机器人」），`web_search` 工具**全部返回空结果**。这不是关键词问题，而是本轮检索通道不可用。\n\n按照我的职责规则（**优先联网检索、不凭记忆编造数字、关键结论须可追溯**），我**不会**用训练记忆中的数字冒充实时检索结果。因此本轮我交付两样东西：\n\n1. **可执行的任务拆分方案**（这是你本次的核心诉求，可独立交付）；\n2. **对比分析框架 + 需核验的关键数据清单**（标注每项该去哪查）。\n 待检索通道恢复后，我可立即按此框架填充实证数据。\n\n---\n\n## 二、任务拆分方案\n\n### 子任务 A：宇树科技（Unitree）技术路线与商业化\n**技术路线待查点**\n- 硬件路线：全自研关节电机/减速器、低成本高性能路线；H1（全尺寸）→ G1（小型化、9.9万元级定价）的产品分层。\n- 运动控制：以强化学习（RL）驱动的运动能力（跑、跳、后空翻、复杂地形）为强项；是否走\"纯运控强、AI 大模型大脑弱\"的路线。\n- 大脑/具身智能：自研 or 外采（如与外部大模型/操作系统合作）。\n\n**商业化待查点**\n- 出货量与收入：2024–2025 年人形机器人销量、营收、毛利率（宇树已启动 IPO 辅导，招股书数据是最权威口径）。\n- 客户结构：科研院所/高校为主 vs 工业/商用占比。\n- 价格策略：G1 低价策略对行业定价的冲击。\n\n**一手来源**：宇树 IPO 招股说明书、官方发布会、创始人王兴兴公开访谈。\n\n### 子任务 B：优必选（UBTech）技术路线与商业化\n**技术路线待查点**\n- 全栈自研：伺服驱动器、运动控制、SLAM 导航；Walker 系列迭代（Walker X → Walker S → Walker S2）。\n- 工业场景落地：热插拔换电、自主换电、与车厂/工厂的协同作业（如极氪、比亚迪等产线实训）。\n- 大脑路线：自研具身智能大模型（如\"天工\"相关或内部模型）+ 群体智能（多机协同）。\n\n**商业化待查点**\n- 订单：工业场景意向订单/中标金额（优必选为港股上市，公告为权威口径）。\n- 财务：2024 年报、2025 中报的人形机器人相关收入与亏损情况。\n- 交付形态：实训 vs 规模交付。\n\n**一手来源**：优必选（09880.HK）港交所公告、财报、业绩发布会。\n\n### 子任务 C：智元机器人（AgiBot）技术路线与商业化\n**技术路线待查点**\n- 双线产品：远征（A2 全尺寸）与灵犀（X1 小型/开源）；\"本体 + 大脑 + 数据\"三位一体。\n- 数据路线：自建数据采集工厂（大规模真机数据采集）是其差异化叙事。\n- 开源策略：开源框架/数据集，构建开发者生态。\n\n**商业化待查点**\n- 量产：2025 年\"量产元年\"相关出货/下线节点（如上汽入股、工厂合作）。\n- 融资与股东：腾讯、比亚迪、上汽等产业资本背景（影响其落地渠道）。\n- 收入与订单：官方披露或媒体可核验数据。\n\n**一手来源**：智元官方、股东方公告、可信财经媒体。\n\n### 子任务 D：横向对比与综合结论\n**对比维度（建议做成矩阵）**\n| 维度 | 宇树 | 优必选 | 智元 |\n|---|---|---|---|\n| 技术强项 | 运动控制/低价本体 | 全栈+工业落地 | 数据+开源生态 |\n| 大脑路线 | 待核验 | 待核验 | 待核验 |\n| 商业化阶段 | 待核验 | 待核验 | 待核验 |\n| 客户结构 | 待核验 | 待核验 | 待核验 |\n| 定价策略 | 待核验 | 待核验 | 待核验 |\n| 资本路径 | 拟 A 股 IPO | 港股上市 | 一级市场融资 |\n\n---\n\n## 三、需要你确认的两个问题\n\n1. **是否希望我在检索通道恢复后，自动按上述 A→B→C→D 顺序执行并输出带来源链接的完整报告？**\n2. **对比口径优先级**：你更看重**出货量/营收等\"官方财务口径\"**，还是**技术路线与产品能力**？这决定我检索时的信源倾斜。\n\n---\n\n## 四、下一步（待工具可用）\n\n检索通道恢复后，我将按以下顺序取数，并**对同一指标并列官方口径 vs 行业口径**（如\"出货量\"公司口径与第三方机构口径常不一致，会标注差额原因）：\n\n1. 宇树 IPO 招股书 / 公开披露 → 出货、营收、毛利\n2. 优必选港交所公告 / 年报 → 订单、收入\n3. 智元官方 + 股东公告 → 量产节点、融资\n4. 第三方机构（高工机器人、IDC 等）→ 市场规模与出货量交叉验证\n\n**是否需要我现在就把上述框架落成一版\"待填数据表\"模板，方便你后续核对？** 如果你手头有检索通道，也可以直接把任一公司的官方链接给我，我来做结构化整理。\n\n##### 调研优必选人形机器人技术路线与商业化进展\n\n（本子任务结果为空）\n\n##### 调研智元机器人人形机器人技术路线与商业化进展\n\n## ⚠️ 取证状态说明（必须先讲清）\n\n本轮 `web_search` **连续 11 次查询全部返回空结果**（含中文全称/短词、英文、含年份数据点等多种写法，覆盖三家厂商与市场规模类查询）。因此**本轮我无法产出任何可直接引用的实时数据**。\n\n按研究员规则，我不会凭记忆填补数字。所以本回复交付的是：**（1）子任务拆分；（2）口径对齐规则；（3）每家厂商的可核验字段清单与指定信源；（4）待验证的对比框架；（5）条件化综合结论**。文中**不出现任何未经核验的具体数字**，凡涉及数字处均标为 `[待填]`。\n\n---\n\n## 一、子任务拆分\n\n| 编号 | 子任务 | 核心问题 | 交付物 | 信源优先级 |\n|---|---|---|---|---|\n| **A** | 宇树科技 | 低成本本体路线 vs 通用智能；出货结构（科研/教育/工业） | 技术路线图 + 出货口径表 | 招股书/上市披露 \u003e 官网 \u003e 权威媒体 |\n| **B** | 优必选 | Walker 系列迭代节奏；工业场景落地深度 vs 订单质量 | 订单台账（区分确定性/框架） | 港交所年报/公告 \u003e 官网 \u003e 媒体 |\n| **C** | **智元机器人（本人负责）** | \"本体+数据+模型\"全栈路线；量产与资本化进程 | 产品矩阵 + 量产/商业化时间线 | 官网/官微 \u003e 投资方公告 \u003e 权威媒体 |\n| **D** | 横向对比与结论 | 口径统一后谁领先、领先在哪一环 | 对比矩阵 + 综合结论 | 依赖 A/B/C 结果 |\n\n---\n\n## 二、口径对齐（这一步不做，三家数字无法比较）\n\n这是本任务**最大的陷阱**：三家的对外表述用的是不同口径，直接横向比会系统性失真。\n\n| 高频指标 | 常见口径分歧 | 处理规则 |\n|---|---|---|\n| 出货量 | 累计 vs 年度；**出货** vs **交付** vs **中标** vs **产能规划** | 统一为「已交付台数（含年份）」，其余单列 |\n| 订单金额 | 框架协议/MOU/战略合作 vs 确定性采购合同 | 拆成「确定性订单」与「框架意向」两栏 |\n| \"量产\" | 几十台小批量试产 vs 千台级产线投产 | 标注\"月产能/年产能\"实际值，不采信形容词 |\n| 客户结构 | 科研教育/展演 vs 工业真实产线 | 按场景拆分占比，教育科研单列 |\n| 估值/融资 | 投后估值 vs 实际交割金额 vs 传闻 | 只采信投资方或公司公告口径 |\n\n---\n\n## 三、子任务 C：智元机器人（重点）待取证字段\n\n| # | 待核验事实 | 建议信源 |\n|---|---|---|\n| C1 | 成立时间、创始人团队、股权与融资轮次/金额/投后估值 | 公司官网、投资方（如地方国资/产业资本）公告、企业信息公示 |\n| C2 | 产品矩阵型号谱系（双足/轮式/轻量级）及各自定位 | 官网产品页、发布会实录 |\n| C3 | **技术路线主张**：是否\"本体+数据+模型\"全栈；本体自研比例、关节/执行器自研程度 | 技术博客、论文、开源仓库 |\n| C4 | 模型侧：是否有开源具身大模型、数据采集规模（真机数据条数） | 开源平台（GitHub/HuggingFace）、公司技术披露 |\n| C5 | 量产：代工合作方、产线投产时间、**实际交付台数（区分年度/累计）** | 代工方公告、供应链上市公司披露、权威媒体 |\n| C6 | 客户与订单：是否存在**确定性**采购合同（非 MOU），金额与场景 | 采购方公告、招投标平台 |\n| C7 | 资本化进程：股改进展、借壳/收购/IPO 路径相关公告 | 交易所公告、上市公司公告 |\n| C8 | 关键人事/组织变动 | 官方渠道、权威媒体 |\n\n\u003e 补充可核验渠道：**中国政府采购网、上市公司公告（巨潮/交易所）、企业信用信息公示系统**——这三处是\"确定性订单\"和\"产线投产\"最硬的证据源，优先级高于媒体转述。\n\n---\n\n## 四、待验证的对比框架（定性假设，需数据落地）\n\n以\"技术路线三问\"作为统一分析轴，先把三家放进同一坐标系（以下为**待验证假设**，非结论）：\n\n- **H1｜本体与成本策略**：宇树倾向\"标准化本体 + 极致成本\"横向铺量；优必选倾向\"工业场景定制 + 大客户交付\"；智元倾向\"多形态本体矩阵 + 平台化\"。→ 待 C1/C2/C5 与 A/B 同字段验证。\n- **H2｜智能架构**：宇树偏运动控制与通用本体能力；优必选强调群体智能/多机协同；智元强调数据—模型闭环。→ 待各自论文/开源物证验证。\n- **H3｜数据飞轮来源**：谁掌握**真实产线数据**，谁的模型迭代可持续。→ 待 A/B/C 客户结构（工业 vs 教育科研占比）验证。\n\n---\n\n## 五、综合结论（条件化，暂不可落定）\n\n在缺失实时数据的前提下，我只能给出**结论成立的条件**，而不是结论本身：\n\n1. 若「已交付台数」口径下宇树显著领先 → 结论应表述为**\"规模化出货领先，但不等于工业场景渗透领先\"**（教育科研占比需单列）。\n2. 若「确定性工业订单」口径下优必选领先 → 结论应表述为**\"订单质量/场景深度领先，但需核验毛利率与交付节奏\"**。\n3. 若智元在**数据规模与模型开源**上形成可核验壁垒 → 结论应表述为**\"全栈叙事完整、但量产与订单兑现是最薄弱环节\"**；若其量产/订单同样可核验，则是三家中**纵向整合度最高**的一家。\n\n\u003e 一句话：**三家的\"路线差异\"多半成立，但\"谁领先\"完全取决于把哪个口径当分母——在没有统一口径数据前，任何排名都是不可靠的。**\n\n---\n\n## 六、下一步（请确认其一）\n\n1. **重试联网**：若检索工具恢复，我按第三节 C1–C8 逐条取证，每条附机构名/链接/发布时间，并标注官方口径 vs 行业口径差异。\n2. **你提供线索**：如果你手上有原始材料（招股书、年报、公告、发布会实录），我可据此完成可追溯整理，不依赖检索。\n3. **先要框架**：我可以先交付一版完整的「三口径对比矩阵模板」（空表待填），供团队分头取证后直接汇总。\n\n请告诉我选哪条，或直接提供材料，我继续推进。\n\n##### 横向对比三家技术路线、商业化进展与关键证据\n\n## 一、取证状态（先讲结论）\n\n本轮我又发起 **7 组查询**（含中文全称/短词、英文、以及极端兜底词「机器人」「2025」「Unitree humanoid robot」）——**全部返回空结果**。连「2025」这种无歧义词都查不到，可以判定：**本轮 `web_search` 通道整体不可用**，不是关键词匹配问题。\n\n因此，**本回复不产出任何实时数字**。按研究员规则，我不会用训练记忆中的数字冒充检索结果。你要的「拆分子任务」本身可以独立交付，我把它做扎实；**涉及数字处一律标 `[待填]` 并指定该去哪取证**。\n\n---\n\n## 二、任务拆分（核心交付）\n\n总任务 → 4 个子任务 + 1 个综合子任务。每个子任务都规定：**核心问题 / 取证字段 / 信源优先级 / 交付物 / 验收口径**。\n\n### 子任务 A｜宇树科技（Unitree）\n- **核心问题**：低成本本体路线能否转化为规模化出货？出货结构里「科研教育 vs 工业」各占多少？\n- **取证字段**：产品谱系与定价（全尺寸 vs 小型）；关节/执行器自研程度；运动控制技术路线（是否 RL 驱动）；大脑/具身智能是自研还是外采；**年度与累计交付台数**；营收/毛利；客户结构占比。\n- **信源优先级**：IPO 招股书/上市披露（最高）\u003e 官方发布会/创始人访谈 \u003e 权威财经媒体 \u003e 第三方机构。\n- **交付物**：技术路线图 + 出货口径表。\n- **验收口径**：区分「出货 / 交付 / 中标 / 产能规划」，统一折算为**已交付台数（标年份）**。\n\n### 子任务 B｜优必选（UBTech，港股上市）\n- **核心问题**：工业场景落地的**订单质量**如何——是确定性采购，还是框架/意向？\n- **取证字段**：Walker 系列迭代节奏；伺服驱动/运动控制/SLAM 自研程度；工业协同作业案例（产线实训 vs 规模交付）；是否有多机协同/群体智能路线；**订单台账（确定性 / 框架分列）**；人形机器人相关收入与亏损。\n- **信源优先级**：交易所公告/年报/中报（最高）\u003e 业绩发布会 \u003e 官网 \u003e 媒体。\n- **交付物**：订单台账（含确定性标注）+ 财务口径表。\n- **验收口径**：MOU/战略合作**不得**计入订单金额，必须单列。\n\n### 子任务 C｜智元机器人（AgiBot）\n- **核心问题**：全栈叙事（本体+数据+模型）中，**量产与订单兑现**这一最薄弱环节能否被证实？\n- **取证字段**：股权与融资轮次/金额/投后估值；产品矩阵（双足/轮式/轻量）；本体自研比例；是否有开源具身大模型与**真机数据规模**；代工方与产线投产时间；**实际交付台数**；是否存在确定性采购合同；资本化进程（股改/借壳/收购公告）。\n- **信源优先级**：官网/官微 \u003e 投资方与代工方（上市公司）公告 \u003e 招投标平台/政府采购网 \u003e 权威媒体。\n- **交付物**：产品矩阵 + 量产/资本化时间线。\n- **验收口径**：「量产」必须落到**月/年产能实际值**，不采信形容词。\n\n### 子任务 D｜市场规模与第三方交叉验证（贯穿 A/B/C）\n- **核心问题**：三家自报数据与第三方机构口径差多少、差在哪。\n- **取证字段**：行业出货量与市场规模（第三方机构）；各厂商市占率；均价走势。\n- **作用**：为 A/B/C 的数字提供**外部交叉验证**，并显式标注**官方口径 vs 泛行业口径**的差额及成因。\n\n### 子任务 E｜横向对比与综合结论\n- **输入**：A/B/C/D 全部产出，且已按第三节口径对齐。\n- **交付物**：对比矩阵 + 综合结论（含「结论在何种口径下成立」的条件说明）。\n\n---\n\n## 三、口径对齐规则（不做这步，三家数字不可比）\n\n这是本任务**最大的坑**：三家对外表述口径不同，直接横比会系统性失真。\n\n| 指标 | 常见口径分歧 | 统一规则 |\n|---|---|---|\n| 出货量 | 累计/年度；出货/交付/中标/产能 | 统一为「已交付台数（含年份）」，其余单列 |\n| 订单金额 | 框架协议/MOU vs 确定性合同 | 拆「确定性订单」「框架意向」两栏 |\n| 「量产」 | 小批量试产 vs 千台级产线 | 标实际月/年产能，不采信形容词 |\n| 客户结构 | 科研教育/展演 vs 工业产线 | 按场景拆分占比，教育科研单列 |\n| 估值/融资 | 投后估值 vs 交割金额 vs 传闻 | 只采信投资方或公司公告口径 |\n\n**证据等级建议**：①交易所/招股书公告 ＞ ②政府采购网/招投标/上市公司公告 ＞ ③官方发布会 ＞ ④权威媒体 ＞ ⑤自媒体/传闻。①—③可作结论依据，④仅作线索，⑤不引用。\n\n---\n\n## 四、对比框架（待数据落地）\n\n| 维度 | 宇树 | 优必选 | 智元 |\n|---|---|---|---|\n| 技术强项 | 运动控制 / 低成本本体 | 全栈 + 工业落地 | 数据 + 开源生态 |\n| 大脑路线 | `[待填]` | `[待填]` | `[待填]` |\n| 商业化阶段 | `[待填]` | `[待填]` | `[待填]` |\n| 客户结构 | `[待填]` | `[待填]` | `[待填]` |\n| 定价策略 | `[待填]` | `[待填]` | `[待填]` |\n| 资本路径 | 拟 A 股 IPO（待核验） | 港股上市 | 一级市场融资 |\n\n三条待验证假设（H）：\n- **H1 本体与成本**：宇树偏「标准化本体 + 极致成本横向铺量」；优必选偏「工业定制 + 大客户交付」；智元偏「多形态本体 + 平台化」。\n- **H2 智能架构**：宇树偏运动控制；优必选强调多机协同；智元强调数据—模型闭环。\n- **H3 数据飞轮**：谁能掌握**真实产线数据**，谁才具备可持续的模型迭代能力 → 需用客户结构（工业 vs 教育科研占比）验证。\n\n---\n\n## 五、综合结论（条件化，**不是**定论）\n\n在缺失可核验数据前提下，我只能给出「结论成立的条件」，而非排名：\n\n1. 若「已交付台数」口径下宇树领先 → 应表述为**「规模化出货领先，但不等于工业场景渗透领先」**（教育科研占比须单列）。\n2. 若「确定性工业订单」口径下优必选领先 → 应表述为**「订单质量/场景深度领先，但需核验毛利率与交付节奏」**。\n3. 若智元在**数据规模与模型开源**上形成可核验壁垒 → **「全栈叙事完整，但量产与订单兑现是最薄弱环节」**；若其量产/订单亦可核验，则为三家中**纵向整合度最高**者。\n\n\u003e 一句话：三家的**路线差异**多半成立；**「谁领先」完全取决于把哪个口径当分母**——在统一口径数据到位前，任何排名都不可靠。\n\n---\n\n## 六、下一步（请选一条）\n\n1. **重试联网**：通道恢复后，我按 A→B→C→D→E 顺序逐条取证，每条附**机构名/链接/发布时间**，并并列标注**官方口径 vs 行业口径**差异。\n2. **你提供线索**：若有招股书/年报/公告/发布会实录，我可直接做可追溯的结构化整理，不依赖检索。\n3. **先要模板**：我先交付一版「三口径对比矩阵空表 + 逐字段取证清单」，供团队分头填数后汇总。\n\n请告诉我选哪条，或直接提供材料，我继续推进。\n\n##### 撰写三家对比综合报告与结论\n\n## 一、子任务拆分\n\n1. 统一对比口径：技术路线、产品矩阵、目标场景、量产交付、收入与资本。\n2. 分别梳理宇树科技、优必选、智元机器人的技术路线。\n3. 分别梳理三家公司的人形机器人商业化进展。\n4. 做技术路线横向对比与商业化横向对比。\n5. 给出综合结论、风险提示与观察指标。\n\n\u003e 说明：以下基于截至公开信息整理，具体数据以公司公告、年报/招股书及官方发布为准，不构成投资建议。\n\n## 二、技术路线对比\n\n### 1. 宇树科技\n- **关键词**：硬件驱动、高动态运动控制、低成本电驱关节、强化学习。\n- **硬件**：自研关节电机、减速器、编码器等核心部件，强调高扭矩密度与成本控制。代表产品 H1、G1。\n- **运动控制**：四足时代积累的全身控制、模型预测控制与强化学习 sim2real 能力突出，人形机器人运动性能与稳定性较强。\n- **感知与决策**：上层具身智能、任务\n\n##### 核验事实、逻辑与结论并给出最终判断\n\n## 证据状况说明（先声明，影响下文置信度）\n\n本次共发起 10 次检索（中英文、长尾与宽口径均覆盖），**全部返回空结果**，说明检索工具当前不可用。因此：\n\n- 我**无法提供经外部实时数据核验**的最新出货量、订单、财报、融资估值等数字；\n- 下文判断基于我的**既有认知（训练数据，时效大致截至 2025 年上半年）**，属于**「待核验的既有认知」**，不是本轮检索所得的「事实」；\n- 凡涉及具体数字（出货量、订单金额、估值、交付数），**均有较高过时与偏差风险**，请以最新公告/财报为准。\n\n按规则，我不在有证据缺口时强行下断言——所以下文刻意区分「事实」「观点」「推测」，并把需你补充核实的关键点单列。\n\n---\n\n## 一、子任务拆分（建议的对比框架）\n\n**ST1 — 技术路线对比**（本体与硬件架构 / 运动控制 / AI「大脑」/ 数据与仿真 / 开源策略）\n**ST2 — 商业化进展对比**（产品矩阵与定价 / 目标客户与场景 / 出货与订单口径 / 收入结构 / 资本与上市）\n**ST3 — 事实与逻辑核验**（数据口径一致性、矛盾点、易被夸大的叙事）\n**ST4 — 综合结论与权衡建议**（各自的强项、风险与「该看什么指标」）\n\n四个子任务中，ST1、ST2 依赖外部实时数据，本轮只能给框架 + 既有认知；ST3、ST4 的**方法论与逻辑判断**可当场给出，且不随时间失效。\n\n---\n\n## 二、ST1 技术路线（既有认知，先标注为「推测/观点」）\n\n| 维度 | 宇树科技 Unitree | 优必选 UBTech | 智元机器人 AgiBot |\n|---|---|---|---|\n| 出身/基因 | 四足起家，硬件运动控制基因 | 全栈自研，伺服—本体—AI 一路做上来 | 软硬一体，大模型/数据驱动，华为系人才 |\n| 代表机型 | H1、G1（低价，约 9.9 万元级）H1-2 | Walker / Walker X / Walker S / S1 系列 | 远征 A1/A2、灵犀 X1/X2、A2-W |\n| 技术侧重 | 关节模组自研、高动态运动、sim2real、**成本与性能** | 全尺寸工业级本体，强调「大脑-小脑-本体」，工厂场景适配 | 具身基座大模型（GO 系列）、**数据采集工厂 + 开源生态** |\n| 开源/生态 | 相对封闭，靠产品性价比扩散 | 商用为主 | **开源激进**（图纸、操作系统、数据集） |\n\n**评审判断**：三者并非同一维度的竞争——宇树是**「硬件+运动能力」**路线，优必选是**「全栈+工业落地」**路线，智元是**「通用智能+数据/生态」**路线。把三者简单比「谁更强」是**错误的比较框架**，应分维度看。\n\n---\n\n## 三、ST2 商业化进展（既有认知，数字高度待核验）\n\n- **宇树**：四足机器人已规模化出货（消费/教育/工业），全球份额靠前；人形 G1 以低价推动科研教育市场放量；**人形绝对出货量仍小于四足**。2025 年有 IPO/上市辅导相关传闻。\n - 标注：四足「已量产」为**较高置信事实**；人形具体销量为**推测**。\n- **优必选**：2023 年底港股上市（「人形机器人第一股」）；Walker S 系列进入多家车企/工厂**实训**（蔚来、比亚迪、富士康、极氪等），宣称获得车厂订单/意向；**但长期亏损，人形机器人收入占比小**，营收仍依赖教育/物流/消费业务。\n - 标注：上市为**事实**；「实训 ≠ 采购交付」，订单多为意向/框架，**实际交付与验收金额不明**——这是最易被夸大的点。\n- **智元**：量产口号激进（曾宣称千台级下线），资本运作活跃（2025 年传有借壳/收购上市公司股权动作），建数据采集中心，商用产品线铺得广。\n - 标注：「下线」与「交付客户并付费验收」是两回事，**口头/目标出货不等于销售**——**属推测**，需核实。\n\n---\n\n## 四、ST3 核验：必须警惕的三处逻辑/口径陷阱\n\n1. **「出货量」口径混乱**：样机 / 意向订单 / 框架协议 / 实训部署 / 实际交付验收，五者常被混为一谈。**结论：任何「千台级」数字，都要追问是哪种口径。**\n2. **「进厂实训」≠ 商业化成功**：工厂试点多为付费意愿未验证的概念验证。**结论：需看复购与验收付款，而非进场新闻。**\n3. **「人形机器人收入」与「公司总收入」混淆**：优必选等上市公司总营收中，人形贡献仍小；用公司营收证明人形商业化是**逻辑跳跃**。\n\n---\n\n## 五、ST4 综合结论与权衡建议\n\n**技术路线**：宇树重**硬件/运动与成本**，优必选重**全栈与工业适配**，智元重**通用智能与数据生态**。三者互补大于直接对抗，赛道尚未收敛。\n\n**商业化成熟度（既有认知排序，置信度中低）**：\n- 收入确定性：宇树（四足）\u003e 优必选（多业务但人形占比小）\u003e 智元（早期、量产待验证）；\n- 工业场景验证：优必选暂时领先（实训名单最实）；\n- 量产激进程度：智元口号最激进，但**最需要被证据检验**。\n\n**给决策者的三条取舍建议**：\n1. 看**本体与出货**→ 关注宇树，但要区分四足与人形、且警惕低价放量对毛利的影响；\n2. 看**工业落地证据**→ 关注优必选，但只认「验收付款」而非「实训/意向」；\n3. 看**通用智能与生态**→ 关注智元，但把「下线/目标」与「实际销售」严格分开。\n\n**统一结论**：三家**均处于商业模式未证明的早期阶段**，任何「已领跑」的说法都缺乏可核验的财务支撑。**现阶段应有条件的判断，而非定论。**\n\n---\n\n## 六、请你补充核实（补上我本轮无法完成的证据）\n\n- 三家公司**最近一期**的：实际交付台数（非意向）、人形相关营收/毛利、在手订单验收情况；\n- 优必选最新财报中**人形机器人收入占比**；\n- 宇树 IPO 进展、智元资本运作的**官方披露原文**；\n- 统一口径的第三方出货量榜单（如高工/IDC/GGII 等）。\n\n若你提供上述材料，或检索工具恢复，我可对 ST1–ST4 逐条替换为**经证据核验**的版本，并重新给出结论。**当前版本请按「既有认知 + 待核验」使用，勿直接引用其中的数字。**\n\n\u003c/details\u003e","timestamp":"2026-09-25 19:23:16","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_04/summary.md b/test/general_assistant/run_04/summary.md new file mode 100644 index 0000000..c06a1c0 --- /dev/null +++ b/test/general_assistant/run_04/summary.md @@ -0,0 +1,7 @@ +# run_04 +- 类型：编排型（公司对比） +- 意图：orchestrated +- 字数：12593 +- details：True +- 子任务数：16 +- 时间：19:23:16 diff --git a/test/general_assistant/run_05/request.json b/test/general_assistant/run_05/request.json new file mode 100644 index 0000000..8565418 --- /dev/null +++ b/test/general_assistant/run_05/request.json @@ -0,0 +1 @@ +{"message":"Search for the latest 2026 pricing of Tesla Optimus humanoid robot.","mode":"quick","task_id":0,"specialist_key":""} diff --git a/test/general_assistant/run_05/response.json b/test/general_assistant/run_05/response.json new file mode 100644 index 0000000..9d41d18 --- /dev/null +++ b/test/general_assistant/run_05/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"检索未能返回结果（多次尝试均无数据），因此我无法确认 2026 年的最新定价。以下是我在知识范围内的已知信息，**未经实时验证，请以官方渠道为准**：\n\n**关键结论：截至我掌握的公开信息，特斯拉从未公布 Optimus 的正式零售定价，也没有 2026 年官方售价。**\n\n已公开的表态（均为马斯克个人说法，非官方定价）：\n- 在 2024 年 10 月「We, Robot」发布会及此前财报电话会上，马斯克称 Optimus 未来售价目标约 **2 万–3 万美元**，并称\"可能比一辆车还便宜\"。\n- 量产时间表：马斯克多次表示 2025 年起先在特斯拉自家工厂内部使用，**对外销售目标约在 2026 年**，但时间表已多次推迟（\"明年量产\"的说法自 2022 年起反复出现）。\n\n需要提醒的点：\n- 目前没有官方 SKU、配置或价格单，网传的\"3 万美元预售\"\"2026 上市价\"多为媒体推测或二手转述，可信度低。\n- 该品类（人形机器人）尚无成熟消费级定价体系，2026 年实际价格可能因配置（工业版／家用版）差异很大。\n\n**建议获取权威价格的渠道：**\n1. 特斯拉官网 / 官方新闻稿（tesla.com）\n2. 特斯拉季度财报电话会记录（ir.tesla.com）\n3. 马斯克 X（Twitter）账号\n\n如果我需要给出确切数字，建议你允许我再次联网查询，或提供你看到的某条具体报道链接，我来帮你核实出处。","timestamp":"2026-09-25 19:23:43","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_05/summary.md b/test/general_assistant/run_05/summary.md new file mode 100644 index 0000000..f9970c4 --- /dev/null +++ b/test/general_assistant/run_05/summary.md @@ -0,0 +1,6 @@ +# run_05 +- 类型：单问联网搜索（英文） +- 意图：single_search +- 字数：614 +- details：False +- 时间：19:23:43 diff --git a/test/general_assistant/run_06/request.json b/test/general_assistant/run_06/request.json new file mode 100644 index 0000000..8ecb95f --- /dev/null +++ b/test/general_assistant/run_06/request.json @@ -0,0 +1,6 @@ +{ + "message": "请分三部分分别调研具身智能机器人产业链的上游、中游、下游，每部分给出代表性公司名称和最新进展，最后合并成一份结构化报告", + "specialist_key": "general-assistant", + "mode": "chat", + "stream": false +} \ No newline at end of file diff --git a/test/general_assistant/run_06/summary.md b/test/general_assistant/run_06/summary.md new file mode 100644 index 0000000..b3b2ddb --- /dev/null +++ b/test/general_assistant/run_06/summary.md @@ -0,0 +1,8 @@ +# run_06 +- 类型：编排型（多部分任务） +- 意图：orchestrated +- 状态：超时（未返回结果） +- 耗时：>300s（无响应，客户端中断） +- 时间：2026-09-25 20:04 +- 说明：请求为「分上中下游调研具身智能机器人产业链」。编排器需拆解多子任务、每子任务走 web_search（三级源）。因本机数据中心 IP（180.158.134.57）触发百度「安全验证」/搜狗「点击验证码」反爬，搜索源持续超时，叠加 LLM 多轮 tool_calls，整体超过客户端等待上限。 +- 结论：编排链路本身逻辑正常（见 run_01 曾成功返回 43KB 编排结果），但**依赖搜索数据时，在网络反爬未解决前无法稳定跑通**。 \ No newline at end of file diff --git a/test/general_assistant/run_07/request.json b/test/general_assistant/run_07/request.json new file mode 100644 index 0000000..870cbc8 --- /dev/null +++ b/test/general_assistant/run_07/request.json @@ -0,0 +1,6 @@ +{ + "message": "帮我联网查一下：近期有哪些公司在做人形机器人？给出几家有代表性的公司名字", + "specialist_key": "general-assistant", + "mode": "chat", + "stream": false +} \ No newline at end of file diff --git a/test/general_assistant/run_07/summary.md b/test/general_assistant/run_07/summary.md new file mode 100644 index 0000000..3b8605f --- /dev/null +++ b/test/general_assistant/run_07/summary.md @@ -0,0 +1,8 @@ +# run_07 +- 类型：联网单问 +- 意图：single_search +- 状态：超时（未返回结果） +- 耗时：>180s（无响应，客户端中断） +- 时间：2026-09-25 20:10 +- 说明：请求为「联网查近期做做人形机器人的公司」。单问意图应快速返回，但 web_search 走三级源时：SearXNG 空 → 搜狗HTTP 被 checkSNUID 拦 → 浏览器兜底又被百度/搜狗验证码卡住（见 run_06 同因）。三级源每级都要等超时，单次搜索即 30s+，再叠加 LLM 多轮 tool_calls，导致单问也超时。 +- 结论：核心阻塞是**数据中心 IP 被所有免费搜索源反爬标记**，非意图分流或编排逻辑问题。对比 run_05（英文单问 19:23 曾成功）可见结果不稳定，取决于当时是否偶发绕过验证码。 \ No newline at end of file diff --git a/test/general_assistant/run_08/request.json b/test/general_assistant/run_08/request.json new file mode 100644 index 0000000..97d50a7 --- /dev/null +++ b/test/general_assistant/run_08/request.json @@ -0,0 +1,6 @@ +{ + "message": "解释一下大语言模型里的 temperature 参数是什么？它影响模型的什么行为？", + "specialist_key": "general-assistant", + "mode": "chat", + "stream": false +} \ No newline at end of file diff --git a/test/general_assistant/run_08/response.json b/test/general_assistant/run_08/response.json new file mode 100644 index 0000000..42a9424 --- /dev/null +++ b/test/general_assistant/run_08/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"Temperature 是大语言模型**推理/采样阶段**的一个参数，不是模型训练出来的权重。它用来调节下一个 token 的概率分布有多“随机”。\n\n原理上，模型先给每个候选 token 一个分数 logits，然后：\n\n\\[\np_i = \\frac{\\exp(z_i / T)}{\\sum_j \\exp(z_j / T)}\n\\]\n\n其中 \\(T\\) 就是 temperature。\n\n- **T \u003c 1，低温**：分布更尖锐，高概率 token 更容易被选中。输出更确定、保守、稳定，适合事实问答、代码、结构化任务。\n- **T = 1**：按模型原始概率采样。\n- **T \u003e 1，高温**：分布更平坦，低概率 token 也有更多机会被选中。输出更多样、发散、有创造性，但也更容易跑题、胡说或幻觉。\n- **T → 0**：接近贪心解码，每次选概率最高的 token；实际实现通常直接特殊处理为 greedy。\n\n它主要影响这些行为：\n\n1. **随机性/多样性**：温度越高，同一 prompt 每次输出差异越大。\n2. **创造性**：高温更容易产生意外组合和新表达。\n3. **稳定性/一致性**：低温输出更可复现、更稳定。\n4. **事实准确性**：高温通常增加幻觉和错误风险；低温更稳，但可能单调、重复。\n5. **解码效果**：它不改变模型知识，只改变从概率分布里怎么选词。\n\n实际使用中，Temperature 常和 top-k、top-p 一起用。经验上：事实问答/代码用 0～0.3，普通对话 0.5～0.8，创意写作可到 0.8～1.2 或更高。","timestamp":"2026-09-25 20:10:40","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_08/summary.md b/test/general_assistant/run_08/summary.md new file mode 100644 index 0000000..b072316 --- /dev/null +++ b/test/general_assistant/run_08/summary.md @@ -0,0 +1,9 @@ +# run_08 +- 类型：纯知识直答 +- 意图：direct_answer +- 状态：成功 +- 耗时：约 8s +- 字数：687 +- 时间：2026-09-25 20:10:40 +- 说明：请求为「解释大语言模型里的 temperature 参数」。未触发联网/编排，单轮直答即返回，内容：temperature 是采样阶段参数，给出 softmax 公式（p_i = exp(z_i/T)/Σ...）、T<1 低温确定性高、T=1 原始采样、T>1 高温发散、T→0 贪心解码、并说明与 top_p 的区别。专业准确。 +- 结论：direct_answer 路径正常（~8s，结构化、专业）。这是三类意图中唯一完全通畅的路径，验证了不依赖外部搜索时通用助手本体能力可靠。这也说明超时问题**不在直答/编排逻辑，而在搜索数据源的反爬**。 \ No newline at end of file diff --git a/test/general_assistant/run_09/request.json b/test/general_assistant/run_09/request.json new file mode 100644 index 0000000..66735f8 --- /dev/null +++ b/test/general_assistant/run_09/request.json @@ -0,0 +1,6 @@ +{ + "message": "请解释机器学习中的过拟合（overfitting）问题：它是什么、为什么会发生、有哪些常见的解决方法？给出一个通俗但准确的专业回答。", + "specialist_key": "general-assistant", + "mode": "chat", + "stream": false +} \ No newline at end of file diff --git a/test/general_assistant/run_09/response.json b/test/general_assistant/run_09/response.json new file mode 100644 index 0000000..b5e3a39 --- /dev/null +++ b/test/general_assistant/run_09/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"**一句话**：过拟合是模型在训练集上“考满分”，但换到新数据就“露馅”——它把噪声和偶然规律也当成真规律学进去了。\n\n**是什么** \n- 训练误差很低，验证/测试误差却很高。 \n- 从偏差-方差看，属于**高方差**：模型对训练样本的微小变化过于敏感。 \n- 典型曲线：验证误差先下降，随后随着训练继续反而上升。\n\n**为什么会发生** \n- 模型太复杂：参数太多、网络太深、树太深，容量超过了数据能支撑的信息量。 \n- 数据太少、噪声大、特征维度高，模型容易记住“特例”而非规律。 \n- 训练太久，模型开始拟合残差和噪声。 \n- 反复用同一验证集/测试集调参，或存在数据泄露，也会造成“看起来过拟合/虚高”。\n\n**常见解决方法** \n1. **数据层面**：增加样本、数据增强、加噪声、重采样。 \n2. **模型层面**：降低复杂度，如减少参数、降维、特征选择、决策树剪枝、限制深度。 \n3. **正则化**：L1/L2、权重衰减、Dropout、标签平滑；正则太强会转向欠拟合。 \n4. **早停**：监控验证集误差，在它开始上升前停止训练。 \n5. **可靠评估**：交叉验证，验证集调参，测试集只在最后用一次。 \n6. **集成方法**：Bagging、随机森林、模型平均等可降低方差。 \n7. **其他**：贝叶斯先验、最大间隔思想、批归一化等也有一定正则效果。\n\n**关键点**：过拟合无法完全消除，只能缓解；目标不是训练误差最低，而是**泛化误差最低**。就像学生背答案不如理解规则——模型要学的是规律，不是题面。","timestamp":"2026-09-25 20:33:47","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_09/summary.md b/test/general_assistant/run_09/summary.md new file mode 100644 index 0000000..ba32979 --- /dev/null +++ b/test/general_assistant/run_09/summary.md @@ -0,0 +1,8 @@ +# run_09 +- 类型：纯知识直答 +- 意图：direct_answer +- 状态：成功 +- 耗时：14.4s（后端 ai_call_log: 14415ms） +- 时间：2026-09-25 20:33:47 +- 说明：请求为「解释机器学习里的过拟合」。未触发联网/编排，单轮直答返回，内容：过拟合定义、成因（模型复杂度过高/数据不足/噪声）、三大类解决（数据层/模型层/正则化层）结构化专业回答。 +- 结论：direct_answer 路径稳定（~14s）。证明在不依赖搜索时通用助手本体能力可靠。这也再次印证：超时问题集中在「联网/编排」路径，与直答逻辑无关。 \ No newline at end of file diff --git a/test/general_assistant/run_10/request.json b/test/general_assistant/run_10/request.json new file mode 100644 index 0000000..efcde15 --- /dev/null +++ b/test/general_assistant/run_10/request.json @@ -0,0 +1,6 @@ +{ + "message": "帮我把“系统学习 Rust 语言”拆解成一个分阶段的学习规划，从入门到精通，明确每个阶段应该掌握的核心知识点和推荐的实践方式，最后给出总的学习路线建议。", + "specialist_key": "general-assistant", + "mode": "chat", + "stream": false +} \ No newline at end of file diff --git a/test/general_assistant/run_10/summary.md b/test/general_assistant/run_10/summary.md new file mode 100644 index 0000000..f481055 --- /dev/null +++ b/test/general_assistant/run_10/summary.md @@ -0,0 +1,9 @@ +# run_10 +- 类型：分阶段规划编排 +- 意图：规划 / 编排 +- 状态：超时（后端未返回结果，客户端 200s 中断） +- 耗时：>200s +- 时间：2026-09-25 20:33 后 +- 说明：请求为「把系统学习 Rust 拆成分阶段规划」。被判定为复杂任务进入编排路径，拆解子任务。理论上该任务不需要联网，但编排器对子任务可能同步触发搜索源，而当前未配付费 key、搜索源逐级串行等超时（searxng 25s + sogou 15s + browser 20s+ ≈ 60-80s/轮），叠加编排多子任务与 LLM 多轮，总时长超过客户端上限。 +- 证据：后端 ai_call_log 未新增记录、请求无完成日志，后端本身健康（最小直答 1.2s 正常），故为长耗时路径超时，非服务故障。 +- 结论：**除非解决搜索源慢/超时收敛，编排类任务无法稳定跑通**。 \ No newline at end of file diff --git a/test/general_assistant/run_11/request.json b/test/general_assistant/run_11/request.json new file mode 100644 index 0000000..fb04c7f --- /dev/null +++ b/test/general_assistant/run_11/request.json @@ -0,0 +1,6 @@ +{ + "message": "帮我联网查一下：2026年诺贝尔物理学奖的获奖者是谁？他们因为什么成就获奖？", + "specialist_key": "general-assistant", + "mode": "chat", + "stream": false +} \ No newline at end of file diff --git a/test/general_assistant/run_11/summary.md b/test/general_assistant/run_11/summary.md new file mode 100644 index 0000000..87b3d33 --- /dev/null +++ b/test/general_assistant/run_11/summary.md @@ -0,0 +1,9 @@ +# run_11 +- 类型：联网实时单问 +- 意图：single_search +- 状态：超时（后端未返回结果，客户端 150s 中断） +- 耗时：>150s +- 时间：2026-09-25 20:35 后 +- 说明：请求为「联网查 2026 诺贝尔物理学奖得主」。走 web_search 工具。未配付费 key 时，每次搜索都要串行等完 searxng(25s)+sogou(15s)+browser(20s+)≈60-80s。该类实时问答 LLM 常连续调多轮 web_search 工具，每轮 80s，两轮即超 150s，故超时。 +- 对比：20:28 的同路径单问（人形机器人）耗时 82s 且能诚实降级返回，说明耗时敏感于 LLM 是否多轮调用搜索。 +- 结论：**搜索源未配付费 key 时，每轮搜索 60-80s 的串行等待是联网路径超时的直接根因**。需并发探测 + 收紧超时 + 配置稳定可用的付费源三者其一才可根治。 \ No newline at end of file diff --git a/test/general_assistant/run_12/request.json b/test/general_assistant/run_12/request.json new file mode 100644 index 0000000..fb04c7f --- /dev/null +++ b/test/general_assistant/run_12/request.json @@ -0,0 +1,6 @@ +{ + "message": "帮我联网查一下：2026年诺贝尔物理学奖的获奖者是谁？他们因为什么成就获奖？", + "specialist_key": "general-assistant", + "mode": "chat", + "stream": false +} \ No newline at end of file diff --git a/test/general_assistant/run_12/response.json b/test/general_assistant/run_12/response.json new file mode 100644 index 0000000..66dda93 --- /dev/null +++ b/test/general_assistant/run_12/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"**截至目前的检索结果：2026年诺贝尔物理学奖尚未揭晓，暂无获奖者。**\n\n**关键信息**\n- 据诺贝尔奖官网，2026年诺贝尔奖各项奖项定于 **2026年10月5日至12日** 陆续公布，其中**物理学奖定于 10月6日（周二）** 揭晓。（来源：央视网、中国新闻网、AiTimeline 等）\n- 在检索到的最新信息中（截至2026年9月17日前后），**没有任何机构公布过2026年的获奖者**，因此网上若出现\"2026诺贝尔物理学奖得主\"的具体名单，多为预测或不实信息。（来源：AiTimeline \"Nobel Prize 2026 Timeline\"）\n- 目前仅有**\"引文桂冠奖\"（Citation Laureates，被称为\"诺奖风向标\"）**名单：2026年度物理学领域为中国科学院院士、南方科技大学校长**薛其坤**获奖，但这是预测性奖项，**不等于诺贝尔奖**。（来源：搜狐、腾讯新闻）\n\n**参考：2025年诺贝尔物理学奖**\n- 获奖者：**John Clarke、Michel H. Devoret、John M. Martinis**（均为美国高校学者）\n- 获奖原因：在**量子力学领域的成果，推动了量子技术的发展**（宏观量子隧穿与电路中的量子化能级研究）。（来源：AP/CBS17、WJLA 等）\n\n**建议**：待 **2026年10月6日** 官方公布后，可到诺贝尔奖官网（nobelprize.org）或权威媒体核实最新得主。如果你需要，我可以届时再帮你查一次。","timestamp":"2026-09-25 20:56:50","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_12/summary.md b/test/general_assistant/run_12/summary.md new file mode 100644 index 0000000..abcef83 --- /dev/null +++ b/test/general_assistant/run_12/summary.md @@ -0,0 +1,11 @@ +# run_12 +- 类型：联网实时单问（对比 run_11 超时路径） +- 意图：single_search（「联网查 + 单一事实」） +- 状态：成功 +- 耗时：31.9s（HTTP 200） +- 时间：2026-09-25 20:56:50（ai_call_log #280，latency 63s/请求 31.9s） +- 说明：请求「2026 诺贝尔物理学奖得主」。这是 run_11（150s 超时）的同款回归用例。 +- 结果：**SerpApi 作为主源生效后，同一任务从「150s 超时无结果」变为「31.9s 返回真实、带来源、诚实」**： + - 正确指出 2026 诺奖**尚未揭晓**（物理学奖定于 10月6日），引用央视网、中国新闻网、AiTimeline + - 诚实否定了网传预测名单，明确区分「引文桂冠奖」与「诺贝尔奖」，符合项目搜索诚实性 +- 结论：✅ 付费源彻底修复 single_search 路径的速度与可用性。 \ No newline at end of file diff --git a/test/general_assistant/run_13/request.json b/test/general_assistant/run_13/request.json new file mode 100644 index 0000000..dd50b32 --- /dev/null +++ b/test/general_assistant/run_13/request.json @@ -0,0 +1,6 @@ +{ + "message": "帮我调研一下具身智能（embodied AI）产业的现状，梳理这条产业链的上游、中游、下游分别有哪些环节和代表厂商，当前的技术瓶颈和商业化进展如何？请整理成一份报告，引用尽量准确。", + "specialist_key": "general-assistant", + "mode": "chat", + "stream": false +} \ No newline at end of file diff --git a/test/general_assistant/run_13/summary.md b/test/general_assistant/run_13/summary.md new file mode 100644 index 0000000..6e84d2f --- /dev/null +++ b/test/general_assistant/run_13/summary.md @@ -0,0 +1,19 @@ +# run_13 +- 类型：编排型综合任务（具身智能产业链报告） +- 意图：orchestrated（命中「调研 / 产业链 / 上中下游 / 报告」多信号词） +- 状态：超时（HTTP 000，客户端 210s 中断，无响应文件） +- 时间：2026-09-25 21:00 前后 +- 现象： + - 后端健康（200）正常，但 chat 请求 210s 无返回 + - ai_call_log 近 6 分钟出现 4 条 failed 记录（每次约 20-21s），即编排内部多次 LLM 调用**失败**而非成功 +- 根因（结合代码 + 日志）： + 1. `orchestrate.go` 的 150s 兜底 ctx **传导失效**：编排里 `judgeIntent`(L180)/`planSubTasks`(L239)/`merge`(L403) 调用的 `ai.GenerateWithFallback(route, msgs)` **不接收 ctx 参数**（signature `GenerateWithFallback(primary, messages)`），内部 `client.Generate` 走自己的 http timeout，完全不受编排 150s ctx 取消控制。LLM 端慢/失败时只能等各自超时，整体远超 150s/210s。 + 2. executeSubTasks 里并发 worker 的 `agent.Run(ctx, ...)` 虽带 ctx，但上游判断/拆解环节（GenerateWithFallback）已不可中断，链路整体失控。 + 3. 编排失败后回收不干净，期间**阻塞后续 chat 请求**（run_14 在 run_13 排障期间也超时）。 +- 结论：❌ 编排路径依然是超时黑洞，根因是「编排超时兜底未能传导到 LLM 调用链」。SerpApi 解决了搜索速度，但未解决编排超时控制。 + +## 横向对照 +| 路径 | run_12 单问 | run_13 编排 | +|------|------------|------------| +| SerpApi 前 | run_11 150s 超时 | run_06/07/10 超时 | +| SerpApi 后 | ✅ 31.9s 成功 | ❌ 210s 超时（根因非搜索，是编排超时兜底失效） | \ No newline at end of file diff --git a/test/general_assistant/run_14/request.json b/test/general_assistant/run_14/request.json new file mode 100644 index 0000000..9f8db17 --- /dev/null +++ b/test/general_assistant/run_14/request.json @@ -0,0 +1,6 @@ +{ + "message": "请对比解释一下 HTTP/2 和 HTTP/3 的区别，重点说明它们各自解决了什么问题、在连接建立和传输效率上的差异，以及分别适合什么场景。", + "specialist_key": "general-assistant", + "mode": "chat", + "stream": false +} \ No newline at end of file diff --git a/test/general_assistant/run_14/summary.md b/test/general_assistant/run_14/summary.md new file mode 100644 index 0000000..d1a8e95 --- /dev/null +++ b/test/general_assistant/run_14/summary.md @@ -0,0 +1,18 @@ +# run_14 +- 类型：预期「纯知识直答」（HTTP/2 vs HTTP/3 对比） +- 意图误判：本意测直答基线，但 prompt 含「对比」→ 命中 judgeIntent 强规则（编排信号词：对比），被判 **orchestrated**，实际走了编排路径 +- 状态：超时（HTTP 000，60s 无返回）；两次尝试均失败 +- 时间：2026-09-25 21:03（第二次，后端已恢复后仍超时） +- 证据：近 6 分钟 ai_call_log 有 failed 记录（20s 级），为编排内部 LLM 调用失败 +- 结论： + 1. **「对比」被当作编排信号词**是设计使然（judgeIntent 强规则要「对比→orchestrated」产出结构化多段）。这是真实业务需要的强规则，不是 bug。 + 2. 因此 run_14 实际测的是**编排路径**，与 run_13 同根因超时。 + 3. 纯直答基线由 run_09（14s，不触发联网词）单独代表，仍成立。 +- 教训：测「直答」必须避开编排信号词（对比/分析/报告/上中下游等）；否则会进入编排路径并被当前超时问题拖住。 + +## 三次测试小结（SerpApi 接入后） +- run_12 联网单问：✅ 31.9s（SerpApi 修复 single_search） +- run_13 编排型：❌ 210s 超时 +- run_14 含「对比」：❌ 60s 超时（同 run_13，被编排路径拖住） + +统一结论：**SerpApi 解决了搜索可用性/速度，但编排路径的「超时兜底失效」仍会导致 150s+ 超时且阻塞后续请求**——这是下一步必须修的结构问题。 \ No newline at end of file diff --git a/test/general_assistant/run_15/request.json b/test/general_assistant/run_15/request.json new file mode 100644 index 0000000..9f8db17 --- /dev/null +++ b/test/general_assistant/run_15/request.json @@ -0,0 +1,6 @@ +{ + "message": "请对比解释一下 HTTP/2 和 HTTP/3 的区别，重点说明它们各自解决了什么问题、在连接建立和传输效率上的差异，以及分别适合什么场景。", + "specialist_key": "general-assistant", + "mode": "chat", + "stream": false +} \ No newline at end of file diff --git a/test/general_assistant/run_15/response.json b/test/general_assistant/run_15/response.json new file mode 100644 index 0000000..8913d15 --- /dev/null +++ b/test/general_assistant/run_15/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"已按子任务完成，但结果为空，请重试。\n\n\u003cdetails\u003e\u003csummary\u003e📋 本次由通用编排拆分执行\u003c/summary\u003e\n\n##### 定义对比框架与输出大纲（维度：解决的问题、连接建立、传输效率、适用场景）\n\n（本子任务结果为空）\n\n##### \n\n（本子任务结果为空）\n\n##### \n\n（本子任务结果为空）\n\n##### \n\n（本子任务结果为空）\n\n##### 整合撰写对比解释文：逐维度对照 HTTP/2 vs HTTP/3，含机制原理与场景建议\n\n（本子任务结果为空）\n\n##### \n\n（本子任务结果为空）\n\n\u003c/details\u003e","timestamp":"2026-09-25 21:32:52","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_15/response_success.json b/test/general_assistant/run_15/response_success.json new file mode 100644 index 0000000..5485535 --- /dev/null +++ b/test/general_assistant/run_15/response_success.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"# HTTP/2 vs HTTP/3 对比\n\n\u003e **核心判断**：HTTP/2 修补的是 **HTTP/1.1 的应用层低效**——把请求-响应抽象成\"流\"，复用到一条 TCP 连接上；HTTP/3 修补的是 **TCP 协议本身的缺陷**——用基于 UDP 的 QUIC 替换 TCP，让\"流\"的独立性下沉到传输层。所以二者不是简单的版本迭代，而是**优化层次不同**：HTTP/2 在 TCP 之上做多路复用，HTTP/3 直接换掉了 TCP。\n\n---\n\n## 一、先对齐共同点（避免把差异归错地方）\n\n| 维度 | 说明 |\n|---|---|\n| 语义层 | 方法、状态码、首部字段、缓存语义与 HTTP/1.1 基本一致 |\n| 分帧方式 | 均为二进制帧 + 流，非文本协议 |\n| 多路复用 | 均支持一条连接上并发多个流 |\n| 头部压缩 | 均有专门机制（HPACK / QPACK） |\n| 协商 | 均通过 ALPN 协商（`h2` / `h3`）；HTTP/3 额外依赖 `Alt-Svc`（RFC 7838）或 HTTPS DNS 记录（RFC 9460 SVCB/HTTPS）发现 |\n\n**含义**：迁移到 HTTP/3 不改业务逻辑，改动集中在传输层与基础设施。\n\n---\n\n## 二、各自解决了什么问题\n\n### 2.1 HTTP/2 解决的 HTTP/1.1 痛点\n\n- **连接数瓶颈** → 单连接多路复用，一条 TCP 承载任意数量并发流。\n- **应用层队头阻塞** → 帧可交错发送，流之间在应用层互不阻塞。\n- **头部冗余** → **HPACK**（RFC 7541）：静态表 + 动态表 + 哈夫曼编码，重复首部只传索引。\n- **Server Push**：曾用于主动推送资源，但**实践中失败、已被主流浏览器移除**，不应作为选型理由。\n\n### 2.2 HTTP/2 的遗留问题（正是 HTTP/3 的出发点）\n\n- **TCP 层队头阻塞**：HTTP/2 的\"流\"只是应用层概念，底层仍是**单一字节流**。任一段丢失，内核必须等重传完成才能交付后续数据，**所有流一起被卡住**。丢包率越高，多路复用收益越被抵消。\n- **握手成本高**：TCP 三次握手与 TLS 握手串行，无法合并。\n- **连接与网络绑定**：TCP 连接由四元组标识，Wi-Fi 切蜂窝即断，需重做完整握手。\n- **协议僵化**：TCP 由内核实现、中间盒广泛干预，传输层难以演进。\n\n### 2.3 HTTP/3 的解决方式\n\nHTTP/3（**RFC 9114**）= HTTP over QUIC；QUIC（**RFC 9000**）是用户态实现、内建 TLS 1.3（**RFC 9001**）的可靠传输协议：\n\n- **消除传输层队头阻塞**：QUIC 的流是传输层原生概念，每条流独立流控与重传，丢包只影响该流。\n- **握手合并**：传输握手与 TLS 1.3 握手合并，新建连接 1 RTT，会话恢复可达 0-RTT。\n- **连接迁移**：由 Connection ID 而非 IP/端口标识连接，网络切换时连接存活，仅需路径验证。\n- **QPACK**（RFC 9204）：动态表更新走独立单向流，容忍乱序，避免 HPACK 式按序解码阻塞。\n- **默认加密 + 可演进**：除必要字段外全部加密；丢失检测与拥塞控制（RFC 9002）也在用户态，便于快速迭代。\n\n---\n\n## 三、连接建立：RTT 差异\n\n以\"首次能发出第一个请求\"计：\n\n| 场景 | HTTP/2（TCP + TLS） | HTTP/3（QUIC） |\n|---|---|---|\n| 全新连接 | TLS 1.3：**2 RTT**（TCP 1 + TLS 1）；TLS 1.2：**3 RTT** | **1 RTT**（传输与加密握手合并） |\n| 会话恢复 | 约 **1 RTT**（TLS 1.3 PSK + 早期数据；TCP 握手无法免除） | **0-RTT** |\n| 网络切换（Wi-Fi ↔ 蜂窝） | 连接断开，**重走完整握手** | **连接迁移**，无需重新握手，仅路径验证 |\n\n\u003e ⚠️ **0-RTT 数据可被重放**，服务端通常只接受幂等或明确安全的请求，不能当作无条件性能红利。\n\u003e 高延迟链路（如跨洲 200ms+）少 1 个 RTT 收益直观；低延迟内网基本感知不到。\n\n---\n\n## 四、传输效率：关键差异\n\n| 维度 | HTTP/2 | HTTP/3 |\n|---|---|---|\n| 承载协议 | TCP | QUIC over UDP（通常 UDP 443） |\n| 丢包影响 | 单包丢失阻塞**整条连接所有流** | 仅阻塞**该流** |\n| 头部压缩 | HPACK，动态表须按序处理 | QPACK，容忍乱序 |\n| 拥塞控制 | 内核 TCP 实现 | 用户态实现（RFC 9002），可调优 |\n| 加密 | 可选（实践普遍启用 TLS 1.2/1.3） | 强制，仅 TLS 1.3 |\n| CPU 开销 | 较低，内核与网卡卸载成熟 | 通常更高，用户态 + per-packet 加密 |\n| 中间盒友好度 | 高，TCP 443 通畅 | 较低，部分企业防火墙/代理屏蔽限速 UDP |\n\n**经验规律**（随网络条件变化，勿套固定百分比）：\n- 网络好、丢包低时，HTTP/3 吞吐提升有限，甚至可能因 CPU 开销略降。\n- 丢包、高 RTT、移动场景下，HTTP/3 优势明显放大——此时 TCP 队头阻塞代价最高。\n- **高丢包链路上，HTTP/2 可能比 HTTP/1.1 的多连接模式更差**，这正是\"所有鸡蛋放一个 TCP 篮子\"的后果。\n\n---\n\n## 五、适用场景与选型建议\n\n### 优先 HTTP/2\n- **内部服务间通信（东西向流量）**：数据中心低延迟低丢包，HTTP/3 握手与抗丢包优势无从体现；gRPC 等基于 HTTP/2 的生态成熟。\n- **UDP 受限环境**：企业内网、部分运营商、老旧代理屏蔽/限速 UDP 443，HTTP/3 会回退，不如以 HTTP/2 为主。\n- **服务端 CPU 敏感**：高并发网关、边缘节点，QUIC 用户态成本可能成瓶颈。\n- **需要最大兼容性 / 运维简单**：调试、抓包、负载均衡对 HTTP/2 支持度更高。\n\n### 优先 HTTP/3\n- **面向移动端与弱网用户**：蜂窝、Wi-Fi 抖动大、丢包高的环境，多流并发收益最显著。\n- **高 RTT 跨国/跨洲访问**：少 1 RTT 在 200ms+ 延迟下价值明显。\n- **频繁网络切换的场景**：移动设备在 Wi-Fi/蜂窝间切换，连接迁移避免重握手。\n- **可承担基础设施升级**：需要 CDN/网关/客户端全链路支持 QUIC，并接受 UDP 可达性风险。\n\n### 现实建议\n多数生产环境采取 **HTTP/2 与 HTTP/3 并存、按 ALPN/Alt-Svc 自动协商**的渐进策略：HTTP/2 保底兼容，HTTP/3 对支持且网络受益的客户端优先。不要为了\"版本更新\"而全量切换，应基于**实测丢包率、RTT 分布、CPU 余量、UDP 可达性**四类指标决策。\n\n---\n\n## 六、来源与说明\n\n**规范类（稳定、可直接引用）**\n- HTTP/2：RFC 7540（2015），后被 **RFC 9113**（2022）取代\n- HPACK：RFC 7541 ｜ QPACK：**RFC 9204**\n- HTTP/3：**RFC 9114**（2022）\n- QUIC：**RFC 9000** ｜ TLS over QUIC：**RFC 9001** ｜ 丢失检测与拥塞控制：**RFC 9002**\n- Alt-Svc：RFC 7838 ｜ HTTPS/SVCB DNS 记录：RFC 9460\n\n**关于实时部署数据的说明**：子任务中虽发起了联网检索，但**未返回可引用的实测结果**。因此本文的 RTT、丢包影响、CPU 开销等均为**基于 RFC 协议的定性结论**，未使用具体部署占比或性能百分比数字。若需精确的 HTTP/3 采用率、CDN 实测吞吐对比，建议以 Cloudflare、Google、Akamai 等 CDN 的官方技术博客或 W3Techs 统计为独立来源单独核实，避免跨来源口径混用。\n\n**评审遗留项**：原综合稿在\"优先选择 HTTP/3 的场景\"处被截断，本文已补全第五节场景清单与选型建议。\n\n\u003cdetails\u003e\u003csummary\u003e📋 本次由通用编排拆分执行\u003c/summary\u003e\n\n##### 梳理 HTTP/2 的核心机制与解决的问题\n\nI'll start by gathering authoritative primary sources (RFCs, standards bodies) and current deployment data.\n\n\u003c｜｜DSML｜｜ calls\u003e\n\u003c｜｜DSML｜｜ invoke name=\"web_search\"\u003e\n\u003c｜｜DSML｜｜ parameter name=\"query\" string=\"true\"\u003eHTTP/2 RFC 7540 core mechanisms multiplexing HPACK stream prioritization\u003c/｜｜DSML｜｜ parameter\u003e\n\u003c/｜｜DSML｜｜ invoke\u003e\n\u003c｜｜DSML｜｜ invoke name=\"web_search\"\u003e\n\u003c｜｜DSML｜｜ parameter name=\"query\" string=\"true\"\u003eHTTP/3 RFC 9114 QUIC RFC 9000 connection establishment 0-RTT TLS 1.3\u003c/｜｜DSML｜｜ parameter\u003e\n\u003c/｜｜DSML｜｜ invoke\u003e\n\u003c/｜｜DSML｜｜ calls\u003e\n\n##### 梳理 HTTP/3 的核心机制与解决的问题\n\nI'll research this topic with authoritative sources before answering.\n\n\u003c｜｜DSML｜｜ calls\u003e\n\u003c｜｜DSML｜｜ invoke name=\"web_search\"\u003e\n\u003c｜｜DSML｜｜ parameter name=\"query\" string=\"true\"\u003eHTTP/3 RFC 9114 QUIC RFC 9000 differences from HTTP/2\u003c/｜｜DSML｜｜ parameter\u003e\n\u003c/｜｜DSML｜｜ invoke\u003e\n\u003c｜｜DSML｜｜ invoke name=\"web_search\"\u003e\n\u003c｜｜DSML｜｜ parameter name=\"query\" string=\"true\"\u003eHTTP/2 head-of-line blocking TCP vs HTTP/3 QUIC stream independence\u003c/｜｜DSML｜｜ parameter\u003e\n\u003c/｜｜DSML｜｜ invoke\u003e\n\u003c/｜｜DSML｜｜ calls\u003e\n\n##### 对比 HTTP/2 与 HTTP/3 的连接建立过程与 RTT 差异\n\nI'll research this with authoritative sources (RFCs, measurement studies, and deployment data) before writing the comparison.\n\n\u003c｜｜DSML｜｜ calls\u003e\n\u003c｜｜DSML｜｜ invoke name=\"web_search\"\u003e\n\u003c｜｜DSML｜｜ parameter name=\"query\" string=\"true\"\u003eRFC 9113 HTTP/2 RFC 9114 HTTP/3 specification differences\u003c/｜｜DSML｜｜ parameter\u003e\n\u003c/｜｜DSML｜｜ invoke\u003e\n\u003c｜｜DSML｜｜ invoke name=\"web_search\"\u003e\n\u003c｜｜DSML｜｜ parameter name=\"query\" string=\"true\"\u003eHTTP/3 QUIC connection establishment 1-RTT 0-RTT handshake TLS 1.3 vs HTTP/2 TCP TLS\u003c/｜｜DSML｜｜ parameter\u003e\n\u003c/｜｜DSML｜｜ invoke\u003e\n\u003c/｜｜DSML｜｜ calls\u003e\n\n##### 对比 HTTP/2 与 HTTP/3 的传输效率、队头阻塞与头部压缩\n\n我先联网核实几个关键事实（RFC 编号、规范状态、实测数据），再给出对比。\n\n\u003c｜｜DSML｜｜ calls\u003e\n\u003c｜｜DSML｜｜ invoke name=\"web_search\"\u003e\n\u003c｜｜DSML｜｜ parameter name=\"query\" string=\"true\"\u003eRFC 9113 HTTP/2 RFC 9114 HTTP/3 specification\u003c/｜｜DSML｜｜ parameter\u003e\n\u003c/｜｜DSML｜｜ invoke\u003e\n\u003c｜｜DSML｜｜ invoke name=\"web_search\"\u003e\n\u003c｜｜DSML｜｜ parameter name=\"query\" string=\"true\"\u003eHTTP/3 QUIC connection establishment 0-RTT 1-RTT vs TCP TLS handshake latency\u003c/｜｜DSML｜｜ parameter\u003e\n\u003c/｜｜DSML｜｜ invoke\u003e\n\u003c/｜｜DSML｜｜ calls\u003e\n\n##### 综合整理适用场景与选型建议\n\n## 一句话结论\n\nHTTP/2 是对 **HTTP/1.1 应用层低效**的修补，它把请求-响应抽象成\"流\"并复用一条 TCP 连接；HTTP/3 则是对 **TCP 本身缺陷**的修补，它把传输层换成基于 UDP 的 QUIC，让\"流\"的独立性下沉到传输层。因此两者的差别不只是版本号，而是**优化层次不同**：HTTP/2 在 TCP 之上做多路复用，HTTP/3 直接换掉了 TCP。\n\n---\n\n## 一、先对齐基线：两者的共同点\n\n对比之前先明确它们**没有变**的部分，避免把差异归错地方：\n\n| 维度 | 说明 |\n|---|---|\n| 语义层 | 请求方法、状态码、首部字段、缓存语义与 HTTP/1.1 基本一致 |\n| 二进制分帧 | 都由帧（frame）与流（stream）组成，均非文本协议 |\n| 多路复用 | 都支持在一条连接上并发多个流 |\n| 头部压缩 | 都有专门的头部压缩机制（HPACK / QPACK） |\n| 加密现状 | 公网部署中基本都跑在 TLS 之上（HTTP/3 强制加密） |\n| 协商方式 | 都通过 ALPN 协商（`h2` / `h3`），HTTP/3 额外依赖 `Alt-Svc` 或 HTTPS DNS 记录发现 |\n\n**结论**：选择 HTTP/3 不需要改动应用代码的业务逻辑，改动集中在传输层与基础设施。\n\n---\n\n## 二、各自解决了什么问题\n\n### 2.1 HTTP/2 解决的问题\n\n针对 HTTP/1.1 的四个痛点：\n\n- **连接数瓶颈**：浏览器对同域并发连接限制（通常 6 条），导致大量请求排队。\n → HTTP/2 用**单连接多路复用**：一条 TCP 连接承载任意数量的并发流。\n- **应用层队头阻塞**：HTTP/1.1 的 pipelining 因响应必须按序返回而实际不可用。\n → HTTP/2 的帧可以交错发送，流之间在应用层互不阻塞。\n- **头部冗余**：每个请求重复携带 Cookie、User-Agent 等大字段。\n → **HPACK**（RFC 7541）用静态表 + 动态表 + 哈夫曼编码压缩，重复首部只传索引。\n- **服务器主动推送资源**：曾由 Server Push 承担。\n → **注意**：Server Push 在实践中失败并被主流浏览器移除，不建议作为选型理由。\n\n### 2.2 HTTP/2 遗留的问题（正是 HTTP/3 的出发点）\n\n- **TCP 层队头阻塞**：HTTP/2 的\"流\"只是应用层概念，底层仍是**单一字节流**。任何一个 TCP 段丢失，内核必须等它重传完成后才能把后续数据交给应用层——**所有流一起被卡住**。丢包率越高，多路复用的收益越被抵消。\n- **握手成本高**：TCP 三次握手与 TLS 握手是串行的，无法合并。\n- **连接与网络绑定**：TCP 连接由四元组标识，Wi-Fi 切到蜂窝网络即断开，必须重做完整握手。\n- **协议僵化**：TCP 由内核实现、中间盒广泛干预，传输层难以演进。\n\n### 2.3 HTTP/3 解决的问题\n\nHTTP/3（RFC 9114）是\"HTTP over QUIC\"，而 QUIC（RFC 9000）本身是一个在用户态实现的、内建 TLS 1.3 的可靠传输协议：\n\n- **消除传输层队头阻塞**：QUIC 的流是**传输层的原生概念**，每条流有独立的流控与重传。丢包只阻塞受影响的那条流，其他流照常交付。\n- **握手次数下降**：QUIC 把传输握手与 TLS 1.3 握手（RFC 9001）**合并**，新建连接 1 RTT，会话恢复可做到 0-RTT。\n- **连接迁移**：连接由 Connection ID 而非 IP/端口标识，网络切换时连接可存活，代价是路径验证而非完整重握手。\n- **头部压缩适配乱序**：QPACK（RFC 9204）用独立的单向流传输动态表更新，避免像 HPACK 那样要求严格按序解码而阻塞其他流。\n- **默认加密 + 可演进**：除少数必要字段外全部加密，用户态实现使协议可以快速迭代（RFC 9002 定义的丢失检测与拥塞控制也在用户态）。\n\n---\n\n## 三、连接建立：RTT 差异\n\n以\"首次建立连接到能发出第一个请求\"计：\n\n| 场景 | HTTP/2（TCP + TLS） | HTTP/3（QUIC） |\n|---|---|---|\n| 全新连接 | TLS 1.3：**2 RTT**（TCP 1 + TLS 1）\u003cbr\u003eTLS 1.2：**3 RTT**（TCP 1 + TLS 2） | **1 RTT**（传输与加密握手合并） |\n| 会话恢复 | TLS 1.3 PSK + 早期数据：约 **1 RTT**（TCP 握手无法免除） | **0-RTT**（重放风险需服务端策略约束） |\n| 网络切换（Wi-Fi ↔ 蜂窝） | 连接断开，需**重新走完整握手** | **连接迁移**，无需重新握手，仅做路径验证 |\n\n补充说明：\n\n- 0-RTT 数据**可被重放**，因此服务端通常只接受幂等或明确安全的请求，不应把它当作无条件的性能红利。\n- 在高延迟链路上，减少 1 个 RTT 的收益很直观；在低延迟内网中，这一优势基本感知不到。\n\n---\n\n## 四、传输效率：关键差异\n\n| 维度 | HTTP/2 | HTTP/3 |\n|---|---|---|\n| 承载协议 | TCP | QUIC over UDP（通常 UDP 443） |\n| 丢包影响 | 单包丢失阻塞**整条连接上的所有流** | 仅阻塞**该流** |\n| 头部压缩 | HPACK，动态表更新要求按序处理 | QPACK，动态表更新走独立单向流，容忍乱序 |\n| 拥塞控制 | 内核 TCP 实现 | 用户态实现（RFC 9002），可按应用调优 |\n| 加密 | 可选（实践中普遍启用 TLS 1.2/1.3） | 强制，仅 TLS 1.3 |\n| CPU 开销 | 较低，内核与网卡卸载成熟 | 通常更高，用户态处理与 per-packet 加密 |\n| 中间盒友好度 | 高，TCP 443 通畅 | 较低，部分企业防火墙/代理屏蔽或限速 UDP |\n\n**效率判断的经验规律**（随网络条件变化，不宜套用固定百分比）：\n\n- 网络质量好、丢包率低时，HTTP/3 相对 HTTP/2 的吞吐提升有限，甚至可能因 CPU 开销略降。\n- 网络丢包、高 RTT、移动场景下，HTTP/3 的优势明显放大——因为此时 TCP 队头阻塞的代价最高。\n- HTTP/2 在**高丢包链路**上会退化得比 HTTP/1.1 的多连接模式更差，这是\"所有鸡蛋放在一个 TCP 篮子\"的直接后果。\n\n---\n\n## 五、适用场景与选型建议\n\n### 5.1 优先选择 HTTP/2 的场景\n\n- **内部服务间通信（东西向流量）**：数据中心网络低延迟、低丢包，HTTP/3 的握手与抗丢包优势无法体现；gRPC 等基于 HTTP/2 的生态已成熟。\n- **UDP 受限环境**：企业内网、部分运营商网络、老旧代理设备屏蔽或限速 UDP 443。此时 HTTP/3 会回退到 HTTP/2，不如直接以 HTTP/2 为主。\n- **服务端 CPU 敏感**：高并发网关、边缘计算节点上，QUIC 的用户态加密与处理成本可能成为瓶颈。\n- **需要最大兼容性**：面向未知客户端群体、中间件链路复杂的场景。\n- **运维复杂度优先**：HTTP/2 的调试、抓包、负载均衡支持度更高。\n\n### 5.2 优先选择 HTTP/3 的场景\n\n- **面向移动端与弱网用户**：蜂窝网络、Wi-Fi 抖动大、丢包率高的环境，多流并发时收益最显著。\n- **高 RTT 跨国/跨洲访问**：少一个 RTT 的握手成本在 200ms+ 延迟下价值明显\n\n##### 审核技术准确性、逻辑一致性与用户要求覆盖度\n\n# 评审意见：HTTP/2 vs HTTP/3 对比材料\n\n## 总体结论\n\n**判断：技术准确性高，可沿用；但作为交付物「未完成」，且有三处表述需要收紧。**\n\n- 材料对核心机制的定性（分层优化、队头阻塞的层次、握手合并、连接迁移）**准确且有洞察**，RFC 引用逐条核对无误，是一份质量在平均线以上的对比稿。\n- **最严重的问题不是内容错，而是产物被截断**：正文停在 5.2「高 RTT 跨国/跨洲访问」一句中间，用户明确要求的\"适合什么场景\"只答了一半。\n- 若干表述过于绝对，会在被追问时露怯，需要加限定词。\n\n---\n\n## 一、技术准确性审核\n\n### 1.1 抽查确认无误的关键事实（可直接采信）\n\n| 断言 | 判定 | 依据 |\n|---|---|---|\n| HPACK = RFC 7541、QPACK = RFC 9204 | 【事实】✓ | RFC 编号正确 |\n| HTTP/3 = RFC 9114、QUIC = RFC 9000、TLS over QUIC = RFC 9001、丢失检测/拥塞控制 = RFC 9002 | 【事实】✓ | 全部正确 |\n| TLS 1.3 全新连接 = TCP\n\n\u003c/details\u003e","timestamp":"2026-09-25 22:02:48","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_15/summary.md b/test/general_assistant/run_15/summary.md new file mode 100644 index 0000000..3311088 --- /dev/null +++ b/test/general_assistant/run_15/summary.md @@ -0,0 +1,47 @@ +# run_15（上下文：编排超时兜底修复回归） + +- 类型：编排型（HTTP/2 vs HTTP/3 对比，「对比」命中编排信号词） +- 目的：验证「编排 150s 硬截止兜底」在 ctx 贯穿 + agent 轮次 ctx 检查 + executeSubTasks wall-clock 截止后真正生效 +- 结果：✅ **HTTP 200，150.0s 收敛**（此前同用例 run_14 为 210s 无限挂起，curl 200s 0 字节） +- 时间：2026-09-25 21:30:22 → 21:32:52 + +## 修复内容（本回归所验证） +1. `llm.go`：所有 LLM 调用（Generate/GenerateFull/GenerateStream/xxxFallback/Embed）加 `context.Context` 参数，`post` 用 `http.NewRequestWithContext`，使上层 ctx（编排 150s 兜底）真正能取消进行中的 HTTP 请求。 +2. `agent.go RunWithUsage`：每轮 tool_calls 前检查 `ctx.Err()`，ctx 取消立即退出，避免慢 worker 靠单次已发起成功的 HTTP 响应续命拖死 `wg.Wait()`。 +3. `orchestrate.go executeSubTasks`：分批 worker 的 `wg.Wait()` 改为与 `ctx.Done()` 竞争（select），到点不等最慢 worker，**150s 硬截止返回当前已完成产物**。 + +## 效果对照 +| 维度 | 修复前（run_14） | 修复后（run_15） | +|---|---|---| +| 请求收敛 | 210s 无限挂起，curl 200s 0 字节 | ✅ 150s HTTP 200 返回 | +| 后续请求 | 被阻塞（run_14 曾连带超时） | ✅ 不阻塞 | +| ctx 传导 | 失效 | ✅ ai_call_log 出现 `context deadline exceeded` 的快速失败(0ms)| +| 产物 | - | 超时兜底返回「已按子任务完成，但结果为空」+ 部分子任务标题 | + +## 多策略修复后 → 成功（2026-09-25 22:02） +对「worker 空回复 / tool_calls 死循环」叠加三重策略后重跑同用例（request 见 `request.json`，结果存 `response_success.json`）： + +| 指标 | 结果 | +|---|---| +| 收敛时长 | ✅ **94s**（无需 150s 兜底，正常完成） | +| 产物体量 | ✅ 约 19KB 深度对比正文（含核心判断/共同点/各自问题/RTT/传输效率/选型/来源引用） | +| 编排完整性 | ✅ plan(5子任务)→worker 执行→merge→审核 worker 全部跑通 | +| ai_call_log | 4 个 worker 1.4-2.1s 极快产出（无工具收敛路径）+ 2 个 worker 21-23s + 主回复 94s | + +### 三重策略明细（`internal/ai/agent.go` + `orchestrate.go`） +1. **roundWithEmptyRecovery**：单轮「空响应」→ 带工具重试一次 → 仍空降级「无工具纯文本」重试，兼容「带工具即空、纯文本正常」的路由。 +2. **tool 死循环收敛**：`RunWithUsage` 统计连续「只发工具调用、无结论文本」轮数，≥3 轮即中断，用无工具纯文本基于已回填的搜索结果重生成结论——直接掐断模型反复搜索不下结论的死循环。 +3. **worker 级兜底**：`executeSubTasks.runOne` 在 agent 失败/空时，用无工具 `GenerateWithFallback` 再生成一次，保证每个 worker 至少有可拼接内容。 + +## 遗留问题（非本次修复范围） +- 部分子任务产物仍含模型原样输出的 `｜tool｜` 转义残留（个别 worker 未完全收敛时把工具调用文本化），但最终 merge 正文干净，不影响主交付。 + +## 回归确认（修改未误伤其它路径） +| 用例 | 路径 | 结果 | +|---|---|---| +| run_03（周末闲聊） | direct_answer | ✅ HTTP 200，4.2s，内容完整（纯文本直答，无产物） | +| run_12（2026 诺贝尔奖联网查） | single_search / orchestrated | ✅ HTTP 收敛返回（ai_call_log 记录 123s success；curl 90s 断开属本端上限，服务端实际 123s 完成，不挂死） | + +## 下一步建议 +- 单考 worker 空回复：在 `RunWithUsage` 或 worker 侧对「模型最终回复为空」做一次退避重试；或对不兼容 tool_calls 的路由降级为无工具生成。 +- 已确认修改未误伤 direct_answer / single_search 路径；剩 worker 空回复与单问调用偏慢，根因是当前路由 `deepseek-v4-flash` 对带 web_search 工具的多轮 tool_calls 支持不佳，属独立问题待商定。 \ No newline at end of file diff --git a/test/general_assistant/run_16/request.json b/test/general_assistant/run_16/request.json new file mode 100644 index 0000000..09b4405 --- /dev/null +++ b/test/general_assistant/run_16/request.json @@ -0,0 +1 @@ +{"message": "你好，简单介绍一下你自己，以及你能帮我做哪些事情？","specialist_key":"general-assistant","mode":"chat","stream":false} \ No newline at end of file diff --git a/test/general_assistant/run_16/response.json b/test/general_assistant/run_16/response.json new file mode 100644 index 0000000..d511c41 --- /dev/null +++ b/test/general_assistant/run_16/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"你好！我是一个 AI 通用助手，可以帮你处理各种文字和知识类任务。\n\n我能做的事情包括：\n\n- **问答与解释**：解释概念、查资料、梳理思路\n- **写作与润色**：写文章、邮件、文案、总结、改写\n- **翻译**：中英互译及多语言翻译\n- **学习辅导**：讲题、复习、制定学习计划\n- **编程帮助**：写代码、调试、解释代码、给方案\n- **信息整理**：总结长文、提炼要点、做表格/清单\n- **联网检索**：需要实时信息时，我可以检索并标注来源，不编造数据\n\n有具体问题直接发给我就行。","timestamp":"2026-09-25 22:05:32","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_16/summary.md b/test/general_assistant/run_16/summary.md new file mode 100644 index 0000000..132929b --- /dev/null +++ b/test/general_assistant/run_16/summary.md @@ -0,0 +1,15 @@ +# run_16（直答路径回归） + +- 用例：`message="你好，简单介绍一下你自己，以及你能帮我做哪些事情？"` +- 意图：direct_answer（身份/能力问答，无联网、无编排信号） +- 目的：验证 ctx 贯穿 + 西南 Ensemble worker 优化后，直答路径无回归 +- 结果：✅ **HTTP 200，3.6s** 返回，`is_plan=false`，纯文本结构化回答 +- 时间：2026-09-25 22:05:28 + +## 产出观测 +- 无编排产物（直接 `data.message.content` 文本）； +- 回答列出了能力矩阵（问答/写作/翻译/辅导/编程/整理/联网检索）； +- 直答路径不受通用助手编排器改造影响。 + +## 结论 +直答单轮路径稳定，未受本次 ctx 贯穿与收敛优化影响。 \ No newline at end of file diff --git a/test/general_assistant/run_17/request.json b/test/general_assistant/run_17/request.json new file mode 100644 index 0000000..a97d115 --- /dev/null +++ b/test/general_assistant/run_17/request.json @@ -0,0 +1 @@ +{"message": "帮我联网查一下：2026年9月，苹果最新发布的那款 iPhone 的起售价是多少人民币？","specialist_key":"general-assistant","mode":"chat","stream":false} \ No newline at end of file diff --git a/test/general_assistant/run_17/response.json b/test/general_assistant/run_17/response.json new file mode 100644 index 0000000..dba8dde --- /dev/null +++ b/test/general_assistant/run_17/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"**结论：截至我检索到的最新公开信息，2026 年 9 月的苹果秋季发布会尚未举行，也还没有官方公布的国行起售价。**所以这个问题目前**没有可核实的确定答案**，我不编造数字。\n\n补充几点可核实的信息：\n\n**1. 最近一次 9 月发布（2025 年）的实际情况**\n- 苹果于 2025 年 9 月发布 iPhone 17 系列，**国行起售价 5999 元**（256GB 起步，6.3 英寸 120Hz 屏）。\n- 来源：腾讯新闻、新浪等多家媒体对 2025 年 9 月发布会的报道（如「苹果发布 iPhone 17 搭载 A19 芯片，国行版起售价为 5999 元」）。\n\n**2. 关于 2026 年的情况（均为传闻，非官方）**\n- 目前网上流传的多是「前瞻/传闻」类文章，例如「九月苹果新品前瞻：iPhone 万元起步」「2026 苹果新品全家桶集体破万」，以及「苹果首款折叠屏 iPhone 或于 2026 年秋季亮相、起售价超 2000 美元」等说法。\n- 这些**属于媒体预测和爆料，不是官方定价**，不同来源数字互相矛盾（有的说涨价、有的说持平），不能当作事实引用。\n\n**建议**\n- 如果你想了解的是**已确定的机型价格**，请以 Apple 中国大陆官网「购买 iPhone」页面的实时标价为准。\n- 如果你确实在关注 2026 年 9 月的新品，建议等发布会（通常为每年 9 月）结束、苹果官网更新定价后再核。\n\n需要的话，我可以帮你**重新联网**查一下苹果官网当前在售机型的最新国行价格，或关注某个具体型号（如 iPhone 17 Pro / Pro Max）的售价。","timestamp":"2026-09-25 22:06:46","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_17/summary.md b/test/general_assistant/run_17/summary.md new file mode 100644 index 0000000..d2b187e --- /dev/null +++ b/test/general_assistant/run_17/summary.md @@ -0,0 +1,16 @@ +# run_17（单问联网路径回归） + +- 用例：`message="帮我联网查一下：2026年9月，苹果最新发布的那款 iPhone 的起售价是多少人民币？"` +- 意图：single_search（实时单点事实 → web_search 工具 → SerpApi 等引擎） +- 目的：验证联网单问在多重策略（roundWithEmptyRecovery + tool 死循环收敛）下诚实作答 +- 结果：✅ **HTTP 200，63.6s** 返回，`is_plan=false` +- 时间：2026-09-25 22:05:42 + +## 产出观测 +- **诚实性达标**：明确指出「2026 年 9 月发布会尚未举行、无官方国行定价」，不编造数字； +- 提供可核实的**历史事实**（2025 年 9 月 iPhone 17 国行起售价 5999 元，并标注来源）； +- **区分官方事实与媒体传闻**（提及折叠屏爆料属于预测、相互矛盾，不作事实引用）； +- 结尾给出复核建议（以 Apple 官网实时标价为准），并主动提出可再次联网查询具体型号。 + +## 结论 +联网单问路径在 SerpApi 多引擎 + text_gen worker 收敛优化后稳定，保持「搜索诚实性」项目价值观。 \ No newline at end of file diff --git a/test/general_assistant/run_18/request.json b/test/general_assistant/run_18/request.json new file mode 100644 index 0000000..c8d9b7c --- /dev/null +++ b/test/general_assistant/run_18/request.json @@ -0,0 +1 @@ +{"message": "请写一份关于\"人形机器人产业链上中下游\"的分析报告，重点包括上游核心零部件、中游整机制造、下游应用场景，并对比国内外主要玩家。","specialist_key":"general-assistant","mode":"chat","stream":false} \ No newline at end of file diff --git a/test/general_assistant/run_18/response.json b/test/general_assistant/run_18/response.json new file mode 100644 index 0000000..eb09504 --- /dev/null +++ b/test/general_assistant/run_18/response.json @@ -0,0 +1 @@ +{"code":0,"data":{"message":{"role":"assistant","content":"## 制定报告框架与关键问题清单\n\n以下为规划稿。作为“规划者”，我先锁定报告框架、关键问题与执行拆解；后续撰写正文时可按此推进，避免返工。\n\n## 一、报告定位与边界\n\n- **研究对象**：通用人形机器人，兼顾双足与轮式/轮足形态。\n- **产业链范围**：上游核心零部件与算力软件、中游整机制造与具身智能系统、下游应用场景与运营服务。\n- **对比地域**：中国、美国、欧洲、日本、韩国。\n- **时间口径**：现状以近 3 年为主，市场预测延伸至 2030 年。\n- **输出目标**：形成“产业链图谱 + 成本/技术/玩家对比 + 场景成熟度 + 趋势风险”的分析报告。\n\n## 二、报告框架\n\n1. **摘要与核心结论**\n - 产业链关键判断、国内外差距、投资/产业机会。\n\n2. **产业链总览与界定**\n - 上中下游划分、价值分布、技术架构、商业化阶段。\n\n3. **上游：核心零部件**\n - 成本结构与价值量占比\n - 减速器、伺服电机、控制器、传感器、丝杠、编码器、执行器、芯片/算力、电池/热管理\n - 技术壁垒、国产化率、卡脖子环节、降本路径、代表供应商\n\n4. **中游：整机制造**\n - 技术路线：电驱/液压、双足/轮式、端到端/分层控制\n - 本体平台、运动控制、具身智能大模型\n - 量产能力、BOM 成本、供应链、商业模式\n\n5. **下游：应用场景**\n - 工业制造、物流仓储、商业服务、家庭服务、医疗康复、特种作业、教育科研\n - 场景成熟度、ROI、付费意愿、规模化瓶颈\n\n6. **国内外主要玩家对比**\n - 海外：Tesla、Figure、1X、Agility、Boston Dynamics、Apptronik 等\n - 国内：优必选、宇树、智元、傅利叶、小鹏、小米、达闼、开普勒、星动纪元等\n - 对比维度：技术路线、成本、量产进度、客户/订单、软件生态、融资与股东\n\n7. **市场空间、趋势与风险**\n - 市场规模预测、驱动因素、技术拐点、政策环境\n - 风险：技术路线变化、商业化不及预期、估值泡沫、安全伦理\n\n8. **结论与建议**\n - 产业端、投资端、政策端建议。\n\n9. **附录**\n - 数据来源、术语表、公司清单、时间线。\n\n## 三、关键问题清单\n\n| 类别 | 关键问题 | 对应章节 |\n|---|---|---|\n| 上游 | 人形机器人 BOM 中，减速器、电机、丝杠、传感器、控制器各占多少？ | 上游 |\n| 上游 | 哪些环节国产化率低、壁垒高？降本路径是什么？ | 上游 |\n| 中游 | 主流技术路线有哪些？电驱是否成为共识？ | 中游 |\n| 中游 | 头部玩家是否具备量产能力？BOM 成本降到多少？ | 中游 |\n| 中游 | 具身智能大模型在整机中扮演什么角色？ | 中游 |\n| 下游\n\n\u003cdetails\u003e\u003csummary\u003e📋 本次由通用编排拆分执行\u003c/summary\u003e\n\n##### 制定报告框架与关键问题清单\n\n以下为规划稿。作为“规划者”，我先锁定报告框架、关键问题与执行拆解；后续撰写正文时可按此推进，避免返工。\n\n## 一、报告定位与边界\n\n- **研究对象**：通用人形机器人，兼顾双足与轮式/轮足形态。\n- **产业链范围**：上游核心零部件与算力软件、中游整机制造与具身智能系统、下游应用场景与运营服务。\n- **对比地域**：中国、美国、欧洲、日本、韩国。\n- **时间口径**：现状以近 3 年为主，市场预测延伸至 2030 年。\n- **输出目标**：形成“产业链图谱 + 成本/技术/玩家对比 + 场景成熟度 + 趋势风险”的分析报告。\n\n## 二、报告框架\n\n1. **摘要与核心结论**\n - 产业链关键判断、国内外差距、投资/产业机会。\n\n2. **产业链总览与界定**\n - 上中下游划分、价值分布、技术架构、商业化阶段。\n\n3. **上游：核心零部件**\n - 成本结构与价值量占比\n - 减速器、伺服电机、控制器、传感器、丝杠、编码器、执行器、芯片/算力、电池/热管理\n - 技术壁垒、国产化率、卡脖子环节、降本路径、代表供应商\n\n4. **中游：整机制造**\n - 技术路线：电驱/液压、双足/轮式、端到端/分层控制\n - 本体平台、运动控制、具身智能大模型\n - 量产能力、BOM 成本、供应链、商业模式\n\n5. **下游：应用场景**\n - 工业制造、物流仓储、商业服务、家庭服务、医疗康复、特种作业、教育科研\n - 场景成熟度、ROI、付费意愿、规模化瓶颈\n\n6. **国内外主要玩家对比**\n - 海外：Tesla、Figure、1X、Agility、Boston Dynamics、Apptronik 等\n - 国内：优必选、宇树、智元、傅利叶、小鹏、小米、达闼、开普勒、星动纪元等\n - 对比维度：技术路线、成本、量产进度、客户/订单、软件生态、融资与股东\n\n7. **市场空间、趋势与风险**\n - 市场规模预测、驱动因素、技术拐点、政策环境\n - 风险：技术路线变化、商业化不及预期、估值泡沫、安全伦理\n\n8. **结论与建议**\n - 产业端、投资端、政策端建议。\n\n9. **附录**\n - 数据来源、术语表、公司清单、时间线。\n\n## 三、关键问题清单\n\n| 类别 | 关键问题 | 对应章节 |\n|---|---|---|\n| 上游 | 人形机器人 BOM 中，减速器、电机、丝杠、传感器、控制器各占多少？ | 上游 |\n| 上游 | 哪些环节国产化率低、壁垒高？降本路径是什么？ | 上游 |\n| 中游 | 主流技术路线有哪些？电驱是否成为共识？ | 中游 |\n| 中游 | 头部玩家是否具备量产能力？BOM 成本降到多少？ | 中游 |\n| 中游 | 具身智能大模型在整机中扮演什么角色？ | 中游 |\n| 下游\n\n##### \n\n（本子任务结果为空）\n\n##### \n\n（本子任务结果为空）\n\n##### \n\n（本子任务结果为空）\n\n##### \n\n（本子任务结果为空）\n\n##### \n\n（本子任务结果为空）\n\n\u003c/details\u003e","timestamp":"2026-09-25 22:16:38","type":"text"},"is_plan":false,"is_expert":false,"stream":false},"error":null,"message":"success"} \ No newline at end of file diff --git a/test/general_assistant/run_18/summary.md b/test/general_assistant/run_18/summary.md new file mode 100644 index 0000000..4f69138 --- /dev/null +++ b/test/general_assistant/run_18/summary.md @@ -0,0 +1,32 @@ +# run_18（编排路径 · 重度搜索型 · 预算放宽后） + +- 用例：`message="请写一份关于\"人形机器人产业链上中下游\"的分析报告，重点包括上游核心零部件、中游整机制造、下游应用场景，并对比国内外主要玩家。"` +- 意图：**orchestrated**（产业链/上中下游/对比 → 强编排信号） +- 跨预算验证：150s → 240s（`overallTimeout` 放宽），并加宽 worker 死循环收敛阈值（`toolRounds >= 5`） +- 结果：⚠️ **HTTP 200，240.0s**（踩新的 240s 兜底边界返回），6.4KB +- 时间：2026-09-25 22:12:38 + +## 两次对比 +| 项 | 预算150s（run_18首次） | 预算240s（本次） | +|---|---|---| +| 收敛 | 150s 兜底 | 240s 兜底 | +| 产物 | S1 框架 + 4.6KB | S1 框架（更完整、含玩家清单/章节大纲）+ 6.4KB | +| worker 报告 | S2-S6 空 | S2-S6 仍空 | + +## ai_call_log（关键诊断） +- 338：planSubTasks 拆解 19.3s success； +- 339：主编排 240.0s； +- **⚠️ worker 一条 `text_gen` 记录都没有**——说明 5 个 worker 的 `agent.Run` 均未跑完返回（runOne 未落日志），worker 卡在首轮/多轮 `generateWithTools` 的 HTTP 等待中，直到编排 ctx 截止。 + +## 根因判断（重视） +路由 `chat_route_lmuai_deepseek_v4_flash` 的 `timeout_seconds: 90`。run_18 的 worker prompt 属「长输入、报告型」，3 个 worker 并发发起时 LLM 服务端响应极慢/挂起，单次调用逼近 90s 仍无返回，多轮叠加远超编排预算 → worker 无法在预算内写出报告。 +- 这不是「编排空回复/死循环」逻辑问题（对比 run_14 HTTP 对比 94s 正常完成、run_16/17 优秀）；而是 **LLM 服务端对「长 prompt + 并发报告型」请求的响应能力/排队**导致单次调用卡满 timeout。 + +## 编排侧已尽力的优化（本次已改） +1. `overallTimeout` 150s → **240s**，给重度搜索型 worker 更多写稿预算； +2. `RunWithUsage` tool 死循环收敛由「仅纯工具轮统计」放宽为「工具轮数 >= 5 即收敛」，并在历史含搜索素材时用无工具纯文本重生成结论。 + +## 待决策（超出「修」范围） +- **调用级超时**：给编排 worker 的每次 `generateWithTools` 设一个更短的调用超时（如 30s），使慢调用快速失败、跳过该类 worker，避免单个慢 LLM 拖死整个编排； +- **路由/并发**：评估为编排 worker 换一条对长 prompt 响应更稳的路由，或降低 `maxConcurrent`、减少长 prompt 并发排队； +- **预算再放宽**：若接受更长等待，可把编排预算提到 300s+，但需权衡用户体验。 \ No newline at end of file