31 Commits
Author SHA1 Message Date
kicer 62e5902834 版本号升到 2.5.0:收口语音输入这一批改动
- 语音:长说不带停顿按能量最低点软切、转写并行发送并限流 3
- 语音:识别提示改动态进度(段数 + 秒数)
- 鸿蒙 APK 长按时按住区不再随遮罩隐藏
- 公网临时链接:图片改 inline 返回,sw.js 放行 /p/ 二进制直链
- package.json 与 routes/system.js 的 VERSION 同步为 2.5.0(发版约定)
2026-11-11 10:16:02 +08:00
kicer b4755ac98b 转写请求改并行发送并限流:最多 3 个在飞,名额谁落定谁交出去
串行上传(一段没回来不发下一段)让长语音的松手等待等于各段耗时之和,
上游一慢就整体排队。改成并行,同时限制并发数避免压垮上游:

- 并发上限 ASR_MAX_CONCURRENCY = 3(页面侧常量,改完刷新即生效)
- 名额制而不是「第 i 段等第 i-N 段」:后者的伪阻塞在于最慢那段会卡住
  本可以发的后续段(只飞 1 个时,排队的第 7 段也要一直等)
- 名额在成功/失败后都归还,单段失败不吞名额
- 取消/重录:被唤醒的排队段看到 gen 变了只还名额、不真发,计数不漏
- 结果按 textParts[idx] 落位:并行返回是乱序的,拼接仍按说话顺序
- 收口改成 Promise.all(inflight),逐个兜 catch,避免单段异常让整批失败、
  只能等 60s 超时把已识别内容全丢掉
2026-11-11 09:25:07 +08:00
kicer df1b1787e9 长说不带停顿时按能量最低点软切:6s 先发一段,不再憋到松手
一口气说不停顿是语音输入最慢的路径:没有 0.5s 停顿就一段都发不出去,
只能等松手整段上传。改成累计语音到 6s 就在低能量处分段发出:

- 只在尾部 3s 窗口里找切点:太靠前会把很久以前的低点当作刀口
- 切点按分片边界取:每片已有峰值 dB(与 segChunks 平行的 segLens/segDbs),
  取最小者下刀,尾部静音是 -Infinity 会天然胜出 → 落在气口上
- 切完剩下的留在缓冲继续累积,不丢采样、不重复;真静音切点仍优先
- 25s 硬切保留作兜底(软切一直不成立时才会走到)
- silLen 在切后被钳到剩余长度:切点落在尾巴静音里时不能超过段长

代价:刀口是分片粒度(APK 约 100ms),可能劈在字中间,所以段更短;
调大 VAD_SOFT_CUT_SEC 可让切点更可能落在真实气口。
2026-11-11 09:11:32 +08:00
kicer 03cf4b86e4 语音松手后的识别提示改为动态进度:段数 + 秒数
「正在识别…」是静态文案,上游慢时看着像卡死。改成按真实进度变化:

- 多段:正在识别 2/3 段 · 5s(每完成一段分子加一)
- 单段:正在识别… 5s(0/1 看着也像没进展,只留秒数)
- 秒数 1s 一跳,从松手(尾巴已入队)才开始算,说话过程不计时
- 失败也算走完一段,进度不会停在半路
- resetUI 统一 clearInterval:取消/超时/完成/切模式都不会漏
2026-11-11 08:55:40 +08:00
kicer 7641f5c0a7 鸿蒙长按时按住区不再随遮罩隐藏:避免指针捕获被释放而误判“说话太短”
按下后 body.voice-active 会把输入卡所有子项设成 visibility:hidden,#voice-hold 也在内。
它是 pointerdown 里 setPointerCapture 的持有者,鸿蒙 ArkWeb 在元素不可见时会释放捕获并
补一个 pointercancel,页面把它当成“松手”→ 按住不到 500ms → 丢弃并提示“说话时间太短”,
表现就是长按立刻失效、按钮像丢了状态。

- 只把 #voice-hold 排除在隐藏规则外(遮罩覆盖这一段本来就不透明,视觉无差别)
- 其余元素(输入框、操作栏等)的隐藏行为保持不变
- 未改 JS:录音状态机、取消手势阈值、识别流程都不动

真机确认有效后再看是否需要处理 setPointerCapture 与长按序列打断。
2026-11-11 08:48:14 +08:00
kicer ae8ed6bb25 Service Worker 放行 /p/ 二进制直链:图片外链不再被当 HTML 文本重建
图片外链改成 inline 后点开变成坏图:sw.js 的导航分支默认把同源导航当 HTML,
resp.text() 把整张 PNG 解成替换字符再 new Response 回去,浏览器只看到空白;
它“残缺重试一次”的行为还让日志里每点一次出现两条 public-file 取用。

- 跳过名单补 /p/:公网短链是二进制 + 带 TTL 的 bearer 能力,不该接管也不该缓存
- 导航分支加硬约束:Content-Type 不是 text/html 就原样透传,不再按文本重建
- 该兜底不依赖路径枚举,其它同源二进制直链导航同样受保护

sw.js 不在预缓存清单里,无需升 CACHE_VERSION;刷新页面即可生效。
2026-11-11 07:59:32 +08:00
kicer 3806071698 公网临时链接图片改 inline 返回:点开直接看图,不再一律下载
/p/<id> 原先不分类型一律 attachment(为安卓封装壳的 DownloadManager 兜底),图片外链点开只会进下载器;read_file 读图也走这个端点,用户点开来只能下载、看不到图。

- download-send.js 抽出 contentDisposition(type),新增 inlineImageType / sendInlineImage
- 图片显式给 image/* + X-Content-Type-Options: nosniff + inline;缓存仍 no-store(/p/ 是短命 bearer 链)
- 按扩展名判定:png/jpg/jpeg/webp/gif/bmp/tif/tiff/avif/ico/svg,不读文件头做嗅探
- SVG 额外加 CSP: sandbox(匿名同源端点,直接打开不能执行内嵌脚本;img 引用不受影响)
- inline 走 dotfiles:allow,保证 read_file 的 .imgcache/ 压缩产物能取到
- 其余类型(PDF/Office/zip/HTML 等)保持 attachment,下载语义与安卓兜底不变
- README「公网临时链接」补响应头说明
2026-11-11 07:31:02 +08:00
kicer b0a8283406 占位裁剪新增 turns(真人回合)条件:回合内不裁,跨回合才裁
rounds 数的是 assistant 行,长回合里会把模型还要用的回执裁掉——实测有回合把同一文件
分段重读了 24 次(每次都在 rounds:2 生效的那一轮回来重读)。

- 规则新增 turns 字段:其后又来了几条真人消息(role=user 且 type 为空,注入行不算)
- rounds 与 turns 同时满足才裁(AND);两者都写 0 才算规则关闭
- 默认:fetch / read_file / web_search 用 rounds:2 + turns:1(回合内绝不裁),
  write_file 参数侧保持 rounds:1 + turns:0(只是写盘快照,照旧早裁)
- config.example.yml 补了带时间线的例子与「rounds=后面 AI 又说了几句话 /
  turns=后面又来了几条真人消息」的注释;AGENTS.md 与 tool-design.md 同步
- 启动日志改为打印 轮≥N,回合≥M,便于核对生效规则
2026-11-03 08:06:43 +08:00
kicer cc53c117e8 web_search snippet 默认不截断,改由调用方传 maxSnippetLength
之前自定义上游与 Exa 都写死 500 字,换上游就等于悄悄丢内容。现在:

- 默认原样返回整段 snippet(只压平空白)
- 传 maxSnippetLength: N 才截断到 N 字并补省略号;0 / 负数 / 非数字一律视为不传
- 三路上游(自定义 /search、Parallel、Exa)统一按同一参数处理
- 上游报错时的响应片段仍固定截 200 字(那是诊断信息,不参与该参数)
2026-11-02 20:55:55 +08:00
kicer 10877c9723 web_search 支持自建 /search 上游:上游参数逐请求由 header 带入
与 image_task / asr 同构:容器不存密钥,配置只写在 config.yml 的 mcp_servers[].headers。

- 新增 X-Web-Search-Base-Url(拼 /search)与可选 Authorization(裸 key 自动补 Bearer);
  配了地址就以它为准,失败直接报错,不静默退回免费后端
- 没配地址时行为不变:Parallel 优先,失败自动退 Exa(降级从前端 provider 参数收回服务端)
- 工具 schema 去掉 provider 参数(模型不该决定走哪家上游),只留 query / numResults
- 响应统一归一化:丢弃无 url 条目,snippet 压平并截断 500 字,published_at 映射为 publishedAt
- server.js 把 req.headers 传进协议层;stdio 模式无 header,只能用免费后端
- 设置页预设补两条可选字段(settings.js 无需改动,纯数据驱动)
2026-11-02 20:28:10 +08:00
kicer 509d63a99b 重负载占位裁剪改为配置驱动:agent.trim.rules 统一策略,默认覆盖 web_search 2026-11-02 19:46:16 +08:00
kicer dbd67ec273 PDF 预览改用 inline 直连,支持 Range 与 304 缓存
新增 /files/inline;桌面面板与窄窗口统一用 iframe 直连,不再 fetch 整包转 blob;下载接口保持 attachment/no-store 不变。
2026-10-26 11:16:26 +08:00
kicer 774d09a07a 图片预览改为服务端派生 WebP 直连,修复大图加载慢
新增 /files/preview:按宽度生成 WebP 并落盘缓存,inline + ETag,原图仅下载时取;前端图片与全屏查看器改用派生直链,不再 fetch 整包转 blob。
2026-10-26 11:07:19 +08:00
kicer 5b005cc042 微信中途消息改走干预队列;工具失败不再推给微信
微信与渠道普通消息改用 enqueueMessage(mode:'interject'):回合中插话在当前工具跑完后生效,不再把 user 行插进 tool 批次中间;interject 入队插到队列 messages 之前,保证边界检查能命中队首。

微信端不再下发任何工具失败(多数是 AI 参数用错,模型下一轮自行纠正):去掉即时「工具调用失败」行与尾段失败清单,台账只保留中性计数与「N 次因你介入未执行」。
2026-10-26 10:41:28 +08:00
kicer 7a34f612e7 修复沉浸式模式下的显示问题 2026-10-25 23:08:05 +08:00
kicer 2e220d0a22 运行中发送改为待发送条幅:排队 / 干预 / 立即发送
- 运行中点发送不再立即插话,改为进服务端队列(engine.pendings,内存态),
  输入框上方一行条幅:默认本轮结束后发出,队首可「干预」(当前工具跑完就插话)
  或「立即发送」(终止本轮工具调用并立刻发)。队列在服务端,关页面/重连不丢。
- 新增 closeToolBatch():给未闭合批次里缺回执的 tool_call 补合成回执,
  取消/干预/finalize 兜底三处调用;顺带修掉「中途停止后库里留孤儿 tool_calls、
  下一轮请求被上游拒收」的存量 bug。
- llm.buildMessages 加读侧配对过滤(pairedByAssistant / emittedCallIds):
  只下发本批确有回执的调用,孤儿回执也不下发,兜历史脏数据,DB/UI 不动。
- HTTP:POST /messages 支持 delivery:'queue';新增 POST/DELETE /pending/:qid;
  会话详情与 status 事件带 pending。
- 前端:条幅渲染与动作、pending_added/pending_removed/user_message 事件、
  硬中断后工具卡标「已取消」;发送始终交服务端判定,避免过期状态把 user 行
  插进工具批次中间。
- 文档:app/AGENTS.md 补生命周期、SSE 事件清单与待投递队列语义。
2026-10-25 22:44:02 +08:00
kicer 0ac161c579 配置写回:带冒号的值加引号、参数表写单行
- 写回的值含冒号(纯 URL 除外)时强制双引号:global:hy-image-3.5 这类模型 id / header 值
  裸写虽能被本项目的 yaml 解析,换个解析器或落进 flow 集合就容易被当成分隔符
- extra_params / thinking_params 用 flow 风格写单行({k: v}),不再展开成多层块
- 追加整项时连同父数组一起转 block:flow 空数组里塞 block 映射会输出成残句
  (platforms: 后直接跟键,序列丢失)
- 只作用于 PATCH /api/config 写入的节点,文件其它部分与注释原样保留
2026-10-25 22:12:37 +08:00
kicer 81e0a44671 MCP 页去掉「刷新连接状态」按钮
- 状态本来就是进页时的快照,配置改动后都要重启才生效,手动刷新意义不大
- 顺带删掉因此无人使用的 mcpUI.refresh 导出
2026-10-25 21:33:26 +08:00
kicer 560bd9afd4 模型平台编辑器:预设平台 + 模型高级参数
- 新增平台时给预设 chips(智谱 / DeepSeek / 通义 / 自定义):点选填好 url 与平台名,
  模型 id 用预设的 model_hint 作 placeholder,新模型行自动带上 model_defaults
  (extra_params / thinking_params / reasoning_ack_field)
- 切换预设只覆盖「空 / 上一个预设缺省」的行,手填参数与已有模型不动;
  选「自定义」清空平台字段与 Key/模型行,回到空白平台
- 每个模型卡加「高级」:display_name、profile(下拉取 model_profiles 的 key)、
  extra_params / thinking_params(JSON 文本框)、reasoning_ack_field
- 保存继续走细粒度 path,只推真正变化的叶子;清空写 op:delete,绝不整体替换模型对象;
  JSON 先前端校验,非法直接提示不发请求
- 余额类型不再让用户填:用预设新增平台时隐式按预设落 type(平台名与预设一致则不写)
- 移动端模型弹窗同步放宽;去掉弹窗底部「仅写入配置…」提示
- presets:智谱 label 精简为「智谱」
2026-10-25 16:06:57 +08:00
kicer ce7a62dcba MCP 卡片显示运行态连接状态
- mcp.js 留痕每个服务的发现结果(key = name|url|mode → ok/tools/hidden/error/disabled),
  重试阶梯重跑 loadServer 时状态自动更新;失败原因补上 err.cause,
  卡片 title 能看到 fetch failed(ECONNREFUSED)这类真因
- 新增 GET /api/config/mcp-status(随 /api/config 继承管理员门禁)
- 卡片:「已配置」转中性灰,颜色只表达连接——已连接(绿,带工具数)/
  未连接(红,带原因)/ 待重启(黄,运行态查不到);mode=disable 不显示连接标记
- 状态接口自身失败时整块不显示,避免把全部卡片误报成「待重启」
- 页头加「刷新连接状态」:状态是页面快照,重试阶梯成功后需手动刷
- 预设字段的 hint 右对齐
2026-10-25 15:47:12 +08:00
kicer d0e6a981a6 MCP 设置页改成内置服务引导:预设卡片 + 字段表单
- header 掩码只遮密钥类(名字 Authorization/*token*/*key*,或值 Bearer…/sk-…),
  base-url / model 明文回显——引导表单得看得见当前值才能改
- restoreMcpHeaders 改为按键名还原(原按出现顺序,只遮部分 header 后会张冠李戴);
  补上单个 header 叶子写入的还原:原来把 ***** 直接写进 config.yml
- MCP 页分「内置服务」(4 张预设卡:未配置→添加、已配置→编辑)与「其它服务」
- 弹窗预设模式:name/url 只读、mode 收敛为「预设值 / disable」、字段按 presets.fields
  生成(左标签 + 右输入),隐藏 header 区;配置里历史多余的 header 保存时仍原样带上
- 超时 / 工具暴露改成左标签右控件的单行排版,ms 作输入框内后缀
- 移动端 MCP 弹窗放宽到 calc(100% - 24px),内边距收紧
2026-10-25 15:22:48 +08:00
kicer 1ea29c0448 设置页配置预设:平台与同栈 MCP 的固定契约收进 presets.json
- 新增 app/server/presets.json:3 个模型平台(url/type/model_defaults)与
  4 个内置 MCP(url/mode/header 字段,含 placeholder/hint),不含任何密钥
- routes/config.js 新增 GET /api/config/presets(随 /api/config 挂载,仅管理员)
- 启动时校验一次:key/url/type 必填、key 不重复、mode 枚举、fields[].header 必填;
  失败只 warn 并降级为空预设,不影响启动
2026-10-25 12:20:13 +08:00
kicer d6b949969f image_task 图生图改走 /images/edits:下载参考图后 multipart 上传
- 文生图仍走 /images/generations,图生图改走 /images/edits(原先错发到 generations 的 images 数组)
- X-Image-Task-Base-Url 统一剥离末尾 /images/generations 或 /images/edits,端点由模式决定
- 参考图先下载成字节再以 multipart 上传:60s 独立超时、20MB 流式上限、校验 image/*
- 同步 README / mcp README / package.json 说明
2026-10-25 10:13:47 +08:00
kicer bdc2de7128 image_task 去掉智谱专用通道,统一按 OpenAI 兼容协议
- 三个 header 全部必填:Authorization / X-Image-Task-Base-Url / X-Image-Task-Model
- 删除 zhipu 别名、bigmodel.cn 主机判断与默认模型;地址必须是完整 http(s) URL,
  已给到 /images/generations 就直接用,否则自动补全
- 请求体统一为 { model, prompt, n: 1, response_format: "url" },传图时追加 images
- 任务摘要不再输出 provider;图生图不再按通道拒绝,能否编辑交给上游
- 同步 image_task README / package.json 描述 / 根 README 与 mcp/README 的示例
2026-10-25 09:13:32 +08:00
kicer b97b13095f 部署初始化收敛:init.sh 不再生成配置,只做 .env + 公网地址 + 初始 admin
- scripts/init.sh 重写:不再生成模型/MCP/用户配置;只维护 .env(幂等复用密钥、保留手改变量)、
  探测 PUBLIC_BASE_URL、config.yml 缺失时写入初始管理员(admin/admin)。已存在绝不改写;
  Docker 误建的空目录自动删除重建,非空目录报错退出;去掉 --env-only 参数
- config.js:config.yml 缺失/为空/被误建成目录都能正常启动(不再 EISDIR 崩);PATCH 在文件
  缺失时以空文档继续并自动创建;public_link 改为 config.yml 优先、PUBLIC_BASE_URL 兜底
- compose:ASR_URL 固定为 http://mcp_asr:3000;agent-core 注入 PUBLIC_BASE_URL;
  token 缺失提示改指 scripts/init.sh
- 删除 .env.example(与 init.sh/compose 重复),引用改指 README
- 移除仓库内所有 VIRTUAL_HOST/VIRTUAL_PORT/CERT_NAME 关联(特定部署的反代约定,不进仓库)
- 同步 README / AGENTS.md / config.example.yml / init_host.sh / wxbot / mcp 文档
2026-10-25 08:42:26 +08:00
kicer dca4e6be70 优化document-photo-to-pdf技能 2026-10-24 23:17:33 +08:00
kicer 58b9eaddd4 浏览器语音输入改为流式断句:ScriptProcessor 采 PCM 降采样到 16k,与套壳共用 pushChunk 流水线
- 浏览器不再用 MediaRecorder 整段录后上传,改为 AudioContext + ScriptProcessor 实时采 PCM
- 新增 downsampleTo16k():44.1k/48k 降采样到 16k,小数相位跨分片累计不漂移
- 抽出 pushChunk(),壳推的分片与浏览器采的分片汇到同一处做 VAD/切段/上传
- 电平统一用 PCM 峰值,删除 AnalyserNode;两条路收口都走 flushTail/waitFlush
- 新增 primeAudioCtx():iOS Safari 需在手势里创建并 resume AudioContext
- nativeStop():cancelVoice 缺失时退回 stopVoice,避免壳侧麦克风一直开着
- 同步 docs/voice-input.md
2026-10-24 20:21:33 +08:00
kicer b2b0f8d2b2 语音输入改为流式断句,服务端只做超长兜底切分
- 壳推 16k/单声道/16bit PCM 分片(onNativeVoiceChunk,~100ms 一片),
  页面自己判停顿(≥0.5s 静音)断句、逐段串行上传;松手只 flush 剩下的话,
  全部结果到齐后一次性写进输入框并自动发送
- 纯静音的尾巴不再上传(否则只会换来一次「没有可识别人声」)
- 删除 onNativeVoiceResult / onNativeVoiceAmp:声波改由页面用 PCM 峰值驱动
- 服务端不再逢停顿就切:≤25s 直接一次请求、不跑 silencedetect;
  >25s 才在距上限最后 6s 的窗口里挑停顿中点,挑不到硬切,段数 ≈ 时长/25
  (去掉 ASR_MAX_SEGMENTS 的 20 段退化分支)
- 上游 200 + 空 text 改判 400(这是「这段没人声」的正常结果,不再打堆栈)
- docs/voice-input.md 按新契约整篇重写(含 AudioRecord 参考骨架)
2026-10-24 20:11:25 +08:00
kicer f97eb566e3 语音按住说话的遮罩改为不透明底色
遮罩顶部伸进会话流 72px,原来只有一层 9% 蓝渐变、没有实底,底下的消息文字直接透上来,
「松手传送」看着就像半透明、也没把底部盖住。改成 --page 实底 + 上沿 20px 渐隐衔接,
提示文案由 --gray 加深到 #5f6672,取消态同步改为同样的实底 + 红调。
2026-10-24 19:37:26 +08:00
kicer 153a8768bf ASR_URL 改为可由 .env 覆盖(支持指向外网 mcp_asr)
- compose 用 ${ASR_URL-http://mcp_asr:3000}:不设则默认内网;显式写空值则关闭语音输入
  (用无冒号的 - 而非 :-,否则空值会被默认值兜掉,就没法关闭)
- .env.example 补注释示例
- README 环境变量表与 MCP 章节补充外网用法与注意事项(对端需接受三个 header、证书校验)
2026-10-24 18:56:06 +08:00
kicer ceccb3645f 语音识别上游参数改为随请求带入,init.sh 不再绑定平台
- mcp_asr 不再从容器 env 读 key/base_url/model,改为逐请求 header
  (Authorization / X-ASR-Base-Url / X-ASR-Model),容器不存任何平台密钥
- core 的 /api/asr 从 config.yml 的 mcp_servers[asr].headers 取值转发,
  /status 增加 reason(未接线时前端 console 直接打印原因)
- init.sh 只自动启用模型平台与 web_search;image_task / video_task / asr
  改为带默认 url 与 header 名的注释模板,删掉 ASR_API_* 输入与 BIGMODEL_KEY 复用
- docker-compose 去掉 mcp_asr 的三个上游 env
- 同步 README / AGENTS / app/config.example.yml / mcp 文档
2026-10-24 17:43:36 +08:00
57 changed files with 4428 additions and 1375 deletions
-25
View File
@@ -1,25 +0,0 @@
# .env.example — 仓库根 .env 模板(.env 已 gitignore,不会被提交)。
# 标准路径是跑 ./scripts/init.sh:自动生成下面全部密钥并幂等复用(重跑不掉登录态、不换 token)。
# 本文件仅作手动部署参考;手动生成 token:openssl rand -hex 32。
# 其余部署旋钮(EXECUTOR_URL、*_LOG_LEVEL、VIRTUAL_HOST 等)都在 docker-compose.yml 里改,不放这里。
# ---- 必填(compose 用 ${VAR:?} 检查,缺失则 docker compose up 直接报错)----
# core ↔ executor 调用鉴权(compose 注入两侧同值)
EXECUTOR_TOKEN=change-me-openssl-rand-hex-32
# core ↔ wxbot 微信接入服务 token(compose 注入两侧同值;未就位 = 微信入口整体静默关闭)
WXBOT_TOKEN=change-me-openssl-rand-hex-32
# 登录态签名密钥:init.sh 写进 config.yml 的 auth.secret 并在此复用;
AUTH_SECRET=change-me-openssl-rand-hex-32
# ---- 可选 ----
# agent-core 映射到宿主机的端口(默认 8090),改这里就不用动 docker-compose.yml
# AGENT_PORT=8090
# ---- 仅调试:临时把对应 MCP 服务映射到宿主机端口(默认注释掉;改完记得注释回去)----
# WEB_SEARCH_PORT=8081
# IMAGE_TASK_PORT=8082
# VIDEO_TASK_PORT=8083
+9 -6
View File
@@ -24,7 +24,7 @@
| `wxbot/` | 微信 iLink 协议调制解调器(多实例) | 独立容器 `agent-wxbot` | | `wxbot/` | 微信 iLink 协议调制解调器(多实例) | 独立容器 `agent-wxbot` |
| `mcp/` | 同栈 MCP 服务:`web_search` / `image_task` / `video_task` / `asr` | 四个容器,仅内网 | | `mcp/` | 同栈 MCP 服务:`web_search` / `image_task` / `video_task` / `asr` | 四个容器,仅内网 |
| `skills/` | 目录式技能(`SKILL.md` + `run.py`/`run.sh`) | 运行时挂载,`skills/deps` 为依赖层 | | `skills/` | 目录式技能(`SKILL.md` + `run.py`/`run.sh`) | 运行时挂载,`skills/deps` 为依赖层 |
| `scripts/` | `init.sh` 生成 `.env` + `config.yml`;`init_host.sh` 裸机初始化 | 幂等 | | `scripts/` | `init.sh` 生成 `.env` + 首次创建 `config.yml`(仅初始管理员);`init_host.sh` 裸机初始化 | 幂等,**不覆盖已有配置** |
| `docs/` | 专题文档:`tool-design.md`(工具接口规范)、`OFFICE.md` | — | | `docs/` | 专题文档:`tool-design.md`(工具接口规范)、`OFFICE.md` | — |
| `tasks/` | **运行时数据**:每个会话一个工作目录 | gitignore | | `tasks/` | **运行时数据**:每个会话一个工作目录 | gitignore |
| `data/` | **运行时数据**:SQLite `.agent.db`、`prompt.txt` 调试产物 | gitignore | | `data/` | **运行时数据**:SQLite `.agent.db`、`prompt.txt` 调试产物 | gitignore |
@@ -60,7 +60,7 @@ flowchart TD
| `agent-core` | 8090 | 宿主机映射,**唯一对外** | | `agent-core` | 8090 | 宿主机映射,**唯一对外** |
| `agent-executor` | 9000(exec)、3100(预览网关) | 仅 `expose`,内网 | | `agent-executor` | 9000(exec)、3100(预览网关) | 仅 `expose`,内网 |
| `agent-wxbot` | 8093 | 仅内网 | | `agent-wxbot` | 8093 | 仅内网 |
| `mcp_*` | 3000 | 仅内网;compose 里注释掉的 `ports` 仅供本机调试 | | `mcp_*` | 3000 | 仅内网 |
### 数据持久化(bind mount) ### 数据持久化(bind mount)
@@ -83,8 +83,10 @@ flowchart TD
### 环境变量(接线全靠根 `.env` + compose) ### 环境变量(接线全靠根 `.env` + compose)
`AGENT_CONFIG`、`PORT`、`EXECUTOR_URL`、`EXECUTOR_TOKEN`、`WXBOT_URL`、`WXBOT_TOKEN`、 `AGENT_CONFIG`、`PORT`、`EXECUTOR_URL`、`EXECUTOR_TOKEN`、`WXBOT_URL`、`WXBOT_TOKEN`、
`ASR_URL`、`ASR_API_KEY`、`VIRTUAL_HOST`、`PREVIEW_PROXIES`、`EXECUTOR_LOG_LEVEL`、`WXBOT_LOG_LEVEL`。 `PUBLIC_BASE_URL`、`ASR_URL`、`PREVIEW_PROXIES`、`EXECUTOR_LOG_LEVEL`、`WXBOT_LOG_LEVEL`、`ASR_LOG_LEVEL`。
密钥生成:`./scripts/init.sh`(幂等,重跑不掉登录态)。 密钥生成:`./scripts/init.sh`(幂等,重跑不掉登录态;**从不覆盖已有 config.yml**,只在其缺失时创建
最小骨架)。语音识别的上游 key/base/model 不在 env,
写在 `config.yml` 的 `mcp_servers[name=asr].headers`(容器不存平台密钥)。
## 三条主链路 ## 三条主链路
@@ -109,7 +111,7 @@ flowchart TD
## 全局约束(改之前先读) ## 全局约束(改之前先读)
1. **单实例、单进程内存态**。`engine.js` 的 `runs`/`titling`、`wechat.js` 的回合投递状态与实例缓存、 1. **单实例、单进程内存态**。`engine.js` 的 `runs`/`titling`/`pendings`(待投递消息队列)、`wechat.js` 的回合投递状态与实例缓存、
`publicFiles` 的短链表、`download-token` 的随机密钥都在进程内——重启即清空,多实例不共享。 `publicFiles` 的短链表、`download-token` 的随机密钥都在进程内——重启即清空,多实例不共享。
(微信投递游标 `last_msg_id` 例外,它是落库的。)不要引入需要跨进程一致性的设计。 (微信投递游标 `last_msg_id` 例外,它是落库的。)不要引入需要跨进程一致性的设计。
2. **配置冷加载**。`config.js` 的 `DEFAULTS` 在启动时 deep-merge 并校验;改 `config.yml` 后必须 2. **配置冷加载**。`config.js` 的 `DEFAULTS` 在启动时 deep-merge 并校验;改 `config.yml` 后必须
@@ -160,9 +162,10 @@ curl -s http://127.0.0.1:8090/api/health
| 配置默认值 | `app/server/config.js` 的 `DEFAULTS` ↔ `app/config.example.yml` | | 配置默认值 | `app/server/config.js` 的 `DEFAULTS` ↔ `app/config.example.yml` |
| 内置工具 | `app/server/tools/definitions.json` ↔ `app/AGENTS.md` / README 工具表 ↔ `docs/tool-design.md` 规范 | | 内置工具 | `app/server/tools/definitions.json` ↔ `app/AGENTS.md` / README 工具表 ↔ `docs/tool-design.md` 规范 |
| 新增服务 / 端口 / 卷 | `docker-compose.yml` ↔ `README.md` 的部署与安全章节 | | 新增服务 / 端口 / 卷 | `docker-compose.yml` ↔ `README.md` 的部署与安全章节 |
| 新增环境变量 | `.env.example` ↔ compose ↔ README「环境变量」 | | 新增环境变量 | compose ↔ README「环境变量」 |
| 发版号 | `app/package.json` 的 `version` ↔ `app/server/routes/system.js` 的 `VERSION` 字面量(两者不自动同步) | | 发版号 | `app/package.json` 的 `version` ↔ `app/server/routes/system.js` 的 `VERSION` 字面量(两者不自动同步) |
| 技能格式 | `skills/README.md` ↔ `app/server/tools/skills.js` 的解析 | | 技能格式 | `skills/README.md` ↔ `app/server/tools/skills.js` 的解析 |
| 同栈 MCP 的 url / header 名 | `app/server/presets.json` ↔ `mcp/<服务>/src`(设置页引导表单的字段来自前者,不会自动跟随后者) |
| 对外 API | `app/server/routes/*` ↔ 前端 `app/server/public/js/*` ↔ README | | 对外 API | `app/server/routes/*` ↔ 前端 `app/server/public/js/*` ↔ README |
## 代码约定 ## 代码约定
+63 -38
View File
@@ -20,6 +20,7 @@
| 隔离执行 | `terminal` 和技能在 `agent-executor` 容器中运行,只看到当前会话目录,根文件系统只读 | | 隔离执行 | `terminal` 和技能在 `agent-executor` 容器中运行,只看到当前会话目录,根文件系统只读 |
| 大文件交付 | 文件面板上传/下载/打包 zip;外部服务取图走带过期时间的公网短链 | | 大文件交付 | 文件面板上传/下载/打包 zip;外部服务取图走带过期时间的公网短链 |
| 上下文管理 | 手动压缩、按 token 阈值提示压缩、历史重放自动裁剪、会话标题自动生成 | | 上下文管理 | 手动压缩、按 token 阈值提示压缩、历史重放自动裁剪、会话标题自动生成 |
| 回合中投递 | 运行中发的消息先进输入框上方的待发送条幅:默认等本轮结束自动发出;可「干预」(当前工具跑完就插话)或「立即发送」(终止本轮并立刻发)。队列在服务端,关页面不丢 |
| 定时任务 | 每会话最多一个 cron 任务;触发前清空模型可见历史,按计划执行并推送结果 | | 定时任务 | 每会话最多一个 cron 任务;触发前清空模型可见历史,按计划执行并推送结果 |
| 微信接入 | 扫码绑定个人微信,文本/图片/视频/文件进入同一套会话与命令体系 | | 微信接入 | 扫码绑定个人微信,文本/图片/视频/文件进入同一套会话与命令体系 |
| 语音输入 | 输入框为空时发送键变麦克风:点一下进入语音模式,输入框位置变成「按住 说话」,松开即转写并直接发送;发送键位置变键盘按钮可切回打字。套壳 App 走原生录音(http 页面也能用),浏览器走 MediaRecorder(需 HTTPS);识别在 `mcp_asr`,不经过模型、不消耗 token | | 语音输入 | 输入框为空时发送键变麦克风:点一下进入语音模式,输入框位置变成「按住 说话」,松开即转写并直接发送;发送键位置变键盘按钮可切回打字。套壳 App 走原生录音(http 页面也能用),浏览器走 MediaRecorder(需 HTTPS);识别在 `mcp_asr`,不经过模型、不消耗 token |
@@ -41,38 +42,34 @@
Debian 12 裸机可以先跑 `scripts/init_host.sh`(幂等,可重复执行,也可单独拷到服务器上跑):它会配好 Swap、Docker、国内镜像加速与基础 shell 环境;`REGION=oversea` 切海外源。跑完会打印后续的 `init.sh` 与部署步骤。 Debian 12 裸机可以先跑 `scripts/init_host.sh`(幂等,可重复执行,也可单独拷到服务器上跑):它会配好 Swap、Docker、国内镜像加速与基础 shell 环境;`REGION=oversea` 切海外源。跑完会打印后续的 `init.sh` 与部署步骤。
### 1. 生成配置 ### 1. 初始化(只做部署接线)
在仓库根目录执行: 在仓库根目录执行:
```bash ```bash
BIGMODEL_KEY=xxx \
DEEPSEEK_KEY=yyy \
QWEN_KEY=zzz \
AUTH_USER=admin \
AUTH_PASSWORD='换一个强密码' \
PUBLIC_IP=1.2.3.4 \
./scripts/init.sh ./scripts/init.sh
``` ```
三个模型 Key 都可选,填几个启用几个。`PUBLIC_IP` 也可选:**不配置时会自动探测公网 IP**(探测失败则 `public_link` 为空,外部服务取图功能不可用)。 它只做三件事,**幂等**,随便重跑:
脚本会生成: 1. 生成 `.env` 里的 `EXECUTOR_TOKEN` / `WXBOT_TOKEN` / `AUTH_SECRET`(已有值原样复用,重跑不会掉登录态,也不会换掉 executor 的 token)。
2. 探测公网 IP 并写成 `PUBLIC_BASE_URL`(外部服务靠它回取会话文件,图生视频需要)。知道地址就直接给:
```bash
PUBLIC_IP=1.2.3.4 ./scripts/init.sh
```
3. 确保 `config.yml` 存在:**不存在时**才创建,内容只有初始管理员 `admin` / `admin`。已有文件**绝不改写**。
- `.env`:`EXECUTOR_TOKEN`、`WXBOT_TOKEN`、`AGENT_PORT` 等部署变量。 脚本不再生成模型平台 / MCP / 语音这些配置——它们全部在前端「设置」里完成,写的就是同一个 `config.yml`。所以重跑脚本永远不会清掉你配好的东西(旧版脚本会覆盖,这是本次的行为变化)。
- `config.yml`:模型平台、登录账号、MCP 服务、公网前缀。
`image_task` / `video_task` 两个 MCP 服务复用 `BIGMODEL_KEY`(智谱与 BigModel 是同一个 key);未配置 `BIGMODEL_KEY` 时它们以 `mode: disable` 写入配置。 - 想换初始管理员:仅在**首次创建**时生效,`AUTH_USER=me AUTH_PASSWORD='强密码' ./scripts/init.sh`。
- `config.yml` 被 Docker 误建成了空目录(源文件缺失时才会这样):脚本会自动删掉并重建;目录非空则报错让你手工处理。
`AUTH_USER` / `AUTH_PASSWORD` 不传时默认是 `admin` / `admin`,首次部署务必改掉。 没有 `config.yml` 也能启动:`platforms` 为空、`auth` 为空即“无模型 + 不启用登录”,登录后从设置页补齐即可(保存后点「重启服务」生效)。
`.env` 里的密钥会复用,重新执行不会让登录态失效;旧的 `config.yml` 会先备份为 `config.yml.bak.<时间戳>`。
注意:`config.yml` 每次都会按本次环境变量重新生成,平台 Key 不保存在 `.env` 里。已经部署过的实例请用设置页改配置,或带上原有变量重跑;只想刷新密钥时用 `./scripts/init.sh --env-only`。
### 2. 启动 ### 2. 启动
```bash ```bash
# 迁移:把旧版根目录的 config.yml 原样留着即可,init.sh 不会动它
docker compose up -d --build docker compose up -d --build
docker compose logs -f agent-core docker compose logs -f agent-core
``` ```
@@ -81,7 +78,7 @@ docker compose logs -f agent-core
首次启动还会运行一次性的 `agent-executor-init`,把技能依赖安装到 `./skills/deps`,随后自动退出,属正常现象。 首次启动还会运行一次性的 `agent-executor-init`,把技能依赖安装到 `./skills/deps`,随后自动退出,属正常现象。
### 3. 访问 ### 3. 访问与首次配置
浏览器打开: 浏览器打开:
@@ -89,30 +86,57 @@ docker compose logs -f agent-core
http://<服务器 IP>:<AGENT_PORT> http://<服务器 IP>:<AGENT_PORT>
``` ```
使用 `init.sh` 里的账号登录。默认端口 `8090`,可用 `.env` 的 `AGENT_PORT` 修改。 首次用 `admin` / `admin` 登录(**登录后立刻在「设置 → 账户」改密码**)。默认端口 `8090`,可用 `.env` 的 `AGENT_PORT` 修改。
对外只需要放行这一个端口。`agent-executor`、`wxbot` 和 MCP 服务都只在 Docker 内网,不映射到宿主机。 登录后去「设置」补齐三块,保存后点页面顶部的「重启服务」:
| 设置页 | 配什么 |
|---|---|
| 模型 | 平台地址 + API Key + 模型 id(`extra_params` / `thinking_params` / profile 等在「高级」里) |
| MCP | `image_task` / `video_task` / `asr` 需上游 key;`web_search` 免费,地址 `http://mcp_web_search:3000/` |
| 用户 | 其余账号、角色、默认模型;改密码在「账户」 |
对外只需要放行 core 这一个端口。`agent-executor`、`wxbot` 和 MCP 服务都只在 Docker 内网,不映射到宿主机。
### 4. 同栈 MCP 服务 ### 4. 同栈 MCP 服务
`init.sh` 默认把仓库内 `mcp/` 的服务写进 `config.yml`: 初始 `config.yml` 不包含任何 MCP 服务。设置页「MCP」会把四个同栈服务作为**内置服务卡片**列出来,
点卡片 → 填表 → 保存即可(url 与 header 名由 `app/server/presets.json` 提供,不用记)。
`web_search` 免费、无需 key;另外三个要填上游 key。手工写 YAML 的形状如下(容器不存密钥):
```yaml ```yaml
mcp_servers: mcp_servers:
- name: web_search - name: web_search
url: "http://mcp_web_search:3000/" url: "http://mcp_web_search:3000/"
- name: image_task
url: "http://mcp_image_task:3000/mcp" # - name: image_task
- name: video_task # url: "http://mcp_image_task:3000/mcp"
url: "http://mcp_video_task:3000/mcp" # headers:
- name: asr # Authorization: Bearer <upstream-api-key>
url: "http://mcp_asr:3000/mcp" # X-Image-Task-Base-Url: "https://open.bigmodel.cn/api/paas/v4" # 任意 OpenAI 兼容的 images 上游(生成 /images/generations、编辑 /images/edits)
mode: skill # X-Image-Task-Model: "CogView-4"
# mode: skill
# - name: video_task
# url: "http://mcp_video_task:3000/mcp"
# headers:
# Authorization: Bearer <zhipu-api-key>
# mode: skill
# - name: asr
# url: "http://mcp_asr:3000/mcp"
# headers:
# Authorization: Bearer <key> # 免鉴权的自建服务可省
# X-ASR-Base-Url: "https://<host>/v1"
# X-ASR-Model: "whisper-1"
# mode: skill
``` ```
`web_search` / `image_task` / `video_task` / `asr` 与 core 由同一个根 `docker-compose.yml` 启动,没有先后顺序,也不占宿主机端口。工具说明、header 覆盖项与调试方式见 [mcp/README.md](mcp/README.md)。 `web_search` / `image_task` / `video_task` / `asr` 四个容器与 core 由同一个根 `docker-compose.yml` 启动(与是否写进配置无关),没有先后顺序,也不占宿主机端口。工具说明、header 覆盖项与调试方式见 [mcp/README.md](mcp/README.md)。
语音输入(H5 输入框里说话)走的是另一条路:客户端录音 → `POST /api/asr/transcribe` → `mcp_asr` 的 `/transcribe`,**不经过模型、不消耗 token**,结果插入输入框可编辑。客户端录音契约(Android 套壳原生桥 / 浏览器 MediaRecorder)见 [docs/voice-input.md](docs/voice-input.md);`ASR_URL` 置空即整体关闭。 `ASR_URL`(`docker-compose.yml` 里固定为 `http://mcp_asr:3000`)是 core 调用语音转写的基地址;把 `mcp_asr` 放到另一台机器时改这一行即可(那台要能接受 `Authorization` / `X-ASR-Base-Url` / `X-ASR-Model` 三个 header)。
语音输入(H5 输入框里说话)走的是另一条路:客户端录音 → `POST /api/asr/transcribe` → `mcp_asr` 的 `/transcribe`,**不经过模型、不消耗 token**,结果插入输入框可编辑。客户端录音契约(Android 套壳原生桥 / 浏览器 MediaRecorder)见 [docs/voice-input.md](docs/voice-input.md);删掉 `config.yml` 里的 `asr` 段即整体关闭。
`mcp_asr` 自己**不存任何平台密钥**:上游 key / base_url / model 都由 core 从这里那段 `asr.headers` 随请求带进去,换平台只改 YAML(不用重建镜像、不用动 `.env`),也不预设任何厂商。
接入栈外的 MCP 服务:在设置页添加 `url` / `headers`,或在 `config.yml` 的 `mcp_servers` 追加一项。服务不可达时 core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。 接入栈外的 MCP 服务:在设置页添加 `url` / `headers`,或在 `config.yml` 的 `mcp_servers` 追加一项。服务不可达时 core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。
@@ -176,6 +200,7 @@ mcp_servers:
在「设置 → 账户 → 微信绑定」生成二维码,扫码后即可单线对话: 在「设置 → 账户 → 微信绑定」生成二维码,扫码后即可单线对话:
- 微信消息复用同一套会话和命令层,支持 `/new`、`/list`、`/switch`、`/delete`、`/rename`、`/models`、`/think`、`/stop`、`/compact`、`/clear`、`/status`、`/help`。 - 微信消息复用同一套会话和命令层,支持 `/new`、`/list`、`/switch`、`/delete`、`/rename`、`/models`、`/think`、`/stop`、`/compact`、`/clear`、`/status`、`/help`。
- 回合进行中发消息=自动干预:当前工具调用跑完就插话(同批剩余调用标记为「因你介入未执行」),不会等本轮结束,也不会打断正在执行的命令。要立刻中止用 `/stop`。
- 图片、视频、文件会落到当前会话目录;单发媒体只留痕,不唤醒 AI。 - 图片、视频、文件会落到当前会话目录;单发媒体只留痕,不唤醒 AI。
- AI 最终回复会推回微信;较长回复自动分段,超长时落成 `.md` 文件卡片。 - AI 最终回复会推回微信;较长回复自动分段,超长时落成 `.md` 文件卡片。
- 定时任务完成或失败也会通知微信。 - 定时任务完成或失败也会通知微信。
@@ -244,14 +269,13 @@ platforms:
| `PORT` | core 监听端口,容器内 `8090` | | `PORT` | core 监听端口,容器内 `8090` |
| `EXECUTOR_URL` | `agent-executor` 地址;空则命令在 core 进程内本地执行,仅适合开发 | | `EXECUTOR_URL` | `agent-executor` 地址;空则命令在 core 进程内本地执行,仅适合开发 |
| `EXECUTOR_TOKEN` | core ↔ executor 的 Bearer token,两侧同值 | | `EXECUTOR_TOKEN` | core ↔ executor 的 Bearer token,两侧同值 |
| `ASR_URL` | `mcp_asr` 地址(compose 为 `http://mcp_asr:3000`);置空则语音输入关闭 | | `ASR_URL` | core 拼接 `/transcribe` 的基地址,compose 里固定 `http://mcp_asr:3000`(把 `mcp_asr` 放别处时改那一行) |
| `ASR_API_KEY` / `ASR_API_BASE` / `ASR_MODEL` | `mcp_asr` 的上游语音识别密钥与地址(默认智谱 `glm-asr`) | | `ASR_LOG_LEVEL` | `mcp_asr` 日志等级 |
| `WXBOT_URL` | wxbot 地址;置空则微信功能整体关闭 | | `WXBOT_URL` | wxbot 地址;置空则微信功能整体关闭 |
| `WXBOT_TOKEN` | core ↔ wxbot 的共享 token | | `WXBOT_TOKEN` | core ↔ wxbot 的共享 token |
| `VIRTUAL_HOST` | 设置后 `public_link.base_url` 强制取 `https://<第一个域名>` | | `PUBLIC_BASE_URL` | 对外的完整地址(如 `http://1.2.3.4:8090`),作为 `public_link` 的默认值;设置页填过则以设置页为准 |
| `PREVIEW_PROXIES` | 覆盖内置预览反代注册表(JSON 数组) | | `PREVIEW_PROXIES` | 覆盖内置预览反代注册表(JSON 数组) |
| `EXECUTOR_LOG_LEVEL` / `WXBOT_LOG_LEVEL` | 两个附属服务的日志等级 | | `EXECUTOR_LOG_LEVEL` / `WXBOT_LOG_LEVEL` | 两个附属服务的日志等级 |
| `WEB_SEARCH_PORT` / `IMAGE_TASK_PORT` / `VIDEO_TASK_PORT` | 仅调试:临时把对应 MCP 服务映射到宿主机端口(默认注释掉) |
`config.yml` 与 `.env` 都含密钥,已在 `.gitignore` 中。不要提交,也不要挂给不需要它的容器。 `config.yml` 与 `.env` 都含密钥,已在 `.gitignore` 中。不要提交,也不要挂给不需要它的容器。
@@ -336,6 +360,7 @@ http://<host>/p/<id>
- 只由 core 进程内的工具签发,签发前校验文件在任务目录内且 `realpath` 未越界。 - 只由 core 进程内的工具签发,签发前校验文件在任务目录内且 `realpath` 未越界。
- 默认 30 分钟过期,可配置 1 分钟到 24 小时。 - 默认 30 分钟过期,可配置 1 分钟到 24 小时。
- 链接可重复使用,直到过期;服务重启后全部失效。 - 链接可重复使用,直到过期;服务重启后全部失效。
- 响应头按类型分开:图片(`png/jpg/webp/gif/bmp/tif/avif/ico/svg`)返回 `inline` + 对应 `image/*`,点开链接直接看图;其余类型返回 `attachment`,交给浏览器/WebView 下载(SVG 额外带 `Content-Security-Policy: sandbox`,禁止内嵌脚本)。
- 任何人拿到链接即可匿名访问,不要对含密钥的文件签发。 - 任何人拿到链接即可匿名访问,不要对含密钥的文件签发。
### HTTPS ### HTTPS
@@ -354,7 +379,7 @@ proxy_buffering off;
proxy_read_timeout 3600s; proxy_read_timeout 3600s;
``` ```
若设置了 `VIRTUAL_HOST`,公网链接前缀会自动变成 `https://<域名>`;仓库默认 compose 里带有 `VIRTUAL_HOST=agent.ai.foresh.com`,不接反向代理时应删除或改成自己的域名。 公网链接前缀取 `config.yml` 的 `public_link.base_url`(设置页「服务 → 公网地址」);没填时用 `.env` 的 `PUBLIC_BASE_URL`(`init.sh` 会自动探测写入)。前置了反向代理 + HTTPS 的部署,直接把它填成域名即可。
--- ---
@@ -415,9 +440,9 @@ curl -s http://127.0.0.1:8090/api/health
|---|---| |---|---|
| 启动时报 `network agent-mcp-net has active endpoints` | 旧的双仓库部署残留:先停旧的 mcp 仓库(`docker compose down`),再 `up` 本栈 | | 启动时报 `network agent-mcp-net has active endpoints` | 旧的双仓库部署残留:先停旧的 mcp 仓库(`docker compose down`),再 `up` 本栈 |
| 套壳 App 填了服务器地址仍连不上 | 先 `curl <地址>/api/health` 看是否返回 `service:agent-core`;再查 Android 9+ 默认禁止明文 HTTP(需 `usesCleartextTraffic`)与 https 自签证书 | | 套壳 App 填了服务器地址仍连不上 | 先 `curl <地址>/api/health` 看是否返回 `service:agent-core`;再查 Android 9+ 默认禁止明文 HTTP(需 `usesCleartextTraffic`)与 https 自签证书 |
| 麦克风按钮不显示 | `ASR_URL` 为空(未部署 `mcp_asr`);或浏览器以 `http://<IP>` 访问且没有原生录音桥(非安全上下文开不了麦,见 `docs/voice-input.md`) | | 麦克风按钮不显示 | `config.yml` 的 `mcp_servers` 里没有启用的 `asr` 段 / 该段缺 `X-ASR-Base-Url`(`GET /api/asr/status` 会返回 `reason`);或浏览器以 `http://<IP>` 访问且没有原生录音桥(非安全上下文开不了麦,见 `docs/voice-input.md`) |
| 点麦克风提示「语音识别服务不可用」 | `mcp_asr` 未起来或 `ASR_API_KEY` 为空:`docker compose logs --tail=50 mcp_asr` | | 点麦克风提示「语音识别服务不可用」 | `mcp_asr` 未起来(`docker compose logs --tail=50 mcp_asr`);或 `config.yml` 的 `asr.headers` 缺 `X-ASR-Base-Url` / `X-ASR-Model` |
| `config.yml` 变成目录 | 启动前文件不存在,Docker 自动建了同名目录;停容器、删目录、放入配置文件 | | `config.yml` 变成目录 | 启动前文件不存在,Docker 自动建了同名目录;重跑 `./scripts/init.sh` 会自动删除空目录并重建(非空目录需先备份再手工删除) |
| 没有可用模型 | `platforms` 为空或模型全部禁用;在设置页添加后重启 | | 没有可用模型 | `platforms` 为空或模型全部禁用;在设置页添加后重启 |
| 创建会话报「无可用模型」 | 模型池为空,或指定模型所在平台没有 key | | 创建会话报「无可用模型」 | 模型池为空,或指定模型所在平台没有 key |
| 技能依赖缺失 | 重新 `docker compose up -d --build agent-executor`;或检查 `skills/deps` | | 技能依赖缺失 | 重新 `docker compose up -d --build agent-executor`;或检查 `skills/deps` |
+52 -5
View File
@@ -39,6 +39,7 @@ AGENT_CONFIG=./config.yml node server/server.js
|---|---| |---|---|
| `server/server.js` | 装配、路由挂载、`/api/models`、`/api/health`、prompt dump、优雅退出 | | `server/server.js` | 装配、路由挂载、`/api/models`、`/api/health`、prompt dump、优雅退出 |
| `server/config.js` | YAML 加载/校验/默认值;`platforms` 展开成 `cfg.models`;配置文本改写(设置页) | | `server/config.js` | YAML 加载/校验/默认值;`platforms` 展开成 `cfg.models`;配置文本改写(设置页) |
| `server/presets.json` | 平台与同栈 MCP 的固定契约(url / type / header 名),设置页新增时的模板来源;改服务地址改这里 |
| `server/db.js` | 建表、索引、幂等迁移;纯 SQL 数据层,不放业务 | | `server/db.js` | 建表、索引、幂等迁移;纯 SQL 数据层,不放业务 |
| `server/engine.js` | **核心**:会话状态机、模型池调度、Agent 主循环、压缩、标题、日记收口、消息增删 | | `server/engine.js` | **核心**:会话状态机、模型池调度、Agent 主循环、压缩、标题、日记收口、消息增删 |
| `server/llm.js` | 消息组装、system prompt 拼接、上游流式调用、占位裁剪、多模态块编解码 | | `server/llm.js` | 消息组装、system prompt 拼接、上游流式调用、占位裁剪、多模态块编解码 |
@@ -78,18 +79,56 @@ POST /api/sessions/:id/messages
checkToolArgs:JSON 非法/缺必填 → 整条 assistant 标 type='errAck' checkToolArgs:JSON 非法/缺必填 → 整条 assistant 标 type='errAck'
saveMessage(assistant) + recordModelUsage saveMessage(assistant) + recordModelUsage
压缩回合的收尾答复 → type='summary',之前全部消息 → type='archived' 压缩回合的收尾答复 → type='summary',之前全部消息 → type='archived'
无 tool_calls → 若期间又有新 user 消息则继续,否则收尾 无 tool_calls → 待投递里有「干预」则投递并继续;否则若有新 user 消息继续,否则收尾
有 tool_calls → 逐个 executeTool → saveMessage(tool) → emit tool_result 有 tool_calls → 逐个 executeTool → saveMessage(tool) → emit tool_result
(每步之后与整批之前各查一次「干预」,命中就先闭合批次再投递)
→ finalize → finalize
closeToolBatch(兜底:补齐本批未执行调用的合成回执)
cancelled → status=cancelled cancelled → status=cancelled
正常 → status=held,emit done,maybeGenerateTitle,run.taskWrap → taskClockOut 正常 → status=held,emit done,maybeGenerateTitle,run.taskWrap → taskClockOut
收尾后若队列非空 → setImmediate 投递队首(排队模式的唯一出口)
→ maybeAutoCompress(回合彻底结束后才检查) → maybeAutoCompress(回合彻底结束后才检查)
``` ```
**给前端的是 SSE 事件,不是响应体**。前端在 `GET /api/sessions/:id/stream` 上听: **给前端的是 SSE 事件,不是响应体**。前端在 `GET /api/sessions/:id/stream` 上听:
`status`、`assistant_delta`、`reasoning_delta`、`tool_call_start`、`tool_call_args`、 `status`、`assistant_delta`、`reasoning_delta`、`tool_call_start`、`tool_call_args`、
`tool_call`、`tool_result`、`assistant_message`、`done`、`error`、`title`、`auto_compress`、 `tool_call`、`tool_result`、`assistant_message`、`done`、`error`、`title`、`auto_compress`、
`ui_card`,以及每 15s 的具名心跳 `ping`(注释帧不触发 JS 事件,所以用具名事件做前端看门狗)。 `ui_card`、`pending_added`、`pending_removed`、`user_message`,以及每 15s 的具名心跳 `ping`
(注释帧不触发 JS 事件,所以用具名事件做前端看门狗)。
## 待投递消息(排队 / 干预 / 立即发送)
回合正在跑时,Web 端发送不再「立即插话」,而是进**服务端队列**(`engine.js` 的 `pendings`,
进程内内存态,同 `runs`,重启即丢):输入框上方出现一行条幅,默认等本轮结束自动发出。
| 模式 | 入口 | 行为 |
|---|---|---|
| `queue`(默认) | 网页端运行中点发送 | 本轮 `finalize` 后作为新回合的第一条消息发出 |
| `interject`(干预) | 条幅「干预」/ **IM 渠道消息** | 当前工具跑完(或本条回复落库)后,闭合批次、就地插话,同一回合继续 |
| `now`(立即发送) | 条幅「立即发送」 | 杀进程 + abort 流,本回合判 `cancelled`,收尾后立刻发 |
微信 / `POST /api/channel/send` 的普通消息走 `enqueueMessage(..., {mode:'interject'})`:
IM 用户在实时对话,回合中插话应当“当前这步跑完就插”,不排队等本轮结束;且**必须走队列**
(旧的直接 `postUserMessage` 会把 user 行插进工具批次中间)。`interject` 入队时插到所有
`queue` 之前(已在队列里的 interject 仍保持先来后到),这样它立刻成为队首,边界检查才能命中。
**铁律:队列里的消息绝不先落 `messages` 表。** 只在安全边界写库——① 工具批次闭合
(本批每个 `tool_call_id` 都有回执);② 无 `tool_calls` 的回复已落库;③ 回合 finalize。
否则 `user` 行会夹在 `assistant.tool_calls` 与 `tool` 回执之间,或批次没闭合就收尾,
上游一律拒收整个请求。
- `closeToolBatch(sessionId, reason)` 是配对兜底的唯一写入口:给最后一条带 `tool_calls` 的
assistant 里缺回执的调用补一条 `is_error=1` 的合成 tool 行(「用户介入/终止,本次调用未执行」)。
`finalize` 无条件调一次,取消路径与干预路径各调一次。广播的 `tool_result` 带 `skipped:true`,
微信端据此显示「N 次因你介入未执行」。
- **微信端不下发任何工具失败**(即使 `is_error=true`):多数是模型参数用错、下一轮自己会改,
推给用户既看不懂也帮不上忙;要交代就由模型自己的回复说。失败仍完整保留在库里与网页端工具卡上。
- 读侧还有一层纯过滤(`llm.buildMessages` 的 `pairedByAssistant` / `emittedCallIds`):只下发
「本批(紧邻的连续 tool 行)确有回执」的调用,孤儿回执也不下发。DB/UI 不动,专门兜历史脏数据。
- `stop()`(用户点「停止」)**会清空队列**(全停语义);「立即发送」不走 `stop`,只中断当前回合、保留队首。
- 只允许升级**队首**(`promotePending` 对非队首回 409),避免「越过后面的消息先发」。
- HTTP:`POST /messages` 的 `delivery:'queue'`;`POST /pending/:qid {action}`;`DELETE /pending/:qid`;
会话详情响应带 `pending`,`status` 事件也带 `pending`(前端把条幅当服务端状态的回显)。
## 会话状态机 ## 会话状态机
@@ -151,8 +190,16 @@ POST /api/sessions/:id/messages
- 重读去重(engine `run.imgDelivered`)**只拦同一批 tool call 内的重复读**(一次请求里塞两份同样的图 - 重读去重(engine `run.imgDelivered`)**只拦同一批 tool call 内的重复读**(一次请求里塞两份同样的图
没意义);跨批次重读一律放行。不要写成「一回合只投递一次」,也不要靠推测「图还在不在上下文里」—— 没意义);跨批次重读一律放行。不要写成「一回合只投递一次」,也不要靠推测「图还在不在上下文里」——
模型说拿不到就得给,而且文件可能已重新生成(路径相同、内容不同);拦掉只会把新像素挡在门外。 模型说拿不到就得给,而且文件可能已重新生成(路径相同、内容不同);拦掉只会把新像素挡在门外。
- 占位裁剪(`agent.trim_write_rounds` / `trim_result_rounds`):距尾 ≥N 个 assistant 轮的 - 占位裁剪(`agent.trim.rules`):指定工具的参数(`side: args` + `fields`,仅顶层字符串)或回执正文
`write_file.content`、`fetch`/`read_file` 回执换成单行占位。**只改发给上游的副本**,DB 与 UI 不动。 (`side: result`)在满足**两个距离条件**时换成单行占位:`rounds` = 其后又有几条 assistant 行
(「后面 AI 又说了几句话」)、`turns` = 其后又有几条真人消息(`role=user` 且 `type` 为空,
「后面又来了几条真人消息」)。两者是 AND,同时满足才裁;`turns: 1` = 回合内绝不裁、跨过用户
回合边界才裁——`fetch` / `read_file` / `web_search` 默认都配了它(否则长回合里模型会把同一段
反复重读,实测有回合重读同一文件 24 次);`write_file` 的参数只是快照,只配 `rounds: 1`。
默认规则在 `config.js` 的 `DEFAULTS.agent.trim.rules`(唯一来源),`config.yml` 写了 `trim.rules`
就整体替换(`[]` = 全关)。**只改发给上游的副本**,DB 与 UI 不动。规则只给「内容可再生或
只是当时快照」的工具配:`terminal` 这类一次性输出裁掉后模型就再也看不到
(规则写法与示例见 `config.example.yml` 的 `agent.trim`)。
- `compressMessages` = `buildMessages` + 末尾一条压缩指令 `user`。**铁律**:压缩请求必须与上一次 - `compressMessages` = `buildMessages` + 末尾一条压缩指令 `user`。**铁律**:压缩请求必须与上一次
常规请求字节同构、只在尾部追加;不要为了省 token 在压缩回合抽掉快照或裁剪历史,断前缀缓存等于全价重读。 常规请求字节同构、只在尾部追加;不要为了省 token 在压缩回合抽掉快照或裁剪历史,断前缀缓存等于全价重读。
- `titleMessages`:不带 system prompt,只取 user/assistant 纯文本行(白名单 `null`/`summary`/`task_brief`) - `titleMessages`:不带 system prompt,只取 user/assistant 纯文本行(白名单 `null`/`summary`/`task_brief`)
@@ -266,7 +313,7 @@ preview-proxy.earlyGuard
express.static(public) express.static(public)
/api/sessions ×4 ← sessions / messages / files / skill-run(通用执行面) /api/sessions ×4 ← sessions / messages / files / skill-run(通用执行面)
/api/skills /api/skills
/api/asr ← 语音识别代理:/transcribe 走登录态;ASR_URL 空则 503 /api/asr ← 语音识别代理:/transcribe 走登录态;ASR_URL 空或配置里无可用 asr 段则 503
/api/config ← requireAdmin /api/config ← requireAdmin
/api/platforms /api/platforms
/api/system ← /restart 需 admin,其余登录即可 /api/system ← /restart 需 admin,其余登录即可
+46 -4
View File
@@ -27,7 +27,7 @@ data_root: "/workspace/data" # 数据根目录:SQLite
db_path: "" # 留空取 data_root/.agent.db db_path: "" # 留空取 data_root/.agent.db
log_level: "info" # debug < info < warn < error < none(仅 core 自身;executor/wxbot 的日志等级另走 EXECUTOR_LOG_LEVEL / WXBOT_LOG_LEVEL env,compose 注) log_level: "info" # debug < info < warn < error < none(仅 core 自身;executor/wxbot 的日志等级另走 EXECUTOR_LOG_LEVEL / WXBOT_LOG_LEVEL env,compose 注)
# executor(命令执行)与 wxbot(微信接入)均**不是本文件的配置项**,接线全走根 compose 注入的 env(见 .env.example): # executor(命令执行)与 wxbot(微信接入)均**不是本文件的配置项**,接线全走根 compose 注入的 env(见 README「环境变量」):
# EXECUTOR_URL / EXECUTOR_TOKEN;WXBOT_URL(默认 http://agent-wxbot:8093,置空=微信入口静默关闭)/ WXBOT_TOKEN(init.sh 生成,两侧同值)。 # EXECUTOR_URL / EXECUTOR_TOKEN;WXBOT_URL(默认 http://agent-wxbot:8093,置空=微信入口静默关闭)/ WXBOT_TOKEN(init.sh 生成,两侧同值)。
terminal: terminal:
@@ -47,8 +47,43 @@ agent:
max_retries: 2 # 上游失败重试次数 max_retries: 2 # 上游失败重试次数
language: "Simplified Chinese" # 强制回复语言;留空不限 language: "Simplified Chinese" # 强制回复语言;留空不限
auto_compress_tokens: 60000 # In token 超此值弹「自动压缩」提议;0=关 auto_compress_tokens: 60000 # In token 超此值弹「自动压缩」提议;0=关
trim_write_rounds: 1 # 历史重放裁剪:write_file 参数正文距尾 ≥N 个 assistant 轮换单行占位(0=关;DB/UI 不动,盘上可重读) # 历史重放占位裁剪(省 token):把「可再生的重负载」换成单行占位再发给上游
trim_result_rounds: 2 # fetch/read_file 回执正文距尾 ≥N 个 assistant 轮换单行占位(0=关;占位留 url/path 作恢复指针) #(DB/UI 不动,盘上可重读/重抓)。两个距离条件**同时满足**才裁:
# rounds = 这一行之后又出现了几条 AI 回复 (「后面 AI 又说了几句话」)
# turns = 这一行之后又来了几条真人消息 (「后面又来了几条真人消息」;注入行不算)
#
# 举例(rounds: 2 + turns: 1):
# 回合1:读① → 读② → 改③ → 「改好了」
# 回合2 第 1 句请求:①② 已过 2 条 AI 回复 + 1 条真人消息 → 裁成占位;
# ③ 只过了 1 条 AI 回复 → 留着
# 回合2 第 2 句请求:③ 也过了 2 条 → 裁
# 也就是说:回合内绝不会裁,回合结束后开始清;想「新回合第一句就清光」把 rounds 改成 1。
#
# rounds 与 turns 都写 0(或不写)= 该条规则关闭;整段 rules: [] = 全关。
# side=args 裁调用参数(fields 点名顶层字符串参数);side=result 裁整段回执正文。
# tool 用模型看到的最终工具名(MCP 重名时含 server__ 前缀)。
# 下面就是内置默认(与 config.js 的 DEFAULTS.agent.trim.rules 同步);写了本段就整体替换默认。
trim:
min_chars: 600 # 短于此长度的正文不裁(占位自身也有成本);单条规则可用 min_chars 覆盖
rules:
- tool: write_file # 参数正文只是写盘时的快照,后续 edit_file 一次就失真
side: args
fields: [content]
rounds: 1
turns: 0 # 不带 turns:回合内也照裁(省的是每轮重发整个文件)
- tool: fetch # 页面可重抓;status_regex 取第一个捕获组写进占位(YAML 用单引号,避免 \d 被当转义)
side: result
rounds: 2
turns: 1 # 回合内不裁(否则同一 URL 会被反复重抓),跨回合后按 rounds 清
status_regex: '^HTTP (\d{3})'
- tool: read_file # 文件在盘上,可重读
side: result
rounds: 2
turns: 1 # 回合内不裁(否则长回合里模型会反复重读同一段)
- tool: web_search # 栈内免费搜索 MCP;可重搜,但结果会随时间变化
side: result
rounds: 2
turns: 1 # 同上;现在回执默认不截断,单条可能上万字
auto_complete_ms: 1800000 # 保持中(held)超此时长自动收口为已完成;0=关(纯状态动作,历史/模型绑定不动) auto_complete_ms: 1800000 # 保持中(held)超此时长自动收口为已完成;0=关(纯状态动作,历史/模型绑定不动)
# 长期记忆(日记,memory.js):收口时一条几十字第一人称碎片入当日条目;存储默认永久,旧记忆靠回忆下钻 # 长期记忆(日记,memory.js):收口时一条几十字第一人称碎片入当日条目;存储默认永久,旧记忆靠回忆下钻
@@ -84,10 +119,17 @@ auth: # users 留空 = 不启用登
# disable=不连接、不发现。旧字段 enable 已废弃;mode: silent 已移除(改用 skill),写进配置会启动报错。 # disable=不连接、不发现。旧字段 enable 已废弃;mode: silent 已移除(改用 skill),写进配置会启动报错。
# #
# 语音识别(mcp/asr)建议用 skill:转写音频是低频能力,不必把 schema 塞进每轮请求。 # 语音识别(mcp/asr)建议用 skill:转写音频是低频能力,不必把 schema 塞进每轮请求。
# 上游参数(key / base_url / model)由 core 随请求带给 mcp_asr,容器自己不存密钥,
# 也不预设任何平台——任何 OpenAI 兼容的 /audio/transcriptions 都行。免鉴权的自建服务可省 Authorization。
# - name: asr # - name: asr
# url: "http://mcp_asr:3000/mcp" # url: "http://mcp_asr:3000/mcp"
# headers:
# Authorization: Bearer <key>
# X-ASR-Base-Url: "https://<host>/v1"
# X-ASR-Model: "whisper-1"
# mode: skill # mode: skill
# 注意:输入框里的语音输入走的是 core 的 /api/asr(由 compose 的 ASR_URL 接线),不经这个工具,也不消耗 token。 # 注意:输入框里的语音输入走的是 core 的 /api/asr(由 compose 的 ASR_URL 接线),也读这一段的 headers;
# 不经工具、不消耗 token。mode: disable 或删掉这段 = 麦克风入口关闭。
mcp_servers: [] mcp_servers: []
public_link: public_link:
+1 -1
View File
@@ -1,6 +1,6 @@
{ {
"name": "agent-app", "name": "agent-app",
"version": "2.4.0", "version": "2.5.0",
"description": "自用通用 Agent 系统:多模型调度 + 任务目录 + 工具调用 + H5 Web UI", "description": "自用通用 Agent 系统:多模型调度 + 任务目录 + 工具调用 + H5 Web UI",
"main": "server/server.js", "main": "server/server.js",
"scripts": { "scripts": {
+183 -20
View File
@@ -86,9 +86,24 @@ const DEFAULTS = {
// auto_compress_tokens:本轮 In token 峰值 ≥ 此值时推送「自动压缩」提议(0=关)。 // auto_compress_tokens:本轮 In token 峰值 ≥ 此值时推送「自动压缩」提议(0=关)。
// auto_complete_ms:held(保持中)超过此时长自动收口为 completed(0=关)。key 非独占后 held 不占任何资源, // auto_complete_ms:held(保持中)超过此时长自动收口为 completed(0=关)。key 非独占后 held 不占任何资源,
// 收口是纯视觉动作:历史/绑定不动,再发言照常由 completed 分支续跑(见 engine.sweepHeldTimeouts)。 // 收口是纯视觉动作:历史/绑定不动,再发言照常由 completed 分支续跑(见 engine.sweepHeldTimeouts)。
// trim_write_rounds / trim_result_rounds:历史重放占位裁剪(llm.buildMessages)——write_file 参数正文 / // 历史重放占位裁剪(llm.buildMessages):trim.rules 逐条声明「哪个工具、参数侧还是回执侧、
// fetch、read_file 回执正文距尾 ≥N 个 assistant 轮后换单行占位(DB/UI 不动,内容可再生:盘上重读/重抓);0=关。 // 距尾多远换单行占位」;只改发给上游的副本,DB/UI 不动。
agent: { temperature: 1.0, max_tool_iterations: 100, max_retries: 2, language: 'Simplified Chinese', auto_compress_tokens: 60000, auto_complete_ms: 1800000, trim_write_rounds: 1, trim_result_rounds: 2 }, // 两个距离条件**同时满足**才裁:
// rounds = 这一行之后又出现了几条 assistant 行(「后面 AI 又说了几句话」)
// turns = 这一行之后又来了几条真人消息(role=user 且 type 为空,「后面又来了几条真人消息」)
// 所以 turns:1 = 回合内绝不裁、跨过用户回合边界才裁(避免长回合里模型反复重读同一个文件)。
// 这里是默认策略的唯一来源:config.yml 写了 trim.rules 就整体替换(写 [] = 全关)。
agent: { temperature: 1.0, max_tool_iterations: 100, max_retries: 2, language: 'Simplified Chinese', auto_compress_tokens: 60000, auto_complete_ms: 1800000, trim: {
min_chars: 600,
rules: [
// 参数正文只是写盘时的快照:不带 turns,回合内也照裁(省的是每轮重发整个文件)
{ tool: 'write_file', side: 'args', fields: ['content'], rounds: 1 },
// 回执可再生(页面可重抓 / 文件可重读 / 可重搜):turns:1 保证同一回合内不裁,回合结束后按 rounds 兜底
{ tool: 'fetch', side: 'result', rounds: 2, turns: 1, status_regex: '^HTTP (\\d{3})' },
{ tool: 'read_file', side: 'result', rounds: 2, turns: 1 },
{ tool: 'web_search', side: 'result', rounds: 2, turns: 1 },
],
} },
// 大图上传预处理(浏览器端 canvas 压缩,参数经 /api/system/status 下发前端)。 // 大图上传预处理(浏览器端 canvas 压缩,参数经 /api/system/status 下发前端)。
// paste_to_file_threshold_chars:粘贴文本超过该字符数时前端转成 .txt 附件,0 = 关闭。 // paste_to_file_threshold_chars:粘贴文本超过该字符数时前端转成 .txt 附件,0 = 关闭。
upload: { image_compress_threshold_kb: 1536, image_max_dim: 2000, image_quality: 0.85, confirm_size_mb: 10, paste_to_file_threshold_chars: 2000 }, upload: { image_compress_threshold_kb: 1536, image_max_dim: 2000, image_quality: 0.85, confirm_size_mb: 10, paste_to_file_threshold_chars: 2000 },
@@ -126,7 +141,7 @@ const DEFAULTS = {
// mode 三态:advertise=工具下发给模型;skill=不下发,改为以技能形式暴露(get 返回原始 // mode 三态:advertise=工具下发给模型;skill=不下发,改为以技能形式暴露(get 返回原始
// input_schema,run 直接转发);disable=不加载。 // input_schema,run 直接转发);disable=不加载。
mcp_servers: [], mcp_servers: [],
// 公网临时链接:base_url 非空才启用 mint_public_link;容器配 VIRTUAL_HOST 时以它为准。 // 公网临时链接:base_url 非空才启用 mint_public_link(config.yml 优先,其次 env PUBLIC_BASE_URL)。
public_link: { base_url: '', ttl_ms: 1800000 }, public_link: { base_url: '', ttl_ms: 1800000 },
}; };
@@ -236,10 +251,85 @@ function normalizePlatforms(rawPlatforms, profileNames) {
return out; return out;
} }
// ---------- 历史重放的重负载占位裁剪(agent.trim) ----------
// 语义:某条工具调用/回执距对话尾部 ≥rounds 个 assistant 轮、且 ≥turns 个真人回合后,
// 把其中「可再生的重负载」换成单行占位再发给上游(llm.buildMessages;DB/UI 不动)。
// rounds = 「后面 AI 又说了几句话」;turns = 「后面又来了几条真人消息」(type 为空的 user 行)。
// 两者同时满足才裁。只该给「内容可再生或只是当时快照」的工具开:read_file/fetch 能重读重抓、write_file 参数
// 只是快照;terminal 输出是一次性的,裁掉模型就永久看不到了。
const TRIM_RULE_KEYS = new Set(['tool', 'side', 'rounds', 'turns', 'fields', 'min_chars', 'status_regex']);
function toNonNegInt(v, d) {
const n = Math.floor(Number(v));
return Number.isFinite(n) ? Math.max(0, n) : d;
}
// 单条规则校验:未知字段直接报错(拼错静默忽略 = 以为省了 token 其实没省)。
function normalizeTrimRule(r, i, defMinChars) {
const at = 'agent.trim.rules[' + i + ']';
if (!r || typeof r !== 'object' || Array.isArray(r)) throw new Error(at + ' 必须是对象');
for (const k of Object.keys(r)) {
if (!TRIM_RULE_KEYS.has(k)) {
throw new Error(at + ' 含未知字段:' + k + '(可用:' + Array.from(TRIM_RULE_KEYS).join(' / ') + ')');
}
}
const tool = String(r.tool == null ? '' : r.tool).trim();
if (!tool) throw new Error(at + ' 缺少 tool(填模型看到的最终工具名,MCP 重名时含 server__ 前缀)');
const side = String(r.side == null ? '' : r.side).trim();
if (side !== 'args' && side !== 'result') {
throw new Error(at + '.side 只能是 args(裁调用参数)/ result(裁回执正文),收到:' + side);
}
// rounds / turns 都是「距尾多远」,同时满足才裁;两个都写 0(或不写)= 该条规则关闭,直接丢掉,不留空规则。
const rounds = toNonNegInt(r.rounds, 0);
const turns = toNonNegInt(r.turns, 0);
if (rounds <= 0 && turns <= 0) return null;
const out = { tool, side, rounds, turns, min_chars: toNonNegInt(r.min_chars, defMinChars) };
if (side === 'args') {
if (!Array.isArray(r.fields) || !r.fields.length) {
throw new Error(at + '(args 侧)必须配 fields 数组(要占位的顶层参数名,如 [content])');
}
out.fields = r.fields.map(x => String(x).trim()).filter(Boolean);
if (!out.fields.length) throw new Error(at + '(args 侧)fields 不能为空');
} else if (r.fields !== undefined) {
throw new Error(at + '.fields 只适用于 args 侧(result 侧整段正文替换,无需点名字段)');
}
if (r.status_regex !== undefined && r.status_regex !== null && String(r.status_regex).trim()) {
if (side !== 'result') throw new Error(at + '.status_regex 只适用于 result 侧');
const src = String(r.status_regex);
try { new RegExp(src); } catch (_) { throw new Error(at + '.status_regex 不是合法正则:' + src); }
out.status_regex = src;
}
return out;
}
// agent.trim 归一:默认值来自 DEFAULTS.agent.trim.rules(唯一来源),config.yml 写了 rules
// 就整体替换([] = 全关)。归一结果直接写回 cfg.agent.trim.rules,不再另造 trim_rules 键。
function normalizeAgentTrim(cfg) {
// 拷一份再改:无 agent 段时 cfg.agent 与 DEFAULTS.agent 是同一引用,直接写会污染默认值
// (配置页反复校验时上一份的 trim 会漏给下一份)。
const a = Object.assign({}, cfg.agent || {});
cfg.agent = a;
const trim = (a.trim && typeof a.trim === 'object' && !Array.isArray(a.trim)) ? a.trim : {};
const defMinChars = toNonNegInt(trim.min_chars, DEFAULTS.agent.trim.min_chars);
// undefined / null 都是「没配」,回落到 DEFAULTS(deepMerge 通常已把默认数组带进来,
// 这里兜住 agent.trim: null 这类显式空值);显式 [] 才是全关。
const rawRules = (trim.rules === undefined || trim.rules === null) ? DEFAULTS.agent.trim.rules : trim.rules;
if (!Array.isArray(rawRules)) throw new Error('agent.trim.rules 必须是数组');
const rules = rawRules.map((r, i) => normalizeTrimRule(r, i, defMinChars)).filter(Boolean);
const seen = new Set();
for (const r of rules) {
const k = r.side + '\u0000' + r.tool;
if (seen.has(k)) throw new Error('agent.trim.rules 重复声明同一工具同一侧:' + r.tool + '(' + r.side + ')');
seen.add(k);
}
a.trim = Object.assign({}, trim, { min_chars: defMinChars, rules });
}
// 校验原始配置文本(启动读文件与网页编辑共用)。configPath 仅记录来源,可为空。 // 校验原始配置文本(启动读文件与网页编辑共用)。configPath 仅记录来源,可为空。
function parseAndValidate(rawText, configPath) { function parseAndValidate(rawText, configPath) {
let raw = YAML.parse(rawText || '') || {}; let raw = YAML.parse(rawText || '') || {};
const cfg = deepMerge(DEFAULTS, raw); const cfg = deepMerge(DEFAULTS, raw);
normalizeAgentTrim(cfg);
// ---------- 模型配置:platforms 层级(platforms[].models[] + platforms[].keys[])---------- // ---------- 模型配置:platforms 层级(platforms[].models[] + platforms[].keys[])----------
// models 提到平台层(与 url/type 同级),多 key 共用同一份 models。 // models 提到平台层(与 url/type 同级),多 key 共用同一份 models。
@@ -383,16 +473,14 @@ function parseAndValidate(rawText, configPath) {
// 公网链接宁可短不可长(“永久公开”正是这套机制要避免的东西)。 // 公网链接宁可短不可长(“永久公开”正是这套机制要避免的东西)。
// //
// 对外前缀的取值优先级: // 对外前缀的取值优先级:
// 1) 容器 env 的 VIRTUAL_HOST 非空 → https://<第一个域名> // 1) config.yml 的 public_link.base_url(设置页「公网地址」手填的值,以它为准)。
// (nginx-proxy 的写法,逗号分隔多域名时取第一个)。只要配了域名 + HTTPS 这一层, // 2) env PUBLIC_BASE_URL(scripts/init.sh 探测公网 IP 后写进 .env 的部署地址)。
// 返回给外部服务(video_task 取参考图)的链接就必须走域名,所以 env 优先; // 它只是默认值:页面里填过 1) 之后就归 1) 管,避免“重跑部署脚本”和“UI 手改”互相打架。
// 反之 config.yml 里那个 init 脚本生成的 http://<IP>:8090 会把这个开关盖住。
// 协议写死 https:前置了 nginx-proxy 一定是 HTTPS(证书由 acme-companion 签)。
// 2) 否则用 config.yml 的 public_link.base_url(纯 IP:端口部署,init 脚本写 http://<IP>:8090)。
function normalizePublicLink(cfg) { function normalizePublicLink(cfg) {
const pl = cfg.public_link || {}; const pl = cfg.public_link || {};
const vhost = String(process.env.VIRTUAL_HOST || '').split(',')[0].trim(); const fromCfg = String(pl.base_url == null ? '' : pl.base_url).trim();
const baseUrl = vhost ? 'https://' + vhost : pl.base_url; const fromEnv = String(process.env.PUBLIC_BASE_URL || '').trim();
const baseUrl = fromCfg || fromEnv;
cfg.public_link = { cfg.public_link = {
base_url: String(baseUrl || '').trim().replace(/\/+$/, ''), base_url: String(baseUrl || '').trim().replace(/\/+$/, ''),
ttl_ms: Math.min(Math.max(Number(pl.ttl_ms) || 1800000, 60 * 1000), 24 * 3600 * 1000), ttl_ms: Math.min(Math.max(Number(pl.ttl_ms) || 1800000, 60 * 1000), 24 * 3600 * 1000),
@@ -405,7 +493,22 @@ function normalizePublicLink(cfg) {
function loadConfig(configPath) { function loadConfig(configPath) {
const p = configPath || process.env.AGENT_CONFIG || path.join(__dirname, '..', 'config.yml'); const p = configPath || process.env.AGENT_CONFIG || path.join(__dirname, '..', 'config.yml');
const text = fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : ''; // 目录按“文件不存在”处理:Docker 在 bind mount 的源文件缺失时会建一个同名**空目录**,
// 直接 readFileSync 会 EISDIR 崩在启动阶段——那时用户看不到任何可操作的报错。
// 空文件/缺失都是合法状态:platforms 为空、auth 为空(= 未启用登录),全部配置可稍后在前端完成。
let text = '';
let isDir = false;
try {
const st = fs.statSync(p);
if (st.isFile()) text = fs.readFileSync(p, 'utf8');
else isDir = true;
} catch (_) { /* 不存在 */ }
if (isDir) {
log.warn('config', 'config.yml 是目录(Docker 在挂载源文件缺失时会自动建同名目录,容器内无法当文件写):' + p +
';请在宿主机上删掉该空目录后重跑 scripts/init.sh');
} else if (!text.trim()) {
log.warn('config', 'config.yml 缺失或为空(' + p + '):当前无模型、无登录鉴权;可在前端「设置」里补齐配置(保存后重启生效)');
}
return parseAndValidate(text, p); return parseAndValidate(text, p);
} }
@@ -418,25 +521,85 @@ function loadConfigFromText(text, configPath) {
// 读当前配置文件原文(保留注释);文件不存在返回 null。 // 读当前配置文件原文(保留注释);文件不存在返回 null。
function readConfigText(cfg) { function readConfigText(cfg) {
const p = cfg && cfg.config_path; const p = cfg && cfg.config_path;
if (!p || !fs.existsSync(p)) return null; if (!p) return null;
// 目录(Docker 误建)与缺失一视同仁按“不存在”返回,交给调用方决定新建还是报错。
try { if (!fs.statSync(p).isFile()) return null; } catch (_) { return null; }
return fs.readFileSync(p, 'utf8'); return fs.readFileSync(p, 'utf8');
} }
// 单项编辑:[{path:[...], value}] 或 [{path:[...], delete:true}] 或 [{path:[...], value, append:true}]。 // 单项编辑:[{path:[...], value}] 或 [{path:[...], delete:true}] 或 [{path:[...], value, append:true}]。
// 用 YAML Document 写回,保留注释与排版;路径段为纯数字时按数组下标处理(如 ["platforms",0,"keys",1,"models",0])。 // 用 YAML Document 写回,保留注释与排版;路径段为纯数字时按数组下标处理(如 ["platforms",0,"keys",1,"models",0])。
// append:向目标数组追加一项(新增平台/Key/模型用);目标不存在时创建新数组。 // append:向目标数组追加一项(新增平台/Key/模型用);目标不存在时创建新数组。
//
// 写回时的版式处理(只作用于本次编辑写入的节点,文件其它部分原样保留):
// · 值带冒号(如模型 id "global:hy-image-3.5")强制双引号——裸写的 plain 标量换个解析器、
// 或落进 flow 集合里就容易被当成分隔符;纯 URL 例外(裸写无歧义)。
// · extra_params / thinking_params 这类小参数表用 flow 风格({k: v})写成一行,否则嵌套几层
// 展开成十几行,读起来又乱又占版面。
// · 追加整项时连同所在数组一起转 block:flow 数组里塞 block 映射会输出成残句(platforms: 后直接跟键)。
const FLOW_PARAM_KEYS = new Set(['extra_params', 'thinking_params']);
function needsQuoteStr(v) {
return typeof v === 'string' && v.includes(':') && !/^\w+:\/\/\S+$/.test(v);
}
function styleWrittenNode(node, forceBlock) {
if (!node || typeof node !== 'object') return;
if (YAML.isScalar(node)) {
if (needsQuoteStr(node.value)) node.type = 'QUOTE_DOUBLE';
return;
}
if (YAML.isMap(node)) {
if (forceBlock) node.flow = false;
for (const pair of node.items) {
const key = pair.key && pair.key.value;
const child = pair.value;
// 参数表保持 flow;内部值不再强制 block(不然 {k: {…}} 里的嵌套表会被抖开)
if (FLOW_PARAM_KEYS.has(String(key)) && child && typeof child === 'object' && !YAML.isScalar(child)) {
child.flow = true;
styleWrittenNode(child, false);
} else {
styleWrittenNode(child, forceBlock);
}
}
} else if (YAML.isSeq(node)) {
if (forceBlock) node.flow = false;
for (const item of node.items) styleWrittenNode(item, forceBlock);
}
}
function styledNode(doc, value, forceBlock) {
const node = doc.createNode(value);
if (forceBlock && node && typeof node === 'object' && !YAML.isScalar(node)) node.flow = false;
styleWrittenNode(node, forceBlock);
return node;
}
function applyEditsToText(text, edits) { function applyEditsToText(text, edits) {
const doc = YAML.parseDocument(text || ''); const doc = YAML.parseDocument(text || '');
for (const e of edits || []) { for (const e of edits || []) {
if (!e || !Array.isArray(e.path) || !e.path.length) throw new Error('配置项 path 必须是非空数组'); if (!e || !Array.isArray(e.path) || !e.path.length) throw new Error('配置项 path 必须是非空数组');
const docPath = e.path.map(s => (typeof s === 'string' && /^\d+$/.test(s)) ? Number(s) : s); const docPath = e.path.map(s => (typeof s === 'string' && /^\d+$/.test(s)) ? Number(s) : s);
if (e.delete) doc.deleteIn(docPath); if (e.delete) { doc.deleteIn(docPath); continue; }
else if (e.append) { if (e.append) {
const item = styledNode(doc, e.value, true);
const target = doc.getIn(docPath, true); const target = doc.getIn(docPath, true);
if (target && typeof target.add === 'function') target.add(e.value); if (target && typeof target.add === 'function') {
else if (target === null || target === undefined) doc.setIn(docPath, [e.value]); target.flow = false; // 与 block 化的新项保持一致,否则父数组仍是 flow
else throw new Error('配置项 ' + docPath.join('.') + ' 不是数组,无法追加'); target.add(item);
} else doc.setIn(docPath, e.value); } else if (target === null || target === undefined) {
const seq = doc.createNode([]);
seq.flow = false;
seq.add(item);
doc.setIn(docPath, seq);
} else throw new Error('配置项 ' + docPath.join('.') + ' 不是数组,无法追加');
continue;
}
const node = styledNode(doc, e.value, false);
// 直接写参数键(整对象 set)时也要 flow
if (FLOW_PARAM_KEYS.has(String(docPath[docPath.length - 1])) &&
node && typeof node === 'object' && !YAML.isScalar(node)) node.flow = true;
doc.setIn(docPath, node);
} }
return doc.toString(); return doc.toString();
} }
+49 -5
View File
@@ -1,4 +1,4 @@
// 单文件下载响应的公共实现:任务文件的浏览器下载(routes/files.js)与公网临时文件 // 单文件下载 / 内联响应的公共实现:任务文件的浏览器下载(routes/files.js)、公网临时文件
// (routes/public-files.js)共用,避免两处各写一套文件名/缓存策略。 // (routes/public-files.js)共用,避免两处各写一套文件名/缓存策略。
'use strict'; 'use strict';
@@ -9,13 +9,37 @@ const path = require('path');
// 老 AOSP DownloadManager 的正则解析失败而改从 URL 猜名(download.pdf)。 // 老 AOSP DownloadManager 的正则解析失败而改从 URL 猜名(download.pdf)。
// 这里传统 filename= 直接放百分号编码的 UTF-8:朴素解析器解码后能得到真名, // 这里传统 filename= 直接放百分号编码的 UTF-8:朴素解析器解码后能得到真名,
// 标准客户端照旧优先 filename*(RFC 5987)。 // 标准客户端照旧优先 filename*(RFC 5987)。
function downloadDisposition(name) { function contentDisposition(name, type) {
const legacy = encodeURIComponent(name); const legacy = encodeURIComponent(name);
// RFC 5987 attr-char 不含 ' ( ) ! *,ext-value 里需额外编码 // RFC 5987 attr-char 不含 ' ( ) ! *,ext-value 里需额外编码
const ext = legacy.replace(/['()!*]/g, function (c) { const ext = legacy.replace(/['()!*]/g, function (c) {
return '%' + c.charCodeAt(0).toString(16).toUpperCase(); return '%' + c.charCodeAt(0).toString(16).toUpperCase();
}); });
return 'attachment; filename="' + legacy + '"; filename*=UTF-8\'\'' + ext; return type + '; filename="' + legacy + '"; filename*=UTF-8\'\'' + ext;
}
function downloadDisposition(name) {
return contentDisposition(name, 'attachment');
}
// 内联图片判定:只看扩展名,不读文件头——公网端点不做内容嗅探,也不该为了“猜类型”整包读文件。
// svg 也算:浏览器只有拿到 image/svg+xml 才会渲染而不是下载(脚本风险由下面的 CSP sandbox 兜住)。
const INLINE_IMAGE_TYPES = new Map([
['.png', 'image/png'],
['.jpg', 'image/jpeg'],
['.jpeg', 'image/jpeg'],
['.webp', 'image/webp'],
['.gif', 'image/gif'],
['.bmp', 'image/bmp'],
['.tif', 'image/tiff'],
['.tiff', 'image/tiff'],
['.avif', 'image/avif'],
['.ico', 'image/x-icon'],
['.svg', 'image/svg+xml'],
]);
function inlineImageType(abs) {
return INLINE_IMAGE_TYPES.get(path.extname(String(abs || '')).toLowerCase()) || null;
} }
// 下载统一响应:禁用一切缓存协商。 // 下载统一响应:禁用一切缓存协商。
@@ -23,12 +47,32 @@ function downloadDisposition(name) {
// 先发条件请求拿 304 空体,下载管理器随后卡在“等待中”(桌面 Safari/curl 不受影响)。 // 先发条件请求拿 304 空体,下载管理器随后卡在“等待中”(桌面 Safari/curl 不受影响)。
// 不能用 res.download:它会用 content-disposition 包覆盖上面的文件名策略; // 不能用 res.download:它会用 content-disposition 包覆盖上面的文件名策略;
// res.sendFile 不设置 Content-Disposition,Content-Type 按扩展名自动出,Range 由 send 支持。 // res.sendFile 不设置 Content-Disposition,Content-Type 按扩展名自动出,Range 由 send 支持。
function sendDownload(res, abs) { function noStore(res) {
res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate'); res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
res.setHeader('Pragma', 'no-cache'); res.setHeader('Pragma', 'no-cache');
res.setHeader('Expires', '0'); res.setHeader('Expires', '0');
}
function sendDownload(res, abs) {
noStore(res);
res.setHeader('Content-Disposition', downloadDisposition(path.basename(abs))); res.setHeader('Content-Disposition', downloadDisposition(path.basename(abs)));
res.sendFile(abs, { lastModified: false, etag: false, maxAge: 0 }); res.sendFile(abs, { lastModified: false, etag: false, maxAge: 0 });
} }
module.exports = { downloadDisposition, sendDownload }; // 内联图片响应(公网链 GET /p/<id> 的图片分支):点开链接直接显示,不再被当成附件下载。
// 安卓封装壳 / WebView 对 attachment 一律交系统下载器,图片外链因此“只下载、不打开”;
// inline + 明确的 image/* 才走渲染路径。缓存仍 no-store:/p/<id> 是短命 bearer 链,
// 不该被中间缓存留副本(与下载同语义)。
function sendInlineImage(res, abs, type) {
noStore(res);
res.setHeader('Content-Type', type);
res.setHeader('X-Content-Type-Options', 'nosniff');
res.setHeader('Content-Disposition', contentDisposition(path.basename(abs), 'inline'));
// SVG 是唯一能带脚本的“图片”,而 /p/ 是匿名同源端点:直接打开会以本应用身份执行脚本。
// sandbox 不给 allow-scripts,退化成不可执行、无同源权限的文档;<img> 引用本就不执行脚本,不受影响。
if (type === 'image/svg+xml') res.setHeader('Content-Security-Policy', 'sandbox');
// dotfiles 显式放行:read_file 的压缩产物在 .imgcache/(点目录),默认策略对其他调用方不保证。
res.sendFile(abs, { dotfiles: 'allow', lastModified: false, etag: false, maxAge: 0 });
}
module.exports = { contentDisposition, downloadDisposition, sendDownload, sendInlineImage, inlineImageType };
+250 -11
View File
@@ -16,6 +16,13 @@ const TOOL_DEFINITIONS = require('./tools/definitions.json');
let cfg, db, bus; let cfg, db, bus;
const runs = new Map(); // session_id -> {cancelled, procs:Set, abortController, looping:boolean} const runs = new Map(); // session_id -> {cancelled, procs:Set, abortController, looping:boolean}
const titling = new Set(); // 正在生成标题的会话(防重入;标题落库后靠 title 非空自然不再触发) const titling = new Set(); // 正在生成标题的会话(防重入;标题落库后靠 title 非空自然不再触发)
// 待投递消息队列:session_id -> [{id, content, deepThink, mode, created_at}]
// 铁律:队列里的消息**绝不先落 messages 表**,只在「安全边界」写入并成为模型下一轮输入:
// ① 工具批次闭合(本批每个 tool_call_id 都有回执);② 无 tool_calls 的回复已落库;
// ③ 回合 finalize(循环已退、没有在跑的工具)。
// 原因:tool 回执必须紧跟带 tool_calls 的 assistant,user 行插进批次中间、或批次没闭合就收尾,
// 都会让上游拒收整个请求(tool_call 配对)。进程内内存态(同 runs),重启即丢,不跨实例共享。
const pendings = new Map();
// ---------- 小工具 ---------- // ---------- 小工具 ----------
const now = () => Date.now(); const now = () => Date.now();
@@ -142,6 +149,8 @@ function emitStatus(sessionId) {
session_id: sessionId, session_id: sessionId,
status: s.status, status: s.status,
model_id: s.model_id, model_id: s.model_id,
// 待投递队列一并带上:前端把条幅当成服务端状态的回显,重连/换设备后自动对齐
pending: listPending(sessionId),
}); });
} }
@@ -456,6 +465,48 @@ function killRunProcs(run) {
run.procs.clear(); run.procs.clear();
} }
// 关闭当前工具批次:给「最后一条带 tool_calls 的 assistant」里还没有回执的调用补合成 tool 行。
// 上游硬约束:assistant.tool_calls 必须逐个配 tool 消息,缺一条整个请求被拒(400)。
// 触发点:取消(含「立即发送」硬中断)、干预跳过同批剩余调用、finalize 兜底(异常退出)。
// 只在批次尾部补:若最后一条非 tool 行已经是 user(历史遗留脏数据、user 插在批次中间),
// 补在后面会造成顺序错乱,交给 llm.buildMessages 的读侧配对过滤处理。
// reason 是一句以冒号结尾的前缀,拼成模型能读懂的「为什么没执行」。
function closeToolBatch(sessionId, reason) {
// 会话已被删除(用户在工具执行中删了会话):不再往库里补行,否则留下无法归属的孤儿行。
if (!getSession(sessionId)) return 0;
// 只取最后一条非 tool 行 + 它之后的回执 id:走 idx_messages_session,不载全量历史
//(finalize 每回合都会调一次,长会话下 loadHistory 太贵)。
const last = db.prepare(
"SELECT id, role, tool_calls FROM messages WHERE session_id = ? AND role != 'tool' ORDER BY id DESC LIMIT 1"
).get(sessionId);
if (!last || last.role !== 'assistant') return 0; // 最后一条非 tool 行不是 assistant:不是当前批次
if (!last.tool_calls) return 0; // 收尾回复:批次已经闭合
let calls = [];
try { calls = JSON.parse(last.tool_calls) || []; } catch (_) { return 0; }
if (!calls.length) return 0;
const got = new Set(
db.prepare(
"SELECT tool_call_id FROM messages WHERE session_id = ? AND role = 'tool' AND id > ? AND tool_call_id IS NOT NULL AND tool_call_id != ''"
).all(sessionId, last.id).map(r => r.tool_call_id)
);
let n = 0;
for (const c of calls) {
if (!c || !c.id || got.has(c.id)) continue;
const name = (c.function && c.function.name) || '未知工具';
const text = 'Error: ' + reason + '本次调用未执行(' + name + ')。';
const msgId = saveMessage(sessionId, { role: 'tool', tool_call_id: c.id, name, content: text, is_error: true });
// 同步广播:前端工具卡不能停在「调用中」呼吸态。
// skipped:这不是工具自己失败,而是用户介入导致没执行——微信端据此不报
// 「工具调用失败」、不计入失败数(否则一次干预会换来一串误导性告警)。
bus.emit(sessionId, 'tool_result', {
tool_call_id: c.id, name, content: text, is_error: true, skipped: true, msg_id: msgId,
});
n++;
}
if (n) log.info('tool', sessionId + ' 补齐 ' + n + ' 条未执行调用的合成回执(' + reason + ')');
return n;
}
// ---------- Agent 主循环 ---------- // ---------- Agent 主循环 ----------
async function runLoop(sessionId) { async function runLoop(sessionId) {
const run = getRun(sessionId, true); const run = getRun(sessionId, true);
@@ -481,22 +532,34 @@ function finalize(sessionId, run) {
const s = getSession(sessionId); const s = getSession(sessionId);
if (!s || s.status !== 'active') { runs.delete(sessionId); return; } if (!s || s.status !== 'active') { runs.delete(sessionId); return; }
const cancelled = run.cancelled; const cancelled = run.cancelled;
// 兜底:回合结束时本批 tool_call 必须逐个有回执。取消/异常/进程被杀都可能留下半批,
// 缺的补一条「未执行」合成回执——这是「工具调用不匹配」的唯一根治点。
try { closeToolBatch(sessionId, cancelled ? (run.interruptReason || '用户已终止任务:') : '回合异常结束:'); }
catch (e) { log.warn('tool', sessionId + ' 关闭工具批次失败:' + (e && e.message || e)); }
if (cancelled) { if (cancelled) {
touch(sessionId, { status: 'cancelled', cancelled_at: now(), completed_at: null }); touch(sessionId, { status: 'cancelled', cancelled_at: now(), completed_at: null });
runs.delete(sessionId); runs.delete(sessionId);
bus.emit(sessionId, 'done', { status: 'cancelled' }); bus.emit(sessionId, 'done', { status: 'cancelled' });
emitStatus(sessionId); emitStatus(sessionId);
return; } else {
// 正常结束:进入 held,绑定保持(key 非独占、无租约,不再自动到期);用户追问直接复用模型,唯一出口是手动「断开」。
touch(sessionId, { status: 'held', held_at: now(), completed_at: null, cancelled_at: null });
runs.delete(sessionId);
bus.emit(sessionId, 'done', { status: 'held' });
emitStatus(sessionId);
maybeGenerateTitle(sessionId, s, run);
// 定时即下班:本回合创建过定时任务 → done 广播后收口(attachBus 监听已在 done 回调里同步捕获绑定入队投递,
// 此时删绑定不影响微信本次回复送达)。
if (run.taskWrap) taskClockOut(sessionId);
}
// 队首待投递消息:回合已收尾(循环已退、批次已闭合),这是排队模式唯一的安全出口。
// setImmediate 让 finalize 所在的 finally 先跑完(maybeAutoCompress 会读状态),再开新一轮。
if (headPending(sessionId)) {
setImmediate(() => {
try { deliverPendingHead(sessionId); }
catch (e) { log.warn('msg', sessionId + ' 待投递消息发送失败:' + (e && e.message || e)); }
});
} }
// 正常结束:进入 held,绑定保持(key 非独占、无租约,不再自动到期);用户追问直接复用模型,唯一出口是手动「断开」。
touch(sessionId, { status: 'held', held_at: now(), completed_at: null, cancelled_at: null });
runs.delete(sessionId);
bus.emit(sessionId, 'done', { status: 'held' });
emitStatus(sessionId);
maybeGenerateTitle(sessionId, s, run);
// 定时即下班:本回合创建过定时任务 → done 广播后收口(attachBus 监听已在 done 回调里同步捕获绑定入队投递,
// 此时删绑定不影响微信本次回复送达)。
if (run.taskWrap) taskClockOut(sessionId);
} }
// 自动生成标题:每回合结束(finalize 成功分支)过门槛才触发,fire-and-forget 不阻塞收尾。 // 自动生成标题:每回合结束(finalize 成功分支)过门槛才触发,fire-and-forget 不阻塞收尾。
@@ -736,6 +799,13 @@ async function runLoopInner(sessionId, run) {
} }
if (!hasTools) { if (!hasTools) {
// 「干预」升级过的待投递消息:本条回复已落库,正是安全边界——直接插话并继续同一回合
//(不用等 finalize 再开新一轮,模型能接着刚才的上下文改弦更张)。
const head = headPending(sessionId);
if (head && head.mode === 'interject') {
deliverPendingHead(sessionId);
continue;
}
// 回合结束;但若期间用户又发了新消息(live 投递),继续下一轮而不是收尾 // 回合结束;但若期间用户又发了新消息(live 投递),继续下一轮而不是收尾
if (!hasUserSince(sessionId, lastIncludedId)) break; if (!hasUserSince(sessionId, lastIncludedId)) break;
continue; continue;
@@ -743,8 +813,19 @@ async function runLoopInner(sessionId, run) {
// 执行工具 // 执行工具
const vision = modelVision(session); const vision = modelVision(session);
// 干预(整批还没开跑):一个工具都不执行,整批补「未执行」回执后立刻插话。
// 顺序不能反:必须先闭合批次(写完全部 tool 回执)再写 user 行,否则 user 会夹在
// assistant.tool_calls 与 tool 回执之间,上游直接拒收。
const headBeforeBatch = headPending(sessionId);
if (headBeforeBatch && headBeforeBatch.mode === 'interject') {
closeToolBatch(sessionId, '用户已介入并要求中止:');
deliverPendingHead(sessionId);
iter++;
continue;
}
// 标题门槛信号:本批参数预检通过并真实执行 = 会话在干实事(finalize 据此判是否立题, // 标题门槛信号:本批参数预检通过并真实执行 = 会话在干实事(finalize 据此判是否立题,
// 见 maybeGenerateTitle);errAck 批(参数畸形、下轮整轮对模型不可见)不算。 // 见 maybeGenerateTitle);errAck 批(参数畸形、下轮整轮对模型不可见)不算,
// 被干预整批跳过(上面已 continue)也不计。
if (!isErrAck) run.toolWorked = true; if (!isErrAck) run.toolWorked = true;
for (const tc of msgRow.tool_calls) { for (const tc of msgRow.tool_calls) {
if (run.cancelled) break; if (run.cancelled) break;
@@ -837,7 +918,18 @@ async function runLoopInner(sessionId, run) {
image_url: imageRel ? '/api/sessions/' + encodeURIComponent(sessionId) + '/files/download?path=' + encodeURIComponent(imageRel) : undefined, image_url: imageRel ? '/api/sessions/' + encodeURIComponent(sessionId) + '/files/download?path=' + encodeURIComponent(imageRel) : undefined,
msg_id: toolMsgId, msg_id: toolMsgId,
}); });
// 干预(当前工具已跑完、回执已落库):同批剩余调用不再执行,闭合批次后立刻插话。
// 不杀进程——这就是「干预」与「立即发送」的唯一区别。
const headAfterTool = headPending(sessionId);
if (headAfterTool && headAfterTool.mode === 'interject') {
closeToolBatch(sessionId, '用户已介入并要求中止:');
deliverPendingHead(sessionId);
break;
}
} }
// 取消(含「立即发送」硬中断):本批还没跑到的调用补合成回执,否则库里留下
// 「有调用无回执」的孤儿行,下一轮请求必被上游拒收(本次顺手修掉的存量 bug)。
if (run.cancelled) closeToolBatch(sessionId, run.interruptReason || '用户已终止任务:');
iter++; iter++;
} }
if (iter >= maxIter && !run.cancelled) { if (iter >= maxIter && !run.cancelled) {
@@ -1058,6 +1150,143 @@ function createSession(title, preferModelId, assistantType, user) {
return session; return session;
} }
// ---------- 待投递消息(排队 / 干预 / 立即发送) ----------
// 三种模式的差别只在「何时写库」,写库之前一律躺在 pendings 里(见文件头注释的铁律):
// queue → 本轮 finalize 后投递(默认;浏览器关了也照发,因为队列在服务端)
// interject → 当前工具批次闭合 / 本条回复落库后立即投递,同一回合内让模型看到
// now → 硬中断(杀进程 + abort 流,本回合判 cancelled),收尾后立刻投递
// 只允许升级队首:越过后面的消息先发会让对话顺序不可解释(前端也只有队首有这两个按钮)。
function newPendingId() {
return 'q_' + Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
}
function publicPending(it) {
return { id: it.id, content: it.content, mode: it.mode, created_at: it.created_at };
}
function pendingList(sessionId) {
return pendings.get(sessionId) || [];
}
function headPending(sessionId) {
const list = pendings.get(sessionId);
return list && list.length ? list[0] : null;
}
function listPending(sessionId) {
return pendingList(sessionId).map(publicPending);
}
// 清空队列(用户点「停止」、删会话、清空会话):逐条广播,前端条幅随之消失。
function clearPendings(sessionId) {
const list = pendings.get(sessionId);
if (!list || !list.length) return 0;
pendings.delete(sessionId);
for (const it of list) bus.emit(sessionId, 'pending_removed', { id: it.id, reason: 'cancelled' });
log.info('msg', sessionId + ' 清空待投递消息 ' + list.length + ' 条');
return list.length;
}
// 入队。没有在跑的回合时,任何模式都等价于立即发送(队列只对运行中的回合有意义)。
// opts.mode:
// queue(默认)→ 排到队尾,本轮收尾后发(网页端发消息走这条)
// interject → 插队到所有 queue 之前,下一个安全边界就投递(IM/渠道消息走这条:
// 用户是在实时对话,不应该排在网页端被动排队的消息后面)
function enqueueMessage(sessionId, content, opts) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
const text = String(content == null ? '' : content).trim();
if (!text) throw Object.assign(new Error('content 不能为空'), { status_code: 400 });
const mode = (opts && opts.mode) === 'interject' ? 'interject' : 'queue';
const run = runs.get(sessionId);
if (!run || !run.looping) {
const r = postUserMessage(sessionId, text, { deepThink: !!(opts && opts.deepThink) });
return { message_id: r.message_id, delivered: r.delivered, pending: [] };
}
const item = {
id: newPendingId(), content: text,
deepThink: !!(opts && opts.deepThink), mode, created_at: now(),
};
const list = pendingList(sessionId).slice();
if (mode === 'interject') {
// 插到第一条「排队」消息之前;已在队列里的干预消息仍保持先来后到(不反序)。
const i = list.findIndex(x => x.mode === 'queue');
if (i < 0) list.push(item); else list.splice(i, 0, item);
} else {
list.push(item);
}
pendings.set(sessionId, list);
bus.emit(sessionId, 'pending_added', publicPending(item));
log.info('msg', sessionId + ' 待投递消息入队(' + mode + ',队列 ' + list.length + '):' + text.slice(0, 60).replace(/\s+/g, ' '));
return { pending_id: item.id, queued: true, pending: list.map(publicPending) };
}
// 升级队首:interject(跑完当前这一步就插话) / now(立刻中断本轮)。
// 回合已经结束(没在跑)时直接投递——用户点按钮时恰好收尾,不该把消息卡在队列里。
function promotePending(sessionId, qid, action) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
const list = pendingList(sessionId);
const idx = list.findIndex(x => x.id === qid);
if (idx < 0) throw Object.assign(new Error('待发送消息不存在'), { status_code: 404 });
if (idx !== 0) throw Object.assign(new Error('只能升级队首消息:前面的消息还没发出去'), { status_code: 409 });
const run = runs.get(sessionId);
if (!run || !run.looping) {
deliverPendingHead(sessionId);
return { ok: true, delivered: true, pending: listPending(sessionId) };
}
const item = list[0];
if (action === 'now') {
item.mode = 'now';
bus.emit(sessionId, 'pending_added', publicPending(item)); // 前端按 id upsert,按钮态跟着变
run.interruptReason = '用户选择立即发送:';
run.cancelled = true;
killRunProcs(run);
if (run.abortController) { try { run.abortController.abort(); } catch (_) {} }
log.info('msg', sessionId + ' 立即发送:中断当前回合,收尾后投递队首');
} else {
item.mode = 'interject';
bus.emit(sessionId, 'pending_added', publicPending(item));
log.info('msg', sessionId + ' 干预:等待当前工具/回复结束后插话');
}
return { ok: true, pending: listPending(sessionId) };
}
// 取消队列里的一条(条幅上的 ×)。任意一条都可删:删队首后剩下的自然顺延,顺序仍是 FIFO。
function cancelPending(sessionId, qid) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
const list = pendingList(sessionId);
const idx = list.findIndex(x => x.id === qid);
if (idx < 0) throw Object.assign(new Error('待发送消息不存在'), { status_code: 404 });
const next = list.slice();
next.splice(idx, 1);
if (next.length) pendings.set(sessionId, next); else pendings.delete(sessionId);
bus.emit(sessionId, 'pending_removed', { id: qid, reason: 'cancelled' });
log.info('msg', sessionId + ' 取消待投递消息 ' + qid);
return { ok: true, pending: next.map(publicPending) };
}
// 投递队首:写库 + 广播。调用方必须已保证处在安全边界(批次已闭合 / 回合已收尾)。
// 落库走 postUserMessage:正在跑时它是 live 追加(下一轮迭代自动带上),没在跑时直接开新一轮。
function deliverPendingHead(sessionId) {
const list = pendingList(sessionId);
if (!list.length) return null;
const item = list[0];
const next = list.slice(1);
if (next.length) pendings.set(sessionId, next); else pendings.delete(sessionId);
const r = postUserMessage(sessionId, item.content, { deepThink: item.deepThink });
const row = db.prepare('SELECT created_at FROM messages WHERE id = ?').get(r.message_id);
bus.emit(sessionId, 'pending_removed', { id: item.id, reason: 'delivered' });
// 排队期间前端不画这条消息(它还不是历史),落库这一刻才画
bus.emit(sessionId, 'user_message', {
id: r.message_id, content: item.content,
created_at: (row && row.created_at) || item.created_at, pending_id: item.id,
});
log.info('msg', sessionId + ' 待投递消息已送达(原模式 ' + item.mode + ',剩余 ' + next.length + ' 条)');
return r;
}
// 用户消息入口:不再排队——任意非 looping 状态都是「拿模型立即开跑」(delivered 恒 live); // 用户消息入口:不再排队——任意非 looping 状态都是「拿模型立即开跑」(delivered 恒 live);
// 绑定失效(配置改动后原模型被删/禁用)由 ensureBinding 自动改选,用户无感。 // 绑定失效(配置改动后原模型被删/禁用)由 ensureBinding 自动改选,用户无感。
// opts.deepThink: true 时启用模型该「深度思考」参数(记在会话 run 上,正在跑的回合下一轮迭代会取到最新值)。 // opts.deepThink: true 时启用模型该「深度思考」参数(记在会话 run 上,正在跑的回合下一轮迭代会取到最新值)。
@@ -1088,9 +1317,13 @@ function postUserMessage(sessionId, content, opts) {
function stop(sessionId) { function stop(sessionId) {
const session = getSession(sessionId); const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 }); if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
// 「停止」= 全停:待投递队列一并作废。否则 finalize 会立刻把队首当成新回合发出去,
// 与用户按停止的意图相反(「立即发送」不走这里,它只中断当前回合、保留队首)。
clearPendings(sessionId);
const run = runs.get(sessionId); const run = runs.get(sessionId);
if (run) { if (run) {
run.cancelled = true; run.cancelled = true;
run.interruptReason = '用户已终止任务:';
killRunProcs(run); killRunProcs(run);
if (run.abortController) { try { run.abortController.abort(); } catch (_) {} } if (run.abortController) { try { run.abortController.abort(); } catch (_) {} }
} }
@@ -1415,6 +1648,7 @@ function clearSessionMessages(sessionId) {
if (run.abortController) { try { run.abortController.abort(); } catch (_) {} } if (run.abortController) { try { run.abortController.abort(); } catch (_) {} }
} }
runs.delete(sessionId); runs.delete(sessionId);
clearPendings(sessionId); // 历史清零:队列里的消息也没了着落,一并作废
db.prepare('DELETE FROM messages WHERE session_id = ?').run(sessionId); db.prepare('DELETE FROM messages WHERE session_id = ?').run(sessionId);
wipeSessionTmp(sessionId); // 会话级 /tmp 随清空一并抹掉(尽力而为,失败只记日志不阻断) wipeSessionTmp(sessionId); // 会话级 /tmp 随清空一并抹掉(尽力而为,失败只记日志不阻断)
autoCompressProposed.delete(sessionId); // 历史清零,恢复自动压缩提议额度 autoCompressProposed.delete(sessionId); // 历史清零,恢复自动压缩提议额度
@@ -1523,6 +1757,10 @@ module.exports = {
activeRuns, activeRuns,
createSession, createSession,
postUserMessage, postUserMessage,
enqueueMessage,
promotePending,
cancelPending,
listPending,
stop, stop,
releaseHold, releaseHold,
renameSession, renameSession,
@@ -1537,6 +1775,7 @@ module.exports = {
loadHistory, loadHistory,
checkToolArgs, // 参数预检/信封解包两个纯函数:导出供探针与回归验证(运行链路由 runLoopInner 内部调用) checkToolArgs, // 参数预检/信封解包两个纯函数:导出供探针与回归验证(运行链路由 runLoopInner 内部调用)
unwrapToolArgs, unwrapToolArgs,
closeToolBatch, // 批次闭合兜底:导出供回归验证(正常链路由 runLoopInner / finalize 调用)
saveMessage, saveMessage,
recordModelUsage, recordModelUsage,
modelUsageStats, modelUsageStats,
+126 -39
View File
@@ -198,19 +198,26 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
const ids = new Set(history.map(r => r.id)); const ids = new Set(history.map(r => r.id));
for (const k of Array.from(session.blocksCache.keys())) if (!ids.has(k)) session.blocksCache.delete(k); for (const k of Array.from(session.blocksCache.keys())) if (!ids.has(k)) session.blocksCache.delete(k);
} }
// 裁剪预扫:① 每行距尾的 assistant 轮数(从尾往头扫);② tool_call id → function // 裁剪预扫:① 每行距尾的 assistant 轮数(rounds)与真人回合数(turns),一趟从尾往头扫;
// (给 fetch/read_file 占位回填 url/path)。trimOn=false 时整个跳过(压缩回合)。 // ② tool_call id → function(result 侧规则需要反查工具名)。
const trimActive = trimOn !== false && (TRIM.writeRounds > 0 || TRIM.resultRounds > 0); // turns 只数「真实用户消息」(role=user 且 type 为空):channel_note / memory_note 这类注入行
// 不是回合边界(与 engine 立题同口径),数进去会让回合数虚高、提前裁掉本回合的内容。
// trimOn=false(压缩回合)或没配规则时整个跳过。
const trimActive = trimOn !== false && (TRIM.argsByTool.size > 0 || TRIM.resultByTool.size > 0);
const roundsAfter = new Map(); const roundsAfter = new Map();
const turnsAfter = new Map();
const callById = new Map(); const callById = new Map();
if (trimActive) { if (trimActive) {
let n = 0; let n = 0;
let t = 0;
for (let i = history.length - 1; i >= 0; i--) { for (let i = history.length - 1; i >= 0; i--) {
const r = history[i]; const r = history[i];
roundsAfter.set(r.id, n); roundsAfter.set(r.id, n);
turnsAfter.set(r.id, t);
if (r.role === 'user' && r.type == null) t++;
if (r.role === 'assistant' && r.type !== 'archived' && r.type !== 'errAck') n++; if (r.role === 'assistant' && r.type !== 'archived' && r.type !== 'errAck') n++;
} }
if (TRIM.resultRounds > 0) { if (TRIM.resultByTool.size > 0) {
for (const r of history) { for (const r of history) {
if (r.role !== 'assistant' || !r.tool_calls) continue; if (r.role !== 'assistant' || !r.tool_calls) continue;
try { for (const c of JSON.parse(r.tool_calls) || []) if (c && c.id && c.function) callById.set(c.id, c.function); } catch (_) {} try { for (const c of JSON.parse(r.tool_calls) || []) if (c && c.id && c.function) callById.set(c.id, c.function); } catch (_) {}
@@ -219,7 +226,33 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
} }
// tool 回执按 tool_call_id 索引:给 errAck 行拼错误提示时取执行时挡下的原因 // tool 回执按 tool_call_id 索引:给 errAck 行拼错误提示时取执行时挡下的原因
const toolRowById = new Map(); const toolRowById = new Map();
for (const row of history) if (row.role === 'tool' && row.tool_call_id) toolRowById.set(row.tool_call_id, row); // 只收「会下发」的回执:archived 行不进模型,不能拿它当配对凭据
//(否则 assistant 的调用被保留、回执却被跳过,上游照样拒收)。
for (const row of history) {
if (row.role !== 'tool' || !row.tool_call_id || row.type === 'archived') continue;
toolRowById.set(row.tool_call_id, row);
}
// 已下发的 tool_call id 集合:tool 行按它反查自己有没有「主」。
// 与下面的调用侧过滤合成「读侧配对兜底」:库里的孤儿行(旧版本中途终止留下的有调用无回执、
// 或历史被外部改动)一律不进请求——严格上游对配对是硬约束,缺一条整请求被拒。
// 只影响发给模型的那一份,DB 与 UI 完全不动。
const emittedCallIds = new Set();
// 预扫:每条带 tool_calls 的 assistant「紧跟着它的那批回执」里真实存在的 call id。
// 只往下扫连续的 tool 行,遇到 user/assistant 就停——上游要求 tool 回执紧跟在
// 带 tool_calls 的 assistant 后面,中间夹任何消息(旧版 live 追投就可能把 user 插进来)
// 都会让整批非法。所以不能拿「全库里有这条回执」当配对凭据。
const pairedByAssistant = new Map(); // assistant 行 id -> Set(call_id)
for (let i = 0; i < history.length; i++) {
const r = history[i];
if (r.role !== 'assistant' || !r.tool_calls) continue;
const ids = new Set();
for (let j = i + 1; j < history.length && history[j].role === 'tool'; j++) {
// archived 回执不进模型,不能当作「已答复」凭据(否则调用被保留、回执被跳过)
if (history[j].type === 'archived') continue;
if (history[j].tool_call_id) ids.add(history[j].tool_call_id);
}
pairedByAssistant.set(r.id, ids);
}
// 「已消费」分界 = 最后一条**写过文本**的 assistant 行(不要求无 tool_calls): // 「已消费」分界 = 最后一条**写过文本**的 assistant 行(不要求无 tool_calls):
// 描述写在 content 里 + 继续调工具,就是模型真看到图的证据(见文件头注释的循环复盘)。 // 描述写在 content 里 + 继续调工具,就是模型真看到图的证据(见文件头注释的循环复盘)。
// errAck / archived 不发模型,不算回复:它们之前的图不算被消费。 // errAck / archived 不发模型,不算回复:它们之前的图不算被消费。
@@ -293,8 +326,20 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
// reasoning_ack_field 改名注入后此键必被剥除,不会泄往上游)。 // reasoning_ack_field 改名注入后此键必被剥除,不会泄往上游)。
if (row.reasoning) m.__reasoning = row.reasoning; if (row.reasoning) m.__reasoning = row.reasoning;
if (row.tool_calls) { if (row.tool_calls) {
m.tool_calls = JSON.parse(row.tool_calls); let calls = [];
if (trimActive && TRIM.writeRounds > 0) trimWriteCalls(m.tool_calls, roundsAfter.get(row.id) || 0); try { calls = JSON.parse(row.tool_calls) || []; } catch (_) { calls = []; }
// 配对兜底(读侧):只下发本批确有回执的调用。旧版本中途终止、外部工具异常、
// user 行插进批次中间,都会留下无法配对的调用,严格上游会拒收整个请求。
const pairedIds = pairedByAssistant.get(row.id) || new Set();
const paired = calls.filter(c => c && c.id && pairedIds.has(c.id));
if (!paired.length) {
// 整轮调用都没回执:纯工具轮整行不发;带正文的保留为普通文本回复
if (!String(m.content || '').trim()) return;
} else {
m.tool_calls = paired;
for (const c of paired) emittedCallIds.add(c.id);
if (trimActive && TRIM.argsByTool.size > 0) trimToolCallArgs(m.tool_calls, roundsAfter.get(row.id) || 0, turnsAfter.get(row.id) || 0);
}
} }
if (!m.content) delete m.content; if (!m.content) delete m.content;
messages.push(m); messages.push(m);
@@ -302,6 +347,8 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
} }
// errAck 轮的 tool 回执:随该轮一起丢弃,避免无主 tool 消息 // errAck 轮的 tool 回执:随该轮一起丢弃,避免无主 tool 消息
if (row.role === 'tool' && dropToolCallIds.has(row.tool_call_id)) return; if (row.role === 'tool' && dropToolCallIds.has(row.tool_call_id)) return;
// 孤儿 tool 回执(调用行被过滤/存档/errAck 丢弃):单独下发必被上游拒收,直接跳过
if (row.role === 'tool' && !emittedCallIds.has(row.tool_call_id)) return;
// tool/user 行:含图哨兵 JSON 还原为内容块(解析结果按行 id 缓存);已消费的图只留文字描述 + 标记 // tool/user 行:含图哨兵 JSON 还原为内容块(解析结果按行 id 缓存);已消费的图只留文字描述 + 标记
const blocks = cachedDecodeBlocks(session, row); const blocks = cachedDecodeBlocks(session, row);
let content = row.content || ''; let content = row.content || '';
@@ -354,7 +401,7 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
} }
} }
if (row.role === 'tool') { if (row.role === 'tool') {
if (trimActive && typeof content === 'string') content = trimToolContent(content, row, callById, roundsAfter); if (trimActive && typeof content === 'string') content = trimToolContent(content, row, callById, roundsAfter, turnsAfter);
messages.push({ role: 'tool', tool_call_id: row.tool_call_id, name: row.name, content }); messages.push({ role: 'tool', tool_call_id: row.tool_call_id, name: row.name, content });
} else { } else {
messages.push({ role: row.role, content }); messages.push({ role: row.role, content });
@@ -382,46 +429,86 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
} }
// ---------- 重负载占位裁剪(历史重放省 token) ---------- // ---------- 重负载占位裁剪(历史重放省 token) ----------
// fetch/read_file 回执与 write_file 参数正文是重放里最贵的存量,且都可再生:文件在盘上、 // 策略只在配置里:默认值来自 config.js 的 DEFAULTS.agent.trim.rules,config.yml 写了
// 页面可重抓;write 参数只是当时快照(后续 edit_file 一次就失真,本就不该被当现势引用)。 // agent.trim.rules 就整体替换([] = 全关)。本模块不含任何工具名或默认阈值;未注入 = 不裁剪。
// 组装请求时对「距尾 ≥N 个 assistant 轮」的行换单行占位:纯函数、DB 不动(UI 工具卡照旧 // 语义:某条工具调用/回执距对话尾部 ≥rounds 个 assistant 轮**且** ≥turns 个真人回合后,把其中
// 可展全量)、与压缩归档正交(archived 行本来就不进模型)。距离按现存行数 assistant 轮: //「可再生的重负载」——args 侧指定参数正文、result 侧整段回执——换成单行占位再发给上游。
// 删中间消息可让已占位行短暂复活全文(一次性断前缀缓存,与图片消费 i<lastAck 同一 // rounds = 「后面 AI 又说了几句话」,turns = 「后面又来了几条真人消息」;
// 语义,接受)。阈值可配(config agent.trim_write_rounds / trim_result_rounds,0=关), // turns:1 就是「回合内绝不裁,跨过用户回合边界才裁」(长回合里防模型反复重读同一段)。
// 启动时 setPayloadTrim 注入。 // 只应给可再生/快照型工具开规则:占位只改发给上游的副本(DB/UI 照旧可看全量),但模型侧
let TRIM = { writeRounds: 1, resultRounds: 2 }; // 一旦被裁就再也看不到那段内容(如 terminal 的一次性输出)。
const TRIM_MIN_CHARS = 600; // 短正文不裁:占位行自身成本接近原文,裁了反而胀 // 纯函数、与压缩归档正交(archived 行本来就不进模型)。距离按现存行数:删中间消息可让已占位行
function setPayloadTrim(agentCfg) { // 短暂复活全文(一次性断前缀缓存,与图片消费 i<lastAck 同一语义,接受)。
const a = agentCfg || {}; function compileTrimRules(rules) {
const toN = (v, d) => { const n = Math.floor(Number(v)); return Number.isFinite(n) ? Math.max(0, n) : d; }; const argsByTool = new Map();
TRIM = { writeRounds: toN(a.trim_write_rounds, 1), resultRounds: toN(a.trim_result_rounds, 2) }; const resultByTool = new Map();
for (const r of rules || []) {
if (!r || !r.tool) continue;
const rounds = Math.max(0, Math.floor(Number(r.rounds)) || 0);
const turns = Math.max(0, Math.floor(Number(r.turns)) || 0);
// 两个距离都写 0 = 规则关闭(config.js 归一化时已丢弃,这里兼容手搓 cfg)
if (rounds <= 0 && turns <= 0) continue;
const rule = {
rounds,
turns,
minChars: Math.max(0, Math.floor(Number(r.min_chars)) || 0),
fields: Array.isArray(r.fields) ? r.fields.map(String) : [],
statusRe: null,
};
if (r.side === 'result' && r.status_regex) {
try { rule.statusRe = new RegExp(String(r.status_regex)); } catch (_) { /* config.js 已校验 */ }
}
if (r.side === 'args') argsByTool.set(String(r.tool), rule);
else if (r.side === 'result') resultByTool.set(String(r.tool), rule);
}
return { argsByTool, resultByTool };
} }
// write_file 参数占位:只洗 content。AI 友好记号风格:键值对、不写整句——path 不必重复, let TRIM = compileTrimRules([]);
// 本条 arguments 里就还在;改写的是已 parse 副本,DB 行不动,重新 stringify 保持 JSON 合法。 function setPayloadTrim(agentCfg) {
function trimWriteCalls(calls, rounds) { const trim = (agentCfg && agentCfg.trim && typeof agentCfg.trim === 'object' && !Array.isArray(agentCfg.trim))
if (rounds < TRIM.writeRounds) return; ? agentCfg.trim : {};
TRIM = compileTrimRules(Array.isArray(trim.rules) ? trim.rules : []);
}
function omittedMarker(size, extra) {
return '[OMITTED' + (extra || '') + ', size=' + size + ']';
}
// args 侧占位:只洗规则点名的顶层字符串参数,其余参数原样保留(path/url 等恢复指针不动)。
// 改写的是已 parse 副本,DB 行不动,重新 stringify 保持 JSON 合法。
function trimToolCallArgs(calls, rounds, turns) {
for (const c of calls || []) { for (const c of calls || []) {
if (!c || !c.function || c.function.name !== 'write_file') continue; if (!c || !c.function) continue;
const rule = TRIM.argsByTool.get(c.function.name);
if (!rule || rounds < rule.rounds || turns < rule.turns) continue;
let args; let args;
try { args = JSON.parse(c.function.arguments || ''); } catch (_) { continue; } try { args = JSON.parse(c.function.arguments || ''); } catch (_) { continue; }
if (!args || typeof args.content !== 'string' || args.content.length < TRIM_MIN_CHARS) continue; if (!args || typeof args !== 'object' || Array.isArray(args)) continue;
args.content = '[OMITTED, size=' + args.content.length + ']'; let changed = false;
c.function.arguments = JSON.stringify(args); for (const f of rule.fields) {
const v = args[f];
if (typeof v !== 'string' || v.length < rule.minChars) continue;
args[f] = omittedMarker(v.length);
changed = true;
}
if (changed) c.function.arguments = JSON.stringify(args);
} }
} }
// fetch/read_file 回执占位:同款键值记号。url/path 不进占位——发起调用的 assistant 行仍载着 // result 侧占位:整段回执换单行。图片回执(blocks 非空)在上游分支里已还原成文字/图块,
// 它们,参数本身就是恢复指针。图片回执(blocks 非空)不碰:已有自己的消费省略逻辑。 // 这里只处理纯文本;status_regex 可把状态码写进占位(如 fetch 的 HTTP 状态)。
function trimToolContent(content, row, callById, roundsAfter) { function trimToolContent(content, row, callById, roundsAfter, turnsAfter) {
if (TRIM.resultRounds <= 0 || content.length < TRIM_MIN_CHARS) return content; if (typeof content !== 'string') return content;
if ((roundsAfter.get(row.id) || 0) < TRIM.resultRounds) return content;
const fn = callById.get(row.tool_call_id); const fn = callById.get(row.tool_call_id);
const name = row.name || (fn && fn.name) || ''; const name = row.name || (fn && fn.name) || '';
if (name !== 'fetch' && name !== 'read_file') return content; const rule = TRIM.resultByTool.get(name);
if (name === 'fetch') { if (!rule) return content;
const hm = /^HTTP (\d{3})/.exec(content); if ((roundsAfter.get(row.id) || 0) < rule.rounds) return content;
return '[OMITTED' + (hm ? ', http_status=' + hm[1] : '') + ', size=' + content.length + ']'; if ((turnsAfter.get(row.id) || 0) < rule.turns) return content;
if (content.length < rule.minChars) return content;
let extra = '';
if (rule.statusRe) {
const m = rule.statusRe.exec(content);
if (m && m[1]) extra = ', http_status=' + m[1];
} }
return '[OMITTED, size=' + content.length + ']'; return omittedMarker(content.length, extra);
} }
// 拼压缩回合的 messages(参考 titleMessages 的拼法):默认 system prompt + 正常历史 // 拼压缩回合的 messages(参考 titleMessages 的拼法):默认 system prompt + 正常历史
+26 -3
View File
@@ -18,7 +18,21 @@ const CALL_TIMEOUT_MS = 60000;
let toolDefs = []; // OpenAI function 格式(所有 MCP 工具) let toolDefs = []; // OpenAI function 格式(所有 MCP 工具)
const toolIndex = new Map(); // 发送名 -> { server, tool, def }(服务配置 + 原始工具名 + 原始契约) const toolIndex = new Map(); // 发送名 -> { server, tool, def }(服务配置 + 原始工具名 + 原始契约)
let builtinNames = new Set(); let builtinNames = new Set();
let PUBLIC_BASE = ''; // core 自身公网前缀(loadConfig 已归一:VIRTUAL_HOST 优先 config.yml);随每次请求 X-Public-Base 头下发 let PUBLIC_BASE = ''; // core 自身公网前缀(loadConfig 已归一:config.yml 优先,其次 PUBLIC_BASE_URL);随每次请求 X-Public-Base 头下发
// 每个服务的连接状态(启动发现 + 重试阶梯的实时结果),给设置页卡片上的「已连接 / 未连接」用。
// 只反映运行态:改了 headers 没重启时仍是旧状态(页面顶部有「配置已写入,重启后生效」横幅兜底)。
const statusMap = new Map(); // key = name|url|mode
function statusKeyOf(s) {
return [s.name, String(s.url || '').replace(/\/+$/, ''), s.mode || 'advertise'].join('|');
}
function setStatus(s, patch) {
statusMap.set(statusKeyOf(s), Object.assign({
name: s.name, url: s.url, mode: s.mode || 'advertise',
ok: false, tools: 0, hidden: 0, disabled: false, error: '',
}, patch));
}
function statuses() { return Array.from(statusMap.values()); }
// 发一次 JSON-RPC 请求,返回 { result, headers }(HTTP 非 2xx / error / 无法解析时抛异常)。 // 发一次 JSON-RPC 请求,返回 { result, headers }(HTTP 非 2xx / error / 无法解析时抛异常)。
// 某些 MCP 服务遵循 Streamable HTTP 规范会在 initialize 响应里返回 Mcp-Session-Id, // 某些 MCP 服务遵循 Streamable HTTP 规范会在 initialize 响应里返回 Mcp-Session-Id,
@@ -169,9 +183,16 @@ async function loadServer(s) {
log.warn('mcp', s.name + ': 名单过滤后剩 0 个工具,请核对 tools_allow/tools_deny 与 ' + log.warn('mcp', s.name + ': 名单过滤后剩 0 个工具,请核对 tools_allow/tools_deny 与 ' +
'服务端实际工具名(如 ' + all.slice(0, 3).map(t => t.name).join(', ') + ' …)'); '服务端实际工具名(如 ' + all.slice(0, 3).map(t => t.name).join(', ') + ' …)');
} }
setStatus(s, { ok: true, tools: tools.length, hidden: hidden });
return true; return true;
} catch (err) { } catch (err) {
log.warn('mcp', s.name + ' 工具发现失败(' + (err && err.message || err) + ')'); // Node 的 fetch 只给一句 "fetch failed",真正原因在 cause(code=ECONNREFUSED / ENOTFOUND,
// 或 message="bad port" 这类),设置页卡片的 title 要看这个才诊断得了
const cause = err && err.cause;
const detail = (cause && (cause.code || cause.message)) || '';
const msg = String((err && err.message) || err) + (detail ? '(' + detail + ')' : '');
log.warn('mcp', s.name + ' 工具发现失败(' + msg + ')');
setStatus(s, { error: msg });
return false; return false;
} }
} }
@@ -208,6 +229,7 @@ function retryFailed(failed) {
async function init(cfg) { async function init(cfg) {
toolDefs = []; toolDefs = [];
toolIndex.clear(); toolIndex.clear();
statusMap.clear();
PUBLIC_BASE = (cfg && cfg.public_link && cfg.public_link.base_url) || ''; PUBLIC_BASE = (cfg && cfg.public_link && cfg.public_link.base_url) || '';
try { try {
for (const d of require('./tools/definitions.json')) { for (const d of require('./tools/definitions.json')) {
@@ -221,6 +243,7 @@ async function init(cfg) {
// mode: disable 时启动不加载该服务(不建工具表;配置保留,改回 advertise 重启后恢复) // mode: disable 时启动不加载该服务(不建工具表;配置保留,改回 advertise 重启后恢复)
if (s.mode === 'disable') { if (s.mode === 'disable') {
log.info('mcp', s.name + ': mode=disable,跳过工具加载'); log.info('mcp', s.name + ': mode=disable,跳过工具加载');
setStatus(s, { disabled: true });
continue; continue;
} }
if (!(await loadServer(s))) failed.push(s); if (!(await loadServer(s))) failed.push(s);
@@ -295,4 +318,4 @@ async function notifyTool(name, args, timeoutMs, extraHeaders) {
} }
} }
module.exports = { init, toolDefinitions, hasTool, skillTools, getSkillTool, callTool, notifyTool }; module.exports = { init, toolDefinitions, hasTool, skillTools, getSkillTool, callTool, notifyTool, statuses };
+147
View File
@@ -0,0 +1,147 @@
{
"platforms": [
{
"key": "bigmodel",
"label": "智谱",
"url": "https://open.bigmodel.cn/api/paas/v4",
"type": "bigmodel",
"model_hint": "glm-5.3-flash",
"model_defaults": {
"vision": true,
"extra_params": { "reasoning_effort": "low", "tool_stream": true },
"thinking_params": { "reasoning_effort": "max" }
}
},
{
"key": "deepseek",
"label": "DeepSeek",
"url": "https://api.deepseek.com",
"type": "deepseek",
"model_hint": "deepseek-flash",
"model_defaults": {
"vision": true,
"extra_params": { "thinking": { "type": "disabled" } },
"thinking_params": { "thinking": { "type": "enabled" }, "reasoning_effort": "max" },
"reasoning_ack_field": "reasoning_content"
}
},
{
"key": "qwen",
"label": "通义千问",
"url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
"type": "qwen",
"model_hint": "qwen3.8-flash",
"model_defaults": {
"vision": true,
"extra_params": { "enable_thinking": false },
"thinking_params": { "enable_thinking": true, "reasoning_effort": "xhigh" }
}
}
],
"mcp": [
{
"key": "web_search",
"label": "网页搜索",
"desc": "内置免费搜索,也可接自建 /search",
"url": "http://mcp_web_search:3000/",
"mode": "advertise",
"fields": [
{
"header": "Authorization",
"label": "鉴权",
"secret": true,
"prefix": "Bearer ",
"placeholder": "API Key",
"hint": "免费后端留空"
},
{
"header": "X-Web-Search-Base-Url",
"label": "地址",
"placeholder": "https://<host>/v1",
"hint": "留空用免费后端"
}
]
},
{
"key": "image_task",
"label": "图片生成",
"desc": "文生图 / 图生图",
"url": "http://mcp_image_task:3000/mcp",
"mode": "skill",
"fields": [
{
"header": "Authorization",
"label": "鉴权",
"secret": true,
"prefix": "Bearer ",
"required": true,
"placeholder": "API Key"
},
{
"header": "X-Image-Task-Base-Url",
"label": "地址",
"required": true,
"placeholder": "https://<host>/v1",
"hint": "OpenAI 兼容 generations / edits"
},
{
"header": "X-Image-Task-Model",
"label": "模型",
"required": true,
"placeholder": "上游的模型 id"
}
]
},
{
"key": "video_task",
"label": "视频生成",
"desc": "智谱 BigModel 异步视频接口",
"url": "http://mcp_video_task:3000/mcp",
"mode": "skill",
"fields": [
{
"header": "Authorization",
"label": "鉴权",
"secret": true,
"prefix": "Bearer ",
"required": true,
"placeholder": "智谱 API Key"
},
{
"header": "X-Video-Task-Model",
"label": "模型",
"default": "cogvideox-flash"
}
]
},
{
"key": "asr",
"label": "语音识别",
"desc": "按住说话 / transcribe_audio",
"url": "http://mcp_asr:3000/mcp",
"mode": "skill",
"fields": [
{
"header": "Authorization",
"label": "鉴权",
"secret": true,
"prefix": "Bearer ",
"placeholder": "支持自建免鉴权服务"
},
{
"header": "X-ASR-Base-Url",
"label": "地址",
"required": true,
"placeholder": "https://<host>/v1",
"hint": "OpenAI 兼容的 /audio/transcriptions"
},
{
"header": "X-ASR-Model",
"label": "模型",
"required": true,
"placeholder": "上游的模型 id"
}
]
}
]
}
+121 -34
View File
@@ -11,12 +11,24 @@
--drawer-bg: rgb(249, 250, 251); /* 侧边栏底色(与页面白底区分;分组表头吸顶同色) */ --drawer-bg: rgb(249, 250, 251); /* 侧边栏底色(与页面白底区分;分组表头吸顶同色) */
--border: #ececf1; --border: #ececf1;
--radius-lg: 24px; --radius-lg: 24px;
/* 安全区与软键盘(成因与注入约定见 js/viewport.js 顶部注释):
--sat / --sab 默认取 env()——iOS 独立 PWA 下有效;安卓 WebView 的 env() 只反映
屏幕挖孔(display cutout),不含状态栏/导航栏高度,基本恒为 0,需由套壳 App 用
documentElement.style.setProperty 注入真实高度覆盖。
--kb 是键盘占用的高度,取两个来源的较大值:--kb-page 由 viewport.js 按 visualViewport
算(壳不注入时也能工作),--kb-native 由壳按 IME insets 注入(WebView 完全感知不到
键盘时只能走这条)。两个变量分开放,避免页面与壳互相覆盖同一个值。 */
--sat: env(safe-area-inset-top, 0px);
--sab: env(safe-area-inset-bottom, 0px);
--kb-page: 0px;
--kb-native: 0px;
--kb: max(var(--kb-page), var(--kb-native));
} }
* { margin: 0; padding: 0; box-sizing: border-box; -webkit-tap-highlight-color: transparent; } * { margin: 0; padding: 0; box-sizing: border-box; -webkit-tap-highlight-color: transparent; }
/* 整站是视口锁定的 app shell:文档本身永不滚动,滚动只发生在内部容器 /* 整站是视口锁定的 app shell:文档本身永不滚动,滚动只发生在内部容器
(消息流 #chat-view / 抽屉列表 .drawer-list / 设置页 .set-scroll,均已 overflow-y:auto)。 (消息流 #chat-view / 抽屉列表 .drawer-list / 设置页 .set-scroll,均已 overflow-y:auto)。
不写 overflow:hidden 时,桌面端只要有一行内容没收缩下(nowrap 胶囊/代码块/宽表格), 不写 overflow:hidden 时,桌面端只要有一行内容没收缩下(nowrap 胶囊/代码块/宽表格),
浏览器就给窗口加横向滚动条;横向条又吃掉一屏高度,而 #app 死守 height:100%, 浏览器就给窗口加横向滚动条;横向条又吃掉一屏高度,而 #app 死守视口高度,
于是竖横向滚动条一起出现、缩窗口页面不动。 */ 于是竖横向滚动条一起出现、缩窗口页面不动。 */
html, body { height: 100%; overflow: hidden; } html, body { height: 100%; overflow: hidden; }
body { body {
@@ -37,7 +49,9 @@ input, textarea { font: inherit; color: inherit; border: 0; outline: none; backg
/* ================= 应用骨架 ================= */ /* ================= 应用骨架 ================= */
#app { #app {
height: 100%; /* 减去 --kb:键盘弹起时整块 shell 收缩,footer 才会落在键盘上沿。
壳已正确 resize(adjustResize / resizes-content)时 --kb 恒为 0,不重复收缩。 */
height: calc(100% - var(--kb));
max-width: 760px; max-width: 760px;
margin: 0 auto; margin: 0 auto;
display: flex; display: flex;
@@ -53,7 +67,8 @@ input, textarea { font: inherit; color: inherit; border: 0; outline: none; backg
display: flex; display: flex;
align-items: center; align-items: center;
gap: 8px; gap: 8px;
padding: 10px 12px; /* 顶栏自己吃下状态栏高度(背景跟着铺上去,不留白条);设置页顶栏同用 .header */
padding: calc(10px + var(--sat)) 12px 10px;
min-height: 56px; min-height: 56px;
background: var(--drawer-bg); background: var(--drawer-bg);
} }
@@ -280,7 +295,7 @@ main { flex: 1; min-height: 0; display: flex; flex-direction: column; }
.tool-card .tool-time .act-del:hover { color: #c0392b; } .tool-card .tool-time .act-del:hover { color: #c0392b; }
/* ================= 底部输入区 ================= */ /* ================= 底部输入区 ================= */
footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-area-inset-bottom, 0px)); background: var(--page); } footer { position: relative; flex: none; padding: 8px 12px calc(10px + var(--sab)); background: var(--page); }
.attach-chips { display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 8px; } .attach-chips { display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 8px; }
.attach-chip { .attach-chip {
display: inline-flex; align-items: center; gap: 6px; display: inline-flex; align-items: center; gap: 6px;
@@ -423,37 +438,48 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
/* 录音中给一个极浅底色作反馈(文字同时变成「松开 结束」) */ /* 录音中给一个极浅底色作反馈(文字同时变成「松开 结束」) */
#voice-hold.recording { background: var(--surface); } #voice-hold.recording { background: var(--surface); }
/* 录音期间:输入卡内容整体让位给遮罩(透明渐变不能把按钮/文字透出来) */ /* 录音期间:输入卡内容整体让位给遮罩(遮罩不再透光,按钮/文字留着会和提示叠字) */
body.voice-active .input-shell { border-color: transparent; box-shadow: none; } body.voice-active .input-shell { border-color: transparent; box-shadow: none; }
body.voice-active .input-shell > *:not(#voice-overlay) { visibility: hidden; } /* #voice-hold 不能一起藏:它是 pointerdown 时 setPointerCapture 的持有者,一按下就变成
visibility:hidden 时鸿蒙 ArkWeb 会释放捕获并补一个 pointercancel,页面把它当成“松手”
→ 按住不到 500ms → 误报“说话时间太短”。遮罩覆盖这一段本来就不透明(var(--page)),
留着按住区视觉上没有差别。 */
body.voice-active .input-shell > *:not(#voice-overlay):not(#voice-hold) { visibility: hidden; }
body.voice-active .attach-chips { visibility: hidden; } body.voice-active .attach-chips { visibility: hidden; }
body.voice-active .scroll-bottom-btn { display: none; } body.voice-active .scroll-bottom-btn { display: none; }
/* 按住说话的遮罩:左右贴屏幕两边;底部一直铺到屏幕底(含 footer 的 10px 内边距与安全区), /* 按住说话的遮罩:左右贴屏幕两边;底部一直铺到屏幕底(含 footer 的 10px 内边距与安全区),
向上多铺 72px 让渐变淡出。 向上多铺 72px 把输入卡上方那一条会话流也盖住。
声波中心对齐「按住 说话」那一行:padding-bottom 70px + 安全区 = 声波中心对齐「按住 说话」那一行:padding-bottom 70px + 安全区 =
59(声波中心到输入卡底部)+ 11(遮罩底边向下外扩的 1px 边框 + 10px footer 内边距)。 */ 59(声波中心到输入卡底部)+ 11(遮罩底边向下外扩的 1px 边框 + 10px footer 内边距)。 */
#voice-overlay { #voice-overlay {
position: absolute; position: absolute;
top: -72px; top: -72px;
bottom: calc(-11px - env(safe-area-inset-bottom, 0px)); bottom: calc(-11px - var(--sab));
left: -13px; right: -13px; left: -13px; right: -13px;
z-index: 6; z-index: 6;
display: flex; flex-direction: column; align-items: center; justify-content: flex-end; display: flex; flex-direction: column; align-items: center; justify-content: flex-end;
gap: 20px; gap: 20px;
padding-bottom: calc(70px + env(safe-area-inset-bottom, 0px)); padding-bottom: calc(70px + var(--sab));
/* 极淡的蓝调,从下往上淡出(“几乎看不出来,仔细看才有一层”) */ /* 底色必须是**不透明**的 var(--page):早先只铺一层 9% 蓝渐变,遮罩伸进会话流的那一段
background: linear-gradient(to top, rgba(57, 100, 254, .09), rgba(57, 100, 254, 0)); 会把底下的消息文字透出来,「松手传送」看着就成了半透明。
顶层那 20px 由透明渐变到 --page 只是把上边缘与会话流接上,别把整块都做成渐变。 */
background:
linear-gradient(to top, rgba(57, 100, 254, .09), rgba(57, 100, 254, 0) 70%),
linear-gradient(to bottom, rgba(255, 255, 255, 0), var(--page) 20px);
color: var(--active); color: var(--active);
pointer-events: auto; touch-action: none; pointer-events: auto; touch-action: none;
transition: background .15s linear, color .15s linear; transition: background .15s linear, color .15s linear;
} }
/* 上滑取消态:整体换成极淡的红调,声波/文案同步变红 */ /* 上滑取消态:整体换成极淡的红调,声波/文案同步变红 */
#voice-overlay.cancel { #voice-overlay.cancel {
background: linear-gradient(to top, rgba(192, 57, 43, .09), rgba(192, 57, 43, 0)); background:
linear-gradient(to top, rgba(192, 57, 43, .09), rgba(192, 57, 43, 0) 70%),
linear-gradient(to bottom, rgba(255, 255, 255, 0), var(--page) 20px);
color: #c0392b; color: #c0392b;
} }
.vo-hint { font-size: 13px; line-height: 18px; color: var(--gray); letter-spacing: .2px; } /* 提示文案落在外挂层上,用比 --gray 深一档的中灰:13px 的字在浅灰上发虚 */
.vo-hint { font-size: 13px; line-height: 18px; color: #5f6672; letter-spacing: .2px; }
.vo-wave { display: flex; align-items: center; justify-content: center; gap: 3px; height: 34px; max-width: 100%; } .vo-wave { display: flex; align-items: center; justify-content: center; gap: 3px; height: 34px; max-width: 100%; }
/* 柱子高度用 scaleY 而不是 height:只走合成层,不触发重排 */ /* 柱子高度用 scaleY 而不是 height:只走合成层,不触发重排 */
.vo-wave i { .vo-wave i {
@@ -501,7 +527,7 @@ body.voice-active .scroll-bottom-btn { display: none; }
border-radius: 16px 16px 0 0; border-radius: 16px 16px 0 0;
box-shadow: 0 -6px 24px rgba(20, 30, 70, 0.16); box-shadow: 0 -6px 24px rgba(20, 30, 70, 0.16);
transform: translateY(105%); transition: transform .25s ease; /* 收起时滑出屏幕 */ transform: translateY(105%); transition: transform .25s ease; /* 收起时滑出屏幕 */
padding-bottom: env(safe-area-inset-bottom, 0px); padding-bottom: var(--sab);
overflow: hidden; overflow: hidden;
} }
.files-panel.open { transform: translateY(0); } .files-panel.open { transform: translateY(0); }
@@ -597,7 +623,7 @@ body.voice-active .scroll-bottom-btn { display: none; }
padding: 10px 14px; padding: 10px 14px;
border-top: 1px solid var(--border); border-top: 1px solid var(--border);
background: var(--page); background: var(--page);
padding-bottom: calc(10px + env(safe-area-inset-bottom, 0px)); padding-bottom: calc(10px + var(--sab));
} }
.files-panel-count { .files-panel-count {
font-size: 13px; color: var(--gray); font-size: 13px; color: var(--gray);
@@ -750,7 +776,9 @@ body.voice-active .scroll-bottom-btn { display: none; }
} }
#scrim.show { opacity: 1; pointer-events: auto; } #scrim.show { opacity: 1; pointer-events: auto; }
#drawer { #drawer {
position: fixed; top: 0; bottom: 0; left: 0; z-index: 50; /* 抽屉是 fixed 全屏层:顶部让出状态栏,底部随键盘收缩(搜索框输入时列表不被盖住) */
position: fixed; top: 0; bottom: var(--kb); left: 0; z-index: 50;
padding-top: var(--sat);
width: min(78vw, 320px); width: min(78vw, 320px);
background: var(--drawer-bg); background: var(--drawer-bg);
display: flex; flex-direction: column; display: flex; flex-direction: column;
@@ -841,7 +869,7 @@ body.voice-active .scroll-bottom-btn { display: none; }
/* 底部用户区 */ /* 底部用户区 */
.drawer-user { .drawer-user {
flex: none; display: flex; align-items: center; gap: 10px; flex: none; display: flex; align-items: center; gap: 10px;
padding: 12px 14px calc(12px + env(safe-area-inset-bottom, 0px)); padding: 12px 14px calc(12px + var(--sab));
border-top: 1px solid var(--border); border-top: 1px solid var(--border);
} }
.avatar { .avatar {
@@ -926,12 +954,12 @@ body.voice-active .scroll-bottom-btn { display: none; }
/* 两层 img 绝对定位居中叠放:滑动切换时旧图滑出、新图同步滑入(见 js/stream.js 的 slideTo) */ /* 两层 img 绝对定位居中叠放:滑动切换时旧图滑出、新图同步滑入(见 js/stream.js 的 slideTo) */
#img-viewer img { position: absolute; inset: 0; margin: auto; max-width: 100vw; max-height: 88vh; touch-action: none; cursor: grab; user-select: none; -webkit-user-drag: none; will-change: transform; } #img-viewer img { position: absolute; inset: 0; margin: auto; max-width: 100vw; max-height: 88vh; touch-action: none; cursor: grab; user-select: none; -webkit-user-drag: none; will-change: transform; }
/* 组内页码:底部居中悬浮,不参与命中测试(点它等于点背景会关闭) */ /* 组内页码:底部居中悬浮,不参与命中测试(点它等于点背景会关闭) */
#img-count { position: fixed; left: 50%; bottom: calc(18px + env(safe-area-inset-bottom, 0px)); transform: translateX(-50%); z-index: 151; padding: 3px 12px; border-radius: 999px; background: rgba(0,0,0,0.5); color: #fff; font-size: 12px; letter-spacing: .5px; pointer-events: none; } #img-count { position: fixed; left: 50%; bottom: calc(18px + var(--sab)); transform: translateX(-50%); z-index: 151; padding: 3px 12px; border-radius: 999px; background: rgba(0,0,0,0.5); color: #fff; font-size: 12px; letter-spacing: .5px; pointer-events: none; }
#fs-viewer { position: fixed; inset: 0; z-index: 130; background: rgba(8,10,20,0.88); padding: 40px 14px 24px; overflow: auto; /* 缩放后支持横纵滚动 */ } #fs-viewer { position: fixed; inset: 0; z-index: 130; background: rgba(8,10,20,0.88); padding: 40px 14px 24px; overflow: auto; /* 缩放后支持横纵滚动 */ }
#fs-viewer.hidden { display: none; } #fs-viewer.hidden { display: none; }
.fs-panel { max-width: 860px; margin: 0 auto; background: var(--page); border-radius: 14px; padding: 18px 20px; font-size: 15.5px; } .fs-panel { max-width: 860px; margin: 0 auto; background: var(--page); border-radius: 14px; padding: 18px 20px; font-size: 15.5px; }
/* 顶部操作区:默认右上角悬浮(消息全屏用);文件预览走 fs-bar 模式时独立成一行 */ /* 顶部操作区:默认右上角悬浮(消息全屏用);文件预览走 fs-bar 模式时独立成一行 */
.fs-actions { position: fixed; top: calc(2px + env(safe-area-inset-top, 0px)); right: 14px; z-index: 131; display: flex; align-items: center; gap: 8px; } .fs-actions { position: fixed; top: calc(2px + var(--sat)); right: 14px; z-index: 131; display: flex; align-items: center; gap: 8px; }
.fs-name { display: none; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 13px; font-weight: 600; color: var(--ink); } .fs-name { display: none; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 13px; font-weight: 600; color: var(--ink); }
.fs-btn { .fs-btn {
flex: none; display: flex; align-items: center; justify-content: center; flex: none; display: flex; align-items: center; justify-content: center;
@@ -948,8 +976,8 @@ body.voice-active .scroll-bottom-btn { display: none; }
#fs-viewer.fs-bar .fs-actions { #fs-viewer.fs-bar .fs-actions {
position: sticky; top: 0; z-index: 1; position: sticky; top: 0; z-index: 1;
flex: none; width: 100%; flex: none; width: 100%;
height: calc(40px + env(safe-area-inset-top, 0px)); height: calc(40px + var(--sat));
padding: env(safe-area-inset-top, 0px) 10px 0 14px; padding: var(--sat) 10px 0 14px;
justify-content: flex-end; gap: 6px; justify-content: flex-end; gap: 6px;
background: var(--page); border-bottom: 1px solid var(--border); background: var(--page); border-bottom: 1px solid var(--border);
} }
@@ -964,14 +992,14 @@ body.voice-active .scroll-bottom-btn { display: none; }
#fs-viewer.fs-bar #fs-body .bubble-ai, #fs-viewer.fs-bar #fs-body .bubble-ai,
#fs-viewer.fs-bar #fs-body .bubble-user { #fs-viewer.fs-bar #fs-body .bubble-user {
max-width: 100%; margin: 0; border-radius: 0; box-shadow: none; background: var(--page); max-width: 100%; margin: 0; border-radius: 0; box-shadow: none; background: var(--page);
padding: 14px 12px calc(28px + env(safe-area-inset-bottom, 0px)); font-size: 15.5px; padding: 14px 12px calc(28px + var(--sab)); font-size: 15.5px;
} }
#fs-viewer.fs-bar #fs-src-pane { overflow: auto; } #fs-viewer.fs-bar #fs-src-pane { overflow: auto; }
#fs-viewer.fs-bar #fs-src-code { max-height: none; border: 0; border-radius: 0; padding: 12px 14px calc(28px + env(safe-area-inset-bottom, 0px)); } #fs-viewer.fs-bar #fs-src-code { max-height: none; border: 0; border-radius: 0; padding: 12px 14px calc(28px + var(--sab)); }
#fs-viewer.fs-bar .fs-img-frame { max-width: 100%; max-height: 100%; border-radius: 0; margin: 0 auto; } #fs-viewer.fs-bar .fs-img-frame { max-width: 100%; max-height: 100%; border-radius: 0; margin: 0 auto; }
.fs-close { .fs-close {
/* 顶到视口最上沿(避开刘海),不再压住预览面板顶部 */ /* 顶到视口最上沿(避开刘海),不再压住预览面板顶部 */
position: fixed; top: calc(2px + env(safe-area-inset-top, 0px)); right: 14px; z-index: 131; width: 34px; height: 34px; position: fixed; top: calc(2px + var(--sat)); right: 14px; z-index: 131; width: 34px; height: 34px;
border: none; border-radius: 50%; background: rgba(0,0,0,0.42); color: #fff; border: none; border-radius: 50%; background: rgba(0,0,0,0.42); color: #fff;
box-shadow: 0 1px 5px rgba(0,0,0,0.22); box-shadow: 0 1px 5px rgba(0,0,0,0.22);
font-size: 15px; line-height: 1; cursor: pointer; font-size: 15px; line-height: 1; cursor: pointer;
@@ -1021,7 +1049,7 @@ body.voice-active .scroll-bottom-btn { display: none; }
.header-right .icon-btn:active, .header-right label.icon-btn:active { background: var(--surface); } .header-right .icon-btn:active, .header-right label.icon-btn:active { background: var(--surface); }
label.icon-btn { cursor: pointer; } label.icon-btn { cursor: pointer; }
#set-body { flex: 1; min-height: 0; background: var(--surface); display: flex; flex-direction: column; } #set-body { flex: 1; min-height: 0; background: var(--surface); display: flex; flex-direction: column; }
.set-scroll { flex: 1; min-height: 0; overflow-y: auto; overflow-x: hidden; padding: 12px 12px calc(16px + env(safe-area-inset-bottom, 0px)); } .set-scroll { flex: 1; min-height: 0; overflow-y: auto; overflow-x: hidden; padding: 12px 12px calc(16px + var(--sab)); }
.empty-tip { color: var(--gray-light); text-align: center; padding: 18px; font-size: 13px; } .empty-tip { color: var(--gray-light); text-align: center; padding: 18px; font-size: 13px; }
/* ---------- 设置主页卡片 ---------- */ /* ---------- 设置主页卡片 ---------- */
@@ -1179,6 +1207,9 @@ label.icon-btn { cursor: pointer; }
.model-card-state.busy { background: #fdecea; color: #b3382c; } .model-card-state.busy { background: #fdecea; color: #b3382c; }
.model-card-state.pending { background: #fff4dc; color: #a06a00; } .model-card-state.pending { background: #fff4dc; color: #a06a00; }
.model-card-state.off { background: var(--surface); color: var(--gray); } .model-card-state.off { background: var(--surface); color: var(--gray); }
/* MCP 页分段标题:内置服务 / 其它服务 */
.mcp-sec-title { margin: 16px 4px 0; font-size: 12.5px; font-weight: 600; color: var(--gray); }
.mcp-list > .mcp-sec-title:first-child { margin-top: 10px; }
/* 禁用态卡片:背景转灰、名称/token 区淡化,开关保持正常亮度可点 */ /* 禁用态卡片:背景转灰、名称/token 区淡化,开关保持正常亮度可点 */
.model-card.off { background: #f5f6f8; } .model-card.off { background: #f5f6f8; }
.model-card.off .model-card-name, .model-card.off .cfg-kv { opacity: 0.5; } .model-card.off .model-card-name, .model-card.off .cfg-kv { opacity: 0.5; }
@@ -1197,6 +1228,8 @@ label.icon-btn { cursor: pointer; }
/* 三段分区:平台字段 / Keys / 模型,用虚线分隔 + 留白,避免挤在一起 */ /* 三段分区:平台字段 / Keys / 模型,用虚线分隔 + 留白,避免挤在一起 */
.modal .mpe-sec { margin-top: 16px; padding-top: 12px; border-top: 1px dashed var(--border); } .modal .mpe-sec { margin-top: 16px; padding-top: 12px; border-top: 1px dashed var(--border); }
.modal .mpe-sec-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin: 0 0 10px; font-size: 13px; font-weight: 600; color: var(--ink); } .modal .mpe-sec-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin: 0 0 10px; font-size: 13px; font-weight: 600; color: var(--ink); }
/* 标题右侧的说明(如内置服务的 desc):跟 flex 靠右,去掉 .cfg-note 的上边距;min-width 让它在窄屏可折行 */
.modal .mpe-sec-head .cfg-note { margin: 0; text-align: right; min-width: 0; font-weight: 400; }
.modal .mpe-foot { margin-top: 18px; } .modal .mpe-foot { margin-top: 18px; }
.modal .mpe-sec-head .ghost-btn.sm { flex: none; padding: 4px 12px; font-size: 12.5px; border-radius: 8px; } .modal .mpe-sec-head .ghost-btn.sm { flex: none; padding: 4px 12px; font-size: 12.5px; border-radius: 8px; }
.modal .mpe-row { display: flex; align-items: center; gap: 6px; margin-bottom: 8px; } .modal .mpe-row { display: flex; align-items: center; gap: 6px; margin-bottom: 8px; }
@@ -1206,22 +1239,50 @@ label.icon-btn { cursor: pointer; }
.modal .mpe-mcard { border: 1px solid var(--border); border-radius: 10px; padding: 9px 10px; margin-bottom: 8px; background: #fafbfd; } .modal .mpe-mcard { border: 1px solid var(--border); border-radius: 10px; padding: 9px 10px; margin-bottom: 8px; background: #fafbfd; }
.modal .mpe-mcard .mpe-row { margin-bottom: 0; } .modal .mpe-mcard .mpe-row { margin-bottom: 0; }
.modal .mpe-cks { display: flex; align-items: center; gap: 16px; margin-top: 8px; } .modal .mpe-cks { display: flex; align-items: center; gap: 16px; margin-top: 8px; }
/* 超时(ms)与「启用」同排。数字框单独成类,不吃 .mpe-ck input 那套 15px 无边框样式(那是给 checkbox 的); /* 单行设置项:左标签 / 右控件(与上面 header 那排同一种「一左一右」的节奏)
选择器带 .modal 前缀是为了压过 .modal input{width:100%},否则会被撑满整行。 */ 选择器带 .modal 前缀是为了压过 .modal input{width:100%},否则输入框会撑满整行。 */
.modal .mpe-num { display: flex; align-items: center; gap: 5px; flex: none; font-size: 12.5px; color: var(--gray); } .modal .mpe-line { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 10px; font-size: 12.5px; color: var(--gray); }
.modal .mpe-num input { width: 92px; padding: 5px 8px; margin: 0; font-size: 13px; border: 1px solid #dde1ea; border-radius: 8px; background: #fff; color: var(--ink); } .modal .mpe-line:last-child { margin-bottom: 0; }
.modal .mpe-num input:focus { border-color: var(--active); } .modal .mpe-line > span { flex: none; white-space: nowrap; }
/* MCP 的 mode 三态下拉:独立成行(弹窗内容宽仅 ~320px,与超时框同排会撑破),内层 select 用 .modal select 的全宽样式 */ .modal .mpe-line input { flex: 1; min-width: 0; margin: 0; }
.modal .mpe-field { display: block; margin-top: 14px; font-size: 12.5px; color: var(--gray); } .modal .mpe-line select { width: auto; min-width: 180px; margin: 0; }
/* 预设字段:一行(可选带说明)作为一个整体留间距 */
.modal .mpe-item { margin-bottom: 10px; }
.modal .mpe-item:last-child { margin-bottom: 0; }
.modal .mpe-item .mpe-line { margin-bottom: 0; }
.modal .mpe-item .cfg-note { margin-top: 4px; text-align: right; }
/* ms 作为输入框内的后缀:定位在框内右侧,pointer-events:none 保证点击穿给输入框 */
.modal .mpe-unit { position: relative; flex: none; width: 118px; }
.modal .mpe-unit input { width: 100%; margin: 0; padding: 8px 30px 8px 10px; }
.modal .mpe-unit i { position: absolute; right: 10px; top: 50%; transform: translateY(-50%); font-style: normal; font-size: 11.5px; color: var(--gray-light); pointer-events: none; }
/* 预设模式下 name/url 是契约值(只读),压暗以区别于可编辑输入框 */
.modal input[readonly] { background: #f1f3f7; color: var(--gray); }
.modal .mpe-ck { display: flex; align-items: center; gap: 5px; font-size: 12.5px; color: var(--gray); } .modal .mpe-ck { display: flex; align-items: center; gap: 5px; font-size: 12.5px; color: var(--gray); }
.modal .mpe-ck input { width: 15px; height: 15px; padding: 0; margin: 0; border: none; background: none; accent-color: var(--active); cursor: pointer; } .modal .mpe-ck input { width: 15px; height: 15px; padding: 0; margin: 0; border: none; background: none; accent-color: var(--active); cursor: pointer; }
.modal .mpe-del { flex: none; border: none; background: none; margin: 0; padding: 2px 7px; cursor: pointer; color: var(--gray-light); font-size: 18px; line-height: 1.2; } .modal .mpe-del { flex: none; border: none; background: none; margin: 0; padding: 2px 7px; cursor: pointer; color: var(--gray-light); font-size: 18px; line-height: 1.2; }
.modal .mpe-del:active { color: #c0392b; } .modal .mpe-del:active { color: #c0392b; }
/* 平台预设:新增平台时点一下填好 url/类型,模型卡带上该平台的参数缺省 */
.modal .mpe-chips { display: flex; flex-wrap: wrap; gap: 6px; margin: 0 0 10px; }
.modal .mpe-chip { flex: none; width: auto; padding: 5px 12px; border: 1px solid #dde1ea; border-radius: 999px; background: #fff; color: var(--gray); font-size: 12.5px; line-height: 1.4; }
.modal .mpe-chip:active { background: var(--surface); }
.modal .mpe-chip.on { border-color: var(--active); color: var(--active); background: var(--active-light); }
/* 模型卡「高级」折叠区:沿用左标签/右控件;JSON 用等宽小字,高度可拖 */
.modal .mpe-adv-btn { margin-left: auto; flex: none; padding: 0; font-size: 12px; color: var(--gray); }
.modal .mpe-adv { margin-top: 8px; padding-top: 8px; border-top: 1px dashed var(--border); }
.modal .mpe-adv .mpe-line { margin-bottom: 8px; }
.modal .mpe-adv .mpe-line:last-child { margin-bottom: 0; }
.modal .mpe-line textarea {
flex: 1; min-width: 0; margin: 0; height: 46px; padding: 6px 9px;
border: 1px solid #dde1ea; border-radius: 10px; background: #fff; color: var(--ink);
font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 12px; line-height: 1.45;
resize: vertical;
}
.modal .mpe-line textarea:focus { border-color: var(--active); }
/* ---------- 编辑器页(config.yml 原文 / 技能文件) ---------- */ /* ---------- 编辑器页(config.yml 原文 / 技能文件) ---------- */
.set-editor { .set-editor {
flex: 1; min-height: 0; display: flex; flex-direction: column; flex: 1; min-height: 0; display: flex; flex-direction: column;
padding: 10px 12px calc(12px + env(safe-area-inset-bottom, 0px)); padding: 10px 12px calc(12px + var(--sab));
} }
.set-editor textarea { .set-editor textarea {
flex: 1; width: 100%; resize: none; background: #fff; color: var(--ink); flex: 1; width: 100%; resize: none; background: #fff; color: var(--ink);
@@ -1247,13 +1308,18 @@ label.icon-btn { cursor: pointer; }
.btn-row { display: flex; gap: 10px; } .btn-row { display: flex; gap: 10px; }
.btn-row .primary-btn { flex: 1; } .btn-row .primary-btn { flex: 1; }
.modal-overlay { .modal-overlay {
position: fixed; inset: 0; background: rgba(20, 25, 50, 0.45); /* bottom 让出键盘:弹窗内的输入框(定时任务提示词等)不被软键盘压住 */
position: fixed; inset: 0; bottom: var(--kb); background: rgba(20, 25, 50, 0.45);
display: flex; align-items: center; justify-content: center; z-index: 100; display: flex; align-items: center; justify-content: center; z-index: 100;
} }
.modal { .modal {
background: var(--page); border-radius: 14px; padding: 20px; width: 84%; max-width: 360px; background: var(--page); border-radius: 14px; padding: 20px; width: 84%; max-width: 360px;
position: relative; max-height: 88%; overflow-y: auto; position: relative; max-height: 88%; overflow-y: auto;
} }
/* 移动端:表单是「左标签 + 右输入」双列,84% 宽度下输入框太窄 */
@media (max-width: 639px) {
#mcp-edit-modal .modal, #model-edit-modal .modal { width: calc(100% - 24px); padding: 18px 14px; }
}
.modal h3 { margin-bottom: 12px; font-size: 16px; } .modal h3 { margin-bottom: 12px; font-size: 16px; }
.modal input { .modal input {
width: 100%; border: 1px solid #dde1ea; border-radius: 10px; width: 100%; border: 1px solid #dde1ea; border-radius: 10px;
@@ -1572,6 +1638,27 @@ body.pv-resizing #pv-pane iframe { pointer-events: none; }
} }
@keyframes drop-overlay-in { from { opacity: 0; } to { opacity: 1; } } @keyframes drop-overlay-in { from { opacity: 0; } to { opacity: 1; } }
/* ================= 待发送条幅(运行中排队 / 干预 / 立即发送) ================= */
/* 输入卡上方一行小条:正文单行省略 + 动作按钮。多条时逐条堆叠,每条仍是一行。
配色刻意与「编辑提示条」的蓝色区分:排队是“稍后执行”的提示态,不是输入态。 */
.send-queue { display: flex; flex-direction: column; gap: 6px; margin-bottom: 8px; }
.sq-item {
display: flex; align-items: center; gap: 6px;
padding: 5px 5px 5px 11px;
border-radius: 12px; background: #fff4dc; color: #a06a00; font-size: 12.5px;
}
.sq-item .sq-text { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.sq-item .sq-tag { flex: none; font-size: 11.5px; opacity: .75; }
.sq-item button {
flex: none; padding: 2px 9px; border-radius: 8px;
font-size: 12.5px; font-weight: 600; color: inherit; background: none; border: none;
}
.sq-item button:active { background: rgba(160, 106, 0, 0.12); }
.sq-item button:disabled { opacity: .45; }
.sq-item .sq-x { padding: 2px 7px; font-weight: 500; }
/* 已升级为「干预/立即发送」但还没到边界:按钮置灰,显示“等待当前步骤” */
.sq-item.sq-busy button:not(.sq-x) { opacity: .45; }
/* ================= 编辑已发送消息提示条 ================= */ /* ================= 编辑已发送消息提示条 ================= */
/* 覆盖式重发:输入框内部的浅蓝提示条(嵌在 .input-shell 顶端,间距由 shell 的 gap 提供)。 */ /* 覆盖式重发:输入框内部的浅蓝提示条(嵌在 .input-shell 顶端,间距由 shell 的 gap 提供)。 */
.edit-bar { .edit-bar {
+32 -18
View File
@@ -2,7 +2,10 @@
<html lang="zh"> <html lang="zh">
<head> <head>
<meta charset="UTF-8"> <meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"> <!-- viewport-fit=cover:让 env(safe-area-inset-*) 生效(缺了它 iOS 上恒为 0);
interactive-widget=resizes-content:键盘弹起时缩 layout viewport(新 Chromium 认;
不认的浏览器会忽略,由 js/viewport.js 的 --kb 兜底)。 -->
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover, interactive-widget=resizes-content">
<title>Agent 任务台</title> <title>Agent 任务台</title>
<script src="/vendor/marked.min.js"></script> <script src="/vendor/marked.min.js"></script>
<meta name="theme-color" content="#3964FE"> <meta name="theme-color" content="#3964FE">
@@ -157,10 +160,13 @@
<!-- ================= 底部输入区 ================= --> <!-- ================= 底部输入区 ================= -->
<footer> <footer>
<div class="attach-chips hidden" id="attach-chips"></div> <div class="attach-chips hidden" id="attach-chips"></div>
<!-- 待发送条幅:运行中发出的消息先排在这里(不立即入库),逐条一行。
默认等本轮结束自动发出;队首可「干预」(跑完当前这步就插话)或「立即发送」(中断本轮)。 -->
<div class="send-queue hidden" id="send-queue" aria-live="polite"></div>
<div class="input-shell"> <div class="input-shell">
<!-- 编辑已发送消息:覆盖式重发提示条(发送后丢弃该条及其后的历史) --> <!-- 编辑已发送消息:覆盖式重发提示条(发送后丢弃该条及其后的历史) -->
<div class="edit-bar hidden" id="edit-bar"> <div class="edit-bar hidden" id="edit-bar">
<span>正在编辑已发送的消息,发送后将丢弃其后的历史</span> <span>编辑已发送消息:发送后将丢弃原历史信息</span>
<button id="edit-cancel" type="button">取消</button> <button id="edit-cancel" type="button">取消</button>
</div> </div>
<div class="up-cards hidden" id="up-cards" aria-label="已上传文件"></div> <div class="up-cards hidden" id="up-cards" aria-label="已上传文件"></div>
@@ -296,6 +302,8 @@
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg> <svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
</button> </button>
<h3 id="mpe-title">编辑平台</h3> <h3 id="mpe-title">编辑平台</h3>
<!-- 平台预设:仅新增平台时展示,点选即填好 url/类型并给模型卡带上该平台的参数缺省 -->
<div class="mpe-chips hidden" id="mpe-presets"></div>
<input type="text" id="mpe-name" placeholder="平台名(留空取 url 主机名首段)"> <input type="text" id="mpe-name" placeholder="平台名(留空取 url 主机名首段)">
<input type="text" id="mpe-url" placeholder="平台上游地址(OpenAI 兼容 /v1)"> <input type="text" id="mpe-url" placeholder="平台上游地址(OpenAI 兼容 /v1)">
<div class="mpe-sec"> <div class="mpe-sec">
@@ -310,7 +318,6 @@
<button class="ghost-btn danger hidden" id="mpe-del-btn" onclick="sUI.mDelPlat()">删除平台</button> <button class="ghost-btn danger hidden" id="mpe-del-btn" onclick="sUI.mDelPlat()">删除平台</button>
<button class="primary-btn" onclick="sUI.mSave()">保存</button> <button class="primary-btn" onclick="sUI.mSave()">保存</button>
</div> </div>
<div class="cfg-note">仅写入配置,点击「重启服务」后生效。</div>
</div> </div>
</div> </div>
@@ -343,27 +350,33 @@
<svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg> <svg viewBox="0 0 24 24"><line x1="18" y1="6" x2="6" y2="18"></line><line x1="6" y1="6" x2="18" y2="18"></line></svg>
</button> </button>
<h3 id="mce-title">编辑 MCP 服务</h3> <h3 id="mce-title">编辑 MCP 服务</h3>
<input type="text" id="mce-name" placeholder="服务名(留空取 url 主机名首段)"> <input type="text" id="mce-name" placeholder="服务名">
<input type="text" id="mce-url" placeholder="MCP 服务 JSON-RPC 端点(完整 URL)"> <input type="text" id="mce-url" placeholder="MCP 服务 JSON-RPC URL">
<div class="mpe-sec"> <!-- 内置服务预设字段(url/name 只读,表单由预设生成) -->
<div class="mpe-sec hidden" id="mce-preset-sec">
<div class="mpe-sec-head"><span>配置参数</span><span class="cfg-note" id="mce-preset-desc"></span></div>
<div id="mce-preset-fields"></div>
</div>
<div class="mpe-sec" id="mce-headers-sec">
<div class="mpe-sec-head"><span>请求头(headers)</span><button class="ghost-btn sm" onclick="mcpUI.addHeader()">添加 header</button></div> <div class="mpe-sec-head"><span>请求头(headers)</span><button class="ghost-btn sm" onclick="mcpUI.addHeader()">添加 header</button></div>
<div id="mce-headers"></div> <div id="mce-headers"></div>
</div> </div>
<div class="mpe-cks" style="margin-top:14px"> <div class="mpe-sec">
<label class="mpe-num">单次调用超时<input type="number" id="mce-timeout" min="1000" max="600000" step="1000" placeholder="默认 60000">ms</label> <label class="mpe-line"><span>单次调用超时</span>
<span class="mpe-unit"><input type="number" id="mce-timeout" min="1000" max="600000" step="1000" placeholder="60000"><i>ms</i></span>
</label>
<label class="mpe-line"><span>工具暴露</span>
<select id="mce-mode">
<option value="advertise">advertise(下发给模型)</option>
<option value="skill">skill(以技能形式暴露)</option>
<option value="disable">disable(不加载)</option>
</select>
</label>
</div> </div>
<label class="mpe-field">工具暴露
<select id="mce-mode">
<option value="advertise">advertise(下发给模型)</option>
<option value="skill">skill(以技能形式暴露)</option>
<option value="disable">disable(不加载)</option>
</select>
</label>
<div class="btn-row mpe-foot"> <div class="btn-row mpe-foot">
<button class="ghost-btn danger hidden" id="mce-del-btn" onclick="mcpUI.del()">删除服务</button> <button class="ghost-btn danger hidden" id="mce-del-btn" onclick="mcpUI.del()">删除服务</button>
<button class="primary-btn" onclick="mcpUI.save()">保存</button> <button class="primary-btn" onclick="mcpUI.save()">保存</button>
</div> </div>
<div class="cfg-note">仅写入配置,点击「重启服务」后生效。</div>
</div> </div>
</div> </div>
@@ -515,6 +528,7 @@
</div> </div>
</div> </div>
<script src="/js/viewport.js"></script>
<script src="/js/core.js"></script> <script src="/js/core.js"></script>
<script src="/js/chat.js"></script> <script src="/js/chat.js"></script>
<script src="/js/sessions.js"></script> <script src="/js/sessions.js"></script>
@@ -527,12 +541,12 @@
// 启动自愈:外部工具改前端文件是非原子写入,极端时机下浏览器可能拿到半截或重复拼接的 HTML // 启动自愈:外部工具改前端文件是非原子写入,极端时机下浏览器可能拿到半截或重复拼接的 HTML
// (脚本缺半 → 白屏裸首页;重复注入 → 每个文件报 duplicate variable 后 JS 全挂)。 // (脚本缺半 → 白屏裸首页;重复注入 → 每个文件报 duplicate variable 后 JS 全挂)。
// 这里检测关键脚本数量与入口全局,不对就自动整页重载一次(sessionStorage 防循环)。 // 这里检测关键脚本数量与入口全局,不对就自动整页重载一次(sessionStorage 防循环)。
// 注意:js/ 脚本增减时需同步改这里的期望数 7。 // 注意:js/ 脚本增减时需同步改这里的期望数 9。
(function () { (function () {
var ok = false; var ok = false;
try { try {
var n = document.querySelectorAll('script[src^="/js/"]').length; var n = document.querySelectorAll('script[src^="/js/"]').length;
ok = n === 7 && typeof state !== 'undefined' && ok = n === 9 && typeof state !== 'undefined' &&
typeof openFilePreview === 'function' && typeof restartNow === 'function'; typeof openFilePreview === 'function' && typeof restartNow === 'function';
} catch (_) {} } catch (_) {}
if (ok) { try { sessionStorage.removeItem('boot-heal'); } catch (_) {} return; } if (ok) { try { sessionStorage.removeItem('boot-heal'); } catch (_) {} return; }
+2
View File
@@ -412,6 +412,8 @@
state.status = (s && s.status) || ''; state.status = (s && s.status) || '';
state.modelId = (s && s.model_id) || ''; // 顶部动作区展示当前模型 state.modelId = (s && s.model_id) || ''; // 顶部动作区展示当前模型
state.schedule = detail.schedule || null; // 定时任务数据(顶部动作区副标题) state.schedule = detail.schedule || null; // 定时任务数据(顶部动作区副标题)
state.pending = Array.isArray(detail.pending) ? detail.pending : []; // 待投递队列(服务端内存态回显)
renderSendQueue();
renderHeader(); renderHeader();
updateHeaderActions(); updateHeaderActions();
+1
View File
@@ -170,6 +170,7 @@
schedule: null, // 当前会话定时任务(详情 schedule 字段,null=无) schedule: null, // 当前会话定时任务(详情 schedule 字段,null=无)
sessions: [], // 抽屉列表缓存 sessions: [], // 抽屉列表缓存
attachments: [], // 待发送附件 {file, name, size} attachments: [], // 待发送附件 {file, name, size}
pending: [], // 待投递消息队列(服务端内存态的回显):{id, content, mode, created_at}
editingMsgId: 0, // 正在编辑的历史消息 id(0=普通发送,覆盖式重发) editingMsgId: 0, // 正在编辑的历史消息 id(0=普通发送,覆盖式重发)
lastImgBlobUrl: null, // 任务文件图片预览的 blob URL,下次预览或开新图时回收 lastImgBlobUrl: null, // 任务文件图片预览的 blob URL,下次预览或开新图时回收
lastPdfBlobUrl: null, // 同上:PDF 页内预览的 blob URL(浏览器内建查看器用) lastPdfBlobUrl: null, // 同上:PDF 页内预览的 blob URL(浏览器内建查看器用)
+53 -5
View File
@@ -25,6 +25,18 @@ function pvOfficeUrl(rel) {
String(rel).split('/').filter(Boolean).map(encodeURIComponent).join('/') + '/'; String(rel).split('/').filter(Boolean).map(encodeURIComponent).join('/') + '/';
} }
// 图片预览派生地址:服务端按 w 生成并缓存 WebP,<img> 直连可边下边画;原图只留给“下载”。
function pvPreviewUrl(rel, w) {
return '/api/sessions/' + encodeURIComponent(state.sessionId) +
'/files/preview?path=' + encodeURIComponent(rel) + '&w=' + w;
}
// PDF 预览直连:让内建查看器自己发 Range 请求,不必先 fetch 整包转 blob。
function pvPdfUrl(rel) {
return '/api/sessions/' + encodeURIComponent(state.sessionId) +
'/files/inline?path=' + encodeURIComponent(rel);
}
function pvKind(name) { function pvKind(name) {
const low = String(name).toLowerCase(); const low = String(name).toLowerCase();
if (/\.html?$/i.test(low)) return 'html'; if (/\.html?$/i.test(low)) return 'html';
@@ -36,8 +48,8 @@ function pvKind(name) {
} }
// 文件面板「当前目录」里的图片作为一组,供查看器左右滑动切换。 // 文件面板「当前目录」里的图片作为一组,供查看器左右滑动切换。
// 同组直接用下载直链(<img> 不受 Content-Disposition: attachment 影响),不必逐张取 blob。 // 同组直接用预览派生直链(2048px),不必逐张取原图/blob,滑动的预取也不会打满带宽。
// 依赖 files.js 的 filesNodeAt / filesCurDir / assetDownloadUrl(同为全局,加载顺序在前)。 // 依赖 files.js 的 filesNodeAt / filesCurDir(同为全局,加载顺序在前)。
function pvImgGroup(name) { function pvImgGroup(name) {
try { try {
if (typeof filesNodeAt !== 'function') return null; if (typeof filesNodeAt !== 'function') return null;
@@ -46,7 +58,7 @@ function pvImgGroup(name) {
const paths = node.files.map(f => f.filename).filter(p => PV_IMG.test(p)); const paths = node.files.map(f => f.filename).filter(p => PV_IMG.test(p));
if (paths.length < 2) return null; if (paths.length < 2) return null;
return { return {
list: paths.map(p => ({ src: assetDownloadUrl(p), alt: p.split('/').pop() })), list: paths.map(p => ({ src: pvPreviewUrl(p, 2048), alt: p.split('/').pop() })),
at: paths.indexOf(name), at: paths.indexOf(name),
}; };
} catch (_) { return null; } } catch (_) { return null; }
@@ -54,8 +66,9 @@ function pvImgGroup(name) {
// 刷新/新窗口两个钮对**所有**预览类型统一开放: // 刷新/新窗口两个钮对**所有**预览类型统一开放:
// refresh → pvState.reload(各类型都注入「按同一路径重开」,与地址条回车同一条路) // refresh → pvState.reload(各类型都注入「按同一路径重开」,与地址条回车同一条路)
// popup → pvState.url(office=预览网关;文本/HTML/图片/PDF=blob URL;不支持的类型=下载地址) // popup → pvState.url(office=预览网关;图片/PDF=inline 直链;
// 服务端文件响应一律是 attachment,直接导航只会触发下载,所以能用 blob 的一律走 blob。 // 文本/HTML=blob URL;不支持的类型=下载地址)
// 下载接口是 attachment,直接导航只会触发下载;图片/PDF 走各自的 inline 路由可直接开新窗口。
function pvToolbar(o) { function pvToolbar(o) {
document.getElementById('pv-refresh').classList.toggle('hidden', !o.refresh); document.getElementById('pv-refresh').classList.toggle('hidden', !o.refresh);
document.getElementById('pv-popup').classList.toggle('hidden', !o.popup); document.getElementById('pv-popup').classList.toggle('hidden', !o.popup);
@@ -223,6 +236,40 @@ async function openFilePreview(name, sizeText) {
show(pvInfoNode(name, sizeText, hint), tbAll); show(pvInfoNode(name, sizeText, hint), tbAll);
return; return;
} }
// 图片走服务端派生预览:<img> 直连边下边画,不再 fetch 整包转 blob;原图只在“下载”时取。
// SVG 保留原路径(移动端还要展示源码),其余图片统一交给 /files/preview。
if (kind === 'img' && !/\.svg$/i.test(name)) {
const alt = String(name).split('/').pop();
const g = pvImgGroup(name);
if (desk) {
const im = document.createElement('img');
im.className = 'pv-img'; im.alt = String(name); im.decoding = 'async';
// 面板宽度约半屏,交给浏览器按 DPR 选 640/1280/2048,手机不会去拉大图
im.sizes = '(min-width: 960px) 50vw, 100vw';
im.srcset = [640, 1280, 2048].map(w => pvPreviewUrl(name, w) + ' ' + w + 'w').join(',');
const url = pvPreviewUrl(name, 2048);
im.src = url;
im.addEventListener('click', () => openImageViewer(url, alt, g && g.list, g && g.at));
im.addEventListener('error', () => {
if (my !== pvSeq) return;
show(pvInfoNode(name, sizeText, '图片读取失败:文件可能已被删除,或格式无法解码。'), tbAll);
});
show(im, Object.assign({}, tbAll, { url }));
} else {
openImageViewer(pvPreviewUrl(name, 2048), alt, g && g.list, g && g.at);
}
return;
}
// PDF 直连 inline 路由:桌面面板与窄窗口(全屏 overlay)都让内建查看器按 Range 取字节,
// 不再 fetch 整包转 blob。show() 会按 desk 自动落到右侧面板或 #fs-viewer。
if (kind === 'pdf') {
const url = pvPdfUrl(name);
const fr = document.createElement('iframe');
fr.className = desk ? 'pv-frame' : 'fs-html-frame';
fr.title = String(name); fr.src = url;
show(fr, Object.assign({}, tbAll, { url }));
return;
}
let r; let r;
try { try {
r = await fetch('/api/sessions/' + state.sessionId + '/files/download?path=' + encodeURIComponent(name)); r = await fetch('/api/sessions/' + state.sessionId + '/files/download?path=' + encodeURIComponent(name));
@@ -358,6 +405,7 @@ async function pvRenderLegacy(name, r, my) {
pvOverlayShow(iframe, { bar: true, name: name, source: html }); // 全宽沉浸,源码可看/可复制 pvOverlayShow(iframe, { bar: true, name: name, source: html }); // 全宽沉浸,源码可看/可复制
if (my !== pvSeq) return; if (my !== pvSeq) return;
} else if (/\.pdf$/i.test(name)) { } else if (/\.pdf$/i.test(name)) {
// 正常路径已在 openFilePreview 用 /files/inline 直连;这里仅作旧路径兜底。
const u = URL.createObjectURL(await r.blob()); const u = URL.createObjectURL(await r.blob());
if (state.lastPdfBlobUrl) { try { URL.revokeObjectURL(state.lastPdfBlobUrl); } catch (_) {} } if (state.lastPdfBlobUrl) { try { URL.revokeObjectURL(state.lastPdfBlobUrl); } catch (_) {} }
state.lastPdfBlobUrl = u; state.lastPdfBlobUrl = u;
+9 -1
View File
@@ -79,6 +79,8 @@
state.sessionTitle = ''; state.sessionTitle = '';
state.sessionType = 'secretary'; state.sessionType = 'secretary';
state.pendingModel = ''; state.pendingModel = '';
state.pending = [];
renderSendQueue();
state.streamEl = null; state.streamEl = null;
state.streamText = ''; state.streamText = '';
state.toolCards = {}; state.toolCards = {};
@@ -190,6 +192,8 @@
state.status = ''; state.status = '';
state.modelId = ''; state.modelId = '';
state.schedule = null; // 防详情返回前残留上一会话的任务状态 state.schedule = null; // 防详情返回前残留上一会话的任务状态
state.pending = []; // 同上:队列是会话级的,先清空,详情回来再回显
renderSendQueue();
// 先从抽屉列表缓存取会话类型,让顶部 icon 立即正确;详情回来后由 renderDetail 纠正 // 先从抽屉列表缓存取会话类型,让顶部 icon 立即正确;详情回来后由 renderDetail 纠正
const cached = (state.sessions || []).find(x => x.id === id); const cached = (state.sessions || []).find(x => x.id === id);
state.sessionType = (cached && cached.assistant_type) || 'secretary'; state.sessionType = (cached && cached.assistant_type) || 'secretary';
@@ -249,6 +253,8 @@
state.status = ''; state.status = '';
state.modelId = ''; state.modelId = '';
state.schedule = null; state.schedule = null;
state.pending = [];
renderSendQueue();
state.pendingModel = ''; state.pendingModel = '';
state.attachments = []; state.attachments = [];
if (typeof clearEditState === 'function') clearEditState(); if (typeof clearEditState === 'function') clearEditState();
@@ -548,13 +554,15 @@
async function stopSession() { async function stopSession() {
if (!state.sessionId) return; if (!state.sessionId) return;
const held = state.status === 'held'; const held = state.status === 'held';
const queued = (state.pending || []).length;
try { try {
if (held) { if (held) {
await req('POST', '/api/sessions/' + state.sessionId + '/release'); await req('POST', '/api/sessions/' + state.sessionId + '/release');
toast('已断开'); toast('已断开');
} else { } else {
await req('POST', '/api/sessions/' + state.sessionId + '/stop'); await req('POST', '/api/sessions/' + state.sessionId + '/stop');
toast('已发送终止指令'); // 「停止」是全停:服务端会把待投递队列一并作废,这里明确告知,不让消息静静消失
toast(queued ? '已终止,队列中 ' + queued + ' 条消息已取消' : '已发送终止指令');
} }
} catch (e) { toast((held ? '断开失败:' : '终止失败:') + e.message); } } catch (e) { toast((held ? '断开失败:' : '终止失败:') + e.message); }
} }
+444 -81
View File
@@ -27,8 +27,11 @@
pendingEnable: {}, // 已写盘但重启前 effective 仍是旧值的 enable 覆盖(id → bool),防卡片回弹 pendingEnable: {}, // 已写盘但重启前 effective 仍是旧值的 enable 覆盖(id → bool),防卡片回弹
deletedModels: {}, // 已从 config.yml 删除、重启前后端仍会返回的模型(id → true):前端隐藏防回弹 deletedModels: {}, // 已从 config.yml 删除、重启前后端仍会返回的模型(id → true):前端隐藏防回弹
expandedGroups: {}, balanceByGroup: {}, balanceRequested: {}, balanceTypes: [], // 平台编辑弹窗工作态见 pfEdit(模块级变量) expandedGroups: {}, balanceByGroup: {}, balanceRequested: {}, balanceTypes: [], // 平台编辑弹窗工作态见 pfEdit(模块级变量)
modelProfileNames: [], // profile 下拉选项(顶层 model_profiles 的 key)
// MCP 服务页:cfgMcp 缓存当前列表;改动待重启生效时置位,顶部常驻重启横幅 // MCP 服务页:cfgMcp 缓存当前列表;改动待重启生效时置位,顶部常驻重启横幅
cfgMcp: [], mcpPendingRestart: false, cfgMcp: [], mcpPendingRestart: false,
mcpStatus: null, // 运行态连接状态:key = name|url|mode(见 mcpStatusKey);null = 没拿到,不显示标记
presets: null, // 平台/MCP 预设(GET /api/config/presets),设置页各页共用
}; };
let setTok = 0; // 异步渲染防竞态令牌 let setTok = 0; // 异步渲染防竞态令牌
@@ -1186,13 +1189,15 @@
const el = $('model-cards'); const el = $('model-cards');
if (!el || (ctx && !ctx())) return; if (!el || (ctx && !ctx())) return;
try { try {
const [rt, cg] = await Promise.all([req('GET', '/api/models'), req('GET', '/api/config')]); const [rt, cg] = await Promise.all([req('GET', '/api/models'), req('GET', '/api/config'), loadPresets()]);
if (ctx && !ctx()) return; if (ctx && !ctx()) return;
if (!$('model-cards')) return; // 异步期间已离开本页 if (!$('model-cards')) return; // 异步期间已离开本页
SET.runtimeById = {}; SET.runtimeById = {};
for (const m of rt || []) SET.runtimeById[m.id] = m; for (const m of rt || []) SET.runtimeById[m.id] = m;
SET.cfgPlatforms = (cg.effective && cg.effective.platforms) || []; SET.cfgPlatforms = (cg.effective && cg.effective.platforms) || [];
SET.cfgModels = (cg.effective && cg.effective.models) || []; SET.cfgModels = (cg.effective && cg.effective.models) || [];
// 平台编辑器里的 profile 下拉只有名字有意义,不缓存整份 prompt
SET.modelProfileNames = Object.keys((cg.effective && cg.effective.model_profiles) || {});
// 已删除/已改名旧 id 的标记清理:配置(live)与运行池都已无此 id 才清——重启前池里残留时须保留标记, // 已删除/已改名旧 id 的标记清理:配置(live)与运行池都已无此 id 才清——重启前池里残留时须保留标记,
// 否则会话页选择弹窗(读 /api/models 运行池)会重新列出已不可用的模型。 // 否则会话页选择弹窗(读 /api/models 运行池)会重新列出已不可用的模型。
const liveIds = new Set(SET.cfgModels.map(m => m.id)); const liveIds = new Set(SET.cfgModels.map(m => m.id));
@@ -1248,23 +1253,105 @@
for (const m of SET.cfgModels) if (m.platform_index === pi && !seen.has(m.id)) { seen.add(m.id); models.push(m); } for (const m of SET.cfgModels) if (m.platform_index === pi && !seen.has(m.id)) { seen.add(m.id); models.push(m); }
return models; return models;
} }
// 参数对象 → 弹窗里的 JSON 文本。空对象留空(placeholder 提示),避免每张卡都挂一对 {}
function pfJsonText(o) {
return o && typeof o === 'object' && Object.keys(o).length ? JSON.stringify(o) : '';
}
// 预设的模型参数缺省:抽成函数因为「选预设」和「加模型行」两处都要套
function applyModelDefaults(r, preset) {
const d = (preset && preset.model_defaults) || {};
r.extra_params = pfJsonText(d.extra_params);
r.thinking_params = pfJsonText(d.thinking_params);
r.reasoning_ack_field = d.reasoning_ack_field || '';
r.profile = d.profile || '';
}
// 该行的高级参数是否还是「空/上一个预设的缺省」:是才允许被新预设覆盖,不动用户手填的内容
function pfUsesDefaults(r, preset) {
const d = (preset && preset.model_defaults) || {};
return String(r.extra_params || '') === pfJsonText(d.extra_params) &&
String(r.thinking_params || '') === pfJsonText(d.thinking_params) &&
String(r.reasoning_ack_field || '') === String(d.reasoning_ack_field || '') &&
String(r.profile || '') === String(d.profile || '');
}
function pfNewModel() {
const r = { ref: null, id: '', vision: true, enable: true, display_name: '', profile: '',
extra_params: '', thinking_params: '', reasoning_ack_field: '', adv: false };
if (pfEdit) applyModelDefaults(r, pfEdit.preset);
return r;
}
function openModelEditor(pi) { function openModelEditor(pi) {
const add = pi == null; const add = pi == null;
const p = add ? {} : (SET.cfgPlatforms[pi] || {}); const p = add ? {} : (SET.cfgPlatforms[pi] || {});
pfEdit = { pfEdit = {
idx: add ? -1 : Number(pi), idx: add ? -1 : Number(pi),
// 已有 Key:输入框置空(留空=保持原值),masked 存脱敏值仅做 placeholder 提示;绝不把脱敏值回写文件 preset: null,
// 已有 Key:输入框置空(留空=保持原值),masked 存脱敏仅做 placeholder 提示;绝不把脱敏值回写文件
keys: add ? [] : (p.keys || []).map((k, ki) => ({ ref: ki, api_key: '', masked: k.api_key || '' })), keys: add ? [] : (p.keys || []).map((k, ki) => ({ ref: ki, api_key: '', masked: k.api_key || '' })),
models: add ? [] : platformModels(pi).map(m => ({ ref: m.model_index, id: m.mid || m.id, vision: !!m.vision, enable: m.enable !== false })), models: add ? [] : platformModels(pi).map(m => ({
ref: m.model_index,
id: m.mid || m.id,
vision: !!m.vision,
enable: m.enable !== false,
// 显示名缺省就是 id(config.js 归一化过):相同时留空,弹窗里不重复展示
display_name: m.display_name && m.display_name !== (m.mid || m.id) ? m.display_name : '',
profile: m.profile || '',
extra_params: pfJsonText(m.extra_params),
thinking_params: pfJsonText(m.thinking_params),
reasoning_ack_field: m.reasoning_ack_field || '',
adv: false,
})),
}; };
$('mpe-title').textContent = add ? '新增平台' : '编辑平台'; $('mpe-title').textContent = add ? '新增平台' : '编辑平台';
$('mpe-name').value = add ? '' : (p.name || ''); $('mpe-name').value = add ? '' : (p.name || '');
$('mpe-url').value = add ? '' : (p.url || ''); $('mpe-url').value = add ? '' : (p.url || '');
if (add) { pfEdit.keys.push({ ref: null, api_key: '' }); pfEdit.models.push({ ref: null, id: '', vision: true, enable: true }); } if (add) { pfEdit.keys.push({ ref: null, api_key: '' }); pfEdit.models.push(pfNewModel()); }
$('mpe-del-btn').classList.toggle('hidden', add); $('mpe-del-btn').classList.toggle('hidden', add);
renderPfPresets();
renderPfRows(); renderPfRows();
$('model-edit-modal').classList.remove('hidden'); $('model-edit-modal').classList.remove('hidden');
} }
// 新增平台时的平台预设:点一下填好 url / 平台名,模型行带上该平台的参数缺省
function renderPfPresets() {
const box = $('mpe-presets');
if (!box) return;
const list = (SET.presets && SET.presets.platforms) || [];
const show = !!pfEdit && pfEdit.idx < 0 && list.length > 0;
box.classList.toggle('hidden', !show);
if (!show) { box.innerHTML = ''; return; }
const cur = pfEdit.preset ? pfEdit.preset.key : '';
box.innerHTML = list.map(p =>
'<button type="button" class="mpe-chip' + (cur === p.key ? ' on' : '') + '" onclick="sUI.mPreset(\'' + att(p.key) + '\')">' + esc(p.label || p.key) + '</button>'
).join('') +
'<button type="button" class="mpe-chip' + (cur ? '' : ' on') + '" onclick="sUI.mPreset(\'\')">自定义</button>';
}
function applyPfPreset(key) {
if (!pfEdit || pfEdit.idx >= 0) return;
// 已经是自定义:不重复清空用户正在手填的内容
if (!key && !pfEdit.preset) return;
const list = (SET.presets && SET.presets.platforms) || [];
const preset = key ? (list.find(x => x.key === key) || null) : null;
const prev = pfEdit.preset;
pfEdit.preset = preset;
if (preset) {
$('mpe-url').value = preset.url || '';
// 名称只在不覆盖手输时跟随预设(空 / 还等于上一个预设名)
const nm = $('mpe-name').value.trim();
if (!nm || nm === (prev ? prev.key : '')) $('mpe-name').value = preset.key || '';
} else {
// 自定义 = 从空白开始:清空平台字段与 Key/模型行(含刚套上的预设参数)
$('mpe-name').value = '';
$('mpe-url').value = '';
pfEdit.keys = [{ ref: null, api_key: '' }];
pfEdit.models = [pfNewModel()];
}
// 只改「新增行」且高级参数还是空/上一个预设缺省的行;已有模型与手填内容一律不动
for (const r of pfEdit.models) {
if (r.ref != null) continue;
if (pfUsesDefaults(r, prev)) applyModelDefaults(r, preset);
}
renderPfPresets();
renderPfRows();
}
// Key 行:全部可编辑。已有 Key 输入框置空 + placeholder 提示当前脱敏值,输入新值=替换,留空=保持。 // Key 行:全部可编辑。已有 Key 输入框置空 + placeholder 提示当前脱敏值,输入新值=替换,留空=保持。
function pfKeysRowHtml(r, i) { function pfKeysRowHtml(r, i) {
const ph = r.ref == null const ph = r.ref == null
@@ -1275,18 +1362,33 @@
'<button class="mpe-del" title="删除此 Key" onclick="sUI.mDelKey(' + i + ')">×</button>' + '<button class="mpe-del" title="删除此 Key" onclick="sUI.mDelKey(' + i + ')">×</button>' +
'</div>'; '</div>';
} }
// 模型子卡片两行:上行配 id,下行勾 vision/enable。id 可改(仅改 config.yml,重启生效)。 // 模型子卡片:上行配 id,中行勾 vision/enable + 「高级」,高级区放不常改的字段。
// display_name/concurrency/type 不进弹窗:保存只按细粒度 path 改,不碰文件里其余字段。 // 全部走细粒度 path 保存,不整体覆盖模型对象(保住文件里的手写字段)。
function pfModelsRowHtml(r, i) { function pfModelsRowHtml(r, i) {
const ph = (pfEdit && pfEdit.preset && pfEdit.preset.model_hint) || 'id(上游模型名)';
const profiles = (SET.modelProfileNames || []).slice();
// 配置里引用了但不在下拉里的 profile(手工改过 YAML):补一项,避免保存时被静默改回默认
if (r.profile && profiles.indexOf(r.profile) < 0) profiles.push(r.profile);
const adv = r.adv ? '<div class="mpe-adv">' +
'<label class="mpe-line"><span>显示名</span><input type="text" placeholder="默认同 id" value="' + att(r.display_name) + '" oninput="sUI.mModField(' + i + ',\'display_name\',this.value)"></label>' +
'<label class="mpe-line"><span>Profile</span><select onchange="sUI.mModField(' + i + ',\'profile\',this.value)">' +
'<option value="">默认</option>' +
profiles.map(n => '<option value="' + att(n) + '"' + (n === r.profile ? ' selected' : '') + '>' + esc(n) + '</option>').join('') +
'</select></label>' +
'<label class="mpe-line"><span>请求参数</span><textarea rows="2" spellcheck="false" placeholder=\'{"key":"value"}\' oninput="sUI.mModField(' + i + ',\'extra_params\',this.value)">' + esc(r.extra_params) + '</textarea></label>' +
'<label class="mpe-line"><span>思考参数</span><textarea rows="2" spellcheck="false" placeholder=\'{"reasoning_effort":"max"}\' oninput="sUI.mModField(' + i + ',\'thinking_params\',this.value)">' + esc(r.thinking_params) + '</textarea></label>' +
'<label class="mpe-line"><span>思考链回传</span><input type="text" placeholder="回传字段名" value="' + att(r.reasoning_ack_field) + '" oninput="sUI.mModField(' + i + ',\'reasoning_ack_field\',this.value)"></label>' +
'</div>' : '';
return '<div class="mpe-mcard">' + return '<div class="mpe-mcard">' +
'<div class="mpe-row">' + '<div class="mpe-row">' +
'<input class="mpe-grow" type="text" placeholder="id(上游模型名)" value="' + esc(r.id) + '" oninput="sUI.mModId(' + i + ',this.value)">' + '<input class="mpe-grow" type="text" placeholder="' + att(ph) + '" value="' + att(r.id) + '" oninput="sUI.mModId(' + i + ',this.value)">' +
'<button class="mpe-del" title="删除此模型" onclick="sUI.mDelModel(' + i + ')">×</button>' + '<button class="mpe-del" title="删除此模型" onclick="sUI.mDelModel(' + i + ')">×</button>' +
'</div>' + '</div>' +
'<div class="mpe-cks">' + '<div class="mpe-cks">' +
'<label class="mpe-ck"><input type="checkbox"' + (r.vision ? ' checked' : '') + ' onchange="sUI.mModVision(' + i + ',this.checked)">图片输入</label>' + '<label class="mpe-ck"><input type="checkbox"' + (r.vision ? ' checked' : '') + ' onchange="sUI.mModVision(' + i + ',this.checked)">图片输入</label>' +
'<label class="mpe-ck"><input type="checkbox"' + (r.enable !== false ? ' checked' : '') + ' onchange="sUI.mModEnable(' + i + ',this.checked)">启用</label>' + '<label class="mpe-ck"><input type="checkbox"' + (r.enable !== false ? ' checked' : '') + ' onchange="sUI.mModEnable(' + i + ',this.checked)">启用</label>' +
'</div>' + '<button type="button" class="mpe-adv-btn" onclick="sUI.mAdvToggle(' + i + ')">' + (r.adv ? '收起' : '高级') + '</button>' +
'</div>' + adv +
'</div>'; '</div>';
} }
// 行下标变化后需重渲染(事件处理器里捕获了旧 i),故增删后重建两段行列表。 // 行下标变化后需重渲染(事件处理器里捕获了旧 i),故增删后重建两段行列表。
@@ -1296,7 +1398,7 @@
$('mpe-models').innerHTML = pfEdit.models.map(pfModelsRowHtml).join('') || '<div class="model-group-empty">至少保留一个模型</div>'; $('mpe-models').innerHTML = pfEdit.models.map(pfModelsRowHtml).join('') || '<div class="model-group-empty">至少保留一个模型</div>';
} }
function addPfKey() { if (!pfEdit) return; pfEdit.keys.push({ ref: null, api_key: '' }); renderPfRows(); } function addPfKey() { if (!pfEdit) return; pfEdit.keys.push({ ref: null, api_key: '' }); renderPfRows(); }
function addPfModel() { if (!pfEdit) return; pfEdit.models.push({ ref: null, id: '', vision: true, enable: true }); renderPfRows(); } function addPfModel() { if (!pfEdit) return; pfEdit.models.push(pfNewModel()); renderPfRows(); }
function delPfKey(i) { function delPfKey(i) {
if (!pfEdit) return; if (!pfEdit) return;
if (pfEdit.keys.length <= 1) return toast('至少保留一个 Key'); if (pfEdit.keys.length <= 1) return toast('至少保留一个 Key');
@@ -1310,6 +1412,37 @@
function setPfKey(i, f, v) { if (pfEdit && pfEdit.keys[i]) pfEdit.keys[i][f] = v; } function setPfKey(i, f, v) { if (pfEdit && pfEdit.keys[i]) pfEdit.keys[i][f] = v; }
function setPfModel(i, f, v) { if (pfEdit && pfEdit.models[i]) pfEdit.models[i][f] = v; } function setPfModel(i, f, v) { if (pfEdit && pfEdit.models[i]) pfEdit.models[i][f] = v; }
function closeModelEditor() { $('model-edit-modal').classList.add('hidden'); } function closeModelEditor() { $('model-edit-modal').classList.add('hidden'); }
// JSON 参数:留空 = {}(不写进文件);非空必须是 JSON 对象(数组/标量对上游没意义)
function pfParams(r, key, label) {
const txt = String(r[key] || '').trim();
if (!txt) return {};
let v;
try { v = JSON.parse(txt); } catch (_) {
throw new Error('模型「' + (String(r.id || '').trim() || '未命名') + '」的' + label + '不是合法 JSON');
}
if (!v || typeof v !== 'object' || Array.isArray(v)) {
throw new Error('模型「' + (String(r.id || '').trim() || '未命名') + '」的' + label + '要填 JSON 对象,如 {"key":"value"}');
}
return v;
}
// 新增行/新增平台时落盘的模型对象:只写非缺省项,其余交给 config.js 的默认值
function pfModelValue(r) {
const id = String(r.id || '').trim();
const nv = { id };
if (r.vision === false) nv.vision = false; // 缺省 true,只在取消勾选时显式落键
if (r.enable === false) nv.enable = false;
const dn = String(r.display_name || '').trim();
if (dn && dn !== id) nv.display_name = dn;
const prof = String(r.profile || '').trim();
if (prof) nv.profile = prof;
const ep = pfParams(r, 'extra_params', '请求参数');
if (Object.keys(ep).length) nv.extra_params = ep;
const tp = pfParams(r, 'thinking_params', '思考参数');
if (Object.keys(tp).length) nv.thinking_params = tp;
const ra = String(r.reasoning_ack_field || '').trim();
if (ra) nv.reasoning_ack_field = ra;
return nv;
}
// 根据工作态算批量编辑:原地改(值变更项) → 删行(降序) → 新增行(append)。 // 根据工作态算批量编辑:原地改(值变更项) → 删行(降序) → 新增行(append)。
// YAML 数组删项后下标收紧,同批内删/改/增按原 ref 定位,服务端依次应用。 // YAML 数组删项后下标收紧,同批内删/改/增按原 ref 定位,服务端依次应用。
function buildPfEdits() { function buildPfEdits() {
@@ -1333,25 +1466,59 @@
if (!pfEdit.keys.some(r => r.ref === ki)) delKeys.push(ki); if (!pfEdit.keys.some(r => r.ref === ki)) delKeys.push(ki);
} }
delKeys.sort((a, b) => b - a).forEach(ki => edits.push({ op: 'delete', path: ['platforms', pfEdit.idx, 'keys', ki] })); delKeys.sort((a, b) => b - a).forEach(ki => edits.push({ op: 'delete', path: ['platforms', pfEdit.idx, 'keys', ki] }));
// 模型:已有行只按细粒度 path 改 vision/enable(不整体覆盖,保住文件里的 display_name/extra_params 等); // 模型:已有行全部按细粒度 path 改(不整体覆盖,保住文件里的手写字段与其他参数);
// 新增行 append 最小对象(缺省项不写:display_name 后端同 id,enable 缺省启用) // 新增行 append 最小对象(缺省项不写:display_name 同 id、enable 缺省启用、参数为空)
pfEdit.models.forEach(r => { pfEdit.models.forEach(r => {
if (r.ref != null) { if (r.ref != null) {
const om = (p.models || [])[r.ref] || {}; const om = (p.models || [])[r.ref] || {};
const mp = ['platforms', pfEdit.idx, 'models', r.ref];
const nid = String(r.id || '').trim(); const nid = String(r.id || '').trim();
if (nid && om.id && nid !== om.id) { if (nid && om.id && nid !== om.id) {
edits.push({ path: ['platforms', pfEdit.idx, 'models', r.ref, 'id'], value: nid }); edits.push({ path: mp.concat('id'), value: nid });
SET.deletedModels[p.name + '/' + om.id] = true; // 重启前运行池里旧 id 不再可绑,标记隐藏 SET.deletedModels[p.name + '/' + om.id] = true; // 重启前运行池里旧 id 不再可绑,标记隐藏
delete SET.deletedModels[p.name + '/' + nid]; // 改成曾被删的 id:清掉旧标记防误屏蔽 delete SET.deletedModels[p.name + '/' + nid]; // 改成曾被删的 id:清掉旧标记防误屏蔽
} }
if (!!om.vision !== !!r.vision) edits.push({ path: ['platforms', pfEdit.idx, 'models', r.ref, 'vision'], value: !!r.vision }); if (!!om.vision !== !!r.vision) edits.push({ path: mp.concat('vision'), value: !!r.vision });
if ((om.enable !== false) !== (r.enable !== false)) edits.push({ path: ['platforms', pfEdit.idx, 'models', r.ref, 'enable'], value: r.enable !== false }); if ((om.enable !== false) !== (r.enable !== false)) edits.push({ path: mp.concat('enable'), value: r.enable !== false });
// 显示名缺省 = id:空值/等于 id 都按「不写」处理
const curDn = String(om.display_name || '');
const dn = String(r.display_name || '').trim();
if (!dn || dn === (nid || om.id)) {
if (curDn && curDn !== om.id) edits.push({ path: mp.concat('display_name'), op: 'delete' });
} else if (dn !== curDn) {
edits.push({ path: mp.concat('display_name'), value: dn });
}
const curProf = String(om.profile || '');
const prof = String(r.profile || '').trim();
if (!prof) {
if (curProf) edits.push({ path: mp.concat('profile'), op: 'delete' });
} else if (prof !== curProf) {
edits.push({ path: mp.concat('profile'), value: prof });
}
// 参数类:值没变就不写(避免无意义重写丢掉节点注释);清空 = 删键,回落默认 {}
const curEp = om.extra_params || {};
const ep = pfParams(r, 'extra_params', '请求参数');
if (JSON.stringify(ep) !== JSON.stringify(curEp)) {
edits.push(Object.keys(ep).length
? { path: mp.concat('extra_params'), value: ep }
: { path: mp.concat('extra_params'), op: 'delete' });
}
const curTp = om.thinking_params || {};
const tp = pfParams(r, 'thinking_params', '思考参数');
if (JSON.stringify(tp) !== JSON.stringify(curTp)) {
edits.push(Object.keys(tp).length
? { path: mp.concat('thinking_params'), value: tp }
: { path: mp.concat('thinking_params'), op: 'delete' });
}
const curRa = String(om.reasoning_ack_field || '');
const ra = String(r.reasoning_ack_field || '').trim();
if (!ra) {
if (curRa) edits.push({ path: mp.concat('reasoning_ack_field'), op: 'delete' });
} else if (ra !== curRa) {
edits.push({ path: mp.concat('reasoning_ack_field'), value: ra });
}
} else { } else {
const id = String(r.id || '').trim(); edits.push({ op: 'append', path: ['platforms', pfEdit.idx, 'models'], value: pfModelValue(r) });
const nv = { id };
if (r.vision === false) nv.vision = false; // 后端缺省已改 true:勾上靠缺省不落键,取消勾选必须显式写 false
if (r.enable === false) nv.enable = false;
edits.push({ op: 'append', path: ['platforms', pfEdit.idx, 'models'], value: nv });
} }
}); });
const delMods = (p.models || []).map((_, i) => i).filter(i => !pfEdit.models.some(r => r.ref === i)).sort((a, b) => b - a); const delMods = (p.models || []).map((_, i) => i).filter(i => !pfEdit.models.some(r => r.ref === i)).sort((a, b) => b - a);
@@ -1376,23 +1543,23 @@
let edits; let edits;
try { try {
if (add) { if (add) {
// 新增平台:一次 append 整个对象(name 留空由服务端取主机段;type/concurrency/display_name 均不落配置,走各自缺省) // 新增平台:一次 append 整个对象
edits = [{ op: 'append', path: ['platforms'], value: { const obj = {
name, url, name, url,
keys: pfEdit.keys.map(r => ({ api_key: String(r.api_key || '').trim() })), keys: pfEdit.keys.map(r => ({ api_key: String(r.api_key || '').trim() })),
models: pfEdit.models.map(r => { models: pfEdit.models.map(pfModelValue),
const id = String(r.id).trim(); };
const nv = { id }; // 用预设时把余额查询类型固定下来(不展示给用户):名字与预设一致可不写(服务端缺省 = 平台名)
if (r.vision === false) nv.vision = false; // 同上:缺省 true,只在取消勾选时显式落键 const presetType = pfEdit.preset ? String(pfEdit.preset.type || pfEdit.preset.key || '') : '';
if (r.enable === false) nv.enable = false; if (presetType && presetType !== name) obj.type = presetType;
return nv; edits = [{ op: 'append', path: ['platforms'], value: obj }];
}),
} }];
} else { } else {
// 改名不影响 pi(数组位置);其余按原 ref 定位,见 buildPfEdits // 改名不影响 pi(数组位置);其余按原 ref 定位,见 buildPfEdits
edits = buildPfEdits(); edits = buildPfEdits();
if (!edits.length) { closeModelEditor(); return toast('没有变更'); } if (!edits.length) { closeModelEditor(); return toast('没有变更'); }
} }
} catch (e) { return toast(e.message); } // JSON 校验失败等:提示后不发请求
try {
await req('PATCH', '/api/config', { edits }); await req('PATCH', '/api/config', { edits });
// 重加同名模型(重启前被标记隐藏的):清掉删除标记防误屏蔽 // 重加同名模型(重启前被标记隐藏的):清掉删除标记防误屏蔽
const pname = name || (SET.cfgPlatforms[pfEdit.idx] || {}).name || ''; const pname = name || (SET.cfgPlatforms[pfEdit.idx] || {}).name || '';
@@ -1425,8 +1592,38 @@
// mode 三态:advertise(默认,工具下发给模型) / skill(不下发,以技能形式暴露) / disable(不加载): // mode 三态:advertise(默认,工具下发给模型) / skill(不下发,以技能形式暴露) / disable(不加载):
// 默认值不写进文件——选 advertise 时删键,回落到 config.js 的缺省。 // 默认值不写进文件——选 advertise 时删键,回落到 config.js 的缺省。
// 运行配置(cg.effective.mcp_servers)即文件刚解析后的视图,按 pi 直接定位;重启后才会重新发现工具。 // 运行配置(cg.effective.mcp_servers)即文件刚解析后的视图,按 pi 直接定位;重启后才会重新发现工具。
let mcpEdit = null; // 工作态:{ idx, headers:[{key, value, masked}] };idx=-1 为新增 // 预设取一次就缓存:取不到不报错,退化成纯自定义列表,不阻塞设置页
let presetsReq = null;
function loadPresets() {
if (SET.presets) return Promise.resolve(SET.presets);
if (!presetsReq) {
presetsReq = req('GET', '/api/config/presets').then(p => {
SET.presets = { platforms: (p && p.platforms) || [], mcp: (p && p.mcp) || [] };
return SET.presets;
}).catch(() => {
presetsReq = null; // 失败不缓存,下次进页再试
return { platforms: [], mcp: [] };
});
}
return presetsReq;
}
function presetMcpList() { return (SET.presets && SET.presets.mcp) || []; }
let mcpEdit = null; // 工作态:{ idx, preset, values:{header:值}, headers:[{key, value, masked}] };idx=-1 为新增
const MCP_HEADER_MASK = '*****'; // 与后端 routes/config.js 的掩码保持一致 const MCP_HEADER_MASK = '*****'; // 与后端 routes/config.js 的掩码保持一致
const MCP_MODE_LABELS = {
advertise: 'advertise(下发给模型)',
skill: 'skill(以技能形式暴露)',
disable: 'disable(不加载)',
};
// url 归一化:内置服务按 url 认亲(name 允许用户改),尾斜杠不算差异
function normUrl(u) { return String(u || '').trim().replace(/\/+$/, ''); }
function presetIdx(p) {
const url = normUrl(p.url);
let i = SET.cfgMcp.findIndex(s => normUrl(s.url) === url);
if (i < 0) i = SET.cfgMcp.findIndex(s => String(s.name || '') === p.key);
return i;
}
async function setPageMcp(ctx) { async function setPageMcp(ctx) {
setTitle('MCP 服务'); setTitle('MCP 服务');
setActions('<button class="icon-btn" title="添加 MCP 服务" onclick="mcpUI.add()">' + setActions('<button class="icon-btn" title="添加 MCP 服务" onclick="mcpUI.add()">' +
@@ -1434,41 +1631,98 @@
setBody('<div class="set-scroll" id="mcp-list"><div class="empty-tip">加载中…</div></div>'); setBody('<div class="set-scroll" id="mcp-list"><div class="empty-tip">加载中…</div></div>');
await loadMcpList(ctx); await loadMcpList(ctx);
} }
// 连接状态的认亲键:name + url + mode(与后端 mcp.statusKeyOf 一致,url 去尾斜杠)
function mcpStatusKey(s) {
return [s.name, normUrl(s.url), s.mode || 'advertise'].join('|');
}
// 运行态连接标记:没有运行态记录 = 配置比进程新(刚加、改了 url/mode),需重启才生效;
// 整个状态接口没拿到(null)= 无从判断,宁可不显示也不要全部误报「待重启」。
function mcpConnChip(s) {
if (!SET.mcpStatus) return '';
const st = SET.mcpStatus.get(mcpStatusKey(s));
if (!st) return '<span class="model-card-state pending" title="配置已写入,重启后生效">待重启</span>';
if (st.disabled) return '<span class="model-card-state off">已停用</span>';
if (st.ok) {
const extra = st.hidden ? ',其中 ' + st.hidden + ' 个以技能暴露' : '';
return '<span class="model-card-state idle" title="发现 ' + (st.tools || 0) + ' 个工具' + extra + '">已连接</span>';
}
return '<span class="model-card-state busy" title="' + att(st.error || '连接失败') + '">未连接</span>';
}
async function loadMcpList(ctx) { async function loadMcpList(ctx) {
const box = $('mcp-list'); const box = $('mcp-list');
if (!box || (ctx && !ctx())) return; if (!box || (ctx && !ctx())) return;
try { try {
const cg = await req('GET', '/api/config'); const [cg, , st] = await Promise.all([
if (ctx && !ctx()) return; req('GET', '/api/config'),
if (!$('mcp-list')) return; loadPresets(),
// 状态接口失败不该挡住整个页面(老进程没有该路由 / 网络抖动):拿不到就不显示连接标记
req('GET', '/api/config/mcp-status').catch(() => null),
]);
if ((ctx && !ctx()) || !$('mcp-list')) return;
SET.cfgMcp = (cg.effective && cg.effective.mcp_servers) || []; SET.cfgMcp = (cg.effective && cg.effective.mcp_servers) || [];
if (!SET.cfgMcp.length) { const statusList = st && Array.isArray(st.servers) ? st.servers : null;
box.innerHTML = (SET.mcpPendingRestart SET.mcpStatus = statusList ? new Map(statusList.map(x => [mcpStatusKey(x), x])) : null;
? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>' const presets = presetMcpList();
: '') + '<div class="empty-tip">尚未配置 MCP 服务,点右上角 + 添加。</div>'; // 内置服务已占用的条目不再列入「其它」,避免同一服务出两张卡
return; const taken = new Set(presets.map(presetIdx).filter(i => i >= 0));
} const others = SET.cfgMcp.map((s, i) => ({ s, i })).filter(o => !taken.has(o.i));
const banner = SET.mcpPendingRestart let html = SET.mcpPendingRestart
? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>' ? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>'
: ''; : '';
box.innerHTML = banner + SET.cfgMcp.map(mcpCardHtml).join('') + if (presets.length) {
'<div class="empty-tip">点卡片编辑 MCP 服务。advertise 的工具启动时发现并追加到内置工具之后;skill 不下发,改为以技能形式暴露(skill 工具里 get 拿到原始 input_schema)。</div>'; html += '<div class="mcp-sec-title">内置服务</div>' + presets.map(presetCardHtml).join('');
}
if (others.length) {
html += '<div class="mcp-sec-title">其它服务</div>' + others.map(o => mcpCardHtml(o.s, o.i)).join('');
}
if (!presets.length && !others.length) {
html += '<div class="empty-tip">尚未配置 MCP 服务,点右上角 + 添加。</div>';
}
$('mcp-list').innerHTML = html;
} catch (e) { } catch (e) {
const b = $('mcp-list'); const b = $('mcp-list');
if (b && (!ctx || ctx())) b.innerHTML = '<div class="empty-tip">加载失败:' + esc(e.message) + '</div>'; if (b && (!ctx || ctx())) b.innerHTML = '<div class="empty-tip">加载失败:' + esc(e.message) + '</div>';
} }
} }
// 内置服务卡:未配置→添加;已配置→显示当前值与状态,点击编辑。密钥类只显示「已配置」,不外显真值。
function presetCardHtml(p) {
const idx = presetIdx(p);
const s = idx >= 0 ? (SET.cfgMcp[idx] || {}) : null;
const mode = s ? (s.mode || 'advertise') : '';
// 标签用中性灰,颜色只表达连接状态(续=已连接 / 红=未连接 / 黄=待重启)
const state = !s
? '<span class="model-card-state off">未配置</span>'
: '<span class="model-card-state off">已配置</span>' +
(mode === 'disable' ? '' : mcpConnChip(s));
const h = (s && s.headers) || {};
const kv = (p.fields || []).map(f => {
const v = h[f.header];
const txt = f.secret ? (v ? '已配置' : '--') : (v ? String(v) : '--');
return '<div class="cfg-kv"><label>' + esc(f.label || f.header) + '</label><b>' + esc(txt) + '</b></div>';
}).join('');
return '<div class="model-card' + (mode === 'disable' ? ' off' : '') + '"' +
' onclick="mcpUI.' + (s ? 'editPreset' : 'addPreset') + '(\'' + att(p.key) + '\')">' +
'<div class="model-card-head">' +
'<span class="model-card-name">' + esc(p.label || p.key) + '</span>' +
state +
'</div>' +
'<div class="cfg-kv"><label>地址</label><b>' + esc(p.url) + '</b></div>' + kv +
'</div>';
}
// MCP 卡:头部 = 名称 + url + mode 状态;体内 = headers 键值列表。整卡点击进入编辑。 // MCP 卡:头部 = 名称 + url + mode 状态;体内 = headers 键值列表。整卡点击进入编辑。
function mcpCardHtml(s, pi) { function mcpCardHtml(s, pi) {
const mode = s.mode || 'advertise'; const mode = s.mode || 'advertise';
const stateHtml = mode === 'disable' // 同样:模式文字保持中性,颜色留给连接状态
? '<span class="model-card-state off">已禁用</span>' const stateHtml = '<span class="model-card-state off">' +
: mode === 'skill' (mode === 'disable' ? '已禁用' : mode === 'skill' ? '以技能暴露' : '启用') + '</span>' +
? '<span class="model-card-state idle">以技能暴露</span>' (mode === 'disable' ? '' : mcpConnChip(s));
: '<span class="model-card-state idle">启用</span>';
const entries = Object.entries(s.headers || {}); const entries = Object.entries(s.headers || {});
// header 值等同密码对待:后端 effective 已脱敏为固定短掩码,这里透传展示;若收到未脱敏原文也一律替换,不外显 // 后端只对密钥类 header 脱敏(base-url/model 这类明文);掩码值统一显示「已配置」,不露长度
const maskVal = (v) => { const str = String(v == null ? '' : v); if (!str) return '--'; return str.includes('*') ? esc(str) : MCP_HEADER_MASK; }; const maskVal = (v) => {
const str = String(v == null ? '' : v);
if (!str) return '--';
return str === MCP_HEADER_MASK ? '已配置' : esc(str);
};
const headersHtml = entries.length const headersHtml = entries.length
? entries.map(([k, v]) => '<div class="cfg-kv"><label>' + esc(k) + '</label><b>' + maskVal(v) + '</b></div>').join('') ? entries.map(([k, v]) => '<div class="cfg-kv"><label>' + esc(k) + '</label><b>' + maskVal(v) + '</b></div>').join('')
: '<div class="cfg-kv"><label>(无)</label><b>--</b></div>'; : '<div class="cfg-kv"><label>(无)</label><b>--</b></div>';
@@ -1480,25 +1734,58 @@
'</div>' + headersHtml + '</div>' + headersHtml +
'</div>'; '</div>';
} }
// 弹窗打开:add 模式 (idx=-1) → 空工作态;edit 模式 → 从当前配置复制。 // 弹窗打开:add 模式 (idx=null) → 空工作态;edit 模式 → 从当前配置复制。
function openMcpEditor(idx) { // presetKey 有值 = 内置服务模式:url/name/mode 是契约(只读),表单由预设的 fields 生成。
function openMcpEditor(idx, presetKey) {
const preset = presetKey ? (presetMcpList().find(p => p.key === presetKey) || null) : null;
const add = idx == null; const add = idx == null;
const s = add ? {} : (SET.cfgMcp[idx] || {}); const s = add ? {} : (SET.cfgMcp[idx] || {});
const curH = s.headers || {};
const fieldHeaders = new Set(((preset && preset.fields) || []).map(f => f.header));
mcpEdit = { mcpEdit = {
idx: add ? -1 : Number(idx), idx: add ? -1 : Number(idx),
preset: preset,
values: {},
// 预设字段走 values;这里只留「配置里有、预设未声明」的 header(手加的)——
// headers 是整体替换的,不带着它们保存一次就丢了。
headers: Object.keys(curH).filter(k => !fieldHeaders.has(k)).map(k => {
const v = String(curH[k]);
// 明文值直接回填(可原地改);掩码值置空,placeholder 提示「留空保持不变」
return { key: k, value: v === MCP_HEADER_MASK ? '' : v, masked: v };
}),
};
if (preset) {
(preset.fields || []).forEach(f => {
// 明文项回填当前值(看得见才好改);密钥项只提示「已配置」,留空即保持原值
mcpEdit.values[f.header] = add
? (f.secret ? '' : String(f.default || ''))
: (f.secret ? '' : String(curH[f.header] || ''));
});
} else if (add) {
// headers 数组:每个 {key, value, masked} 为一条编辑行。已有行 value 置空、masked 存当前脱敏值仅做提示 // headers 数组:每个 {key, value, masked} 为一条编辑行。已有行 value 置空、masked 存当前脱敏值仅做提示
// (同平台 Key 的留空=保持原值);新行 masked=null,必须手输真值。空 key 行保存时丢弃。 // (同平台 Key 的留空=保持原值);新行 masked=null,必须手输真值。空 key 行保存时丢弃。
headers: add mcpEdit.headers = [{ key: '', value: '', masked: null }];
? [{ key: '', value: '', masked: null }] }
: Object.entries(s.headers || {}).map(([k, v]) => ({ key: k, value: '', masked: String(v) })), $('mce-title').textContent = (add ? '添加 ' : '编辑 ') + (preset ? preset.label : 'MCP 服务');
}; $('mce-name').value = preset ? preset.key : (add ? '' : (s.name || ''));
$('mce-title').textContent = add ? '添加 MCP 服务' : '编辑 MCP 服务'; $('mce-url').value = preset ? preset.url : (add ? '' : (s.url || ''));
$('mce-name').value = add ? '' : (s.name || ''); $('mce-name').readOnly = !!preset;
$('mce-url').value = add ? '' : (s.url || ''); $('mce-url').readOnly = !!preset;
// 运行配置里的 timeout_ms 已被 config.js 填上缺省值,所以这里显示的就是当前生效值(没配则为 60000)。 // 运行配置里的 timeout_ms 已被 config.js 填上缺省值,所以这里显示的就是当前生效值(没配则为 60000)。
$('mce-timeout').value = add || s.timeout_ms == null ? '' : String(s.timeout_ms); $('mce-timeout').value = add || s.timeout_ms == null ? '' : String(s.timeout_ms);
$('mce-mode').value = add ? 'advertise' : (s.mode || 'advertise'); // 预设的 mode 是契约(asr / image_task 必须 skill 才不会把一堆转写/生成工具塞进每轮工具表),
// 只允许在「预设值 / disable」之间切;手改成别的值时按契约值显示,不凭空改写文件。
const curMode = add ? (preset ? (preset.mode || 'advertise') : 'advertise') : (s.mode || 'advertise');
const modes = preset ? [preset.mode || 'advertise', 'disable'] : ['advertise', 'skill', 'disable'];
$('mce-mode').innerHTML = modes.map(m => '<option value="' + att(m) + '">' + esc(MCP_MODE_LABELS[m] || m) + '</option>').join('');
$('mce-mode').value = modes.indexOf(curMode) >= 0 ? curMode : modes[0];
$('mce-preset-sec').classList.toggle('hidden', !preset);
$('mce-preset-desc').textContent = preset ? (preset.desc || '') : '';
// 预设已经覆盖该服务的全部 header,不再给「其它 header」入口;
// 配置里若还留着历史多余 header,仍原样带着(保存是整体替换,不带着就丢),只是不展示。
$('mce-headers-sec').classList.toggle('hidden', !!preset);
$('mce-del-btn').classList.toggle('hidden', add); $('mce-del-btn').classList.toggle('hidden', add);
renderPresetFields();
renderMcpHeaders(); renderMcpHeaders();
$('mcp-edit-modal').classList.remove('hidden'); $('mcp-edit-modal').classList.remove('hidden');
} }
@@ -1508,7 +1795,7 @@
// 已有行:输入框置空,placeholder 提示当前脱敏值;留空=保持原值,输入新值=替换 // 已有行:输入框置空,placeholder 提示当前脱敏值;留空=保持原值,输入新值=替换
const ph = r.masked != null ? '当前: ' + r.masked + '(留空保持不变)' : '值'; const ph = r.masked != null ? '当前: ' + r.masked + '(留空保持不变)' : '值';
return '<div class="mpe-row">' + return '<div class="mpe-row">' +
'<input class="mpe-grow" type="text" placeholder="Header 名(如 Authorization)" value="' + esc(r.key) + '" oninput="mcpUI.setHeader(' + i + ',\'key\',this.value)">' + '<input class="mpe-grow" type="text" placeholder="Header 字段" value="' + esc(r.key) + '" oninput="mcpUI.setHeader(' + i + ',\'key\',this.value)">' +
'<input class="mpe-grow" type="text" placeholder="' + esc(ph) + '" value="' + esc(r.value) + '" oninput="mcpUI.setHeader(' + i + ',\'value\',this.value)">' + '<input class="mpe-grow" type="text" placeholder="' + esc(ph) + '" value="' + esc(r.value) + '" oninput="mcpUI.setHeader(' + i + ',\'value\',this.value)">' +
'<button class="mpe-del" title="删除此 header" onclick="mcpUI.delHeader(' + i + ')">×</button>' + '<button class="mpe-del" title="删除此 header" onclick="mcpUI.delHeader(' + i + ')">×</button>' +
'</div>'; '</div>';
@@ -1530,13 +1817,82 @@
renderMcpHeaders(); renderMcpHeaders();
} }
function setMcpHeader(i, f, v) { if (mcpEdit && mcpEdit.headers[i]) mcpEdit.headers[i][f] = v; } function setMcpHeader(i, f, v) { if (mcpEdit && mcpEdit.headers[i]) mcpEdit.headers[i][f] = v; }
// 预设字段表单:label + 输入框 + 提示。密钥项只提示「已配置」,不回填真值(前端拿到的本来就是掩码)。
function renderPresetFields() {
if (!mcpEdit) return;
const box = $('mce-preset-fields');
if (!box) return;
const p = mcpEdit.preset;
if (!p) { box.innerHTML = ''; return; }
const curH = ((mcpEdit.idx >= 0 && SET.cfgMcp[mcpEdit.idx]) || {}).headers || {};
box.innerHTML = (p.fields || []).map(f => {
const isSet = !!curH[f.header];
const ph = f.secret && isSet ? '已配置,留空保持不变' : (f.placeholder || '');
const val = mcpEdit.values[f.header] || '';
// 左标签 / 右输入,与下方「单次调用超时 / 工具暴露」同一种单行排版。
// 必填不加 * 标记(会破坏对齐)——空着保存时按 label 点名报错。
return '<div class="mpe-item"><label class="mpe-line"><span>' + esc(f.label || f.header) + '</span>' +
'<input type="' + (f.secret ? 'password' : 'text') + '"' +
' value="' + att(val) + '"' +
' placeholder="' + att(ph) + '"' +
' autocomplete="off" spellcheck="false"' +
' oninput="mcpUI.setField(\'' + att(f.header) + '\',this.value)">' +
'</label>' + (f.hint ? '<div class="cfg-note">' + esc(f.hint) + '</div>' : '') + '</div>';
}).join('');
}
function setPresetField(header, v) {
if (mcpEdit && mcpEdit.values) mcpEdit.values[header] = v;
}
// 预设里的 prefix(如 Bearer )只在用户没带过时才补,避开「Bearer Bearer sk-x」
function withPrefix(f, v) {
const p = String(f.prefix || '');
if (!p) return v;
const re = new RegExp('^' + p.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\s', 'i');
return re.test(v) ? v : p + v;
}
// 与配置里的 headers 比较:key 顺序不同不算改动(避免无意义重写丢掉节点里的注释)
function sameHeaders(a, b) {
const ka = Object.keys(a).sort(), kb = Object.keys(b).sort();
if (ka.length !== kb.length) return false;
return ka.every((k, i) => k === kb[i] && a[k] === b[kb[i]]);
}
// 自定义服务的 headers:空 key 行丢弃,已有行留空 = 发回掩码占位由后端按键名还原
function plainHeaders() {
const out = {};
for (const r of mcpEdit.headers) {
const k = String(r.key || '').trim();
if (!k) continue;
const v = String(r.value || '').trim();
out[k] = v || (r.masked != null ? r.masked : '');
}
return out;
}
// 预设模式的 headers:字段按声明顺序取 values,空的可选项不写(不给上游塞空 header),
// 必填项空着直接报错并点名 label;手加的 header 原样跟上(整体替换语义下不带就丢)。
function presetHeaders() {
const p = mcpEdit.preset;
const curH = ((mcpEdit.idx >= 0 && SET.cfgMcp[mcpEdit.idx]) || {}).headers || {};
const out = {};
for (const f of p.fields || []) {
const raw = String(mcpEdit.values[f.header] || '').trim();
if (raw) { out[f.header] = withPrefix(f, raw); continue; }
if (f.secret && curH[f.header]) { out[f.header] = MCP_HEADER_MASK; continue; }
if (f.required) throw new Error('请填写「' + (f.label || f.header) + '」');
}
for (const r of mcpEdit.headers) {
const k = String(r.key || '').trim();
if (!k || out[k] !== undefined) continue;
const v = String(r.value || '').trim();
out[k] = v || (r.masked != null ? r.masked : '');
}
return out;
}
// 收集弹窗内的修改为批量 PATCH:服务端一次读文/写回/校验,原子生效。 // 收集弹窗内的修改为批量 PATCH:服务端一次读文/写回/校验,原子生效。
// headers 整体替换(简单可靠;键值对场景下增量 diff 收益小):空 key 行不写入。 // headers 整体替换(简单可靠;键值对场景下增量 diff 收益小):空 key 行不写入。
function buildMcpEdits() { function buildMcpEdits() {
if (!mcpEdit) return []; if (!mcpEdit) return [];
const edits = []; const edits = [];
const name = $('mce-name').value.trim(); const preset = mcpEdit.preset;
const url = $('mce-url').value.trim();
const mode = $('mce-mode').value; const mode = $('mce-mode').value;
// 超时:留空 = 不写入该项(沿用缺省 60s)。区间在 UI 先把一道, // 超时:留空 = 不写入该项(沿用缺省 60s)。区间在 UI 先把一道,
// 比写进 YAML 再被 config.js 静默夹掉好排查(两边上限保持 600000 一致)。 // 比写进 YAML 再被 config.js 静默夹掉好排查(两边上限保持 600000 一致)。
@@ -1547,6 +1903,10 @@
if (!Number.isFinite(tmo) || tmo < 1000 || tmo > 600000) throw new Error('超时要填 1000 ~ 600000 毫秒(留空 = 默认 60s)'); if (!Number.isFinite(tmo) || tmo < 1000 || tmo > 600000) throw new Error('超时要填 1000 ~ 600000 毫秒(留空 = 默认 60s)');
tmo = Math.round(tmo); tmo = Math.round(tmo);
} }
// 内置服务的 name/url 是契约(表单只读),只有自定义服务才从输入框取
const name = preset ? preset.key : $('mce-name').value.trim();
const url = preset ? preset.url : $('mce-url').value.trim();
const headers = preset ? presetHeaders() : plainHeaders();
const add = mcpEdit.idx < 0; const add = mcpEdit.idx < 0;
if (add) { if (add) {
if (!url) throw new Error('请填写 url'); if (!url) throw new Error('请填写 url');
@@ -1554,19 +1914,15 @@
if (name) obj.name = name; if (name) obj.name = name;
if (mode !== 'advertise') obj.mode = mode; if (mode !== 'advertise') obj.mode = mode;
if (tmo != null) obj.timeout_ms = tmo; if (tmo != null) obj.timeout_ms = tmo;
const headers = {};
for (const r of mcpEdit.headers) {
const k = String(r.key || '').trim();
const v = String(r.value || '').trim();
if (k) headers[k] = v;
}
if (Object.keys(headers).length) obj.headers = headers; if (Object.keys(headers).length) obj.headers = headers;
edits.push({ op: 'append', path: ['mcp_servers'], value: obj }); edits.push({ op: 'append', path: ['mcp_servers'], value: obj });
} else { } else {
const cur = SET.cfgMcp[mcpEdit.idx] || {}; const cur = SET.cfgMcp[mcpEdit.idx] || {};
if (!url) throw new Error('请填写 url'); if (!preset) {
if (name !== (cur.name || '')) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'name'], value: name }); if (!url) throw new Error('请填写 url');
if (url !== (cur.url || '')) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'url'], value: url }); if (name !== (cur.name || '')) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'name'], value: name });
if (url !== (cur.url || '')) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'url'], value: url });
}
// mode:默认值不写进文件(选 advertise 就删键) // mode:默认值不写进文件(选 advertise 就删键)
if ((cur.mode || 'advertise') !== mode) edits.push(mode === 'advertise' if ((cur.mode || 'advertise') !== mode) edits.push(mode === 'advertise'
? { path: ['mcp_servers', mcpEdit.idx, 'mode'], op: 'delete' } ? { path: ['mcp_servers', mcpEdit.idx, 'mode'], op: 'delete' }
@@ -1576,17 +1932,10 @@
if (tmo !== curTmo) edits.push(tmo == null if (tmo !== curTmo) edits.push(tmo == null
? { path: ['mcp_servers', mcpEdit.idx, 'timeout_ms'], op: 'delete' } ? { path: ['mcp_servers', mcpEdit.idx, 'timeout_ms'], op: 'delete' }
: { path: ['mcp_servers', mcpEdit.idx, 'timeout_ms'], value: tmo }); : { path: ['mcp_servers', mcpEdit.idx, 'timeout_ms'], value: tmo });
// headers 仅在内容变更时整体 setIn;避免无意义重写(顺序可能不同) // headers 仅在内容变更时整体 setIn;避免无意义重写(顺序或 key 顺序不同不算变更)
const newH = {}; if (!sameHeaders(headers, cur.headers || {})) {
for (const r of mcpEdit.headers) { edits.push({ path: ['mcp_servers', mcpEdit.idx, 'headers'], value: headers });
const k = String(r.key || '').trim();
// 已有行留空 = 保持原值:把脱敏占位原样发回,由后端按键名还原真值(前端不持有真值)
const v = String(r.value || '').trim() || (r.masked != null ? r.masked : '');
if (k) newH[k] = v;
} }
const curH = cur.headers || {};
const same = JSON.stringify(newH) === JSON.stringify(curH);
if (!same) edits.push({ path: ['mcp_servers', mcpEdit.idx, 'headers'], value: newH });
} }
return edits; return edits;
} }
@@ -1618,6 +1967,13 @@
} }
window.mcpUI = { window.mcpUI = {
add: function () { openMcpEditor(null); }, add: function () { openMcpEditor(null); },
addPreset: function (key) { openMcpEditor(null, key); },
editPreset: function (key) {
const p = presetMcpList().find(x => x.key === key);
const i = p ? presetIdx(p) : -1;
if (i >= 0) openMcpEditor(i, key);
},
setField: setPresetField,
edit: openMcpEditor, edit: openMcpEditor,
close: closeMcpEditor, close: closeMcpEditor,
save: saveMcpEditor, save: saveMcpEditor,
@@ -1678,8 +2034,15 @@
mDelModel: delPfModel, mDelModel: delPfModel,
mKeyApi: function (i, v) { setPfKey(i, 'api_key', v); }, mKeyApi: function (i, v) { setPfKey(i, 'api_key', v); },
mModId: function (i, v) { setPfModel(i, 'id', v); }, mModId: function (i, v) { setPfModel(i, 'id', v); },
mModField: function (i, f, v) { setPfModel(i, f, v); },
mModVision: function (i, v) { setPfModel(i, 'vision', v); }, mModVision: function (i, v) { setPfModel(i, 'vision', v); },
mModEnable: function (i, v) { setPfModel(i, 'enable', v); }, mModEnable: function (i, v) { setPfModel(i, 'enable', v); },
mAdvToggle: function (i) {
if (!pfEdit || !pfEdit.models[i]) return;
pfEdit.models[i].adv = !pfEdit.models[i].adv;
renderPfRows();
},
mPreset: applyPfPreset,
mDelPlat: delPlatformFromModal, mDelPlat: delPlatformFromModal,
restartNow: restartNow, restartNow: restartNow,
toggleGroup: toggleModelGroup, toggleGroup: toggleModelGroup,
+106 -6
View File
@@ -19,7 +19,7 @@
const content = ta.value.trim(); const content = ta.value.trim();
const editingId = state.editingMsgId || 0; const editingId = state.editingMsgId || 0;
// 没有文字就不发(避免产生空消息);但只有附件时允许发送——粘贴长文本转成的 .txt 需要能单独发出。 // 没有文字就不发(避免产生空消息);但只有附件时允许发送——粘贴长文本转成的 .txt 需要能单独发出。
// 运行中也是这条规则:有字就发(后端 live 追投),没字又没附件时按钮本身是「停止」。 // 运行中也是这条规则:有字就发,没字又没附件时按钮本身是「停止」。
if (!content && !state.attachments.length) return; if (!content && !state.attachments.length) return;
const pending = state.attachments.slice(); const pending = state.attachments.slice();
@@ -43,7 +43,10 @@
const text = names.length const text = names.length
? '用户上传了文件:' + names.join('、') + (content ? '\n\n' + content : '') ? '用户上传了文件:' + names.join('、') + (content ? '\n\n' + content : '')
: content; : content;
const body = { content: text, deepThink: !!state.deepThink }; // 是否排队由**服务端**决定:Web 端一律交 delivery:'queue',回合在跑就进队列,
// 没在跑就等价于立即发送(enqueueMessage 直接走 postUserMessage)。
// 不用 state.status 判断——SSE 状态可能过期,误判成 live 会把 user 行插进工具批次中间。
const body = { content: text, deepThink: !!state.deepThink, delivery: 'queue' };
let sent; let sent;
if (editingId) { if (editingId) {
// 覆盖式编辑:先撤掉本地该条及其后的渲染,再让服务端删除同范围历史并以新内容重开一轮 // 覆盖式编辑:先撤掉本地该条及其后的渲染,再让服务端删除同范围历史并以新内容重开一轮
@@ -56,7 +59,15 @@
} }
clearUploadCards(); // 消息已发出(告知行已拼入正文),卡片使命完成清掉 clearUploadCards(); // 消息已发出(告知行已拼入正文),卡片使命完成清掉
appendUserMsg(text, atts.map(a => a.name), sent && sent.message_id); // 排队回执:条幅以服务端返回的队列为准(本端不画气泡,等真正落库的 user_message 再画);
// 竞态下服务端发现回合已结束会直接送达(没有 queued 字段),那就照常当普通发送处理。
const queued = !!(sent && sent.queued);
if (queued) {
state.pending = sent.pending || [];
renderSendQueue();
} else {
appendUserMsg(text, atts.map(a => a.name), sent && sent.message_id);
}
// 标题取用户原文,不带文件告知行;纯附件发送时退回粘贴文本的前缀 // 标题取用户原文,不带文件告知行;纯附件发送时退回粘贴文本的前缀
const seed = content || (pending[0] && pending[0].titleSeed) || ''; const seed = content || (pending[0] && pending[0].titleSeed) || '';
if (!state.sessionTitle && seed) { if (!state.sessionTitle && seed) {
@@ -65,7 +76,8 @@
renderHeader(); renderHeader();
// 运行中插话:正文字流进行中已有一个气泡作「活着」的信号,不再挂打字占位 // 运行中插话:正文字流进行中已有一个气泡作「活着」的信号,不再挂打字占位
//(刚挂上就会被下一个 delta 移除,只会闪一下);工具间隙里补上占位反而有用。 //(刚挂上就会被下一个 delta 移除,只会闪一下);工具间隙里补上占位反而有用。
if (!state.streaming) addTyping(); // 排队时本回合没有任何新动静,不挂占位。
if (!queued && !state.streaming) addTyping();
loadSessionList(); loadSessionList();
} catch (e) { } catch (e) {
// 发送失败:附件还原+草稿文本回填(发送前已清空输入框,挂起/失败不能让文字蒸发), // 发送失败:附件还原+草稿文本回填(发送前已清空输入框,挂起/失败不能让文字蒸发),
@@ -83,6 +95,56 @@
} }
} }
// ---------- 待发送条幅 ----------
// 队列本身在服务端(engine.pendings),关页面/换设备/重连都不丢;这里只负责画。
// 每条一行;只有队首有「干预 / 立即发送」,其余显示排队中(不能越过前一条先发)。
function renderSendQueue() {
const box = $('send-queue');
if (!box) return;
const list = state.pending || [];
box.classList.toggle('hidden', !list.length);
if (!list.length) { box.innerHTML = ''; return; }
box.innerHTML = list.map((it, i) => {
const busy = it.mode === 'interject' || it.mode === 'now';
const tag = it.mode === 'now' ? '<span class="sq-tag">正在中断…</span>'
: it.mode === 'interject' ? '<span class="sq-tag">等待当前步骤…</span>'
: (i === 0 ? '' : '<span class="sq-tag">排队中</span>');
const acts = (i === 0 && !busy)
? '<button data-act="interject" title="当前工具调用结束后立即插话">干预</button>' +
'<button data-act="now" title="终止本轮工具调用并立即发送">立即发送</button>'
: '';
return '<div class="sq-item' + (busy ? ' sq-busy' : '') + '" data-qid="' + esc(it.id) + '">' +
'<span class="sq-text" title="' + esc(it.content) + '">' + esc(it.content) + '</span>' +
tag + acts +
'<button class="sq-x" data-act="cancel" title="取消这条">×</button></div>';
}).join('');
}
// 条幅按钮:× 取消;干预/立即发送升级队首(服务端只在安全边界真正投递)。
async function onSendQueueClick(e) {
const btn = e.target.closest('#send-queue button[data-act]');
if (!btn || !state.sessionId) return;
const item = btn.closest('.sq-item');
const qid = item && item.dataset.qid;
if (!qid) return;
const act = btn.dataset.act;
btn.disabled = true;
try {
const base = '/api/sessions/' + state.sessionId + '/pending/' + encodeURIComponent(qid);
const r = act === 'cancel' ? await req('DELETE', base) : await req('POST', base, { action: act });
if (r && Array.isArray(r.pending)) { state.pending = r.pending; renderSendQueue(); }
if (act === 'cancel') return;
if (r && r.delivered) return; // 回合已结束:服务端直接投递,等 user_message 画气泡
toast(act === 'now' ? '已请求中断,随后立即发送' : '已请求干预:当前步骤结束后插话');
} catch (err) {
toast('操作失败:' + err.message);
renderSendQueue();
}
}
const sendQueueBox = $('send-queue');
if (sendQueueBox) sendQueueBox.addEventListener('click', onSendQueueClick);
// ---------- SSE 流 ---------- // ---------- SSE 流 ----------
// 助手消息流式容器:首个 delta 到达时创建,同时为思考面板预留挂载点 // 助手消息流式容器:首个 delta 到达时创建,同时为思考面板预留挂载点
function ensureStreamWrap() { function ensureStreamWrap() {
@@ -158,12 +220,15 @@
state.lastSseAt = Date.now(); // 建连即重置静默计时 state.lastSseAt = Date.now(); // 建连即重置静默计时
// 任何具名事件都算连接存活:静默看门狗与回前台宽限共用(error 不列,原生连接错误也走 error) // 任何具名事件都算连接存活:静默看门狗与回前台宽限共用(error 不列,原生连接错误也走 error)
['ping', 'status', 'assistant_delta', 'reasoning_delta', 'assistant_message', 'tool_call_start', ['ping', 'status', 'assistant_delta', 'reasoning_delta', 'assistant_message', 'tool_call_start',
'tool_call_args', 'tool_call', 'tool_result', 'ui_card', 'auto_compress', 'done', 'title', 'think_auto'] 'tool_call_args', 'tool_call', 'tool_result', 'ui_card', 'auto_compress', 'done', 'title', 'think_auto',
'pending_added', 'pending_removed', 'user_message']
.forEach(function (n) { es.addEventListener(n, function () { markSseAlive(n); }); }); .forEach(function (n) { es.addEventListener(n, function () { markSseAlive(n); }); });
es.addEventListener('status', ev => { es.addEventListener('status', ev => {
const d = JSON.parse(ev.data); const d = JSON.parse(ev.data);
state.status = d.status; state.status = d.status;
if (d.model_id) state.modelId = d.model_id; if (d.model_id) state.modelId = d.model_id;
// 待投递队列以服务端为准(重连/换标签页后条幅能自动回到真实状态)
if (Array.isArray(d.pending)) { state.pending = d.pending; renderSendQueue(); }
renderHeader(); renderHeader();
updateHeaderActions(); updateHeaderActions();
updateScrollBottomBtn(); // 状态切换同步右下角转圈(开始/结束干活) updateScrollBottomBtn(); // 状态切换同步右下角转圈(开始/结束干活)
@@ -348,8 +413,33 @@
es.addEventListener('auto_compress', ev => { es.addEventListener('auto_compress', ev => {
proposeAutoCompress(JSON.parse(ev.data)); proposeAutoCompress(JSON.parse(ev.data));
}); });
// 待发送条幅:新入队 / 升级(同 id upsert)
es.addEventListener('pending_added', ev => {
const d = JSON.parse(ev.data);
if (!d || !d.id) return;
const list = state.pending.slice();
const i = list.findIndex(x => x.id === d.id);
if (i >= 0) list[i] = d; else list.push(d);
state.pending = list;
renderSendQueue();
});
// 出队(已送达 / 被取消 / 停止时整体清空)
es.addEventListener('pending_removed', ev => {
const d = JSON.parse(ev.data);
state.pending = state.pending.filter(x => x.id !== (d && d.id));
renderSendQueue();
});
// 排队消息真正落库:这一刻它才成为历史,画进聊天区(排队期间不画)
es.addEventListener('user_message', ev => {
const d = JSON.parse(ev.data);
if (!d || !d.id || state.renderedSigs[d.id]) return; // 防重(重连补拉/多标签页)
appendUserMsg(d.content, null, d.id);
removeTyping();
});
es.addEventListener('done', ev => { es.addEventListener('done', ev => {
removeTyping(); // 本轮结束,占位亦终止(如模型报错无回复) removeTyping(); // 本轮结束,占位亦终止(如模型报错无回复)
let doneStatus = '';
try { doneStatus = (JSON.parse(ev.data) || {}).status || ''; } catch (_) { /* 无 data 的连接层错误 */ }
// 压缩回合异常结束的兜底(模型报错回合直接 break / 被终止 → 不会有带 is_summary 的最终消息): // 压缩回合异常结束的兜底(模型报错回合直接 break / 被终止 → 不会有带 is_summary 的最终消息):
// 复位等待状态并还原压缩按钮,历史保持原样不动。 // 复位等待状态并还原压缩按钮,历史保持原样不动。
if (state.pendingSummary) { if (state.pendingSummary) {
@@ -364,10 +454,20 @@
state.streamWrap = null; state.streamWrap = null;
state.streamReasoning = ''; state.streamReasoning = '';
state.streamThinkEl = null; state.streamThinkEl = null;
// 异常收尾兜底:把参数未流完的早卡就地回填收尾,避免占位态永远呼吸 // 异常收尾兜底:把参数未流完的早卡就地回填收尾,避免占位态永远呼吸。
// 被「立即发送/停止」硬中断时,这些调用根本没落库、不会再有回执,
// 结果区要明确写「已取消」,否则卡片永远停在「执行中…」。
for (const sid of Object.keys(state.toolCallStreaming)) { for (const sid of Object.keys(state.toolCallStreaming)) {
const stg = state.toolCallStreaming[sid]; const stg = state.toolCallStreaming[sid];
finalizeToolCardArgs(sid, stg.name, stg.args); finalizeToolCardArgs(sid, stg.name, stg.args);
const card = state.toolCards[sid];
const pre = card && card.querySelector('.tool-result');
if (pre && pre.textContent === '执行中…') {
card.classList.add('error');
const spin = card.querySelector('.spin');
if (spin) spin.textContent = '⏹';
pre.textContent = doneStatus === 'cancelled' ? '已取消(本轮被终止,未执行)' : '本轮已结束,未收到结果';
}
} }
state.toolCards = {}; state.toolCards = {};
state.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置 state.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置
+76
View File
@@ -0,0 +1,76 @@
// 视口适配:软键盘高度 → CSS 变量 --kb-page(纯页面侧兜底,不依赖套壳 App 改代码)
// ----------------------------------------------------------------------------
// 症状:套壳 App(Android WebView / ArkWeb)开了 edge-to-edge 后,
// 1) 顶部内容压在状态栏下面 —— 安卓 WebView 的 env(safe-area-inset-top) 只反映屏幕
// 挖孔(display cutout),不含状态栏高度,基本恒为 0;壳不额外注入就顶不上去。
// 这一条由壳注入 CSS 变量解决,见下方「注入约定」,本文件不处理。
// 2) 键盘弹起、输入框被盖住 —— Chromium 默认 interactive-widget=resizes-visual,只缩
// visual viewport,layout viewport 不动。本页是 height:100% 的固定 shell,footer 全靠
// layout viewport 变矮才会被顶上来,于是原地不动被键盘压住(看起来像「没给键盘留位置」)。
//
// 本文件只解决第 2 条:用 visualViewport 与 innerHeight 的差值算出键盘实际占用的高度,
// 写进 --kb-page;#app 按 --kb(= max(--kb-page, --kb-native))收缩,footer 自动落在键盘上沿。
// 壳若已正确 resize(adjustResize / resizes-content 生效),innerHeight 会同步变矮,
// 差值恒为 0,本逻辑自动失效,不会二次收缩。
//
// 注入约定(壳侧,loadUrl 之后或 WindowInsets 变化时):
// document.documentElement.style.setProperty('--sat', '36px'); // 状态栏高度
// document.documentElement.style.setProperty('--sab', '20px'); // 导航栏/手势条高度
// document.documentElement.style.setProperty('--kb-native', '300px'); // IME 高度(可选)
// --kb-native 用于「WebView 完全感知不到键盘」的情况(窗口不 resize、visualViewport 也不缩),
// 此时本文件量不到任何东西,只能靠壳把 IME insets 报进来;页面与壳各写各的变量,互不覆盖。
(function () {
'use strict';
const root = document.documentElement;
const vv = window.visualViewport;
// 没有 visualViewport 的老 WebView:只剩 interactive-widget / 壳 resize 两条路
if (!vv) return;
// 键盘判定阈值:地址栏/浏览器 UI 收起通常 < 60px,软键盘一般 > 150px,
// 取 80 让两者之间留足余量,避免把浏览器 UI 收起误判成键盘。
const KB_MIN = 80;
// 贴底判定:与 chat.js 的 SCROLL_BOTTOM_THRESHOLD 同量级即可,不必严格一致
const STICK_PX = 80;
let kb = 0;
let raf = 0;
function nearBottom(box) {
return box.scrollHeight - box.scrollTop - box.clientHeight < STICK_PX;
}
function measure() {
raf = 0;
// 键盘占掉的高度 = layout viewport 高度 -(visual viewport 顶部偏移 + 可视高度)。
// 浏览器为露出光标会把 visual viewport 上推(offsetTop > 0),这部分要一并扣掉,
// 否则会按「整段键盘」收缩,footer 反而被顶得比键盘上沿更高。
let next = Math.round(window.innerHeight - vv.offsetTop - vv.height);
// 双指缩放时 vv.height 被压缩,不代表键盘(user-scalable=no 下基本走不到)
if (vv.scale > 1.01 || next < KB_MIN) next = 0;
// 兜底上限:横屏 + 大字号等极端情况下别把整个 shell 收没
next = Math.min(next, Math.round(window.innerHeight * 0.7));
if (next === kb) return;
const box = document.getElementById('chat-view');
// 只在「键盘弹起导致变矮」时继续贴底;收键盘时保持当前阅读位置不动
const stick = next > kb && !!box && nearBottom(box);
kb = next;
root.style.setProperty('--kb-page', kb + 'px');
if (stick) {
// 等一次布局:#app 收缩后 scrollHeight / clientHeight 才是新值
requestAnimationFrame(() => { box.scrollTop = box.scrollHeight; });
}
}
function schedule() {
if (!raf) raf = requestAnimationFrame(measure);
}
vv.addEventListener('resize', schedule);
vv.addEventListener('scroll', schedule); // 浏览器平移 visual viewport 时 offsetTop 会变
// 转屏后尺寸与 inset 都变了,等系统栏动画结束再量一次
window.addEventListener('orientationchange', () => setTimeout(measure, 200));
})();
+424 -175
View File
@@ -8,10 +8,12 @@
// · 松手:取消态 → 丢弃 + 轻提示;否则转写后**直接发送** // · 松手:取消态 → 丢弃 + 轻提示;否则转写后**直接发送**
// · 发送键位置变成键盘按钮,点一下回文本模式并聚焦输入框(移动端弹键盘) // · 发送键位置变成键盘按钮,点一下回文本模式并聚焦输入框(移动端弹键盘)
// //
// 录音在客户端:套壳原生桥(http 页面也能用)或 HTTPS 下的 MediaRecorder; // 录音在客户端,两条路,下游是同一套:
// 转写在服务端 mcp_asr(经 core 的 /api/asr 中转)。 // · 套壳原生桥(http 页面也能用):壳把 16k/单声道 PCM 以 ~100ms 分片推给页面。
// 电平:浏览器用 AnalyserNode 算 RMS;套壳上报 onNativeVoiceAmp(原始 getMaxAmplitude)。 // · 浏览器(需 HTTPS):AudioContext + ScriptProcessor 自己采 PCM,降采样到 16k 后约 20ms 一片。
// 归一化/门限/平滑全部在页面侧做,壳不做任何换算。 // 两条路都汇到 pushChunk():判停顿、切段、逐段上传、最后合并发送,只有一份实现。
// 于是大部分识别在说话过程中就做完了,松手通常只剩最后一段要等。
// 电平在页面侧算(PCM 峰值),壳和浏览器都不做任何换算。
// //
// 包在 IIFE 里:前端是共享全局作用域的经典脚本,顶层声明会和其他文件撞名。 // 包在 IIFE 里:前端是共享全局作用域的经典脚本,顶层声明会和其他文件撞名。
@@ -28,11 +30,16 @@
const native = (window.AgentNative && typeof window.AgentNative.startVoice === 'function') const native = (window.AgentNative && typeof window.AgentNative.startVoice === 'function')
? window.AgentNative : null; ? window.AgentNative : null;
const webOk = !!(window.isSecureContext && navigator.mediaDevices const webOk = !!(window.isSecureContext && navigator.mediaDevices
&& typeof navigator.mediaDevices.getUserMedia === 'function' && window.MediaRecorder); && typeof navigator.mediaDevices.getUserMedia === 'function'
&& (window.AudioContext || window.webkitAudioContext));
const MAX_MS = 60000; // 单次录音上限 const MAX_MS = 180000; // 单次录音上限(流式上传后不再受 60s 限制)
const MIN_MS = 500; // 短于这个时长按误触处理,不上传 const MIN_MS = 500; // 短于这个时长按误触处理,不上传
const NO_RESULT_MS = 3000; // 松开后壳迟迟不回音频(比如还在等权限)→ 复位 const FLUSH_MS = 60000; // 松手后等尾段识别完的上限(超过就当失败)
// 转写请求的并发上限:段一碎(6s 软切)并发就会很多,全放出去会把上游压垮、
// 也可能被限流。超过就排到后面,等前面的落定再发。改完刷新页面即生效。
const ASR_MAX_CONCURRENCY = 3;
const OUT_RATE = 16000; // 页面内部统一按 16k 处理:VAD 时长与段长上限都按它算
const BAR_COUNT = 45; // 声波柱数(要足够宽,手指按住时两侧仍能看到) const BAR_COUNT = 45; // 声波柱数(要足够宽,手指按住时两侧仍能看到)
// 两端矮、中间高的包络:看起来像一段声波而不是一排等高柱子 // 两端矮、中间高的包络:看起来像一段声波而不是一排等高柱子
@@ -58,12 +65,40 @@
let discard = false; // 本次录音太短/已取消:结果到了也丢掉 let discard = false; // 本次录音太短/已取消:结果到了也丢掉
let recordStartAt = 0; let recordStartAt = 0;
let stopTimer = null; let stopTimer = null;
let hardTimer = null;
let watchdog = null;
let rec = null;
let stream = null; let stream = null;
let chunks = []; // 浏览器采集:ScriptProcessor 直接给 Float32 PCM,这里降到 16k 后喂 pushChunk
let mime = ''; let procNode = null;
let capRate = 0; // AudioContext 的真实采样率(通常 44.1k/48k)
let dsAcc = 0; // 降采样:当前输出周期内的样本和
let dsN = 0;
let dsPhase = 0; // 小数相位,跨分片累计 → 长期不漂移
// 流式:壳推的分片 / 浏览器自己采的分片,都在这里断句后逐段上传
let pcmRate = 16000; // 当前流的采样率(契约要求 16k)
let segChunks = []; // 当前段的 PCM 分片(Int16Array)
let segLens = []; // 各分片采样数(与 segChunks 平行:软切要按采样换算边界)
let segDbs = []; // 各分片峰值 dB(与 segChunks 平行:软切要找能量最低的边界)
let segLen = 0; // 当前段总采样数
let silLen = 0; // 段尾连续静音采样数
let textParts = []; // 各段识别结果,按提交顺序占位(并行返回是乱序的)
let segSent = 0; // 本轮已提交转写的段数(进度分母)
let segDone = 0; // 已返回(含失败)的段数(进度分子)
let busyTimer = null; // 「识别中」提示的秒表(1s 一跳)
let busyStartAt = 0;
let inflight = []; // 本轮各段的落定 promise(收口要等全它们)
let waiting = []; // 等名额的段(在飞满了才排)
let active = 0; // 正在飞的请求数
let gen = 0; // 会话代号:取消/重录后迟到结果直接丢弃
let streamOn = false; // 是否接受 PCM 分片
let flushTimer = null;
// VAD 参数(页面侧唯一一份:改完刷新页面即生效,不用重打 APK)
const VAD_SILENCE_DB = -42; // 低于这个音量算“没人说话”(正常说话峰值约 -10~-30dB)
const VAD_PAUSE_SEC = 0.5; // 连续静音这么久 → 断句(与壳无关)
const VAD_MIN_SPEECH_SEC = 0.3; // 一段短于这个 → 当噪声丢掉
const VAD_MAX_SEG_SEC = 25; // 单段上限:连续说话没停顿就硬切(上游单次上限)
const VAD_SOFT_CUT_SEC = 6; // 累计语音超过这么久 → 在低能量处先切一刀发出去
const VAD_SOFT_WINDOW_SEC = 3; // 软切只在尾部这个窗口里找切点(不切在很久以前)
// 电平与渲染 // 电平与渲染
let rafId = 0; let rafId = 0;
@@ -71,13 +106,11 @@
let levelCur = 0; let levelCur = 0;
let lastRealLevelAt = 0; let lastRealLevelAt = 0;
let audioCtx = null; let audioCtx = null;
let analyser = null;
let audioBuf = null;
let srcNode = null; let srcNode = null;
function clamp01(v) { return v < 0 ? 0 : v > 1 ? 1 : v; } function clamp01(v) { return v < 0 ? 0 : v > 1 ? 1 : v; }
// 电平归一化的唯一实现:浏览器(RMS)和壳(峰值幅度)都在这里落到 0~1。 // 电平归一化的唯一实现:两条录音路径的 PCM 峰值都在这里落到 0~1。
// 低于 -55dB 视为静音,-5dB 及以上视为满幅;要调灵敏度只改这两个常量。 // 低于 -55dB 视为静音,-5dB 及以上视为满幅;要调灵敏度只改这两个常量。
const LEVEL_FLOOR_DB = -55; const LEVEL_FLOOR_DB = -55;
const LEVEL_RANGE_DB = 50; const LEVEL_RANGE_DB = 50;
@@ -95,10 +128,35 @@
if (overlay) overlay.classList.toggle('cancel', m === 'cancel'); if (overlay) overlay.classList.toggle('cancel', m === 'cancel');
if (hintEl) { if (hintEl) {
hintEl.textContent = m === 'cancel' ? '松开取消' hintEl.textContent = m === 'cancel' ? '松开取消'
: m === 'busy' ? '正在识别…' : '松手传送,上滑取消'; : m === 'busy' ? busyHintText() : '松手传送,上滑取消';
} }
} }
// 「识别中」的进度提示:段数是真实进度(一段一次转写),秒数让长时间等待时数字也在动,
// 不至于看着像卡住。只有一段时不显示 0/1(那看着也像没进展),只留秒数。
function busyHintText() {
const sec = Math.max(0, Math.floor((Date.now() - busyStartAt) / 1000));
if (segSent > 1) {
return '正在识别 ' + Math.min(segDone, segSent) + '/' + segSent + ' 段 · ' + sec + 's';
}
return '正在识别… ' + sec + 's';
}
function refreshBusyHint() {
if (hintEl && phase === 'busy') hintEl.textContent = busyHintText();
}
function stopBusyTicker() {
if (busyTimer) { clearInterval(busyTimer); busyTimer = null; }
}
function startBusyTicker() {
stopBusyTicker();
busyStartAt = Date.now();
refreshBusyHint();
busyTimer = setInterval(refreshBusyHint, 1000);
}
function renderBars(level, animate) { function renderBars(level, animate) {
if (!bars.length) return; if (!bars.length) return;
const t = Date.now() / 1000; const t = Date.now() / 1000;
@@ -121,22 +179,9 @@
rafId = 0; rafId = 0;
if (!overlay || overlay.classList.contains('hidden')) return; if (!overlay || overlay.classList.contains('hidden')) return;
let animate = false; // 电平只有一个来源:pushChunk() 每收到一片 PCM 就更新 levelTarget。
if (analyser && audioBuf) { // 超过 300ms 没有新数据(授权还没给 / 已经停了)→ 静默停在基线,不假动。
analyser.getFloatTimeDomainData(audioBuf); if (Date.now() - lastRealLevelAt > 300) {
let sum = 0;
for (let i = 0; i < audioBuf.length; i++) sum += audioBuf[i] * audioBuf[i];
const rms = Math.sqrt(sum / audioBuf.length);
const db = 20 * Math.log10(rms + 1e-7); // 静音约 -140,正常说话 -35 ~ -12
levelTarget = dbToLevel(db);
animate = true;
} else if (Date.now() - lastRealLevelAt <= 300) {
animate = true; // 壳刚上报过电平
}
if (!animate) {
// 没有电平来源(壳没实现 onNativeVoiceAmp / AnalyserNode 不可用):
// 静默停在基线,不再空转(也绝不能假动)
levelCur = 0; levelCur = 0;
renderBars(0, false); renderBars(0, false);
return; return;
@@ -148,25 +193,68 @@
rafId = requestAnimationFrame(tickMeter); rafId = requestAnimationFrame(tickMeter);
} }
function attachAnalyser() { // iOS Safari 只允许在用户手势里真正启动 AudioContext;getUserMedia 之后那条异步链已经
if (!stream) return; // 脱离手势,那时才 new AudioContext 有可能一直 suspended(一点声音都采不到)。
// 所以在 pointerdown 里先把 ctx 建好并 resume,拿到麦克风后直接复用。
function primeAudioCtx() {
if (audioCtx) return true;
const AC = window.AudioContext || window.webkitAudioContext;
if (!AC) return false;
try { try {
const AC = window.AudioContext || window.webkitAudioContext;
if (!AC) return;
audioCtx = new AC(); audioCtx = new AC();
analyser = audioCtx.createAnalyser();
analyser.fftSize = 512;
audioBuf = new Float32Array(analyser.fftSize);
srcNode = audioCtx.createMediaStreamSource(stream);
srcNode.connect(analyser); // 不接 destination,不会回放
if (audioCtx.state === 'suspended') audioCtx.resume(); if (audioCtx.state === 'suspended') audioCtx.resume();
startLoop(); // 之前可能在静默态停掉了循环 return true;
} catch (_) { } catch (_) {
analyser = null; audioCtx = null;
audioBuf = null; return false;
} }
} }
// 浏览器:拿 PCM 只能靠 ScriptProcessor(已标废弃,但 Chrome/Safari/Firefox 都还在,
// 且不需要额外加载文件)。AudioWorklet 要 addModule,异步加载会吞掉开头几个字。
function startCapture() {
if (!stream || !primeAudioCtx()) return false;
try {
capRate = audioCtx.sampleRate || 48000;
dsAcc = 0; dsN = 0; dsPhase = 0;
srcNode = audioCtx.createMediaStreamSource(stream);
procNode = audioCtx.createScriptProcessor(1024, 1, 1);
procNode.onaudioprocess = function (ev) {
const pcm = downsampleTo16k(ev.inputBuffer.getChannelData(0));
if (pcm.length) pushChunk(pcm, OUT_RATE);
};
srcNode.connect(procNode);
// 必须接到 destination 才会被驱动;输出缓冲区不写,所以不会外放
procNode.connect(audioCtx.destination);
if (audioCtx.state === 'suspended') audioCtx.resume();
startLoop();
return true;
} catch (_) {
stopMeter(false);
return false;
}
}
// Float32(任意采样率)→ 16k Int16。按「输出周期内取均值」降采样:既是抽点也能压一点高频,
// 且 dsPhase 跨分片累计,长时间录不会整体越走越快/越慢(整数倍抽取会)。
function downsampleTo16k(input) {
const out = new Int16Array(Math.ceil(input.length * OUT_RATE / capRate) + 1);
let n = 0;
for (let i = 0; i < input.length; i++) {
dsAcc += input[i];
dsN++;
dsPhase += OUT_RATE;
if (dsPhase >= capRate) {
dsPhase -= capRate;
const v = Math.round((dsAcc / dsN) * 32767);
out[n++] = v > 32767 ? 32767 : v < -32768 ? -32768 : v;
dsAcc = 0;
dsN = 0;
}
}
return n === out.length ? out : out.subarray(0, n);
}
function startMeter() { function startMeter() {
stopMeter(false); stopMeter(false);
levelTarget = 0; levelTarget = 0;
@@ -177,9 +265,13 @@
function stopMeter(flatten) { function stopMeter(flatten) {
if (rafId) { cancelAnimationFrame(rafId); rafId = 0; } if (rafId) { cancelAnimationFrame(rafId); rafId = 0; }
if (procNode) {
try { procNode.disconnect(); } catch (_) { /* 已断 */ }
procNode.onaudioprocess = null;
procNode = null;
}
if (srcNode) { try { srcNode.disconnect(); } catch (_) { /* 已断 */ } srcNode = null; } if (srcNode) { try { srcNode.disconnect(); } catch (_) { /* 已断 */ } srcNode = null; }
analyser = null; // 采集节点也挂在这个 ctx 上:关掉它浏览器这边就彻底不再送 PCM 了
audioBuf = null;
if (audioCtx) { try { audioCtx.close(); } catch (_) { /* 已关 */ } audioCtx = null; } if (audioCtx) { try { audioCtx.close(); } catch (_) { /* 已关 */ } audioCtx = null; }
if (flatten !== false) { if (flatten !== false) {
for (let i = 0; i < bars.length; i++) bars[i].style.transform = 'scaleY(.12)'; for (let i = 0; i < bars.length; i++) bars[i].style.transform = 'scaleY(.12)';
@@ -206,9 +298,9 @@
pressing = false; pressing = false;
pressY = 0; pressY = 0;
discard = false; discard = false;
stopBusyTicker();
abortStream();
if (stopTimer) { clearTimeout(stopTimer); stopTimer = null; } if (stopTimer) { clearTimeout(stopTimer); stopTimer = null; }
if (hardTimer) { clearTimeout(hardTimer); hardTimer = null; }
if (watchdog) { clearTimeout(watchdog); watchdog = null; }
hold.classList.remove('recording'); hold.classList.remove('recording');
setHoldText('按住 说话'); setHoldText('按住 说话');
hideOverlay(); hideOverlay();
@@ -221,14 +313,6 @@
stream = null; stream = null;
} }
function pickMime() {
const list = ['audio/webm;codecs=opus', 'audio/webm', 'audio/mp4', 'audio/ogg;codecs=opus'];
for (let i = 0; i < list.length; i++) {
try { if (MediaRecorder.isTypeSupported(list[i])) return list[i]; } catch (_) { /* 忽略 */ }
}
return '';
}
// ---------- 模式切换 ---------- // ---------- 模式切换 ----------
function enter() { function enter() {
if (!available || mode) return; if (!available || mode) return;
@@ -257,21 +341,24 @@
if (phase !== 'idle') return; if (phase !== 'idle') return;
pressing = true; pressing = true;
discard = false; discard = false;
segSent = 0;
segDone = 0;
hold.classList.add('recording'); hold.classList.add('recording');
setHoldText('松开 结束'); setHoldText('松开 结束');
showOverlay(); showOverlay();
if (native) { if (native) {
// 原生侧即使要弹权限也先当「已开始」:松开时 stopVoice(),壳若还在等权限会忽略, // 原生侧即使要弹权限也先当「已开始」:页面已经开始收分片,壳真开录后会推数据。
// 由 watchdog 兜底复位(只有首次授权那一次会遇到)。 // 首次授权那一次的分片要等用户点允许才会到,之前的静音不计入。
phase = 'recording'; phase = 'recording';
recordStartAt = Date.now(); recordStartAt = Date.now();
gen++; // 新会话:让上一轮迟到的结果全部失效
inflight = []; // 上一轮的在途请求不再计入本轮收口
streamOn = true;
pcmRate = 16000;
clearSeg();
textParts = [];
stopTimer = setTimeout(finishHold, MAX_MS); stopTimer = setTimeout(finishHold, MAX_MS);
hardTimer = setTimeout(function () {
try { if (native.cancelVoice) native.cancelVoice(); } catch (_) { /* 忽略 */ }
resetUI();
toast('录音超时');
}, MAX_MS + NO_RESULT_MS);
try { try {
native.startVoice(); native.startVoice();
} catch (e) { } catch (e) {
@@ -281,7 +368,9 @@
return; return;
} }
phase = 'arming'; // 等 getUserMedia/MediaRecorder 起来 // 浏览器:先拿麦克风(可能要等用户授权),拿到后 startCapture 开始往里推 PCM
phase = 'arming';
primeAudioCtx(); // 必须在手势里建(见 primeAudioCtx 注释)
startWeb(); startWeb();
} }
@@ -295,46 +384,24 @@
return; return;
} }
if (!pressing) { releaseStream(); resetUI(); return; } // 松开得比授权快 if (!pressing) { releaseStream(); resetUI(); return; } // 松开得比授权快
attachAnalyser(); // 声波接同一路 MediaStream
mime = pickMime();
try {
rec = mime ? new MediaRecorder(stream, { mimeType: mime }) : new MediaRecorder(stream);
} catch (_) {
rec = new MediaRecorder(stream);
mime = rec.mimeType || '';
}
chunks = [];
rec.ondataavailable = function (ev) {
if (ev.data && ev.data.size) chunks.push(ev.data);
};
rec.onstop = function () {
const type = mime || 'audio/webm';
const blob = new Blob(chunks, { type: type });
chunks = [];
rec = null;
releaseStream();
if (discard) { discard = false; resetUI(); toast('说话时间太短'); return; }
upload(blob);
};
rec.onerror = function () {
releaseStream();
resetUI();
toast('录音出错');
};
try {
rec.start();
} catch (e) {
releaseStream();
resetUI();
toast('无法开始录音:' + String((e && e.message) || e));
return;
}
// 与套壳同一套状态,只是换成了「自己采 PCM」而不是「等壳推」
phase = 'recording'; phase = 'recording';
recordStartAt = Date.now(); recordStartAt = Date.now();
gen++;
pcmRate = OUT_RATE;
streamOn = true;
inflight = [];
clearSeg();
textParts = [];
if (!startCapture()) {
streamOn = false;
releaseStream();
resetUI();
toast('无法开始录音:当前浏览器采不到音频');
return;
}
stopTimer = setTimeout(finishHold, MAX_MS); stopTimer = setTimeout(finishHold, MAX_MS);
hardTimer = setTimeout(resetUI, MAX_MS + NO_RESULT_MS);
} }
// 松手:结束录音(太短则丢弃) // 松手:结束录音(太短则丢弃)
@@ -347,10 +414,23 @@
phase = 'busy'; phase = 'busy';
hold.classList.remove('recording'); hold.classList.remove('recording');
setHoldText(discard ? '按住 说话' : '正在识别…'); setHoldText(discard ? '按住 说话' : '正在识别…');
// 遮罩留着,文案换成「正在识别…」;柱子停在低位,等结果回来再收 // 遮罩留着,文案换成动态识别进度;柱子停在低位,等结果回来再收
setOverlayMode(discard ? 'send' : 'busy'); setOverlayMode(discard ? 'send' : 'busy');
stopMeter(); stopMeter();
if (discard) {
abortStream();
releaseStream();
nativeStop(false); // 只停采集,不用管壳知不知道“被丢弃”(页面已经不再收分片)
resetUI();
toast('说话时间太短');
return;
}
// 两条路收口完全一样:把不足一个停顿的尾巴发走(纯静音的尾巴不发),再等所有段回来。
// 大部分段在说话过程中已经识别完了,这里通常只等最后一段。
flushTail();
startBusyTicker(); // 尾巴已进队列:现在才有准确的总段数,从这一刻开始计时
if (native) { if (native) {
try { try {
native.stopVoice(); native.stopVoice();
@@ -359,57 +439,29 @@
toast('结束录音失败:' + String((e && e.message) || e)); toast('结束录音失败:' + String((e && e.message) || e));
return; return;
} }
// 壳若因为权限弹窗没有真正开录,stopVoice() 会被忽略、结果不会回来 } else {
watchdog = setTimeout(function () { releaseStream(); // 采集节点已经由上面的 stopMeter() 拆掉了
if (phase !== 'busy') return;
try { if (native.cancelVoice) native.cancelVoice(); } catch (_) { /* 忽略 */ }
resetUI();
}, NO_RESULT_MS);
return;
} }
waitFlush();
}
// 让壳停止采集:优先 cancelVoice(语义明确),壳没实现时退回 stopVoice——
// 否则麦克风会在壳侧一直开着(页面这边已经不再收分片了,但录音还在跑)。
function nativeStop(cancel) {
if (!native) return;
try { try {
if (rec && rec.state !== 'inactive') rec.stop(); if (cancel && native.cancelVoice) native.cancelVoice();
else { releaseStream(); resetUI(); } else if (native.stopVoice) native.stopVoice();
} catch (_) { } catch (_) { /* 已停 */ }
releaseStream();
resetUI();
}
} }
// 放弃本次录音(切模式 / 离开页面 / 上滑取消 / 壳回调 cancelled) // 放弃本次录音(切模式 / 离开页面 / 上滑取消 / 壳回调 cancelled)
function cancelHold() { function cancelHold() {
if (phase === 'idle') return; if (phase === 'idle') return;
const r = rec; abortStream(); // 丢弃已发在途的结果,也不碰输入框
rec = null; releaseStream(); // 浏览器:停麦克风轨道(采集节点由 resetUI → stopMeter 拆)
chunks = []; nativeStop(true);
if (r) { r.onstop = null; r.onerror = null; }
releaseStream();
resetUI(); resetUI();
try {
if (r && r.state !== 'inactive') r.stop();
else if (native && native.cancelVoice) native.cancelVoice();
} catch (_) { /* 已停 */ }
}
// ---------- 上传 + 自动发送 ----------
function upload(blob) {
if (!blob || !blob.size) { resetUI(); toast('没有录到声音'); return; }
phase = 'busy';
setOverlayMode('busy');
req('POST', '/api/asr/transcribe', blob, true, 120000)
.then(function (r) {
const text = String((r && r.text) || '').replace(/\s+/g, ' ').trim();
// 先收遮罩再做后续:toast 固定在 bottom:96px,遮罩还在时弹出来会压住声波
resetUI();
if (!text) { toast('没有识别到内容'); return; }
ta.value = text;
send();
})
.catch(function (e) {
resetUI();
toast('语音识别失败:' + String((e && e.message) || e));
});
} }
// ---------- 按住 / 滑动 / 松开 ---------- // ---------- 按住 / 滑动 / 松开 ----------
@@ -478,43 +530,238 @@
// 录音中离开页面:释放麦克风 // 录音中离开页面:释放麦克风
window.addEventListener('pagehide', cancelHold); window.addEventListener('pagehide', cancelHold);
// ---------- 原生桥回调(契约见 docs/voice-input.md) ---------- // ---------- PCM 处理(两条录音路径共用) ----------
// 实时幅度:套壳每 ~100ms 上报一次 MediaRecorder.getMaxAmplitude() 的**原始值**(0~32767)。 // 壳每 ~100ms 推一片 16bit/单声道小端 PCM;浏览器自己采。采样率、分片大小、门限全部不在别处算。
// 换算、门限、平滑全部在页面侧做——规则只存在这一份,壳不要做任何数学。 function b64ToI16(b64) {
function onNativeAmp(raw) { const bin = atob(String(b64 || ''));
if (!native) return; const n = bin.length >> 1;
const amp = Number(raw); const out = new Int16Array(n);
if (!isFinite(amp)) return; for (let i = 0; i < n; i++) out[i] = (bin.charCodeAt(i * 2 + 1) << 8) | bin.charCodeAt(i * 2);
lastRealLevelAt = Date.now(); return out;
if (amp <= 0) {
levelTarget = 0;
} else {
const db = 20 * Math.log10(Math.min(amp, 32767) / 32767);
levelTarget = dbToLevel(db);
}
startLoop(); // 静默态下循环已停,下一帧数据到了再启
} }
window.onNativeVoiceAmp = onNativeAmp;
window.onNativeVoiceLevel = onNativeAmp; // 旧名兼容:同样按原始幅度解释
window.onNativeVoiceResult = function (b64, mimeType) { // 这一片 PCM 的峰值电平(dBFS)。用峰值而不是 RMS:与原先 getMaxAmplitude 的尺度一致。
if (phase !== 'busy' && phase !== 'recording') return; function peakDb(arr) {
if (watchdog) { clearTimeout(watchdog); watchdog = null; } let peak = 0;
if (discard) { discard = false; resetUI(); toast('说话时间太短'); return; } for (let i = 0; i < arr.length; i++) {
try { const v = arr[i] < 0 ? -arr[i] : arr[i];
const bin = atob(String(b64 || '')); if (v > peak) peak = v;
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; i++) arr[i] = bin.charCodeAt(i);
upload(new Blob([arr], { type: mimeType || 'audio/mp4' }));
} catch (_) {
resetUI();
toast('语音数据解析失败');
} }
return peak <= 0 ? -Infinity : 20 * Math.log10(peak / 32767);
}
function encodeWav(samples, rate) {
const b = new ArrayBuffer(44 + samples.length * 2);
const v = new DataView(b);
const str = function (off, s) { for (let i = 0; i < s.length; i++) v.setUint8(off + i, s.charCodeAt(i)); };
str(0, 'RIFF'); v.setUint32(4, 36 + samples.length * 2, true); str(8, 'WAVE');
str(12, 'fmt '); v.setUint32(16, 16, true);
v.setUint16(20, 1, true); // PCM
v.setUint16(22, 1, true); // mono
v.setUint32(24, rate, true); // 采样率
v.setUint32(28, rate * 2, true); // byte rate
v.setUint16(32, 2, true); v.setUint16(34, 16, true);
str(36, 'data'); v.setUint32(40, samples.length * 2, true);
for (let i = 0, o = 44; i < samples.length; i++, o += 2) v.setInt16(o, samples[i], true);
return new Blob([b], { type: 'audio/wav' });
}
// 从当前段取前 n 个采样(拼成一段连续 PCM)
function takeSeg(n) {
const out = new Int16Array(n);
let off = 0;
for (const c of segChunks) {
if (off >= n) break;
const k = Math.min(c.length, n - off);
out.set(k === c.length ? c : c.subarray(0, k), off);
off += k;
}
return out;
}
function clearSeg() { segChunks = []; segLens = []; segDbs = []; segLen = 0; silLen = 0; }
// 长说不停顿是最慢的路径:没有 0.5s 停顿就一段都发不出去,只能憋到松手整段上传。
// 所以累计语音到 VAD_SOFT_CUT_SEC 后,在尾部窗口里挑能量最低的分片边界先切一刀,
// 后面的继续累积。真静音切点依然优先(更自然),这里只解决「一直说个没完」。
function softCutChunk() {
const win = Math.floor(pcmRate * VAD_SOFT_WINDOW_SEC);
let from = segChunks.length - 1; // 窗口起点分片下标
let acc = 0;
for (let i = segChunks.length - 1; i >= 0; i--) {
acc += segLens[i];
from = i;
if (acc >= win) break;
}
let best = from;
for (let i = from + 1; i < segChunks.length; i++) {
if (segDbs[i] < segDbs[best]) best = i;
}
// 切在 best 之前(前 best 片发走);best 为 0 说明没有可切的前缀
return best > 0 ? best : -1;
}
// 从段头取走前 k 个分片发出去,剩下的留在缓冲里继续累积
function softCut(k) {
let n = 0;
for (let i = 0; i < k; i++) n += segLens[i];
emitSegment(n);
segChunks = segChunks.slice(k);
segLens = segLens.slice(k);
segDbs = segDbs.slice(k);
segLen -= n;
if (silLen > segLen) silLen = segLen; // 切点落在尾巴的静音里时,静音计数不能超过剩余长度
}
// 把当前段的前 n 个采样作为一段发出去(太短当噪声丢掉)。
// 注意:必须在 clearSeg() 之前调,takeSeg 要读 segChunks。
function emitSegment(n) {
if (n < pcmRate * VAD_MIN_SPEECH_SEC) return;
emit(encodeWav(takeSeg(n), pcmRate));
}
// 每段切出来就发,不等上一段回来,但同时最多 ASR_MAX_CONCURRENCY 个。
// 名额是「谁落定谁交出去」,不按固定顺序等某一段:否则最慢那段会卡住本可以发的后续段。
// 并行返回是乱序的,所以结果按「提交时的下标」落位,拼接时仍按说话顺序。
function emit(blob) {
const my = gen;
const idx = segSent++; // 分母:已提交的段数,同时是这一段结果的落位下标
const p = acquire().then(function () {
if (my !== gen) { release(); return; } // 已取消/重录:名额还回去,别再发
return req('POST', '/api/asr/transcribe', blob, true, 120000)
.then(function (r) {
if (my !== gen) return;
const t = String((r && r.text) || '').replace(/\s+/g, ' ').trim();
if (t) textParts[idx] = t;
})
.catch(function () {
/* 单段失败不连坐,其余段照常出字;失败也算走完一段,进度才不会停在半路 */
})
.then(function () {
release(); // 不论成败都先腾名额
if (my !== gen) return;
segDone++;
refreshBusyHint();
});
});
inflight.push(p);
}
// 名额:没满直接拿;满了就排队,任一请求落定后把名额交给下一个(不按固定顺序)
function acquire() {
if (active < ASR_MAX_CONCURRENCY) { active++; return Promise.resolve(); }
return new Promise(function (res) { waiting.push(res); });
}
function release() {
const next = waiting.shift();
if (next) next(); // 名额直接转交,active 不变
else active--;
}
// 拼接各段:中文直接相连;两侧都是西文字母/数字时补一个空格,
// 否则英文被切开后会粘成 "helloworld"。
function joinText(parts) {
let out = '';
for (const s of parts) {
if (!s) continue;
if (out && /[A-Za-z0-9]$/.test(out) && /^[A-Za-z0-9]/.test(s)) out += ' ';
out += s;
}
return out;
}
// 丢弃本轮的一切(段缓冲 + 已发在途结果):取消 / 误触 / 超时都走这里
function abortStream() {
streamOn = false;
clearSeg();
textParts = [];
inflight = [];
gen++;
if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
}
// 一片 16bit 单声道 PCM:两条录音路径的唯一汇合点。
// 电平、静音判定、断句、上传全在页面侧;壳和浏览器都不做任何判断。
function pushChunk(pcm, rate) {
if (!streamOn || phase !== 'recording') return;
const r = Number(rate);
if (r > 0 && r !== pcmRate) pcmRate = r;
if (!pcm.length) return;
// 电平:直接用这片 PCM 的峰值
const db = peakDb(pcm);
lastRealLevelAt = Date.now();
levelTarget = db === -Infinity ? 0 : dbToLevel(db);
startLoop();
segChunks.push(pcm);
segLens.push(pcm.length);
segDbs.push(db);
segLen += pcm.length;
// 静音按「整片」判:一片约 20~100ms,足够分辨 0.5s 的停顿(再细也没意义)
silLen = db < VAD_SILENCE_DB ? silLen + pcm.length : 0;
if (silLen >= pcmRate * VAD_PAUSE_SEC) {
// 停顿够了 → 把静音之前的部分发走,静音本身丢掉(不浪费上游额度)
const tail = segLen - silLen;
emitSegment(tail);
clearSeg();
} else if (segLen >= pcmRate * VAD_MAX_SEG_SEC) {
// 一口气说了 25 秒没停顿:硬切(宁可切开也不能超上游上限)
emitSegment(segLen);
clearSeg();
} else if (segLen >= pcmRate * VAD_SOFT_CUT_SEC) {
// 说太久又没停顿:先在能量最低处切一刀(软切),别把整段憋到松手或 25s 硬切
const k = softCutChunk();
if (k > 0) softCut(k);
}
}
// 壳每 ~100ms 推一片 16bit/单声道小端 PCM(契约见 docs/voice-input.md)
window.onNativeVoiceChunk = function (b64, rate) {
if (!native) return;
pushChunk(b64ToI16(b64), rate);
}; };
// 松手/超时:把不足一个停顿的尾巴也发出去,然后等全部段回来。
// 必须剔掉尾巴上的静音:停顿那一下已经把缓冲清空了,之后累积的可能全是静音
//(用户停一会儿才松手),发出去只会换来一次「没有可识别语音」。
function flushTail() {
streamOn = false;
const speech = segLen - silLen;
if (speech > 0) emitSegment(speech);
clearSeg();
}
function waitFlush() {
const my = gen;
flushTimer = setTimeout(function () {
flushTimer = null;
if (my !== gen) return;
gen++; // 让迟到结果失效
resetUI();
toast('语音识别超时');
}, FLUSH_MS);
// 并行发之后没有串行链可挂:等本轮全部段落定(含被限流挡着的)再收口。
// 逐个兜一层 catch:只要有一个 Promise 意外 reject,Promise.all 就整批失败,
// 收口逻辑永远不跑,只能等 60s 超时把已识别的内容全部丢掉。
const all = inflight.map(function (p) { return p.catch(function () {}); });
Promise.all(all).then(function () {
if (my !== gen) return;
if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
const text = joinText(textParts);
// 先收遮罩再做后续:toast 固定在 bottom:96px,遮罩还在时弹出来会压住声波
resetUI();
if (!text) { toast('没有识别到内容'); return; }
ta.value = text;
send();
});
}
window.onNativeVoiceState = function (s) { window.onNativeVoiceState = function (s) {
if (!native || s !== 'recording' || phase !== 'recording') return; if (!native || s !== 'recording' || phase !== 'recording') return;
// 真正开录:60s 与「太短」判定从这一刻算(首次授权弹窗的时间不算) // 真正开录:180s 与「太短」判定从这一刻算(首次授权弹窗的时间不算)
recordStartAt = Date.now(); recordStartAt = Date.now();
if (stopTimer) clearTimeout(stopTimer); if (stopTimer) clearTimeout(stopTimer);
stopTimer = setTimeout(finishHold, MAX_MS); stopTimer = setTimeout(finishHold, MAX_MS);
@@ -523,6 +770,7 @@
window.onNativeVoiceError = function (code, message) { window.onNativeVoiceError = function (code, message) {
if (phase === 'idle') return; if (phase === 'idle') return;
abortStream();
resetUI(); resetUI();
// 生命周期打断(切后台/换页)属预期,不弹提示 // 生命周期打断(切后台/换页)属预期,不弹提示
if (code === 'cancelled' || code === 'canceled') return; if (code === 'cancelled' || code === 'canceled') return;
@@ -544,10 +792,11 @@
console.info('[voice] 语音入口未启用:没有 window.AgentNative,且当前不是安全上下文(需 HTTPS,或由套壳 App 注入原生桥)'); console.info('[voice] 语音入口未启用:没有 window.AgentNative,且当前不是安全上下文(需 HTTPS,或由套壳 App 注入原生桥)');
return; return;
} }
// 服务端没接线(core 的 ASR_URL 为空)就不给入口;探测失败则照常启用 // 服务端没接线(core 的 ASR_URL 为空,或 config.yml 里没有可用的 asr 段)就不给入口;
// 探测失败则照常启用(不因一次探测失败就永久藏掉入口)。
req('GET', '/api/asr/status').then(function (s) { req('GET', '/api/asr/status').then(function (s) {
if (s && s.enabled === false) { if (s && s.enabled === false) {
console.info('[voice] 语音入口未启用:服务端未配置语音识别(agent-core 的 ASR_URL 为空)'); console.info('[voice] 语音入口未启用:' + ((s && s.reason) || '服务端未配置语音识别'));
return; return;
} }
available = true; available = true;
+4 -2
View File
@@ -2,7 +2,7 @@
<html lang="zh"> <html lang="zh">
<head> <head>
<meta charset="UTF-8"> <meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"> <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover, interactive-widget=resizes-content">
<title>Agent 任务台 · 登录</title> <title>Agent 任务台 · 登录</title>
<meta name="theme-color" content="#1e3c72"> <meta name="theme-color" content="#1e3c72">
<meta name="apple-mobile-web-app-capable" content="yes"> <meta name="apple-mobile-web-app-capable" content="yes">
@@ -13,7 +13,8 @@
<link rel="stylesheet" href="/css/style.css"> <link rel="stylesheet" href="/css/style.css">
<style> <style>
.login-wrap { .login-wrap {
position: fixed; inset: 0; display: flex; align-items: center; justify-content: center; /* bottom 让出软键盘:表单垂直居中,键盘弹起时卡片跟着可见区域上移(--kb 见 js/viewport.js) */
position: fixed; inset: 0; bottom: var(--kb, 0px); display: flex; align-items: center; justify-content: center;
background: linear-gradient(135deg, #1e3c72, #2a5299); background: linear-gradient(135deg, #1e3c72, #2a5299);
} }
.login-card { .login-card {
@@ -39,6 +40,7 @@
<p class="login-error" id="login-error"></p> <p class="login-error" id="login-error"></p>
</form> </form>
</div> </div>
<script src="/js/viewport.js"></script>
<script> <script>
'use strict'; 'use strict';
const TOKEN_KEY = 'agent_token'; const TOKEN_KEY = 'agent_token';
+9 -2
View File
@@ -50,8 +50,12 @@ self.addEventListener('fetch', (event) => {
// 只处理同源 // 只处理同源
if (url.origin !== self.location.origin) return; if (url.origin !== self.location.origin) return;
// 跳过 API/SSE/预览/交付取件,避免缓存动态数据(预览页需实时;/f/ 同链内容会随重新 save 变化) // 跳过 API/SSE/预览/交付取件,避免缓存动态数据(预览页需实时;/f/ 同链内容会随重新 save 变化)。
if (url.pathname.startsWith('/api/') || url.pathname.startsWith('/sse') || url.pathname.startsWith('/preview') || url.pathname.startsWith('/f/')) return; // /p/ 是公网短链(图片/文件直链):内容是二进制、带 TTL 的 bearer 能力,既不能当 HTML 文本重建,
// 也不该进缓存。漏掉它时点开图片外链会先被“导航”分支 fetch 两次、再按文本重建,结果是一张坏图,
// 日志里表现为每点一次成对出现两条 public-file 取用记录。
if (url.pathname.startsWith('/api/') || url.pathname.startsWith('/sse') || url.pathname.startsWith('/preview')
|| url.pathname.startsWith('/f/') || url.pathname.startsWith('/p/')) return;
// vendor 预览页发出的根绝对请求(fetch('/') 自刷新、EventSource('/events') 等,Referer 是预览页): // vendor 预览页发出的根绝对请求(fetch('/') 自刷新、EventSource('/events') 等,Referer 是预览页):
// 内容随文档变化,既不缓存,也不能把 office 文档页写进 '/' 这类 SPA 缓存键。 // 内容随文档变化,既不缓存,也不能把 office 文档页写进 '/' 这类 SPA 缓存键。
@@ -73,6 +77,9 @@ self.addEventListener('fetch', (event) => {
try { try {
const resp = await fetch(request); const resp = await fetch(request);
if (!resp.ok || resp.type !== 'basic') return resp; if (!resp.ok || resp.type !== 'basic') return resp;
// 非 HTML 的导航(图片/PDF 等直链):二进制不能按文本重建,原样透传;
// 否则 resp.text() 会把像素解成替换字符,页面只剩空白/乱码。
if (!/text\/html/i.test(resp.headers.get('content-type') || '')) return resp;
last = { txt: await resp.text(), resp }; last = { txt: await resp.text(), resp };
} catch (e) { } catch (e) {
if (last) break; // 已有残破快照:降级返回它 if (last) break; // 已有残破快照:降级返回它
+60 -5
View File
@@ -4,8 +4,20 @@
// 一个宿主端口都不占(它自身没有鉴权,暴露即被白嫖)。对外唯一的入口仍是 core, // 一个宿主端口都不占(它自身没有鉴权,暴露即被白嫖)。对外唯一的入口仍是 core,
// 鉴权沿用全局登录态(auth.middleware 已挂在 /api 之前)。 // 鉴权沿用全局登录态(auth.middleware 已挂在 /api 之前)。
// //
// 开关:core 的 ASR_URL 为空 = 未部署语音识别,本路由一律 503,前端据此不显示麦克风。 // 上游参数全部来自 config.yml 的 mcp_servers 里那条 asr(与 image_task 完全同构):
// - name: asr
// url: "http://mcp_asr:3000/mcp"
// headers:
// Authorization: Bearer <key> # 免鉴权的自建服务可省
// X-ASR-Base-Url: "https://.../v1"
// X-ASR-Model: "whisper-1"
// mcp_asr 自己不存任何平台密钥(容器 env 一条都不读),所以要换 ASR 平台只改这个文件对应的
// YAML 段 + 重启 core,不碰 .env、不重建镜像。头名与 mcp/asr/src/server.js 的常量一一对应。
//
// 开关:ASR_URL 为空(未部署 mcp_asr)或配置里没有可用的 asr 段 = 关闭,本路由一律 503,
// 前端据此不显示麦克风。ASR_URL 留在 env 是部署接线(容器地址),不属于平台密钥。
const express = require('express'); const express = require('express');
const engine = require('../engine');
const log = require('../log'); const log = require('../log');
const router = express.Router(); const router = express.Router();
@@ -15,6 +27,39 @@ const ASR_URL = String(process.env.ASR_URL || '').trim().replace(/\/+$/, '');
const MAX_BYTES = 20 * 1024 * 1024; const MAX_BYTES = 20 * 1024 * 1024;
const TIMEOUT_MS = 120000; const TIMEOUT_MS = 120000;
// 只转发 ASR 约定的三个头:config.yml 里该条目的其它 header 与本服务无关,没必要透传进内网。
const PASS_HEADERS = ['authorization', 'x-asr-base-url', 'x-asr-model'];
// 取当前生效的 asr 配置段。配置冷加载(engine 里那份是启动时解析的),所以这里读到的就是
// 运行中的值;重启前改 config.yml 不会影响已生效的这份,与其它配置项一致。
function asrEntry() {
let cfg = null;
try { cfg = engine.getConfig(); } catch (_) { cfg = null; } // 启动早期 engine 还没拿到 cfg
const list = (cfg && cfg.mcp_servers) || [];
const s = list.find(function (x) { return x && x.name === 'asr'; });
// mode: disable = 明确关闭(与模型侧工具同一开关:关了就别给麦克风)
if (!s || s.mode === 'disable') return null;
return s;
}
function asrHeaders() {
const s = asrEntry();
if (!s) return null;
const out = {};
for (const [k, v] of Object.entries(s.headers || {})) {
if (PASS_HEADERS.indexOf(String(k).toLowerCase()) >= 0) out[k] = String(v);
}
return out;
}
// 有没有真的能转写:缺 base_url 就转不了(model 也缺的话 mcp_asr 会给出更具体的报错)。
// 只判 base_url 是为了让「配了但漏填 model」在探测阶段仍显示入口,用户点了能拿到明确提示。
function hasUpstream(headers) {
return Object.keys(headers || {}).some(function (k) {
return k.toLowerCase() === 'x-asr-base-url' && String(headers[k] || '').trim();
});
}
// 只接音频二进制。全局 express.json(2mb) 只解析 application/json,两者不冲突。 // 只接音频二进制。全局 express.json(2mb) 只解析 application/json,两者不冲突。
// 注意 WebView 可能发 audio/mp4、audio/webm;codecs=opus,统一按 audio/* 接。 // 注意 WebView 可能发 audio/mp4、audio/webm;codecs=opus,统一按 audio/* 接。
const rawAudio = express.raw({ const rawAudio = express.raw({
@@ -24,12 +69,22 @@ const rawAudio = express.raw({
// 前端可用性探测(按钮是否显示)。不碰网络,纯看接线。 // 前端可用性探测(按钮是否显示)。不碰网络,纯看接线。
router.get('/status', function (req, res) { router.get('/status', function (req, res) {
res.json({ enabled: !!ASR_URL, max_bytes: MAX_BYTES }); if (!ASR_URL) return res.json({ enabled: false, reason: 'core 未设置 ASR_URL' });
if (!asrEntry()) return res.json({ enabled: false, reason: 'config.yml 的 mcp_servers 里没有启用的 asr' });
const headers = asrHeaders();
if (!hasUpstream(headers)) {
return res.json({ enabled: false, reason: 'config.yml 的 asr.headers 缺 X-ASR-Base-Url' });
}
res.json({ enabled: true, max_bytes: MAX_BYTES });
}); });
router.post('/transcribe', rawAudio, async function (req, res) { router.post('/transcribe', rawAudio, async function (req, res) {
if (!ASR_URL) { if (!ASR_URL) {
return res.status(503).json({ error: '语音识别未配置(core 未设置 ASR_URL)' }); return res.status(503).json({ error: '语音识别未部署(core 未设置 ASR_URL)' });
}
const headers = asrHeaders();
if (!headers || !hasUpstream(headers)) {
return res.status(503).json({ error: '语音识别未配置上游(config.yml 的 asr.headers 需设 X-ASR-Base-Url / X-ASR-Model)' });
} }
const buf = req.body; const buf = req.body;
if (!Buffer.isBuffer(buf) || !buf.length) { if (!Buffer.isBuffer(buf) || !buf.length) {
@@ -38,7 +93,7 @@ router.post('/transcribe', rawAudio, async function (req, res) {
try { try {
const r = await fetch(ASR_URL + '/transcribe', { const r = await fetch(ASR_URL + '/transcribe', {
method: 'POST', method: 'POST',
headers: { 'Content-Type': req.headers['content-type'] || 'application/octet-stream' }, headers: Object.assign({ 'Content-Type': req.headers['content-type'] || 'application/octet-stream' }, headers),
body: buf, body: buf,
signal: AbortSignal.timeout(TIMEOUT_MS), signal: AbortSignal.timeout(TIMEOUT_MS),
}); });
@@ -52,7 +107,7 @@ router.post('/transcribe', rawAudio, async function (req, res) {
const code = r.status >= 400 && r.status < 500 ? r.status : 502; const code = r.status >= 400 && r.status < 500 ? r.status : 502;
return res.status(code).json({ error: msg }); return res.status(code).json({ error: msg });
} }
// 原样透传 ASR 的 {text, ms, backend} // 原样透传 ASR 的 {text, ms, model}
res.type('application/json').send(text); res.type('application/json').send(text);
} catch (e) { } catch (e) {
log.warn('asr', '调用 ASR 服务失败:' + String(e && e.message || e)); log.warn('asr', '调用 ASR 服务失败:' + String(e && e.message || e));
+15 -4
View File
@@ -236,7 +236,11 @@ function handleSend(db, opts) {
// 普通消息:解析当前会话,无绑定自动新建(IM 用户不会先打 /new 才能聊天)。 // 普通消息:解析当前会话,无绑定自动新建(IM 用户不会先打 /new 才能聊天)。
// 微信通道以 binding 行的全局 deep_think 开关作消息的 deepThink 取值(与 H5 按钮 body 同义, // 微信通道以 binding 行的全局 deep_think 开关作消息的 deepThink 取值(与 H5 按钮 body 同义,
// 只是没得点、改用 /think 拨);非 wx 通道照旧不传 opts,行为零变化。 // 只是没得点、改用 /think 拨);非 wx 通道照旧不传 deepThink,行为零变化。
// 投递走 mode:'interject':IM 用户是在实时对话,回合中插话应当「当前工具跑完就插话」,
// 而不是排队等本轮结束。没在跑时 enqueueMessage 等价于立即发送,行为与旧 postUserMessage 一致。
// (旧实现直接 postUserMessage → live 追投:user 行可能落在 assistant.tool_calls 与
// tool 回执之间,批次配对当场断裂。走队列才能保证只在安全边界写库。)
if (!parsed || parsed.normal) { if (!parsed || parsed.normal) {
const wx = String(channel).startsWith('wx:'); const wx = String(channel).startsWith('wx:');
const deepThink = wx ? !!((db.prepare('SELECT deep_think FROM wechat_bindings WHERE id = ?').get(channel.slice(3)) || {}).deep_think) : undefined; const deepThink = wx ? !!((db.prepare('SELECT deep_think FROM wechat_bindings WHERE id = ?').get(channel.slice(3)) || {}).deep_think) : undefined;
@@ -246,10 +250,17 @@ function handleSend(db, opts) {
const r = newSessionFor(db, user, channel, text, wx ? { deepThink } : undefined); const r = newSessionFor(db, user, channel, text, wx ? { deepThink } : undefined);
s = r.s; sent = r.sent; s = r.s; sent = r.sent;
} else { } else {
sent = engine.postUserMessage(s.id, text, wx ? { deepThink } : undefined); sent = engine.enqueueMessage(s.id, text, wx ? { deepThink, mode: 'interject' } : { mode: 'interject' });
} }
log.info('msg', tag + ' channel 消息 → ' + s.id); const queued = !!(sent && sent.queued);
return { kind: 'message', reply: '已发送到会话 ' + s.id, session_id: s.id, message_id: sent.message_id }; log.info('msg', tag + ' channel 消息 → ' + s.id + (queued ? '(已排队,等安全边界投递)' : ''));
return {
kind: 'message',
reply: (queued ? '已排队到会话 ' : '已发送到会话 ') + s.id,
session_id: s.id,
message_id: sent && sent.message_id,
pending_id: sent && sent.pending_id,
};
} }
if (parsed.unknown) { if (parsed.unknown) {
+108 -17
View File
@@ -5,10 +5,55 @@ const express = require('express');
const engine = require('../engine'); const engine = require('../engine');
const { loadConfigFromText, readConfigText, applyEditsToText, writeConfigText } = require('../config'); const { loadConfigFromText, readConfigText, applyEditsToText, writeConfigText } = require('../config');
const balance = require('../balance'); const balance = require('../balance');
const mcp = require('../mcp');
const log = require('../log'); const log = require('../log');
const router = express.Router(); const router = express.Router();
// 平台 / MCP 预设:设置页「新增平台」「添加内置 MCP」的模板来源(纯静态,无密钥)。
// 文件写坏时降级为空预设:通用表单仍可用,不影响其它功能。
const MCP_MODES = ['advertise', 'skill', 'disable'];
function checkPresetList(list, kind, bad) {
const seen = new Set();
(list || []).forEach((x, i) => {
const at = kind + '[' + i + ']';
if (!x || typeof x !== 'object') { bad.push(at + ' 必须是对象'); return; }
if (!x.key || !x.url) { bad.push(at + ' 缺 key/url'); return; }
if (seen.has(x.key)) { bad.push(at + ' key 重复:' + x.key); return; }
seen.add(x.key);
if (kind === 'platforms') {
if (!x.type) bad.push(at + ' 缺 type');
if (x.model_defaults != null && typeof x.model_defaults !== 'object') {
bad.push(at + '.model_defaults 必须是对象');
}
return;
}
if (x.mode != null && MCP_MODES.indexOf(x.mode) < 0) {
bad.push(at + '.mode 只能是 ' + MCP_MODES.join(' / '));
}
if (x.fields != null && !Array.isArray(x.fields)) { bad.push(at + '.fields 必须是数组'); return; }
(x.fields || []).forEach((f, fi) => {
if (!f || !f.header) bad.push(at + '.fields[' + fi + '] 缺 header');
});
});
}
function loadPresets() {
const p = require('../presets.json') || {};
const bad = [];
checkPresetList(p.platforms, 'platforms', bad);
checkPresetList(p.mcp, 'mcp', bad);
if (bad.length) throw new Error(bad.join(';'));
return { platforms: p.platforms || [], mcp: p.mcp || [] };
}
let PRESETS = { platforms: [], mcp: [] };
try {
PRESETS = loadPresets();
} catch (e) {
log.warn('config', 'presets.json 无效,设置页将没有预设:' + String((e && e.message) || e));
}
function sendErr(res, err) { function sendErr(res, err) {
const code = err && err.status_code || 500; const code = err && err.status_code || 500;
res.status(code).json({ error: String(err && err.message || err) }); res.status(code).json({ error: String(err && err.message || err) });
@@ -112,13 +157,29 @@ function restorePasswords(submitted, orig) {
}).join('\n'); }).join('\n');
} }
// MCP header 值脱敏(等同密码):统一固定短掩码 *****(不泄露长度),原文编辑器与 effective 视图共用。 // MCP header 值脱敏:只遮「像密钥的」,base-url / model 这类明文回显——
// 设置页的引导表单要看得见当前值才能改。两条启发式任一命中即遮:
// 名字(Authorization / X-*-Token / X-Api-Key …)、值(Bearer … / sk-…)。
// 值那条是兜底:用户自定义的怪名字(X-Upstream-Auth: sk-xxx)也不会明文外显。
// headers 行 = `headers:` 块内比它更深缩进的键值行(如 ` Authorization: Bearer sk-xxx`,引号可选)。 // headers 行 = `headers:` 块内比它更深缩进的键值行(如 ` Authorization: Bearer sk-xxx`,引号可选)。
// 局限:块标量(|/>)续行内容无法逐行识别,与 api_key/password 的行级掩码同一量级的取舍。 // 局限:块标量(|/>)续行内容无法逐行识别,与 api_key/password 的行级掩码同一量级的取舍。
const MCP_HEADER_MASK = '*****'; const MCP_HEADER_MASK = '*****';
const HEADERS_BLOCK_LINE = /^(\s*)headers:\s*(?:#.*)?$/; const HEADERS_BLOCK_LINE = /^(\s*)headers:\s*(?:#.*)?$/;
const MCP_HEADER_LINE = /^(\s*(?:-\s+)?[\w.-]+:\s*)(["']?)(.*)\2\s*$/; const MCP_HEADER_LINE = /^(\s*(?:-\s+)?[\w.-]+:\s*)(["']?)(.*)\2\s*$/;
function maskHeaderValue(v) { return v ? MCP_HEADER_MASK : ''; } const SECRET_NAME_RE = /^(authorization|cookie)$|(?:^|[-_])(token|key|secret|password)(?:[-_]|$)/i;
const SECRET_VALUE_RE = /^Bearer\s|^sk-[A-Za-z0-9_-]{16,}/i;
function isSecretHeader(name, value) {
return SECRET_NAME_RE.test(String(name || '').trim()) ||
SECRET_VALUE_RE.test(String(value == null ? '' : value).trim());
}
function maskHeaderValue(name, v) {
if (!v) return '';
return isSecretHeader(name, v) ? MCP_HEADER_MASK : v;
}
// 从匹配行里取 header 名(去掉列表短横与结尾冒号),用于按键名遮罩/还原
function headerNameOf(m) {
return String(m[1] || '').replace(/^\s*-\s*/, '').replace(/:\s*$/, '').trim();
}
// 遍历 headers 块内的键值行,fn(line, match) 返回替换后的行;块边界按缩进判定。 // 遍历 headers 块内的键值行,fn(line, match) 返回替换后的行;块边界按缩进判定。
function mapMcpHeaderLines(text, fn) { function mapMcpHeaderLines(text, fn) {
if (!text) return text; if (!text) return text;
@@ -138,22 +199,32 @@ function mapMcpHeaderLines(text, fn) {
} }
function maskMcpHeaders(text) { function maskMcpHeaders(text) {
return mapMcpHeaderLines(text, function (line, m) { return mapMcpHeaderLines(text, function (line, m) {
return m[1] + m[2] + maskHeaderValue(m[3]) + m[2]; return m[1] + m[2] + maskHeaderValue(headerNameOf(m), m[3]) + m[2];
}); });
} }
// 还原:提交原文中值恰为 ***** 的 header 行 = 用户未改动,按出现顺序从原文件取回原值;其他值原样保留。 // 还原:提交原文里值恰为 ***** 的行 = 用户未改动,按键名从原文件取回真值。
// 按键名而非出现顺序:只遮部分 header 后,按顺序还原会张冠李戴。
// 键名在原文里找不到(改名/新增行却留着占位)直接报错,绝不把占位写进配置。
function restoreMcpHeaders(submitted, orig) { function restoreMcpHeaders(submitted, orig) {
if (!submitted) return submitted; if (!submitted) return submitted;
const origVals = []; const origVals = {};
mapMcpHeaderLines(orig || '', function (line, m) { origVals.push(m[3]); return line; }); mapMcpHeaderLines(orig || '', function (line, m) { origVals[headerNameOf(m)] = m[3]; return line; });
let i = 0;
return mapMcpHeaderLines(submitted, function (line, m) { return mapMcpHeaderLines(submitted, function (line, m) {
if (m[3] !== MCP_HEADER_MASK) return line; // 用户改过,保留手输新值 if (m[3] !== MCP_HEADER_MASK) return line; // 用户改过,保留手输新值
const ov = i < origVals.length ? origVals[i] : ''; const name = headerNameOf(m);
i++; if (!(name in origVals)) throw new Error('Header「' + name + '」的值为脱敏占位且找不到原值,请填写真实值');
return m[1] + m[2] + ov + m[2]; return m[1] + m[2] + origVals[name] + m[2];
}); });
} }
// 整文件编辑的还原链:掩码占位按原文件回填真值;还原不了属于用户输入问题,回 400
function unmaskText(text, origText) {
try {
return restoreApiKeys(restorePasswords(restoreMcpHeaders(text, origText), origText), origText);
} catch (e) {
e.status_code = 400;
throw e;
}
}
// PATCH 细粒度编辑的 headers 还原:值=掩码占位时按键名找回原值(前端只持有脱敏视图,改不动真值)。 // PATCH 细粒度编辑的 headers 还原:值=掩码占位时按键名找回原值(前端只持有脱敏视图,改不动真值)。
// 找不到可还原的原值(新增服务/用户改了 header 名)则报错,绝不把占位符写进配置。 // 找不到可还原的原值(新增服务/用户改了 header 名)则报错,绝不把占位符写进配置。
function restoreHeaderMasks(headers, origHeaders) { function restoreHeaderMasks(headers, origHeaders) {
@@ -168,13 +239,22 @@ function restoreMaskedHeaderEdit(e, curCfg) {
if (e.delete) return; if (e.delete) return;
const p = e.path; const p = e.path;
if (p[0] !== 'mcp_servers') return; if (p[0] !== 'mcp_servers') return;
const origOf = (i) => (((curCfg || {}).mcp_servers || [])[Number(i)] || {}).headers || {};
if (e.append) { // 新增服务没有“原值”可言,出现占位即拒绝 if (e.append) { // 新增服务没有“原值”可言,出现占位即拒绝
if (e.value && e.value.headers) restoreHeaderMasks(e.value.headers, null); if (e.value && e.value.headers) restoreHeaderMasks(e.value.headers, null);
return; return;
} }
if (p.length === 3 && p[2] === 'headers' && e.value && typeof e.value === 'object') { if (p.length === 3 && p[2] === 'headers' && e.value && typeof e.value === 'object') {
const orig = (((curCfg || {}).mcp_servers || [])[Number(p[1])] || {}).headers || {}; restoreHeaderMasks(e.value, origOf(p[1]));
restoreHeaderMasks(e.value, orig); return;
}
// 单个 header 的叶子写入(如 ['mcp_servers',0,'headers','Authorization'])同样要按键名还原;
// 漏了这一支会把 ***** 当真值写进 config.yml(前端引导表单不走这条路,但 API 可直达)。
if (p.length === 4 && p[2] === 'headers' && e.value === MCP_HEADER_MASK) {
const one = {};
one[p[3]] = MCP_HEADER_MASK;
restoreHeaderMasks(one, origOf(p[1]));
e.value = one[p[3]];
} }
} }
@@ -186,7 +266,7 @@ function maskEffective(cfg) {
})); }));
c.mcp_servers = (cfg.mcp_servers || []).map(s => { c.mcp_servers = (cfg.mcp_servers || []).map(s => {
const headers = {}; const headers = {};
for (const [k, v] of Object.entries(s.headers || {})) headers[k] = maskHeaderValue(v); for (const [k, v] of Object.entries(s.headers || {})) headers[k] = maskHeaderValue(k, v);
return Object.assign({}, s, { headers }); return Object.assign({}, s, { headers });
}); });
c.models = (cfg.models || []).map(m => Object.assign({}, m, { api_key: maskKey(m.api_key) })); c.models = (cfg.models || []).map(m => Object.assign({}, m, { api_key: maskKey(m.api_key) }));
@@ -215,13 +295,23 @@ router.get('/', wrap((req, res) => {
res.json({ config_path: cfg.config_path || '', exists: text !== null, text: shown, effective: eff, balance_types: balance.types() }); res.json({ config_path: cfg.config_path || '', exists: text !== null, text: shown, effective: eff, balance_types: balance.types() });
})); }));
// 预设模板(前端新增平台 / 添加内置 MCP 用)
router.get('/presets', wrap((req, res) => { res.json(PRESETS); }));
// MCP 运行态连接状态(设置页卡片上的「已连接 / 未连接」):只读快照,
// 来自 mcp.init 的工具发现结果(含重试阶梯的更新)。重启前改 header 不会反映出来
// —— 那些情况由页面顶部的「配置已写入,重启后生效」横幅兜底。
router.get('/mcp-status', wrap((req, res) => {
res.json({ servers: mcp.statuses() });
}));
// 干跑校验(编辑器保存前预检):body { text } // 干跑校验(编辑器保存前预检):body { text }
// 还原脱敏后的 api_key/password 再校验,避免 diff 误报变更。 // 还原脱敏后的 api_key/password 再校验,避免 diff 误报变更。
router.post('/validate', wrap((req, res) => { router.post('/validate', wrap((req, res) => {
const text = req.body && req.body.text; const text = req.body && req.body.text;
if (typeof text !== 'string') return badRequest(res, new Error('body.text 必须是字符串')); if (typeof text !== 'string') return badRequest(res, new Error('body.text 必须是字符串'));
const origText = readConfigText(cfgOf()) || ''; const origText = readConfigText(cfgOf()) || '';
const restored = restoreApiKeys(restorePasswords(restoreMcpHeaders(text, origText), origText), origText); const restored = unmaskText(text, origText);
try { try {
const next = loadConfigFromText(restored, ''); const next = loadConfigFromText(restored, '');
res.json({ ok: true, changed: diffTop(cfgOf(), next) }); res.json({ ok: true, changed: diffTop(cfgOf(), next) });
@@ -237,7 +327,7 @@ router.put('/', wrap((req, res) => {
const text = req.body && req.body.text; const text = req.body && req.body.text;
if (typeof text !== 'string') return badRequest(res, new Error('body.text 必须是字符串')); if (typeof text !== 'string') return badRequest(res, new Error('body.text 必须是字符串'));
const origText = readConfigText(cfg) || ''; const origText = readConfigText(cfg) || '';
const restored = restoreApiKeys(restorePasswords(restoreMcpHeaders(text, origText), origText), origText); const restored = unmaskText(text, origText);
let next; let next;
try { next = loadConfigFromText(restored, cfg.config_path); } catch (e) { return badRequest(res, e); } try { next = loadConfigFromText(restored, cfg.config_path); } catch (e) { return badRequest(res, e); }
writeConfigText(cfg, restored); writeConfigText(cfg, restored);
@@ -261,8 +351,9 @@ function normEdit(e) {
} }
router.patch('/', wrap((req, res) => { router.patch('/', wrap((req, res) => {
const cfg = cfgOf(); const cfg = cfgOf();
const text = readConfigText(cfg); // 文件缺失(或曾被 Docker 误建成空目录)不阻塞:以空文档继续,写入时由 writeConfigText 创建。
if (text === null) return sendErr(res, Object.assign(new Error('配置文件不存在:' + (cfg.config_path || '(未知路径)')), { status_code: 409 })); // 前提是父目录可写(容器里 /app 可写);否则 fs.writeFileSync 会报错并在下面回 500。
const text = readConfigText(cfg) || '';
const body = req.body || {}; const body = req.body || {};
let edits; let edits;
try { try {
+98 -1
View File
@@ -1,5 +1,6 @@
// 文件管理 API:上传 / 列表 / 下载 / 删除 // 文件管理 API:上传 / 列表 / 下载 / 预览 / 删除
const express = require('express'); const express = require('express');
const crypto = require('crypto');
const fs = require('fs'); const fs = require('fs');
const path = require('path'); const path = require('path');
const multer = require('multer'); const multer = require('multer');
@@ -146,6 +147,102 @@ router.get('/:id/files/download', serveDownload);
// 供解析不了 Content-Disposition 的下载器兜底;path 参数与验签逻辑完全一致。 // 供解析不了 Content-Disposition 的下载器兜底;path 参数与验签逻辑完全一致。
router.get('/:id/files/download-name/*', serveDownload); router.get('/:id/files/download-name/*', serveDownload);
// ---------- 图片预览派生图(inline,供 <img> 直连;与下载接口的 attachment/no-store 语义分开) ----------
// 大图慢的三层原因:整包 fetch 完才渲染、每次都要重下、把原始像素丢给浏览器解码。
// 这里按宽度用 sharp 生成 WebP 落盘缓存,前端 <img> 直连即可边下边画;原图只留给“下载”。
const PREVIEW_IMG_RE = /\.(png|jpe?g|gif|webp|svg|bmp|avif|ico)$/i;
const PREVIEW_WIDTHS = new Set([320, 640, 960, 1280, 1600, 2048]);
let sharp = null;
try { sharp = require('sharp'); } catch (_) { /* 未安装 sharp 时整条路由降级为原图直出 */ }
// 预览响应不能带 Content-Disposition: attachment;.imgcache 是点目录,sendFile 需显式放行。
function sendInline(res, abs) {
res.setHeader('Cache-Control', 'private, max-age=0, must-revalidate');
res.sendFile(abs, { cacheControl: false, dotfiles: 'allow', etag: true, lastModified: true });
}
router.get('/:id/files/preview', async function (req, res) {
try {
const rel = String(req.query.path || '');
if (!rel) return res.status(400).json({ error: '缺少 path 参数' });
if (!PREVIEW_IMG_RE.test(rel)) return res.status(400).json({ error: '不是图片' });
const w = PREVIEW_WIDTHS.has(Number(req.query.w)) ? Number(req.query.w) : 1600;
const taskDir = engine.taskDirOf(req.params.id);
const abs = resolveInTask(taskDir, rel);
const st = fs.statSync(abs);
if (!st.isFile()) return res.status(400).json({ error: '不是文件' });
// SVG 是矢量;GIF 可能在预览里要保留动画;没有 sharp 时只能原图直出。
if (/\.svg$/i.test(rel) || /\.gif$/i.test(rel) || !sharp) {
return sendInline(res, abs);
}
// 缓存 key 带 size+mtime:文件被 AI 覆盖后自动失效,不需要额外的清理逻辑。
const key = crypto.createHash('sha1')
.update(rel + '|' + st.size + '|' + st.mtimeMs + '|' + w)
.digest('hex');
const outDir = path.join(path.resolve(taskDir), '.imgcache', 'preview');
const out = path.join(outDir, key + '.webp');
if (!fs.existsSync(out)) {
// sharp 默认只取动图首帧,直接给原图避免“预览不动了”。metadata 只读文件头,不解码像素。
let meta = null;
try { meta = await sharp(abs).metadata(); } catch (_) { /* 交给下面原图兜底 */ }
if (meta && meta.pages && meta.pages > 1) return sendInline(res, abs);
// 小文件不一定像素少(高压缩的大尺寸图仍解码很慢):体积与像素都小才直出原图,
// 避免“压缩后反而更大”,也避免把 24MP 的 200KB 图原样丢给低端机解码。
const px = meta && meta.width && meta.height ? meta.width * meta.height : 0;
if (st.size <= 256 * 1024 && (!px || px <= 2 * 1000 * 1000)) return sendInline(res, abs);
fs.mkdirSync(outDir, { recursive: true });
// 随机临时名 + rename:并发请求不会读到半截文件,也不互相覆盖。
const tmp = out + '.' + crypto.randomBytes(4).toString('hex') + '.tmp.webp';
try {
await sharp(abs, { limitInputPixels: 80 * 1000 * 1000 })
.rotate()
.resize({ width: w, height: w, fit: 'inside', withoutEnlargement: true })
.webp({ quality: 85 })
.toFile(tmp);
fs.renameSync(tmp, out);
} catch (err) {
try { fs.unlinkSync(tmp); } catch (_) {}
return sendInline(res, abs); // 解码失败/格式不支持 → 原图兜底
}
}
sendInline(res, out);
} catch (err) {
res.status(404).json({ error: '文件不存在' });
}
});
// ---------- PDF 预览(inline,供 iframe 直连) ----------
// 现有下载接口是 attachment + no-store:前端只能 fetch 整包再转 blob,查看器要等整包下完才出现。
// 这里单独给预览一条 inline 路由,保留 sendFile 的 Range 支持,让内建查看器自己按需取字节;
// ETag/Last-Modified 让重复打开走 304,不再重下。下载按钮仍走原 /files/download,语义不变。
router.get('/:id/files/inline', function (req, res) {
try {
const rel = String(req.query.path || '');
if (!rel) return res.status(400).json({ error: '缺少 path 参数' });
if (!/\.pdf$/i.test(rel)) return res.status(400).json({ error: '不是 PDF' });
const abs = resolveInTask(engine.taskDirOf(req.params.id), rel);
const st = fs.statSync(abs);
if (!st.isFile()) return res.status(400).json({ error: '不是文件' });
res.setHeader('Content-Type', 'application/pdf');
res.setHeader('Content-Disposition', 'inline');
res.setHeader('Cache-Control', 'private, max-age=0, must-revalidate');
res.sendFile(abs, {
cacheControl: false,
dotfiles: 'allow',
etag: true,
lastModified: true,
acceptRanges: true,
});
} catch (err) {
res.status(404).json({ error: '文件不存在' });
}
});
// ---------- 打包下载(选中项含文件夹时,后端把整个选择打成 zip 流式返回) ---------- // ---------- 打包下载(选中项含文件夹时,后端把整个选择打成 zip 流式返回) ----------
// 纯 Node 实现(STORE 不压缩 + 手拼 zip 结构):任务目录里多是媒体/生成产物, // 纯 Node 实现(STORE 不压缩 + 手拼 zip 结构):任务目录里多是媒体/生成产物,
// 压缩收益低;两遍读文件(先算 CRC 再磁盘流发送),内存占用与总大小无关。 // 压缩收益低;两遍读文件(先算 CRC 再磁盘流发送),内存占用与总大小无关。
+29
View File
@@ -16,17 +16,46 @@ function wrap(fn) {
} }
// 附件上传只写任务目录文件(见 routes/files.js),消息正文原样入库,不再拼接任何通知行。 // 附件上传只写任务目录文件(见 routes/files.js),消息正文原样入库,不再拼接任何通知行。
// delivery:
// live(默认,兼容旧调用方/微信)→ 立即入库;回合在跑时下一轮迭代自动带上
// queue → 回合在跑时进待投递队列(不落库),回合收尾后自动发出;不在跑则等价于 live
// 「干预 / 立即发送」不走这里,而是对已在队列里的条目做升级(POST /pending/:qid)。
router.post('/:id/messages', wrap((req, res) => { router.post('/:id/messages', wrap((req, res) => {
const content = String((req.body && req.body.content) || '').trim(); const content = String((req.body && req.body.content) || '').trim();
if (!content) return res.status(400).json({ error: 'content 不能为空' }); if (!content) return res.status(400).json({ error: 'content 不能为空' });
// deepThink:是否启用模型该「深度思考」参数(thinking_params 合并进上游请求体) // deepThink:是否启用模型该「深度思考」参数(thinking_params 合并进上游请求体)
const deepThink = !!(req.body && req.body.deepThink); const deepThink = !!(req.body && req.body.deepThink);
const delivery = String((req.body && req.body.delivery) || 'live');
if (delivery === 'queue') {
const r = engine.enqueueMessage(req.params.id, content, { deepThink });
log.info('msg', (req.user || '-') + ' ' + req.params.id + ' 用户消息(' +
(r.queued ? '排队 ' + r.pending_id : r.delivered || '?') + '):' +
content.slice(0, 60).replace(/\s+/g, ' '));
return res.json(r);
}
const r = engine.postUserMessage(req.params.id, content, { deepThink }); const r = engine.postUserMessage(req.params.id, content, { deepThink });
log.info('msg', (req.user || '-') + ' ' + req.params.id + ' 用户消息(' + (r && r.delivered || '?') + '):' + log.info('msg', (req.user || '-') + ' ' + req.params.id + ' 用户消息(' + (r && r.delivered || '?') + '):' +
content.slice(0, 60).replace(/\s+/g, ' ')); content.slice(0, 60).replace(/\s+/g, ' '));
res.json(r); res.json(r);
})); }));
// 待投递队列:升级队首(干预 / 立即发送)。
// 干预 = 等当前工具跑完/本条回复落库后插话;立即发送 = 杀进程 + abort 流,本回合收尾后立刻发。
router.post('/:id/pending/:qid', wrap((req, res) => {
const action = String((req.body && req.body.action) || 'interject');
if (action !== 'interject' && action !== 'now') {
return res.status(400).json({ error: 'action 只能是 interject 或 now' });
}
const r = engine.promotePending(req.params.id, req.params.qid, action);
log.info('msg', (req.user || '-') + ' ' + req.params.id + ' 待投递消息 ' + req.params.qid + ' → ' + action);
res.json(r);
}));
// 取消一条待投递消息(条幅上的 ×)。
router.delete('/:id/pending/:qid', wrap((req, res) => {
res.json(engine.cancelPending(req.params.id, req.params.qid));
}));
// 覆盖式编辑:删除该条及其后的历史,再以新内容重开一轮(运行中 409)。 // 覆盖式编辑:删除该条及其后的历史,再以新内容重开一轮(运行中 409)。
router.post('/:id/messages/:mid/edit', wrap((req, res) => { router.post('/:id/messages/:mid/edit', wrap((req, res) => {
+11 -2
View File
@@ -7,6 +7,10 @@
// 3. 只吐"签发时已校验过、且落在该会话任务目录内"的文件,这里再用 resolveInTask 复核一次。 // 3. 只吐"签发时已校验过、且落在该会话任务目录内"的文件,这里再用 resolveInTask 复核一次。
// //
// 挂在 auth.middleware **之前**(server.js),所以登录与否都能访问;未命中一律 404,不吐内部信息。 // 挂在 auth.middleware **之前**(server.js),所以登录与否都能访问;未命中一律 404,不吐内部信息。
//
// 响应头按扩展名分两路:图片(png/jpg/webp/gif/.../svg)走 inline + 明确 image/*,
// 用户或外部服务点开链接就能直接看图;其余一律 attachment,交给下载器
// (安卓封装壳的 DownloadManager 只认 attachment,下载语义不能改)。
'use strict'; 'use strict';
const fs = require('fs'); const fs = require('fs');
@@ -14,7 +18,7 @@ const express = require('express');
const engine = require('../engine'); const engine = require('../engine');
const publicFiles = require('../public-files'); const publicFiles = require('../public-files');
const { resolveInTask } = require('../tools/executor'); const { resolveInTask } = require('../tools/executor');
const { sendDownload } = require('../download-send'); const { sendDownload, sendInlineImage, inlineImageType } = require('../download-send');
const log = require('../log'); const log = require('../log');
const router = express.Router(); const router = express.Router();
@@ -31,7 +35,12 @@ router.get('/:id', function (req, res) {
return res.status(404).type('text/plain').send('not found\n'); return res.status(404).type('text/plain').send('not found\n');
} }
log.info('public-file', entry.sessionId + ' 外部取用:' + entry.rel); // 图片单独走 inline:用户点开 /p/<id> 是要看图,不是要下载文件。安卓封装壳 / WebView
// 对 Content-Disposition: attachment 一律交系统下载器,图片外链因此“只下载、不打开”。
// 其余类型保持原下载语义(PDF/Office 等交给下载器或外部服务自己处理)。
const imgType = inlineImageType(abs);
log.info('public-file', entry.sessionId + ' 外部取用' + (imgType ? '(图片,inline)' : '(附件)') + ':' + entry.rel);
if (imgType) return sendInlineImage(res, abs, imgType);
sendDownload(res, abs); sendDownload(res, abs);
}); });
+2
View File
@@ -208,6 +208,8 @@ router.get('/:id', wrap((req, res) => {
files: listTaskFiles(taskDir), files: listTaskFiles(taskDir),
schedule, schedule,
running: !!(engine.getRun(session.id) || {}).looping, running: !!(engine.getRun(session.id) || {}).looping,
// 待投递队列(刷新/换设备后条幅能原样恢复):只在服务端内存里,重启即空
pending: engine.listPending(session.id),
has_more: hasMore, // 分页模式下:是否还有更早的历史 has_more: hasMore, // 分页模式下:是否还有更早的历史
oldest_id: messages.length ? messages[0].id : null, // 本页最早行 id,作为下一页 before 游标 oldest_id: messages.length ? messages[0].id : null, // 本页最早行 id,作为下一页 before 游标
}); });
+1 -1
View File
@@ -15,7 +15,7 @@ const router = express.Router();
const STARTED_AT = Date.now(); const STARTED_AT = Date.now();
// 版本以本文件字面量为准:容器部署只挂载 app/server,镜像里的 package.json 可能是旧的, // 版本以本文件字面量为准:容器部署只挂载 app/server,镜像里的 package.json 可能是旧的,
// 读它会一直显示发版时的版本号(之前 2.1.0 改完仍显 2.0.0 即此因)。发版时记得同步这里。 // 读它会一直显示发版时的版本号(之前 2.1.0 改完仍显 2.0.0 即此因)。发版时记得同步这里。
const VERSION = '2.4.0'; const VERSION = '2.5.0';
// git 提交号单独返回(提交时 post-commit 钩子自动生成),前端只显示简洁版本号 // git 提交号单独返回(提交时 post-commit 钩子自动生成),前端只显示简洁版本号
const VERSION_COMMIT = versionInfo.commit || ''; const VERSION_COMMIT = versionInfo.commit || '';
+5 -2
View File
@@ -18,7 +18,10 @@ const log = require('./log');
const cfg = loadConfig(process.env.AGENT_CONFIG); const cfg = loadConfig(process.env.AGENT_CONFIG);
log.setLevel(cfg.log_level); // 分级日志开关(log.js;config.yml log_level,重启生效) log.setLevel(cfg.log_level); // 分级日志开关(log.js;config.yml log_level,重启生效)
llm.setPayloadTrim(cfg.agent); // 历史重放的重负载占位裁剪阈值(llm.buildMessages;config agent.trim_*) llm.setPayloadTrim(cfg.agent); // 历史重放的重负载占位裁剪规则(llm.buildMessages;config agent.trim.rules)
// 启动时把生效规则打出来:工具名拼错不会报错(MCP 工具要等发现后才存在),只能靠这行核对。
log.info('startup', '历史重放占位裁剪:' + (((cfg.agent && cfg.agent.trim && cfg.agent.trim.rules) || [])
.map(r => r.tool + '/' + r.side + '(轮≥' + r.rounds + ',回合≥' + r.turns + ')').join(', ') || '关闭'));
const db = initDb(cfg.db_path); const db = initDb(cfg.db_path);
const bus = createBus(); const bus = createBus();
@@ -72,7 +75,7 @@ app.use('/api/sessions', require('./routes/files'));
app.use('/api/sessions', require('./routes/skill-run')); app.use('/api/sessions', require('./routes/skill-run'));
app.use('/api/skills', require('./routes/skills')); app.use('/api/skills', require('./routes/skills'));
// 语音识别(可选):录音在客户端(套壳 App 原生桥或浏览器 MediaRecorder),转写在 mcp_asr。 // 语音识别(可选):录音在客户端(套壳 App 原生桥或浏览器 MediaRecorder),转写在 mcp_asr。
// ASR_URL 为空时接口回 503,前端据此不显示麦克风按钮(见 routes/asr.js)。 // ASR_URL 为空、或 config.yml 里没有启用的 asr 段时接口回 503,前端据此不显示麦克风按钮(见 routes/asr.js)。
app.use('/api/asr', require('./routes/asr')); app.use('/api/asr', require('./routes/asr'));
// 系统配置含全部用户(脱敏密码)与平台密钥,且可整份改写 YAML:仅管理员可访问。 // 系统配置含全部用户(脱敏密码)与平台密钥,且可整份改写 YAML:仅管理员可访问。
app.use('/api/config', auth.requireAdmin, require('./routes/config')); app.use('/api/config', auth.requireAdmin, require('./routes/config'));
+21 -34
View File
@@ -418,9 +418,10 @@ function saveTaskMedia(s, buf, kind, rawName) {
// 预算够 → 全文 + 附件卡片;放不下但 ≥2 → 降级「截断头部 + 全文写会话 // 预算够 → 全文 + 附件卡片;放不下但 ≥2 → 降级「截断头部 + 全文写会话
// .md 转文件卡片」(内容零丢失);<2 → 放弃并告警(网页端完整可见)。 // .md 转文件卡片」(内容零丢失);<2 → 放弃并告警(网页端完整可见)。
// 4. 工具台账(重结果轻过程;微信端不再有独立台账消息):tool_call/tool_result 只在 st.tools // 4. 工具台账(重结果轻过程;微信端不再有独立台账消息):tool_call/tool_result 只在 st.tools
// 记账;失败即时单发一行「工具调用失败: 名称 + 参数」(预算保不住结论储备则留给尾段汇总); // 记账;**工具失败一律不下发**(多数是 AI 参数用错,模型下一轮自己改,推给用户既看不懂
// done 时汇总为一句「本轮工具调用 N 次(name x c, ...),其中 M 次失败」搭结论尾段, // 也帮不上忙;网页端工具卡与库里的 is_error 照旧保留)。done 时只汇总一句中性计数
// 纯工具轮(无结论文本)则汇总与文件卡片合成一条兜底消息(网页端始终全量可见)。 // 「本轮工具调用 N 次(name x c, ...)」搭结论尾段,若本轮有因用户介入而未执行的调用,
// 额外补「N 次因你介入未执行」;纯工具轮(无结论文本)则汇总与文件卡片合成一条兜底消息。
// 5. 通用 ui_card(MCP 工具回包的预览卡片块):按 URL 去重攒进 st.cards,不独立占配额, // 5. 通用 ui_card(MCP 工具回包的预览卡片块):按 URL 去重攒进 st.cards,不独立占配额,
// done 时作「文件」小节搭结论尾段;每条 markdown 链接 + 原始 URL 各一行(防纯文化退化 // done 时作「文件」小节搭结论尾段;每条 markdown 链接 + 原始 URL 各一行(防纯文化退化
// 后点不开);未知 action 或未配公网前缀在微信端静默忽略。 // 后点不开);未知 action 或未配公网前缀在微信端静默忽略。
@@ -439,13 +440,13 @@ function attachBus() {
else if (event === 'done') enqueueDelivery(bid, () => flushHeld(bid)); else if (event === 'done') enqueueDelivery(bid, () => flushHeld(bid));
else { else {
// 工具调用/回执:心跳 + 台账记账(台账不再独立成消息,见策略注释第 4 条); // 工具调用/回执:心跳 + 台账记账(台账不再独立成消息,见策略注释第 4 条);
// 失败经串行队列即时单发一行;ui_card 攒进本回合卡片列表(done 时随尾段投)。 // 失败一律**不下发**(多数是 AI 参数用错,模型下一轮自己改;用户看到
// 「工具调用失败」既看不懂也帮不上忙)。网页端工具卡与库里的 is_error 照旧保留。
// ui_card 攒进本回合卡片列表(done 时随尾段投)。
// reasoning_delta(思考流)不进台账,只走下面的心跳——微信用户能看到「正在输入」在思考。 // reasoning_delta(思考流)不进台账,只走下面的心跳——微信用户能看到「正在输入」在思考。
if (event === 'tool_call') toolDigestPush(bid, data); if (event === 'tool_call') toolDigestPush(bid, data);
else if (event === 'tool_result') { else if (event === 'tool_result') toolDigestMark(bid, data);
toolDigestMark(bid, data); else if (event === 'ui_card') cardCollect(bid, data, sessionId);
if (data && data.is_error) enqueueDelivery(bid, () => flushFailedLine(bid));
} else if (event === 'ui_card') cardCollect(bid, data, sessionId);
maybeTypingPing(bid); // 「正在输入」心跳:长工具/思考回合里微信持续看到 AI 还在干活 maybeTypingPing(bid); // 「正在输入」心跳:长工具/思考回合里微信持续看到 AI 还在干活
} }
} catch (e) { } catch (e) {
@@ -572,32 +573,34 @@ function toolDigestPush(bid, data) {
const name = String((data && data.name) || ''); const name = String((data && data.name) || '');
if (!name) return; if (!name) return;
const hint = argHint(data && data.arguments); const hint = argHint(data && data.arguments);
const ex = st.tools.find(t => t.name === name && t.hint === hint && !t.err); // 同参数同名归并成一条(失败也不再单开一条:失败对用户不可见,没必要为它拆行)
const ex = st.tools.find(t => t.name === name && t.hint === hint && !t.skipped);
if (ex) { ex.count++; if (data.id) ex.ids.push(data.id); return; } if (ex) { ex.count++; if (data.id) ex.ids.push(data.id); return; }
st.tools.push({ name, hint, count: 1, err: false, ids: data && data.id ? [data.id] : [] }); st.tools.push({ name, hint, count: 1, skipped: false, ids: data && data.id ? [data.id] : [] });
} catch (_) { /* 摘要锦上添花,绝不动摇投递 */ } } catch (_) { /* 摘要锦上添花,绝不动摇投递 */ }
} }
// 只记「未执行」(用户介入/终止导致没跑的调用)。工具自身失败不进台账展示:
// 多数是 AI 参数写错,模型下一轮会自己改;它要不要告诉用户,由模型自己的回复决定。
function toolDigestMark(bid, data) { function toolDigestMark(bid, data) {
try { try {
if (!data || !data.is_error) return; if (!data || !data.skipped) return;
const st = getTurn(bid); const st = getTurn(bid);
const t = st.tools.find(x => x.ids.indexOf(data.tool_call_id) >= 0); const t = st.tools.find(x => x.ids.indexOf(data.tool_call_id) >= 0);
if (t) t.err = true; if (t) t.skipped = true;
} catch (_) { /* 同上 */ } } catch (_) { /* 同上 */ }
} }
// 降级路径的渲染(peek 不清空):台账单发预算不足/失败时搭结论尾段,结论投递成功后调用方清空。 // 降级路径的渲染(peek 不清空):台账单发预算不足/失败时搭结论尾段,结论投递成功后调用方清空。
// 若 wxbot 开 WXBOT_STRIP_MARKDOWN 回退纯文化,stripMarkdown 会把围栏/标题降为普通行,信息不丢。 // 若 wxbot 开 WXBOT_STRIP_MARKDOWN 回退纯文化,stripMarkdown 会把围栏/标题降为普通行,信息不丢。
// done 尾段的工具汇总(peek 不清空):一句计数 + 未即时送达的失败行;结论投递成功后由调用方清空。 // done 尾段的工具汇总(peek 不清空):一句中性计数 + 「因你介入未执行」的条数。
// 刻意不列失败:工具报错是 AI 自己该处理的事,往里推只会让用户困惑(详见 toolDigestMark 注释)。
function peekToolDigest(st) { function peekToolDigest(st) {
const ts = st && st.tools; const ts = st && st.tools;
if (!ts || !ts.length) return ''; if (!ts || !ts.length) return '';
const total = ts.reduce((n, t) => n + (t.count || 1), 0); const total = ts.reduce((n, t) => n + (t.count || 1), 0);
const breakdown = ts.map(t => t.name + (t.count > 1 ? ' x' + t.count : '')).join(', '); const breakdown = ts.map(t => t.name + (t.count > 1 ? ' x' + t.count : '')).join(', ');
const errN = ts.filter(t => t.err).length;
let s = '---\n\n### 工具\n\n本轮工具调用 ' + total + ' 次(' + breakdown + ')'; let s = '---\n\n### 工具\n\n本轮工具调用 ' + total + ' 次(' + breakdown + ')';
if (errN) s += ',其中 ' + errN + ' 次失败'; const skipN = ts.filter(t => t.skipped).length;
const unnotified = ts.filter(t => t.err && !t.warned); if (skipN) s += ',' + skipN + ' 次因你介入未执行';
if (unnotified.length) s += '\n' + unnotified.map(t => '- 失败: ' + t.name + (t.hint ? ' ' + t.hint : '')).join('\n');
return s; return s;
}// 正文与 digest 一起分段:正文照旧 splitText,digest 原子追尾——markdown 代码围栏不能被 }// 正文与 digest 一起分段:正文照旧 splitText,digest 原子追尾——markdown 代码围栏不能被
// 1800 字分段拦腰斩断;尾段能与正文同段就同段(不多占配额),放不下才单独成段。 // 1800 字分段拦腰斩断;尾段能与正文同段就同段(不多占配额),放不下才单独成段。
@@ -610,22 +613,6 @@ function digestSegs(body, digest) {
else segs.push(digest); else segs.push(digest);
return segs; return segs;
} }
// 独立台账消息:一批 ≤8 行整屏渲染,无折叠(零头等下一班车,done 时补发)。
// 失败即时单发:一次 tool_result 失败事件触发一次;预算保不住结论储备就留给尾段汇总兜底。
async function flushFailedLine(bid) {
const st = getTurn(bid);
const t = st.tools.find(x => x.err && !x.warned);
if (!t) return;
const b = bindReady(bid);
if (!b) return;
if (st.sent + 1 > REPLY_QUOTA - CONCLUSION_RESERVE) return;
try {
await wxbotApi('POST', '/api/deliver', { id: b.id, to: b.wx_to_user, text: '工具调用失败: ' + t.name + (t.hint ? '\n' + t.hint : '') }, 15000);
st.sent++;
t.warned = true;
} catch (_) { /* 投失败不紧:done 时尾段汇总仍会列出 */ }
}
// ---------- 通用 UI 卡片(bus ui_card 事件,见 wechat 策略注释第 5 条)---------- // ---------- 通用 UI 卡片(bus ui_card 事件,见 wechat 策略注释第 5 条)----------
// open_preview → 绝对预览 URL:与前端 pvOfficeUrl/网关寻址同款,前缀真相在 core(public_link.base_url)。 // open_preview → 绝对预览 URL:与前端 pvOfficeUrl/网关寻址同款,前缀真相在 core(public_link.base_url)。
function uiCardUrl(data, sessionId) { function uiCardUrl(data, sessionId) {
@@ -671,7 +658,7 @@ async function flushTail(bid) {
// 留给结论尾段搭便车;直投失败归还队首(串行队列调度,与正文消息天然排队,无并发互踩)。 // 留给结论尾段搭便车;直投失败归还队首(串行队列调度,与正文消息天然排队,无并发互踩)。
// 过程消息:直发窗口内且投完后仍给结论留足储备才投;否则计入 omitted,并进结论的注记行。 // 过程消息:直发窗口内且投完后仍给结论留足储备才投;否则计入 omitted,并进结论的注记行。
// 正文不携带工具信息——工具信息自有出口(失败即时行/done 尾段汇总),不重复。 // 正文不携带工具信息——工具信息自有出口(done 尾段汇总),不重复;工具失败不下发。
async function deliverProcess(bid, m, sessionId) { async function deliverProcess(bid, m, sessionId) {
const b = bindReady(bid); const b = bindReady(bid);
if (!b || stale(b, m)) return; if (!b || stale(b, m)) return;
+12 -20
View File
@@ -4,8 +4,7 @@ services:
container_name: agent-core container_name: agent-core
restart: unless-stopped restart: unless-stopped
ports: ports:
# 无 nginx-proxy:直接把容器 8090 映射到宿主机端口,用 http://<服务器IP>:<AGENT_PORT> 访问。 # 直接把容器 8090 映射到宿主机端口,用 http://<服务器IP>:<AGENT_PORT> 访问。
# 改端口:在仓库顶层 .env 里设 AGENT_PORT(默认 8090)。
- "${AGENT_PORT:-8090}:8090" - "${AGENT_PORT:-8090}:8090"
volumes: volumes:
- ./tasks:/workspace/tasks # 持久化:任务目录 - ./tasks:/workspace/tasks # 持久化:任务目录
@@ -20,12 +19,15 @@ services:
- EXECUTOR_URL=http://agent-executor:9000 - EXECUTOR_URL=http://agent-executor:9000
# 调用鉴权 token:两侧同一值。从 .env 读取(已 gitignore),不再硬编码进仓库; # 调用鉴权 token:两侧同一值。从 .env 读取(已 gitignore),不再硬编码进仓库;
# 未设置则 compose 直接报错,避免静默无鉴权。生成:openssl rand -hex 32 # 未设置则 compose 直接报错,避免静默无鉴权。生成:openssl rand -hex 32
- EXECUTOR_TOKEN=${EXECUTOR_TOKEN:?EXECUTOR_TOKEN not set - see .env.example} - EXECUTOR_TOKEN=${EXECUTOR_TOKEN:?EXECUTOR_TOKEN not set - run scripts/init.sh}
# 微信接入 # 微信接入
- WXBOT_URL=http://agent-wxbot:8093 - WXBOT_URL=http://agent-wxbot:8093
- WXBOT_TOKEN=${WXBOT_TOKEN:?WXBOT_TOKEN not set - run scripts/init.sh} - WXBOT_TOKEN=${WXBOT_TOKEN:?WXBOT_TOKEN not set - run scripts/init.sh}
# 语音识别(可选):mcp_asr 的内网地址。置空 = 不启用,前端不显示麦克风按钮。 # 语音识别(可选):core 拼 /transcribe 的基地址,固定指向栈内 mcp_asr。
- ASR_URL=http://mcp_asr:3000 - ASR_URL=http://mcp_asr:3000
# 对外地址:public_link 的默认值(scripts/init.sh 探测公网 IP 后写进 .env)。
# 设置页里填过 public_link.base_url 时以设置页为准。
- PUBLIC_BASE_URL=${PUBLIC_BASE_URL:-}
networks: networks:
- agent-mcp-net - agent-mcp-net
@@ -81,8 +83,8 @@ services:
- ./skills:/workspace/skills:ro # 技能目录:所有任务/会话共享同一份技能 - ./skills:/workspace/skills:ro # 技能目录:所有任务/会话共享同一份技能
environment: environment:
- PORT=9000 - PORT=9000
# 与 agent-core 侧同一值,从 .env 读取(见 .env.example): # 与 agent-core 侧同一值,从根 .env 读取(scripts/init.sh 生成):
- EXECUTOR_TOKEN=${EXECUTOR_TOKEN:?EXECUTOR_TOKEN not set - see .env.example} - EXECUTOR_TOKEN=${EXECUTOR_TOKEN:?EXECUTOR_TOKEN not set - run scripts/init.sh}
# 日志等级:debug|info|warn|error|none(默认 info); # 日志等级:debug|info|warn|error|none(默认 info);
# debug 会把与 core 的完整交互打印出来(请求、/exec 请求体、每条 SSE 帧、JSON 响应): # debug 会把与 core 的完整交互打印出来(请求、/exec 请求体、每条 SSE 帧、JSON 响应):
- EXECUTOR_LOG_LEVEL=info - EXECUTOR_LOG_LEVEL=info
@@ -170,9 +172,6 @@ services:
timeout: 5s timeout: 5s
retries: 5 retries: 5
start_period: 5s start_period: 5s
# 调试用(默认关):
# ports:
# - "${WEB_SEARCH_PORT:-8081}:3000"
networks: networks:
- agent-mcp-net - agent-mcp-net
@@ -186,9 +185,6 @@ services:
timeout: 5s timeout: 5s
retries: 5 retries: 5
start_period: 5s start_period: 5s
# 调试用(默认关):
# ports:
# - "${IMAGE_TASK_PORT:-8082}:3000"
networks: networks:
- agent-mcp-net - agent-mcp-net
@@ -202,9 +198,6 @@ services:
timeout: 5s timeout: 5s
retries: 5 retries: 5
start_period: 5s start_period: 5s
# 调试用(默认关;这里映的是 MCP 端口,会暴露 /mcp,仅本机短时调试用):
# ports:
# - "${VIDEO_TASK_PORT:-8083}:3000"
networks: networks:
- agent-mcp-net - agent-mcp-net
@@ -212,7 +205,9 @@ services:
# 同进程两个入口(见 mcp/asr/src/server.js 头注释): # 同进程两个入口(见 mcp/asr/src/server.js 头注释):
# POST /transcribe ← agent-core 的 /api/asr 转发(输入框,低延迟、不经过模型) # POST /transcribe ← agent-core 的 /api/asr 转发(输入框,低延迟、不经过模型)
# POST /mcp ← 模型的 MCP 工具 transcribe_audio({url})(转写任务目录里的音频) # POST /mcp ← 模型的 MCP 工具 transcribe_audio({url})(转写任务目录里的音频)
# 转写走上游 OpenAI 兼容的 /audio/transcriptions(默认智谱 glm-asr,换平台改 ASR_API_* 即可)。 # 本容器不存任何平台密钥:上游走 OpenAI 兼容的 /audio/transcriptions,key / base_url / model
# 全部由调用方随请求 header 带入(core 从 config.yml 的 mcp_servers 里 asr.headers 取)。
# 换 ASR 平台 → 改 config.yml 后重启 core,本服务不用动、也不用重建镜像。
mcp_asr: mcp_asr:
build: ./mcp/asr build: ./mcp/asr
container_name: mcp_asr container_name: mcp_asr
@@ -224,16 +219,13 @@ services:
retries: 5 retries: 5
start_period: 5s start_period: 5s
environment: environment:
- ASR_API_KEY=${ASR_API_KEY:-}
- ASR_API_BASE=${ASR_API_BASE:-https://open.bigmodel.cn/api/paas/v4}
- ASR_MODEL=${ASR_MODEL:-glm-asr}
- ASR_LOG_LEVEL=${ASR_LOG_LEVEL:-info} - ASR_LOG_LEVEL=${ASR_LOG_LEVEL:-info}
- TZ=Asia/Shanghai - TZ=Asia/Shanghai
networks: networks:
- agent-mcp-net - agent-mcp-net
networks: networks:
# 全部服务共用一个网络;由本仓库创建(固定名字,避免被加上 compose 项目名前缀)。 # 全部服务共用一个网络;由本仓库创建
# - core 与 executor 靠它按容器名访问 MCP 服务(如 http://mcp_web_search:3000/) # - core 与 executor 靠它按容器名访问 MCP 服务(如 http://mcp_web_search:3000/)
# - 外部服务取参考图走的是 core 对外的 GET /p/<id>(见 public_link):AI 调内置工具 # - 外部服务取参考图走的是 core 对外的 GET /p/<id>(见 public_link):AI 调内置工具
# mint_public_link 在 core 进程内现签短链,不需要 executor 反查 core 的额外端口 # mint_public_link 在 core 进程内现签短链,不需要 executor 反查 core 的额外端口
+7
View File
@@ -66,6 +66,13 @@ system prompt 不重复 schema 已表达的内容。
tools 数组每轮请求完整重发。新工具进来时,先问"能不能装进已有工具",再问"要不要新建"。 tools 数组每轮请求完整重发。新工具进来时,先问"能不能装进已有工具",再问"要不要新建"。
回执/参数里可能很大的内容,若**可再生**(文件在盘上可重读、页面可重抓)或只是当时快照,
可在 `agent.trim.rules` 登记历史重放占位裁剪:同时满足「其后 ≥rounds 条 assistant 行」与
「其后 ≥turns 条真人消息」后换成单行占位(`app/server/llm.js` 的 `setPayloadTrim`;
`side: args` 点名参数、`side: result` 裁整段回执)。`turns: 1` = 回合内不裁、跨回合才裁;
长回合里会被反复回看的内容(如 `read_file` 的分段)应配它,否则模型会把同一段重读一遍。
一次性输出(`terminal`、外部服务扣额度的生成结果等)不要登记——裁掉后模型无法恢复。
### 九、回执形态 ### 九、回执形态
- **内容型**工具(`read_file` 的文本、`fetch` 的正文、`db` 的查询结果)回执就是内容本身,不要套 JSON 信封。 - **内容型**工具(`read_file` 的文本、`fetch` 的正文、`db` 的查询结果)回执就是内容本身,不要套 JSON 信封。
+190 -195
View File
@@ -1,36 +1,50 @@
# 语音输入:客户端录音契约 # 语音输入:客户端录音契约
链路是「按住说话 → 客户端录音 → `POST /api/asr/transcribe` → 转写结果**自动发送**」。 链路是「按住说话 → 端上持续送 PCM → 页面按停顿切段并逐段转写 → 松手后一次性写入输入框并**自动发送**」。
服务端只收音频字节,不关心是谁录的。`public/js/voice.js` 按能力自己选录音方式:
| 页面环境 | 录音方式 | 说明 | `public/js/voice.js` 按能力自己选录音方式:
|---|---|---|
| Android 套壳 App(WebView) | **原生录音 + JS 桥** | WebView 没有 Web Speech API;http 页面也允许 `getUserMedia` 的替代路径 |
| 浏览器 / PWA(HTTPS) | `MediaRecorder` | 标准 `getUserMedia`,不用改壳 |
| 纯浏览器(`http://<IP>`) | 不可用 | 非安全上下文,浏览器拒绝开麦 |
**发送键的四种状态**(`sessions.js` 的 `updateSendBtn` 决定): | 页面环境 | 录音方式 | 实时断句 | 说明 |
|---|---|---|---|
| Android 套壳 App(WebView) | **原生 `AudioRecord` + JS 桥流式推 PCM** | ✅ | WebView 没有 Web Speech API;`http://` 页面也能用 |
| 浏览器 / PWA(HTTPS) | **`AudioContext` + `ScriptProcessor` 采 PCM** | ✅ | 降采样到 16k 后与套壳走**完全同一套** VAD/切段/上传 |
| 纯浏览器(`http://<IP>`) | 不可用 | — | 非安全上下文,浏览器拒绝开麦 |
| `data-state` | 什么时候 | 点击行为 | **为什么必须要流式**:录音只在松手后才上传的话,识别要等整段录完 + 整段识别,长语音尤其慢。
|---|---|---| 流式之后,说话过程中的每个停顿都会立刻切段上传,**松手时通常只剩最后一段要等**。
| `stop` | 生成中且输入框为空 | 停止当前回合(优先级最高,不被语音入口顶掉) |
| `voice` | 空闲、无文字无附件、且语音可用 | 进入语音模式 |
| `keyboard` | 已在语音模式 | 回键盘模式,聚焦输入框(移动端弹键盘) |
| `send` | 其余情况 | 发送 |
「语音可用」= ①有录音能力(原生桥,或安全上下文下的 `MediaRecorder`)②`GET /api/asr/status` 两条录音路径只在「PCM 从哪来」上不同,进到 `pushChunk(pcm, rate)` 之后一模一样:
返回 `enabled !== false`。所以**套壳 App 里即使页面是 `http://`,只要桥注入成功,麦克风入口照样出现**; 电平、静音门限、断句、逐段上传、最后合并发送,代码只有一份。
纯浏览器 `http://<IP>` 不会出现(非安全上下文,浏览器禁止开麦)。
语音模式下输入框被 `#voice-hold` 取代(只有居中文字,无按钮外观):按住后整块输入区被
**全宽遮罩**盖住(`#voice-overlay`,向左右各扩到屏幕边缘),遮罩里是「实时电平声波 + 提示文案」。
手指上滑进入文案区域 → 取消态(声波与文案变红,文案改为「松开取消」),滑回下方恢复;
松手时取消态则**直接丢弃**(不弹 toast——它会盖住声波,取消本身已经有变色/文案反馈),否则转写并直接发送。
松手后遮罩保持到识别结束,文案换成「正在识别…」。发送键变成键盘按钮。
--- ---
## 一、桥的契约 ## 一、交互与页面行为(壳只需要知道这些)
1. 用户按住 `#voice-hold` → 页面开始录音(套壳调 `startVoice()`,浏览器自己 `getUserMedia`),同时把整块输入区换成全宽遮罩(实时声波 + 提示文案)。
2. 壳推 / 浏览器采的 PCM 进来后,页面自己判停顿(连续静音 ≥0.5s)→ 立即 POST 该段 → 结果攒在内存里。
一直不停顿地长说时,累计约 6s 会在**能量最低的分片边界**先切一刀(软切)→ 同样先发出去,
否则整段只能憋到松手才上传(这是最慢的路径)。
3. 手指上滑进入文案区 = 取消态;松手时处于取消态则**整轮丢弃**(已上传段的结果也丢掉),输入框保持原样。
4. 松手 → 页面把尾巴里**有声音的部分**发出去(纯静音的尾巴不发,否则只会换来一次「没有可识别人声」)
→ 等所有段回来 → **一次性**写进输入框 → 自动发送。
5. 识别结果**不会边识别边显示**:遮罩/发送键本来就盖住了输入框,渐进文本用户看不到,
所以统一在最后落到输入框里,用户拿到的是完整一句话。
### 浏览器 / PWA(HTTPS)的实现要点
- 采集:`getUserMedia` → `createMediaStreamSource` → `createScriptProcessor(1024, 1, 1)`。
不用 `AudioWorklet` 是因为要多加载一个模块文件、且 `addModule` 是异步的(按下才加载会把开头几个字吞掉);
`ScriptProcessor` 虽已标废弃,但 Chrome/Safari/Firefox 都还在,这点开销可忽略。
- 降采样:浏览器采样率通常是 44.1k/48k,`downsampleTo16k()` 按「一个输出周期内取均值」降到 16k,
小数相位跨分片累计(整数倍抽取会越录越快/越慢)。**不能**把 44.1k 直接喂进 VAD ——
0.5s 停顿、6s 软切与 25s 段长都是按 16k 估算的。
- iOS Safari:`AudioContext` 必须在手势里创建/resume;`await getUserMedia` 之后已脱离手势,
所以按下(`pointerdown`)时就先把 ctx 建好,拿到麦克风后复用。
- 浏览器只在安全上下文开麦:`http://<IP>` 下麦克风按钮不会出现,只有 HTTPS 域名(或套壳壳内)可用。
---
## 二、桥的契约
### 1. 注入时机 ### 1. 注入时机
@@ -49,69 +63,66 @@ webView.loadUrl(startUrl);
```js ```js
window.AgentNative = { window.AgentNative = {
startVoice(), // 开始录音;失败/拒绝通过 onNativeVoiceError 回报 startVoice(), // 开始录音(可能先弹权限);失败通过 onNativeVoiceError 回报
stopVoice(), // 结束录音;结果通过 onNativeVoiceResult 回传 stopVoice(), // 结束录音;**没有返回值**,页面自己等已发出的分段的识别结果
cancelVoice() // 放弃本次录音(无回调;页面自己已经把状态复位了) cancelVoice() // 放弃本次录音(无回调;页面自己已经把状态复位了)
}; };
``` ```
**线程模型**:这三个方法都跑在 WebView 的 JavaBridge 子线程上,**不是主线程**。
`MediaRecorder` 的所有调用必须收敛到主线程:方法入口先 `mainHandler.post(...)`,
读临时文件 + Base64 才放回子线程。
### 3. 回调(页面定义,壳调用) ### 3. 回调(页面定义,壳调用)
```js ```js
window.onNativeVoiceResult(base64, mime) // mime 例:'audio/mp4' window.onNativeVoiceChunk(base64Pcm, sampleRate) // 必需:流式 PCM 分片
window.onNativeVoiceError(code, message) // 见下方错误码表 window.onNativeVoiceState('recording') // 建议:真正开始录时调一次
window.onNativeVoiceState('recording') // 建议实现:真正开始录时调一次 window.onNativeVoiceError(code, message) // 出错/被打断时调
window.onNativeVoiceAmp(amp) // 建议实现:原始幅度 0~32767,驱动遮罩里的声波
``` ```
- `onNativeVoiceAmp(amp)`:壳只上报 `MediaRecorder.getMaxAmplitude()` 的**原始值** #### `onNativeVoiceChunk(base64Pcm, sampleRate)`
(0~32767,主线程每 100ms 一次),**不要做任何换算**。dB 归一化、静音门限、快攻慢放平滑
全部在页面侧——浏览器(RMS)和壳(峰值)两条路的规则只存在一份。
旧名 `onNativeVoiceLevel` 仍作为别名接受(同样按原始幅度解释)。
不实现也能用:声波静默停在基线上(不空转、不假动)。
JS 侧还要自己做快攻慢放平滑,壳不需要平滑。
- `onNativeVoiceState('recording')`:**按住说话的时长判定依赖它**。页面用这个回调重置
「60 秒上限」和「太短丢弃」的起点,避免首次授权弹窗的时间被算进录音。不实现也不会崩:
页面按点击时刻计时,代价是首次授权那一次会被当成「太短」丢弃(用户再按一次即可)。
- 页面收到 `onNativeVoiceResult` 后会直接发送消息(不经过输入框、不可编辑)。
- 所有回调都必须在**主线程**调 `webView.evaluateJavascript`。
- 字符串一律用 `JSONObject.quote(...)` 拼,不要手写 `'` 转义——异常 message 里可能有
`\`、换行、U+2028,会把整段脚本打断。
### 4. 状态机与错误码 - 内容:**裸 PCM**,`16bit 小端 / 单声道 / 16kHz`(小端是 `AudioRecord` 的原始字节序,直接转 Base64 即可)。
- 节奏:约 **100ms 一片**(1600 采样 = 3200 字节,Base64 后约 4.3KB)。50~200ms 都可接受。
- 壳**不做任何数学**:不判静音、不切段、不算音量。dB 归一化、静音门限、停顿判定、切段
全部在页面侧(`voice.js`),规则只存在一份。
- 声波也是页面用这片 PCM 的峰值算的——**不再需要** `onNativeVoiceAmp` / `getMaxAmplitude`。
- 页面已经复位(用户松手/取消)后再来的分片会被忽略,壳不用刻意等待。
壳侧状态:`IDLE → (WAITING_PERMISSION) → RECORDING → ENCODING → IDLE`。 #### `onNativeVoiceState('recording')`
`startVoice` 只在 `IDLE` 生效,`stopVoice` 只在 `RECORDING` 生效(其余静默忽略)。
**按住时长判定依赖它**:页面用这个回调重置「180 秒上限」与「太短丢弃」的起点,
避免首次授权弹窗的时间被算进录音。不实现也不会崩,但首次授权那一次可能被当成「太短」丢掉。
#### `onNativeVoiceError(code, message)`
| code | 触发时机 | 页面表现 | | code | 触发时机 | 页面表现 |
|---|---|---| |---|---|---|
| `no_permission` | 用户拒绝 / 取消授权弹窗 | toast「需要麦克风权限」 | | `no_permission` | 用户拒绝 / 取消授权弹窗 | toast「录音失败:…」 |
| `start_failed` | `prepare()` / `start()` 抛异常(含回退 MIC 后仍失败) | toast | | `start_failed` | `AudioRecord` 初始化/启动失败(含 16k 不支持) | toast |
| `too_short` | `stop()` 抛异常(录音 < ~1s) | toast「说话时间太短,请按住再说」,**不上传** | | `read_failed` | 采集线程读失败 | toast |
| `read_failed` | 读临时文件失败 | toast | | `forbidden` | 非白名单 URL / 应用不在前台 | toast |
| `cancelled` | 生命周期打断(切后台 / 换页) | **静默复位,不弹提示** | | `cancelled` | 生命周期打断(切后台 / 换页) | **静默复位,不弹提示** |
| 其他未知 code | — | toast 里显示 `message`,没有就显示 code | | 其他未知 code | — | toast 里显示 `message`,没有就显示 code |
**取消语义**:页面在 `stopVoice()` 之后会一直等结果(直到点击后 90 秒的硬超时), **取消语义**:页面在 `stopVoice()` 之后只等自己发出的分段请求(不再等壳回音频),
所以壳在生命周期里取消录音时**必须**回调 `onNativeVoiceError('cancelled','')`, 所以壳在生命周期里中断录音时**仍建议**回调 `onNativeVoiceError('cancelled','')`,
否则按钮会卡在「录音中」。`cancelVoice()` 是页面主动发起的,壳不需要回报。 让页面立刻收遮罩,不必干等。`cancelVoice()` 是页面主动发起的,壳不需要回报。
### 5. 体积与时序 ### 4. 体积与时序
- 16kHz / 32kbps / 单声道 AAC:60 秒 ≈ **240KB**,Base64 后 ≈ **320KB**。 - 每秒 32KB 原始 PCM(16k × 2 字节),Base64 后约 43KB/s;一片 100ms 约 4.3KB。
- `evaluateJavascript` 走 Binder,单次约 1MB 上限;320KB 安全,但**不要再延长单次时长**。 `evaluateJavascript` 走 Binder,单次约 1MB 上限,4.3KB 远低于上限。
真要 2 分钟以上,改成按段回传或本地 HTTP 回传。 - 一次 60 秒的听写 = 约 600 次桥调用、2.6MB 字符串。Android WebView 完全吃得住,
- 松开后页面最多等 3 秒拿音频(等不到就复位,覆盖「壳还在等权限」的情况); 但**不要**把分片缩到 20ms 以下(调用次数会翻 5 倍,收益为零)。
拿到后上传+识别,正常 1~2 秒。 - 页面侧开销:每片扫一遍峰值(1600 个 short),可忽略。
- 按住时间 < 500ms 视为误触:页面直接丢弃,不上传;壳自己的 `too_short` 是第二道保险。
### 5. 壳侧状态机
`IDLE → (WAITING_PERMISSION) → RECORDING → IDLE`
`startVoice` 只在 `IDLE` 生效,`stopVoice` / `cancelVoice` 在非 `RECORDING` 时静默忽略。
--- ---
## 二、Java 参考骨架(纯 Java / minSdk 21) ## 三、Java 参考骨架(纯 Java / minSdk 21)
只演示契约要求的部分;`UrlPolicy`、埋点、通知等按各自工程接。 只演示契约要求的部分;`UrlPolicy`、埋点、通知等按各自工程接。
@@ -121,32 +132,21 @@ window.onNativeVoiceAmp(amp) // 建议实现:原始幅度 0~3276
public final class VoiceBridge { public final class VoiceBridge {
private static final int REQ_MIC = 1001; private static final int REQ_MIC = 1001;
private static final long MAX_MS = 60_000; private static final int RATE = 16000; // 契约固定:16k / 单声道 / 16bit
private static final int CHUNK_MS = 100; // 每 100ms 推一片
private static final long MAX_MS = 180_000; // 页面也会自己停,这里是兜底
private enum State { IDLE, WAITING_PERMISSION, RECORDING, ENCODING } private enum State { IDLE, WAITING_PERMISSION, RECORDING }
private final Activity activity; private final Activity activity;
private final WebView webView; private final WebView webView;
private final Handler main = new Handler(Looper.getMainLooper()); private final Handler main = new Handler(Looper.getMainLooper());
private final Runnable autoStop = this::stopOnMain; private final Runnable autoStop = this::stopOnMain;
// 实时电平:每 100ms 读一次 getMaxAmplitude() 交给页面画声波
private static final long LEVEL_INTERVAL_MS = 100;
private final Runnable levelTick = this::tickLevel;
private void tickLevel() {
MediaRecorder r = recorder;
if (state != State.RECORDING || r == null) return;
int amp = 0;
try { amp = r.getMaxAmplitude(); } catch (Exception ignored) { }
// 原始幅度直接给页面:dB 归一化/门限/平滑全在 JS,壳不做任何数学
js("window.onNativeVoiceAmp && window.onNativeVoiceAmp(" + amp + ")");
main.postDelayed(levelTick, LEVEL_INTERVAL_MS);
}
private State state = State.IDLE; private State state = State.IDLE;
private MediaRecorder recorder; private AudioRecord record;
private File file; private Thread worker;
private volatile boolean running;
public VoiceBridge(Activity activity, WebView webView) { public VoiceBridge(Activity activity, WebView webView) {
this.activity = activity; this.activity = activity;
@@ -159,15 +159,13 @@ public final class VoiceBridge {
@JavascriptInterface public void cancelVoice() { main.post(() -> cancelOnMain(true)); } @JavascriptInterface public void cancelVoice() { main.post(() -> cancelOnMain(true)); }
// ---- 生命周期:由 Activity / WebViewClient 调用 ---- // ---- 生命周期:由 Activity / WebViewClient 调用 ----
// 注意:只取消真正在录/在编码的状态。授权弹窗期间某些 ROM 会走 onPause, // 只在真正录音时取消。授权弹窗期间某些 ROM 会走 onPause,
// 那里如果一并取消,首次授权的两段式流程就断了。 // 那里一并取消的话,首次授权的两段式流程就断了。
public void onPause() { public void onPause() {
main.post(() -> { main.post(() -> { if (state == State.RECORDING) cancelOnMain(true); });
if (state == State.RECORDING || state == State.ENCODING) cancelOnMain(true);
});
} }
public void onDestroy() { main.post(() -> cancelOnMain(false)); } public void onDestroy() { main.post(() -> cancelOnMain(false)); }
public void onPageChanged() { main.post(() -> cancelOnMain(true)); } public void onPageChanged() { main.post(() -> cancelOnMain(true)); }
public void onRequestPermissionsResult(int requestCode, int[] grantResults) { public void onRequestPermissionsResult(int requestCode, int[] grantResults) {
if (requestCode != REQ_MIC) return; if (requestCode != REQ_MIC) return;
@@ -177,7 +175,7 @@ public final class VoiceBridge {
boolean ok = grantResults != null && grantResults.length > 0 boolean ok = grantResults != null && grantResults.length > 0
&& grantResults[0] == PackageManager.PERMISSION_GRANTED; && grantResults[0] == PackageManager.PERMISSION_GRANTED;
if (!ok) { fail("no_permission", "需要麦克风权限"); return; } if (!ok) { fail("no_permission", "需要麦克风权限"); return; }
beginRecording(); // 授权后直接开录(体验优先,不要求用户再点一次) beginRecording(); // 授权后直接开录,不让用户再点一次
}); });
} }
@@ -198,105 +196,96 @@ public final class VoiceBridge {
beginRecording(); beginRecording();
} }
@SuppressLint("NewApi")
private void beginRecording() { private void beginRecording() {
int minBuf = AudioRecord.getMinBufferSize(
RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
if (minBuf <= 0) { fail("start_failed", "设备不支持 16kHz 录音"); return; }
// VOICE_RECOGNITION 关掉 AGC/降噪,对 ASR 更友好;个别机型不支持则回退 MIC // VOICE_RECOGNITION 关掉 AGC/降噪,对 ASR 更友好;个别机型不支持则回退 MIC
final AudioRecord r = createRecord(minBuf);
if (r == null) { fail("start_failed", "无法开始录音"); return; }
record = r;
running = true;
state = State.RECORDING;
main.postDelayed(autoStop, MAX_MS);
final int samplesPerChunk = RATE * CHUNK_MS / 1000; // 1600
worker = new Thread(() -> captureLoop(r, samplesPerChunk), "voice-capture");
worker.start();
// 让页面的 180s 从“真的开始录”算(授权弹窗的时间不算)
js("window.onNativeVoiceState && window.onNativeVoiceState('recording')");
}
private AudioRecord createRecord(int minBuf) {
int[] sources = {MediaRecorder.AudioSource.VOICE_RECOGNITION, int[] sources = {MediaRecorder.AudioSource.VOICE_RECOGNITION,
MediaRecorder.AudioSource.MIC}; MediaRecorder.AudioSource.MIC};
for (int source : sources) { for (int source : sources) {
File f = null;
MediaRecorder r = null;
try { try {
f = File.createTempFile("voice", ".m4a", activity.getCacheDir()); AudioRecord t = new AudioRecord(source, RATE, AudioFormat.CHANNEL_IN_MONO,
r = Build.VERSION.SDK_INT >= 31 AudioFormat.ENCODING_PCM_16BIT, Math.max(minBuf * 2, 8192));
? new MediaRecorder(activity) // 无参构造在 API 31 起废弃 if (t.getState() == AudioRecord.STATE_INITIALIZED) return t;
: new MediaRecorder(); t.release();
r.setAudioSource(source); } catch (Exception ignored) { /* 换下一个 source */ }
r.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4); }
r.setAudioEncoder(MediaRecorder.AudioEncoder.AAC); return null;
r.setAudioSamplingRate(16000); }
r.setAudioEncodingBitRate(32000);
r.setAudioChannels(1);
r.setOutputFile(f.getAbsolutePath());
r.prepare();
r.start();
recorder = r; /** 采集线程:阻塞 read → 小端字节 → Base64 → 推给页面。不判静音、不切段。 */
file = f; private void captureLoop(AudioRecord r, int samplesPerChunk) {
state = State.RECORDING; short[] pcm = new short[samplesPerChunk];
main.postDelayed(autoStop, MAX_MS); byte[] bytes = new byte[samplesPerChunk * 2];
main.postDelayed(levelTick, LEVEL_INTERVAL_MS); try {
// 让页面的 60s 从“真的开始录”算(授权弹窗的时间不算) r.startRecording();
js("window.onNativeVoiceState && window.onNativeVoiceState('recording')"); while (running) {
// 不要再额外弹原生 Toast:页面遮罩已经给了全部反馈,弹窗会压住声波 int n = r.read(pcm, 0, pcm.length);
return; if (n <= 0) continue;
} catch (Exception e) { for (int i = 0; i < n; i++) {
// 局部变量释放:失败时 recorder 字段还没赋值,releaseQuietly() 管不到它 bytes[i * 2] = (byte) (pcm[i] & 0xff);
if (r != null) { bytes[i * 2 + 1] = (byte) ((pcm[i] >> 8) & 0xff);
try { r.stop(); } catch (Exception ignored) { }
try { r.release(); } catch (Exception ignored) { }
} }
delete(f); String b64 = Base64.encodeToString(bytes, 0, n * 2, Base64.NO_WRAP);
// 字符串一律 JSONObject.quote,避免任何转义问题(Base64 本身安全,这里是统一规矩)
js("window.onNativeVoiceChunk(" + JSONObject.quote(b64) + "," + RATE + ")");
} }
} catch (Exception e) {
if (running) fail("read_failed", "录音中断:" + e.getMessage());
} finally {
try { r.stop(); } catch (Exception ignored) { }
try { r.release(); } catch (Exception ignored) { }
} }
state = State.IDLE;
fail("start_failed", "无法开始录音");
} }
private void stopOnMain() { private void stopOnMain() {
if (state != State.RECORDING) return; if (state != State.RECORDING) return;
main.removeCallbacks(autoStop); main.removeCallbacks(autoStop);
main.removeCallbacks(levelTick); // 停止上报电平 stopCapture();
state = State.ENCODING; state = State.IDLE;
// 注意:这里不再回传音频,识别分段已经在录音过程中发完了
MediaRecorder r = recorder;
File f = file;
recorder = null;
file = null;
boolean stopped = true;
try { r.stop(); } catch (RuntimeException e) { stopped = false; } // 太短会抛
try { r.release(); } catch (Exception ignored) { }
if (!stopped) {
delete(f);
state = State.IDLE;
fail("too_short", "没有录到声音");
return;
}
new Thread(() -> {
try {
byte[] bytes = readAll(f);
String b64 = Base64.encodeToString(bytes, Base64.NO_WRAP);
delete(f);
main.post(() -> {
state = State.IDLE;
js("window.onNativeVoiceResult(" + JSONObject.quote(b64) + ",'audio/mp4')");
});
} catch (Exception e) {
delete(f);
main.post(() -> { state = State.IDLE; fail("read_failed", "读取录音失败"); });
}
}, "voice-encode").start();
} }
/** notify=true:页面在等结果,必须回 cancelled 让它复位;onDestroy 时页面已走,不必回。 */ /** notify=true:页面在等收尾,回 cancelled 让它立刻收遮罩;onDestroy 时页面已走,不必回。 */
private void cancelOnMain(boolean notify) { private void cancelOnMain(boolean notify) {
main.removeCallbacks(autoStop); main.removeCallbacks(autoStop);
main.removeCallbacks(levelTick);
boolean wasActive = state != State.IDLE; boolean wasActive = state != State.IDLE;
releaseQuietly(); stopCapture();
delete(file);
file = null;
state = State.IDLE; state = State.IDLE;
if (notify && wasActive) js("window.onNativeVoiceError('cancelled','')"); if (notify && wasActive) js("window.onNativeVoiceError('cancelled','')");
} }
private void releaseQuietly() { private void stopCapture() {
if (recorder == null) return; running = false;
try { recorder.stop(); } catch (Exception ignored) { } AudioRecord r = record;
try { recorder.release(); } catch (Exception ignored) { } record = null;
recorder = null; if (r != null) {
// 打断阻塞中的 read();stop/release 由采集线程的 finally 做,
// 避免跨线程操作同一个 AudioRecord
try { r.stop(); } catch (Exception ignored) { }
}
Thread w = worker;
worker = null;
if (w != null) w.interrupt();
} }
private void fail(String code, String message) { private void fail(String code, String message) {
@@ -307,20 +296,6 @@ public final class VoiceBridge {
private void js(String script) { private void js(String script) {
webView.post(() -> webView.evaluateJavascript(script, null)); webView.post(() -> webView.evaluateJavascript(script, null));
} }
private static byte[] readAll(File f) throws Exception {
try (FileInputStream in = new FileInputStream(f);
ByteArrayOutputStream out = new ByteArrayOutputStream()) {
byte[] buf = new byte[8192];
int n;
while ((n = in.read(buf)) > 0) out.write(buf, 0, n);
return out.toByteArray();
}
}
private static void delete(File f) {
if (f != null) f.delete();
}
} }
``` ```
@@ -334,59 +309,79 @@ webView.addJavascriptInterface(new VoiceBridge(this, webView), "AgentNative");
super.onRequestPermissionsResult(code, p, r); super.onRequestPermissionsResult(code, p, r);
bridge.onRequestPermissionsResult(code, r); bridge.onRequestPermissionsResult(code, r);
} }
@Override protected void onPause() { bridge.onPause(); super.onPause(); } @Override protected void onPause() { bridge.onPause(); super.onPause(); }
@Override protected void onDestroy() { bridge.onDestroy(); super.onDestroy(); } @Override protected void onDestroy() { bridge.onDestroy(); super.onDestroy(); }
// WebViewClient.onPageStarted:URL 变了就 bridge.onPageChanged() // WebViewClient.onPageStarted:URL 变了就 bridge.onPageChanged()
``` ```
**和上一版(MediaRecorder)的差别,别照抄旧代码**:
- 不再有 `MediaRecorder`、临时文件、`onNativeVoiceResult`、`getMaxAmplitude`、60 秒自动停止。
- `stopVoice()` 之后没有任何回传动作,页面会自己等已发出的分段请求。
- 必须在**采集线程**里 `read()`,不能读在主线程;`AudioRecord` 的 stop/release 只由该线程的
`finally` 执行(主线程只调 `stop()` 打断阻塞)。
- 个别设备 16k 不支持时:`getMinBufferSize` 会返回负数。此时要么回滚到 44.1k 并在壳里做
2 点平均降采样到 16k(多几十行),要么直接 `start_failed`。**不要**改推 44.1k 给页面——
页面只按 16k 估算时长与切段。
--- ---
## 三、壳侧必须同步的清单 ## 四、壳侧必须同步的清单
| 项 | 内容 | | 项 | 内容 |
|---|---| |---|---|
| `AndroidManifest.xml` | `<uses-permission android:name="android.permission.RECORD_AUDIO" />` | | `AndroidManifest.xml` | `<uses-permission android:name="android.permission.RECORD_AUDIO" />` |
| `proguard-rules.pro` | 保留桥:`-keepclassmembers class * { @android.webkit.JavascriptInterface <methods>; }`,并删掉「本项目未使用 addJavascriptInterface」的注释 | | `proguard-rules.pro` | 保留桥:`-keepclassmembers class * { @android.webkit.JavascriptInterface <methods>; }`,并删掉「本项目未使用 addJavascriptInterface」的注释 |
| README 安全表 | 从「不使用 JS 桥」改为「仅暴露语音桥:三个无参方法,无文件/存储读取能力」 | | README 安全表 | 「不使用 JS 桥」→「仅暴露语音桥:三个无参方法,无文件/存储读取能力」 |
| README 权限行 | 「只有 INTERNET」→「INTERNET + RECORD_AUDIO」 | | README 权限行 | 「只有 INTERNET」→「INTERNET + RECORD_AUDIO」 |
| 桥的防护 | `UrlPolicy.isAllowed(webView.getUrl())` + `activity.hasWindowFocus()` + 单实例状态机;建议再加一个原生 Toast 提示录音已开始(外部 CDN 脚本与页面同源,能调桥,但用户至少看得见) | | 桥的防护 | `UrlPolicy.isAllowed(webView.getUrl())` + `activity.hasWindowFocus()` + 单实例状态机 |
| 页面导航 | `onPageStarted` 且 URL 变化时取消,避免 base64 打到新页面的回调上 | | 页面导航 | `onPageStarted` 且 URL 变化时取消;分片打到新页面会污染新一轮的缓冲 |
| 录音上限 | 壳侧兜底 180s(页面也会在 180s 时主动 `stopVoice()`),不要做成 60s |
> 触摸时间戳门槛(最近 N 秒内有触摸才允许录音)能进一步防静默录音,但会让无障碍操作不可用, > 触摸时间戳门槛(最近 N 秒内有触摸才允许录音)能进一步防静默录音,但会让无障碍操作不可用,
> 不建议默认开。 > 不建议默认开。
--- ---
## 四、iOS(以后若有 WKWebView 壳) ## 五、iOS(以后若有 WKWebView 壳)
契约相同,换注入方式: 契约相同,只是数据源换成 `AVAudioEngine` 的 tap(`installTapOnBus` 直接把
`AVAudioPCMBuffer` 转成 16bit 小端 PCM,每 ~100ms 一次):
```swift ```swift
// 注入:WKUserScript(source: "window.AgentNative = {...}", injectionTime: .atDocumentStart, ...) // 注入:WKUserScript(source: "window.AgentNative = {...}", injectionTime: .atDocumentStart, ...)
// 录音:AVAudioRecorder(16kHz / 单声道 / m4a) // 推流:webView.evaluateJavaScript("window.onNativeVoiceChunk('\(b64)',16000)")
// 回传:webView.evaluateJavaScript("window.onNativeVoiceResult('\(b64)','audio/mp4')") // 结束:stopVoice() 停 tap 即可,不需要回传文件
``` ```
`Info.plist` 需要 `NSMicrophoneUsageDescription`。 `Info.plist` 需要 `NSMicrophoneUsageDescription`。
## 五、服务端接口 ---
## 六、服务端接口
```http ```http
POST /api/asr/transcribe POST /api/asr/transcribe
Content-Type: audio/mp4 # 或 audio/webm / audio/wav / application/octet-stream Content-Type: audio/wav # 两条路都是 wav:页面自己加的 44 字节头(16k/单声道/16bit)
Cookie: <登录态> # 与页面同一份 HttpOnly cookie Cookie: <登录态> # 与页面同一份 HttpOnly cookie
<音频二进制> <音频二进制>
``` ```
```json ```json
{ "text": "打开今天的日报", "ms": 842, "model": "glm-asr" } { "text": "打开今天的日报", "ms": 842, "model": "whisper-1" }
``` ```
- 上限 20MB,超时 120s;识别失败返回 `{"error": "..."}`(前端直接 toast 出来)。 - 上限 20MB,超时 120s;识别失败返回 `{"error": "..."}`(前端直接 toast 出来)。
- `GET /api/asr/status` → `{"enabled": true}`:`ASR_URL` 没接线时为 `false`。 - 一次「按住说话」会变成 **多次** 请求(每个停顿一次,套壳与浏览器都是)。页面**并行**发送,
结果按提交时的下标落位,拼接仍按说话顺序(并行返回是乱序的)。
并发上限由 `voice.js` 的 `ASR_MAX_CONCURRENCY` 控制(默认 3),超出的排到后面等前面落定。
- 单段失败不影响其他段(页面侧吞掉单段错误,继续等下一段);全部失败才提示。
- 服务端只做**超长兜底**:一次请求超过 25s 才切,且切点尽量落在停顿处(端上已经按停顿切好了,
这里多数请求根本不会触发切分)。参数见 `mcp/asr/README.md`。
- `GET /api/asr/status` → `{"enabled": true}`;未接线时 `{"enabled": false, "reason": "..."}`。
## 六、为什么不用浏览器的 Web Speech API ## 七、为什么不用浏览器的 Web Speech API
- Android WebView 没有实现 `SpeechRecognition`;iOS WKWebView 同样不可用(只有 Safari 有)。 - Android WebView 没有实现 `SpeechRecognition`;iOS WKWebView 同样不可用(只有 Safari 有)。
- 桌面 Chrome 的识别走 Google 服务,国内基本报 `network`。 - 桌面 Chrome 的识别走 Google 服务,国内基本报 `network`。
+27 -16
View File
@@ -4,14 +4,13 @@
| 目录 | 容器名 | 作用 | 容器内端口 | MCP 端点 | | 目录 | 容器名 | 作用 | 容器内端口 | MCP 端点 |
|---|---|---|---|---| |---|---|---|---|---|
| `web_search/` | `mcp_web_search` | 免费网页搜索(Parallel / Exa,无需 key) | `3000` | `POST /` | | `web_search/` | `mcp_web_search` | 网页搜索(默认免费 Parallel / Exa,可换成自建 `/search` 上游) | `3000` | `POST /` |
| `image_task/` | `mcp_image_task` | 图片生成 / 编辑(智谱原生或任意 OpenAI 兼容 `/images/generations`,单工具 op=create/get) | `3000` | `POST /mcp` | | `image_task/` | `mcp_image_task` | 图片生成 / 编辑(文生图走 `/images/generations`,图生图走 `/images/edits`,单工具 op=create/get) | `3000` | `POST /mcp` |
| `video_task/` | `mcp_video_task` | 智谱 CogVideo 视频生成(异步,单工具 op=create/get) | `3000` | `POST /mcp` | | `video_task/` | `mcp_video_task` | 智谱 CogVideo 视频生成(异步,单工具 op=create/get) | `3000` | `POST /mcp` |
| `asr/` | `mcp_asr` | 语音转文字(上游 OpenAI 兼容 `/audio/transcriptions`),**额外带一个给输入框用的 `POST /transcribe`** | `3000` | `POST /mcp` | | `asr/` | `mcp_asr` | 语音转文字(上游 OpenAI 兼容 `/audio/transcriptions`),**额外带一个给输入框用的 `POST /transcribe`** | `3000` | `POST /mcp` |
**这些服务一个宿主机端口都不占**——它们只挂在 `agent-mcp-net` 上,由 `agent-core` / `agent-executor` **这些服务一个宿主机端口都不占**——它们只挂在 `agent-mcp-net` 上,由 `agent-core` / `agent-executor`
按容器名访问。所以整台服务器对外只需要开 agent-core 那一个端口(`AGENT_PORT`,默认 8090)。 按容器名访问。所以整台服务器对外只需要开 agent-core 那一个端口(`AGENT_PORT`,默认 8090)。
(要从宿主机 curl 调试时,把根 `docker-compose.yml` 里对应服务注释掉的 `ports` 两行打开。)
## 部署 ## 部署
@@ -28,6 +27,10 @@ docker compose up -d --build
mcp_servers: mcp_servers:
- name: web_search - name: web_search
url: "http://mcp_web_search:3000/" url: "http://mcp_web_search:3000/"
# 可选:换成自己的搜索接口(不配 = 内置免费后端 Parallel / Exa)
# headers:
# Authorization: Bearer <key>
# X-Web-Search-Base-Url: "https://<host>/v1"
- name: image_task - name: image_task
url: "http://mcp_image_task:3000/mcp" url: "http://mcp_image_task:3000/mcp"
- name: video_task - name: video_task
@@ -35,6 +38,10 @@ mcp_servers:
# 可选:语音转写(低频,建议 skill 模式,不占每轮工具表) # 可选:语音转写(低频,建议 skill 模式,不占每轮工具表)
- name: asr - name: asr
url: "http://mcp_asr:3000/mcp" url: "http://mcp_asr:3000/mcp"
headers:
Authorization: Bearer <key> # 免鉴权的自建服务可省
X-ASR-Base-Url: "https://<host>/v1"
X-ASR-Model: "whisper-1"
mode: skill mode: skill
``` ```
@@ -44,21 +51,25 @@ mcp_servers:
`image_task` / `video_task` 的 token **不由服务端保存**——每个请求从 `Authorization` header 读取 `image_task` / `video_task` 的 token **不由服务端保存**——每个请求从 `Authorization` header 读取
(agent 侧配在 `config.yml` 的 `mcp_servers[].headers`)。`video_task` 用智谱 token; (agent 侧配在 `config.yml` 的 `mcp_servers[].headers`)。`video_task` 用智谱 token;
`image_task` 用对应上游(智谱或 OpenAI 兼容网关)的 token,上游地址与模型分别由 `image_task` 走任意 OpenAI 兼容的 images 上游:文生图 `/images/generations`、图生图 `/images/edits`,
`X-Image-Task-Base-Url` / `X-Image-Task-Model` 指定。所以这两个服务不用配任何密钥。 上游地址与模型分别由 `X-Image-Task-Base-Url` / `X-Image-Task-Model` 指定(两者都必填)。
所以这两个服务不用配任何密钥。
`asr` 是例外:输入框那条路(`agent-core` → `POST /transcribe`)不经过 MCP 调用,拿不到 header, `web_search` 同理:默认走内置免费后端(Parallel → Exa,无需 key);想换成自己的搜索接口,
所以它自己的上游密钥由容器 env `ASR_API_KEY` 提供(写在根 `.env`,已 gitignore,不挂给其他容器)。 就在这段 headers 里写 `X-Web-Search-Base-Url`(容器拼 `/search`)与可选的 `Authorization`。
一旦配了地址就以它为准——**失败直接报错,不会静默退回免费后端**(否则 key 过期 / 地址写错
只会表现为「结果质量突然变差」)。
`asr` 同理:上游的 key / base_url / model 全部由调用方随请求 header 带入
(`Authorization` / `X-ASR-Base-Url` / `X-ASR-Model`,agent 侧配在 `config.yml` 的
`mcp_servers[name=asr].headers`)。输入框那条路(`agent-core` → `POST /transcribe`)不经过 MCP 调用,
但 core 同样会从那段 `headers` 取值转发过去,所以两边只有一处配置。容器自己不存任何平台密钥,
也不预设任何厂商——任何 OpenAI 兼容的 `/audio/transcriptions` 都能用。
### 调试端口 ### 调试端口
写在仓库顶层 `.env` 里即可(不写就用默认值;开了端口记得调试完注释回去): 本栈默认不给 MCP 服务映射宿主机端口(它们只在 `agent-mcp-net` 内网可达)。要从宿主机直连,
自行在 `docker-compose.yml` 给对应服务加 `ports` 即可。
| 变量 | 默认 | 说明 |
|---|---|---|
| `WEB_SEARCH_PORT` | `8081` | 只在临时打开 web_search 调试端口时用 |
| `IMAGE_TASK_PORT` | `8082` | 只在临时打开 image_task 调试端口时用 |
| `VIDEO_TASK_PORT` | `8083` | 只在临时打开 video_task 调试端口(MCP 口,仅本机短时调试)时用 |
## 图片是怎么到智谱手上的(只有 video_task 关心) ## 图片是怎么到智谱手上的(只有 video_task 关心)
@@ -83,10 +94,10 @@ AI 把拿到的 URL 当 image_url 交给 video_task:3000/mcp
| 服务 | 公网暴露 | 说明 | | 服务 | 公网暴露 | 说明 |
|---|---|---| |---|---|---|
| `mcp_web_search` | 无 | 服务端无鉴权,**永远不要映射出去**(会被白嫖搜索额度);agent 走内网访问 | | `mcp_web_search` | 无 | 服务端无鉴权,**永远不要映射出去**(会被白嫖搜索额度;配了自定义上游时还会把你的 key 白送出去);agent 走内网访问 |
| `mcp_image_task` | 无 | token 由调用方自带,暴露后可被拿去消耗你的上游图片额度 | | `mcp_image_task` | 无 | token 由调用方自带,暴露后可被拿去消耗你的上游图片额度 |
| `mcp_video_task` | 无 | 它需要的公开临时 URL 由 agent 侧集成的工具提供,自己不占端口 | | `mcp_video_task` | 无 | 它需要的公开临时 URL 由 agent 侧集成的工具提供,自己不占端口 |
| `mcp_asr` | 无 | `/mcp` 与 `/transcribe` 都无鉴权,只能由 core 经内网调用;它持有上游 ASR 密钥 | | `mcp_asr` | 无 | `/mcp` 与 `/transcribe` 都无鉴权,只能由 core 经内网调用;它不存密钥(上游参数随请求带入) |
## 单独调试 ## 单独调试
+52 -18
View File
@@ -6,7 +6,7 @@
|---|---|---| |---|---|---|
| `POST /transcribe` | `agent-core` 的 `/api/asr/transcribe`(H5 输入框) | 普通 HTTP,音频二进制进、`{text}` 出。**不经过模型、不消耗 token、1~3s** | | `POST /transcribe` | `agent-core` 的 `/api/asr/transcribe`(H5 输入框) | 普通 HTTP,音频二进制进、`{text}` 出。**不经过模型、不消耗 token、1~3s** |
| `POST /mcp` | 模型(MCP 工具 `transcribe_audio`) | 转写任务目录里已有的音频,参数是公网 URL(与 `video_task` 的 `image_url` 同构) | | `POST /mcp` | 模型(MCP 工具 `transcribe_audio`) | 转写任务目录里已有的音频,参数是公网 URL(与 `video_task` 的 `image_url` 同构) |
| `GET /health` | compose healthcheck | `{ok, model, configured}` | | `GET /health` | compose healthcheck | `{ok, service}`(无状态服务,不反映上游配置) |
端口 `3000` **只在 `agent-mcp-net` 内网**,不映射宿主机——本服务自身没有鉴权,暴露即被白嫖。 端口 `3000` **只在 `agent-mcp-net` 内网**,不映射宿主机——本服务自身没有鉴权,暴露即被白嫖。
对外唯一入口仍是 `agent-core`(`/api/asr` 走登录态鉴权)。 对外唯一入口仍是 `agent-core`(`/api/asr` 走登录态鉴权)。
@@ -19,26 +19,43 @@
## 部署 ## 部署
```bash ```bash
# 1) 配上游密钥(写进仓库根 .env,已 gitignore) # 1) 配上游:写进仓库根 config.yml 的 mcp_servers(与 image_task 同构),容器不存任何密钥
# ASR_API_KEY=你的智谱 token # - name: asr
# url: "http://mcp_asr:3000/mcp"
# headers:
# Authorization: Bearer <key> # 免鉴权的自建服务可省
# X-ASR-Base-Url: "https://<host>/v1"
# X-ASR-Model: "whisper-1"
# mode: skill
# 2) 起服务 # 2) 起服务
docker compose up -d --build mcp_asr docker compose up -d --build mcp_asr
docker compose restart agent-core # core 要在启动时读到 ASR_URL docker compose restart agent-core # core 要在启动时读到 config.yml 与 ASR_URL
curl -s http://127.0.0.1:8090/api/asr/status # {"enabled":true,...} curl -s http://127.0.0.1:8090/api/asr/status # {"enabled":true,...}
``` ```
`agent-core` 的环境变量 `ASR_URL`(compose 里固定为 `http://mcp_asr:3000`)是开关:置空即 `agent-core` 的环境变量 `ASR_URL`(compose 里固定为 `http://mcp_asr:3000`)是部署接线;
不启用,`/api/asr/*` 回 503,前端不显示麦克风按钮。 真正的开关是 config.yml 里那段 `asr`:置为 `mode: disable` 或删掉 = 不启用,`/api/asr/*` 回 503,
前端不显示麦克风按钮。
> 从旧版升级:以前上游 key 写在根 `.env` 的 `ASR_API_KEY`(并默认复用 `BIGMODEL_KEY`),
> 现在容器不再读它。把原来那三个值搬到 `config.yml` 的 `asr.headers` 即可,`.env` 里那行可以删掉;
> 不搬的话语音入口会自动关闭(`GET /api/asr/status` 会返回具体 `reason`)。
## 上游 ## 上游
任何 OpenAI 兼容的 `/audio/transcriptions` 都能用;默认智谱: 任何 OpenAI 兼容的 `/audio/transcriptions` 都能用。**本服务不保存、也不预设任何平台**:
key / base_url / model 全部由调用方随每个请求用 header 带入(与 `image_task` 同构)。
| 变量 | 默认 | | Header | 必填 | 说明 |
|---|---| |---|---|---|
| `ASR_API_BASE` | `https://open.bigmodel.cn/api/paas/v4` | | `X-ASR-Base-Url` | 是 | 上游地址,如 `https://<host>/v1`(服务自己拼 `/audio/transcriptions`) |
| `ASR_API_KEY` | 空(空则 `/transcribe` 回 503) | | `X-ASR-Model` | 是 | 模型名,如 `glm-asr` / `whisper-1` |
| `ASR_MODEL` | `glm-asr` | | `Authorization` | 否 | `Bearer <key>`;写成裸 key 也会自动补 `Bearer `;免鉴权的自建服务可省 |
`agent-core` 从 `config.yml` 的 `mcp_servers[name=asr].headers` 取这三个头,两条入口(`/transcribe`
与 `/mcp`)共用同一处配置——所以换平台只改 YAML + 重启 core,不碰 `.env`、不重建镜像。
缺 `X-ASR-Base-Url` / `X-ASR-Model` 时回 503,并在错误文案里指出缺哪个。
常驻内存约 35~40MB,CPU 基本为 0。没有本地模型可选:2 vCPU / 2GB 的机器跑不动能用的 常驻内存约 35~40MB,CPU 基本为 0。没有本地模型可选:2 vCPU / 2GB 的机器跑不动能用的
whisper(固定 30 秒窗口,`small` 单次要 15~30 秒),需要私有化就把这个容器放到另一台机器, whisper(固定 30 秒窗口,`small` 单次要 15~30 秒),需要私有化就把这个容器放到另一台机器,
@@ -50,13 +67,20 @@ whisper(固定 30 秒窗口,`small` 单次要 15~30 秒),需要私有化
# 任意格式(webm / mp4 / mp3 / wav / ogg / aac / flac),服务端用 ffmpeg 归一化 # 任意格式(webm / mp4 / mp3 / wav / ogg / aac / flac),服务端用 ffmpeg 归一化
curl -s -X POST http://mcp_asr:3000/transcribe \ curl -s -X POST http://mcp_asr:3000/transcribe \
-H 'Content-Type: audio/webm' \ -H 'Content-Type: audio/webm' \
-H 'X-ASR-Base-Url: https://<host>/v1' \
-H 'X-ASR-Model: whisper-1' \
-H 'Authorization: Bearer <key>' \
--data-binary @voice.webm --data-binary @voice.webm
# → {"text":"打开今天的日报","ms":842,"model":"glm-asr"} # → {"text":"打开今天的日报","ms":842,"model":"whisper-1"}
``` ```
- 上限 20MB;超过 `ASR_MAX_CHUNK_SEC`(默认 25s)的音频自动切片后逐段识别再拼接 - 上限 20MB。**只有超过 `ASR_MAX_CHUNK_SEC`(默认 25s)才切**:套壳是流式的,一次请求本就是一�句话,
(多数云端 ASR 单次只吃 ~30s)。 直接一次送出去(不跑静音检测);长音频(浏览器整段上传 / `/mcp`)才需要断开。
- 同时最多 `ASR_MAX_CONCURRENT`(默认 2)个转写,超了回 429。 - 切点尽量落在停顿上:只在距上限最后 `ASR_CUT_LOOKBACK_SEC`(默认 6s)的窗口里找静音区间中点,
挑不到才硬切——硬切会把字劈成两半,而两段之间没有上下文,接缝处的字就丢了。
段数因此最少(≈ 时长/25),不存在“切太碎”的退化。单段不短于 `ASR_MIN_SEG_SEC`(默认 1s)。
- 单段失败不连坐:其余段照常返回(长录音里偶发静音段很常见);**全部**段失败才报错。
- 同时最多 `ASR_MAX_CONCURRENT`(默认 2)个转写请求,超了回 429。
## MCP 工具 ## MCP 工具
@@ -65,6 +89,10 @@ curl -s -X POST http://mcp_asr:3000/transcribe \
mcp_servers: mcp_servers:
- name: asr - name: asr
url: "http://mcp_asr:3000/mcp" url: "http://mcp_asr:3000/mcp"
headers: # 上游参数随请求带入,同「上游」一节
X-ASR-Base-Url: "https://<host>/v1"
X-ASR-Model: "whisper-1"
Authorization: Bearer <key>
mode: skill # 低频能力,别每轮都发 schema mode: skill # 低频能力,别每轮都发 schema
``` ```
@@ -75,11 +103,17 @@ mcp_servers:
| 变量 | 默认 | 说明 | | 变量 | 默认 | 说明 |
|---|---|---| |---|---|---|
| `ASR_API_BASE` / `ASR_API_KEY` / `ASR_MODEL` | 见上 | 上游语音识别 |
| `ASR_MAX_BYTES` | 20971520 | 单次上传上限 | | `ASR_MAX_BYTES` | 20971520 | 单次上传上限 |
| `ASR_MAX_CHUNK_SEC` | `25` | 超长音频切片长度,`0` = 不切 | | `ASR_PAUSE_SEC` | `0.5` | 多长的静音算一个停顿(`silencedetect` 的 `d`,仅在需要切时用) |
| `ASR_SILENCE_DB` | `-35` | 判定“没人说话”的音量门限(正常语音约 -20dB) |
| `ASR_MIN_SEG_SEC` | `1` | 单段最短;避免切出识别不了的碎片 |
| `ASR_MAX_CHUNK_SEC` | `25` | 单段最长;≤ 它就不切(一次请求) |
| `ASR_CUT_LOOKBACK_SEC` | `6` | 切点搜索窗:只在距上限最后这几秒里找停顿 |
| `ASR_MAX_CONCURRENT` | `2` | 并发转写数 | | `ASR_MAX_CONCURRENT` | `2` | 并发转写数 |
| `ASR_LOG_LEVEL` | `info` | debug / info / warn / error / none | | `ASR_LOG_LEVEL` | `info` | debug / info / warn / error / none |
| `FFMPEG_BIN` | `ffmpeg` | 归一化 / 静音检测工具路径 |
上游参数(key / base_url / model)**不是环境变量**,见上面「上游」一节。
## 客户端怎么录音 ## 客户端怎么录音
+182 -50
View File
@@ -14,9 +14,14 @@
// tools/call 三种请求,手写这几十行 JSON-RPC 就够;本机内存只有 2G,省掉 SDK 与 express // tools/call 三种请求,手写这几十行 JSON-RPC 就够;本机内存只有 2G,省掉 SDK 与 express
// 的常驻开销(本服务空载约 35MB)。 // 的常驻开销(本服务空载约 35MB)。
// //
// 转写走上游的 OpenAI 兼容 /audio/transcriptions(默认智谱 glm-asr,换平台改 env 即可)。 // 转写走上游的 OpenAI 兼容 /audio/transcriptions(任何平台都行)。上游三要素——key、base_url、
// model——一律由调用方随请求 header 带入,本容器不存任何平台密钥、也不认任何平台默认值。
// 音频一律先经 ffmpeg 归一化成 16kHz 单声道 wav:WebView 录出来是 webm/opus,iOS 是 mp4/aac, // 音频一律先经 ffmpeg 归一化成 16kHz 单声道 wav:WebView 录出来是 webm/opus,iOS 是 mp4/aac,
// 上游只认 wav/mp3,归一化后两端都自由。 // 上游只认 wav/mp3,归一化后两端都自由。
//
// 超长兜底:只有超过单次上限(默认 25s)才断开重发,切点尽量落在停顿上。
// 套壳是流式的(客户端已按停顿切好,一次请求就是一句话),所以这里多数请求不会被切;
// 真正用得上的是浏览器整段上传与 /mcp 转写已有长音频。
import http from 'node:http'; import http from 'node:http';
import { spawn } from 'node:child_process'; import { spawn } from 'node:child_process';
@@ -25,18 +30,38 @@ import fs from 'node:fs/promises';
import os from 'node:os'; import os from 'node:os';
import path from 'node:path'; import path from 'node:path';
// ── 配置(全部走 env,不读 config.yml:本容器按仓库惯例只拿 env) ────────────── // ── 配置 ──────────────────────────────────────────────────────────────────
const PORT = Number(process.env.PORT || 3000); const PORT = Number(process.env.PORT || 3000);
// 上游:任何 OpenAI 兼容的 /audio/transcriptions(智谱 glm-asr、OpenAI whisper-1 等) // 上游参数逐请求带入(与 mcp/image_task 同构:密钥由调用方提供,服务端不保存):
const API_BASE = String(process.env.ASR_API_BASE || 'https://open.bigmodel.cn/api/paas/v4').trim().replace(/\/+$/, ''); // Authorization: Bearer <key> ← 免鉴权的自建服务可省
const API_KEY = String(process.env.ASR_API_KEY || '').trim(); // X-ASR-Base-Url: https://.../v1
const API_MODEL = String(process.env.ASR_MODEL || 'glm-asr').trim(); // X-ASR-Model: whisper-1
// 为什么不留 env 兜底:两条来源会让「到底生效的是哪个 key」变成靠猜,而且密钥越少地方存越好
//(容器 env 用 docker inspect 就能看,config.yml 至少还受登录态保护)。
const HDR_AUTH = 'authorization';
const HDR_BASE = 'x-asr-base-url';
const HDR_MODEL = 'x-asr-model';
// 单次上传上限。60s 的 AAC 约 240KB、16k wav 约 1.9MB,20MB 是给长音频留的余量。 // 单次上传上限。60s 的 AAC 约 240KB、16k wav 约 1.9MB,20MB 是给长音频留的余量。
const MAX_BYTES = Math.max(1024 * 1024, Number(process.env.ASR_MAX_BYTES || 20 * 1024 * 1024)); const MAX_BYTES = Math.max(1024 * 1024, Number(process.env.ASR_MAX_BYTES || 20 * 1024 * 1024));
// 云端多数 ASR 单次只吃 ~30s:超长音频按这个秒数切片后逐段识别再拼接(0 = 不切)。 // ── 超长兜底切分 ──────────────────────────────────────────────────────
// 谁需要它:套壳是流式的(客户端已经按停顿切好,每次请求就是一句话),
// 所以这里绝大多数请求都 ≤ 25s 直接一次送出去;真正用得上的只有
// 「浏览器整段上传」和「/mcp 转写已有长音频」——它们可能一次给几分钟。
// 切点尽量落在停顿上:硬切会把字劈成两半,而两段之间又没有上下文,接缝处的字就丢了。
// 0.5s 是句子边界:换气/想词的停顿通常 0.3~0.8s,而 0.5s 以下是词内间隔。
const PAUSE_SEC = Math.max(0.1, Number(process.env.ASR_PAUSE_SEC || 0.5));
// 判定为「没人说话」的音量门限:正常语音约 -20dB,安静房间底噪 -60dB 以下。
const SILENCE_DB = Number(process.env.ASR_SILENCE_DB || -35);
// 单段最短:避免最后切出一个没法识别的碎片(并进前一段)。
const MIN_SEG_SEC = Math.max(0, Number(process.env.ASR_MIN_SEG_SEC || 1));
// 单段最长(≈ 上游单次能吃的大致上限):超过它就必须断开。
// 16k/16bit 单声道 wav 恒为 32000 B/s,所以用文件大小就能估时长,不用再起 ffprobe。 // 16k/16bit 单声道 wav 恒为 32000 B/s,所以用文件大小就能估时长,不用再起 ffprobe。
const CHUNK_SEC = Math.max(0, Number(process.env.ASR_MAX_CHUNK_SEC || 25)); const CHUNK_SEC = Math.max(1, Number(process.env.ASR_MAX_CHUNK_SEC || 25));
// 切点搜索窗:只在「距上限还差这么多秒」的范围里找停顿。
// 不从头找是为了每段都尽量接近 25s——否则开头一个 2s 的停顿也会被拿来切,
// 段数无谓变多(请求开销远大于多切一刀的收益)。
const CUT_LOOKBACK_SEC = Math.max(0, Number(process.env.ASR_CUT_LOOKBACK_SEC || 6));
// 同时转写数:2 vCPU 上并发再高只会互相拖慢。 // 同时转写数:2 vCPU 上并发再高只会互相拖慢。
const MAX_CONCURRENT = Math.max(1, Number(process.env.ASR_MAX_CONCURRENT || 2)); const MAX_CONCURRENT = Math.max(1, Number(process.env.ASR_MAX_CONCURRENT || 2));
@@ -49,6 +74,27 @@ function log(level, msg) {
console.log('[asr ' + level + '] ' + msg); console.log('[asr ' + level + '] ' + msg);
} }
// 从请求 header 取上游三要素。Authorization 允许写成裸 key(自动补 Bearer),
// 省得用户还要记各平台前缀有没有写全。
function upstreamOf(req) {
const h = (req && req.headers) || {};
const raw = String(h[HDR_AUTH] || '').trim();
return {
auth: raw ? (/^bearer\s/i.test(raw) ? raw : 'Bearer ' + raw) : '',
base: String(h[HDR_BASE] || '').trim().replace(/\/+$/, ''),
model: String(h[HDR_MODEL] || '').trim(),
};
}
// 缺参数直接 503:这是部署问题(config.yml 没配),不是用户输入问题——回 4xx 会让人以为音频坏了。
function assertUpstream(up) {
const miss = !up.base ? 'X-ASR-Base-Url' : !up.model ? 'X-ASR-Model' : '';
if (!miss) return;
const e = new Error('语音识别未配置上游:config.yml 的 mcp_servers 里 asr 需要 headers.' + miss);
e.status = 503;
throw e;
}
// ── 子进程:统一超时 + 收 stdout/stderr ──────────────────────────────────── // ── 子进程:统一超时 + 收 stdout/stderr ────────────────────────────────────
function run(cmd, args, timeoutMs) { function run(cmd, args, timeoutMs) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
@@ -114,21 +160,83 @@ async function toWav(buf, ext) {
} }
} }
// 按秒切片:只在超过 CHUNK_SEC 时做。切片用 -c copy,纯 PCM 无损。 // ── 停顿检测与切点规划 ─────────────────────────────────────────────────
async function splitWav(wavPath, chunkSec) { // 用 ffmpeg 的 silencedetect 找静音区间:容器里本来就有 ffmpeg,它的判定也处理过
// 重采样/编码的各种边角,比自己扫 PCM 算 RMS 更省心(一次遍历,30s 音频约 50~150ms)。
// 返回 [{start,end}](秒)。末尾那段一直静到文件结束的不会有 silence_end,直接丢掉——
// 尾巴不需要切。
function parseSilences(stderr) {
const out = [];
let cur = null;
for (const line of String(stderr || '').split('\n')) {
const s = /silence_start:\s*(-?[\d.]+)/.exec(line);
if (s) { cur = { start: Number(s[1]), end: null }; out.push(cur); continue; }
const e = /silence_end:\s*(-?[\d.]+)/.exec(line);
if (e && cur) { cur.end = Number(e[1]); cur = null; }
}
return out.filter((p) => p.end != null && p.end > p.start && p.start >= 0);
}
async function detectPauses(wavPath) {
const r = await run(FFMPEG, [
'-hide_banner', '-nostats', '-i', wavPath,
'-af', 'silencedetect=noise=' + SILENCE_DB + 'dB:d=' + PAUSE_SEC,
'-f', 'null', '-',
], 60000);
return parseSilences(r.stderr);
}
// 由「时长 + 静音区间」规划切点,返回 [0, c1, …, duration]。
// 贪心:每次只在「还没超上限」的范围内挑一个切点,因此段数最少(≈ 时长/CHUNK_SEC)。
// 只在最后 CUT_LOOKBACK_SEC 秒里找停顿;找不到就硬切到上限处。
function planCuts(duration, pauses) {
const mids = pauses.map((p) => (p.start + p.end) / 2);
const cuts = [0];
let cur = 0;
while (duration - cur > CHUNK_SEC) {
const limit = cur + CHUNK_SEC;
const floor = Math.max(cur + MIN_SEG_SEC, limit - CUT_LOOKBACK_SEC);
let pick = 0;
for (const t of mids) {
if (t >= floor && t <= limit && t > pick) pick = t; // 取窗口内最靠后的停顿中点
}
if (!pick) pick = limit; // 没有停顿:硬切
// 别切出一个短于 MIN_SEG_SEC 的尾巴(如 25.6s 不该切成 25 + 0.6):对半分
if (duration - pick < MIN_SEG_SEC) pick = cur + (duration - cur) / 2;
cuts.push(pick);
cur = pick;
}
cuts.push(duration);
return cuts;
}
// 按规划好的切点切片。16k/单声道/s16le 的 PCM 用 -c copy 无损切(不重编码)。
async function splitWav(wavPath, cuts) {
const dir = path.dirname(wavPath); const dir = path.dirname(wavPath);
const base = path.basename(wavPath, '.wav'); const base = path.basename(wavPath, '.wav');
const pattern = path.join(dir, base + '-part-%03d.wav'); const parts = [];
await run(FFMPEG, [ for (let i = 0; i + 1 < cuts.length; i++) {
'-hide_banner', '-loglevel', 'error', '-y', const p = path.join(dir, base + '-part-' + String(i).padStart(3, '0') + '.wav');
'-i', wavPath, await run(FFMPEG, [
'-f', 'segment', '-segment_time', String(chunkSec), '-c', 'copy', '-hide_banner', '-loglevel', 'error', '-y',
pattern, '-ss', String(cuts[i]), '-i', wavPath, '-t', String(cuts[i + 1] - cuts[i]),
], 60000); '-c', 'copy', p,
const files = (await fs.readdir(dir)) ], 60000);
.filter((f) => f.startsWith(base + '-part-') && f.endsWith('.wav')) parts.push(p);
.sort(); }
return files.map((f) => path.join(dir, f)); return parts;
}
// 拼接各段文本:中文直接相连;两侧都是西文字母/数字时补一个空格,
// 否则英文句子被切开后会粘成 "helloworld"。
function joinText(parts) {
let out = '';
for (const s of parts) {
if (!s) continue;
if (out && /[A-Za-z0-9]$/.test(out) && /^[A-Za-z0-9]/.test(s)) out += ' ';
out += s;
}
return out;
} }
// ── 引擎 ────────────────────────────────────────────────────────────────── // ── 引擎 ──────────────────────────────────────────────────────────────────
@@ -140,21 +248,17 @@ function extractText(obj) {
return ''; return '';
} }
async function runCloud(wavPath) { async function runCloud(wavPath, up) {
if (!API_KEY) { assertUpstream(up);
const e = new Error('语音识别未配置:容器环境变量 ASR_API_KEY 为空');
e.status = 503;
throw e;
}
const buf = await fs.readFile(wavPath); const buf = await fs.readFile(wavPath);
const form = new FormData(); const form = new FormData();
form.append('model', API_MODEL); form.append('model', up.model);
form.append('file', new Blob([buf], { type: 'audio/wav' }), 'audio.wav'); form.append('file', new Blob([buf], { type: 'audio/wav' }), 'audio.wav');
let res; let res;
try { try {
res = await fetch(API_BASE + '/audio/transcriptions', { res = await fetch(up.base + '/audio/transcriptions', {
method: 'POST', method: 'POST',
headers: { Authorization: 'Bearer ' + API_KEY }, headers: up.auth ? { Authorization: up.auth } : {},
body: form, body: form,
signal: AbortSignal.timeout(60000), signal: AbortSignal.timeout(60000),
}); });
@@ -188,8 +292,12 @@ async function runCloud(wavPath) {
try { obj = JSON.parse(raw); } catch (_) { return raw.trim(); } try { obj = JSON.parse(raw); } catch (_) { return raw.trim(); }
const text = extractText(obj); const text = extractText(obj);
if (!text) { if (!text) {
const err = new Error('上游返回为空:' + raw.slice(0, 300)); // 上游对「这段里没人声」会回 200 + 空 text(如 glm-asr 的 {duration,text:"",usage})。
err.status = 502; // 这是**正常结果**,不是故障:给 400 让上层只记一行 warn(5xx 才打堆栈),
// 前端按「没识别到」处理、页面侧单段失败也会被跳过。
const err = new Error('没有识别到语音内容(这段音频里没有可识别的人声)');
err.status = 400;
err.upstream = raw.slice(0, 300);
throw err; throw err;
} }
return text; return text;
@@ -208,6 +316,8 @@ async function wavLevel(wavPath) {
// 转写一段音频缓冲:归一化 →(超长则切片)→ 逐段识别 → 拼接。 // 转写一段音频缓冲:归一化 →(超长则切片)→ 逐段识别 → 拼接。
async function transcribeBuffer(buf, opts) { async function transcribeBuffer(buf, opts) {
const up = (opts && opts.up) || {};
assertUpstream(up);
const wavPath = await toWav(buf, opts && opts.ext); const wavPath = await toWav(buf, opts && opts.ext);
const parts = []; const parts = [];
try { try {
@@ -216,13 +326,25 @@ async function transcribeBuffer(buf, opts) {
// 每次请求都打一行:原始字节 → 归一化时长。排查“上游说没声音”时第一眼看这个。 // 每次请求都打一行:原始字节 → 归一化时长。排查“上游说没声音”时第一眼看这个。
log('info', '归一化:' + buf.length + 'B (' + ((opts && opts.ext) || '?') + ') → ' log('info', '归一化:' + buf.length + 'B (' + ((opts && opts.ext) || '?') + ') → '
+ seconds.toFixed(1) + 's wav'); + seconds.toFixed(1) + 's wav');
if (CHUNK_SEC > 0 && seconds > CHUNK_SEC * 1.2) {
parts.push(...await splitWav(wavPath, CHUNK_SEC)); // 只有超长才切:套壳是流式的,每次请求本来就是一�句话(1~5s),
log('info', '超长音频切成 ' + parts.length + ' 段'); // 这里直接一次送出去,不用白白跑一趟 silencedetect。
let cuts = [0, seconds];
if (seconds > CHUNK_SEC) {
const pauses = await detectPauses(wavPath).catch((e) => {
log('warn', '静音检测失败,按 ' + CHUNK_SEC + 's 硬切:' + String(e && e.message || e).slice(0, 160));
return [];
});
cuts = planCuts(seconds, pauses);
if (cuts.length > 2) {
parts.push(...await splitWav(wavPath, cuts));
log('info', '超长切成 ' + parts.length + ' 段,切点 '
+ cuts.slice(1, -1).map((t) => t.toFixed(1) + 's').join(' / '));
}
} }
if (!parts.length) { if (!parts.length) {
try { try {
return (await runCloud(wavPath)).trim(); return (await runCloud(wavPath, up)).trim();
} catch (e) { } catch (e) {
// 只在上游判定“没有语音”时量一遍音量(正常路径零开销): // 只在上游判定“没有语音”时量一遍音量(正常路径零开销):
// 静音是 -91dB,正常语音 -20dB 上下,一眼就能分清是设备没收到声还是文件坏了。 // 静音是 -91dB,正常语音 -20dB 上下,一眼就能分清是设备没收到声还是文件坏了。
@@ -234,15 +356,26 @@ async function transcribeBuffer(buf, opts) {
} }
const out = []; const out = [];
for (const p of parts) { let firstErr = null;
for (let i = 0; i < parts.length; i++) {
const t0 = Date.now();
const range = cuts[i].toFixed(1) + '–' + cuts[i + 1].toFixed(1) + 's';
// 每段独立识别;单段失败不连累其他段(长录音里偶发静音段常见) // 每段独立识别;单段失败不连累其他段(长录音里偶发静音段常见)
try { try {
out.push((await runCloud(p)).trim()); const text = (await runCloud(parts[i], up)).trim();
log('info', ' part ' + (i + 1) + '/' + parts.length + ' ' + range + ' → '
+ text.length + ' 字 / ' + (Date.now() - t0) + 'ms');
out.push(text);
} catch (e) { } catch (e) {
log('warn', '切片识别失败(跳过):' + String(e && e.message || e).slice(0, 200)); if (!firstErr) firstErr = e;
log('warn', ' part ' + (i + 1) + '/' + parts.length + ' ' + range
+ ' 识别失败(跳过):' + String(e && e.message || e).slice(0, 200));
} }
} }
return out.filter(Boolean).join(''); // 全部失败才报错:否则前端只会看到 200 + 空文本,分不清是「没说话」还是「上游挂了」。
// 部分失败保持静默降级(长录音里某一段坏了不该连坐)。
if (!out.length && firstErr) throw firstErr;
return joinText(out);
} finally { } finally {
await fs.rm(wavPath, { force: true }).catch(() => {}); await fs.rm(wavPath, { force: true }).catch(() => {});
for (const p of parts) await fs.rm(p, { force: true }).catch(() => {}); for (const p of parts) await fs.rm(p, { force: true }).catch(() => {});
@@ -301,15 +434,18 @@ async function handleTranscribe(req, res, url) {
if (active >= MAX_CONCURRENT) { if (active >= MAX_CONCURRENT) {
return json(res, 429, { error: '语音识别繁忙,请稍后再试' }); return json(res, 429, { error: '语音识别繁忙,请稍后再试' });
} }
// 先判配置再读 body:没配上游时不必白读 20MB
const up = upstreamOf(req);
assertUpstream(up);
const buf = await readBody(req, MAX_BYTES); const buf = await readBody(req, MAX_BYTES);
if (!buf.length) return json(res, 400, { error: '未收到音频数据' }); if (!buf.length) return json(res, 400, { error: '未收到音频数据' });
active++; active++;
const t0 = Date.now(); const t0 = Date.now();
try { try {
const text = await transcribeBuffer(buf, { ext: extOf(req.headers['content-type']) }); const text = await transcribeBuffer(buf, { ext: extOf(req.headers['content-type']), up });
log('info', 'transcribed ' + buf.length + 'B → ' + text.length + ' 字,' + (Date.now() - t0) + 'ms'); log('info', 'transcribed ' + buf.length + 'B → ' + text.length + ' 字,' + (Date.now() - t0) + 'ms');
json(res, 200, { text, ms: Date.now() - t0, model: API_MODEL }); json(res, 200, { text, ms: Date.now() - t0, model: up.model });
} finally { } finally {
active--; active--;
} }
@@ -375,7 +511,7 @@ async function handleMcp(req, res) {
if (!urlStr) return ok({ isError: true, content: [{ type: 'text', text: '缺少 url 参数' }] }); if (!urlStr) return ok({ isError: true, content: [{ type: 'text', text: '缺少 url 参数' }] });
try { try {
const { buf, ext } = await fetchAudio(urlStr); const { buf, ext } = await fetchAudio(urlStr);
const text = await transcribeBuffer(buf, { ext }); const text = await transcribeBuffer(buf, { ext, up: upstreamOf(req) });
return ok({ content: [{ type: 'text', text }] }); return ok({ content: [{ type: 'text', text }] });
} catch (e) { } catch (e) {
return ok({ isError: true, content: [{ type: 'text', text: '转写失败:' + String(e && e.message || e) }] }); return ok({ isError: true, content: [{ type: 'text', text: '转写失败:' + String(e && e.message || e) }] });
@@ -402,11 +538,8 @@ const server = http.createServer((req, res) => {
}; };
if (req.method === 'GET' && url.pathname === '/health') { if (req.method === 'GET' && url.pathname === '/health') {
return json(res, 200, { // 无状态服务:健康 = 进程活着。上游参数逐请求带入,没有全局「configured」可言。
ok: true, return json(res, 200, { ok: true, service: 'asr' });
model: API_MODEL,
configured: !!API_KEY,
});
} }
if (req.method === 'POST' && url.pathname === '/transcribe') return done(handleTranscribe(req, res, url)); if (req.method === 'POST' && url.pathname === '/transcribe') return done(handleTranscribe(req, res, url));
if (url.pathname === '/mcp') { if (url.pathname === '/mcp') {
@@ -428,6 +561,5 @@ process.on('SIGTERM', () => shutdown('SIGTERM'));
process.on('SIGINT', () => shutdown('SIGINT')); process.on('SIGINT', () => shutdown('SIGINT'));
server.listen(PORT, '0.0.0.0', () => { server.listen(PORT, '0.0.0.0', () => {
log('info', 'listening on ' + PORT + ',model=' + API_MODEL + ' @ ' + API_BASE); log('info', 'listening on ' + PORT + '(上游 key/base_url/model 由调用方随请求 header 带入)');
if (!API_KEY) log('warn', 'ASR_API_KEY 为空:/transcribe 会返回 503');
}); });
+53 -90
View File
@@ -3,12 +3,9 @@
一个基于 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 的图片生成 / 编辑服务。 一个基于 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 的图片生成 / 编辑服务。
对外只有一个工具 `image_task`,用 `op` 区分动作(`create` / `get`),异步任务契约与 `video_task` 一致。 对外只有一个工具 `image_task`,用 `op` 区分动作(`create` / `get`),异步任务契约与 `video_task` 一致。
上游支持两种协议,由 `X-Image-Task-Base-Url` 选择: 上游必须是 OpenAI 兼容的 images 端点:文生图走 `/images/generations`,图生图走 `/images/edits`
(智谱、各类网关走同一套协议)。`X-Image-Task-Base-Url` / `X-Image-Task-Model` / `Authorization`
| 通道 | 上游 | 请求体 | 三个 header 都必填,服务不存密钥、也不预设厂商或默认模型。
|---|---|---|
| 智谱原生 | `https://open.bigmodel.cn/api/paas/v4/images/generations` | `{ model, prompt }` |
| OpenAI 兼容 | 任意实现 `/images/generations` 的网关(如 `https://wb.ai.foresh.com/v1`) | `{ model, prompt, n: 1, response_format: "url", images? }` |
- 协议:MCP **Streamable HTTP**(单端点 `/mcp`,支持 SSE 流) - 协议:MCP **Streamable HTTP**(单端点 `/mcp`,支持 SSE 流)
- 端口:容器内 `3000`(**不映射宿主机**,只在 `agent-mcp-net` 内被 agent 访问) - 端口:容器内 `3000`(**不映射宿主机**,只在 `agent-mcp-net` 内被 agent 访问)
@@ -25,8 +22,8 @@ cd /root/workspace/tools/agent
docker compose up -d --build mcp_image_task docker compose up -d --build mcp_image_task
``` ```
服务容器名 `mcp_image_task`。要从宿主机 curl 调试,把根 `docker-compose.yml` 里 服务容器名 `mcp_image_task`,**默认不占宿主机端口**,由 agent 走 `agent-mcp-net` 按容器名访问。
`mcp_image_task` 注释掉的 `ports` 两行打开(默认 8082),调试完记得注释回去。 要从宿主机 curl 调试,自行给该服务加 `ports` 映射。
```bash ```bash
# 不占端口的健康检查 # 不占端口的健康检查
@@ -43,7 +40,7 @@ docker exec mcp_image_task node -e "fetch('http://localhost:3000/health').then(r
"url": "http://localhost:8082/mcp", "url": "http://localhost:8082/mcp",
"headers": { "headers": {
"Authorization": "Bearer <upstream-api-key>", "Authorization": "Bearer <upstream-api-key>",
"X-Image-Task-Base-Url": "zhipu", "X-Image-Task-Base-Url": "https://open.bigmodel.cn/api/paas/v4",
"X-Image-Task-Model": "CogView-4" "X-Image-Task-Model": "CogView-4"
} }
} }
@@ -78,13 +75,14 @@ docker exec mcp_image_task node -e "fetch('http://localhost:3000/health').then(r
`image` 是模式开关: `image` 是模式开关:
- 不传 → **文生图**; - 不传 → **文生图**,请求 `POST <base>/images/generations`;
- 传一个公网 URL → **图生图 / 编辑**。 - 传一个公网 URL → **图生图 / 编辑**,服务先把这张图拉下来,再以 multipart 上传到
`POST <base>/images/edits`。
本地图片先用 `mint_public_link` 换成公网 URL,再传给 `image`。 本地图片先用 `mint_public_link` 换成公网 URL,再传给 `image`。
> 尺寸、质量、模型、上游地址都**不是**工具参数:它们属于部署策略,由调用方在 header 里固定, > 尺寸、质量、模型、上游地址都**不是**工具参数:它们属于部署策略,由调用方在 header 里固定,
> 避免 AI 乱填尺寸档位或模型名白烧额度。智谱原生通道也不接受尺寸,直接走上游默认值。 > 避免 AI 乱填尺寸档位或模型名白烧额度。尺寸/质量直接走上游默认值。
### 返回 ### 返回
@@ -93,7 +91,7 @@ docker exec mcp_image_task node -e "fetch('http://localhost:3000/health').then(r
```jsonc ```jsonc
{ {
"content": [ "content": [
{ "type": "text", "text": "Model: CogView-4\nProvider: zhipu\nMode: text-to-image\ntask_id: <uuid>\ntask_status: PROCESSING\n\nImage generation is running in background. Call this tool again with op=\"get\" and task_id=\"<uuid>\" to fetch the result." } { "type": "text", "text": "Model: CogView-4\nMode: text-to-image\ntask_id: <uuid>\ntask_status: PROCESSING\n\nImage generation is running in background. Call this tool again with op=\"get\" and task_id=\"<uuid>\" to fetch the result." }
] ]
} }
``` ```
@@ -106,7 +104,7 @@ docker exec mcp_image_task node -e "fetch('http://localhost:3000/health').then(r
```jsonc ```jsonc
{ {
"content": [ "content": [
{ "type": "text", "text": "task_id: <uuid>\nmodel: CogView-4\nprovider: zhipu\nelapsed: 12s\ntask_status: SUCCESS\nImage URL: https://..." } { "type": "text", "text": "task_id: <uuid>\nmodel: CogView-4\nelapsed: 12s\ntask_status: SUCCESS\nImage URL: https://..." }
] ]
} }
``` ```
@@ -122,70 +120,53 @@ URL 由上游签名下发,**带有效期**(通常 24h),需要长期保
| Header | 必填 | 说明 | | Header | 必填 | 说明 |
|---|---|---| |---|---|---|
| `Authorization` | ✅ | `Bearer <key>`,原样作为上游 Bearer token | | `Authorization` | ✅ | `Bearer <key>`,原样作为上游 Bearer token |
| `X-Image-Task-Base-Url` | ❌ | 别名或完整 URL;缺省 `zhipu` | | `X-Image-Task-Base-Url` | ✅ | 上游 base URL(完整 `http(s)` 地址,如 `https://<host>/v1`);若已给到 `/images/generations` 或 `/images/edits` 会自动剥回 base,再按模式拼端点 |
| `X-Image-Task-Model` | 见下 | 模型名原样透传 | | `X-Image-Task-Model` | ✅ | 模型名原样透传 |
### Base-Url 别名 地址与模型只由 header 决定,AI 看不到也填不了;换模型 = 改 header 后重启 core。
| 值 | 实际地址 | 协议 |
|---|---|---|
| `zhipu`(默认) | `https://open.bigmodel.cn/api/paas/v4` | 智谱原生 |
其余值必须是完整的 `http(s)` URL:
```yaml
X-Image-Task-Base-Url: "https://wb.ai.foresh.com/v1"
```
- 已经给到 `/images/generations` 全路径就直接用,否则自动补 `/images/generations`。
- 解析后的 host 是 `bigmodel.cn`(含子域)→ 智谱原生请求体;其余 host → OpenAI 兼容请求体。
- 因此把网关地址填进来即可,不需要额外指定“用哪家协议”。
### 模型
| 场景 | `X-Image-Task-Model` |
|---|---|
| Base-Url = `zhipu` | 可省略,缺省 `CogView-3-Flash` |
| 其他 Base-Url | **必填**(不会把 CogView 误发到网关) |
模型只由 header 决定,AI 看不到也填不了。换模型 = 改 header 后重启 core。
### 图生图 ### 图生图
`image` 只对 OpenAI 兼容通道生效: 图生图**不能**走 `/images/generations`,必须走 `/images/edits`。服务会先把 `image` URL 下载成字节
(独立 60s 超时,单图上限 20MB,响应需是 `image/*`,如 png / jpeg / webp / gif / bmp),再以 multipart 上传:
| Base-Url | 传 `image` | ```text
|---|---| POST <base>/images/edits
| `zhipu` | 直接返回错误:智谱不支持图生图(只做文生图) | Content-Type: multipart/form-data; boundary=...
| 网关 URL | 上游请求体带 `images: [url]` |
### 请求体差异 model=<header 里的模型>
prompt=<prompt>
image=@<下载到的参考图> # 字段名 image,文件名按 MIME 补扩展名
n=1
response_format=url
```
| 字段 | 智谱原生 | OpenAI 兼容 | 选 multipart 而不是 JSON + base64 data URL:参考图已经在本地手里,直接当文件传可省掉 base64 的
|---|---|---| 1/3 体积膨胀,也避开网关对超大 JSON 体的限制。
| `model` / `prompt` | ✅ | ✅ |
| `n` | ❌ | 固定 `1` | ### 请求体
| `response_format` | ❌ | 固定 `"url"` |
| `size` / `quality` | ❌ | ❌(交给上游默认值) | - 文生图:JSON `{ model, prompt, n: 1, response_format: "url" }` → `/images/generations`
| `images` | ❌ | 传图时带,数组形式 `[url]` | - 图生图:multipart(字段见上)→ `/images/edits`
`size` / `quality` 一律不传,交给上游默认值。两种模式的成功响应都按 `data[0].url` 取图。
--- ---
## 配置示例 ## 配置示例
### 智谱直连(默认) 智谱与网关走同一套协议,只换地址与模型:
```yaml ```yaml
- name: image_task - name: image_task
url: "http://mcp_image_task:3000/mcp" url: "http://mcp_image_task:3000/mcp"
headers: headers:
Authorization: "Bearer <智谱 KEY>" Authorization: "Bearer <KEY>"
X-Image-Task-Base-Url: "https://open.bigmodel.cn/api/paas/v4"
X-Image-Task-Model: "CogView-4" X-Image-Task-Model: "CogView-4"
mode: skill mode: skill
``` ```
### OpenAI 兼容网关(文生图)
```yaml ```yaml
- name: image_task - name: image_task
url: "http://mcp_image_task:3000/mcp" url: "http://mcp_image_task:3000/mcp"
@@ -196,20 +177,6 @@ X-Image-Task-Base-Url: "https://wb.ai.foresh.com/v1"
mode: skill mode: skill
``` ```
### OpenAI 兼容网关(图生图 / 修图)
```yaml
- name: image_task
url: "http://mcp_image_task:3000/mcp"
headers:
Authorization: "Bearer <网关 KEY>"
X-Image-Task-Base-Url: "https://wb.ai.foresh.com/v1"
X-Image-Task-Model: "cn:hunyuan-image-alpha"
mode: skill
```
同一个网关换模型只改 `X-Image-Task-Model`;换供应商只改 `X-Image-Task-Base-Url`。
--- ---
## 错误响应 ## 错误响应
@@ -217,17 +184,18 @@ X-Image-Task-Base-Url: "https://wb.ai.foresh.com/v1"
| 场景 | HTTP 状态 | 表现 | | 场景 | HTTP 状态 | 表现 |
|---|---|---| |---|---|---|
| 缺 `Authorization` | `200`(MCP 工具返回) | `isError: true`,提示补 header | | 缺 `Authorization` | `200`(MCP 工具返回) | `isError: true`,提示补 header |
| `X-Image-Task-Base-Url` 非法 | `200`(MCP 工具返回) | `isError: true`,列出可用别名 | | 缺 `X-Image-Task-Base-Url` / 不是完整 http(s) URL | `200`(MCP 工具返回) | `isError: true`,提示填完整地址 |
| 非 zhipu 通道缺 `X-Image-Task-Model` | `200`(MCP 工具返回) | `isError: true`,提示补 header | | 缺 `X-Image-Task-Model` | `200`(MCP 工具返回) | `isError: true`,提示补 header |
| zhipu 通道传了 `image` | `200`(MCP 工具返回) | `isError: true`,提示智谱不支持图生图,改用 OpenAI 兼容端点 |
| `image` 不是公网 http(s) URL | `200`(MCP 工具返回) | `isError: true`,提示只接受公网 URL,不接受文件上传 / base64 | | `image` 不是公网 http(s) URL | `200`(MCP 工具返回) | `isError: true`,提示只接受公网 URL,不接受文件上传 / base64 |
| 参考图下载失败 / 超时(>60s)/ 超过 20MB / 不是图片 | `200`(MCP 工具返回) | 在 `op=get` 中以 `task_status: FAIL` 呈现,错误直述下载环节 |
| `op=create` 缺 prompt / `op=get` 缺 task_id | `200`(MCP 工具返回) | `isError: true`,参数提示 | | `op=create` 缺 prompt / `op=get` 缺 task_id | `200`(MCP 工具返回) | `isError: true`,参数提示 |
| `op=get` 查不到任务 | `200`(MCP 工具返回) | `isError: true`,提示 unknown task_id | | `op=get` 查不到任务 | `200`(MCP 工具返回) | `isError: true`,提示 unknown task_id |
| 上游 4xx/5xx | `200`(MCP 工具返回) | 在 `op=get` 中以 `task_status: FAIL` 呈现,正文含上游状态码和 body | | 上游 4xx/5xx | `200`(MCP 工具返回) | 在 `op=get` 中以 `task_status: FAIL` 呈现,正文含上游状态码和 body |
| 上游只回 `b64_json` | `200`(MCP 工具返回) | `task_status: FAIL`,提示本服务只接受 URL | | 上游只回 `b64_json` | `200`(MCP 工具返回) | `task_status: FAIL`,提示本服务只接受 URL |
| 网络失败 / 超时(>180s) | `200`(MCP 工具返回) | `task_status: FAIL`,不会出现永久 PROCESSING 的僵尸任务 | | 网络失败 / 超时(>180s) | `200`(MCP 工具返回) | `task_status: FAIL`,不会出现永久 PROCESSING 的僵尸任务 |
> JSON 请求体上限保持 2MB:`image` 只接受 URL,不接收文件或 base64。 > JSON 请求体上限保持 2MB:工具参数里的 `image` 只接受 URL,不接收文件或 base64。
> 参考图由服务自己下载后以 multipart 转发给上游,不经过 MCP 请求体。
--- ---
@@ -264,11 +232,12 @@ curl -s -X POST http://localhost:8082/mcp \
-H "Mcp-Session-Id: $SESSION" \ -H "Mcp-Session-Id: $SESSION" \
-d '{"jsonrpc": "2.0", "method": "notifications/initialized"}' -d '{"jsonrpc": "2.0", "method": "notifications/initialized"}'
# 3. 文生图(智谱通道;换成网关时补 X-Image-Task-Base-Url / X-Image-Task-Model) # 3. 文生图(三个 header 都必填)
curl -s -X POST http://localhost:8082/mcp \ curl -s -X POST http://localhost:8082/mcp \
-H "Content-Type: application/json" \ -H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \ -H "Accept: application/json, text/event-stream" \
-H "Authorization: Bearer $TOKEN" \ -H "Authorization: Bearer $TOKEN" \
-H "X-Image-Task-Base-Url: https://open.bigmodel.cn/api/paas/v4" \
-H "X-Image-Task-Model: CogView-4" \ -H "X-Image-Task-Model: CogView-4" \
-H "Mcp-Session-Id: $SESSION" \ -H "Mcp-Session-Id: $SESSION" \
-d '{ -d '{
@@ -284,7 +253,7 @@ curl -s -X POST http://localhost:8082/mcp \
} }
}' }'
# 4. 图生图(OpenAI 兼容通道) # 4. 图生图
curl -s -X POST http://localhost:8082/mcp \ curl -s -X POST http://localhost:8082/mcp \
-H "Content-Type: application/json" \ -H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \ -H "Accept: application/json, text/event-stream" \
@@ -353,18 +322,10 @@ image_task/
- token / 上游地址 / 模型在 `create` 那一刻从请求 header 捕获进闭包,后台完成前不再读取 - token / 上游地址 / 模型在 `create` 那一刻从请求 header 捕获进闭包,后台完成前不再读取
- **每 session 一个 transport + server**:通过 `Mcp-Session-Id` 复用 - **每 session 一个 transport + server**:通过 `Mcp-Session-Id` 复用
- **模型 / 上游地址不入 schema**:只从 HTTP header 读取,AI 不可见 - **模型 / 上游地址不入 schema**:只从 HTTP header 读取,AI 不可见
- **`image` 单一开关**:不传 = 文生图,传一个公网 URL = 图生图;`image` 是单个字符串,只接受公网 `http(s)` URL - **`image` 单一开关**:不传 = 文生图(`/images/generations`),传一个公网 URL = 图生图
(下载后 multipart 上传 `/images/edits`);`image` 是单个字符串,只接受公网 `http(s)` URL
- **URL 提取**:只接受 `data[].url` 形式的 http(s) URL;上游若回 `b64_json` 则记 `FAIL` 并给出明确错误 - **URL 提取**:只接受 `data[].url` 形式的 http(s) URL;上游若回 `b64_json` 则记 `FAIL` 并给出明确错误
### 默认模型
```js
// src/mcp-server.js
const DEFAULT_MODEL = "CogView-3-Flash"; // 仅 Base-Url=zhipu 时生效
```
修改后 `docker compose up -d --build mcp_image_task` 即可生效。
--- ---
## 常见问题 ## 常见问题
@@ -378,11 +339,13 @@ A: 不需要重建 session,但 core 的 `mcp_servers[].headers` 是启动时
**Q: 为什么只支持一张参考图?** **Q: 为什么只支持一张参考图?**
A: 当前上游契约只稳定支持单张;`image` 因此是单个 URL 字符串。 A: 当前上游契约只稳定支持单张;`image` 因此是单个 URL 字符串。
**Q: 图生图为什么在 zhipu 通道报错?** **Q: 图生图报错?**
A: 智谱原生接口不支持图生图。把 `X-Image-Task-Base-Url` 指向支持 `images` 字段的 OpenAI 兼容网关即可。 A: 图生图走 `/images/edits` + multipart(字段名 `image`)。若上游模型不支持编辑、或网关不认这种入参,
上游会回 4xx,在 `op=get` 里以 `task_status: FAIL` 呈现。换一个支持 `/images/edits` 的模型即可。
**Q: 本地图片怎么传?** **Q: 本地图片怎么传?**
A: 先调用 agent 内置的 `mint_public_link` 工具,把会话目录里的文件换成短期公网 URL,再传给 `image`。本服务不接受文件上传或 base64,上游服务器也无法访问你的本地路径。 A: 先调用 agent 内置的 `mint_public_link` 工具,把会话目录里的文件换成短期公网 URL,再传给 `image`。
本服务不接受文件上传或 base64(MCP 请求体不放图片字节),参考图由服务自己从这个 URL 拉取。
**Q: 上游是同步接口,为什么对外做成异步?** **Q: 上游是同步接口,为什么对外做成异步?**
A: 和 `video_task` 保持同一套任务型契约;同时避免一次生图把 core 的 `tools/call` 拖超时。 A: 和 `video_task` 保持同一套任务型契约;同时避免一次生图把 core 的 `tools/call` 拖超时。
+1 -1
View File
@@ -1,7 +1,7 @@
{ {
"name": "mcp_image_task", "name": "mcp_image_task",
"version": "1.0.0", "version": "1.0.0",
"description": "MCP server for image generation and editing via Zhipu BigModel CogView or any OpenAI-compatible /images/generations endpoint (single tool image_task with op=create/get)", "description": "MCP server for image generation and editing via any OpenAI-compatible images API (/images/generations and /images/edits), single tool image_task with op=create/get",
"type": "module", "type": "module",
"main": "src/mcp-server.js", "main": "src/mcp-server.js",
"scripts": { "scripts": {
+183 -93
View File
@@ -6,20 +6,19 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js"; import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod"; import { z } from "zod";
// 上游地址既支持完整 URL,也支持别名。zhipu 走智谱原生协议(body 只有 // 上游必须是 OpenAI 兼容的端点:文生图走 /images/generations,图生图走 /images/edits。
// model/prompt);其余地址一律按 OpenAI 兼容的 /images/generations 协议 // Base-Url / 模型 / 凭据全部由调用方随每个请求用 header 带入(X-Image-Task-Base-Url /
// (body 加 n / response_format=url)。别名目前只保留 zhipu。 // X-Image-Task-Model / Authorization),服务自己不存、也不预设任何厂商。
const BASE_URL_ALIASES = {
zhipu: "https://open.bigmodel.cn/api/paas/v4",
};
// 只有智谱需要走原生请求体,其余主机一律按 OpenAI 兼容处理。
const ZHIPU_HOST_SUFFIX = "bigmodel.cn";
const DEFAULT_MODEL = "CogView-3-Flash";
// 上游同步调用耗时上限(出图几十秒量级,留足余量)。 // 上游同步调用耗时上限(出图几十秒量级,留足余量)。
// 超时后任务记为 FAIL,避免上游挂而不回时永远卡在 PROCESSING。 // 超时后任务记为 FAIL,避免上游挂而不回时永远卡在 PROCESSING。
const UPSTREAM_TIMEOUT_MS = 180_000; const UPSTREAM_TIMEOUT_MS = 180_000;
// 图生图要先把参考图拉成字节再 multipart 上传:下载超时与体积都要单独兜底,
// 否则慢 CDN 会拖死任务、超大原图会顶满容器内存。
const IMAGE_DOWNLOAD_TIMEOUT_MS = 60_000;
const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
// ── 优雅退出 ────────────────────────────────────────────────────────────── // ── 优雅退出 ──────────────────────────────────────────────────────────────
// 容器里 node 以 PID 1 运行且未注册 SIGTERM 处理器时,内核不会对其执行默认 // 容器里 node 以 PID 1 运行且未注册 SIGTERM 处理器时,内核不会对其执行默认
// 终止动作,docker stop/restart 会白等满 10s 宽限期才被 SIGKILL。 // 终止动作,docker stop/restart 会白等满 10s 宽限期才被 SIGKILL。
@@ -84,45 +83,36 @@ function pickModel(headers) {
return pickHeaderString(headers, "x-image-task-model"); return pickHeaderString(headers, "x-image-task-model");
} }
// 解析 Base-Url:别名优先,否则必须是 http(s) URL。 // 解析 Base-Url:必须是完整 http(s) URL。允许调用方直接填到 /images/generations 或
// 返回 { provider, url }:url 是最终 POST 的完整地址。 // /images/edits(老配置、照抄文档的写法),统一剥回 base,端点由 mode 决定——
function resolveEndpoint(rawBase) { // 否则图生图会被错发到 generations。
const raw = String(rawBase || "zhipu").trim().replace(/\/+$/, ""); function resolveBaseUrl(rawBase) {
const alias = BASE_URL_ALIASES[raw.toLowerCase()]; const base = String(rawBase || "").trim().replace(/\/+$/, "");
const base = alias || raw; if (!base) {
let host;
try {
if (!/^https?:\/\//i.test(base)) throw new Error("not http(s)");
host = new URL(base).hostname.toLowerCase();
} catch {
throw new Error( throw new Error(
`Invalid X-Image-Task-Base-Url "${raw}": use an alias (${Object.keys(BASE_URL_ALIASES).join(", ")}) ` + "Missing X-Image-Task-Base-Url: pass the upstream base URL (e.g. https://<host>/v1)."
"or a full http(s) URL."
); );
} }
if (!/^https?:\/\//i.test(base)) {
// 已经给到 /images/generations 就直接用;否则补在 base 后面。 throw new Error(
const url = /\/images\/generations$/i.test(base) `Invalid X-Image-Task-Base-Url "${base}": must be a full http(s) URL.`
? base );
: base + "/images/generations"; }
const provider = return base.replace(/\/images\/(generations|edits)$/i, "");
host === ZHIPU_HOST_SUFFIX || host.endsWith("." + ZHIPU_HOST_SUFFIX)
? "zhipu"
: "openai";
return { provider, url };
} }
// 模型只由 header 决定,AI 看不到也填不了。 // mode=edit 走 /images/edits(图生图),否则走 /images/generations(文生图)。
// zhipu 通道有默认模型;其他通道必须显式给 —— 否则会把 CogView 发到网关, function resolveEndpoint(base, mode) {
// 换来的只是一个含义不明的 400。 return base + (mode === "edit" ? "/images/edits" : "/images/generations");
function resolveModel(headers, provider) { }
// 模型只由 header 决定,AI 看不到也填不了。不猜缺省值:猜错只会换来含义不明的 400。
function resolveModel(headers) {
const model = pickModel(headers); const model = pickModel(headers);
if (model) return model; if (!model) {
if (provider === "zhipu") return DEFAULT_MODEL; throw new Error("Missing X-Image-Task-Model: pass the upstream model name.");
throw new Error( }
"X-Image-Task-Model is required when X-Image-Task-Base-Url is not the zhipu alias." return model;
);
} }
// 一次解析出本次请求的上游、凭据、模型。 // 一次解析出本次请求的上游、凭据、模型。
@@ -132,31 +122,24 @@ function resolveTarget(headers) {
if (!token) { if (!token) {
throw new Error('Missing Authorization: use "Authorization: Bearer <token>".'); throw new Error('Missing Authorization: use "Authorization: Bearer <token>".');
} }
const { provider, url } = resolveEndpoint(pickBaseUrl(headers)); return {
return { provider, url, token, model: resolveModel(headers, provider) }; base: resolveBaseUrl(pickBaseUrl(headers)),
token,
model: resolveModel(headers),
};
} }
async function callImagesGenerations({ provider, url, token, model, prompt, image }) { // 统一的上游 POST:超时、错误体解析都在这层,JSON 与 multipart 共用。
// 智谱原生只认 model/prompt;OpenAI 兼容通道固定单图,并要求返回 URL // contentType 为空表示交给 fetch 自己写(multipart 必须这样,boundary 由它生成)。
// (b64_json 几十 MB,既塞不进任务表也没法给模型看)。尺寸/质量一律不传, async function postUpstream({ url, token, body, contentType }) {
// 交给上游默认值 —— 各家(尤其 CogView)对尺寸的限制并不一致。 const headers = { Authorization: `Bearer ${token}` };
// 传了 image 就是图生图;上游字段是数组,所以这里包一层。 if (contentType) headers["Content-Type"] = contentType;
const body =
provider === "zhipu"
? { model, prompt }
: Object.assign(
{ model, prompt, n: 1, response_format: "url" },
image ? { images: [image] } : null
);
let resp; let resp;
try { try {
resp = await fetch(url, { resp = await fetch(url, {
method: "POST", method: "POST",
headers: { headers,
Authorization: `Bearer ${token}`, body,
"Content-Type": "application/json",
},
body: JSON.stringify(body),
signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS), signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
}); });
} catch (e) { } catch (e) {
@@ -175,9 +158,8 @@ async function callImagesGenerations({ provider, url, token, model, prompt, imag
data = { raw: text }; data = { raw: text };
} }
if (!resp.ok) { if (!resp.ok) {
const label = provider === "zhipu" ? "Zhipu" : "OpenAI-compatible";
const err = new Error( const err = new Error(
`${label} API error: ${resp.status} ${resp.statusText} - ${text}` `Upstream API error: ${resp.status} ${resp.statusText} - ${text}`
); );
err.status = resp.status; err.status = resp.status;
err.detail = data; err.detail = data;
@@ -186,6 +168,126 @@ async function callImagesGenerations({ provider, url, token, model, prompt, imag
return data; return data;
} }
const MIME_TO_EXT = {
"image/png": "png",
"image/jpeg": "jpg",
"image/webp": "webp",
"image/gif": "gif",
"image/bmp": "bmp",
};
const EXT_TO_MIME = {
png: "image/png",
jpg: "image/jpeg",
jpeg: "image/jpeg",
webp: "image/webp",
gif: "image/gif",
bmp: "image/bmp",
};
function urlExtension(url) {
try {
const m = /\.([a-z0-9]+)$/i.exec(new URL(url).pathname);
return m ? m[1].toLowerCase() : "";
} catch {
return "";
}
}
// 判定参考图的 MIME:优先响应头,其次 URL 扩展名。响应头只要声明是 image/* 就放行
// (avif / tiff 这类冷门格式交给上游判断),避免本地图片被我们提前拒掉。
// 两者都不是图片就报错——典型情况是链接过期后拿到 HTML 错误页,继续上传只会换来
// 上游一句难懂的 400。
function pickImageMime(contentType, url) {
const ct = String(contentType || "").split(";")[0].trim().toLowerCase();
if (/^image\/[a-z0-9.+-]+$/.test(ct)) return ct;
const mime = EXT_TO_MIME[urlExtension(url)];
if (mime) return mime;
throw new Error(
`Reference image is not an image: content-type "${ct || "none"}" (${url}).`
);
}
// multipart 里的文件名按 MIME 补扩展名;冷门 image/* 就把子类型当年扩展名。
function extensionForMime(mime) {
return (
MIME_TO_EXT[mime] ||
mime.slice("image/".length).replace(/[^a-z0-9]/g, "") ||
"img"
);
}
// 图生图需要真实字节:先把 image URL 拉下来。带独立超时与体积上限,错误直述下载环节,
// 便于区分「参考图挂了」和「上游出图失败」。
async function downloadImage(url) {
let resp;
try {
resp = await fetch(url, {
signal: AbortSignal.timeout(IMAGE_DOWNLOAD_TIMEOUT_MS),
});
} catch (e) {
if (e?.name === "TimeoutError" || e?.name === "AbortError") {
throw new Error(
`Failed to download reference image: timed out after ${IMAGE_DOWNLOAD_TIMEOUT_MS} ms (${url})`
);
}
throw new Error(`Failed to download reference image: ${e.message} (${url})`);
}
if (!resp.ok) {
throw new Error(
`Failed to download reference image: ${resp.status} ${resp.statusText} (${url})`
);
}
const declared = Number(resp.headers.get("content-length") || 0);
if (declared > MAX_IMAGE_BYTES) {
throw new Error(
`Reference image is too large: ${declared} bytes (limit ${MAX_IMAGE_BYTES}) (${url})`
);
}
// 不直接 arrayBuffer():没有 content-length 的响应会一路读进内存,
// 这里边读边计数,超限立刻中止(断掉上游连接)。
const chunks = [];
let total = 0;
for await (const chunk of resp.body) {
total += chunk.length;
if (total > MAX_IMAGE_BYTES) {
throw new Error(
`Reference image is too large: >${MAX_IMAGE_BYTES} bytes (limit ${MAX_IMAGE_BYTES}) (${url})`
);
}
chunks.push(chunk);
}
if (total === 0) {
throw new Error(`Reference image is empty (${url})`);
}
const buffer = Buffer.concat(chunks, total);
const mime = pickImageMime(resp.headers.get("content-type"), url);
return { buffer, mime, filename: `image.${extensionForMime(mime)}` };
}
// 文生图:JSON 体。response_format=url(b64_json 几十 MB,既塞不进任务表也没法给模型看)。
// 尺寸/质量一律不传,交给上游默认值。
async function callImagesGenerations({ url, token, model, prompt }) {
const body = JSON.stringify({ model, prompt, n: 1, response_format: "url" });
return postUpstream({ url, token, body, contentType: "application/json" });
}
// 图生图:上游只认 /images/edits,且实测只接受两种入参——
// 1) multipart/form-data,image 字段是文件(image=@a.jpg);
// 2) application/json,image 字段是 data:image/...;base64,... 的 data URL。
// 这里走 multipart:参考图已经在本地手里,直接当文件上传,省掉 base64 的 1/3 体积膨胀,
// 也避开网关对超大 JSON 体的限制。响应格式与 generations 一致(data[0].url)。
async function callImagesEdits({ url, token, model, prompt, image }) {
const ref = await downloadImage(image);
const form = new FormData();
form.append("model", model);
form.append("prompt", prompt);
form.append("image", new Blob([ref.buffer], { type: ref.mime }), ref.filename);
form.append("n", "1");
form.append("response_format", "url");
// 不传 Content-Type:fetch 会带上含 boundary 的 multipart/form-data
return postUpstream({ url, token, body: form });
}
// 只认 http(s) URL。b64_json 不再当 URL 存:它会把任务表撑爆,模型也读不了。 // 只认 http(s) URL。b64_json 不再当 URL 存:它会把任务表撑爆,模型也读不了。
function extractUrls(data) { function extractUrls(data) {
if (!data) return []; if (!data) return [];
@@ -207,7 +309,7 @@ function hasInlineBase64(data) {
} }
// ===== 自维护任务表(异步语义全靠这层模拟) ===== // ===== 自维护任务表(异步语义全靠这层模拟) =====
// 上游智谱 images 接口是同步阻塞的,但对外要和 video_task 一样提供 // 上游智谱/网关的 images 接口是同步阻塞的,但对外要和 video_task 一样提供
// create(立即返回 task_id)+ get(轮询结果)的异步契约: // create(立即返回 task_id)+ get(轮询结果)的异步契约:
// create 登记 PROCESSING 后把同步调用丢到后台跑,get 从表里读最新状态。 // create 登记 PROCESSING 后把同步调用丢到后台跑,get 从表里读最新状态。
// //
@@ -239,14 +341,21 @@ function pruneTasks() {
// 后台跑同步上游调用,结果回写任务表(fire-and-forget,不 await) // 后台跑同步上游调用,结果回写任务表(fire-and-forget,不 await)
function runImageTask({ task, target, prompt, image }) { function runImageTask({ task, target, prompt, image }) {
callImagesGenerations({ const upstream = image
provider: target.provider, ? callImagesEdits({
url: target.url, url: resolveEndpoint(target.base, "edit"),
token: target.token, token: target.token,
model: target.model, model: target.model,
prompt, prompt,
image, image,
}) })
: callImagesGenerations({
url: resolveEndpoint(target.base, "generation"),
token: target.token,
model: target.model,
prompt,
});
upstream
.then((data) => { .then((data) => {
task.finishedAt = Date.now(); task.finishedAt = Date.now();
const urls = extractUrls(data); const urls = extractUrls(data);
@@ -282,7 +391,8 @@ async function handleCreate({ args, headers }) {
}; };
} }
// image 是文生图/图生图开关:不传 = 文生图;传一个公网 URL = 修图。 // image 是文生图/图生图开关:不传 = 文生图(/images/generations);传一个公网 URL = 修图
// (/images/edits,服务会先把这张图拉下来再以 multipart 上传)。
// 只接受公网 http(s) URL;本地文件请先由调用方用 mint_public_link 换成公网链接。 // 只接受公网 http(s) URL;本地文件请先由调用方用 mint_public_link 换成公网链接。
if (args.image !== undefined && typeof args.image !== "string") { if (args.image !== undefined && typeof args.image !== "string") {
return { return {
@@ -318,26 +428,10 @@ async function handleCreate({ args, headers }) {
}; };
} }
// 智谱原生接口不支持图生图;带 image 的请求只能走 OpenAI 兼容端点。
if (image && target.provider === "zhipu") {
return {
isError: true,
content: [
{
type: "text",
text:
'Image editing is not supported by the configured model. ' +
'Remove "image" for text-to-image.',
},
],
};
}
pruneTasks(); pruneTasks();
const taskId = randomUUID(); const taskId = randomUUID();
const task = { const task = {
status: "PROCESSING", status: "PROCESSING",
provider: target.provider,
model: target.model, model: target.model,
prompt, prompt,
createdAt: Date.now(), createdAt: Date.now(),
@@ -350,7 +444,6 @@ async function handleCreate({ args, headers }) {
const mode = image ? "edit" : "text-to-image"; const mode = image ? "edit" : "text-to-image";
const summary = const summary =
`Model: ${target.model}\n` + `Model: ${target.model}\n` +
`Provider: ${target.provider}\n` +
`Mode: ${mode}\n` + `Mode: ${mode}\n` +
`task_id: ${taskId}\n` + `task_id: ${taskId}\n` +
`task_status: PROCESSING\n` + `task_status: PROCESSING\n` +
@@ -411,7 +504,6 @@ async function handleGet({ args }) {
text: text:
`task_id: ${taskId}\n` + `task_id: ${taskId}\n` +
`model: ${task.model}\n` + `model: ${task.model}\n` +
`provider: ${task.provider}\n` +
`elapsed: ${elapsed}s\n` + `elapsed: ${elapsed}s\n` +
`task_status: PROCESSING\n` + `task_status: PROCESSING\n` +
`\n` + `\n` +
@@ -429,7 +521,6 @@ async function handleGet({ args }) {
type: "text", type: "text",
text: text:
`task_id: ${taskId}\n` + `task_id: ${taskId}\n` +
`provider: ${task.provider}\n` +
`elapsed: ${elapsedSeconds(task)}s\n` + `elapsed: ${elapsedSeconds(task)}s\n` +
`task_status: FAIL\n` + `task_status: FAIL\n` +
`error: ${task.error}`, `error: ${task.error}`,
@@ -447,7 +538,6 @@ async function handleGet({ args }) {
const summary = const summary =
`task_id: ${taskId}\n` + `task_id: ${taskId}\n` +
`model: ${task.model}\n` + `model: ${task.model}\n` +
`provider: ${task.provider}\n` +
`elapsed: ${elapsedSeconds(task)}s\n` + `elapsed: ${elapsedSeconds(task)}s\n` +
`task_status: SUCCESS\n` + `task_status: SUCCESS\n` +
`${lines}`; `${lines}`;
+2 -3
View File
@@ -23,8 +23,7 @@ docker compose up -d --build mcp_video_task
``` ```
服务容器名 `mcp_video_task`,**默认不占宿主机端口**:由 agent 走 `agent-mcp-net` 按容器名访问 服务容器名 `mcp_video_task`,**默认不占宿主机端口**:由 agent 走 `agent-mcp-net` 按容器名访问
(`http://mcp_video_task:3000/mcp`)。需要从宿主机 curl 调试时,去仓库根 `docker-compose.yml` (`http://mcp_video_task:3000/mcp`)。要从宿主机 curl 调试,自行给该服务加 `ports` 映射。
把 `mcp_video_task` 注释掉的 `ports` 两行打开(映的是 MCP 端口 3000,仅本机短时调试用)。
```bash ```bash
# 容器内健康检查(无需占端口) # 容器内健康检查(无需占端口)
@@ -53,7 +52,7 @@ docker exec mcp_video_task node -e "fetch('http://localhost:3000/health').then(r
} }
``` ```
> 上面 `url` 里的端口 `8083` 需要先把 compose 里注释的 `ports` 打开(默认不占宿主端口)。 > 上面的 `localhost:8083` 只是示例:本栈默认不给 MCP 服务映射宿主端口,要直连需自行加 `ports`。
> **重要**:客户端必须在 **每一个 HTTP 请求**(`initialize` / `notifications/initialized` / `tools/call`)都带上 `Authorization` header。 > **重要**:客户端必须在 **每一个 HTTP 请求**(`initialize` / `notifications/initialized` / `tools/call`)都带上 `Authorization` header。
+43 -6
View File
@@ -1,15 +1,49 @@
# web_search # web_search
免费网页搜索 MCP server 的本地重构版(上游开源实现:[@sheep233_/dsh-web-search-free](https://github.com/sheep-programmer/dsh-web-search-free),MIT)。 网页搜索 MCP server 的本地重构版(上游开源实现:[@sheep233_/dsh-web-search-free](https://github.com/sheep-programmer/dsh-web-search-free),MIT)。
零运行时依赖,只用 Node 内置 `fetch`(Node ≥ 18),**无需 npm install,直接 `node server.js` 启动**。 零运行时依赖,只用 Node 内置 `fetch`(Node ≥ 18),**无需 npm install,直接 `node server.js` 启动**。
## 三路上游
| 条件 | 走哪 | 说明 |
| --- | --- | --- |
| 请求带了 `X-Web-Search-Base-Url` | 你的 `POST {base}/search` | key 可选(`Authorization`)。**失败直接报错,不静默退回免费后端** |
| 没带 | Parallel(免费匿名) | 失败自动退 Exa |
| stdio 模式 | 只能免费 | stdio 没有 HTTP header |
自定义上游的协议:
```http
POST {base}/search
Authorization: Bearer <key>
Content-Type: application/json
{"query":"2027山东省考公告","max_results":5}
```
```json
{"query":"...","type":"text2text","results":[{"title":"...","url":"https://...","snippet":"..."}]}
```
响应归一化成 `[{url, title?, snippet?, publishedAt?}]`:`results[]` 里没有 `url` 的条目丢弃,
`snippet` 压平空白后**原样返回**(默认不截断);调用方传 `maxSnippetLength: 3000` 才会按该长度截断,
`published_at` / `publishedAt` / `publish_date` 任一存在则映射为 `publishedAt`。
## 工具参数
| 参数 | 必填 | 说明 |
| --- | --- | --- |
| `query` | 是 | 搜什么 |
| `numResults` | 否 | 返回条数,默认 8 |
| `maxSnippetLength` | 否 | 每条 `snippet` 的最大字符数;**不传 = 不截断**(上游常给整段正文,长文本请自行控预算) |
## 结构 ## 结构
| 文件 | 职责 | | 文件 | 职责 |
| --- | --- | | --- | --- |
| `core.js` | 搜索后端:Parallel(默认)/ Exa(备用)免费 MCP 端点封装 + 响应解析 | | `core.js` | 搜索后端:自定义 `/search` + Parallel / Exa 免费 MCP 端点封装 + 响应解析 |
| `mcp.js` | MCP 协议层:`web_search` 工具定义 + JSON-RPC 分发 | | `mcp.js` | MCP 协议层:`web_search` 工具定义 + JSON-RPC 分发 + 从 header 取上游参数 |
| `server.js` | 入口:CLI 参数 + stdio / HTTP/SSE 双传输 | | `server.js` | 入口:CLI 参数 + stdio / HTTP/SSE 双传输 |
## 本地启动 ## 本地启动
@@ -33,13 +67,16 @@ MCP 端点:
- `EXA_API_KEY` — 提升 Exa 匿名限额 - `EXA_API_KEY` — 提升 Exa 匿名限额
- `SEARCH_TIMEOUT_MS` — 上游搜索超时,默认 30000 - `SEARCH_TIMEOUT_MS` — 上游搜索超时,默认 30000
上游地址 / 鉴权**不是**环境变量:由调用方随每个请求用 header 带入(见上面「三路上游」),
agent 侧写在 `config.yml` 的 `mcp_servers[name=web_search].headers`。换接口只改 YAML + 重启 core,
不碰 `.env`、不重建镜像;容器自身不存任何平台密钥。
## Docker ## Docker
`docker-compose.yml` 中的 `mcp_web_search` 服务直接构建本目录,Dockerfile 已改为拷贝源码启动(不再有 `npm install -g`)。 `docker-compose.yml` 中的 `mcp_web_search` 服务直接构建本目录,Dockerfile 已改为拷贝源码启动(不再有 `npm install -g`)。
容器内监听 3000,**默认不占宿主端口**:agent 走 `agent-mcp-net` 按容器名访问 容器内监听 3000,**默认不占宿主端口**:agent 走 `agent-mcp-net` 按容器名访问
(`http://mcp_web_search:3000/`)。需要从宿主机 curl 调试时,把仓库根 `docker-compose.yml` 里 (`http://mcp_web_search:3000/`)。要从宿主机 curl 调试,自行给该服务加 `ports` 映射。
`mcp_web_search` 注释掉的 `ports` 两行打开(默认写的是 8081),调试完记得注释回去。
```bash ```bash
docker compose build mcp_web_search && docker compose up -d mcp_web_search docker compose build mcp_web_search && docker compose up -d mcp_web_search
@@ -48,4 +85,4 @@ docker exec mcp_web_search node -e "fetch('http://localhost:3000/health').then(r
# {"name":"web_search","version":"...","transport":"http/sse","port":3000} # {"name":"web_search","version":"...","transport":"http/sse","port":3000}
``` ```
该服务**无服务端鉴权**(上游是免费端点),**永远不要**对外映射端口——会被白嫆搜索额度。 该服务**无服务端鉴权**,**永远不要**对外映射端口——会被白嫖搜索额度(自定义上游时还会把你的 key 白送出去)。
+107 -13
View File
@@ -1,9 +1,13 @@
/** /**
* 零依赖搜索核心:Parallel(默认,匿名免 key)与 Exa(备用)两个免费后端的统一封装。 * 零依赖搜索核心:三路上游,统一归一化成 `{ url, title?, snippet?, publishedAt? }[]`。
* *
* 只用 Node 内置 fetch,不依赖任何 npm 包。两个后端都是公开的免费 MCP 端点, * - 自定义上游(`X-Web-Search-Base-Url` + `Authorization`):任意 `POST {base}/search`,
* 本模块以 JSON-RPC `tools/call` 的方式直接调用它们,并归一化成统一的结果结构: * 请求体 `{ query, max_results }`、响应 `{ results: [{ title, url, snippet }] }`。
* `{ url, title?, snippet?, publishedAt? }[]`。 * - Parallel(免费匿名 MCP 端点,默认后端)。
* - Exa(免费 MCP 端点,Parallel 挂掉时的兜底)。
*
* 只用 Node 内置 fetch,不依赖任何 npm 包。免费侧两个后端都是公开的 MCP 端点,
* 本模块以 JSON-RPC `tools/call` 的方式直接调用它们。
* *
* 上游实现参考:@sheep233_/dsh-web-search-free(github.com/sheep-programmer/dsh-web-search-free)。 * 上游实现参考:@sheep233_/dsh-web-search-free(github.com/sheep-programmer/dsh-web-search-free)。
*/ */
@@ -13,9 +17,22 @@ export const PARALLEL_MCP_URL = 'https://search.parallel.ai/mcp';
/** Exa 免费 MCP 端点(匿名可用;EXA_API_KEY 可提升限额)。 */ /** Exa 免费 MCP 端点(匿名可用;EXA_API_KEY 可提升限额)。 */
export const EXA_MCP_URL = 'https://mcp.exa.ai/mcp'; export const EXA_MCP_URL = 'https://mcp.exa.ai/mcp';
const USER_AGENT = 'web_search/1.0.0'; const USER_AGENT = 'web_search/1.1.0';
/** 单次上游搜索请求的超时,避免远端挂起拖死 MCP 请求。 */ /** 单次上游搜索请求的超时,避免远端挂起拖死 MCP 请求。 */
const REQUEST_TIMEOUT_MS = Number(process.env.SEARCH_TIMEOUT_MS ?? 30_000); const REQUEST_TIMEOUT_MS = Number(process.env.SEARCH_TIMEOUT_MS ?? 30_000);
/**
* snippet 一律截断:搜索结果会进历史,之后每一轮都可能被整条重放。
* 有些上游(如自建 v1/search)的 snippet 是整段正文,不截等于白烧 token。
*/
/**
* snippet 一律压平空白;是否截断由调用方传 maxSnippetLength 决定,缺省不截断。
* 为什么默认不截:上限该由调用方按自己的上下文预算定,写死在服务里会让「换上游 = 悄悄丢内容」。
*/
export function capSnippet(text, max) {
const s = String(text == null ? '' : text).replace(/\s+/g, ' ').trim();
if (!Number.isFinite(max) || max <= 0 || s.length <= max) return s;
return s.slice(0, max) + '…';
}
/** /**
* 向免费 MCP 端点发一次 `tools/call`,返回工具结果里的 text 载荷。 * 向免费 MCP 端点发一次 `tools/call`,返回工具结果里的 text 载荷。
@@ -74,7 +91,7 @@ export function extractToolText(body) {
} }
/** Parallel 响应解析:text 是内嵌 JSON `{ results: [...] }`。 */ /** Parallel 响应解析:text 是内嵌 JSON `{ results: [...] }`。 */
export function mapParallelResponse(text) { export function mapParallelResponse(text, maxSnippetLength) {
let payload; let payload;
try { try {
payload = JSON.parse(text); payload = JSON.parse(text);
@@ -84,10 +101,11 @@ export function mapParallelResponse(text) {
const sources = []; const sources = [];
for (const item of payload.results ?? []) { for (const item of payload.results ?? []) {
if (!item.url) continue; if (!item.url) continue;
const snippet = item.excerpts?.length > 0 ? capSnippet(item.excerpts.join(' '), maxSnippetLength) : '';
sources.push({ sources.push({
url: item.url, url: item.url,
...(item.title ? { title: item.title } : {}), ...(item.title ? { title: item.title } : {}),
...(item.excerpts?.length > 0 ? { snippet: item.excerpts.join(' ') } : {}), ...(snippet ? { snippet } : {}),
...(item.publish_date ? { publishedAt: item.publish_date } : {}), ...(item.publish_date ? { publishedAt: item.publish_date } : {}),
}); });
} }
@@ -105,7 +123,7 @@ export function mapParallelResponse(text) {
* <正文摘要> * <正文摘要>
* ``` * ```
*/ */
export function parseExaText(text) { export function parseExaText(text, maxSnippetLength) {
const blocks = text.split(/(?=^Title: )/m).filter((block) => block.trim().length > 0); const blocks = text.split(/(?=^Title: )/m).filter((block) => block.trim().length > 0);
const sources = []; const sources = [];
for (const block of blocks) { for (const block of blocks) {
@@ -114,28 +132,104 @@ export function parseExaText(text) {
const title = block.match(/^Title: (.+)$/m)?.[1]?.trim(); const title = block.match(/^Title: (.+)$/m)?.[1]?.trim();
const published = block.match(/^Published: (.+)$/m)?.[1]?.trim(); const published = block.match(/^Published: (.+)$/m)?.[1]?.trim();
const highlights = block.split(/^Highlights:\s*$/m)[1]?.trim(); const highlights = block.split(/^Highlights:\s*$/m)[1]?.trim();
const snippet = capSnippet(highlights, maxSnippetLength);
sources.push({ sources.push({
url, url,
...(title ? { title } : {}), ...(title ? { title } : {}),
...(highlights ? { snippet: highlights.slice(0, 500) } : {}), ...(snippet ? { snippet } : {}),
...(published && published !== 'N/A' ? { publishedAt: published } : {}), ...(published && published !== 'N/A' ? { publishedAt: published } : {}),
}); });
} }
return sources; return sources;
} }
/**
* 自定义上游:`POST {base}/search`,body `{ query, max_results }`。
* 配置了地址就以它为准——失败直接抛错,不静默退回免费后端(否则 key 过期/base 写错
* 只会表现为「结果质量突然变差」,永远没人发现)。
* @param {{ auth: string, base: string }} up 由 mcp.js 从请求 header 解析(容器不存密钥)
* @param {number} [maxSnippetLength] 调用方要求的最大 snippet 长度;缺省不截断
*/
export async function customSearch(query, maxResults, up, maxSnippetLength) {
const url = up.base.replace(/\/+$/, '') + '/search';
const headers = {
'content-type': 'application/json',
'accept': 'application/json',
'user-agent': USER_AGENT,
};
// 免鉴权的自建服务可省;有值才带,避免给上游塞一个空 Authorization 反而被拒
if (up.auth) headers.authorization = up.auth;
let response;
try {
response = await fetch(url, {
method: 'POST',
// 不跟随跳转:Authorization 不能被顺手带到别的地址去
redirect: 'error',
headers,
body: JSON.stringify({ query, max_results: maxResults }),
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
} catch (error) {
throw new Error(`搜索上游请求失败(${url}):${String(error && error.message || error)}`);
}
const raw = await response.text();
if (!response.ok) {
// 带上游响应片段:401 和 500 的处置完全不同,只说「请求失败」没法排查
const detail = capSnippet(raw, 200);
throw new Error(`搜索上游 HTTP ${response.status}${detail ? ':' + detail : ''}`);
}
let payload;
try {
payload = JSON.parse(raw);
} catch (error) {
throw new Error(`搜索上游返回了无法解析的响应:${String(error)}`);
}
const sources = [];
for (const item of payload.results ?? []) {
if (!item || !item.url) continue;
const snippet = capSnippet(item.snippet, maxSnippetLength);
const publishedAt = item.published_at ?? item.publishedAt ?? item.publish_date;
sources.push({
url: String(item.url),
...(item.title ? { title: String(item.title) } : {}),
...(snippet ? { snippet } : {}),
...(publishedAt ? { publishedAt: String(publishedAt) } : {}),
});
}
return maxResults !== undefined ? sources.slice(0, maxResults) : sources;
}
/** Parallel 搜索(默认免费后端)。 */ /** Parallel 搜索(默认免费后端)。 */
export async function parallelSearch(query, maxResults) { export async function parallelSearch(query, maxResults, maxSnippetLength) {
const text = await callMcpTool(PARALLEL_MCP_URL, 'web_search', { const text = await callMcpTool(PARALLEL_MCP_URL, 'web_search', {
objective: query, objective: query,
search_queries: [query], search_queries: [query],
}, AbortSignal.timeout(REQUEST_TIMEOUT_MS)); }, AbortSignal.timeout(REQUEST_TIMEOUT_MS));
const sources = mapParallelResponse(text); const sources = mapParallelResponse(text, maxSnippetLength);
return maxResults !== undefined ? sources.slice(0, maxResults) : sources; return maxResults !== undefined ? sources.slice(0, maxResults) : sources;
} }
/**
* 免费侧入口:Parallel 优先,失败自动退 Exa。
* 降级放在服务端(而不是让模型显式传 provider)——模型看不到后端,也就不会选错。
* @param {string} [exaApiKey] 可选,提升 Exa 匿名限额
* @param {number} [maxSnippetLength] 缺省不截断
*/
export async function freeSearch(query, maxResults, exaApiKey, maxSnippetLength) {
try {
return await parallelSearch(query, maxResults, maxSnippetLength);
} catch (first) {
try {
return await exaSearch(query, maxResults, exaApiKey, maxSnippetLength);
} catch (second) {
throw new Error(`免费搜索后端均不可用(parallel: ${String(first && first.message || first)};` +
`exa: ${String(second && second.message || second)})`);
}
}
}
/** Exa 搜索(备用免费后端;apiKey 可选,用于提升匿名限额)。 */ /** Exa 搜索(备用免费后端;apiKey 可选,用于提升匿名限额)。 */
export async function exaSearch(query, maxResults, apiKey) { export async function exaSearch(query, maxResults, apiKey, maxSnippetLength) {
const endpoint = apiKey const endpoint = apiKey
? `${EXA_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}` ? `${EXA_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}`
: EXA_MCP_URL; : EXA_MCP_URL;
@@ -145,6 +239,6 @@ export async function exaSearch(query, maxResults, apiKey) {
numResults: maxResults ?? 8, numResults: maxResults ?? 8,
livecrawl: 'fallback', livecrawl: 'fallback',
}, AbortSignal.timeout(REQUEST_TIMEOUT_MS)); }, AbortSignal.timeout(REQUEST_TIMEOUT_MS));
const sources = parseExaText(text); const sources = parseExaText(text, maxSnippetLength);
return maxResults !== undefined ? sources.slice(0, maxResults) : sources; return maxResults !== undefined ? sources.slice(0, maxResults) : sources;
} }
+59 -16
View File
@@ -2,34 +2,59 @@
* MCP(Model Context Protocol)协议层:工具清单 + JSON-RPC 分发。 * MCP(Model Context Protocol)协议层:工具清单 + JSON-RPC 分发。
* *
* 与传输无关(stdio / HTTP 都在 server.js 里),只负责把一条 JSON-RPC * 与传输无关(stdio / HTTP 都在 server.js 里),只负责把一条 JSON-RPC
* 消息变成 JSON-RPC 响应。支持的 method 与上游 dsh-web-search-free 一致: * 消息变成 JSON-RPC 响应。支持的 method:initialize / tools/list / tools/call / ping。
* initialize / tools/list / tools/call / ping。 *
* 上游参数逐请求从 HTTP header 取(与 mcp/asr、mcp/image_task 同构):
* X-Web-Search-Base-Url: https://<host>/v1 → 打 {base}/search(配了就用它,不降级)
* Authorization: Bearer <key> → 可选,裸 key 自动补 Bearer
* 两者都不配 = 内置免费后端(Parallel → Exa)。stdio 模式没有 header,因此只有免费后端。
*/ */
import { parallelSearch, exaSearch } from './core.js'; import { customSearch, freeSearch } from './core.js';
export const SERVER_NAME = 'web_search'; export const SERVER_NAME = 'web_search';
export const VERSION = '1.0.0'; export const VERSION = '1.1.0';
const DEFAULT_PROTOCOL = '2025-03-26'; const DEFAULT_PROTOCOL = '2025-03-26';
const HDR_AUTH = 'authorization';
const HDR_BASE = 'x-web-search-base-url';
/** 暴露给 MCP 客户端的工具清单。 */ /** 暴露给 MCP 客户端的工具清单。 */
const TOOLS = [ const TOOLS = [
{ {
name: 'web_search', name: 'web_search',
description: 'Free web search tool. Uses Parallel by default or Exa as fallback. Returns an array of results with title, url, snippet, and publishedAt.', description: 'Search the web. Returns results with title, url, snippet and (when available) publishedAt.',
inputSchema: { inputSchema: {
type: 'object', type: 'object',
properties: { properties: {
query: { type: 'string', description: 'Search query text' }, query: { type: 'string', description: 'Search query text' },
provider: { type: 'string', enum: ['parallel', 'exa'], description: "Backend provider: 'parallel' (default) or 'exa' (fallback)" },
numResults: { type: 'integer', minimum: 1, default: 8, description: 'Maximum number of results to return (default 8)' }, numResults: { type: 'integer', minimum: 1, default: 8, description: 'Maximum number of results to return (default 8)' },
maxSnippetLength: { type: 'integer', minimum: 1, description: 'Truncate each snippet to this many characters (default: keep full text)' },
}, },
required: ['query'], required: ['query'],
}, },
}, },
]; ];
/** 执行一次 tools/call;失败时抛 { code, message } 表示工具级错误。 */ /** 从请求 header 取上游两要素;Authorization 允许写裸 key(自动补 Bearer)。 */
async function callTool(name, args) { function upstreamOf(headers) {
const h = headers || {};
const raw = String(h[HDR_AUTH] || '').trim();
return {
auth: raw ? (/^bearer\s/i.test(raw) ? raw : 'Bearer ' + raw) : '',
base: String(h[HDR_BASE] || '').trim().replace(/\/+$/, ''),
};
}
/** 配了地址就必须是完整 http(s):不能是相对路径,也不能把 key 发到别的协议上。 */
function assertBase(base) {
let u = null;
try { u = new URL(base); } catch (_) { u = null; }
if (!u || (u.protocol !== 'http:' && u.protocol !== 'https:')) {
throw new Error('X-Web-Search-Base-Url 必须是完整的 http(s) 地址,如 https://<host>/v1');
}
}
/** 执行一次 tools/call;失败时抛 { code, message } 表示协议级错误。 */
async function callTool(name, args, headers) {
if (name !== 'web_search') throw { code: -32602, message: `unknown tool: ${name}` }; if (name !== 'web_search') throw { code: -32602, message: `unknown tool: ${name}` };
const params = args ?? {}; const params = args ?? {};
@@ -38,20 +63,36 @@ async function callTool(name, args) {
: null; : null;
if (query === null) throw { code: -32602, message: 'query is required' }; if (query === null) throw { code: -32602, message: 'query is required' };
const provider = params.provider === 'exa' ? 'exa' : 'parallel';
const numResults = typeof params.numResults === 'number' && Number.isFinite(params.numResults) const numResults = typeof params.numResults === 'number' && Number.isFinite(params.numResults)
? Math.max(1, Math.floor(params.numResults)) ? Math.max(1, Math.floor(params.numResults))
: 8; : 8;
// 截断是调用方的选择:不传就原样返回整段 snippet(上游可能给整篇正文,由调用方自己控上下文)
const rawMaxLen = Number(params.maxSnippetLength);
const maxSnippetLength = Number.isFinite(rawMaxLen) && rawMaxLen >= 1 ? Math.floor(rawMaxLen) : undefined;
const sources = provider === 'exa' const up = upstreamOf(headers);
? await exaSearch(query, numResults, process.env.EXA_API_KEY) let sources;
: await parallelSearch(query, numResults); try {
if (up.base) {
assertBase(up.base);
sources = await customSearch(query, numResults, up, maxSnippetLength);
} else {
sources = await freeSearch(query, numResults, process.env.EXA_API_KEY, maxSnippetLength);
}
} catch (error) {
// 工具级错误回文本、协议层仍成功:模型能读懂并换查询/换工具,
// 回 JSON-RPC error 只会被 core 拼成「调用失败」,模型反而不好自纠。
return {
isError: true,
content: [{ type: 'text', text: 'Error: ' + String(error && error.message || error) }],
};
}
return { content: [{ type: 'text', text: JSON.stringify(sources, null, 2) }] }; return { content: [{ type: 'text', text: JSON.stringify(sources, null, 2) }] };
} }
/** 处理一条请求消息,返回 result;失败时抛 { code, message }。 */ /** 处理一条请求消息,返回 result;失败时抛 { code, message }。 */
async function handleRequest(message) { async function handleRequest(message, headers) {
switch (message.method) { switch (message.method) {
case 'initialize': case 'initialize':
return { return {
@@ -62,7 +103,7 @@ async function handleRequest(message) {
case 'tools/list': case 'tools/list':
return { tools: TOOLS }; return { tools: TOOLS };
case 'tools/call': case 'tools/call':
return callTool(message.params?.name, message.params?.arguments); return callTool(message.params?.name, message.params?.arguments, headers);
case 'ping': case 'ping':
return {}; return {};
default: default:
@@ -72,9 +113,11 @@ async function handleRequest(message) {
/** /**
* 解析并执行一条 JSON 消息。 * 解析并执行一条 JSON 消息。
* @param {string} raw JSON-RPC 文本
* @param {object} [headers] 本次 HTTP 请求的 header(stdio 模式没有,上游参数就走免费后端)
* @returns 响应信封对象;notification(无 id)返回 null;非法 JSON 返回 undefined。 * @returns 响应信封对象;notification(无 id)返回 null;非法 JSON 返回 undefined。
*/ */
export async function dispatch(raw) { export async function dispatch(raw, headers) {
let message; let message;
try { try {
message = JSON.parse(raw); message = JSON.parse(raw);
@@ -83,7 +126,7 @@ export async function dispatch(raw) {
} }
if (message.id === undefined) return null; // 通知不响应 if (message.id === undefined) return null; // 通知不响应
try { try {
return { jsonrpc: '2.0', id: message.id, result: await handleRequest(message) }; return { jsonrpc: '2.0', id: message.id, result: await handleRequest(message, headers) };
} catch (error) { } catch (error) {
const e = error; const e = error;
return { return {
+2 -2
View File
@@ -1,8 +1,8 @@
{ {
"name": "web_search", "name": "web_search",
"version": "1.0.0", "version": "1.1.0",
"private": true, "private": true,
"description": "Free web search tool. Uses Parallel by default or Exa as fallback.", "description": "Web search tool. Uses a caller-provided /search endpoint when configured, otherwise free Parallel / Exa backends.",
"license": "MIT", "license": "MIT",
"type": "module", "type": "module",
"main": "server.js", "main": "server.js",
+9 -2
View File
@@ -1,16 +1,22 @@
#!/usr/bin/env node #!/usr/bin/env node
/** /**
* MCP server 入口 —— 免费网页搜索(Parallel 默认 / Exa 备用,匿名免 key)。 * MCP server 入口 —— 网页搜索(自定义 /search 上游,或内置免费 Parallel / Exa)。
* *
* 本地重构版(上游:@sheep233_/dsh-web-search-free),零运行时依赖,直接 node 启动。 * 本地重构版(上游:@sheep233_/dsh-web-search-free),零运行时依赖,直接 node 启动。
* *
* ## 双传输 * ## 双传输
* - **stdio**(默认):`node server.js` * - **stdio**(默认):`node server.js`
* - `claude mcp add web_search -- node <路径>/server.js` * - `claude mcp add web_search -- node <路径>/server.js`
* - 没有 HTTP header,因此只能用内置免费后端
* - **HTTP/SSE**(监听端口):`node server.js --http --port 3000 --host 0.0.0.0` * - **HTTP/SSE**(监听端口):`node server.js --http --port 3000 --host 0.0.0.0`
* - 兼容 Streamable HTTP(`POST /`)与老式 SSE(`GET /sse` + `POST /messages`) * - 兼容 Streamable HTTP(`POST /`)与老式 SSE(`GET /sse` + `POST /messages`)
* - `GET /` 或 `GET /health` 返回服务信息,可做健康检查 * - `GET /` 或 `GET /health` 返回服务信息,可做健康检查
* *
* 上游参数逐请求从 HTTP header 取(与 mcp/asr、mcp/image_task 同构,容器不存密钥):
* X-Web-Search-Base-Url: https://<host>/v1 → 打 {base}/search
* Authorization: Bearer <key> → 可选,裸 key 自动补 Bearer
* 两者都不配 = 免费后端。
*
* 环境变量:EXA_API_KEY(可选,提升 Exa 匿名限额);SEARCH_TIMEOUT_MS(可选,上游超时)。 * 环境变量:EXA_API_KEY(可选,提升 Exa 匿名限额);SEARCH_TIMEOUT_MS(可选,上游超时)。
*/ */
import { createInterface } from 'node:readline'; import { createInterface } from 'node:readline';
@@ -88,7 +94,8 @@ function runHttp(host, port) {
let body = ''; let body = '';
req.on('data', (chunk) => { body += chunk.toString(); }); req.on('data', (chunk) => { body += chunk.toString(); });
req.on('end', () => { req.on('end', () => {
void dispatch(body).then((response) => { // header 必须随消息带进协议层:上游地址 / 鉴权都是逐请求带入的(容器不存密钥)
void dispatch(body, req.headers).then((response) => {
if (response === null) { // 通知 if (response === null) { // 通知
res.writeHead(202).end(); res.writeHead(202).end();
return; return;
+107 -251
View File
@@ -1,280 +1,136 @@
#!/bin/bash #!/bin/bash
# init.sh — 生成 .env 与 config.yml。 # init.sh — 首次部署准备:生成 .env、探测公网地址、创建初始管理员。幂等。
# #
# 只读环境变量,不依赖任何外部文件;**全部可选**,什么都不给也能直接跑。 # ./scripts/init.sh # 已有 .env / config.yml 均不覆盖
# #
# 用法: # 可选变量:PUBLIC_IP、AGENT_PORT、AUTH_USER / AUTH_PASSWORD(默认 admin / admin)、
# ./scripts/init.sh # 全用默认值(无模型、admin/admin) # EXECUTOR_TOKEN / WXBOT_TOKEN / AUTH_SECRET(不给则生成并复用)。
# BIGMODEL_KEY=xxx AUTH_USER=me ./scripts/init.sh # 给几个变量就行
# ./scripts/init.sh --env-only # 只刷新 .env 密钥(幂等,不碰 config.yml)
#
# 输入(都可选):
# BIGMODEL_KEY / DEEPSEEK_KEY / QWEN_KEY 模型平台 key,填几个启用几个(0~3 个)
# image_task / video_task / asr 复用 BIGMODEL_KEY(智谱即 BigModel);
# 未配 BIGMODEL_KEY 时这三个服务写为 mode: disable
# AUTH_USER / AUTH_PASSWORD 登录账号(默认 admin / admin,请自行改掉)
# PUBLIC_IP / AGENT_PORT 对外地址与端口,写进 public_link.base_url;
# PUBLIC_IP 不配置则自动探测公网 IP
# AUTH_SECRET / EXECUTOR_TOKEN / WXBOT_TOKEN 一般不用给:不给就自动生成并复用(见下)
# ASR_API_KEY 语音识别(mcp_asr)的上游 key;不给则复用 BIGMODEL_KEY,
# 已有 .env 里的值优先(语音输入只是可选能力,留空不影响主流程)
#
# 微信接入(wxbot 已合入根 compose,作为栈内服务):本脚本只负责生成/复用根 .env 的 WXBOT_TOKEN;
# wxbot 自身零配置文件(compose 注 env + 内置默认,同 executor 模式),无需任何同步动作。
#
# config.yml 只写 deploy 相关的段:platforms / auth / mcp_servers / public_link;
# 其余配置项一律走 server/config.js 的 DEFAULTS(完整清单见 app/config.example.yml)。
#
# ⚠️ config.yml 是本脚本的生成物,不要手改(每次生成前会把旧的备份为 config.yml.bak.<时间戳>)。
set -euo pipefail set -euo pipefail
# ============================================================
# 路径与默认值
# ============================================================
REPO_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" REPO_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$REPO_DIR" cd "$REPO_DIR"
# 支持 --env-only 参数:只刷 .env 密钥(幂等,绝不碰 config.yml)
if [ "${1:-}" = "--env-only" ]; then ENV_ONLY=1; fi
CONFIG_YML="$REPO_DIR/config.yml"
ENV_FILE="$REPO_DIR/.env" ENV_FILE="$REPO_DIR/.env"
CONFIG_YML="$REPO_DIR/config.yml"
BIGMODEL_KEY="${BIGMODEL_KEY:-}" PUBLIC_IP="${PUBLIC_IP:-}"
DEEPSEEK_KEY="${DEEPSEEK_KEY:-}" PORT_INPUT="${AGENT_PORT:-}"
QWEN_KEY="${QWEN_KEY:-}"
AUTH_USER="${AUTH_USER:-admin}" AUTH_USER="${AUTH_USER:-admin}"
AUTH_PASSWORD="${AUTH_PASSWORD:-admin}" AUTH_PASSWORD="${AUTH_PASSWORD:-admin}"
PUBLIC_IP="${PUBLIC_IP:-}"
# 记住用户是否显式给了端口(下面 .env 复用逻辑不能踩掉显式传参)
AGENT_PORT_INPUT="${AGENT_PORT:-}"
AGENT_PORT="${AGENT_PORT_INPUT:-8090}"
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-}"
AUTH_SECRET="${AUTH_SECRET:-}"
# 微信接入服务 token(core ↔ wxbot 双向共用,compose 两侧同值注入;wxbot 已并入仓库)
WXBOT_TOKEN="${WXBOT_TOKEN:-}"
# 语音识别(mcp_asr)的上游 key:独立于模型平台 key,但默认复用 BIGMODEL_KEY(智谱 glm-asr)
ASR_API_KEY="${ASR_API_KEY:-}"
log() { echo -e "\n\033[1;32m===== $* =====\033[0m"; } info() { echo -e "\033[1;36m[INFO]\033[0m $*"; }
info() { echo -e "\033[1;36m[INFO]\033[0m $*"; } warn() { echo -e "\n\033[1;33m[WARN]\033[0m $*"; }
warn() { echo -e "\n\033[1;33m[WARN]\033[0m $*"; } title() { echo -e "\n\033[1;32m===== $* =====\033[0m"; }
gen_hex() { # $1 = 字节数(默认 32) gen_hex() {
local n="${1:-32}"
if command -v openssl >/dev/null 2>&1; then if command -v openssl >/dev/null 2>&1; then
openssl rand -hex "$n" openssl rand -hex 32
else else
head -c "$n" /dev/urandom | od -An -tx1 | tr -d ' \n' head -c 32 /dev/urandom | od -An -tx1 | tr -d ' \n'
fi fi
} }
# ============================================================ env_get() {
# 1. 生成 .env(密钥只生成一次,之后复用 → 重跑不掉登录态、不改 executor token) [ -f "$ENV_FILE" ] || return 0
# ============================================================ awk -F= -v k="$1" '$1==k { sub(/^[^=]*=/, ""); print; exit }' "$ENV_FILE" || true
log "生成 $ENV_FILE"
if [ -f "$ENV_FILE" ]; then
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(sed -n 's/^EXECUTOR_TOKEN=//p' "$ENV_FILE" | head -1)}"
AUTH_SECRET="${AUTH_SECRET:-$(sed -n 's/^AUTH_SECRET=//p' "$ENV_FILE" | head -1)}"
WXBOT_TOKEN="${WXBOT_TOKEN:-$(sed -n 's/^WXBOT_TOKEN=//p' "$ENV_FILE" | head -1)}"
# ASR_API_KEY 同理复用:手填的 key 不会被重跑抹掉
ASR_API_KEY="${ASR_API_KEY:-$(sed -n 's/^ASR_API_KEY=//p' "$ENV_FILE" | head -1)}"
# AGENT_PORT 同理复用:避免不带参数重跑时把部署机自定义端口重置回 8090(显式传参优先)
AGENT_PORT="${AGENT_PORT_INPUT:-$(sed -n 's/^AGENT_PORT=//p' "$ENV_FILE" | head -1)}"
AGENT_PORT="${AGENT_PORT:-8090}"
fi
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(gen_hex 32)}"
AUTH_SECRET="${AUTH_SECRET:-$(gen_hex 32)}"
WXBOT_TOKEN="${WXBOT_TOKEN:-$(gen_hex 32)}"
ASR_API_KEY="${ASR_API_KEY:-$BIGMODEL_KEY}"
cat > "$ENV_FILE" <<EOF
# 本文件由 scripts/init.sh 生成,勿手改(改配置请重新运行该脚本,或用环境变量覆盖)
# EXECUTOR_TOKEN: core 与 executor 之间的调用鉴权(两侧同值,compose 注入)
# AUTH_SECRET: 登录态签名密钥(写进 config.yml 的 auth.secret)
# WXBOT_TOKEN: core ↔ wxbot 微信接入服务 token(compose 注入两侧;wxbot 零配置文件,env 即全部接线)
# ASR_API_KEY: 语音识别(mcp_asr)的上游 key,空 = 语音输入关闭;默认复用 BIGMODEL_KEY
# AGENT_PORT: agent-core 映射到宿主机的端口
EXECUTOR_TOKEN=$EXECUTOR_TOKEN
AUTH_SECRET=$AUTH_SECRET
WXBOT_TOKEN=$WXBOT_TOKEN
ASR_API_KEY=$ASR_API_KEY
AGENT_PORT=$AGENT_PORT
EOF
info "EXECUTOR_TOKEN / AUTH_SECRET / WXBOT_TOKEN 已就位(沿用已有 .env 的值,没有则新生成);ASR_API_KEY $([ -n "$ASR_API_KEY" ] && echo 已配置 || echo 为空(语音输入关闭))"
# --env-only:只刷密钥,绝不碰 config.yml(平台 key 不在 .env 里,重跑全量会清空已部署配置)
if [ "${ENV_ONLY:-}" = "1" ]; then
log "完成 ✅(--env-only:未改动 config.yml)"
exit 0
fi
# PUBLIC_IP 兜底:只有没给时才去探测(探测不到只告警,不影响启动,只是图生视频用不了)
if [ -z "$PUBLIC_IP" ]; then
for u in https://ifconfig.me https://api.ipify.org; do
if command -v curl >/dev/null 2>&1; then
PUBLIC_IP="$(curl -fsS --max-time 5 "$u" 2>/dev/null || true)"
[ -n "$PUBLIC_IP" ] && break
fi
done
fi
if [ -z "$PUBLIC_IP" ]; then
warn "没给 PUBLIC_IP 也探测不到:public_link 不生效(需要外部服务来取文件的场景用不了)。"
warn "设置后重跑即可: PUBLIC_IP=<公网IP> $0"
fi
# ============================================================
# 2. 生成 config.yml(只写 platforms / auth / mcp_servers / public_link)
# ============================================================
log "生成 $CONFIG_YML"
if [ -f "$CONFIG_YML" ]; then
cp "$CONFIG_YML" "$CONFIG_YML.bak.$(date +%s)"
info "旧 config.yml 已备份为 config.yml.bak.<时间戳>"
fi
# 单个平台骨架(url / 模型 / 参数固定,只有 key 来自变量)
emit_platform() {
case "$1" in
bigmodel)
cat <<EOF
- name: bigmodel
url: https://open.bigmodel.cn/api/paas/v4
keys:
- api_key: "$2"
models:
- id: glm-5.3-flash
vision: true
extra_params: { reasoning_effort: "low", tool_stream: true }
thinking_params: { reasoning_effort: "max" }
EOF
;;
deepseek)
cat <<EOF
- name: deepseek
url: https://api.deepseek.com
keys:
- api_key: "$2"
models:
- id: deepseek-flash
vision: true
extra_params: { thinking: { type: "disabled" } }
thinking_params: { thinking: { type: "enabled" }, reasoning_effort: "max" }
EOF
;;
qwen)
cat <<EOF
- name: qwen
url: https://dashscope.aliyuncs.com/compatible-mode/v1
keys:
- api_key: "$2"
models:
- id: qwen3.8-flash
vision: true
extra_params: { enable_thinking: false }
thinking_params: { enable_thinking: true, reasoning_effort: "xhigh" }
EOF
;;
esac
} }
enabled_plats=() yaml_q() {
if [ -n "$BIGMODEL_KEY" ]; then enabled_plats+=("bigmodel"); fi local s="${1//\\/\\\\}"
if [ -n "$DEEPSEEK_KEY" ]; then enabled_plats+=("deepseek"); fi s="${s//\"/\\\"}"
if [ -n "$QWEN_KEY" ]; then enabled_plats+=("qwen"); fi printf '"%s"' "$s"
}
detect_public_ip() {
command -v curl >/dev/null 2>&1 || return 0
local u ip
for u in https://ifconfig.me https://api.ipify.org; do
ip="$(curl -fsS --max-time 5 "$u" 2>/dev/null || true)"
if [ -n "$ip" ]; then printf '%s' "$ip"; return 0; fi
done
}
# ---------- .env ----------
title "生成 $ENV_FILE"
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(env_get EXECUTOR_TOKEN)}"
WXBOT_TOKEN="${WXBOT_TOKEN:-$(env_get WXBOT_TOKEN)}"
AUTH_SECRET="${AUTH_SECRET:-$(env_get AUTH_SECRET)}"
AGENT_PORT="${PORT_INPUT:-$(env_get AGENT_PORT)}"
AGENT_PORT="${AGENT_PORT:-8090}"
OLD_URL="$(env_get PUBLIC_BASE_URL)"
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(gen_hex)}"
WXBOT_TOKEN="${WXBOT_TOKEN:-$(gen_hex)}"
AUTH_SECRET="${AUTH_SECRET:-$(gen_hex)}"
if [ -n "$PUBLIC_IP" ]; then
PUBLIC_BASE_URL="http://$PUBLIC_IP:$AGENT_PORT"
elif [ -n "$OLD_URL" ]; then
# 显式改端口时只换端口,保留原协议与主机
if [ -n "$PORT_INPUT" ]; then
PUBLIC_BASE_URL="$(printf '%s' "$OLD_URL" | sed -E "s#^(https?://[^/:]+)(:[0-9]+)?#\1:$AGENT_PORT#")"
else
PUBLIC_BASE_URL="$OLD_URL"
fi
else
DETECTED_IP="$(detect_public_ip)"
PUBLIC_BASE_URL="${DETECTED_IP:+http://$DETECTED_IP:$AGENT_PORT}"
if [ -z "$PUBLIC_BASE_URL" ]; then
warn "未探测到公网 IP,PUBLIC_BASE_URL 留空(可设 PUBLIC_IP 后重跑)"
fi
fi
EXTRAS=""
if [ -f "$ENV_FILE" ]; then
EXTRAS="$(awk -F= '/^[A-Za-z_][A-Za-z0-9_]*=/ &&
$1 !~ /^(EXECUTOR_TOKEN|WXBOT_TOKEN|AUTH_SECRET|AGENT_PORT|PUBLIC_BASE_URL)$/ { print }' \
"$ENV_FILE" || true)"
fi
{ {
echo "# 本文件由 scripts/init.sh 生成,请勿手改!" echo "# 由 scripts/init.sh 生成;重跑复用已有密钥,并保留其它变量。"
echo "# 只含 deploy 相关段(platforms / auth / mcp_servers / public_link),其余走 server/config.js 默认值。" echo "EXECUTOR_TOKEN=$EXECUTOR_TOKEN"
echo "# 生成时间: $(date '+%Y-%m-%d %H:%M:%S')" echo "WXBOT_TOKEN=$WXBOT_TOKEN"
echo "# 已启用平台: ${enabled_plats[*]:-(无)}" echo "AUTH_SECRET=$AUTH_SECRET"
echo echo "AGENT_PORT=$AGENT_PORT"
echo "PUBLIC_BASE_URL=$PUBLIC_BASE_URL"
if [ "${#enabled_plats[@]}" -eq 0 ]; then if [ -n "$EXTRAS" ]; then
echo "platforms: [] # 没有配置平台 key(BIGMODEL_KEY / DEEPSEEK_KEY / QWEN_KEY)" echo
else printf '%s\n' "$EXTRAS"
echo "platforms:"
if [ -n "$BIGMODEL_KEY" ]; then emit_platform bigmodel "$BIGMODEL_KEY"; fi
if [ -n "$DEEPSEEK_KEY" ]; then emit_platform deepseek "$DEEPSEEK_KEY"; fi
if [ -n "$QWEN_KEY" ]; then emit_platform qwen "$QWEN_KEY"; fi
fi fi
echo } > "$ENV_FILE"
cat <<EOF info "EXECUTOR_TOKEN / WXBOT_TOKEN / AUTH_SECRET 已就位"
# ---------- config.yml(只写初始管理员)----------
title "检查 $CONFIG_YML"
if [ -d "$CONFIG_YML" ]; then
rmdir "$CONFIG_YML" 2>/dev/null || { warn "config.yml 是非空目录,请先处理:$CONFIG_YML"; exit 1; }
info "已删除被误建的空目录"
fi
CREATED=0
if [ -f "$CONFIG_YML" ]; then
info "已存在,跳过"
else
cat > "$CONFIG_YML" <<EOF
auth: auth:
secret: "$AUTH_SECRET" secret: $(yaml_q "$AUTH_SECRET")
users: users:
- user: $AUTH_USER - user: $(yaml_q "$AUTH_USER")
password: "$AUTH_PASSWORD" password: $(yaml_q "$AUTH_PASSWORD")
role: admin # 初始账号为管理员;其余用户的增删/角色/默认模型在前端「设置→用户」里配 role: admin
mcp_servers:
- name: web_search
url: "http://mcp_web_search:3000/"
EOF EOF
info "已创建,初始管理员 $AUTH_USER"
CREATED=1
fi
if [ -n "$BIGMODEL_KEY" ]; then # ---------- 汇总 ----------
cat <<EOF title "汇总"
- name: image_task echo " 访问地址 : ${PUBLIC_BASE_URL:-(未设置)}"
url: "http://mcp_image_task:3000/mcp" if [ "$CREATED" = "1" ]; then
headers: echo " 初始账号 : $AUTH_USER${AUTH_PASSWORD:+ / }$([ "$AUTH_PASSWORD" = "admin" ] && echo 'admin(登录后请修改)' || echo '<AUTH_PASSWORD 传入值>')"
Authorization: "Bearer $BIGMODEL_KEY" fi
mode: skill # 不下发给模型,以技能形式暴露(skill 工具里 list/get/run) echo " 下一步 : docker compose up -d --build"
- name: video_task
url: "http://mcp_video_task:3000/mcp"
headers:
Authorization: "Bearer $BIGMODEL_KEY"
mode: skill
EOF
else
cat <<'EOF'
- name: image_task
url: "http://mcp_image_task:3000/mcp"
mode: disable # 未配 BIGMODEL_KEY:不连接、不发现;补上 key 后重跑本脚本
- name: video_task
url: "http://mcp_video_task:3000/mcp"
mode: disable # 未配 BIGMODEL_KEY:不连接、不发现;补上 key 后重跑本脚本
EOF
fi
# 语音转写:key 在容器 env(ASR_API_KEY),不经 headers,所以单独按 ASR_API_KEY 判断
if [ -n "$ASR_API_KEY" ]; then
cat <<'EOF'
- name: asr
url: "http://mcp_asr:3000/mcp"
mode: skill # 语音转写是低频能力,不下发到每轮工具表
EOF
else
cat <<'EOF'
- name: asr
url: "http://mcp_asr:3000/mcp"
mode: disable # 未配 ASR_API_KEY:不连接、不发现
EOF
fi
echo
cat <<EOF
# 给外部服务(如智谱)现签公网临时链接用;改地址后重跑本脚本
public_link:
base_url: "${PUBLIC_IP:+http://$PUBLIC_IP:$AGENT_PORT}"
EOF
} > "$CONFIG_YML"
info "平台: ${enabled_plats[*]:-无};图像/视频 MCP: $([ -n "$BIGMODEL_KEY" ] && echo 启用 || echo 未配置(mode: disable))"
# ============================================================
# 3. 汇总
# ============================================================
log "汇总"
echo "---------------------------------------------"
echo " 访问地址 : http://${PUBLIC_IP:-<公网IP>}:${AGENT_PORT}"
echo " 账号 : $AUTH_USER"
echo " 密码 : $AUTH_PASSWORD"
echo " 平台 : ${enabled_plats[*]:-(无)}"
echo " 图像/视频: $([ -n "$BIGMODEL_KEY" ] && echo "image_task / video_task 已启用" || echo "未配置(mode: disable)")"
echo " 语音输入 : $([ -n "$ASR_API_KEY" ] && echo "mcp_asr 已启用" || echo "未配置(ASR_API_KEY 为空)")"
echo " MCP 服务 : web_search / image_task / video_task / asr(同栈,随 compose 启动)"
echo " 微信接入 : WXBOT_TOKEN 已就位(compose 注入 core 与 wxbot 两侧;wxbot 无需配置文件)"
echo "---------------------------------------------"
log "完成 ✅"
+1 -2
View File
@@ -359,8 +359,7 @@ print_next_steps() {
备注: 备注:
- 上面若提示需要重启(内核/核心库更新),建议先 reboot,再执行第 ③ 步 - 上面若提示需要重启(内核/核心库更新),建议先 reboot,再执行第 ③ 步
- init.sh 可重复执行:.env 里的密钥复用,config.yml 会先备份为 .bak.<时间戳> - init.sh 可重复执行:已有的 .env 与 config.yml 都不会被覆盖
- 只刷新密钥、不动配置:./scripts/init.sh --env-only
EOF EOF
} }
+118
View File
@@ -0,0 +1,118 @@
# CHANGELOG
本文件记录 `document-photo-to-pdf` 的改造历史。对外接口(`SKILL.md` 里的
`images` / `output` 参数、审核页、返回结构)**未变**,仅检测内部实现有改动。
---
## 2026-10-24 · 纸张检测修复(基于原 skill 基线)
### 背景
原实现在真实拍摄的照片上,`detect()` 返回的角点大面积不可信,`validate()` 判失败后
整框被替换成「画面内缩 3% 的兜底矩形」,等于把整张照片塞进 PDF。两个典型样本:
| 场景 | 原检测角点 (px) | 失效原因 |
|---|---|---|
| 白纸卡(蓝花布背景) | (464,136) (824,103) (893,1824) (158,2011) | 掩膜把蓝布并进纸面(`paper_frac=0.64`),拟合出的“纸边”其实是照片边框;校验报上/右/下三边内侧混入桌面 |
| 词典封面(塑料袋台面) | (152,1898) (1325,1053) (91,3008) (100,3016) | 白书封与塑料袋亮度接近、连通成一片,四边形不满足凸性,右下与左下相距仅 12px |
根因是四层:阈值硬编码未标定 → 形态学只有闭运算、把高光连进纸面 → 角点用“四方向极值点”
在圆角/毛刺下退化成病态求交 → 校验失败后一票否决整框丢弃。
### 变更
**1. 掩膜改为多候选打分**(`params.detect.mask_ladder`、`auto_quad.paper_masks`)
原实现用一组固定阈值 `V>0.50, S<0.45`,实测 Otsu 算出 0.471/0.498 均被
`paper_otsu_floor=0.50` 顶成 0.500。改为跑 6 组候选,按 solidity、最小外接矩形填充率、
贴边程度、宽高比打分选最优。
**2. 掩膜收敛加开运算**(`auto_quad._mask_from_bright`)
原来只有闭运算,布面高光斑点会被“连”到纸上,把最小外接矩形撑大。加开运算后两个样本的
`rect_fill` 从 0.51/0.86 升到 0.94/0.86,`solidity` 升到 0.99/0.94。
同时把「开→闭→填→取最大→再开→再闭→再填」的 8 次形态学收敛为 4 次
(闭运算幂等,取最大连通域后已无细小碎块),单候选 0.3 s → 0.15 s。
**3. 四角拟合改用最小外接矩形做初始四边形**(`min_area_rect` / `order_quad` / `quad_ok`)
原来的“四方向极值点当锚点”,在纸张有圆角、掩膜有毛刺时会把四个锚点挤到同一段弧上,
相邻两边近似平行,求交得到病态角点。改用凸包 + 旋转卡壳求最小外接矩形,天然凸、天然有序。
**4. 四边形按 IoU 择优**(`quad_iou`、`detect_quad_corners`)
**不要**在收紧结果上设“与矩形的夹角 / 角点位移上限”。真实拍摄的纸张是**梯形**,
左右两边本来就该一边内收、一边外放;用矩形先验当门槛会把透视关系判成错误,
最后退回成平行四边形(现象:角点能落在大致位置,但丢掉了变形)。
改为在三个候选里按与纸面掩膜的 IoU 选优:
| 候选 | 样本 A IoU | 样本 B IoU |
|---|---|---|
| 最小外接矩形 | 0.9163 | 0.8988 |
| 掩膜边界逐边拟合 | 0.9825 | 0.9610 |
| **边缘点逐边拟合(通常胜出)** | **0.9845** | **0.9634** |
**5. 逐边支撑度检查**(`params.detect.side_support_frac`)
一条边的边界点数不足边长的 25% 时,该边退回矩形边。防的是“某条边在掩膜上几乎没被看到、
却拿去和邻边求交”导致的飞角——实测出现过 300 px 偏移。
**6. 校验失败改为“先重拟合、再降级”**(`run.py`)
原来 `if not v["ok"]` 直接把整个四边形换成画面内缩 3% 的兜底框,`detected_corners`
只写不读。现在先尝试 `rect_quad()` 重拟合:通过则 `ready`,不通过则标 `review` 并保留几何,
只有完全检测不到纸才用兜底框。
**7. 收缝**(`auto_quad.shrink_to_mask`)
最小外接矩形/边线拟合给出的框通常比纸面大 5~40 px,裁出来四边挂背景。沿每条边法向
“向内多远才是纸”取中位数后内推,只许向内、有上限。样本 B 据此收掉 38 px。
### 测试结果
| 项目 | 结果 |
|---|---|
| 真实照片 12 张 | 全部 `validate.ok = True` |
| 裁剪框内属于纸面的像素比例 | 35.7% / 30.0%(原) → **97.0% / 95.8%** |
| 两张梯形透视样本(原版结果已被确认为正确) | 逐角差 **0 px** / 最大 **16 px** |
| 合成样张(已知真值) | 角点最大误差 **5.1 px**(用例容差 35 px) |
### 性能
| 场景 | 原 skill | 本版本 | 差异 |
|---|---|---|---|
| 2 张图端到端(含出 PDF) | 均 6.14 s | 均 6.46 s | +5% |
| 12 张图检测阶段合计 | — | 21.2 s(约 1.8 s/张) | — |
改造过程中曾出现严重性能回退(2 张 61.8 s),原因是 `_mask_quality()` 对整张掩膜的
约 30 万非零像素跑纯 Python 凸包。已改为「只取掩膜边界点 + 降采样到 1500 点」,
单候选 3.4 s → 0.07 s。若后续再改这块,注意别再对全图像素做 Python 循环。
### 部署
只改动 3 个文件,其余与原件逐字节相同:
```
run.py ← 改(校验失败改为重拟合/降级)
doc_deskew/auto_quad.py ← 改(掩膜候选、最小外接矩形、IoU 择优、收缝)
doc_deskew/params.py ← 改(新增候选梯度、支撑度、IoU 等参数)
```
未改动、可直接沿用原件:`SKILL.md`、`REVIEW.md`、`web/index.html`、`validate.py`、
`compose.py`、`homography.py`、`check.py`、`state.py`、`review_store.py`、
`review_page.py`、`smoke_test.py`。
对外接口未变,**不需要改 `SKILL.md`**。覆盖前建议备份原文件。
### 已知局限
1. `check.py` 的「边缘背景残留 / 内容贴边」仍会报不达标。这两项在 `params.py` 里明确
标注为「启发式、未标定、误报多」(`check.edge_warnings` 默认 `False`,只留在 checks
不升为 warning)。贴着纸边裁切时必然触发;原版整幅兜底框同样报这两项。
2. 纸张本身出画(角点贴在画面边界上)时无法还原,只能出整幅。
3. `detect.snap_enable` 默认关闭。贴边吸附(沿法向找梯度极值重拟合)在布面/塑料袋场景
会跳到干扰结构上,实测反而更差,保留代码但不启用。
4. 自带 `smoke_test.py` 在**未修改的原 skill** 上也跑不过(`KeyError: 'output'`:
`run.py` 默认 review 模式返回的字段结构与测试断言不一致)。属既有问题,本次未动。
+6 -2
View File
@@ -26,8 +26,12 @@ input_schema:
## 返回值 ## 返回值
- `ok:true`:`summary` 一句话摘要,`pdf` 文件名,`images` 是 `out/` 下的原图路径; - `ok:true`:`summary` 一句话摘要,`pdf` 文件名,`images` 是 `out/` 下的原图路径;
末尾附完整「访问地址」。把 PDF、地址和图片路径一起给用户。 末尾附完整「访问地址」。务必把 PDF、地址和图片路径一起给用户——自动找的纸边不一定准,
- `ok:false`:转述 `error.message` / `error.hint`,忽略访问地址。 用户在审核页拖角/旋转后点「重新生成 PDF」即可就地修正,不必重传。
此时可直接收尾,不必额外复跑或逐页读图;但要在回话里带出 `summary` 的状态档位和需要人看的页
(`needs_corners` / `review` / `failed` 各有几页),不要只报"已生成"。
- `ok:false`:一张都没出件(参数错误、图打不开、渲染失败、写盘失败)。此时没有 PDF、
也没有审核批次,访问地址打开是空的,**无意义**;只需转述 `error.message` / `error.hint`。
每次运行还会把校正后的单页原图(未调色、未缩放、无白边)导出到 `out/`,文件名与 PDF 每次运行还会把校正后的单页原图(未调色、未缩放、无白边)导出到 `out/`,文件名与 PDF
同名:`合同_校正.pdf` → `out/合同_校正-01.png`、`out/合同_校正-02.png`。不需要图片时 同名:`合同_校正.pdf` → `out/合同_校正-01.png`、`out/合同_校正-02.png`。不需要图片时
@@ -252,6 +252,9 @@ def largest_connected(mask_small):
return out return out
QUAD_INFO = {}
# ---------------------------------------------------------------- 纸面掩膜 # ---------------------------------------------------------------- 纸面掩膜
def otsu_threshold(score): def otsu_threshold(score):
@@ -274,39 +277,313 @@ def otsu_threshold(score):
return float(centers[int(np.argmax(between))]) return float(centers[int(np.argmax(between))])
def _mask_from_bright(bright, factor, d, ref_side=None):
"""把“合格像素”图收敛成单张纸的掩膜(小尺寸)。
关键一步是开运算(erode→dilate):布面高光、塑料袋反光这类细小高亮
块会被整块抹掉,而纸面(一块几百像素宽的大区域)毫发无损。旧实现只有
闭运算,高光点反而被“连”到纸上,把最小外接矩形撑得老远,这就是
rect_fill 只有 0.5、角点飞出去的根源。
ref_side 是原图短边:形态学核按它换算,保证不同 factor 下降采样后
用的是同一个“物理尺寸”的核,否则不同分辨率下的打分不可比。
"""
bs = downsample_any(bright, factor)
if not bs.any():
return bs, 0.0
f = max(1, int(factor))
if ref_side is None:
ref_side = min(bs.shape) * f
def _k(div, minpx):
return _odd(max(minpx, int(max(minpx, ref_side // max(1, div)) / f)))
k_open = _k(d.get("paper_open_div", 90), d.get("paper_open_min", 5))
k_close = _k(d["paper_close_div"], d["paper_close_min"])
k_close2 = _k(d["paper_close2_div"], d["paper_close_min"])
k_close_max = max(k_close, k_close2)
# 掩膜收敛:开 → 闭 → 填洞 → 取最大连通域 → 填洞,共 4 次形态学。
# 不再重复开运算与第二次闭运算:闭运算幂等,且取最大连通域后已无细小
# 碎块,重复一遍结果不变、耗时翻倍(实测单候选 0.3s → 0.15s)。
m = opening(bs, k_open) # 去细小高光与细桥
if not m.any():
m = bs
m = closing(m, k_close_max)
m = fill_holes(m)
m = largest_connected(m)
m = fill_holes(m)
return m, float(bs.mean())
def convex_hull(pts):
"""Andrew monotone chain 凸包,返回逆时针顶点(不含重复首点)。"""
p = np.asarray(pts, dtype=np.float64)
if len(p) < 3:
return None
order = np.lexsort((p[:, 1], p[:, 0]))
p = p[order]
def cross(o, a, b):
return ((a[0] - o[0]) * (b[1] - o[1])
- (a[1] - o[1]) * (b[0] - o[0]))
lower = []
for q in p:
while len(lower) >= 2 and cross(lower[-2], lower[-1], q) <= 0:
lower.pop()
lower.append(q)
upper = []
for q in p[::-1]:
while len(upper) >= 2 and cross(upper[-2], upper[-1], q) <= 0:
upper.pop()
upper.append(q)
hull = lower[:-1] + upper[:-1]
return np.array(hull, dtype=np.float64) if len(hull) >= 3 else None
def _poly_area(q):
"""多边形面积(绝对值)。"""
q = np.asarray(q, dtype=np.float64)
x, y = q[:, 0], q[:, 1]
return float(abs(np.dot(x, np.roll(y, -1)) - np.dot(y, np.roll(x, -1))) / 2.0)
def quad_iou(mask, quad, step=2):
"""凸四边形与二值掩膜的交并比(粗网格采样,用于候选择优)。
为什么用它而不是“和矩形的夹角/位移上限”:真实拍摄的纸张是梯形,
左右两条边本来就该一个往里收、一个往外放,用“偏离矩形的位移”当门槛
会把整张梯形的透视关系判成错误,最后退回成一个平行四边形。
IoU 直接衡量“这个四边形是不是把纸面圈住了”,不预设形状。
"""
m = np.asarray(mask, dtype=bool)
q = np.asarray(quad, dtype=np.float64)
if q.shape != (4, 2) or not np.isfinite(q).all():
return 0.0
area2 = 0.0
for i in range(4):
p0, p1 = q[i], q[(i + 1) % 4]
area2 += p0[0] * p1[1] - p1[0] * p0[1]
if area2 < 0:
q = q[::-1]
H, W = m.shape
st = max(1, int(step))
ys = np.arange(0, H, st)
xs = np.arange(0, W, st)
gx, gy = np.meshgrid(xs, ys)
inside = np.ones(gx.shape, dtype=bool)
for i in range(4):
p0, p1 = q[i], q[(i + 1) % 4]
cr = (p1[0] - p0[0]) * (gy - p0[1]) - (p1[1] - p0[1]) * (gx - p0[0])
inside &= (cr >= 0)
mm = m[::st, ::st]
h = min(mm.shape[0], inside.shape[0])
w = min(mm.shape[1], inside.shape[1])
mm = mm[:h, :w]
inside = inside[:h, :w]
inter = float((inside & mm).sum())
union = float((inside | mm).sum())
return inter / union if union > 0 else 0.0
def min_area_rect(pts):
"""旋转卡壳求点集的最小外接矩形,返回 4 个角点(未排序)。
旧实现用“四个方向的极值点”当锚点,纸张有圆角/掩膜有毛刺时四个极值
会挤到同一段弧上,相邻两边近似平行,求交得到病态角点(实测出现过
两角相距 9px、甚至跑到画面外)。最小外接矩形天然凸、天然有序。
"""
hull = convex_hull(pts)
if hull is None:
return None
n = len(hull)
best = None
for i in range(n):
p0 = hull[i]
p1 = hull[(i + 1) % n]
e = p1 - p0
L = float(np.hypot(e[0], e[1]))
if L < 1e-9:
continue
u = e / L
v = np.array([-u[1], u[0]], dtype=np.float64)
pu = hull @ u
pv = hull @ v
u0, u1 = float(pu.min()), float(pu.max())
v0, v1 = float(pv.min()), float(pv.max())
area = (u1 - u0) * (v1 - v0)
if best is None or area < best[0]:
best = (area, u, v, u0, u1, v0, v1)
if best is None:
return None
_, u, v, u0, u1, v0, v1 = best
return np.array([u * u0 + v * v0, u * u1 + v * v0,
u * u1 + v * v1, u * u0 + v * v1], dtype=np.float64)
def order_quad(quad):
"""把四个角点排成 左上→右上→右下→左下(屏幕坐标,y 向下)。"""
q = np.asarray(quad, dtype=np.float64)
c = q.mean(axis=0)
ang = np.arctan2(q[:, 1] - c[1], q[:, 0] - c[0])
q = q[np.argsort(ang)]
# 起点选最左上的那个
k = int(np.argmin(q[:, 0] + q[:, 1]))
q = np.roll(q, -k, axis=0)
# 屏幕坐标下顺时针,第二点应在前点右侧;否则反向重排
if q[1][0] - q[0][0] < 0 or q[2][1] - q[1][1] < 0:
q = q[::-1]
k = int(np.argmin(q[:, 0] + q[:, 1]))
q = np.roll(q, -k, axis=0)
return q
def quad_ok(quad, min_area=1.0):
"""四边形是否可用:凸 + 有面积 + 边长不退化。"""
q = np.asarray(quad, dtype=np.float64)
if q.shape != (4, 2) or not np.isfinite(q).all():
return False
a = _poly_area(q)
if a < min_area:
return False
for i in range(4):
if float(np.hypot(*(q[(i + 1) % 4] - q[i]))) < 2.0:
return False
sign = None
for i in range(4):
p0, p1, p2 = q[i], q[(i + 1) % 4], q[(i + 2) % 4]
cr = ((p1[0] - p0[0]) * (p2[1] - p1[1])
- (p1[1] - p0[1]) * (p2[0] - p1[0]))
s = 1 if cr > 0 else -1
if sign is None:
sign = s
elif s != sign:
return False
return True
def _border_touch_frac(mask):
"""掩膜贴画面四条边的最大覆盖率:纸不应贴边,贴边说明混进了背景。"""
if not mask.any():
return 1.0
return float(max(mask[0, :].mean(), mask[-1, :].mean(),
mask[:, 0].mean(), mask[:, -1].mean()))
def _mask_quality(m, d):
"""给一个候选掩膜打分:越像“一整张塞在画面里的纸”分越高。
性能要点:只取掩膜边界像素并降采样后再做凸包。旧写法对全部非零像素
(~30 万)做纯 Python 的单调链凸包,单个候选要 3.4 s,六个候选就把
整页拖到 30 s 以上。边界点只有几千个,结果几乎不差。
"""
w = d["mask_score"]
area = float(m.mean())
if area < d["mask_area_min"] or area > d["mask_area_max"]:
return None
ys, xs = np.nonzero(m)
if len(xs) < 32:
return None
pts = mask_boundary_points(m, {"detect": d})
if len(pts) < 32:
return None
cap = int(d.get("mask_quality_max_pts", 1500))
if len(pts) > cap:
pts = pts[::max(1, len(pts) // cap)]
pts = pts.astype(np.float64)
hull = convex_hull(pts)
if hull is None or len(hull) < 3:
return None
hull_area = _poly_area(hull)
if hull_area <= 1e-6:
return None
solidity = min(1.0, area * m.size / hull_area)
rect = min_area_rect(pts)
rect_fill = 0.0
if rect is not None:
ra = _poly_area(rect)
if ra > 1e-6:
rect_fill = min(1.0, area * m.size / ra)
aspect = float(xs.max() - xs.min() + 1) / max(1.0, float(ys.max() - ys.min() + 1))
asp_ok = (d["mask_aspect_min"] <= aspect <= d["mask_aspect_max"])
border = _border_touch_frac(m)
scoring = (w["solidity"] * solidity
+ w["rect_fill"] * rect_fill
- w["border_touch"] * border
+ (w["aspect"] if asp_ok else -w["aspect"]))
return {"score": float(scoring), "solidity": float(solidity),
"rect_fill": float(rect_fill), "area": float(area),
"aspect": float(aspect), "border": border}
def paper_masks(arr, P): def paper_masks(arr, P):
"""返回 (raw, eroded)。 """返回 (raw, eroded, info)。
raw:未腐蚀的纸面掩膜,用于回退几何,避免角点内收。 raw:未腐蚀的纸面掩膜,用于回退几何,避免角点内收。
eroded:腐蚀后的掩膜,只用于限定边缘搜索环带。 eroded:腐蚀后的掩膜,只用于限定边缘搜索环带。
info:选中的候选参数与打分(用于审核页/排查)。
相比旧实现:不再把一组固定阈值当真理(旧值没有用真实样张标定)。
这里跑一梯子候选,按“像不像一张纸”打分选最好的那个——关键是
solidity / 最小外接矩形填充率要高高、贴画面边缘要低低。
“白纸放在亮背景(蓝花布、塑料袋、白台面)上”这类场景下,旧阈值会把
背景并进纸面,掩膜一路贴到画面边缘,后续拟合出的“纸边”其实是照片边框。
""" """
d = P["detect"] d = P["detect"]
H, W = arr.shape[:2] H, W = arr.shape[:2]
S, V = rgb_to_sv(arr) S, V = rgb_to_sv(arr)
score = (V * (1.0 - S)).astype(np.float32) score = (V * (1.0 - S)).astype(np.float32)
th = max(otsu_threshold(score), d["paper_otsu_floor"]) base_th = float(otsu_threshold(score))
bright = (score > th) & (V > d["paper_v_min"]) & (S < d["paper_s_max"])
factor = max(1, min(H, W) // d["paper_mask_factor_div"]) factor = max(1, min(H, W) // d["paper_mask_factor_div"])
bs = downsample_any(bright, factor)
m = closing(bs, _odd(max(d["paper_close_min"], best = None
min(bs.shape) // d["paper_close_div"]))) tried = []
m = fill_holes(m) for cand in d["mask_ladder"]:
m = largest_connected(m) th = base_th * float(cand["o"])
m = closing(m, _odd(max(d["paper_close_min"], bright = ((score > th) & (V > float(cand["v"]))
min(bs.shape) // d["paper_close2_div"]))) & (S < float(cand["s"])))
m = fill_holes(m) fb = float(bright.mean())
if fb < d["mask_min_bright_frac"] or fb > d["mask_max_bright_frac"]:
tried.append({"cand": cand, "bright_frac": round(fb, 4),
"skip": "bright_frac"})
continue
m, _ = _mask_from_bright(bright, factor, d, ref_side=min(H, W))
q = _mask_quality(m, d)
if q is None:
tried.append({"cand": cand, "bright_frac": round(fb, 4),
"skip": "area"})
continue
q.update({"cand": cand, "bright_frac": round(fb, 4)})
tried.append({k: (round(v, 4) if isinstance(v, float) else v)
for k, v in q.items()})
if best is None or q["score"] > best[0]["score"]:
best = (q, m)
if best is None:
# 完全选不出来:退回旧的那组固定阈值,保证不做到“空掩膜”
th = max(base_th, d["paper_otsu_floor"])
bright = ((score > th) & (V > d["paper_v_min"])
& (S < d["paper_s_max"]))
m, _ = _mask_from_bright(bright, factor, d, ref_side=min(H, W))
info = {"mask_pick": None, "mask_tried": tried[:6],
"mask_fallback_legacy": True}
else:
q, m = best
info = {"mask_pick": {k: (round(v, 4) if isinstance(v, float) else v)
for k, v in q.items()},
"mask_tried": tried[:6],
"mask_fallback_legacy": False}
raw_small = m
eroded_small = erode(m, _odd(d["mask_erode_kernel"])) eroded_small = erode(m, _odd(d["mask_erode_kernel"]))
if factor > 1: if factor > 1:
raw = upsample_nearest(raw_small, H, W) raw = upsample_nearest(m, H, W)
eroded = upsample_nearest(eroded_small, H, W) eroded = upsample_nearest(eroded_small, H, W)
else: else:
raw, eroded = raw_small, eroded_small raw, eroded = m, eroded_small
return raw, eroded return raw, eroded, info
# ---------------------------------------------------------------- 边缘图 # ---------------------------------------------------------------- 边缘图
@@ -411,28 +688,33 @@ def _side_line(p0, p1):
def detect_quad_corners(paper_raw, points, P): def detect_quad_corners(paper_raw, points, P):
"""从掩膜边界 + 边缘点估四角,返回 (corners, fallback_sides)。""" """从掩膜边界 + 边缘点估四角,返回 (corners, fallback_sides)。
与旧实现的区别:初始四边形不再用“四个方向极值点”(遇圆角/毛刺会把
四个锚点挤到同一段弧上,导致相邻边近乎平行、角点飞出去),而是用
掩膜的最小外接矩形——它天然凸、天然有序,再在此基础上用真实边缘点
逐边收紧。最后再用 quad_ok() 看门,不合格就退回矩形本身。
"""
d = P["detect"] d = P["detect"]
base = mask_boundary_points(paper_raw, P) base = mask_boundary_points(paper_raw, P)
if len(base) < 40: if len(base) < 40:
return [], [0, 1, 2, 3] return [], [0, 1, 2, 3]
bx, by = base[:, 0], base[:, 1] rect = min_area_rect(base)
anchors = np.array([ if rect is None:
base[int(np.argmin(bx + by))], # 左上 return [], [0, 1, 2, 3]
base[int(np.argmax(bx - by))], # 右上 anchors = order_quad(rect)
base[int(np.argmax(bx + by))], # 右下
base[int(np.argmin(bx - by))], # 左下
], dtype=np.float64)
init = [_side_line(anchors[i], anchors[(i + 1) % 4]) for i in range(4)] init = [_side_line(anchors[i], anchors[(i + 1) % 4]) for i in range(4)]
# 用整条掩膜边界重拟合每一边(排除两端,避开角点圆角) # 用整条掩膜边界重拟合每一边(排除两端,避开角点圆角)
base_lines = [] base_lines = []
side_ok = []
for i in range(4): for i in range(4):
sl = init[i] sl = init[i]
if sl is None: if sl is None:
base_lines.append(None) base_lines.append(None)
side_ok.append(False)
continue continue
n, c, u, L = sl n, c, u, L = sl
p0 = anchors[i] p0 = anchors[i]
@@ -441,11 +723,18 @@ def detect_quad_corners(paper_raw, points, P):
m = d["boundary_side_margin"] m = d["boundary_side_margin"]
sel = base[(dist <= d["group_tol_px"]) & sel = base[(dist <= d["group_tol_px"]) &
(proj >= L * m) & (proj <= L * (1.0 - m))] (proj >= L * m) & (proj <= L * (1.0 - m))]
if len(sel) >= 40: # 支撑度:一条边上的边界点应当与边长成比例。点太少说明这条边在掩膜上
# 几乎没被“看到”(被背景吃掉、或被另一条边盖住),此时用这条线去和
# 邻边求交会把角点甩出去(实测出现过 300px),必须退回矩形边。
need = max(d["min_edge_points"],
float(d.get("side_support_frac", 0.25)) * L)
ok = len(sel) >= need
if ok:
n2, c2 = _robust_fit(sel, d["robust_px"]) n2, c2 = _robust_fit(sel, d["robust_px"])
base_lines.append((n2, c2)) base_lines.append((n2, c2))
else: else:
base_lines.append((n, c)) base_lines.append((n, c))
side_ok.append(ok)
final_lines = list(base_lines) final_lines = list(base_lines)
fallback_sides = [0, 1, 2, 3] fallback_sides = [0, 1, 2, 3]
@@ -476,7 +765,11 @@ def detect_quad_corners(paper_raw, points, P):
m = d["boundary_side_margin"] m = d["boundary_side_margin"]
proj = (sel - p0) @ u proj = (sel - p0) @ u
sel = sel[(proj >= L * m) & (proj <= L * (1.0 - m))] sel = sel[(proj >= L * m) & (proj <= L * (1.0 - m))]
if len(sel) >= d["min_edge_points"]: # 边缘点同样要求“支撑度”:点太少就保留上一步的线(掩膜拟合/矩形边)
need_e = max(d["min_edge_points"],
float(d.get("side_support_frac", 0.25)) *
(float(sl[3]) if sl is not None else 0.0))
if len(sel) >= need_e:
n2, c2 = _robust_fit(sel, d["robust_px"]) n2, c2 = _robust_fit(sel, d["robust_px"])
final_lines[i] = (n2, c2) final_lines[i] = (n2, c2)
else: else:
@@ -484,28 +777,62 @@ def detect_quad_corners(paper_raw, points, P):
H, W = paper_raw.shape H, W = paper_raw.shape
oob = d["corner_oob_frac"] oob = d["corner_oob_frac"]
out = []
for i in range(4): def _intersect_all(lines):
chosen = None """四条直线两两求交得到四角;任一条缺失/越界就返回 None。"""
for lines in (final_lines, base_lines): q = []
for i in range(4):
l1, l2 = lines[i - 1], lines[i] l1, l2 = lines[i - 1], lines[i]
if l1 is None or l2 is None: if l1 is None or l2 is None:
continue return None
det = l1[0][0] * l2[0][1] - l2[0][0] * l1[0][1] det = l1[0][0] * l2[0][1] - l2[0][0] * l1[0][1]
if abs(det) < 1e-3: if abs(det) < 1e-3:
continue return None
p = _intersect(l1[0], l1[1], l2[0], l2[1]) p = _intersect(l1[0], l1[1], l2[0], l2[1])
if p is None: if p is None:
continue return None
if (-oob * W <= p[0] <= (1.0 + oob) * W and if not (-oob * W <= p[0] <= (1.0 + oob) * W and
-oob * H <= p[1] <= (1.0 + oob) * H): -oob * H <= p[1] <= (1.0 + oob) * H):
chosen = (float(p[0]), float(p[1])) return None
break q.append([float(p[0]), float(p[1])])
if chosen is None: return q
chosen = (float(anchors[i][0]), float(anchors[i][1]))
if i not in fallback_sides: # 候选几何:矩形(保守)、掩膜边界拟合(贴合纸面)、边缘点拟合(贴合真实边缘)
fallback_sides.append(i) candidates = [("rect", [list(map(float, p)) for p in anchors])]
out.append(chosen) q_mask = _intersect_all(base_lines)
if q_mask is not None:
candidates.append(("mask", q_mask))
q_edge = _intersect_all(final_lines)
if q_edge is not None:
candidates.append(("edge", q_edge))
min_area = 0.0005 * paper_raw.size
step = int(d.get("iou_step", 2))
best = None
scores = {}
for name, q in candidates:
qq = np.asarray(q, dtype=np.float64)
if not quad_ok(qq, min_area=min_area):
continue
iou = quad_iou(paper_raw, qq, step=step)
scores[name] = round(iou, 4)
if best is None or iou > best[0]:
best = (iou, q, name)
if best is None:
out = [tuple(map(float, p)) for p in anchors]
fallback_sides = [0, 1, 2, 3]
else:
out = [tuple(map(float, p)) for p in best[1]]
if best[2] == "rect":
fallback_sides = [0, 1, 2, 3]
elif best[2] == "mask":
pass # 用掩膜边界拟合,fallback_sides 保留“没找到边缘点”的边
else:
fallback_sides = []
QUAD_INFO["scores"] = scores
QUAD_INFO["picked"] = None if best is None else best[2]
QUAD_INFO["iou"] = None if best is None else round(float(best[0]), 4)
return out, sorted(set(fallback_sides)) return out, sorted(set(fallback_sides))
@@ -562,7 +889,7 @@ def detect(img, P):
arr = np.asarray(pil).astype(np.float32) / 255.0 arr = np.asarray(pil).astype(np.float32) / 255.0
H, W = arr.shape[:2] H, W = arr.shape[:2]
paper_raw, paper_eroded = paper_masks(arr, P) paper_raw, paper_eroded, mask_info = paper_masks(arr, P)
frac = float(paper_raw.sum()) / float(H * W) frac = float(paper_raw.sum()) / float(H * W)
info = { info = {
@@ -575,6 +902,7 @@ def detect(img, P):
"fallback": True, "fallback": True,
"fallback_sides": [0, 1, 2, 3], "fallback_sides": [0, 1, 2, 3],
} }
info.update(mask_info)
if frac < 0.005 or not paper_raw.any(): if frac < 0.005 or not paper_raw.any():
return [], info return [], info
@@ -596,9 +924,26 @@ def detect(img, P):
info["edge_pixels"] = int(cand.sum()) info["edge_pixels"] = int(cand.sum())
info["fallback_sides"] = fallback_sides info["fallback_sides"] = fallback_sides
info["fallback"] = bool(fallback_sides) info["fallback"] = bool(fallback_sides)
info["quad_scores"] = dict(QUAD_INFO.get("scores") or {})
info["quad_picked"] = QUAD_INFO.get("picked")
info["quad_iou"] = QUAD_INFO.get("iou")
if not corners: if not corners:
return [], info return [], info
if d.get("snap_enable", True):
snapped = snap_quad(arr, corners, P)
if quad_ok(np.asarray(snapped), min_area=1.0):
info["snapped"] = round(float(np.linalg.norm(
np.asarray(snapped) - np.asarray(corners), axis=1).max()), 2)
corners = snapped
if d.get("shrink_enable", True):
shrunk = shrink_to_mask(paper_raw, corners, P)
if quad_ok(np.asarray(shrunk), min_area=1.0):
info["shrunk"] = round(float(np.linalg.norm(
np.asarray(shrunk) - np.asarray(corners), axis=1).max()), 2)
corners = shrunk
info["coverage"] = { info["coverage"] = {
k: float(v) for k, v in border_coverage_exact( k: float(v) for k, v in border_coverage_exact(
cand, paper_eroded, cand, paper_eroded,
@@ -606,3 +951,196 @@ def detect(img, P):
} }
src_pts = [(float(x / scale), float(y / scale)) for x, y in corners] src_pts = [(float(x / scale), float(y / scale)) for x, y in corners]
return src_pts, info return src_pts, info
def rect_quad(img, P):
"""只取纸面掩膜的最小外接矩形(不做边线收紧)。
用于“检测到了但校验不过”时的保守补救:矩形一定凸、一定有序,
比直接换成画面内缩兜底框贴近真实纸张。返回 (quad_原图坐标, info)。
"""
d = P["detect"]
src_w, src_h = img.size
scale = min(1.0, d["max_side"] / float(max(src_w, src_h)))
if scale < 1.0:
pil = img.resize((int(round(src_w * scale)), int(round(src_h * scale))),
Image.LANCZOS)
else:
pil = img
arr = np.asarray(pil).astype(np.float32) / 255.0
paper_raw, _, mask_info = paper_masks(arr, P)
base = mask_boundary_points(paper_raw, P)
info = dict(mask_info)
if len(base) < 40:
info["rect_fail"] = "boundary_too_few"
return [], info
rect = min_area_rect(base)
if rect is None:
info["rect_fail"] = "rect_none"
return [], info
q = order_quad(rect)
if not quad_ok(q, min_area=1.0):
info["rect_fail"] = "rect_degenerate"
return [], info
info["quad_source"] = "min_area_rect"
if d.get("snap_enable", True):
snapped = snap_quad(arr, q, P)
if quad_ok(np.asarray(snapped), min_area=1.0):
info["quad_source"] = "min_area_rect+snap"
q = np.asarray(snapped, dtype=np.float64)
if d.get("shrink_enable", True):
shrunk = shrink_to_mask(paper_raw, q, P)
if quad_ok(np.asarray(shrunk), min_area=1.0):
info["quad_source"] = str(info.get("quad_source")) + "+shrink"
q = np.asarray(shrunk, dtype=np.float64)
out = [[float(x / scale), float(y / scale)] for x, y in q]
return out, info
def _snap_side(mag, p0, p1, band, th, n):
"""沿一条边的法向找梯度最大处,返回拟合用的点集。"""
H, W = mag.shape
dv = np.asarray(p1, dtype=np.float64) - np.asarray(p0, dtype=np.float64)
L = float(np.hypot(dv[0], dv[1]))
if L < 4.0:
return None
u = dv / L
nv = np.array([-u[1], u[0]], dtype=np.float64)
pts = []
hits = 0
offs = np.arange(-band, band + 0.5, 1.0)
for t in np.linspace(0.10, 0.90, n):
base = np.asarray(p0, dtype=np.float64) + dv * t
best = (-1.0, 0.0)
for o in offs:
q = base + nv * o
xi, yi = int(round(q[0])), int(round(q[1]))
if 0 <= xi < W and 0 <= yi < H:
m = float(mag[yi, xi])
if m > best[0]:
best = (m, o)
if best[0] >= th:
hits += 1
pts.append(base + nv * best[1])
if hits < max(12, int(0.45 * n)) or len(pts) < 12:
return None
return np.array(pts, dtype=np.float64)
def snap_quad(arr, quad, P, rounds=2):
"""把四边形的每条边吸附到真实图像边缘上。
矩形容器给的是“把纸装进去的最小框”,它容易在毛刺、反光处偏出去几十像素
(实测第 2 张上边偏 30px)。这里沿每条边的法向在 ±band 内找梯度极值,
稳健拟合出新边;只有拟合点数够、边仍合法时才采纳,否则保留原边。
"""
d = P["detect"]
q = np.asarray(quad, dtype=np.float64)
if q.shape != (4, 2) or not quad_ok(q, min_area=1.0):
return [[float(x), float(y)] for x, y in q]
gray = luminance(arr)
sigma = max(1.0, gray.shape[0] / float(d["edge_sigma_div"]))
mag = sobel_magnitude(gaussian_blur_np(gray, sigma))
band = float(d.get("snap_band", 40))
th = float(d.get("snap_grad_min", 0.05))
n = int(d.get("snap_samples", 96))
cur = q.copy()
for r in range(max(1, int(rounds))):
lines = []
for i in range(4):
pts = _snap_side(mag, cur[i], cur[(i + 1) % 4], band, th, n)
if pts is not None and len(pts) >= 12:
try:
nvec, c = _robust_fit(pts, d["robust_px"])
lines.append((nvec, c))
continue
except Exception:
pass
sl = _side_line(cur[i], cur[(i + 1) % 4])
lines.append((sl[0], sl[1]) if sl is not None else None)
nxt = []
for i in range(4):
l1, l2 = lines[i - 1], lines[i]
if l1 is None or l2 is None:
nxt.append(cur[i])
continue
det = l1[0][0] * l2[0][1] - l2[0][0] * l1[0][1]
if abs(det) < 1e-3:
nxt.append(cur[i])
continue
p = _intersect(l1[0], l1[1], l2[0], l2[1])
nxt.append(np.asarray(p, dtype=np.float64) if p is not None
else cur[i])
nxt = np.asarray(nxt, dtype=np.float64)
if not quad_ok(nxt, min_area=1.0):
break
# 吸附只允许小幅修正,避免越修越野
lim = float(d.get("snap_max_shift_frac", 0.05)) * float(min(mag.shape))
if float(np.linalg.norm(nxt - q, axis=1).max()) > lim:
break
cur = nxt
band = max(6.0, band * 0.4)
return [[float(x), float(y)] for x, y in cur]
def shrink_to_mask(mask, quad, P):
"""把每条边沿法向向纸内推到掩膜边界(中位数),去掉背景毛边。
最小外接矩形/边线拟合给出的框通常比纸面大 5~40px(阈值分割本身会
吃掉纸边一圈),裁出来四边就挂着背景。这里沿每条边的法向量“向内多远
才是纸”,取中位数后内推,既去毛边又不会被局部的凹陷带走。
只许向内、不许向外,且单边内推有上限,避免把正文切掉。
"""
d = P["detect"]
m = np.asarray(mask, dtype=bool)
q = np.asarray(quad, dtype=np.float64)
if q.shape != (4, 2) or not m.any():
return quad
H, W = m.shape
ys, xs = np.nonzero(m)
cen = np.array([xs.mean(), ys.mean()], dtype=np.float64)
search = float(d.get("shrink_search", 80))
cap = float(d.get("shrink_max_frac", 0.05)) * float(min(H, W))
keep = float(d.get("shrink_keep_px", 1.5))
lines = []
for i in range(4):
p0, p1 = q[i], q[(i + 1) % 4]
dv = p1 - p0
L = float(np.hypot(dv[0], dv[1]))
if L < 4.0:
return quad
u = dv / L
nv = np.array([-u[1], u[0]], dtype=np.float64)
if float((cen - p0) @ nv) < 0:
nv = -nv # 指向纸内
offs = []
for t in np.linspace(0.12, 0.88, 64):
base = p0 + dv * t
hit = None
for o in np.arange(0.0, search, 1.0):
pt = base + nv * o
xi, yi = int(round(pt[0])), int(round(pt[1]))
if 0 <= xi < W and 0 <= yi < H and m[yi, xi]:
hit = o
break
offs.append(search if hit is None else hit)
off = float(np.median(offs)) - keep
off = max(0.0, min(cap, off))
c = float(nv @ p0) + off
lines.append((nv, c))
out = []
for i in range(4):
p = _intersect(lines[i - 1][0], lines[i - 1][1], lines[i][0], lines[i][1])
if p is None:
return quad
out.append([float(p[0]), float(p[1])])
out = np.asarray(out, dtype=np.float64)
if not quad_ok(out, min_area=1.0):
return quad
if _poly_area(out) >= _poly_area(q):
return quad
return out
@@ -15,6 +15,8 @@ P = {
"detect": { "detect": {
"max_side": 1600, # 检测降采样长边;越大越准越慢 "max_side": 1600, # 检测降采样长边;越大越准越慢
"min_edge_points": 40, # 单边拟合所需最少点数,低于则回退掩膜线 "min_edge_points": 40, # 单边拟合所需最少点数,低于则回退掩膜线
"side_support_frac": 0.25, # 单边支撑度:点数至少要达边长的这个比例,
# 不足则这条边退回矩形边(防止角点被甩飞)
"group_tol_px": 22.0, # 边线点归属容差(处理图像素) "group_tol_px": 22.0, # 边线点归属容差(处理图像素)
"robust_px": 2.0, # 稳健拟合的残差基准(处理图像素) "robust_px": 2.0, # 稳健拟合的残差基准(处理图像素)
"mask_erode_kernel": 3, # 掩膜内收核;3 = 半径 1 像素 "mask_erode_kernel": 3, # 掩膜内收核;3 = 半径 1 像素
@@ -25,6 +27,8 @@ P = {
"paper_close_div": 60, # 第一次闭运算核 = min(H,W)//该值 "paper_close_div": 60, # 第一次闭运算核 = min(H,W)//该值
"paper_close_min": 5, # 形态学核最小值 "paper_close_min": 5, # 形态学核最小值
"paper_close2_div": 80, # 第二次闭运算核 = min(H,W)//该值 "paper_close2_div": 80, # 第二次闭运算核 = min(H,W)//该值
"paper_open_div": 90, # 开运算核 = min(H,W)//该值(去布面高光碎点/细桥)
"paper_open_min": 5,
"band_div": 45, # 搜索环带宽度 = H//该值 "band_div": 45, # 搜索环带宽度 = H//该值
"band_min": 15, # 环带宽度下限 "band_min": 15, # 环带宽度下限
"edge_local_gain": 1.55, # 边缘图局部阈值增益 "edge_local_gain": 1.55, # 边缘图局部阈值增益
@@ -42,14 +46,65 @@ P = {
"coverage_tol_min": 10, "coverage_tol_min": 10,
"corner_oob_frac": 0.15, # 角点越界允许幅度(相对画面长边) "corner_oob_frac": 0.15, # 角点越界允许幅度(相对画面长边)
"boundary_side_margin": 0.10, # 拟合单边时排除两端各 10%,避开角点 "boundary_side_margin": 0.10, # 拟合单边时排除两端各 10%,避开角点
# ---- 四边形候选择优
# 不再用“与矩形的夹角/位移上限”当门槛:真实拍摄的纸张是梯形,
# 左右两边本来就该一边内收一边外放,用矩形先验会把透视判成错误。
# 改为在 [矩形 / 掩膜边界拟合 / 边缘点拟合] 里按与纸面掩膜的 IoU 选优。
"iou_step": 2, # IoU 粗网格采样步长(处理图像素)
# ---- 贴边吸附(snap):沿每条边的法向在 ±band 内找梯度极值重拟合
"snap_enable": False, # 默认关闭:实测布面/塑料袋场景会跳到干扰结构上
"snap_band": 42, # 搜索半宽(处理图像素)
"snap_grad_min": 0.05, # 可接受的最小梯度
"snap_samples": 96, # 单边采样数
"snap_max_shift_frac": 0.10, # 吸附造成的最大角点位移(相对画面短边)
# ---- 收缝:把每条边推进到掩膜边界,去掉遗留的背景毛边
"shrink_enable": True,
"shrink_search": 80, # 向内搜索上限(处理图像素)
"shrink_max_frac": 0.05, # 单边内推上限(相对画面短边)
"shrink_keep_px": 1.5, # 留一点余量,不把自己压到纸上
# ---- 自适应纸面掩膜(替代原先固定的 v/s/floor 三件套)
# 旧实现用一组硬阈值,遇到“亮背景 + 低饱和纸张”(蓝布、塑料袋、亮桌面)
# 时背景会和纸并进同一连通域,掩膜一路贴到画面边缘,后续拟合出的
# “纸边”其实是照片边框。改为在下面这组候选里挑一个最像“一张纸”的:
# v = 亮度下限(V)、s = 饱和度上限(S)、o = Otsu 阈值的缩放系数
"mask_ladder": [
{"v": 0.50, "s": 0.45, "o": 1.00}, # 旧行为,作为兜底候选
{"v": 0.52, "s": 0.16, "o": 0.90},
{"v": 0.58, "s": 0.20, "o": 0.88},
{"v": 0.62, "s": 0.14, "o": 0.86},
{"v": 0.68, "s": 0.14, "o": 0.84},
{"v": 0.76, "s": 0.16, "o": 0.82},
],
"mask_min_bright_frac": 0.02, # 候选的原始合格像素占比下限
"mask_max_bright_frac": 0.96, # 上限:几乎全图都合格说明没分出纸
"mask_area_min": 0.02, # 掩膜面积占比合理区间
"mask_area_max": 0.90,
"mask_score": { # 候选打分权重(越大越像一张纸)
"solidity": 1.0, # 面积 / 凸包面积
"rect_fill": 1.4, # 面积 / 最小外接矩形面积
"border_touch": 3.2, # 掩膜贴画面边缘的惩罚
"aspect": 0.6, # 宽高比越接近 [0.2, 5] 越好
"contrast": 0.5, # 掩膜内外的亮暗差
},
"mask_aspect_min": 0.18, # 纸面宽高比合理区间(含横竖)
"mask_aspect_max": 5.5,
"mask_quality_max_pts": 1500, # 打分时凸包/矩形的最大采样点数(性能开关)
}, },
# ---------------------------------------------------------------- 几何门槛 # ---------------------------------------------------------------- 几何门槛
"gate": { "gate": {
"oob_max_pct": 15.0, # 越界超过此值判失败 "oob_max_pct": 15.0, # 越界超过此值判失败
"inner_paper_min": 0.60, # 框内纸面占比下限 "inner_paper_min": 0.60, # 框内纸面占比下限
"inner_edge_min": 0.75, # 每边内侧纸面占比下限 "inner_edge_min": 0.62, # 每边内侧纸面占比下限
# (旧值 0.75 对“矩形比掩膜略大”的正常情形误报;
# 旧的错位案例实测只有 0.14~0.47,0.62 仍能拦住)
"outer_dark_min": 0.35, # 外侧暗像素占比低于此值只告警 "outer_dark_min": 0.35, # 外侧暗像素占比低于此值只告警
"repair": True, # 校验不过时先尝试“重拟合”而不是直接扔兜底框
"repair_fallback": "rect", # rect = 用掩膜的最小外接矩形;off = 直接兜底框
"coverage_warn": 0.40, # 四边覆盖率低于此值告警(未标定) "coverage_warn": 0.40, # 四边覆盖率低于此值告警(未标定)
"aspect_deadband": 0.10, # 0.9~1.1 视为接近正方形,不参与方向投票 "aspect_deadband": 0.10, # 0.9~1.1 视为接近正方形,不参与方向投票
"paper_mismatch_pct": 20.0, # 与批次中位宽高比偏差超过此值告警 "paper_mismatch_pct": 20.0, # 与批次中位宽高比偏差超过此值告警
+46 -3
View File
@@ -29,7 +29,7 @@ HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "doc_deskew")) sys.path.insert(0, os.path.join(HERE, "doc_deskew"))
from params import P # noqa: E402 from params import P # noqa: E402
from auto_quad import detect # noqa: E402 from auto_quad import detect, rect_quad # noqa: E402
from validate import validate # noqa: E402 from validate import validate # noqa: E402
import compose # noqa: E402 import compose # noqa: E402
import check # noqa: E402 import check # noqa: E402
@@ -485,8 +485,51 @@ def process(args, t0):
v = {"ok": False, "metrics": {}, v = {"ok": False, "metrics": {},
"failures": ["校验异常:%s" % e], "warnings": []} "failures": ["校验异常:%s" % e], "warnings": []}
meta["validation"] = v meta["validation"] = v
if not v["ok"]: if not v["ok"] and P["gate"].get("repair"):
# 检测到了但几何不可信:退回兜底框,交给人补角,而不是让整批失败。 # 先试保守重拟合(最小外接矩形),而不是直接把整个四边形
# 扔掉换成画面内缩兜底框。旧行为是“一票否决 + 全框替换”,
# 一旦自动检测有一点偏差,人拿到手的就是整张照片。
meta["detected_corners"] = [list(map(float, q))
for q in meta["corners"]]
try:
rq, rinfo = rect_quad(img, P)
except Exception as e:
rq, rinfo = [], {"error": str(e)}
if rq:
meta["corners"] = [[float(x), float(y)] for x, y in rq]
meta["corners_norm"] = _norm(meta["corners"],
meta["source_size"])
meta["auto_corners"] = [list(map(float, q))
for q in meta["corners"]]
meta["auto_corners_norm"] = meta["corners_norm"]
try:
v2 = validate(img, meta["corners"], P)
except Exception as e:
v2 = {"ok": False, "metrics": {},
"failures": ["校验异常:%s" % e],
"warnings": []}
meta["validation"] = v2
meta["repaired"] = "min_area_rect"
meta["repair_info"] = {
k: vv for k, vv in rinfo.items()
if k in ("paper_frac", "mask_pick", "quad_source")}
if v2["ok"]:
meta["status"] = "ready"
meta["reason"] = None
else:
meta["status"] = "review"
meta["reason"] = "repaired_quad"
else:
meta["corners"] = _fallback_quad(meta["source_size"], P)
meta["corners_norm"] = _norm(meta["corners"],
meta["source_size"])
meta["auto_corners"] = [list(map(float, q))
for q in meta["corners"]]
meta["auto_corners_norm"] = meta["corners_norm"]
meta["status"] = "needs_corners"
meta["reason"] = "invalid_quad"
elif not v["ok"]:
# repair 关掉时保持旧行为:检测到了但几何不可信,退回兜底框。
# auto_corners 也要跟着换成兜底框,否则“恢复自动”会把无效角点拖回来。 # auto_corners 也要跟着换成兜底框,否则“恢复自动”会把无效角点拖回来。
meta["detected_corners"] = meta["corners"] meta["detected_corners"] = meta["corners"]
meta["corners"] = _fallback_quad(meta["source_size"], P) meta["corners"] = _fallback_quad(meta["source_size"], P)
+1 -1
View File
@@ -50,7 +50,7 @@ agent-core 的 `wechat_bindings` 表;扫码二维码呈现在 agent-core 的 W
## 部署 ## 部署
```sh ```sh
./scripts/init.sh --env-only # 生成/复用根 .env 的 WXBOT_TOKEN(幂等,不碰 config.yml) ./scripts/init.sh # 生成/复用根 .env 的 WXBOT_TOKEN(幂等)
docker compose up -d --build agent-wxbot # 首次构建镜像(npm 源可 --build-arg NPM_REGISTRY= 换) docker compose up -d --build agent-wxbot # 首次构建镜像(npm 源可 --build-arg NPM_REGISTRY= 换)
docker compose up -d agent-core # core 带 WXBOT_URL/WXBOT_TOKEN 重建(compose 检测到 env 变化自动 recreate) docker compose up -d agent-core # core 带 WXBOT_URL/WXBOT_TOKEN 重建(compose 检测到 env 变化自动 recreate)
``` ```