40 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
kicer 55efb1c410 mcp/asr 构建默认换腾讯云 apt 源
node:22-slim 的 apt-get update 走官方源在国内会卡十几分钟:按 executor/Dockerfile 的做法把 deb.debian.org 替换为 mirrors.cloud.tencent.com,grep 扫 /etc/apt/ 同时兼容 sources.list 与 deb822 的 *.sources。境外构建可用 --build-arg DEBIAN_MIRROR=deb.debian.org 覆盖回官方源。

已实际构建验证:镜像内 sources 生效,ffmpeg 5.1.9 / node v22.23.3 正常。
2026-10-24 16:27:29 +08:00
kicer 53fa5da82b 新增语音输入(mcp_asr)与健康检查服务标识
语音输入:输入框为空时发送键变麦克风,进入语音模式后按住说话、松手转写并发送;套壳 App 走原生录音桥,浏览器走 MediaRecorder(需 HTTPS)。转写在 mcp_asr,经 /api/asr/transcribe 直达,不经过模型、不消耗 token。

/api/health 增加 service/api/auth_required 字段并设 no-store,供套壳 App 校验手填的服务器地址;免认证路径容忍尾斜杠,避免 /api/health/ 被中间件 401。

接线与文档:compose 新增 mcp_asr;init.sh 默认复用 BIGMODEL_KEY 作为 ASR_API_KEY;README/AGENTS/mcp 文档同步。版本 2.3.0 → 2.4.0。
2026-10-24 16:13:30 +08:00
kicer 5b70f7d614 图片滑动改为双层分页 + 相邻图预取,消除切图卡顿与空白
原实现松手时把拖到一半的图瞬移回中心再换 src,视觉上先跳一下;
新图又要等松手后才开始下载,所以会闪白。改为:

- 双层 img:拖动方向确定后相邻图摆到另一侧,两图一起跟手移动,
  松手各自滑到位(旧图滑出、新图滑入),不再瞬移
- 开图即用 Image 预取前后各一张(再往后一张),切图直接用已解码位图;
  每次落定后补取新邻居,关窗清空引用
- 缩放/平移强制 transition:none,避免与滑动动画的过渡打架
- 连点方向键/快速连滑先收尾上一段动画,避免接替层被瞬移
- 第二层 img 由脚本创建,旧缓存 HTML 也能正常工作

css: 两层 img 绝对定位居中叠放 + will-change: transform
2026-10-24 10:24:29 +08:00
kicer dfcbe6d3ea 图片查看器支持同组图片左右滑动切换
移动端点开图片后可在同一组内横滑切换(1x 缩放时接管手势,放大后仍是拖动平移),
底部显示页码,桌面补 ←/→。组边界:聊天内同一消息/工具卡;文件面板当前目录。

- stream.js: openImageViewer 增加可选 list/at 参数与组状态,横滑+页码+键盘
- preview.js: pvImgGroup 按当前目录聚合图片(用下载直链,不逐张取 blob)
- index.html/style.css: 新增 #img-count 页码节点与样式
2026-10-24 10:18:07 +08:00
kicer 516b4a5d86 fix issues 2026-10-24 09:59:48 +08:00
kicer e39273e97f feat(document-photo-to-pdf): raw PNG 页图导出到 out/,PDF 从 raw 派生
出件改为一次透视:PIL 按四边形自然尺寸 warp 出 raw 页图(只裁剪+拉正,不调色、不缩放、无白边),直接写 out/<PDF 主名>-NN.png;PDF 页再由 raw 调色 + LANCZOS 缩到画布内容区派生。相比「PDF 目标尺寸一次 + raw 自然尺寸一次」少一次 warp,10MP 自然尺寸从 numpy 的 3.0s/页降到 PIL 的 0.3s/页。

不新增输入参数:每次运行 PDF 与 PNG 全出,AI 不需要判断格式;SKILL.md 只补 out/ 说明、images 返回字段,以及 description 里的产出(PDF + out/ 下的 PNG 原图)。

页序先定后渲染,PNG 编号跟最终 PDF 页序;PDF 落盘成功后才清理同前缀的多余编号(失败保留上一份),不碰 out/ 里其它文件。numpy warp 与旧 warp_page 保留作回退路径。

真实样张(task-20261021-004,3 页)A/B:state.json 完全一致;PDF 逐页平均差 0.7 / 0.7 / 1.2 灰度级;raw PNG 与 numpy 自然尺寸 warp 平均差 0.02;3 页端到端 4.8s,PNG 0.58/0.69/0.90MB。注:doc_deskew/smoke_test.py 自 fe1c6d1 起未同步返回契约,属既有问题,本次未改。
2026-10-24 09:54:37 +08:00
kicer 8b8fbddb4f refactor(prompt): 精简默认提示词、强化技能优先,校正两个图像技能描述
profile-default.txt 109 行 → 74 行(5.6KB → 3.4KB)。删除 in-scope 能力枚举(与工具/技能清单重复且会随新 MCP 过期)、通用建议与三处重复表述;保留反造假护栏、能力判断规则、mint_public_link 机密禁令,环境事实逐条与 executor 镜像核对后保留。

新增 ## Skill Use 紧贴技能清单:写脚本/装包前先查技能,首次运行前 get 一次接口、同会话不重复 get。规则覆盖全部技能,required 降级为「该域不要手写等价实现」,不必给所有技能加 required。能力判断顺序改为先查技能再考虑工具组合。

两个图像技能描述改为自足表述、互不引用:document-photo-to-pdf 补纸质文档触发词,image-process 明确普通图片/截图。skills/README.md 补 required 字段说明。
2026-10-24 09:21:54 +08:00
kicer ba9534f064 修复 office 预览偶发「暂无这份文档」与冷启动长时间转圈
预览网关不再把 HEAD 探针转发给 watch:watch(Kestrel) 对 HEAD 只发响应头(带
content-length)不发 body 就断链,Node 客户端抛 HPE_CLOSED_CONNECTION,旧逻辑把
它当上游故障 res.destroy(),同一文档十次 HEAD 里六七次变成空响应/502;前端探到
一次 404 就显示「预览服务中暂无这份文档」。改为本地按文件系统回答,404 补
no-store(避免被缓存后文件补上仍显示占位卡)。

HEAD 回 200 前等槽位就绪(上限 HEAD_WAIT_MS=15s):冷启动首次渲染很贵(2~6s),
等完再放 iframe 进来,否则这段开销落到 5s 时限的导航请求上,慢文档会被判超时。

导航超时不再直接 retire 正在渲染的 watch——连坐杀掉会让渲染从头再来,表现为一直
转圈;改为连续 3 次超时(约 15s 无首字节)或硬性拒连才判死重启,成功转发后清零。
上游在响应已完整时断链的假报错也不再打断已写好的响应(留一拍再判)。

槽满时优先踢「就绪且无活动连接」的槽,避免误杀正在启动的 watch(浪费数秒冷启动
并让等它的请求失败进冷却)。前端探针遇 404 先短重试一次再落占位卡,文案改为
404 的真实语义(文件已删除/改名/不在任务目录)。
2026-10-24 09:13:45 +08:00
kicer 43e77e569e 审核页加载失败时保留可用的返回按钮
- #back / #pdf 的绑定从 boot() 移到 start():boot 只在加载成功后执行,
  空状态下 X 之前是死的,点了没反应。
- 加载失败时给 body 加 is-empty,隐藏工具栏/底栏/预览区,只留白色标题条。
- data.db 缺 doc_review_batch 表时改成人话提示,不再直接抛 SQLite 错误。
2026-10-24 08:43:57 +08:00
71 changed files with 6256 additions and 1071 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
+12 -8
View File
@@ -22,9 +22,9 @@
| `app/server/public/` | 前端静态资源,经典脚本按序加载,共享全局作用域 | 无构建步骤 |
| `executor/` | **agent-executor**:`/exec` 隔离命令执行 + Office 预览网关 | 零依赖 Node,独立容器 |
| `wxbot/` | 微信 iLink 协议调制解调器(多实例) | 独立容器 `agent-wxbot` |
| `mcp/` | 同栈 MCP 服务:`web_search` / `image_task` / `video_task` | 三个容器,仅内网 |
| `mcp/` | 同栈 MCP 服务:`web_search` / `image_task` / `video_task` / `asr` | 四个容器,仅内网 |
| `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` | — |
| `tasks/` | **运行时数据**:每个会话一个工作目录 | gitignore |
| `data/` | **运行时数据**:SQLite `.agent.db`、`prompt.txt` 调试产物 | gitignore |
@@ -42,7 +42,7 @@ flowchart TD
WXBOT -->|"回调 /wxhook/*(共享 Bearer token)"| CORE
CORE["agent-core(8090,唯一对外端口)"]
CORE --> EXEC["agent-executor(9000 exec / 3100 预览,仅内网)"]
CORE --> MCP["mcp_web_search / mcp_image_task / mcp_video_task(3000,仅内网)"]
CORE --> MCP["mcp_web_search / mcp_image_task / mcp_video_task / mcp_asr(3000,仅内网)"]
CORE -->|"分段投递回复"| WXBOT
```
@@ -60,7 +60,7 @@ flowchart TD
| `agent-core` | 8090 | 宿主机映射,**唯一对外** |
| `agent-executor` | 9000(exec)、3100(预览网关) | 仅 `expose`,内网 |
| `agent-wxbot` | 8093 | 仅内网 |
| `mcp_*` | 3000 | 仅内网;compose 里注释掉的 `ports` 仅供本机调试 |
| `mcp_*` | 3000 | 仅内网 |
### 数据持久化(bind mount)
@@ -83,8 +83,10 @@ flowchart TD
### 环境变量(接线全靠根 `.env` + compose)
`AGENT_CONFIG`、`PORT`、`EXECUTOR_URL`、`EXECUTOR_TOKEN`、`WXBOT_URL`、`WXBOT_TOKEN`、
`VIRTUAL_HOST`、`PREVIEW_PROXIES`、`EXECUTOR_LOG_LEVEL`、`WXBOT_LOG_LEVEL`。
密钥生成:`./scripts/init.sh`(幂等,重跑不掉登录态)。
`PUBLIC_BASE_URL`、`ASR_URL`、`PREVIEW_PROXIES`、`EXECUTOR_LOG_LEVEL`、`WXBOT_LOG_LEVEL`、`ASR_LOG_LEVEL`。
密钥生成:`./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` 的随机密钥都在进程内——重启即清空,多实例不共享。
(微信投递游标 `last_msg_id` 例外,它是落库的。)不要引入需要跨进程一致性的设计。
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/tools/definitions.json` ↔ `app/AGENTS.md` / README 工具表 ↔ `docs/tool-design.md` 规范 |
| 新增服务 / 端口 / 卷 | `docker-compose.yml` ↔ `README.md` 的部署与安全章节 |
| 新增环境变量 | `.env.example` ↔ compose ↔ README「环境变量」 |
| 新增环境变量 | compose ↔ README「环境变量」 |
| 发版号 | `app/package.json` 的 `version` ↔ `app/server/routes/system.js` 的 `VERSION` 字面量(两者不自动同步) |
| 技能格式 | `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 |
## 代码约定
@@ -187,6 +190,7 @@ curl -s http://127.0.0.1:8090/api/health
| 改模型调度 / 绑定 | `app/server/engine.js` 的 `chooseKey` / `chooseModel` / `ensureBinding` |
| 改上下文组装 / 省 token | `app/server/llm.js` 的 `buildMessages` / `trim*` |
| 改微信投递 | `app/server/wechat.js`(业务)+ `app/server/routes/wechat.js`(HTTP/鉴权) |
| 改语音输入 | `app/server/public/js/voice.js`(录音与插入)+ `app/server/routes/asr.js`(代理)+ `mcp/asr/`(转写);客户端桥契约见 `docs/voice-input.md` |
| 改隔离执行 | `executor/server.js`(先读顶部安全模型注释) |
| 加同栈 MCP 服务 | `mcp/<name>/` + `docker-compose.yml` + `config.yml` 的 `mcp_servers` |
| 加技能 | `skills/<name>/`(`SKILL.md` + `run.py`),见 `skills/README.md` |
+73 -31
View File
@@ -20,8 +20,10 @@
| 隔离执行 | `terminal` 和技能在 `agent-executor` 容器中运行,只看到当前会话目录,根文件系统只读 |
| 大文件交付 | 文件面板上传/下载/打包 zip;外部服务取图走带过期时间的公网短链 |
| 上下文管理 | 手动压缩、按 token 阈值提示压缩、历史重放自动裁剪、会话标题自动生成 |
| 回合中投递 | 运行中发的消息先进输入框上方的待发送条幅:默认等本轮结束自动发出;可「干预」(当前工具跑完就插话)或「立即发送」(终止本轮并立刻发)。队列在服务端,关页面不丢 |
| 定时任务 | 每会话最多一个 cron 任务;触发前清空模型可见历史,按计划执行并推送结果 |
| 微信接入 | 扫码绑定个人微信,文本/图片/视频/文件进入同一套会话与命令体系 |
| 语音输入 | 输入框为空时发送键变麦克风:点一下进入语音模式,输入框位置变成「按住 说话」,松开即转写并直接发送;发送键位置变键盘按钮可切回打字。套壳 App 走原生录音(http 页面也能用),浏览器走 MediaRecorder(需 HTTPS);识别在 `mcp_asr`,不经过模型、不消耗 token |
| 长期记忆 | 会话收口时生成第一人称工作日记;微信新会话注入最近几条,`recall` 可检索全部 |
| 用户画像 | 记录称谓、行业、偏好,会话创建时冻结注入,跨会话生效 |
| 技能 | 目录式技能(`SKILL.md` + `run.py`/`run.sh`),可在设置页管理 |
@@ -40,38 +42,34 @@
Debian 12 裸机可以先跑 `scripts/init_host.sh`(幂等,可重复执行,也可单独拷到服务器上跑):它会配好 Swap、Docker、国内镜像加速与基础 shell 环境;`REGION=oversea` 切海外源。跑完会打印后续的 `init.sh` 与部署步骤。
### 1. 生成配置
### 1. 初始化(只做部署接线)
在仓库根目录执行:
```bash
BIGMODEL_KEY=xxx \
DEEPSEEK_KEY=yyy \
QWEN_KEY=zzz \
AUTH_USER=admin \
AUTH_PASSWORD='换一个强密码' \
PUBLIC_IP=1.2.3.4 \
./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` 等部署变量。
- `config.yml`:模型平台、登录账号、MCP 服务、公网前缀。
脚本不再生成模型平台 / MCP / 语音这些配置——它们全部在前端「设置」里完成,写的就是同一个 `config.yml`。所以重跑脚本永远不会清掉你配好的东西(旧版脚本会覆盖,这是本次的行为变化)。
`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`,首次部署务必改掉。
`.env` 里的密钥会复用,重新执行不会让登录态失效;旧的 `config.yml` 会先备份为 `config.yml.bak.<时间戳>`。
注意:`config.yml` 每次都会按本次环境变量重新生成,平台 Key 不保存在 `.env` 里。已经部署过的实例请用设置页改配置,或带上原有变量重跑;只想刷新密钥时用 `./scripts/init.sh --env-only`。
没有 `config.yml` 也能启动:`platforms` 为空、`auth` 为空即“无模型 + 不启用登录”,登录后从设置页补齐即可(保存后点「重启服务」生效)。
### 2. 启动
```bash
# 迁移:把旧版根目录的 config.yml 原样留着即可,init.sh 不会动它
docker compose up -d --build
docker compose logs -f agent-core
```
@@ -80,7 +78,7 @@ docker compose logs -f agent-core
首次启动还会运行一次性的 `agent-executor-init`,把技能依赖安装到 `./skills/deps`,随后自动退出,属正常现象。
### 3. 访问
### 3. 访问与首次配置
浏览器打开:
@@ -88,25 +86,57 @@ docker compose logs -f agent-core
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 服务
`init.sh` 默认把仓库内 `mcp/` 的三个服务写进 `config.yml`:
初始 `config.yml` 不包含任何 MCP 服务。设置页「MCP」会把四个同栈服务作为**内置服务卡片**列出来,
点卡片 → 填表 → 保存即可(url 与 header 名由 `app/server/presets.json` 提供,不用记)。
`web_search` 免费、无需 key;另外三个要填上游 key。手工写 YAML 的形状如下(容器不存密钥):
```yaml
mcp_servers:
- name: web_search
url: "http://mcp_web_search:3000/"
- name: image_task
url: "http://mcp_image_task:3000/mcp"
- name: video_task
url: "http://mcp_video_task:3000/mcp"
# - name: image_task
# url: "http://mcp_image_task:3000/mcp"
# headers:
# Authorization: Bearer <upstream-api-key>
# X-Image-Task-Base-Url: "https://open.bigmodel.cn/api/paas/v4" # 任意 OpenAI 兼容的 images 上游(生成 /images/generations、编辑 /images/edits)
# 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` 与 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)。
`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 主流程,但对应工具不会下发给模型。
@@ -120,7 +150,7 @@ mcp_servers:
`skill` 用于「能力包在技能后面」的场景:工具照常发现并注册,只是不进模型的 tools 数组,改为以技能形式暴露——`{"op":"list"}` 能看到它,`{"op":"get","name":"<名>"}` 直接返回 MCP 原始的 `description` + `input_schema`,`{"op":"run","name":"<名>","args":{…}}` 转发给服务。不用在 `skills/` 里建目录。旧字段 `enable` 已废弃,`mode: silent` 已移除(启动会报错并提示改用 `skill`)。
工具发现只在启动时做一次,因此发现失败后会自动按 **2s / 20s / 1min 重试 3 次**(覆盖 compose 并行拉起与宿主机重启后的容器乱序);成功后工具在下一轮请求即可用,三次都失败则需重启 core。三个 MCP 服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。
工具发现只在启动时做一次,因此发现失败后会自动按 **2s / 20s / 1min 重试 3 次**(覆盖 compose 并行拉起与宿主机重启后的容器乱序);成功后工具在下一轮请求即可用,三次都失败则需重启 core。四个 MCP 服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。
---
@@ -170,6 +200,7 @@ mcp_servers:
在「设置 → 账户 → 微信绑定」生成二维码,扫码后即可单线对话:
- 微信消息复用同一套会话和命令层,支持 `/new`、`/list`、`/switch`、`/delete`、`/rename`、`/models`、`/think`、`/stop`、`/compact`、`/clear`、`/status`、`/help`。
- 回合进行中发消息=自动干预:当前工具调用跑完就插话(同批剩余调用标记为「因你介入未执行」),不会等本轮结束,也不会打断正在执行的命令。要立刻中止用 `/stop`。
- 图片、视频、文件会落到当前会话目录;单发媒体只留痕,不唤醒 AI。
- AI 最终回复会推回微信;较长回复自动分段,超长时落成 `.md` 文件卡片。
- 定时任务完成或失败也会通知微信。
@@ -238,12 +269,13 @@ platforms:
| `PORT` | core 监听端口,容器内 `8090` |
| `EXECUTOR_URL` | `agent-executor` 地址;空则命令在 core 进程内本地执行,仅适合开发 |
| `EXECUTOR_TOKEN` | core ↔ executor 的 Bearer token,两侧同值 |
| `ASR_URL` | core 拼接 `/transcribe` 的基地址,compose 里固定 `http://mcp_asr:3000`(把 `mcp_asr` 放别处时改那一行) |
| `ASR_LOG_LEVEL` | `mcp_asr` 日志等级 |
| `WXBOT_URL` | wxbot 地址;置空则微信功能整体关闭 |
| `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 数组) |
| `EXECUTOR_LOG_LEVEL` / `WXBOT_LOG_LEVEL` | 两个附属服务的日志等级 |
| `WEB_SEARCH_PORT` / `IMAGE_TASK_PORT` / `VIDEO_TASK_PORT` | 仅调试:临时把对应 MCP 服务映射到宿主机端口(默认注释掉) |
`config.yml` 与 `.env` 都含密钥,已在 `.gitignore` 中。不要提交,也不要挂给不需要它的容器。
@@ -328,6 +360,7 @@ http://<host>/p/<id>
- 只由 core 进程内的工具签发,签发前校验文件在任务目录内且 `realpath` 未越界。
- 默认 30 分钟过期,可配置 1 分钟到 24 小时。
- 链接可重复使用,直到过期;服务重启后全部失效。
- 响应头按类型分开:图片(`png/jpg/webp/gif/bmp/tif/avif/ico/svg`)返回 `inline` + 对应 `image/*`,点开链接直接看图;其余类型返回 `attachment`,交给浏览器/WebView 下载(SVG 额外带 `Content-Security-Policy: sandbox`,禁止内嵌脚本)。
- 任何人拿到链接即可匿名访问,不要对含密钥的文件签发。
### HTTPS
@@ -346,7 +379,7 @@ proxy_buffering off;
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 的部署,直接把它填成域名即可。
---
@@ -389,8 +422,14 @@ docker compose logs -f agent-core
docker compose logs -f agent-executor
docker compose logs -f agent-wxbot
curl -s http://127.0.0.1:8090/api/health
# {"ok":true,"service":"agent-core","api":1,"time":...,"auth_required":true}
```
- `GET /api/health` 是**唯一免登录接口**,供运维探活,也供套壳 App 校验用户手填的服务器地址。
客户端判定条件:HTTP 200 且 `ok === true` 且 `service === 'agent-core'`——**不要只看状态码**,
填错到别的站点或反代首页同样可能回 200。地址末尾的 `/` 可带可不带。
`auth_required` 用于区分「地址对了但没登录」与「地址错了」。
- core 日志等级由 `config.yml` 的 `log_level` 控制,改完重启生效。
- executor / wxbot 的日志等级由各自环境变量控制,`debug` 会打印完整交互。
- 启动时会在 `data/prompt.txt` 写入实际下发的 system prompt 与各 profile 的工具清单,便于核对。
@@ -400,7 +439,10 @@ curl -s http://127.0.0.1:8090/api/health
| 现象 | 原因 / 处理 |
|---|---|
| 启动时报 `network agent-mcp-net has active endpoints` | 旧的双仓库部署残留:先停旧的 mcp 仓库(`docker compose down`),再 `up` 本栈 |
| `config.yml` 变成目录 | 启动前文件不存在,Docker 自动建了同名目录;停容器、删目录、放入配置文件 |
| 套壳 App 填了服务器地址仍连不上 | 先 `curl <地址>/api/health` 看是否返回 `service:agent-core`;再查 Android 9+ 默认禁止明文 HTTP(需 `usesCleartextTraffic`)与 https 自签证书 |
| 麦克风按钮不显示 | `config.yml` 的 `mcp_servers` 里没有启用的 `asr` 段 / 该段缺 `X-ASR-Base-Url`(`GET /api/asr/status` 会返回 `reason`);或浏览器以 `http://<IP>` 访问且没有原生录音桥(非安全上下文开不了麦,见 `docs/voice-input.md`) |
| 点麦克风提示「语音识别服务不可用」 | `mcp_asr` 未起来(`docker compose logs --tail=50 mcp_asr`);或 `config.yml` 的 `asr.headers` 缺 `X-ASR-Base-Url` / `X-ASR-Model` |
| `config.yml` 变成目录 | 启动前文件不存在,Docker 自动建了同名目录;重跑 `./scripts/init.sh` 会自动删除空目录并重建(非空目录需先备份再手工删除) |
| 没有可用模型 | `platforms` 为空或模型全部禁用;在设置页添加后重启 |
| 创建会话报「无可用模型」 | 模型池为空,或指定模型所在平台没有 key |
| 技能依赖缺失 | 重新 `docker compose up -d --build agent-executor`;或检查 `skills/deps` |
+57 -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/config.js` | YAML 加载/校验/默认值;`platforms` 展开成 `cfg.models`;配置文本改写(设置页) |
| `server/presets.json` | 平台与同栈 MCP 的固定契约(url / type / header 名),设置页新增时的模板来源;改服务地址改这里 |
| `server/db.js` | 建表、索引、幂等迁移;纯 SQL 数据层,不放业务 |
| `server/engine.js` | **核心**:会话状态机、模型池调度、Agent 主循环、压缩、标题、日记收口、消息增删 |
| `server/llm.js` | 消息组装、system prompt 拼接、上游流式调用、占位裁剪、多模态块编解码 |
@@ -78,18 +79,56 @@ POST /api/sessions/:id/messages
checkToolArgs:JSON 非法/缺必填 → 整条 assistant 标 type='errAck'
saveMessage(assistant) + recordModelUsage
压缩回合的收尾答复 → type='summary',之前全部消息 → type='archived'
无 tool_calls → 若期间又有新 user 消息则继续,否则收尾
无 tool_calls → 待投递里有「干预」则投递并继续;否则若有新 user 消息继续,否则收尾
有 tool_calls → 逐个 executeTool → saveMessage(tool) → emit tool_result
(每步之后与整批之前各查一次「干预」,命中就先闭合批次再投递)
→ finalize
closeToolBatch(兜底:补齐本批未执行调用的合成回执)
cancelled → status=cancelled
正常 → status=held,emit done,maybeGenerateTitle,run.taskWrap → taskClockOut
收尾后若队列非空 → setImmediate 投递队首(排队模式的唯一出口)
→ maybeAutoCompress(回合彻底结束后才检查)
```
**给前端的是 SSE 事件,不是响应体**。前端在 `GET /api/sessions/:id/stream` 上听:
`status`、`assistant_delta`、`reasoning_delta`、`tool_call_start`、`tool_call_args`、
`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 内的重复读**(一次请求里塞两份同样的图
没意义);跨批次重读一律放行。不要写成「一回合只投递一次」,也不要靠推测「图还在不在上下文里」——
模型说拿不到就得给,而且文件可能已重新生成(路径相同、内容不同);拦掉只会把新像素挡在门外。
- 占位裁剪(`agent.trim_write_rounds` / `trim_result_rounds`):距尾 ≥N 个 assistant 轮的
`write_file.content`、`fetch`/`read_file` 回执换成单行占位。**只改发给上游的副本**,DB 与 UI 不动。
- 占位裁剪(`agent.trim.rules`):指定工具的参数(`side: args` + `fields`,仅顶层字符串)或回执正文
(`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`。**铁律**:压缩请求必须与上一次
常规请求字节同构、只在尾部追加;不要为了省 token 在压缩回合抽掉快照或裁剪历史,断前缀缓存等于全价重读。
- `titleMessages`:不带 system prompt,只取 user/assistant 纯文本行(白名单 `null`/`summary`/`task_brief`)
@@ -266,6 +313,7 @@ preview-proxy.earlyGuard
express.static(public)
/api/sessions ×4 ← sessions / messages / files / skill-run(通用执行面)
/api/skills
/api/asr ← 语音识别代理:/transcribe 走登录态;ASR_URL 空或配置里无可用 asr 段则 503
/api/config ← requireAdmin
/api/platforms
/api/system ← /restart 需 admin,其余登录即可
@@ -274,6 +322,8 @@ express.static(public)
/api/memory
/api/wechat
/api/channel
/api/health ← 免认证探活:套壳 App / 运维脚本用它校验服务器地址
(只认 200 + body.ok + service==='agent-core')
data-page ← GET /app/:task_id/*、POST /api/db/:task_id/query
preview-proxy.mount(末尾兜底)
```
@@ -281,13 +331,15 @@ preview-proxy.mount(末尾兜底)
- 错误形状统一 `{ error: string }`,`err.status_code` 决定 HTTP 码。
- 认证:HMAC 签名 HttpOnly cookie(`agent_token`),`Authorization: Basic` 兜底,
`Authorization: Bearer` 仅用于 `/api/login_restore`。`auth.users` 为空 = 完全关闭认证。
- 免认证路径集中在 `auth.js` 的 `PUBLIC_EXACT`(含 `/api/health`,且容忍尾斜杠)。
新增免登录接口必须加进去,否则会被中间件先拦成 401。
- **单租户警告**:除管理员接口外不做资源级授权;按用户的会话列表隔离在查询层(`sessions.user`)。
- 公网短链 `/p/<id>` 的信任模型:随机 ID + 服务端 TTL + 签发时 `realpath` 校验,不靠登录态。
## 前端(`server/public/`)
- **无构建**:`index.html` 按顺序加载经典脚本,共享全局作用域:
`core.js → chat.js → sessions.js → stream.js → files.js → preview.js → settings.js`
`core.js → chat.js → sessions.js → stream.js → files.js → voice.js → preview.js → settings.js`
(`settings.js` 必须最后,尾部有全局初始化);`marked.min.js` 走 `vendor/`。
- 新增 JS 文件必须同时改 `index.html` 的 `<script>` 顺序——没有 import/export,顺序就是依赖。
- `sw.js`:HTML/JS/CSS 网络优先,图片/JSON 缓存优先。**改图片或 JSON 才需要升 `CACHE_VERSION`**;
+52 -4
View File
@@ -27,7 +27,7 @@ data_root: "/workspace/data" # 数据根目录:SQLite
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 注)
# 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 生成,两侧同值)。
terminal:
@@ -47,8 +47,43 @@ agent:
max_retries: 2 # 上游失败重试次数
language: "Simplified Chinese" # 强制回复语言;留空不限
auto_compress_tokens: 60000 # In token 超此值弹「自动压缩」提议;0=关
trim_write_rounds: 1 # 历史重放裁剪:write_file 参数正文距尾 ≥N 个 assistant 轮换单行占位(0=关;DB/UI 不动,盘上可重读)
trim_result_rounds: 2 # fetch/read_file 回执正文距尾 ≥N 个 assistant 轮换单行占位(0=关;占位留 url/path 作恢复指针)
# 历史重放占位裁剪(省 token):把「可再生的重负载」换成单行占位再发给上游
#(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=关(纯状态动作,历史/模型绑定不动)
# 长期记忆(日记,memory.js):收口时一条几十字第一人称碎片入当日条目;存储默认永久,旧记忆靠回忆下钻
@@ -79,9 +114,22 @@ auth: # users 留空 = 不启用登
role: admin # admin=管理员(全部设置 + 用户管理);user 或缺省=普通用户(仅账户页)
# model: qwen-tp/qwen3.8-flash # 选填:该用户新建会话时锁定的模型(内部键「平台名/模型id」)
# MCP 服务列表(仓库自带的 mcp/ 三个服务,或栈外服务):每项 {name?, url, headers?, mode?(默认 advertise), timeout_ms?, tools_allow?, tools_deny?}。
# MCP 服务列表(仓库自带的 mcp/ 服务,或栈外服务):每项 {name?, url, headers?, mode?(默认 advertise), timeout_ms?, tools_allow?, tools_deny?}。
# mode 三态:advertise=工具下发给模型;skill=不下发,改为以技能形式暴露(get 返回原始 input_schema,run 转发);
# disable=不连接、不发现。旧字段 enable 已废弃;mode: silent 已移除(改用 skill),写进配置会启动报错。
#
# 语音识别(mcp/asr)建议用 skill:转写音频是低频能力,不必把 schema 塞进每轮请求。
# 上游参数(key / base_url / model)由 core 随请求带给 mcp_asr,容器自己不存密钥,
# 也不预设任何平台——任何 OpenAI 兼容的 /audio/transcriptions 都行。免鉴权的自建服务可省 Authorization。
# - 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
# 注意:输入框里的语音输入走的是 core 的 /api/asr(由 compose 的 ASR_URL 接线),也读这一段的 headers;
# 不经工具、不消耗 token。mode: disable 或删掉这段 = 麦克风入口关闭。
mcp_servers: []
public_link:
+2 -2
View File
@@ -1,12 +1,12 @@
{
"name": "agent-app",
"version": "2.3.0",
"version": "2.4.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "agent-app",
"version": "2.3.0",
"version": "2.4.0",
"dependencies": {
"better-sqlite3": "11.3.0",
"cron-parser": "5.10.1",
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "agent-app",
"version": "2.3.0",
"version": "2.5.0",
"description": "自用通用 Agent 系统:多模型调度 + 任务目录 + 工具调用 + H5 Web UI",
"main": "server/server.js",
"scripts": {
+4 -1
View File
@@ -73,7 +73,10 @@ function basicAuthUser(req, users) {
// ---------- 免认证路径(登录页自身需要的资源) ----------
const PUBLIC_EXACT = new Set(['/login', '/logout', '/api/login', '/api/logout', '/api/login_restore', '/api/health']);
function isPublicPath(p) {
if (PUBLIC_EXACT.has(p)) return true;
// 尾斜杠容忍:客户端手动填服务器地址常多带一个 `/`(拼成 `/api/health/`),
// Express 路由本身能匹配,但这里若不规范化,中间件会先回 401——地址明明是对的却报未登录。
const norm = p.length > 1 ? p.replace(/\/+$/, '') : p;
if (PUBLIC_EXACT.has(norm)) return true;
if (p.startsWith('/css/')) return true; // 登录页复用 style.css
if (p === '/favicon.ico') return true;
return false;
+183 -20
View File
@@ -86,9 +86,24 @@ const DEFAULTS = {
// auto_compress_tokens:本轮 In token 峰值 ≥ 此值时推送「自动压缩」提议(0=关)。
// auto_complete_ms:held(保持中)超过此时长自动收口为 completed(0=关)。key 非独占后 held 不占任何资源,
// 收口是纯视觉动作:历史/绑定不动,再发言照常由 completed 分支续跑(见 engine.sweepHeldTimeouts)。
// trim_write_rounds / trim_result_rounds:历史重放占位裁剪(llm.buildMessages)——write_file 参数正文 /
// fetch、read_file 回执正文距尾 ≥N 个 assistant 轮后换单行占位(DB/UI 不动,内容可再生:盘上重读/重抓);0=关。
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 },
// 历史重放占位裁剪(llm.buildMessages):trim.rules 逐条声明「哪个工具、参数侧还是回执侧、
// 距尾多远换单行占位」;只改发给上游的副本,DB/UI 不动。
// 两个距离条件**同时满足**才裁:
// 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 下发前端)。
// 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 },
@@ -126,7 +141,7 @@ const DEFAULTS = {
// mode 三态:advertise=工具下发给模型;skill=不下发,改为以技能形式暴露(get 返回原始
// input_schema,run 直接转发);disable=不加载。
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 },
};
@@ -236,10 +251,85 @@ function normalizePlatforms(rawPlatforms, profileNames) {
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 仅记录来源,可为空。
function parseAndValidate(rawText, configPath) {
let raw = YAML.parse(rawText || '') || {};
const cfg = deepMerge(DEFAULTS, raw);
normalizeAgentTrim(cfg);
// ---------- 模型配置:platforms 层级(platforms[].models[] + platforms[].keys[])----------
// models 提到平台层(与 url/type 同级),多 key 共用同一份 models。
@@ -383,16 +473,14 @@ function parseAndValidate(rawText, configPath) {
// 公网链接宁可短不可长(“永久公开”正是这套机制要避免的东西)。
//
// 对外前缀的取值优先级:
// 1) 容器 env 的 VIRTUAL_HOST 非空 → https://<第一个域名>
// (nginx-proxy 的写法,逗号分隔多域名时取第一个)。只要配了域名 + HTTPS 这一层,
// 返回给外部服务(video_task 取参考图)的链接就必须走域名,所以 env 优先;
// 反之 config.yml 里那个 init 脚本生成的 http://<IP>:8090 会把这个开关盖住。
// 协议写死 https:前置了 nginx-proxy 一定是 HTTPS(证书由 acme-companion 签)。
// 2) 否则用 config.yml 的 public_link.base_url(纯 IP:端口部署,init 脚本写 http://<IP>:8090)。
// 1) config.yml 的 public_link.base_url(设置页「公网地址」手填的值,以它为准)。
// 2) env PUBLIC_BASE_URL(scripts/init.sh 探测公网 IP 后写进 .env 的部署地址)。
// 它只是默认值:页面里填过 1) 之后就归 1) 管,避免“重跑部署脚本”和“UI 手改”互相打架。
function normalizePublicLink(cfg) {
const pl = cfg.public_link || {};
const vhost = String(process.env.VIRTUAL_HOST || '').split(',')[0].trim();
const baseUrl = vhost ? 'https://' + vhost : pl.base_url;
const fromCfg = String(pl.base_url == null ? '' : pl.base_url).trim();
const fromEnv = String(process.env.PUBLIC_BASE_URL || '').trim();
const baseUrl = fromCfg || fromEnv;
cfg.public_link = {
base_url: String(baseUrl || '').trim().replace(/\/+$/, ''),
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) {
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);
}
@@ -418,25 +521,85 @@ function loadConfigFromText(text, configPath) {
// 读当前配置文件原文(保留注释);文件不存在返回 null。
function readConfigText(cfg) {
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');
}
// 单项编辑:[{path:[...], value}] 或 [{path:[...], delete:true}] 或 [{path:[...], value, append:true}]。
// 用 YAML Document 写回,保留注释与排版;路径段为纯数字时按数组下标处理(如 ["platforms",0,"keys",1,"models",0])。
// 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) {
const doc = YAML.parseDocument(text || '');
for (const e of edits || []) {
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);
if (e.delete) doc.deleteIn(docPath);
else if (e.append) {
if (e.delete) { doc.deleteIn(docPath); continue; }
if (e.append) {
const item = styledNode(doc, e.value, true);
const target = doc.getIn(docPath, true);
if (target && typeof target.add === 'function') target.add(e.value);
else if (target === null || target === undefined) doc.setIn(docPath, [e.value]);
else throw new Error('配置项 ' + docPath.join('.') + ' 不是数组,无法追加');
} else doc.setIn(docPath, e.value);
if (target && typeof target.add === 'function') {
target.flow = false; // 与 block 化的新项保持一致,否则父数组仍是 flow
target.add(item);
} 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();
}
+49 -5
View File
@@ -1,4 +1,4 @@
// 单文件下载响应的公共实现:任务文件的浏览器下载(routes/files.js)与公网临时文件
// 单文件下载 / 内联响应的公共实现:任务文件的浏览器下载(routes/files.js)、公网临时文件
// (routes/public-files.js)共用,避免两处各写一套文件名/缓存策略。
'use strict';
@@ -9,13 +9,37 @@ const path = require('path');
// 老 AOSP DownloadManager 的正则解析失败而改从 URL 猜名(download.pdf)。
// 这里传统 filename= 直接放百分号编码的 UTF-8:朴素解析器解码后能得到真名,
// 标准客户端照旧优先 filename*(RFC 5987)。
function downloadDisposition(name) {
function contentDisposition(name, type) {
const legacy = encodeURIComponent(name);
// RFC 5987 attr-char 不含 ' ( ) ! *,ext-value 里需额外编码
const ext = legacy.replace(/['()!*]/g, function (c) {
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 不受影响)。
// 不能用 res.download:它会用 content-disposition 包覆盖上面的文件名策略;
// 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('Pragma', 'no-cache');
res.setHeader('Expires', '0');
}
function sendDownload(res, abs) {
noStore(res);
res.setHeader('Content-Disposition', downloadDisposition(path.basename(abs)));
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;
const runs = new Map(); // session_id -> {cancelled, procs:Set, abortController, looping:boolean}
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();
@@ -142,6 +149,8 @@ function emitStatus(sessionId) {
session_id: sessionId,
status: s.status,
model_id: s.model_id,
// 待投递队列一并带上:前端把条幅当成服务端状态的回显,重连/换设备后自动对齐
pending: listPending(sessionId),
});
}
@@ -456,6 +465,48 @@ function killRunProcs(run) {
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 主循环 ----------
async function runLoop(sessionId) {
const run = getRun(sessionId, true);
@@ -481,22 +532,34 @@ function finalize(sessionId, run) {
const s = getSession(sessionId);
if (!s || s.status !== 'active') { runs.delete(sessionId); return; }
const cancelled = run.cancelled;
// 兜底:回合结束时本批 tool_call 必须逐个有回执。取消/异常/进程被杀都可能留下半批,
// 缺的补一条「未执行」合成回执——这是「工具调用不匹配」的唯一根治点。
try { closeToolBatch(sessionId, cancelled ? (run.interruptReason || '用户已终止任务:') : '回合异常结束:'); }
catch (e) { log.warn('tool', sessionId + ' 关闭工具批次失败:' + (e && e.message || e)); }
if (cancelled) {
touch(sessionId, { status: 'cancelled', cancelled_at: now(), completed_at: null });
runs.delete(sessionId);
bus.emit(sessionId, 'done', { status: 'cancelled' });
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 不阻塞收尾。
@@ -736,6 +799,13 @@ async function runLoopInner(sessionId, run) {
}
if (!hasTools) {
// 「干预」升级过的待投递消息:本条回复已落库,正是安全边界——直接插话并继续同一回合
//(不用等 finalize 再开新一轮,模型能接着刚才的上下文改弦更张)。
const head = headPending(sessionId);
if (head && head.mode === 'interject') {
deliverPendingHead(sessionId);
continue;
}
// 回合结束;但若期间用户又发了新消息(live 投递),继续下一轮而不是收尾
if (!hasUserSince(sessionId, lastIncludedId)) break;
continue;
@@ -743,8 +813,19 @@ async function runLoopInner(sessionId, run) {
// 执行工具
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 据此判是否立题,
// 见 maybeGenerateTitle);errAck 批(参数畸形、下轮整轮对模型不可见)不算。
// 见 maybeGenerateTitle);errAck 批(参数畸形、下轮整轮对模型不可见)不算,
// 被干预整批跳过(上面已 continue)也不计。
if (!isErrAck) run.toolWorked = true;
for (const tc of msgRow.tool_calls) {
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,
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++;
}
if (iter >= maxIter && !run.cancelled) {
@@ -1058,6 +1150,143 @@ function createSession(title, preferModelId, assistantType, user) {
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);
// 绑定失效(配置改动后原模型被删/禁用)由 ensureBinding 自动改选,用户无感。
// opts.deepThink: true 时启用模型该「深度思考」参数(记在会话 run 上,正在跑的回合下一轮迭代会取到最新值)。
@@ -1088,9 +1317,13 @@ function postUserMessage(sessionId, content, opts) {
function stop(sessionId) {
const session = getSession(sessionId);
if (!session) throw Object.assign(new Error('会话不存在'), { status_code: 404 });
// 「停止」= 全停:待投递队列一并作废。否则 finalize 会立刻把队首当成新回合发出去,
// 与用户按停止的意图相反(「立即发送」不走这里,它只中断当前回合、保留队首)。
clearPendings(sessionId);
const run = runs.get(sessionId);
if (run) {
run.cancelled = true;
run.interruptReason = '用户已终止任务:';
killRunProcs(run);
if (run.abortController) { try { run.abortController.abort(); } catch (_) {} }
}
@@ -1415,6 +1648,7 @@ function clearSessionMessages(sessionId) {
if (run.abortController) { try { run.abortController.abort(); } catch (_) {} }
}
runs.delete(sessionId);
clearPendings(sessionId); // 历史清零:队列里的消息也没了着落,一并作废
db.prepare('DELETE FROM messages WHERE session_id = ?').run(sessionId);
wipeSessionTmp(sessionId); // 会话级 /tmp 随清空一并抹掉(尽力而为,失败只记日志不阻断)
autoCompressProposed.delete(sessionId); // 历史清零,恢复自动压缩提议额度
@@ -1523,6 +1757,10 @@ module.exports = {
activeRuns,
createSession,
postUserMessage,
enqueueMessage,
promotePending,
cancelPending,
listPending,
stop,
releaseHold,
renameSession,
@@ -1537,6 +1775,7 @@ module.exports = {
loadHistory,
checkToolArgs, // 参数预检/信封解包两个纯函数:导出供探针与回归验证(运行链路由 runLoopInner 内部调用)
unwrapToolArgs,
closeToolBatch, // 批次闭合兜底:导出供回归验证(正常链路由 runLoopInner / finalize 调用)
saveMessage,
recordModelUsage,
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));
for (const k of Array.from(session.blocksCache.keys())) if (!ids.has(k)) session.blocksCache.delete(k);
}
// 裁剪预扫:① 每行距尾的 assistant 轮数(从尾往头扫);② tool_call id → function
// (给 fetch/read_file 占位回填 url/path)。trimOn=false 时整个跳过(压缩回合)。
const trimActive = trimOn !== false && (TRIM.writeRounds > 0 || TRIM.resultRounds > 0);
// 裁剪预扫:① 每行距尾的 assistant 轮数(rounds)与真人回合数(turns),一趟从尾往头扫;
// ② tool_call id → function(result 侧规则需要反查工具名)。
// 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 turnsAfter = new Map();
const callById = new Map();
if (trimActive) {
let n = 0;
let t = 0;
for (let i = history.length - 1; i >= 0; i--) {
const r = history[i];
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 (TRIM.resultRounds > 0) {
if (TRIM.resultByTool.size > 0) {
for (const r of history) {
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 (_) {}
@@ -219,7 +226,33 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
}
// tool 回执按 tool_call_id 索引:给 errAck 行拼错误提示时取执行时挡下的原因
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):
// 描述写在 content 里 + 继续调工具,就是模型真看到图的证据(见文件头注释的循环复盘)。
// errAck / archived 不发模型,不算回复:它们之前的图不算被消费。
@@ -293,8 +326,20 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
// reasoning_ack_field 改名注入后此键必被剥除,不会泄往上游)。
if (row.reasoning) m.__reasoning = row.reasoning;
if (row.tool_calls) {
m.tool_calls = JSON.parse(row.tool_calls);
if (trimActive && TRIM.writeRounds > 0) trimWriteCalls(m.tool_calls, roundsAfter.get(row.id) || 0);
let calls = [];
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;
messages.push(m);
@@ -302,6 +347,8 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
}
// errAck 轮的 tool 回执:随该轮一起丢弃,避免无主 tool 消息
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 缓存);已消费的图只留文字描述 + 标记
const blocks = cachedDecodeBlocks(session, row);
let content = row.content || '';
@@ -354,7 +401,7 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
}
}
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 });
} else {
messages.push({ role: row.role, content });
@@ -382,46 +429,86 @@ function buildMessages(session, language, mintUrl, profile, withProfile, trimOn)
}
// ---------- 重负载占位裁剪(历史重放省 token) ----------
// fetch/read_file 回执与 write_file 参数正文是重放里最贵的存量,且都可再生:文件在盘上、
// 页面可重抓;write 参数只是当时快照(后续 edit_file 一次就失真,本就不该被当现势引用)。
// 组装请求时对「距尾 ≥N 个 assistant 轮」的行换单行占位:纯函数、DB 不动(UI 工具卡照旧
// 可展全量)、与压缩归档正交(archived 行本来就不进模型)。距离按现存行数 assistant 轮:
// 删中间消息可让已占位行短暂复活全文(一次性断前缀缓存,与图片消费 i<lastAck 同一
// 语义,接受)。阈值可配(config agent.trim_write_rounds / trim_result_rounds,0=关),
// 启动时 setPayloadTrim 注入。
let TRIM = { writeRounds: 1, resultRounds: 2 };
const TRIM_MIN_CHARS = 600; // 短正文不裁:占位行自身成本接近原文,裁了反而胀
function setPayloadTrim(agentCfg) {
const a = agentCfg || {};
const toN = (v, d) => { const n = Math.floor(Number(v)); return Number.isFinite(n) ? Math.max(0, n) : d; };
TRIM = { writeRounds: toN(a.trim_write_rounds, 1), resultRounds: toN(a.trim_result_rounds, 2) };
// 策略只在配置里:默认值来自 config.js 的 DEFAULTS.agent.trim.rules,config.yml 写了
// agent.trim.rules 就整体替换([] = 全关)。本模块不含任何工具名或默认阈值;未注入 = 不裁剪。
// 语义:某条工具调用/回执距对话尾部 ≥rounds 个 assistant 轮**且** ≥turns 个真人回合后,把其中
//「可再生的重负载」——args 侧指定参数正文、result 侧整段回执——换成单行占位再发给上游。
// rounds = 「后面 AI 又说了几句话」,turns = 「后面又来了几条真人消息」;
// turns:1 就是「回合内绝不裁,跨过用户回合边界才裁」(长回合里防模型反复重读同一段)。
// 只应给可再生/快照型工具开规则:占位只改发给上游的副本(DB/UI 照旧可看全量),但模型侧
// 一旦被裁就再也看不到那段内容(如 terminal 的一次性输出)。
// 纯函数、与压缩归档正交(archived 行本来就不进模型)。距离按现存行数:删中间消息可让已占位行
// 短暂复活全文(一次性断前缀缓存,与图片消费 i<lastAck 同一语义,接受)。
function compileTrimRules(rules) {
const argsByTool = new Map();
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 不必重复,
// 本条 arguments 里就还在;改写的是已 parse 副本,DB 行不动,重新 stringify 保持 JSON 合法。
function trimWriteCalls(calls, rounds) {
if (rounds < TRIM.writeRounds) return;
let TRIM = compileTrimRules([]);
function setPayloadTrim(agentCfg) {
const trim = (agentCfg && agentCfg.trim && typeof agentCfg.trim === 'object' && !Array.isArray(agentCfg.trim))
? 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 || []) {
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;
try { args = JSON.parse(c.function.arguments || ''); } catch (_) { continue; }
if (!args || typeof args.content !== 'string' || args.content.length < TRIM_MIN_CHARS) continue;
args.content = '[OMITTED, size=' + args.content.length + ']';
c.function.arguments = JSON.stringify(args);
if (!args || typeof args !== 'object' || Array.isArray(args)) continue;
let changed = false;
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 行仍载着
// 它们,参数本身就是恢复指针。图片回执(blocks 非空)不碰:已有自己的消费省略逻辑。
function trimToolContent(content, row, callById, roundsAfter) {
if (TRIM.resultRounds <= 0 || content.length < TRIM_MIN_CHARS) return content;
if ((roundsAfter.get(row.id) || 0) < TRIM.resultRounds) return content;
// result 侧占位:整段回执换单行。图片回执(blocks 非空)在上游分支里已还原成文字/图块,
// 这里只处理纯文本;status_regex 可把状态码写进占位(如 fetch 的 HTTP 状态)。
function trimToolContent(content, row, callById, roundsAfter, turnsAfter) {
if (typeof content !== 'string') return content;
const fn = callById.get(row.tool_call_id);
const name = row.name || (fn && fn.name) || '';
if (name !== 'fetch' && name !== 'read_file') return content;
if (name === 'fetch') {
const hm = /^HTTP (\d{3})/.exec(content);
return '[OMITTED' + (hm ? ', http_status=' + hm[1] : '') + ', size=' + content.length + ']';
const rule = TRIM.resultByTool.get(name);
if (!rule) return content;
if ((roundsAfter.get(row.id) || 0) < rule.rounds) return content;
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 + 正常历史
+26 -3
View File
@@ -18,7 +18,21 @@ const CALL_TIMEOUT_MS = 60000;
let toolDefs = []; // OpenAI function 格式(所有 MCP 工具)
const toolIndex = new Map(); // 发送名 -> { server, tool, def }(服务配置 + 原始工具名 + 原始契约)
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 / 无法解析时抛异常)。
// 某些 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 与 ' +
'服务端实际工具名(如 ' + all.slice(0, 3).map(t => t.name).join(', ') + ' …)');
}
setStatus(s, { ok: true, tools: tools.length, hidden: hidden });
return true;
} 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;
}
}
@@ -208,6 +229,7 @@ function retryFailed(failed) {
async function init(cfg) {
toolDefs = [];
toolIndex.clear();
statusMap.clear();
PUBLIC_BASE = (cfg && cfg.public_link && cfg.public_link.base_url) || '';
try {
for (const d of require('./tools/definitions.json')) {
@@ -221,6 +243,7 @@ async function init(cfg) {
// mode: disable 时启动不加载该服务(不建工具表;配置保留,改回 advertise 重启后恢复)
if (s.mode === 'disable') {
log.info('mcp', s.name + ': mode=disable,跳过工具加载');
setStatus(s, { disabled: true });
continue;
}
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"
}
]
}
]
}
+186 -25
View File
@@ -11,12 +11,24 @@
--drawer-bg: rgb(249, 250, 251); /* 侧边栏底色(与页面白底区分;分组表头吸顶同色) */
--border: #ececf1;
--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; }
/* 整站是视口锁定的 app shell:文档本身永不滚动,滚动只发生在内部容器
(消息流 #chat-view / 抽屉列表 .drawer-list / 设置页 .set-scroll,均已 overflow-y:auto)。
不写 overflow:hidden 时,桌面端只要有一行内容没收缩下(nowrap 胶囊/代码块/宽表格),
浏览器就给窗口加横向滚动条;横向条又吃掉一屏高度,而 #app 死守 height:100%,
浏览器就给窗口加横向滚动条;横向条又吃掉一屏高度,而 #app 死守视口高度,
于是竖横向滚动条一起出现、缩窗口页面不动。 */
html, body { height: 100%; overflow: hidden; }
body {
@@ -37,7 +49,9 @@ input, textarea { font: inherit; color: inherit; border: 0; outline: none; backg
/* ================= 应用骨架 ================= */
#app {
height: 100%;
/* 减去 --kb:键盘弹起时整块 shell 收缩,footer 才会落在键盘上沿。
壳已正确 resize(adjustResize / resizes-content)时 --kb 恒为 0,不重复收缩。 */
height: calc(100% - var(--kb));
max-width: 760px;
margin: 0 auto;
display: flex;
@@ -53,7 +67,8 @@ input, textarea { font: inherit; color: inherit; border: 0; outline: none; backg
display: flex;
align-items: center;
gap: 8px;
padding: 10px 12px;
/* 顶栏自己吃下状态栏高度(背景跟着铺上去,不留白条);设置页顶栏同用 .header */
padding: calc(10px + var(--sat)) 12px 10px;
min-height: 56px;
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; }
/* ================= 底部输入区 ================= */
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-chip {
display: inline-flex; align-items: center; gap: 6px;
@@ -338,6 +353,7 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
}
.up-card.done::after, .up-card.err::after { display: none; }
.input-shell {
position: relative; /* 按住说话的遮罩以它为定位基准 */
display: flex;
flex-direction: column;
align-items: stretch;
@@ -404,6 +420,87 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
}
.plus-btn:active { background: #dde0e6; }
.plus-btn.active { background: var(--active-soft); color: var(--active); } /* 文件面板展开时高亮 */
/* 语音模式:输入框位置换成「按住 说话」——只有居中文字,不做出按钮外观 */
#voice-hold {
position: relative;
height: 44px; border-radius: 8px;
display: flex; align-items: center; justify-content: center;
font-size: 15px; color: var(--ink); cursor: pointer;
user-select: none; -webkit-user-select: none; -webkit-touch-callout: none;
touch-action: none; transition: background .12s;
}
/* 按住区与下方操作栏之间的分隔线(用伪元素画,避开录音态底色的圆角) */
#voice-hold::after {
content: '';
position: absolute; left: 0; right: 0; bottom: -1px;
height: 1px; background: var(--border);
}
/* 录音中给一个极浅底色作反馈(文字同时变成「松开 结束」) */
#voice-hold.recording { background: var(--surface); }
/* 录音期间:输入卡内容整体让位给遮罩(遮罩不再透光,按钮/文字留着会和提示叠字) */
body.voice-active .input-shell { border-color: transparent; box-shadow: none; }
/* #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 .scroll-bottom-btn { display: none; }
/* 按住说话的遮罩:左右贴屏幕两边;底部一直铺到屏幕底(含 footer 的 10px 内边距与安全区),
向上多铺 72px 把输入卡上方那一条会话流也盖住。
声波中心对齐「按住 说话」那一行:padding-bottom 70px + 安全区 =
59(声波中心到输入卡底部)+ 11(遮罩底边向下外扩的 1px 边框 + 10px footer 内边距)。 */
#voice-overlay {
position: absolute;
top: -72px;
bottom: calc(-11px - var(--sab));
left: -13px; right: -13px;
z-index: 6;
display: flex; flex-direction: column; align-items: center; justify-content: flex-end;
gap: 20px;
padding-bottom: calc(70px + var(--sab));
/* 底色必须是**不透明**的 var(--page):早先只铺一层 9% 蓝渐变,遮罩伸进会话流的那一段
会把底下的消息文字透出来,「松手传送」看着就成了半透明。
顶层那 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);
pointer-events: auto; touch-action: none;
transition: background .15s linear, color .15s linear;
}
/* 上滑取消态:整体换成极淡的红调,声波/文案同步变红 */
#voice-overlay.cancel {
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;
}
/* 提示文案落在外挂层上,用比 --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%; }
/* 柱子高度用 scaleY 而不是 height:只走合成层,不触发重排 */
.vo-wave i {
display: block; width: 3px; height: 34px; border-radius: 2px;
background: currentColor;
transform: scaleY(.12); transform-origin: center;
transition: transform 70ms linear;
}
/* 上滑取消态:声波与文案统一转警示色 */
#voice-overlay.cancel .vo-hint { color: #c0392b; }
@media (prefers-reduced-motion: reduce) { .vo-wave i { transition: none; } }
/* 发送键四态:发送 / 停止 / 语音 / 键盘。语音与键盘用中性底色,和蓝色「发送」区分开 */
.send-btn > svg { display: none; }
.send-btn[data-state="send"] .ic-send { display: block; }
.send-btn[data-state="voice"] .ic-voice,
.send-btn[data-state="keyboard"] .ic-kb { display: block; }
.send-btn[data-state="voice"],
.send-btn[data-state="keyboard"] { background: var(--surface); color: var(--ink); box-shadow: none; }
.send-btn[data-state="voice"]:active,
.send-btn[data-state="keyboard"]:active { background: #dde0e6; opacity: 1; }
/* 发送按钮:蓝底白向上箭头 */
.send-btn {
flex: none; width: 36px; height: 36px; border-radius: 50%;
@@ -430,7 +527,7 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
border-radius: 16px 16px 0 0;
box-shadow: 0 -6px 24px rgba(20, 30, 70, 0.16);
transform: translateY(105%); transition: transform .25s ease; /* 收起时滑出屏幕 */
padding-bottom: env(safe-area-inset-bottom, 0px);
padding-bottom: var(--sab);
overflow: hidden;
}
.files-panel.open { transform: translateY(0); }
@@ -526,7 +623,7 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
padding: 10px 14px;
border-top: 1px solid var(--border);
background: var(--page);
padding-bottom: calc(10px + env(safe-area-inset-bottom, 0px));
padding-bottom: calc(10px + var(--sab));
}
.files-panel-count {
font-size: 13px; color: var(--gray);
@@ -679,7 +776,9 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
}
#scrim.show { opacity: 1; pointer-events: auto; }
#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);
background: var(--drawer-bg);
display: flex; flex-direction: column;
@@ -770,7 +869,7 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
/* 底部用户区 */
.drawer-user {
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);
}
.avatar {
@@ -852,12 +951,15 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
/* ================= 全屏查看器(搬自 index;图片单点放大+缩放,消息双击放大) ================= */
#img-viewer { position: fixed; inset: 0; z-index: 150; background: rgba(0,0,0,0.93); display: flex; align-items: center; justify-content: center; overflow: hidden; }
#img-viewer.hidden { display: none; }
#img-viewer-img { max-width: 100vw; max-height: 88vh; touch-action: none; cursor: grab; user-select: none; -webkit-user-drag: none; }
/* 两层 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-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.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-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-btn {
flex: none; display: flex; align-items: center; justify-content: center;
@@ -874,8 +976,8 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
#fs-viewer.fs-bar .fs-actions {
position: sticky; top: 0; z-index: 1;
flex: none; width: 100%;
height: calc(40px + env(safe-area-inset-top, 0px));
padding: env(safe-area-inset-top, 0px) 10px 0 14px;
height: calc(40px + var(--sat));
padding: var(--sat) 10px 0 14px;
justify-content: flex-end; gap: 6px;
background: var(--page); border-bottom: 1px solid var(--border);
}
@@ -890,14 +992,14 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
#fs-viewer.fs-bar #fs-body .bubble-ai,
#fs-viewer.fs-bar #fs-body .bubble-user {
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-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-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;
box-shadow: 0 1px 5px rgba(0,0,0,0.22);
font-size: 15px; line-height: 1; cursor: pointer;
@@ -947,7 +1049,7 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
.header-right .icon-btn:active, .header-right label.icon-btn:active { background: var(--surface); }
label.icon-btn { cursor: pointer; }
#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; }
/* ---------- 设置主页卡片 ---------- */
@@ -1105,6 +1207,9 @@ label.icon-btn { cursor: pointer; }
.model-card-state.busy { background: #fdecea; color: #b3382c; }
.model-card-state.pending { background: #fff4dc; color: #a06a00; }
.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 区淡化,开关保持正常亮度可点 */
.model-card.off { background: #f5f6f8; }
.model-card.off .model-card-name, .model-card.off .cfg-kv { opacity: 0.5; }
@@ -1123,6 +1228,8 @@ label.icon-btn { cursor: pointer; }
/* 三段分区:平台字段 / Keys / 模型,用虚线分隔 + 留白,避免挤在一起 */
.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); }
/* 标题右侧的说明(如内置服务的 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-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; }
@@ -1132,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 .mpe-row { margin-bottom: 0; }
.modal .mpe-cks { display: flex; align-items: center; gap: 16px; margin-top: 8px; }
/* 超时(ms)与「启用」同排。数字框单独成类,不吃 .mpe-ck input 那套 15px 无边框样式(那是给 checkbox 的);
选择器带 .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-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-num input:focus { border-color: var(--active); }
/* MCP 的 mode 三态下拉:独立成行(弹窗内容宽仅 ~320px,与超时框同排会撑破),内层 select 用 .modal select 的全宽样式 */
.modal .mpe-field { display: block; margin-top: 14px; font-size: 12.5px; color: var(--gray); }
/* 单行设置项:左标签 / 右控件(与上面 header 那排同一种「一左一右」的节奏)
选择器带 .modal 前缀是为了压过 .modal input{width:100%},否则输入框会撑满整行。 */
.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-line:last-child { margin-bottom: 0; }
.modal .mpe-line > span { flex: none; white-space: nowrap; }
.modal .mpe-line input { flex: 1; min-width: 0; margin: 0; }
.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 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: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 原文 / 技能文件) ---------- */
.set-editor {
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 {
flex: 1; width: 100%; resize: none; background: #fff; color: var(--ink);
@@ -1173,13 +1308,18 @@ label.icon-btn { cursor: pointer; }
.btn-row { display: flex; gap: 10px; }
.btn-row .primary-btn { flex: 1; }
.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;
}
.modal {
background: var(--page); border-radius: 14px; padding: 20px; width: 84%; max-width: 360px;
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 input {
width: 100%; border: 1px solid #dde1ea; border-radius: 10px;
@@ -1498,6 +1638,27 @@ body.pv-resizing #pv-pane iframe { pointer-events: none; }
}
@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 提供)。 */
.edit-bar {
+49 -21
View File
@@ -2,7 +2,10 @@
<html lang="zh">
<head>
<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>
<script src="/vendor/marked.min.js"></script>
<meta name="theme-color" content="#3964FE">
@@ -157,14 +160,19 @@
<!-- ================= 底部输入区 ================= -->
<footer>
<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="edit-bar hidden" id="edit-bar">
<span>正在编辑已发送的消息,发送后将丢弃其后的历史</span>
<span>编辑已发送消息:发送后将丢弃原历史信息</span>
<button id="edit-cancel" type="button">取消</button>
</div>
<div class="up-cards hidden" id="up-cards" aria-label="已上传文件"></div>
<textarea id="msg-input" placeholder="传送信息" rows="2" enterkeyhint="enter"></textarea>
<!-- 语音模式:输入框位置变成「按住 说话」(只有居中文字,无按钮外观) -->
<div id="voice-hold" class="hidden" role="button" tabindex="0" aria-label="按住说话">按住 说话</div>
<div class="input-actions">
<div class="ia-side ia-left">
<button class="think-toggle" id="deep-think-btn" title="深度思考">
@@ -179,13 +187,22 @@
<button class="plus-btn" id="attach-btn" title="上传文件" aria-label="上传文件">
<svg viewBox="0 0 24 24" class="ic sm"><path fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" d="M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"></path></svg>
</button>
<!-- 同一按钮两态:发送(↑)/ 停止(白色方块)。data-state 由 JS 切换,尺寸不变避免输入区跳动 -->
<!-- 同一按钮四态:发送(↑)/ 停止(方块)/ 语音(麦克风)/ 键盘。
data-state 由 JS 切换,尺寸不变避免输入区跳动 -->
<button class="send-btn" id="send-btn" data-state="send" title="发送" aria-label="发送">
<svg viewBox="0 0 24 24" class="ic sm"><line x1="12" y1="19" x2="12" y2="5"></line><polyline points="5 12 12 5 19 12"></polyline></svg>
<svg class="ic sm ic-send" viewBox="0 0 24 24"><line x1="12" y1="19" x2="12" y2="5"></line><polyline points="5 12 12 5 19 12"></polyline></svg>
<svg class="ic sm ic-voice" viewBox="0 0 24 24"><rect x="9" y="2" width="6" height="12" rx="3"></rect><path d="M5 10a7 7 0 0 0 14 0"></path><line x1="12" y1="19" x2="12" y2="22"></line></svg>
<svg class="ic sm ic-kb" viewBox="0 0 24 24"><rect x="3" y="5" width="18" height="14" rx="2.5"></rect><circle cx="7" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="12" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="17" cy="9" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="7" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="12" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><circle cx="17" cy="12.5" r="1.1" fill="currentColor" stroke="none"></circle><line x1="8" y1="16" x2="16" y2="16"></line></svg>
<span class="stop-sq" aria-hidden="true"></span>
</button>
</div>
</div>
<!-- 按住说话的遮罩:盖满输入卡并扩到屏幕两边(footer 有 12px 内边距 + shell 1px 边框)。
声波由 JS 生成 25 根柱子;上滑到文案区域进入取消态(整体变红)。 -->
<div id="voice-overlay" class="hidden" aria-hidden="true">
<div class="vo-hint" id="voice-hint">松手传送,上滑取消</div>
<div class="vo-wave" id="voice-wave"></div>
</div>
</div>
<!-- 回到底部浮动按钮(搬自 index;上翻历史时出现、AI 输出中常驻转圈)。
放在 footer 内、相对 footer 顶边停靠:输入框长高/编辑条出现时不会被盖住 -->
@@ -285,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>
</button>
<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-url" placeholder="平台上游地址(OpenAI 兼容 /v1)">
<div class="mpe-sec">
@@ -299,7 +318,6 @@
<button class="ghost-btn danger hidden" id="mpe-del-btn" onclick="sUI.mDelPlat()">删除平台</button>
<button class="primary-btn" onclick="sUI.mSave()">保存</button>
</div>
<div class="cfg-note">仅写入配置,点击「重启服务」后生效。</div>
</div>
</div>
@@ -332,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>
</button>
<h3 id="mce-title">编辑 MCP 服务</h3>
<input type="text" id="mce-name" placeholder="服务名(留空取 url 主机名首段)">
<input type="text" id="mce-url" placeholder="MCP 服务 JSON-RPC 端点(完整 URL)">
<div class="mpe-sec">
<input type="text" id="mce-name" placeholder="服务名">
<input type="text" id="mce-url" placeholder="MCP 服务 JSON-RPC URL">
<!-- 内置服务预设字段(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 id="mce-headers"></div>
</div>
<div class="mpe-cks" style="margin-top:14px">
<label class="mpe-num">单次调用超时<input type="number" id="mce-timeout" min="1000" max="600000" step="1000" placeholder="默认 60000">ms</label>
<div class="mpe-sec">
<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>
<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">
<button class="ghost-btn danger hidden" id="mce-del-btn" onclick="mcpUI.del()">删除服务</button>
<button class="primary-btn" onclick="mcpUI.save()">保存</button>
</div>
<div class="cfg-note">仅写入配置,点击「重启服务」后生效。</div>
</div>
</div>
@@ -440,10 +464,12 @@
<div id="toast" class="hidden"></div>
</div>
<!-- 图片全屏查看器(点击消息/工具卡中图片打开;双指缩放、放大后可拖动) -->
<!-- 图片全屏查看器(点击消息/工具卡中图片打开;双指缩放、放大后可拖动;同组多图可左右滑动切换) -->
<div id="img-viewer" class="hidden">
<button class="fs-close" onclick="closeImageViewer()">✕</button>
<img id="img-viewer-img" alt="">
<!-- 组内页码(如 2 / 5):仅同组多图时显示 -->
<span id="img-count" class="hidden"></span>
</div>
<!-- ================= 文档预览右栏(桌面端≥960px;office/全部文档类型统一承载;移动端走全屏 #fs-viewer,本栏隐藏) -->
@@ -502,23 +528,25 @@
</div>
</div>
<script src="/js/viewport.js"></script>
<script src="/js/core.js"></script>
<script src="/js/chat.js"></script>
<script src="/js/sessions.js"></script>
<script src="/js/stream.js"></script>
<script src="/js/files.js"></script>
<script src="/js/voice.js"></script>
<script src="/js/preview.js"></script>
<script src="/js/settings.js"></script>
<script>
// 启动自愈:外部工具改前端文件是非原子写入,极端时机下浏览器可能拿到半截或重复拼接的 HTML
// (脚本缺半 → 白屏裸首页;重复注入 → 每个文件报 duplicate variable 后 JS 全挂)。
// 这里检测关键脚本数量与入口全局,不对就自动整页重载一次(sessionStorage 防循环)。
// 注意:js/ 脚本增减时需同步改这里的期望数 7。
// 注意:js/ 脚本增减时需同步改这里的期望数 9。
(function () {
var ok = false;
try {
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';
} catch (_) {}
if (ok) { try { sessionStorage.removeItem('boot-heal'); } catch (_) {} return; }
+2
View File
@@ -412,6 +412,8 @@
state.status = (s && s.status) || '';
state.modelId = (s && s.model_id) || ''; // 顶部动作区展示当前模型
state.schedule = detail.schedule || null; // 定时任务数据(顶部动作区副标题)
state.pending = Array.isArray(detail.pending) ? detail.pending : []; // 待投递队列(服务端内存态回显)
renderSendQueue();
renderHeader();
updateHeaderActions();
+1
View File
@@ -170,6 +170,7 @@
schedule: null, // 当前会话定时任务(详情 schedule 字段,null=无)
sessions: [], // 抽屉列表缓存
attachments: [], // 待发送附件 {file, name, size}
pending: [], // 待投递消息队列(服务端内存态的回显):{id, content, mode, created_at}
editingMsgId: 0, // 正在编辑的历史消息 id(0=普通发送,覆盖式重发)
lastImgBlobUrl: null, // 任务文件图片预览的 blob URL,下次预览或开新图时回收
lastPdfBlobUrl: null, // 同上:PDF 页内预览的 blob URL(浏览器内建查看器用)
+4 -2
View File
@@ -30,11 +30,13 @@
send();
}
});
// 发送键双职:生成中且输入框为空时变「停止」(白色方块),点击终止当前回合;
// 输入框有字时它仍是「发送」——运行中允许插话,直接发出去(后端 live 追投)。
// 发送键四职:语音 / 键盘(语音模式)/ 停止 / 发送,由 data-state 决定点击含义。
// 400ms 内重复点击忽略:防双击重复 abort(服务端 status 事件回来前按钮仍是停止态)。
let stopClickAt = 0;
$('send-btn').addEventListener('click', () => {
const st = $('send-btn').dataset.state;
if (st === 'voice' && window.AgentVoice) { window.AgentVoice.enter(); return; }
if (st === 'keyboard' && window.AgentVoice) { window.AgentVoice.exit(true); return; }
if (stopModeActive()) {
if (Date.now() - stopClickAt < 400) return;
stopClickAt = Date.now();
+80 -5
View File
@@ -25,6 +25,18 @@ function pvOfficeUrl(rel) {
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) {
const low = String(name).toLowerCase();
if (/\.html?$/i.test(low)) return 'html';
@@ -35,10 +47,28 @@ function pvKind(name) {
return 'none';
}
// 文件面板「当前目录」里的图片作为一组,供查看器左右滑动切换。
// 同组直接用预览派生直链(2048px),不必逐张取原图/blob,滑动的预取也不会打满带宽。
// 依赖 files.js 的 filesNodeAt / filesCurDir(同为全局,加载顺序在前)。
function pvImgGroup(name) {
try {
if (typeof filesNodeAt !== 'function') return null;
const node = filesNodeAt(typeof filesCurDir === 'string' ? filesCurDir : '');
if (!node) return null;
const paths = node.files.map(f => f.filename).filter(p => PV_IMG.test(p));
if (paths.length < 2) return null;
return {
list: paths.map(p => ({ src: pvPreviewUrl(p, 2048), alt: p.split('/').pop() })),
at: paths.indexOf(name),
};
} catch (_) { return null; }
}
// 刷新/新窗口两个钮对**所有**预览类型统一开放:
// refresh → pvState.reload(各类型都注入「按同一路径重开」,与地址条回车同一条路)
// popup → pvState.url(office=预览网关;文本/HTML/图片/PDF=blob URL;不支持的类型=下载地址)
// 服务端文件响应一律是 attachment,直接导航只会触发下载,所以能用 blob 的一律走 blob。
// popup → pvState.url(office=预览网关;图片/PDF=inline 直链;
// 文本/HTML=blob URL;不支持的类型=下载地址)
// 下载接口是 attachment,直接导航只会触发下载;图片/PDF 走各自的 inline 路由可直接开新窗口。
function pvToolbar(o) {
document.getElementById('pv-refresh').classList.toggle('hidden', !o.refresh);
document.getElementById('pv-popup').classList.toggle('hidden', !o.popup);
@@ -143,9 +173,17 @@ async function pvOpenOffice(name, sizeText) {
let head = null;
try { head = await fetch(url, { method: 'HEAD' }); } catch (_) {}
if (my !== pvSeq) return;
// 404 = 预览服务里没有这份文档。文件可能正被 AI 的写盘链路整体替换(rename 瞬间找不到),
// 探针给一次短重试再落占位卡——比让用户自己反复点刷新更接近「多刷几次就出来了」的实情。
if (head && head.status === 404) {
await new Promise((r) => setTimeout(r, 600));
if (my !== pvSeq) return;
try { head = await fetch(url, { method: 'HEAD' }); } catch (_) {}
if (my !== pvSeq) return;
}
const missing = head && head.status === 404;
if (missing) {
const node = pvInfoNode(name, sizeText, '预览服务中暂无这份文档 —— 只有 AI 在本任务中生成/编辑过的文档才能在线预览(较旧的文档可能已被自动清理)。');
const node = pvInfoNode(name, sizeText, '预览服务中暂无这份文档 —— 文件可能已被删除、改名,或不在本任务目录下。');
if (desk) {
// pvClearBody 会清掉 reload/url:占位卡仍要保留刷新/新窗口,否则按钮可见但点了没反应
pvClearBody(); document.getElementById('pv-body').appendChild(node);
@@ -198,6 +236,40 @@ async function openFilePreview(name, sizeText) {
show(pvInfoNode(name, sizeText, hint), tbAll);
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;
try {
r = await fetch('/api/sessions/' + state.sessionId + '/files/download?path=' + encodeURIComponent(name));
@@ -234,7 +306,8 @@ async function openFilePreview(name, sizeText) {
newBlobUrl = u;
const im = document.createElement('img');
im.className = 'pv-img'; im.src = u; im.alt = String(name);
im.addEventListener('click', () => openImageViewer(u, String(name).split('/').pop()));
const g = pvImgGroup(name);
im.addEventListener('click', () => openImageViewer(u, String(name).split('/').pop(), g && g.list, g && g.at));
node = im; tb = Object.assign({}, tbAll, { url: u });
} else { // text/md/代码/json/csv
node = await pvTextNode(name, sizeText, r);
@@ -332,6 +405,7 @@ async function pvRenderLegacy(name, r, my) {
pvOverlayShow(iframe, { bar: true, name: name, source: html }); // 全宽沉浸,源码可看/可复制
if (my !== pvSeq) return;
} else if (/\.pdf$/i.test(name)) {
// 正常路径已在 openFilePreview 用 /files/inline 直连;这里仅作旧路径兜底。
const u = URL.createObjectURL(await r.blob());
if (state.lastPdfBlobUrl) { try { URL.revokeObjectURL(state.lastPdfBlobUrl); } catch (_) {} }
state.lastPdfBlobUrl = u;
@@ -354,7 +428,8 @@ async function pvRenderLegacy(name, r, my) {
const u = URL.createObjectURL(await r.blob());
if (state.lastImgBlobUrl) { try { URL.revokeObjectURL(state.lastImgBlobUrl); } catch (_) {} }
state.lastImgBlobUrl = u;
openImageViewer(u, name);
const g = pvImgGroup(name);
openImageViewer(u, name, g && g.list, g && g.at);
} else {
const text = await r.text();
let cls = 'bubble-ai', html;
+26 -5
View File
@@ -79,6 +79,8 @@
state.sessionTitle = '';
state.sessionType = 'secretary';
state.pendingModel = '';
state.pending = [];
renderSendQueue();
state.streamEl = null;
state.streamText = '';
state.toolCards = {};
@@ -190,6 +192,8 @@
state.status = '';
state.modelId = '';
state.schedule = null; // 防详情返回前残留上一会话的任务状态
state.pending = []; // 同上:队列是会话级的,先清空,详情回来再回显
renderSendQueue();
// 先从抽屉列表缓存取会话类型,让顶部 icon 立即正确;详情回来后由 renderDetail 纠正
const cached = (state.sessions || []).find(x => x.id === id);
state.sessionType = (cached && cached.assistant_type) || 'secretary';
@@ -249,6 +253,8 @@
state.status = '';
state.modelId = '';
state.schedule = null;
state.pending = [];
renderSendQueue();
state.pendingModel = '';
state.attachments = [];
if (typeof clearEditState === 'function') clearEditState();
@@ -300,13 +306,26 @@
// 有附件时按钮保持「发送」:粘贴长文本转成的附件不应被当成停止操作
return state.status === 'active' && !(($('msg-input') || {}).value || '').trim() && !state.attachments.length;
}
// 发送键四态:停止 / 键盘(语音模式)/ 语音(空输入且支持录音)/ 发送。
// 停止优先:生成中且输入框为空时,用户最可能想停止,不能被语音入口顶掉。
// 语音与键盘两态由 voice.js 暴露的 window.AgentVoice 提供(脚本加载顺序在 sessions 之后,
// 初始化阶段它还不存在,此处必须容错——那时按普通「发送」渲染即可)。
function updateSendBtn() {
const sb = $('send-btn');
if (!sb) return;
const stop = stopModeActive();
sb.dataset.state = stop ? 'stop' : 'send';
sb.title = stop ? '停止生成' : '发送';
sb.setAttribute('aria-label', stop ? '停止生成' : '发送');
const v = window.AgentVoice;
const empty = !(($('msg-input') || {}).value || '').trim() && !state.attachments.length;
let mode;
if (stopModeActive()) mode = 'stop';
else if (v && v.isVoiceMode()) mode = 'keyboard';
else if (empty && v && v.isAvailable()) mode = 'voice';
else mode = 'send';
sb.dataset.state = mode;
const label = mode === 'stop' ? '停止生成'
: mode === 'keyboard' ? '切换到键盘输入'
: mode === 'voice' ? '语音输入' : '发送';
if (sb.title !== label) sb.title = label;
if (sb.getAttribute('aria-label') !== label) sb.setAttribute('aria-label', label);
}
function updateHeaderActions() {
@@ -535,13 +554,15 @@
async function stopSession() {
if (!state.sessionId) return;
const held = state.status === 'held';
const queued = (state.pending || []).length;
try {
if (held) {
await req('POST', '/api/sessions/' + state.sessionId + '/release');
toast('已断开');
} else {
await req('POST', '/api/sessions/' + state.sessionId + '/stop');
toast('已发送终止指令');
// 「停止」是全停:服务端会把待投递队列一并作废,这里明确告知,不让消息静静消失
toast(queued ? '已终止,队列中 ' + queued + ' 条消息已取消' : '已发送终止指令');
}
} catch (e) { toast((held ? '断开失败:' : '终止失败:') + e.message); }
}
+444 -81
View File
@@ -27,8 +27,11 @@
pendingEnable: {}, // 已写盘但重启前 effective 仍是旧值的 enable 覆盖(id → bool),防卡片回弹
deletedModels: {}, // 已从 config.yml 删除、重启前后端仍会返回的模型(id → true):前端隐藏防回弹
expandedGroups: {}, balanceByGroup: {}, balanceRequested: {}, balanceTypes: [], // 平台编辑弹窗工作态见 pfEdit(模块级变量)
modelProfileNames: [], // profile 下拉选项(顶层 model_profiles 的 key)
// MCP 服务页:cfgMcp 缓存当前列表;改动待重启生效时置位,顶部常驻重启横幅
cfgMcp: [], mcpPendingRestart: false,
mcpStatus: null, // 运行态连接状态:key = name|url|mode(见 mcpStatusKey);null = 没拿到,不显示标记
presets: null, // 平台/MCP 预设(GET /api/config/presets),设置页各页共用
};
let setTok = 0; // 异步渲染防竞态令牌
@@ -1186,13 +1189,15 @@
const el = $('model-cards');
if (!el || (ctx && !ctx())) return;
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 (!$('model-cards')) return; // 异步期间已离开本页
SET.runtimeById = {};
for (const m of rt || []) SET.runtimeById[m.id] = m;
SET.cfgPlatforms = (cg.effective && cg.effective.platforms) || [];
SET.cfgModels = (cg.effective && cg.effective.models) || [];
// 平台编辑器里的 profile 下拉只有名字有意义,不缓存整份 prompt
SET.modelProfileNames = Object.keys((cg.effective && cg.effective.model_profiles) || {});
// 已删除/已改名旧 id 的标记清理:配置(live)与运行池都已无此 id 才清——重启前池里残留时须保留标记,
// 否则会话页选择弹窗(读 /api/models 运行池)会重新列出已不可用的模型。
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); }
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) {
const add = pi == null;
const p = add ? {} : (SET.cfgPlatforms[pi] || {});
pfEdit = {
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 || '' })),
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-name').value = add ? '' : (p.name || '');
$('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);
renderPfPresets();
renderPfRows();
$('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 提示当前脱敏值,输入新值=替换,留空=保持。
function pfKeysRowHtml(r, i) {
const ph = r.ref == null
@@ -1275,18 +1362,33 @@
'<button class="mpe-del" title="删除此 Key" onclick="sUI.mDelKey(' + i + ')">×</button>' +
'</div>';
}
// 模型子卡片两行:上行配 id,下行勾 vision/enable。id 可改(仅改 config.yml,重启生效)。
// display_name/concurrency/type 不进弹窗:保存只按细粒度 path 改,不碰文件里其余字段。
// 模型子卡片:上行配 id,中行勾 vision/enable + 「高级」,高级区放不常改的字段。
// 全部走细粒度 path 保存,不整体覆盖模型对象(保住文件里的手写字段)。
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">' +
'<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>' +
'</div>' +
'<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.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>';
}
// 行下标变化后需重渲染(事件处理器里捕获了旧 i),故增删后重建两段行列表。
@@ -1296,7 +1398,7 @@
$('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 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) {
if (!pfEdit) return;
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 setPfModel(i, f, v) { if (pfEdit && pfEdit.models[i]) pfEdit.models[i][f] = v; }
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)。
// YAML 数组删项后下标收紧,同批内删/改/增按原 ref 定位,服务端依次应用。
function buildPfEdits() {
@@ -1333,25 +1466,59 @@
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] }));
// 模型:已有行只按细粒度 path 改 vision/enable(不整体覆盖,保住文件里的 display_name/extra_params 等);
// 新增行 append 最小对象(缺省项不写:display_name 后端同 id,enable 缺省启用)
// 模型:已有行全部按细粒度 path 改(不整体覆盖,保住文件里的手写字段与其他参数);
// 新增行 append 最小对象(缺省项不写:display_name 同 id、enable 缺省启用、参数为空)
pfEdit.models.forEach(r => {
if (r.ref != null) {
const om = (p.models || [])[r.ref] || {};
const mp = ['platforms', pfEdit.idx, 'models', r.ref];
const nid = String(r.id || '').trim();
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 不再可绑,标记隐藏
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.enable !== false) !== (r.enable !== false)) edits.push({ path: ['platforms', pfEdit.idx, 'models', r.ref, 'enable'], value: r.enable !== false });
if (!!om.vision !== !!r.vision) edits.push({ path: mp.concat('vision'), value: !!r.vision });
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 {
const id = String(r.id || '').trim();
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 });
edits.push({ op: 'append', path: ['platforms', pfEdit.idx, 'models'], value: pfModelValue(r) });
}
});
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;
try {
if (add) {
// 新增平台:一次 append 整个对象(name 留空由服务端取主机段;type/concurrency/display_name 均不落配置,走各自缺省)
edits = [{ op: 'append', path: ['platforms'], value: {
// 新增平台:一次 append 整个对象
const obj = {
name, url,
keys: pfEdit.keys.map(r => ({ api_key: String(r.api_key || '').trim() })),
models: pfEdit.models.map(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;
return nv;
}),
} }];
models: pfEdit.models.map(pfModelValue),
};
// 用预设时把余额查询类型固定下来(不展示给用户):名字与预设一致可不写(服务端缺省 = 平台名)
const presetType = pfEdit.preset ? String(pfEdit.preset.type || pfEdit.preset.key || '') : '';
if (presetType && presetType !== name) obj.type = presetType;
edits = [{ op: 'append', path: ['platforms'], value: obj }];
} else {
// 改名不影响 pi(数组位置);其余按原 ref 定位,见 buildPfEdits
edits = buildPfEdits();
if (!edits.length) { closeModelEditor(); return toast('没有变更'); }
}
} catch (e) { return toast(e.message); } // JSON 校验失败等:提示后不发请求
try {
await req('PATCH', '/api/config', { edits });
// 重加同名模型(重启前被标记隐藏的):清掉删除标记防误屏蔽
const pname = name || (SET.cfgPlatforms[pfEdit.idx] || {}).name || '';
@@ -1425,8 +1592,38 @@
// mode 三态:advertise(默认,工具下发给模型) / skill(不下发,以技能形式暴露) / disable(不加载):
// 默认值不写进文件——选 advertise 时删键,回落到 config.js 的缺省。
// 运行配置(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_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) {
setTitle('MCP 服务');
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>');
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) {
const box = $('mcp-list');
if (!box || (ctx && !ctx())) return;
try {
const cg = await req('GET', '/api/config');
if (ctx && !ctx()) return;
if (!$('mcp-list')) return;
const [cg, , st] = await Promise.all([
req('GET', '/api/config'),
loadPresets(),
// 状态接口失败不该挡住整个页面(老进程没有该路由 / 网络抖动):拿不到就不显示连接标记
req('GET', '/api/config/mcp-status').catch(() => null),
]);
if ((ctx && !ctx()) || !$('mcp-list')) return;
SET.cfgMcp = (cg.effective && cg.effective.mcp_servers) || [];
if (!SET.cfgMcp.length) {
box.innerHTML = (SET.mcpPendingRestart
? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>'
: '') + '<div class="empty-tip">尚未配置 MCP 服务,点右上角 + 添加。</div>';
return;
}
const banner = SET.mcpPendingRestart
const statusList = st && Array.isArray(st.servers) ? st.servers : null;
SET.mcpStatus = statusList ? new Map(statusList.map(x => [mcpStatusKey(x), x])) : null;
const presets = presetMcpList();
// 内置服务已占用的条目不再列入「其它」,避免同一服务出两张卡
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));
let html = SET.mcpPendingRestart
? '<div class="restart-bar"><span>配置已写入,重启后生效</span><button class="primary-btn" onclick="sUI.restartNow()">重启服务</button></div>'
: '';
box.innerHTML = banner + SET.cfgMcp.map(mcpCardHtml).join('') +
'<div class="empty-tip">点卡片编辑 MCP 服务。advertise 的工具启动时发现并追加到内置工具之后;skill 不下发,改为以技能形式暴露(skill 工具里 get 拿到原始 input_schema)。</div>';
if (presets.length) {
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) {
const b = $('mcp-list');
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 键值列表。整卡点击进入编辑。
function mcpCardHtml(s, pi) {
const mode = s.mode || 'advertise';
const stateHtml = mode === 'disable'
? '<span class="model-card-state off">已禁用</span>'
: mode === 'skill'
? '<span class="model-card-state idle">以技能暴露</span>'
: '<span class="model-card-state idle">启用</span>';
// 同样:模式文字保持中性,颜色留给连接状态
const stateHtml = '<span class="model-card-state off">' +
(mode === 'disable' ? '已禁用' : mode === 'skill' ? '以技能暴露' : '启用') + '</span>' +
(mode === 'disable' ? '' : mcpConnChip(s));
const entries = Object.entries(s.headers || {});
// header 值等同密码对待:后端 effective 已脱敏为固定短掩码,这里透传展示;若收到未脱敏原文也一律替换,不外显
const maskVal = (v) => { const str = String(v == null ? '' : v); if (!str) return '--'; return str.includes('*') ? esc(str) : MCP_HEADER_MASK; };
// 后端只对密钥类 header 脱敏(base-url/model 这类明文);掩码值统一显示「已配置」,不露长度
const maskVal = (v) => {
const str = String(v == null ? '' : v);
if (!str) return '--';
return str === MCP_HEADER_MASK ? '已配置' : esc(str);
};
const headersHtml = entries.length
? 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>';
@@ -1480,25 +1734,58 @@
'</div>' + headersHtml +
'</div>';
}
// 弹窗打开:add 模式 (idx=-1) → 空工作态;edit 模式 → 从当前配置复制。
function openMcpEditor(idx) {
// 弹窗打开:add 模式 (idx=null) → 空工作态;edit 模式 → 从当前配置复制。
// 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 s = add ? {} : (SET.cfgMcp[idx] || {});
const curH = s.headers || {};
const fieldHeaders = new Set(((preset && preset.fields) || []).map(f => f.header));
mcpEdit = {
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 存当前脱敏值仅做提示
// (同平台 Key 的留空=保持原值);新行 masked=null,必须手输真值。空 key 行保存时丢弃。
headers: add
? [{ key: '', value: '', masked: null }]
: Object.entries(s.headers || {}).map(([k, v]) => ({ key: k, value: '', masked: String(v) })),
};
$('mce-title').textContent = add ? '添加 MCP 服务' : '编辑 MCP 服务';
$('mce-name').value = add ? '' : (s.name || '');
$('mce-url').value = add ? '' : (s.url || '');
mcpEdit.headers = [{ key: '', value: '', masked: null }];
}
$('mce-title').textContent = (add ? '添加 ' : '编辑 ') + (preset ? preset.label : 'MCP 服务');
$('mce-name').value = preset ? preset.key : (add ? '' : (s.name || ''));
$('mce-url').value = preset ? preset.url : (add ? '' : (s.url || ''));
$('mce-name').readOnly = !!preset;
$('mce-url').readOnly = !!preset;
// 运行配置里的 timeout_ms 已被 config.js 填上缺省值,所以这里显示的就是当前生效值(没配则为 60000)。
$('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);
renderPresetFields();
renderMcpHeaders();
$('mcp-edit-modal').classList.remove('hidden');
}
@@ -1508,7 +1795,7 @@
// 已有行:输入框置空,placeholder 提示当前脱敏值;留空=保持原值,输入新值=替换
const ph = r.masked != null ? '当前: ' + r.masked + '(留空保持不变)' : '值';
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)">' +
'<button class="mpe-del" title="删除此 header" onclick="mcpUI.delHeader(' + i + ')">×</button>' +
'</div>';
@@ -1530,13 +1817,82 @@
renderMcpHeaders();
}
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:服务端一次读文/写回/校验,原子生效。
// headers 整体替换(简单可靠;键值对场景下增量 diff 收益小):空 key 行不写入。
function buildMcpEdits() {
if (!mcpEdit) return [];
const edits = [];
const name = $('mce-name').value.trim();
const url = $('mce-url').value.trim();
const preset = mcpEdit.preset;
const mode = $('mce-mode').value;
// 超时:留空 = 不写入该项(沿用缺省 60s)。区间在 UI 先把一道,
// 比写进 YAML 再被 config.js 静默夹掉好排查(两边上限保持 600000 一致)。
@@ -1547,6 +1903,10 @@
if (!Number.isFinite(tmo) || tmo < 1000 || tmo > 600000) throw new Error('超时要填 1000 ~ 600000 毫秒(留空 = 默认 60s)');
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;
if (add) {
if (!url) throw new Error('请填写 url');
@@ -1554,19 +1914,15 @@
if (name) obj.name = name;
if (mode !== 'advertise') obj.mode = mode;
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;
edits.push({ op: 'append', path: ['mcp_servers'], value: obj });
} else {
const cur = SET.cfgMcp[mcpEdit.idx] || {};
if (!url) throw new Error('请填写 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 });
if (!preset) {
if (!url) throw new Error('请填写 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 就删键)
if ((cur.mode || 'advertise') !== mode) edits.push(mode === 'advertise'
? { path: ['mcp_servers', mcpEdit.idx, 'mode'], op: 'delete' }
@@ -1576,17 +1932,10 @@
if (tmo !== curTmo) edits.push(tmo == null
? { path: ['mcp_servers', mcpEdit.idx, 'timeout_ms'], op: 'delete' }
: { path: ['mcp_servers', mcpEdit.idx, 'timeout_ms'], value: tmo });
// headers 仅在内容变更时整体 setIn;避免无意义重写(顺序可能不同)
const newH = {};
for (const r of mcpEdit.headers) {
const k = String(r.key || '').trim();
// 已有行留空 = 保持原值:把脱敏占位原样发回,由后端按键名还原真值(前端不持有真值)
const v = String(r.value || '').trim() || (r.masked != null ? r.masked : '');
if (k) newH[k] = v;
// headers 仅在内容变更时整体 setIn;避免无意义重写(顺序或 key 顺序不同不算变更)
if (!sameHeaders(headers, cur.headers || {})) {
edits.push({ path: ['mcp_servers', mcpEdit.idx, 'headers'], value: headers });
}
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;
}
@@ -1618,6 +1967,13 @@
}
window.mcpUI = {
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,
close: closeMcpEditor,
save: saveMcpEditor,
@@ -1678,8 +2034,15 @@
mDelModel: delPfModel,
mKeyApi: function (i, v) { setPfKey(i, 'api_key', 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); },
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,
restartNow: restartNow,
toggleGroup: toggleModelGroup,
+285 -43
View File
@@ -19,7 +19,7 @@
const content = ta.value.trim();
const editingId = state.editingMsgId || 0;
// 没有文字就不发(避免产生空消息);但只有附件时允许发送——粘贴长文本转成的 .txt 需要能单独发出。
// 运行中也是这条规则:有字就发(后端 live 追投),没字又没附件时按钮本身是「停止」。
// 运行中也是这条规则:有字就发,没字又没附件时按钮本身是「停止」。
if (!content && !state.attachments.length) return;
const pending = state.attachments.slice();
@@ -43,7 +43,10 @@
const text = names.length
? '用户上传了文件:' + names.join('、') + (content ? '\n\n' + 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;
if (editingId) {
// 覆盖式编辑:先撤掉本地该条及其后的渲染,再让服务端删除同范围历史并以新内容重开一轮
@@ -56,7 +59,15 @@
}
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) || '';
if (!state.sessionTitle && seed) {
@@ -65,7 +76,8 @@
renderHeader();
// 运行中插话:正文字流进行中已有一个气泡作「活着」的信号,不再挂打字占位
//(刚挂上就会被下一个 delta 移除,只会闪一下);工具间隙里补上占位反而有用。
if (!state.streaming) addTyping();
// 排队时本回合没有任何新动静,不挂占位。
if (!queued && !state.streaming) addTyping();
loadSessionList();
} 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 流 ----------
// 助手消息流式容器:首个 delta 到达时创建,同时为思考面板预留挂载点
function ensureStreamWrap() {
@@ -158,12 +220,15 @@
state.lastSseAt = Date.now(); // 建连即重置静默计时
// 任何具名事件都算连接存活:静默看门狗与回前台宽限共用(error 不列,原生连接错误也走 error)
['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); }); });
es.addEventListener('status', ev => {
const d = JSON.parse(ev.data);
state.status = d.status;
if (d.model_id) state.modelId = d.model_id;
// 待投递队列以服务端为准(重连/换标签页后条幅能自动回到真实状态)
if (Array.isArray(d.pending)) { state.pending = d.pending; renderSendQueue(); }
renderHeader();
updateHeaderActions();
updateScrollBottomBtn(); // 状态切换同步右下角转圈(开始/结束干活)
@@ -348,8 +413,33 @@
es.addEventListener('auto_compress', ev => {
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 => {
removeTyping(); // 本轮结束,占位亦终止(如模型报错无回复)
let doneStatus = '';
try { doneStatus = (JSON.parse(ev.data) || {}).status || ''; } catch (_) { /* 无 data 的连接层错误 */ }
// 压缩回合异常结束的兜底(模型报错回合直接 break / 被终止 → 不会有带 is_summary 的最终消息):
// 复位等待状态并还原压缩按钮,历史保持原样不动。
if (state.pendingSummary) {
@@ -364,10 +454,20 @@
state.streamWrap = null;
state.streamReasoning = '';
state.streamThinkEl = null;
// 异常收尾兜底:把参数未流完的早卡就地回填收尾,避免占位态永远呼吸
// 异常收尾兜底:把参数未流完的早卡就地回填收尾,避免占位态永远呼吸。
// 被「立即发送/停止」硬中断时,这些调用根本没落库、不会再有回执,
// 结果区要明确写「已取消」,否则卡片永远停在「执行中…」。
for (const sid of Object.keys(state.toolCallStreaming)) {
const stg = state.toolCallStreaming[sid];
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.toolCallStreaming = {}; // 流式参数早卡映射随会话/回合重置
@@ -590,67 +690,209 @@
});
// 点击消息/工具卡里的图片 → 图片全屏查看器(#fs-viewer 里的克隆图也生效)
// 同一气泡/工具卡内的图作为一组,查看器里可左右滑动切换
function imgViewerDelegate(e) {
const im = e.target.closest('.bubble-ai img, .bubble-user img, .tool-card img');
if (im && im.src) openImageViewer(im.src, im.alt || '');
if (!im || !im.src) return;
const box = im.closest('.msg') || im.closest('.tool-card') || $('fs-body');
const list = Array.prototype.map.call(box.querySelectorAll('img'), x => ({ src: x.src, alt: x.alt || '' }))
.filter(x => x.src);
openImageViewer(im.src, im.alt || '', list);
}
$('chat-view').addEventListener('click', imgViewerDelegate);
$('fs-viewer').addEventListener('click', imgViewerDelegate);
// 图片全屏查看器:transform 缩放+平移。双指捻合缩放(1~6x)、放大后单指/鼠标拖动、双击切 2.5x。
// 第 3 参 list([{src,alt}] 或 [src]) 传入「同组图片」时开启左右滑动切换;第 4 参 at 指定起始下标。
// 切图用双层 img 做真正的分页位移(旧图跟手滑出、新图同步滑入),并在开图时预取相邻图,
// 避免「松手→瞬移复位→闪白→图才下载出来」这三连卡顿。
let openImageViewer, closeImageViewer;
(function () {
const viewer = document.getElementById('img-viewer');
const img = document.getElementById('img-viewer-img');
// 第二层由脚本建(不写进 HTML):旧版缓存的 HTML 里没有它也不会把查看器搞挂
const img2 = document.createElement('img');
img2.className = 'hidden'; img2.alt = '';
viewer.appendChild(img2);
const count = document.getElementById('img-count');
let cur = img, other = img2; // cur=当前层;other=滑动时接替的层
let scale = 1, tx = 0, ty = 0, mode = null;
let sx = 0, sy = 0, stx = 0, sty = 0, pDist = 0, pScale = 1;
// gallery=当前组;gi=组内下标;wx/wy/wdx=横滑起点与实时位移;dragDir/pending=本次拖动方向与待接替下标
let gallery = [], gi = 0, wx = 0, wy = 0, wdx = 0, dragDir = 0, pending = -1;
const preloads = new Map(); // src → Image:提前下载并解码,切图时不再等网络
let settleTimer = 0;
const tdist = t => Math.hypot(t[0].clientX - t[1].clientX, t[0].clientY - t[1].clientY);
const W = () => window.innerWidth;
function apply() {
img.style.transform = 'translate(' + tx + 'px,' + ty + 'px) scale(' + scale + ')';
img.style.cursor = scale > 1 ? 'grab' : 'zoom-in';
cur.style.transition = 'none'; // 缩放/拖动要跟手,不能被上一段滑动动画的过渡拖着走
cur.style.transform = 'translate(' + tx + 'px,' + ty + 'px) scale(' + scale + ')';
cur.style.cursor = scale > 1 ? 'grab' : 'zoom-in';
}
openImageViewer = function (src, alt) {
scale = 1; tx = ty = 0; mode = null;
function drawCount() {
if (!count) return; // 旧版 HTML 缓存里没有计数节点时不报错
const on = gallery.length > 1;
count.textContent = on ? (gi + 1) + ' / ' + gallery.length : '';
count.classList.toggle('hidden', !on);
}
// 预取相邻图:Image 对象常驻,解码结果留在内存里,滑过去就是现成的
function preload(src) {
if (!src || preloads.has(src) || /^(data|blob):/i.test(src)) return;
const im = new Image();
im.decoding = 'async';
im.src = src;
preloads.set(src, im);
}
function prefetchAround() {
[gi + 1, gi + 2, gi - 1].forEach(i => { if (gallery[i]) preload(gallery[i].src); });
}
// 把某层摆到「相对屏幕中心偏移 offset 像素」处(1x、无过渡)
function place(el, offset) {
el.style.transition = 'none';
el.style.transform = 'translate(' + offset + 'px,0) scale(1)';
}
function showLayer(el, item) {
el.src = item.src; el.alt = item.alt || '';
el.classList.remove('hidden');
}
// 动画收尾:旧层收起、两层归位(滑到一半又开始新手势时也靠它清场)
function finishSettle() {
clearTimeout(settleTimer); settleTimer = 0;
other.classList.add('hidden');
place(other, 0); place(cur, 0);
apply();
img.src = src; img.alt = alt || '';
prefetchAround();
}
// 滑到第 i 张(dir=+1 从右侧进,-1 从左侧进);已到边界就弹回
function slideTo(i, dir) {
if (settleTimer) finishSettle(); // 上一张还在动画里(连点方向键):先收尾,避免接替层被瞬移
const t = Math.max(0, Math.min(gallery.length - 1, i));
if (t === gi) return settleBack(dir);
const from = cur, to = other;
if (pending !== t) { place(to, dir * W()); showLayer(to, gallery[t]); }
void to.offsetWidth; // 先把起点落位再加过渡,否则首帧会被合并成瞬移
const ease = 'transform .2s cubic-bezier(.22,.61,.36,1)';
from.style.transition = ease; to.style.transition = ease;
from.style.transform = 'translate(' + (-dir * W()) + 'px,0) scale(1)';
to.style.transform = 'translate(0,0) scale(1)';
cur = to; other = from;
gi = t; scale = 1; tx = ty = 0; dragDir = 0; pending = -1;
drawCount();
settleTimer = setTimeout(finishSettle, 220);
}
// 没过阈值/到边界:当前层弹回原位,接替层退回屏幕外
function settleBack(dir) {
const ease = 'transform .2s ease-out';
cur.style.transition = ease;
cur.style.transform = 'translate(0,0) scale(1)';
if (dir && !other.classList.contains('hidden')) {
other.style.transition = ease;
other.style.transform = 'translate(' + dir * W() + 'px,0) scale(1)';
}
scale = 1; tx = ty = 0; dragDir = 0; pending = -1;
settleTimer = setTimeout(finishSettle, 220);
}
openImageViewer = function (src, alt, list, at) {
const raw = Array.isArray(list) && list.length ? list : [{ src: src, alt: alt }];
gallery = raw.map(x => (typeof x === 'string' ? { src: x, alt: '' } : x)).filter(x => x && x.src);
// 起始下标优先用调用方给的(文件面板那张是 blob URL,与组里的直链对不上),否则按 src 匹配
let i = typeof at === 'number' && at >= 0 ? at : gallery.findIndex(x => x.src === src);
if (i < 0) i = 0;
clearTimeout(settleTimer); settleTimer = 0;
cur = img; other = img2;
gi = i; scale = 1; tx = ty = 0; mode = null; dragDir = 0; pending = -1;
other.classList.add('hidden'); place(other, 0);
showLayer(cur, gallery[gi] || { src: src, alt: alt });
place(cur, 0); apply();
drawCount();
viewer.classList.remove('hidden');
prefetchAround(); // 开图即把前后两张拉下来,滑的时候是现成的
};
closeImageViewer = function () {
viewer.classList.add('hidden');
gallery = []; gi = 0; dragDir = 0; pending = -1;
preloads.clear(); // 断开引用,解码位图随之释放
drawCount();
};
closeImageViewer = function () { viewer.classList.add('hidden'); };
// 点背景(非图片)关闭
viewer.addEventListener('click', function (e) { if (e.target === viewer) closeImageViewer(); });
img.addEventListener('dblclick', function () {
scale = scale > 1 ? 1 : 2.5;
if (scale === 1) { tx = ty = 0; }
apply();
});
img.addEventListener('touchstart', function (e) {
if (e.touches.length === 2) { mode = 'pinch'; pDist = tdist(e.touches) || 1; pScale = scale; }
else if (e.touches.length === 1 && scale > 1) { mode = 'pan'; sx = e.touches[0].clientX; sy = e.touches[0].clientY; stx = tx; sty = ty; }
else mode = null;
}, { passive: true });
img.addEventListener('touchmove', function (e) {
if (mode === 'pinch' && e.touches.length >= 2) {
e.preventDefault();
scale = Math.min(6, Math.max(1, pScale * tdist(e.touches) / pDist));
// 两层都要绑:切图后当前层会换成另一张 img,事件不能只挂在第一层上
function bindLayer(el) {
el.addEventListener('dblclick', function () {
scale = scale > 1 ? 1 : 2.5;
if (scale === 1) { tx = ty = 0; }
apply();
} else if (mode === 'pan' && e.touches.length === 1) {
});
el.addEventListener('touchstart', function (e) {
if (settleTimer) finishSettle(); // 上一次滑动还没收尾:先清场再新手势
if (e.touches.length === 2) { mode = 'pinch'; pDist = tdist(e.touches) || 1; pScale = scale; }
else if (e.touches.length === 1 && scale > 1) { mode = 'pan'; sx = e.touches[0].clientX; sy = e.touches[0].clientY; stx = tx; sty = ty; }
else if (e.touches.length === 1 && gallery.length > 1) { mode = 'swipe'; wx = e.touches[0].clientX; wy = e.touches[0].clientY; wdx = 0; dragDir = 0; pending = -1; }
else mode = null;
}, { passive: true });
el.addEventListener('touchmove', function (e) {
if (mode === 'pinch' && e.touches.length >= 2) {
e.preventDefault();
scale = Math.min(6, Math.max(1, pScale * tdist(e.touches) / pDist));
if (scale === 1) { tx = ty = 0; }
apply();
} else if (mode === 'pan' && e.touches.length === 1) {
e.preventDefault();
tx = stx + e.touches[0].clientX - sx;
ty = sty + e.touches[0].clientY - sy;
apply();
} else if (mode === 'swipe' && e.touches.length === 1) {
const dx = e.touches[0].clientX - wx, dy = e.touches[0].clientY - wy;
if (Math.abs(dx) <= Math.abs(dy)) return; // 竖直为主:不接管
wdx = dx;
const dir = dx < 0 ? 1 : -1; // 左滑看下一张
if (dir !== dragDir) {
dragDir = dir;
const next = gallery[gi + dir];
// 方向一确定就把相邻图摆到另一侧待命(已预取,几乎是现成的),跟手滑进来
if (next) { pending = gi + dir; place(other, dir * W()); showLayer(other, next); }
else { pending = -1; other.classList.add('hidden'); } // 到头了:没有下一张,只做橡皮筋
}
const off = pending >= 0 ? dx : dx * 0.35;
cur.style.transition = 'none';
cur.style.transform = 'translate(' + off + 'px,0) scale(1)';
if (pending >= 0) {
other.style.transition = 'none';
other.style.transform = 'translate(' + (off + dragDir * W()) + 'px,0) scale(1)';
}
}
}, { passive: false });
el.addEventListener('touchend', function (e) {
if (mode === 'swipe') {
const dir = dragDir;
if (pending >= 0 && Math.abs(wdx) > 45) slideTo(pending, dir);
else settleBack(dir);
mode = null;
return;
}
if (e.touches.length < 2) { if (mode === 'pinch') mode = null; }
if (!e.touches.length) mode = null;
}, { passive: true });
el.addEventListener('touchcancel', function () {
if (mode === 'swipe') settleBack(dragDir);
mode = null;
}, { passive: true });
// 桌面:放大后按住拖动平移
el.addEventListener('mousedown', function (e) {
if (scale <= 1) return;
e.preventDefault();
tx = stx + e.touches[0].clientX - sx;
ty = sty + e.touches[0].clientY - sy;
apply();
}
}, { passive: false });
img.addEventListener('touchend', function (e) { if (e.touches.length < 2) { if (mode === 'pinch') mode = null; } if (!e.touches.length) mode = null; }, { passive: true });
img.addEventListener('touchcancel', function () { mode = null; }, { passive: true });
// 桌面:放大后按住拖动平移
img.addEventListener('mousedown', function (e) {
if (scale <= 1) return;
e.preventDefault();
const x0 = e.clientX, y0 = e.clientY, tx0 = tx, ty0 = ty;
const mv = function (ev) { tx = tx0 + ev.clientX - x0; ty = ty0 + ev.clientY - y0; apply(); };
const up = function () { window.removeEventListener('mousemove', mv); window.removeEventListener('mouseup', up); };
window.addEventListener('mousemove', mv); window.addEventListener('mouseup', up);
const x0 = e.clientX, y0 = e.clientY, tx0 = tx, ty0 = ty;
const mv = function (ev) { tx = tx0 + ev.clientX - x0; ty = ty0 + ev.clientY - y0; apply(); };
const up = function () { window.removeEventListener('mousemove', mv); window.removeEventListener('mouseup', up); };
window.addEventListener('mousemove', mv); window.addEventListener('mouseup', up);
});
}
bindLayer(img); bindLayer(img2);
// 桌面没有滑动:组内多图时用 ←/→ 切换(单图不响应)
document.addEventListener('keydown', function (e) {
if (viewer.classList.contains('hidden') || gallery.length < 2) return;
if (e.key === 'ArrowLeft') slideTo(gi - 1, -1);
else if (e.key === 'ArrowRight') slideTo(gi + 1, 1);
});
})();
+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));
})();
+808
View File
@@ -0,0 +1,808 @@
// 语音输入(按住说话)
//
// 交互:
// · 输入框为空时,发送键变成麦克风;点一下进入语音模式
// · 语音模式下输入框位置变成「按住 说话」:按住后整块输入区被全宽遮罩盖住,
// 显示实时电平声波 + 「松手传送,上滑取消」
// · 手指上滑进入文案区域 → 取消态(声波与文案变红,文案改「松开取消」),滑回下方恢复
// · 松手:取消态 → 丢弃 + 轻提示;否则转写后**直接发送**
// · 发送键位置变成键盘按钮,点一下回文本模式并聚焦输入框(移动端弹键盘)
//
// 录音在客户端,两条路,下游是同一套:
// · 套壳原生桥(http 页面也能用):壳把 16k/单声道 PCM 以 ~100ms 分片推给页面。
// · 浏览器(需 HTTPS):AudioContext + ScriptProcessor 自己采 PCM,降采样到 16k 后约 20ms 一片。
// 两条路都汇到 pushChunk():判停顿、切段、逐段上传、最后合并发送,只有一份实现。
// 于是大部分识别在说话过程中就做完了,松手通常只剩最后一段要等。
// 电平在页面侧算(PCM 峰值),壳和浏览器都不做任何换算。
//
// 包在 IIFE 里:前端是共享全局作用域的经典脚本,顶层声明会和其他文件撞名。
(function () {
'use strict';
const hold = $('voice-hold');
const ta = $('msg-input');
const overlay = $('voice-overlay');
const hintEl = $('voice-hint');
const waveEl = $('voice-wave');
if (!hold || !ta) return;
const native = (window.AgentNative && typeof window.AgentNative.startVoice === 'function')
? window.AgentNative : null;
const webOk = !!(window.isSecureContext && navigator.mediaDevices
&& typeof navigator.mediaDevices.getUserMedia === 'function'
&& (window.AudioContext || window.webkitAudioContext));
const MAX_MS = 180000; // 单次录音上限(流式上传后不再受 60s 限制)
const MIN_MS = 500; // 短于这个时长按误触处理,不上传
const FLUSH_MS = 60000; // 松手后等尾段识别完的上限(超过就当失败)
// 转写请求的并发上限:段一碎(6s 软切)并发就会很多,全放出去会把上游压垮、
// 也可能被限流。超过就排到后面,等前面的落定再发。改完刷新页面即生效。
const ASR_MAX_CONCURRENCY = 3;
const OUT_RATE = 16000; // 页面内部统一按 16k 处理:VAD 时长与段长上限都按它算
const BAR_COUNT = 45; // 声波柱数(要足够宽,手指按住时两侧仍能看到)
// 两端矮、中间高的包络:看起来像一段声波而不是一排等高柱子
const WEIGHTS = [];
for (let i = 0; i < BAR_COUNT; i++) {
WEIGHTS.push(0.45 + 0.55 * Math.sin(Math.PI * (i + 0.5) / BAR_COUNT));
}
const bars = [];
if (waveEl) {
for (let i = 0; i < BAR_COUNT; i++) {
const b = document.createElement('i');
waveEl.appendChild(b);
bars.push(b);
}
}
let available = false; // 有能力 + 服务端接线:发送键才显示麦克风
let mode = false; // 是否处于语音模式
let phase = 'idle'; // idle | arming(等 getMedia)| recording | busy
let pressing = false;
let pressY = 0; // 本次按压的起始 Y(判断“确实上滑了”)
let cancelArmed = false; // 已上滑到取消区
let discard = false; // 本次录音太短/已取消:结果到了也丢掉
let recordStartAt = 0;
let stopTimer = null;
let stream = null;
// 浏览器采集:ScriptProcessor 直接给 Float32 PCM,这里降到 16k 后喂 pushChunk
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 levelTarget = 0;
let levelCur = 0;
let lastRealLevelAt = 0;
let audioCtx = null;
let srcNode = null;
function clamp01(v) { return v < 0 ? 0 : v > 1 ? 1 : v; }
// 电平归一化的唯一实现:两条录音路径的 PCM 峰值都在这里落到 0~1。
// 低于 -55dB 视为静音,-5dB 及以上视为满幅;要调灵敏度只改这两个常量。
const LEVEL_FLOOR_DB = -55;
const LEVEL_RANGE_DB = 50;
function dbToLevel(db) {
return clamp01((db - LEVEL_FLOOR_DB) / LEVEL_RANGE_DB);
}
function setHoldText(s) {
if (hold.textContent !== s) hold.textContent = s;
}
// ---------- 遮罩 / 声波 ----------
function setOverlayMode(m) { // 'send' | 'cancel' | 'busy'
cancelArmed = m === 'cancel';
if (overlay) overlay.classList.toggle('cancel', m === 'cancel');
if (hintEl) {
hintEl.textContent = m === 'cancel' ? '松开取消'
: 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) {
if (!bars.length) return;
const t = Date.now() / 1000;
// 只有真的收到可听电平(大于门限)才加流动感;安静时保持完全静止,不靠抖动“装活”
const flow = animate && level > 0.02;
for (let i = 0; i < bars.length; i++) {
const ripple = flow ? (0.88 + 0.12 * Math.sin(t * 6 + i * 0.55)) : 1;
const h = Math.max(0.08, Math.min(1, (0.15 + 0.85 * level) * WEIGHTS[i] * ripple));
bars[i].style.transform = 'scaleY(' + h.toFixed(3) + ')';
}
}
function startLoop() {
if (rafId || !overlay || overlay.classList.contains('hidden')) return;
if (typeof requestAnimationFrame !== 'function') return;
rafId = requestAnimationFrame(tickMeter);
}
function tickMeter() {
rafId = 0;
if (!overlay || overlay.classList.contains('hidden')) return;
// 电平只有一个来源:pushChunk() 每收到一片 PCM 就更新 levelTarget。
// 超过 300ms 没有新数据(授权还没给 / 已经停了)→ 静默停在基线,不假动。
if (Date.now() - lastRealLevelAt > 300) {
levelCur = 0;
renderBars(0, false);
return;
}
// 快攻慢放:起音跟得紧,收音回落慢,柱体不抽筋
levelCur += (levelTarget - levelCur) * (levelTarget > levelCur ? 0.55 : 0.18);
renderBars(levelCur, true);
rafId = requestAnimationFrame(tickMeter);
}
// iOS Safari 只允许在用户手势里真正启动 AudioContext;getUserMedia 之后那条异步链已经
// 脱离手势,那时才 new AudioContext 有可能一直 suspended(一点声音都采不到)。
// 所以在 pointerdown 里先把 ctx 建好并 resume,拿到麦克风后直接复用。
function primeAudioCtx() {
if (audioCtx) return true;
const AC = window.AudioContext || window.webkitAudioContext;
if (!AC) return false;
try {
audioCtx = new AC();
if (audioCtx.state === 'suspended') audioCtx.resume();
return true;
} catch (_) {
audioCtx = 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() {
stopMeter(false);
levelTarget = 0;
levelCur = 0;
lastRealLevelAt = 0;
startLoop();
}
function stopMeter(flatten) {
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; }
// 采集节点也挂在这个 ctx 上:关掉它浏览器这边就彻底不再送 PCM 了
if (audioCtx) { try { audioCtx.close(); } catch (_) { /* 已关 */ } audioCtx = null; }
if (flatten !== false) {
for (let i = 0; i < bars.length; i++) bars[i].style.transform = 'scaleY(.12)';
}
}
function showOverlay() {
if (overlay) overlay.classList.remove('hidden');
// 录音期间隐藏输入卡内容(否则透明渐变会把按钮/文字透出来)
if (document.body) document.body.classList.add('voice-active');
setOverlayMode('send');
startMeter();
}
function hideOverlay() {
if (overlay) overlay.classList.add('hidden');
if (document.body) document.body.classList.remove('voice-active');
stopMeter();
cancelArmed = false;
}
function resetUI() {
phase = 'idle';
pressing = false;
pressY = 0;
discard = false;
stopBusyTicker();
abortStream();
if (stopTimer) { clearTimeout(stopTimer); stopTimer = null; }
hold.classList.remove('recording');
setHoldText('按住 说话');
hideOverlay();
updateSendBtn();
}
function releaseStream() {
if (!stream) return;
try { stream.getTracks().forEach(function (t) { t.stop(); }); } catch (_) { /* 已关 */ }
stream = null;
}
// ---------- 模式切换 ----------
function enter() {
if (!available || mode) return;
mode = true;
ta.classList.add('hidden');
hold.classList.remove('hidden');
try { ta.blur(); } catch (_) { /* 忽略 */ }
resetUI();
updateSendBtn();
}
function exit(focus) {
if (!mode) return;
cancelHold();
mode = false;
hold.classList.add('hidden');
ta.classList.remove('hidden');
autosize();
updateSendBtn();
// 必须在点击手势里同步 focus,移动端才会弹键盘
if (focus) { try { ta.focus(); } catch (_) { /* 忽略 */ } }
}
// ---------- 录音 ----------
function startHold() {
if (phase !== 'idle') return;
pressing = true;
discard = false;
segSent = 0;
segDone = 0;
hold.classList.add('recording');
setHoldText('松开 结束');
showOverlay();
if (native) {
// 原生侧即使要弹权限也先当「已开始」:页面已经开始收分片,壳真开录后会推数据。
// 首次授权那一次的分片要等用户点允许才会到,之前的静音不计入。
phase = 'recording';
recordStartAt = Date.now();
gen++; // 新会话:让上一轮迟到的结果全部失效
inflight = []; // 上一轮的在途请求不再计入本轮收口
streamOn = true;
pcmRate = 16000;
clearSeg();
textParts = [];
stopTimer = setTimeout(finishHold, MAX_MS);
try {
native.startVoice();
} catch (e) {
resetUI();
toast('无法开始录音:' + String((e && e.message) || e));
}
return;
}
// 浏览器:先拿麦克风(可能要等用户授权),拿到后 startCapture 开始往里推 PCM
phase = 'arming';
primeAudioCtx(); // 必须在手势里建(见 primeAudioCtx 注释)
startWeb();
}
async function startWeb() {
try {
stream = await navigator.mediaDevices.getUserMedia({ audio: true });
} catch (e) {
resetUI();
const denied = e && (e.name === 'NotAllowedError' || e.name === 'SecurityError');
toast(denied ? '麦克风权限被拒绝' : '无法打开麦克风:' + String((e && e.message) || e));
return;
}
if (!pressing) { releaseStream(); resetUI(); return; } // 松开得比授权快
// 与套壳同一套状态,只是换成了「自己采 PCM」而不是「等壳推」
phase = 'recording';
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);
}
// 松手:结束录音(太短则丢弃)
function finishHold() {
if (phase !== 'recording') return;
if (stopTimer) { clearTimeout(stopTimer); stopTimer = null; }
const held = Date.now() - recordStartAt;
if (held < MIN_MS) discard = true;
phase = 'busy';
hold.classList.remove('recording');
setHoldText(discard ? '按住 说话' : '正在识别…');
// 遮罩留着,文案换成动态识别进度;柱子停在低位,等结果回来再收
setOverlayMode(discard ? 'send' : 'busy');
stopMeter();
if (discard) {
abortStream();
releaseStream();
nativeStop(false); // 只停采集,不用管壳知不知道“被丢弃”(页面已经不再收分片)
resetUI();
toast('说话时间太短');
return;
}
// 两条路收口完全一样:把不足一个停顿的尾巴发走(纯静音的尾巴不发),再等所有段回来。
// 大部分段在说话过程中已经识别完了,这里通常只等最后一段。
flushTail();
startBusyTicker(); // 尾巴已进队列:现在才有准确的总段数,从这一刻开始计时
if (native) {
try {
native.stopVoice();
} catch (e) {
resetUI();
toast('结束录音失败:' + String((e && e.message) || e));
return;
}
} else {
releaseStream(); // 采集节点已经由上面的 stopMeter() 拆掉了
}
waitFlush();
}
// 让壳停止采集:优先 cancelVoice(语义明确),壳没实现时退回 stopVoice——
// 否则麦克风会在壳侧一直开着(页面这边已经不再收分片了,但录音还在跑)。
function nativeStop(cancel) {
if (!native) return;
try {
if (cancel && native.cancelVoice) native.cancelVoice();
else if (native.stopVoice) native.stopVoice();
} catch (_) { /* 已停 */ }
}
// 放弃本次录音(切模式 / 离开页面 / 上滑取消 / 壳回调 cancelled)
function cancelHold() {
if (phase === 'idle') return;
abortStream(); // 丢弃已发在途的结果,也不碰输入框
releaseStream(); // 浏览器:停麦克风轨道(采集节点由 resetUI → stopMeter 拆)
nativeStop(true);
resetUI();
}
// ---------- 按住 / 滑动 / 松开 ----------
hold.addEventListener('pointerdown', function (e) {
if (e && e.button != null && e.button !== 0) return; // 只响应左键/触摸
e.preventDefault();
if (phase !== 'idle') return;
pressY = e.clientY || 0;
try { hold.setPointerCapture(e.pointerId); } catch (_) { /* 忽略 */ }
startHold();
});
function onMove(e) {
if (!pressing) return;
if (phase !== 'recording' && phase !== 'arming') return;
if (!overlay || overlay.classList.contains('hidden') || !hintEl) return;
// 阈值取文案元素的实际下沿;同时要求相对按下点确实上滑了一段,
// 否则首次 pointermove 的坐标噪声或极端布局会把状态直接判成取消(一进来就红)。
const line = hintEl.getBoundingClientRect().bottom;
const limit = pressY ? Math.min(line - 4, pressY - 24) : (line - 4);
const y = e.clientY;
if (!cancelArmed && y < limit) setOverlayMode('cancel');
else if (cancelArmed && y > line + 4) setOverlayMode('send');
}
function onRelease(e) {
// 必须先进 pressing 判断:这个监听器也挂在 window 上,
// 对无关的 pointerup 调 preventDefault 会吞掉全局 click 事件。
if (!pressing) return;
if (e) e.preventDefault();
pressing = false;
if (cancelArmed) {
// 不弹提示:toast 会盖住声波(取消本身已经有颜色/文案反馈)
cancelHold();
return;
}
if (phase === 'recording') finishHold();
else if (phase === 'arming') cancelHold(); // 还没真正开录:当误触
}
hold.addEventListener('pointerup', onRelease);
hold.addEventListener('pointercancel', onRelease);
hold.addEventListener('pointermove', onMove);
// 兜底:个别环境下 setPointerCapture 不生效,手指移出按钮后也要跟手
window.addEventListener('pointerup', onRelease);
window.addEventListener('pointercancel', onRelease);
window.addEventListener('pointermove', onMove);
// 长按不弹系统菜单(移动端)
hold.addEventListener('contextmenu', function (e) { e.preventDefault(); });
// 键盘可达:空格/回车按下开始,松开结束
hold.addEventListener('keydown', function (e) {
if (e.repeat) return;
if (e.key !== ' ' && e.key !== 'Enter') return;
e.preventDefault();
if (!pressing) startHold();
});
hold.addEventListener('keyup', function (e) {
if (e.key !== ' ' && e.key !== 'Enter') return;
e.preventDefault();
onRelease(null);
});
// 录音中离开页面:释放麦克风
window.addEventListener('pagehide', cancelHold);
// ---------- PCM 处理(两条录音路径共用) ----------
// 壳每 ~100ms 推一片 16bit/单声道小端 PCM;浏览器自己采。采样率、分片大小、门限全部不在别处算。
function b64ToI16(b64) {
const bin = atob(String(b64 || ''));
const n = bin.length >> 1;
const out = new Int16Array(n);
for (let i = 0; i < n; i++) out[i] = (bin.charCodeAt(i * 2 + 1) << 8) | bin.charCodeAt(i * 2);
return out;
}
// 这一片 PCM 的峰值电平(dBFS)。用峰值而不是 RMS:与原先 getMaxAmplitude 的尺度一致。
function peakDb(arr) {
let peak = 0;
for (let i = 0; i < arr.length; i++) {
const v = arr[i] < 0 ? -arr[i] : arr[i];
if (v > peak) peak = v;
}
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) {
if (!native || s !== 'recording' || phase !== 'recording') return;
// 真正开录:180s 与「太短」判定从这一刻算(首次授权弹窗的时间不算)
recordStartAt = Date.now();
if (stopTimer) clearTimeout(stopTimer);
stopTimer = setTimeout(finishHold, MAX_MS);
if (!pressing) finishHold(); // 弹窗期间已经松手:立刻收口(held≈0 → 丢弃)
};
window.onNativeVoiceError = function (code, message) {
if (phase === 'idle') return;
abortStream();
resetUI();
// 生命周期打断(切后台/换页)属预期,不弹提示
if (code === 'cancelled' || code === 'canceled') return;
toast(code === 'too_short'
? '说话时间太短,请按住再说'
: '录音失败:' + String(message || code || '未知错误'));
};
// ---------- 对外暴露给发送键 / sessions.js 的状态查询 ----------
window.AgentVoice = {
isAvailable: function () { return available; },
isVoiceMode: function () { return mode; },
enter: enter,
exit: exit
};
// 能力判定:桥优先;没有桥就得是安全上下文(浏览器不允许 http 页面开麦)
if (!native && !webOk) {
console.info('[voice] 语音入口未启用:没有 window.AgentNative,且当前不是安全上下文(需 HTTPS,或由套壳 App 注入原生桥)');
return;
}
// 服务端没接线(core 的 ASR_URL 为空,或 config.yml 里没有可用的 asr 段)就不给入口;
// 探测失败则照常启用(不因一次探测失败就永久藏掉入口)。
req('GET', '/api/asr/status').then(function (s) {
if (s && s.enabled === false) {
console.info('[voice] 语音入口未启用:' + ((s && s.reason) || '服务端未配置语音识别'));
return;
}
available = true;
updateSendBtn();
}).catch(function () {
available = true;
updateSendBtn();
});
})();
+4 -2
View File
@@ -2,7 +2,7 @@
<html lang="zh">
<head>
<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>
<meta name="theme-color" content="#1e3c72">
<meta name="apple-mobile-web-app-capable" content="yes">
@@ -13,7 +13,8 @@
<link rel="stylesheet" href="/css/style.css">
<style>
.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);
}
.login-card {
@@ -39,6 +40,7 @@
<p class="login-error" id="login-error"></p>
</form>
</div>
<script src="/js/viewport.js"></script>
<script>
'use strict';
const TOKEN_KEY = 'agent_token';
+9 -2
View File
@@ -50,8 +50,12 @@ self.addEventListener('fetch', (event) => {
// 只处理同源
if (url.origin !== self.location.origin) return;
// 跳过 API/SSE/预览/交付取件,避免缓存动态数据(预览页需实时;/f/ 同链内容会随重新 save 变化)
if (url.pathname.startsWith('/api/') || url.pathname.startsWith('/sse') || url.pathname.startsWith('/preview') || url.pathname.startsWith('/f/')) return;
// 跳过 API/SSE/预览/交付取件,避免缓存动态数据(预览页需实时;/f/ 同链内容会随重新 save 变化)。
// /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 是预览页):
// 内容随文档变化,既不缓存,也不能把 office 文档页写进 '/' 这类 SPA 缓存键。
@@ -73,6 +77,9 @@ self.addEventListener('fetch', (event) => {
try {
const resp = await fetch(request);
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 };
} catch (e) {
if (last) break; // 已有残破快照:降级返回它
+126
View File
@@ -0,0 +1,126 @@
// 语音识别代理:浏览器 / 套壳 App 录好的音频 → agent-core → mcp_asr → 文字。
//
// 为什么要 core 中转、而不是前端直连 ASR 容器:mcp_asr 只挂在 agent-mcp-net 内网、
// 一个宿主端口都不占(它自身没有鉴权,暴露即被白嫖)。对外唯一的入口仍是 core,
// 鉴权沿用全局登录态(auth.middleware 已挂在 /api 之前)。
//
// 上游参数全部来自 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 engine = require('../engine');
const log = require('../log');
const router = express.Router();
const ASR_URL = String(process.env.ASR_URL || '').trim().replace(/\/+$/, '');
// 与 mcp_asr 的上限保持一致(60s 的 AAC 约 240KB,这里给长音频留余量)
const MAX_BYTES = 20 * 1024 * 1024;
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,两者不冲突。
// 注意 WebView 可能发 audio/mp4、audio/webm;codecs=opus,统一按 audio/* 接。
const rawAudio = express.raw({
type: ['audio/*', 'application/octet-stream', 'application/mp4'],
limit: '20mb',
});
// 前端可用性探测(按钮是否显示)。不碰网络,纯看接线。
router.get('/status', function (req, res) {
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) {
if (!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;
if (!Buffer.isBuffer(buf) || !buf.length) {
return res.status(400).json({ error: '未收到音频数据(Content-Type 需为 audio/*)' });
}
try {
const r = await fetch(ASR_URL + '/transcribe', {
method: 'POST',
headers: Object.assign({ 'Content-Type': req.headers['content-type'] || 'application/octet-stream' }, headers),
body: buf,
signal: AbortSignal.timeout(TIMEOUT_MS),
});
const text = await r.text();
if (!r.ok) {
// ASR 服务回的是 {error:string}:解出来再转,不然前端会看到两层套嵌的 JSON
let msg = text.slice(0, 300);
try { msg = JSON.parse(text).error || msg; } catch (_) { /* 非 JSON 保留原文 */ }
log.warn('asr', '识别失败 HTTP ' + r.status + ':' + msg);
// 4xx(静音 / 坏音频 / 过载)原样透传;5xx 统一当上游故障
const code = r.status >= 400 && r.status < 500 ? r.status : 502;
return res.status(code).json({ error: msg });
}
// 原样透传 ASR 的 {text, ms, model}
res.type('application/json').send(text);
} catch (e) {
log.warn('asr', '调用 ASR 服务失败:' + String(e && e.message || e));
res.status(502).json({ error: '语音识别服务不可用:' + String(e && e.message || e) });
}
});
// express.raw 超限时抛 entity.too.large,默认会回 HTML;这里翻成前端能读的 JSON。
router.use(function (err, req, res, next) {
if (err && (err.type === 'entity.too.large' || err.status === 413)) {
return res.status(413).json({ error: '音频过大(上限 ' + Math.round(MAX_BYTES / 1048576) + 'MB)' });
}
next(err);
});
module.exports = router;
+15 -4
View File
@@ -236,7 +236,11 @@ function handleSend(db, opts) {
// 普通消息:解析当前会话,无绑定自动新建(IM 用户不会先打 /new 才能聊天)。
// 微信通道以 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) {
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;
@@ -246,10 +250,17 @@ function handleSend(db, opts) {
const r = newSessionFor(db, user, channel, text, wx ? { deepThink } : undefined);
s = r.s; sent = r.sent;
} 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);
return { kind: 'message', reply: '已发送到会话 ' + s.id, session_id: s.id, message_id: sent.message_id };
const queued = !!(sent && sent.queued);
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) {
+108 -17
View File
@@ -5,10 +5,55 @@ const express = require('express');
const engine = require('../engine');
const { loadConfigFromText, readConfigText, applyEditsToText, writeConfigText } = require('../config');
const balance = require('../balance');
const mcp = require('../mcp');
const log = require('../log');
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) {
const code = err && err.status_code || 500;
res.status(code).json({ error: String(err && err.message || err) });
@@ -112,13 +157,29 @@ function restorePasswords(submitted, orig) {
}).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`,引号可选)。
// 局限:块标量(|/>)续行内容无法逐行识别,与 api_key/password 的行级掩码同一量级的取舍。
const MCP_HEADER_MASK = '*****';
const HEADERS_BLOCK_LINE = /^(\s*)headers:\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) 返回替换后的行;块边界按缩进判定。
function mapMcpHeaderLines(text, fn) {
if (!text) return text;
@@ -138,22 +199,32 @@ function mapMcpHeaderLines(text, fn) {
}
function maskMcpHeaders(text) {
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) {
if (!submitted) return submitted;
const origVals = [];
mapMcpHeaderLines(orig || '', function (line, m) { origVals.push(m[3]); return line; });
let i = 0;
const origVals = {};
mapMcpHeaderLines(orig || '', function (line, m) { origVals[headerNameOf(m)] = m[3]; return line; });
return mapMcpHeaderLines(submitted, function (line, m) {
if (m[3] !== MCP_HEADER_MASK) return line; // 用户改过,保留手输新值
const ov = i < origVals.length ? origVals[i] : '';
i++;
return m[1] + m[2] + ov + m[2];
const name = headerNameOf(m);
if (!(name in origVals)) throw new Error('Header「' + name + '」的值为脱敏占位且找不到原值,请填写真实值');
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 还原:值=掩码占位时按键名找回原值(前端只持有脱敏视图,改不动真值)。
// 找不到可还原的原值(新增服务/用户改了 header 名)则报错,绝不把占位符写进配置。
function restoreHeaderMasks(headers, origHeaders) {
@@ -168,13 +239,22 @@ function restoreMaskedHeaderEdit(e, curCfg) {
if (e.delete) return;
const p = e.path;
if (p[0] !== 'mcp_servers') return;
const origOf = (i) => (((curCfg || {}).mcp_servers || [])[Number(i)] || {}).headers || {};
if (e.append) { // 新增服务没有“原值”可言,出现占位即拒绝
if (e.value && e.value.headers) restoreHeaderMasks(e.value.headers, null);
return;
}
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, orig);
restoreHeaderMasks(e.value, origOf(p[1]));
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 => {
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 });
});
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() });
}));
// 预设模板(前端新增平台 / 添加内置 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 }
// 还原脱敏后的 api_key/password 再校验,避免 diff 误报变更。
router.post('/validate', wrap((req, res) => {
const text = req.body && req.body.text;
if (typeof text !== 'string') return badRequest(res, new Error('body.text 必须是字符串'));
const origText = readConfigText(cfgOf()) || '';
const restored = restoreApiKeys(restorePasswords(restoreMcpHeaders(text, origText), origText), origText);
const restored = unmaskText(text, origText);
try {
const next = loadConfigFromText(restored, '');
res.json({ ok: true, changed: diffTop(cfgOf(), next) });
@@ -237,7 +327,7 @@ router.put('/', wrap((req, res) => {
const text = req.body && req.body.text;
if (typeof text !== 'string') return badRequest(res, new Error('body.text 必须是字符串'));
const origText = readConfigText(cfg) || '';
const restored = restoreApiKeys(restorePasswords(restoreMcpHeaders(text, origText), origText), origText);
const restored = unmaskText(text, origText);
let next;
try { next = loadConfigFromText(restored, cfg.config_path); } catch (e) { return badRequest(res, e); }
writeConfigText(cfg, restored);
@@ -261,8 +351,9 @@ function normEdit(e) {
}
router.patch('/', wrap((req, res) => {
const cfg = cfgOf();
const text = readConfigText(cfg);
if (text === null) return sendErr(res, Object.assign(new Error('配置文件不存在:' + (cfg.config_path || '(未知路径)')), { status_code: 409 }));
// 文件缺失(或曾被 Docker 误建成空目录)不阻塞:以空文档继续,写入时由 writeConfigText 创建。
// 前提是父目录可写(容器里 /app 可写);否则 fs.writeFileSync 会报错并在下面回 500。
const text = readConfigText(cfg) || '';
const body = req.body || {};
let edits;
try {
+98 -1
View File
@@ -1,5 +1,6 @@
// 文件管理 API:上传 / 列表 / 下载 / 删除
// 文件管理 API:上传 / 列表 / 下载 / 预览 / 删除
const express = require('express');
const crypto = require('crypto');
const fs = require('fs');
const path = require('path');
const multer = require('multer');
@@ -146,6 +147,102 @@ router.get('/:id/files/download', serveDownload);
// 供解析不了 Content-Disposition 的下载器兜底;path 参数与验签逻辑完全一致。
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 流式返回) ----------
// 纯 Node 实现(STORE 不压缩 + 手拼 zip 结构):任务目录里多是媒体/生成产物,
// 压缩收益低;两遍读文件(先算 CRC 再磁盘流发送),内存占用与总大小无关。
+29
View File
@@ -16,17 +16,46 @@ function wrap(fn) {
}
// 附件上传只写任务目录文件(见 routes/files.js),消息正文原样入库,不再拼接任何通知行。
// delivery:
// live(默认,兼容旧调用方/微信)→ 立即入库;回合在跑时下一轮迭代自动带上
// queue → 回合在跑时进待投递队列(不落库),回合收尾后自动发出;不在跑则等价于 live
// 「干预 / 立即发送」不走这里,而是对已在队列里的条目做升级(POST /pending/:qid)。
router.post('/:id/messages', wrap((req, res) => {
const content = String((req.body && req.body.content) || '').trim();
if (!content) return res.status(400).json({ error: 'content 不能为空' });
// deepThink:是否启用模型该「深度思考」参数(thinking_params 合并进上游请求体)
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 });
log.info('msg', (req.user || '-') + ' ' + req.params.id + ' 用户消息(' + (r && r.delivered || '?') + '):' +
content.slice(0, 60).replace(/\s+/g, ' '));
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)。
router.post('/:id/messages/:mid/edit', wrap((req, res) => {
+11 -2
View File
@@ -7,6 +7,10 @@
// 3. 只吐"签发时已校验过、且落在该会话任务目录内"的文件,这里再用 resolveInTask 复核一次。
//
// 挂在 auth.middleware **之前**(server.js),所以登录与否都能访问;未命中一律 404,不吐内部信息。
//
// 响应头按扩展名分两路:图片(png/jpg/webp/gif/.../svg)走 inline + 明确 image/*,
// 用户或外部服务点开链接就能直接看图;其余一律 attachment,交给下载器
// (安卓封装壳的 DownloadManager 只认 attachment,下载语义不能改)。
'use strict';
const fs = require('fs');
@@ -14,7 +18,7 @@ const express = require('express');
const engine = require('../engine');
const publicFiles = require('../public-files');
const { resolveInTask } = require('../tools/executor');
const { sendDownload } = require('../download-send');
const { sendDownload, sendInlineImage, inlineImageType } = require('../download-send');
const log = require('../log');
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');
}
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);
});
+2
View File
@@ -208,6 +208,8 @@ router.get('/:id', wrap((req, res) => {
files: listTaskFiles(taskDir),
schedule,
running: !!(engine.getRun(session.id) || {}).looping,
// 待投递队列(刷新/换设备后条幅能原样恢复):只在服务端内存里,重启即空
pending: engine.listPending(session.id),
has_more: hasMore, // 分页模式下:是否还有更早的历史
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();
// 版本以本文件字面量为准:容器部署只挂载 app/server,镜像里的 package.json 可能是旧的,
// 读它会一直显示发版时的版本号(之前 2.1.0 改完仍显 2.0.0 即此因)。发版时记得同步这里。
const VERSION = '2.3.0';
const VERSION = '2.5.0';
// git 提交号单独返回(提交时 post-commit 钩子自动生成),前端只显示简洁版本号
const VERSION_COMMIT = versionInfo.commit || '';
+23 -2
View File
@@ -18,7 +18,10 @@ const log = require('./log');
const cfg = loadConfig(process.env.AGENT_CONFIG);
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 bus = createBus();
@@ -71,6 +74,9 @@ app.use('/api/sessions', require('./routes/files'));
// 与 /api/db 对称;执行核心仍复用 tools/skills.runSkill,core 不感知具体技能。
app.use('/api/sessions', require('./routes/skill-run'));
app.use('/api/skills', require('./routes/skills'));
// 语音识别(可选):录音在客户端(套壳 App 原生桥或浏览器 MediaRecorder),转写在 mcp_asr。
// ASR_URL 为空、或 config.yml 里没有启用的 asr 段时接口回 503,前端据此不显示麦克风按钮(见 routes/asr.js)。
app.use('/api/asr', require('./routes/asr'));
// 系统配置含全部用户(脱敏密码)与平台密钥,且可整份改写 YAML:仅管理员可访问。
app.use('/api/config', auth.requireAdmin, require('./routes/config'));
app.use('/api/platforms', require('./routes/platforms'));
@@ -145,7 +151,22 @@ app.get('/api/models', (req, res) => {
res.json(rows);
});
app.get('/api/health', (req, res) => res.json({ ok: true, time: Date.now() }));
// 探活 + 服务器地址校验(免认证,见 auth.js 的 PUBLIC_EXACT)。
// 套壳 App / 运维脚本会手动填服务器地址,必须能判断“这个地址到底是不是本服务”:
// 只认 HTTP 200 + body.ok===true + service==='agent-core',不能只看状态码——
// 填到别的站点、反代首页或劫持页同样可能回 200。
// no-store:避免 WebView / 反向代理 / Service Worker 把旧响应当成“服务在线”。
// auth_required 让客户端区分“连上了但没登录”和“地址填错了”。
app.get('/api/health', (req, res) => {
res.setHeader('Cache-Control', 'no-store');
res.json({
ok: true,
service: 'agent-core',
api: 1, // 接口代际:未来出现不兼容改动时升,客户端据此提示升级
time: Date.now(),
auth_required: !!(cfg.auth && cfg.auth.users && cfg.auth.users.length),
});
});
const PORT = process.env.PORT || cfg.port;
+57 -92
View File
@@ -1,109 +1,74 @@
You are a general-purpose task assistant running on a private server via a web
interface. You help with file generation, data processing, web fetching,
You are a general-purpose task assistant on a private server, reached through a
web interface. You help with file generation, data processing, web fetching,
running commands, writing scripts, and similar tasks.
You have a dedicated working directory for each conversation. All file paths in
tool calls are relative to that directory unless otherwise specified.
Each conversation has its own working directory; tool paths are relative to it
unless stated otherwise. Uploaded files appear there.
## Scope & Capability Boundaries
## Capabilities
You are a file / data / information processing assistant. The tools available
to you vary by session — always check the live tool list before answering.
Your capabilities are exactly what the live tool list and the skills list below
expose — they vary by session, so check them before answering. Do not assume a
capability that isn't there.
In scope: understanding images (describe, OCR, read charts); deterministic image
operations (format conversion, resize, crop, watermark); generative image
creation and editing when an image skill/tool is available; charts and diagrams
from data; document processing and conversion (PDF / Markdown / Word / Excel /
PowerPoint); data processing; running scripts and commands; fetching and
summarizing web information; audio/video transcoding and basic editing;
generative media when a tool or skill for it is present in the current session
(read that tool's or skill's own description for its capabilities and limits);
SQLite operations.
Never fake results: no placeholder files, no claiming a file was created, no
crude substitutes (ASCII art, hand-drawn SVG) for what the user actually wants.
Out of scope: capabilities no available tool exposes in this session. Do not
fake results — no placeholder files, no claiming a file was created, no crude
substitutes (ASCII art, hand-drawn SVG) for what the user actually wants.
When the user asks for something that seems out of scope:
- Before concluding you can't do it, check for combinations: chaining tools, or
combining tools with the user's own environment (their browser or device).
Some requests are impossible from the server alone but become possible when
the work is split between the server and the user's side.
- If an available skill might handle it, check the skill before declaring it out
of scope.
- If it truly can't be done, say so in one or two sentences and stop — do not
call tools just to reject a request, do not over-apologize. If a third-party
tool covers it, mention one briefly. If part of the request is doable, offer
that part.
## Communication
- Be concise and direct. Use plain language; format with Markdown when useful.
- Be truthful. If unsure, say so.
- Do not over-apologize.
If something seems impossible, check relevant skills first, then whether tools
can be combined, or whether the work can be split with the user's own
environment (their browser or device). If it truly can't be done, say so in one
or two sentences and offer whatever part is doable; do not call tools just to
reject a request.
## Work Principles
- **Choose the simplest reliable path.** Prefer standard library or built-in
tools. If a required package is missing, install it into a session-local venv
when possible; otherwise use a fallback or report the limitation.
- **Stop after repeated failures.** If the same approach fails more than once or
twice, switch to a different approach or report failure. Do not keep retrying
the same method.
- **Report progress.** If a task will take many steps, state your plan briefly
first and give periodic updates. Do not run silently for a long stretch.
- **Match effort to the task.** Do not write complex scripts where a few
commands suffice, and do not verify more deeply than the task requires. One
basic check that the output is usable is enough.
- Choose the simplest reliable path; do not write a script where a few commands
suffice.
- If the same approach fails twice, switch approaches or report the failure —
do not keep retrying.
- For multi-step work, state the plan briefly and give periodic updates.
- Match effort to the task: one basic check that the output is usable is enough.
## Tool Use
## Tools
- Use the most appropriate tool for each step.
- Independent tool calls can be made in parallel.
- Follow the parameter schemas exactly; parameters are passed as top-level
fields of the tool call arguments.
- Skills marked **required** in the skill list below must be used for their
scope — do not hand-write scripts to accomplish what a required skill already
does. For other skills, prefer them when they match the task.
- `mint_public_link` creates a public, unauthenticated URL — never use it for
files containing secrets. For image editing, minting the reference image is
the intended path; the link is temporary but publicly reachable.
- Independent calls can run in parallel. Parameters are top-level fields of the
tool call arguments — follow the schema exactly.
- `mint_public_link` makes a file publicly reachable without authentication —
never use it for files containing secrets.
## Skill Use
Before writing a script or installing a package, check the skill list below.
If a skill covers the task, use it instead of reimplementing the same job in
ad-hoc code — skills already handle the server-specific pitfalls. Read its
interface with the `skill` tool (`{"op":"get","name":"<skill>"}`) before the
first run, once per skill per conversation. `required` marks the skills whose
domain must never be hand-rolled.
{APP_SKILLS_SECTION}
## File Management
## Communication
- Work inside the working directory. Use clear file names.
- Uploaded files appear in the working directory; check with `terminal` (e.g.
`ls`) if needed.
- Be concise and direct; Markdown when useful. If unsure, say so. Don't
over-apologize.
- When done, briefly state what was done and list created/modified files. Offer
follow-ups only when useful.
## Completion
## Environment
- After finishing, briefly state what was done and list created/modified files.
- Offer follow-up options only if useful; do not do extra work automatically.
## System Environment
- OS: linux. Shell commands run under POSIX sh (`/bin/sh` is dash); use `bash`
for scripts (`run.sh`). Keep `terminal` one-liners POSIX-compatible.
- Isolated container: a command can access the session working directory, a
session-scoped `/tmp`, read-only `/workspace/skills`, and read-only system
paths. It cannot see other sessions.
- `/tmp` is usable for scratch across `terminal` calls in the same conversation.
`/dev/shm` and `/var/tmp` reset on every `terminal` call — do not use them to
carry state across calls.
- Python 3.11 is available; the system Python and its packages are read-only.
To add packages, create a virtualenv inside the working directory
(`python3 -m venv --system-site-packages .venv`, then `.venv/bin/pip` and `.venv/bin/python`).
Keep it in the working directory, not `/tmp`.
The venv inherits system packages; do not reinstall packages that are
already importable. Only install what is missing.
- System packages cannot be installed at runtime (`apt-get install` fails on the
read-only root filesystem). If a required CLI tool is missing, tell the user
it must be added on the server.
- No C/C++ compiler or `make` — `pip install` works only for packages that ship
a prebuilt wheel or are pure Python.
- For Chinese text in matplotlib: set `font.sans-serif` to `Noto Sans CJK SC`.
- For Chinese ZIP files with GBK filenames, prefer `unar` or `7z x` to avoid
garbled names; in Python, use automatic encoding detection.
- Linux container, isolated per conversation: you see the working directory, a
session-scoped `/tmp`, read-only `/workspace/skills`, and system paths — never
other sessions.
- `terminal` runs POSIX sh (`/bin/sh` is dash); use `bash` for scripts.
- `/tmp` persists across calls in a conversation; `/dev/shm` and `/var/tmp` are
wiped on every call.
- Python 3.11; system packages are read-only. Add packages in a venv in the
working directory: `python3 -m venv --system-site-packages .venv`, then
`.venv/bin/pip` / `.venv/bin/python`. Don't reinstall packages that are
already importable.
- System packages can't be installed at runtime (`apt-get` fails). A missing CLI
tool must be added on the server — tell the user.
- No C/C++ compiler or `make`: `pip install` only works for pure-Python or
prebuilt-wheel packages.
- Chinese text in matplotlib: set `font.sans-serif` to `Noto Sans CJK SC`. For
ZIPs with GBK filenames, use `unar` or `7z x` to avoid garbled names.
+21 -34
View File
@@ -418,9 +418,10 @@ function saveTaskMedia(s, buf, kind, rawName) {
// 预算够 → 全文 + 附件卡片;放不下但 ≥2 → 降级「截断头部 + 全文写会话
// .md 转文件卡片」(内容零丢失);<2 → 放弃并告警(网页端完整可见)。
// 4. 工具台账(重结果轻过程;微信端不再有独立台账消息):tool_call/tool_result 只在 st.tools
// 记账;失败即时单发一行「工具调用失败: 名称 + 参数」(预算保不住结论储备则留给尾段汇总);
// done 时汇总为一句「本轮工具调用 N 次(name x c, ...),其中 M 次失败」搭结论尾段,
// 纯工具轮(无结论文本)则汇总与文件卡片合成一条兜底消息(网页端始终全量可见)。
// 记账;**工具失败一律不下发**(多数是 AI 参数用错,模型下一轮自己改,推给用户既看不懂
// 也帮不上忙;网页端工具卡与库里的 is_error 照旧保留)。done 时只汇总一句中性计数
// 「本轮工具调用 N 次(name x c, ...)」搭结论尾段,若本轮有因用户介入而未执行的调用,
// 额外补「N 次因你介入未执行」;纯工具轮(无结论文本)则汇总与文件卡片合成一条兜底消息。
// 5. 通用 ui_card(MCP 工具回包的预览卡片块):按 URL 去重攒进 st.cards,不独立占配额,
// done 时作「文件」小节搭结论尾段;每条 markdown 链接 + 原始 URL 各一行(防纯文化退化
// 后点不开);未知 action 或未配公网前缀在微信端静默忽略。
@@ -439,13 +440,13 @@ function attachBus() {
else if (event === 'done') enqueueDelivery(bid, () => flushHeld(bid));
else {
// 工具调用/回执:心跳 + 台账记账(台账不再独立成消息,见策略注释第 4 条);
// 失败经串行队列即时单发一行;ui_card 攒进本回合卡片列表(done 时随尾段投)。
// 失败一律**不下发**(多数是 AI 参数用错,模型下一轮自己改;用户看到
// 「工具调用失败」既看不懂也帮不上忙)。网页端工具卡与库里的 is_error 照旧保留。
// ui_card 攒进本回合卡片列表(done 时随尾段投)。
// reasoning_delta(思考流)不进台账,只走下面的心跳——微信用户能看到「正在输入」在思考。
if (event === 'tool_call') toolDigestPush(bid, data);
else if (event === 'tool_result') {
toolDigestMark(bid, data);
if (data && data.is_error) enqueueDelivery(bid, () => flushFailedLine(bid));
} else if (event === 'ui_card') cardCollect(bid, data, sessionId);
else if (event === 'tool_result') toolDigestMark(bid, data);
else if (event === 'ui_card') cardCollect(bid, data, sessionId);
maybeTypingPing(bid); // 「正在输入」心跳:长工具/思考回合里微信持续看到 AI 还在干活
}
} catch (e) {
@@ -572,32 +573,34 @@ function toolDigestPush(bid, data) {
const name = String((data && data.name) || '');
if (!name) return;
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; }
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 (_) { /* 摘要锦上添花,绝不动摇投递 */ }
}
// 只记「未执行」(用户介入/终止导致没跑的调用)。工具自身失败不进台账展示:
// 多数是 AI 参数写错,模型下一轮会自己改;它要不要告诉用户,由模型自己的回复决定。
function toolDigestMark(bid, data) {
try {
if (!data || !data.is_error) return;
if (!data || !data.skipped) return;
const st = getTurn(bid);
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 (_) { /* 同上 */ }
}
// 降级路径的渲染(peek 不清空):台账单发预算不足/失败时搭结论尾段,结论投递成功后调用方清空。
// 若 wxbot 开 WXBOT_STRIP_MARKDOWN 回退纯文化,stripMarkdown 会把围栏/标题降为普通行,信息不丢。
// done 尾段的工具汇总(peek 不清空):一句计数 + 未即时送达的失败行;结论投递成功后由调用方清空。
// done 尾段的工具汇总(peek 不清空):一句中性计数 + 「因你介入未执行」的条数。
// 刻意不列失败:工具报错是 AI 自己该处理的事,往里推只会让用户困惑(详见 toolDigestMark 注释)。
function peekToolDigest(st) {
const ts = st && st.tools;
if (!ts || !ts.length) return '';
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 errN = ts.filter(t => t.err).length;
let s = '---\n\n### 工具\n\n本轮工具调用 ' + total + ' 次(' + breakdown + ')';
if (errN) s += ',其中 ' + errN + ' 次失败';
const unnotified = ts.filter(t => t.err && !t.warned);
if (unnotified.length) s += '\n' + unnotified.map(t => '- 失败: ' + t.name + (t.hint ? ' ' + t.hint : '')).join('\n');
const skipN = ts.filter(t => t.skipped).length;
if (skipN) s += ',' + skipN + ' 次因你介入未执行';
return s;
}// 正文与 digest 一起分段:正文照旧 splitText,digest 原子追尾——markdown 代码围栏不能被
// 1800 字分段拦腰斩断;尾段能与正文同段就同段(不多占配额),放不下才单独成段。
@@ -610,22 +613,6 @@ function digestSegs(body, digest) {
else segs.push(digest);
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 条)----------
// open_preview → 绝对预览 URL:与前端 pvOfficeUrl/网关寻址同款,前缀真相在 core(public_link.base_url)。
function uiCardUrl(data, sessionId) {
@@ -671,7 +658,7 @@ async function flushTail(bid) {
// 留给结论尾段搭便车;直投失败归还队首(串行队列调度,与正文消息天然排队,无并发互踩)。
// 过程消息:直发窗口内且投完后仍给结论留足储备才投;否则计入 omitted,并进结论的注记行。
// 正文不携带工具信息——工具信息自有出口(失败即时行/done 尾段汇总),不重复。
// 正文不携带工具信息——工具信息自有出口(done 尾段汇总),不重复;工具失败不下发。
async function deliverProcess(bid, m, sessionId) {
const b = bindReady(bid);
if (!b || stale(b, m)) return;
+33 -15
View File
@@ -4,8 +4,7 @@ services:
container_name: agent-core
restart: unless-stopped
ports:
# 无 nginx-proxy:直接把容器 8090 映射到宿主机端口,用 http://<服务器IP>:<AGENT_PORT> 访问。
# 改端口:在仓库顶层 .env 里设 AGENT_PORT(默认 8090)。
# 直接把容器 8090 映射到宿主机端口,用 http://<服务器IP>:<AGENT_PORT> 访问。
- "${AGENT_PORT:-8090}:8090"
volumes:
- ./tasks:/workspace/tasks # 持久化:任务目录
@@ -20,10 +19,15 @@ services:
- EXECUTOR_URL=http://agent-executor:9000
# 调用鉴权 token:两侧同一值。从 .env 读取(已 gitignore),不再硬编码进仓库;
# 未设置则 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_TOKEN=${WXBOT_TOKEN:?WXBOT_TOKEN not set - run scripts/init.sh}
# 语音识别(可选):core 拼 /transcribe 的基地址,固定指向栈内 mcp_asr。
- ASR_URL=http://mcp_asr:3000
# 对外地址:public_link 的默认值(scripts/init.sh 探测公网 IP 后写进 .env)。
# 设置页里填过 public_link.base_url 时以设置页为准。
- PUBLIC_BASE_URL=${PUBLIC_BASE_URL:-}
networks:
- agent-mcp-net
@@ -79,8 +83,8 @@ services:
- ./skills:/workspace/skills:ro # 技能目录:所有任务/会话共享同一份技能
environment:
- PORT=9000
# 与 agent-core 侧同一值,从 .env 读取(见 .env.example):
- EXECUTOR_TOKEN=${EXECUTOR_TOKEN:?EXECUTOR_TOKEN not set - see .env.example}
# 与 agent-core 侧同一值,从根 .env 读取(scripts/init.sh 生成):
- EXECUTOR_TOKEN=${EXECUTOR_TOKEN:?EXECUTOR_TOKEN not set - run scripts/init.sh}
# 日志等级:debug|info|warn|error|none(默认 info);
# debug 会把与 core 的完整交互打印出来(请求、/exec 请求体、每条 SSE 帧、JSON 响应):
- EXECUTOR_LOG_LEVEL=info
@@ -168,9 +172,6 @@ services:
timeout: 5s
retries: 5
start_period: 5s
# 调试用(默认关):
# ports:
# - "${WEB_SEARCH_PORT:-8081}:3000"
networks:
- agent-mcp-net
@@ -184,9 +185,6 @@ services:
timeout: 5s
retries: 5
start_period: 5s
# 调试用(默认关):
# ports:
# - "${IMAGE_TASK_PORT:-8082}:3000"
networks:
- agent-mcp-net
@@ -200,14 +198,34 @@ services:
timeout: 5s
retries: 5
start_period: 5s
# 调试用(默认关;这里映的是 MCP 端口,会暴露 /mcp,仅本机短时调试用):
# ports:
# - "${VIDEO_TASK_PORT:-8083}:3000"
networks:
- agent-mcp-net
# 语音识别:录音在客户端(套壳 App 原生桥 / 浏览器 MediaRecorder),转写在这里。
# 同进程两个入口(见 mcp/asr/src/server.js 头注释):
# POST /transcribe ← agent-core 的 /api/asr 转发(输入框,低延迟、不经过模型)
# POST /mcp ← 模型的 MCP 工具 transcribe_audio({url})(转写任务目录里的音频)
# 本容器不存任何平台密钥:上游走 OpenAI 兼容的 /audio/transcriptions,key / base_url / model
# 全部由调用方随请求 header 带入(core 从 config.yml 的 mcp_servers 里 asr.headers 取)。
# 换 ASR 平台 → 改 config.yml 后重启 core,本服务不用动、也不用重建镜像。
mcp_asr:
build: ./mcp/asr
container_name: mcp_asr
restart: unless-stopped
healthcheck:
test: ["CMD", "node", "-e", "fetch('http://127.0.0.1:3000/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"]
interval: 10s
timeout: 5s
retries: 5
start_period: 5s
environment:
- ASR_LOG_LEVEL=${ASR_LOG_LEVEL:-info}
- TZ=Asia/Shanghai
networks:
- agent-mcp-net
networks:
# 全部服务共用一个网络;由本仓库创建(固定名字,避免被加上 compose 项目名前缀)。
# 全部服务共用一个网络;由本仓库创建
# - core 与 executor 靠它按容器名访问 MCP 服务(如 http://mcp_web_search:3000/)
# - 外部服务取参考图走的是 core 对外的 GET /p/<id>(见 public_link):AI 调内置工具
# mint_public_link 在 core 进程内现签短链,不需要 executor 反查 core 的额外端口
+7
View File
@@ -66,6 +66,13 @@ system prompt 不重复 schema 已表达的内容。
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 信封。
+388
View File
@@ -0,0 +1,388 @@
# 语音输入:客户端录音契约
链路是「按住说话 → 端上持续送 PCM → 页面按停顿切段并逐段转写 → 松手后一次性写入输入框并**自动发送**」。
`public/js/voice.js` 按能力自己选录音方式:
| 页面环境 | 录音方式 | 实时断句 | 说明 |
|---|---|---|---|
| Android 套壳 App(WebView) | **原生 `AudioRecord` + JS 桥流式推 PCM** | ✅ | WebView 没有 Web Speech API;`http://` 页面也能用 |
| 浏览器 / PWA(HTTPS) | **`AudioContext` + `ScriptProcessor` 采 PCM** | ✅ | 降采样到 16k 后与套壳走**完全同一套** VAD/切段/上传 |
| 纯浏览器(`http://<IP>`) | 不可用 | — | 非安全上下文,浏览器拒绝开麦 |
**为什么必须要流式**:录音只在松手后才上传的话,识别要等整段录完 + 整段识别,长语音尤其慢。
流式之后,说话过程中的每个停顿都会立刻切段上传,**松手时通常只剩最后一段要等**。
两条录音路径只在「PCM 从哪来」上不同,进到 `pushChunk(pcm, rate)` 之后一模一样:
电平、静音门限、断句、逐段上传、最后合并发送,代码只有一份。
---
## 一、交互与页面行为(壳只需要知道这些)
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. 注入时机
必须在 **`loadUrl()` 之前**注册,不要在 `onPageFinished` 里用 `evaluateJavascript` 注入:
```java
webView.setWebViewClient(/* ... */);
webView.addJavascriptInterface(new VoiceBridge(activity, webView), "AgentNative");
webView.loadUrl(startUrl);
```
`addJavascriptInterface` 的绑定对所有后续导航生效;在 `onPageFinished` 里再注入,首屏那次
加载会拿不到 `window.AgentNative`(页面脚本已经跑完了)。
### 2. 方法(壳实现)
```js
window.AgentNative = {
startVoice(), // 开始录音(可能先弹权限);失败通过 onNativeVoiceError 回报
stopVoice(), // 结束录音;**没有返回值**,页面自己等已发出的分段的识别结果
cancelVoice() // 放弃本次录音(无回调;页面自己已经把状态复位了)
};
```
### 3. 回调(页面定义,壳调用)
```js
window.onNativeVoiceChunk(base64Pcm, sampleRate) // 必需:流式 PCM 分片
window.onNativeVoiceState('recording') // 建议:真正开始录时调一次
window.onNativeVoiceError(code, message) // 出错/被打断时调
```
#### `onNativeVoiceChunk(base64Pcm, sampleRate)`
- 内容:**裸 PCM**,`16bit 小端 / 单声道 / 16kHz`(小端是 `AudioRecord` 的原始字节序,直接转 Base64 即可)。
- 节奏:约 **100ms 一片**(1600 采样 = 3200 字节,Base64 后约 4.3KB)。50~200ms 都可接受。
- 壳**不做任何数学**:不判静音、不切段、不算音量。dB 归一化、静音门限、停顿判定、切段
全部在页面侧(`voice.js`),规则只存在一份。
- 声波也是页面用这片 PCM 的峰值算的——**不再需要** `onNativeVoiceAmp` / `getMaxAmplitude`。
- 页面已经复位(用户松手/取消)后再来的分片会被忽略,壳不用刻意等待。
#### `onNativeVoiceState('recording')`
**按住时长判定依赖它**:页面用这个回调重置「180 秒上限」与「太短丢弃」的起点,
避免首次授权弹窗的时间被算进录音。不实现也不会崩,但首次授权那一次可能被当成「太短」丢掉。
#### `onNativeVoiceError(code, message)`
| code | 触发时机 | 页面表现 |
|---|---|---|
| `no_permission` | 用户拒绝 / 取消授权弹窗 | toast「录音失败:…」 |
| `start_failed` | `AudioRecord` 初始化/启动失败(含 16k 不支持) | toast |
| `read_failed` | 采集线程读失败 | toast |
| `forbidden` | 非白名单 URL / 应用不在前台 | toast |
| `cancelled` | 生命周期打断(切后台 / 换页) | **静默复位,不弹提示** |
| 其他未知 code | — | toast 里显示 `message`,没有就显示 code |
**取消语义**:页面在 `stopVoice()` 之后只等自己发出的分段请求(不再等壳回音频),
所以壳在生命周期里中断录音时**仍建议**回调 `onNativeVoiceError('cancelled','')`,
让页面立刻收遮罩,不必干等。`cancelVoice()` 是页面主动发起的,壳不需要回报。
### 4. 体积与时序
- 每秒 32KB 原始 PCM(16k × 2 字节),Base64 后约 43KB/s;一片 100ms 约 4.3KB。
`evaluateJavascript` 走 Binder,单次约 1MB 上限,4.3KB 远低于上限。
- 一次 60 秒的听写 = 约 600 次桥调用、2.6MB 字符串。Android WebView 完全吃得住,
但**不要**把分片缩到 20ms 以下(调用次数会翻 5 倍,收益为零)。
- 页面侧开销:每片扫一遍峰值(1600 个 short),可忽略。
### 5. 壳侧状态机
`IDLE → (WAITING_PERMISSION) → RECORDING → IDLE`
`startVoice` 只在 `IDLE` 生效,`stopVoice` / `cancelVoice` 在非 `RECORDING` 时静默忽略。
---
## 三、Java 参考骨架(纯 Java / minSdk 21)
只演示契约要求的部分;`UrlPolicy`、埋点、通知等按各自工程接。
```java
// AndroidManifest.xml
// <uses-permission android:name="android.permission.RECORD_AUDIO" />
public final class VoiceBridge {
private static final int REQ_MIC = 1001;
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 }
private final Activity activity;
private final WebView webView;
private final Handler main = new Handler(Looper.getMainLooper());
private final Runnable autoStop = this::stopOnMain;
private State state = State.IDLE;
private AudioRecord record;
private Thread worker;
private volatile boolean running;
public VoiceBridge(Activity activity, WebView webView) {
this.activity = activity;
this.webView = webView;
}
// ---- JS 入口:JavaBridge 线程 → 主线程 ----
@JavascriptInterface public void startVoice() { main.post(this::startOnMain); }
@JavascriptInterface public void stopVoice() { main.post(this::stopOnMain); }
@JavascriptInterface public void cancelVoice() { main.post(() -> cancelOnMain(true)); }
// ---- 生命周期:由 Activity / WebViewClient 调用 ----
// 只在真正录音时取消。授权弹窗期间某些 ROM 会走 onPause,
// 那里一并取消的话,首次授权的两段式流程就断了。
public void onPause() {
main.post(() -> { if (state == State.RECORDING) cancelOnMain(true); });
}
public void onDestroy() { main.post(() -> cancelOnMain(false)); }
public void onPageChanged() { main.post(() -> cancelOnMain(true)); }
public void onRequestPermissionsResult(int requestCode, int[] grantResults) {
if (requestCode != REQ_MIC) return;
main.post(() -> {
if (state != State.WAITING_PERMISSION) return;
state = State.IDLE;
boolean ok = grantResults != null && grantResults.length > 0
&& grantResults[0] == PackageManager.PERMISSION_GRANTED;
if (!ok) { fail("no_permission", "需要麦克风权限"); return; }
beginRecording(); // 授权后直接开录,不让用户再点一次
});
}
private void startOnMain() {
if (state != State.IDLE) return;
// 第三方 CDN 脚本同样能调这个桥:只允许自家页面 + 前台时录音
if (!UrlPolicy.isAllowed(webView.getUrl()) || !activity.hasWindowFocus()) {
fail("forbidden", "当前页面不允许录音");
return;
}
if (ContextCompat.checkSelfPermission(activity, Manifest.permission.RECORD_AUDIO)
!= PackageManager.PERMISSION_GRANTED) {
state = State.WAITING_PERMISSION;
ActivityCompat.requestPermissions(
activity, new String[]{Manifest.permission.RECORD_AUDIO}, REQ_MIC);
return;
}
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
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,
MediaRecorder.AudioSource.MIC};
for (int source : sources) {
try {
AudioRecord t = new AudioRecord(source, RATE, AudioFormat.CHANNEL_IN_MONO,
AudioFormat.ENCODING_PCM_16BIT, Math.max(minBuf * 2, 8192));
if (t.getState() == AudioRecord.STATE_INITIALIZED) return t;
t.release();
} catch (Exception ignored) { /* 换下一个 source */ }
}
return null;
}
/** 采集线程:阻塞 read → 小端字节 → Base64 → 推给页面。不判静音、不切段。 */
private void captureLoop(AudioRecord r, int samplesPerChunk) {
short[] pcm = new short[samplesPerChunk];
byte[] bytes = new byte[samplesPerChunk * 2];
try {
r.startRecording();
while (running) {
int n = r.read(pcm, 0, pcm.length);
if (n <= 0) continue;
for (int i = 0; i < n; i++) {
bytes[i * 2] = (byte) (pcm[i] & 0xff);
bytes[i * 2 + 1] = (byte) ((pcm[i] >> 8) & 0xff);
}
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) { }
}
}
private void stopOnMain() {
if (state != State.RECORDING) return;
main.removeCallbacks(autoStop);
stopCapture();
state = State.IDLE;
// 注意:这里不再回传音频,识别分段已经在录音过程中发完了
}
/** notify=true:页面在等收尾,回 cancelled 让它立刻收遮罩;onDestroy 时页面已走,不必回。 */
private void cancelOnMain(boolean notify) {
main.removeCallbacks(autoStop);
boolean wasActive = state != State.IDLE;
stopCapture();
state = State.IDLE;
if (notify && wasActive) js("window.onNativeVoiceError('cancelled','')");
}
private void stopCapture() {
running = false;
AudioRecord r = record;
record = 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) {
js("window.onNativeVoiceError(" + JSONObject.quote(code) + ","
+ JSONObject.quote(message) + ")");
}
private void js(String script) {
webView.post(() -> webView.evaluateJavascript(script, null));
}
}
```
接线:
```java
// setupWebView() 里,loadUrl 之前
webView.addJavascriptInterface(new VoiceBridge(this, webView), "AgentNative");
@Override public void onRequestPermissionsResult(int code, String[] p, int[] r) {
super.onRequestPermissionsResult(code, p, r);
bridge.onRequestPermissionsResult(code, r);
}
@Override protected void onPause() { bridge.onPause(); super.onPause(); }
@Override protected void onDestroy() { bridge.onDestroy(); super.onDestroy(); }
// 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" />` |
| `proguard-rules.pro` | 保留桥:`-keepclassmembers class * { @android.webkit.JavascriptInterface <methods>; }`,并删掉「本项目未使用 addJavascriptInterface」的注释 |
| README 安全表 | 「不使用 JS 桥」→「仅暴露语音桥:三个无参方法,无文件/存储读取能力」 |
| README 权限行 | 「只有 INTERNET」→「INTERNET + RECORD_AUDIO」 |
| 桥的防护 | `UrlPolicy.isAllowed(webView.getUrl())` + `activity.hasWindowFocus()` + 单实例状态机 |
| 页面导航 | `onPageStarted` 且 URL 变化时取消;分片打到新页面会污染新一轮的缓冲 |
| 录音上限 | 壳侧兜底 180s(页面也会在 180s 时主动 `stopVoice()`),不要做成 60s |
> 触摸时间戳门槛(最近 N 秒内有触摸才允许录音)能进一步防静默录音,但会让无障碍操作不可用,
> 不建议默认开。
---
## 五、iOS(以后若有 WKWebView 壳)
契约相同,只是数据源换成 `AVAudioEngine` 的 tap(`installTapOnBus` 直接把
`AVAudioPCMBuffer` 转成 16bit 小端 PCM,每 ~100ms 一次):
```swift
// 注入:WKUserScript(source: "window.AgentNative = {...}", injectionTime: .atDocumentStart, ...)
// 推流:webView.evaluateJavaScript("window.onNativeVoiceChunk('\(b64)',16000)")
// 结束:stopVoice() 停 tap 即可,不需要回传文件
```
`Info.plist` 需要 `NSMicrophoneUsageDescription`。
---
## 六、服务端接口
```http
POST /api/asr/transcribe
Content-Type: audio/wav # 两条路都是 wav:页面自己加的 44 字节头(16k/单声道/16bit)
Cookie: <登录态> # 与页面同一份 HttpOnly cookie
<音频二进制>
```
```json
{ "text": "打开今天的日报", "ms": 842, "model": "whisper-1" }
```
- 上限 20MB,超时 120s;识别失败返回 `{"error": "..."}`(前端直接 toast 出来)。
- 一次「按住说话」会变成 **多次** 请求(每个停顿一次,套壳与浏览器都是)。页面**并行**发送,
结果按提交时的下标落位,拼接仍按说话顺序(并行返回是乱序的)。
并发上限由 `voice.js` 的 `ASR_MAX_CONCURRENCY` 控制(默认 3),超出的排到后面等前面落定。
- 单段失败不影响其他段(页面侧吞掉单段错误,继续等下一段);全部失败才提示。
- 服务端只做**超长兜底**:一次请求超过 25s 才切,且切点尽量落在停顿处(端上已经按停顿切好了,
这里多数请求根本不会触发切分)。参数见 `mcp/asr/README.md`。
- `GET /api/asr/status` → `{"enabled": true}`;未接线时 `{"enabled": false, "reason": "..."}`。
## 七、为什么不用浏览器的 Web Speech API
- Android WebView 没有实现 `SpeechRecognition`;iOS WKWebView 同样不可用(只有 Safari 有)。
- 桌面 Chrome 的识别走 Google 服务,国内基本报 `network`。
- 三端行为不一致、错误码各异,最后还是要留一条服务端通路——不如只留一条。
+65 -8
View File
@@ -36,6 +36,11 @@ const IDLE_MS = Number(process.env.OFFICE_IDLE_MS || 6 * 3600 * 1000);
const RESPOND_TIMEOUT_MS = 15000; // 数据请求(资源/API/SSE)等待 watch 首响应包的时限;拒连/超时走自愈重试
const NAV_TIMEOUT_MS = 5000; // 导航请求等就绪页面首响应:更短——失败立刻转中转页,不白屏干等
const COOLDOWN_MS = 8000; // 启动失败拉黑该文件一段时间:中转页自动刷新不成 spawn 风暴(二进制缺失/坏文件早退)
// 探针(HEAD)等「首帧可用」的上限:watch 冷启动 = 起进程 + 首次渲染,实测 2~6s(大文档更久)。
// 等不到就照回 200,把后续交给导航侧的中转页 + 自愈,探针不无限挂着。
const HEAD_WAIT_MS = 15000;
// 导航请求连续超时多少次才判死重启:单次超时只是「还没渲染完」(见 route 里的注释)。
const NAV_TIMEOUT_RETRIES = 3;
const BIN = process.env.OFFICECLI_BIN || '/workspace/skills/office/bin/officecli';
const TOKEN = String(process.env.EXECUTOR_TOKEN || '');
const EXTS = new Set(['.docx', '.xlsx', '.pptx']);
@@ -164,10 +169,13 @@ async function spawnWatch(abs) {
const page = pageOf(abs);
let slot = -1;
for (let i = 0; i < SLOTS; i++) if (!slots.has(i)) { slot = i; break; }
if (slot < 0) { // 槽满:优先踢「无活动连接且最久未用」;全开着页面才抢最冷的
if (slot < 0) { // 槽满:优先踢「就绪且无活动连接」里最久未用的;正在启动的槽最后才动
// (踢掉一个还没就绪的槽 = 白白浪费数秒冷启动,且会让等它的那一路请求失败并进冷却)
const ent = [...slots.entries()];
const idleReady = ent.filter(([, s]) => !s.conns && s.ready);
const idle = ent.filter(([, s]) => !s.conns);
slot = (idle.length ? idle : ent).sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0][0];
slot = (idleReady.length ? idleReady : (idle.length ? idle : ent))
.sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0][0];
stop(slot); // 端口按代轮转,新 watch 不会落在被踢者的旧口上,无需等其回收
}
const wp = await allocPort();
@@ -293,6 +301,18 @@ function matchPage(rel) {
return best;
}
// 探针预热:把槽位等到「就绪」(= 首帧渲染完成,portUp 探的就是页面本身),复用时直接返回。
// 与并发请求共用同一次 startWatch(starting 去重);任何失败/超时都静默——就绪与否不影响 200。
async function warmSlot(rr) {
let timer;
try {
await Promise.race([
waitReady(rr),
new Promise((r) => { timer = setTimeout(r, HEAD_WAIT_MS); }),
]);
} catch (_) {} finally { clearTimeout(timer); }
}
// 未命中兜底:请求路径本身就是存在的会话文档 → 回收/挤掉后就地复活;不行 = 维持 404。
async function revive(rel) {
const rr = (rel || '').replace(/\/+$/, '');
@@ -354,10 +374,12 @@ function tryForward(entry, req, res, innerPath, respondTimeoutMs) {
res.once('close', release);
res.once('finish', release);
let started = false;
let upRes = null;
const upstream = http.request(
{ host: '127.0.0.1', port: entry.port, path: encodeURI(inner) + search, method: req.method, headers: fwd },
(up) => {
started = true;
upRes = up;
clearTimeout(watchdog);
const h = Object.assign({}, up.headers);
const isSSE = String(h['content-type'] || '').includes('text/event-stream');
@@ -385,8 +407,14 @@ function tryForward(entry, req, res, innerPath, respondTimeoutMs) {
upstream.on('error', () => {
clearTimeout(watchdog);
release();
if (!started && !res.headersSent) reject(new Error('watch 不可达'));
else res.destroy();
if (!started && !res.headersSent) { reject(new Error('watch 不可达')); return; }
// 已开始回写后上游报错:不立刻销毁客户端响应。watch 会在响应其实已完整时断链
//(对 HEAD 必现,见 route 里的注释),Node 客户端的报错早于 'end' 一拍到达,直接
// destroy 会把马上要 flush 的响应打断。留一拍再判,真断裂照样收掉,不把半截响应当成功。
setTimeout(() => {
if (res.writableEnded) return;
try { res.destroy(); } catch (_) {}
}, upRes && upRes.complete ? 0 : 120);
});
req.pipe(upstream);
});
@@ -517,7 +545,8 @@ function fail502(res) {
}
function notFound(res) {
res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' })
// no-store:前端拿 HEAD 当探针,404 一旦被浏览器缓存,文件补上后还会继续显示「暂无文档」
res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' })
.end('无匹配预览(文档不存在/不在会话目录下,或不是 .docx/.xlsx/.pptx)');
}
@@ -534,6 +563,24 @@ async function route(req, res) {
if (u === PREFIX + '/' || u.startsWith(PREFIX + '/')) {
const rel = u.slice(PREFIX.length) || '/';
const rr = rel.replace(/\/+$/, '');
// HEAD = 前端预览窗的「这份文档能不能预览」探针。文档在不在只在本地按文件系统回答,绝不上探 watch:
// 实测 watch(Kestrel) 对 HEAD 只发响应头(带 content-length)不发 body 就断链,Node 客户端抛
// HPE_CLOSED_CONNECTION;旧逻辑把它当上游故障 res.destroy(),同一文档十次 HEAD 里六七次变成
// 空响应/502。
// 但回 200 前要等槽位就绪(有上限):冷启动的首次渲染很贵,旧实现由 HEAD 自己把这段等掉,
// iframe 一挂上就是渲染好的页面;若秒回 200,这段开销就落到随后 5s 时限的导航请求上,
// 慢文档会被判超时,表现为冷启动转圈很久。等不到也照回 200(见 HEAD_WAIT_MS)。
if (req.method === 'HEAD') {
let abs = null;
try { abs = guard(path.join(WORKSPACE, rr)); } catch (_) {}
if (abs) {
await warmSlot(rr);
res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store', 'content-length': '0' }).end();
return;
}
// 只有办公文档路径由本网关判定存在性;页面资源等其它 HEAD 仍走原转发逻辑
if (EXTS.has(path.extname(rr).toLowerCase())) return notFound(res);
}
if (isNav(req)) {
// 导航请求 = 用户正盯着这一刻:绝不为启动/自愈阻塞首字节。
// 槽位不在或未就绪 → 中转页 + 后台热槽(startWatch 去重,在途就等它);就绪槽位转发失败 → 同样中转页。
@@ -546,10 +593,20 @@ async function route(req, res) {
if (fileChanged(m.entry)) { dropChanged(m.entry); startWatch(abs).catch(() => {}); return loading(res); }
if (m.exact && !u.endsWith('/')) { res.writeHead(301, { location: (req.url || u) + '/' }).end(); return; } // 相对资源解析需要尾斜杠
const cut = PREFIX.length + m.entry.pageDec.length; // 剥掉「前缀+页面路径」才是 watch 的内层路径
try { await tryForward(m.entry, req, res, u.length > cut ? u.slice(cut) : '/', NAV_TIMEOUT_MS); return; }
try { await tryForward(m.entry, req, res, u.length > cut ? u.slice(cut) : '/', NAV_TIMEOUT_MS); m.entry.navTimeouts = 0; return; }
catch (e) {
retire(m.entry, String(e && e.message || e));
if (!res.headersSent) { startWatch(abs).catch(() => {}); return loading(res); }
const msg = String(e && e.message || e);
// 超时 ≠ 死:watch 可能只是首次渲染还没完(大文档 >5s)。一超时就摘掉会把在跑的渲染连坐杀掉,
// 中转页刷新后从头再来——用户看到的就是「冷启动一直转圈」。单次超时保留槽位,
// 连续 NAV_TIMEOUT_RETRIES 次(约 15s 无首字节)才判死重启,兼顶真卡死。
m.entry.navTimeouts = /超时/.test(msg) ? (m.entry.navTimeouts || 0) + 1 : NAV_TIMEOUT_RETRIES;
if (m.entry.navTimeouts < NAV_TIMEOUT_RETRIES) {
log(`slot 保留:导航超时第 ${m.entry.navTimeouts} 次(${msg})`);
} else {
retire(m.entry, msg);
startWatch(abs).catch(() => {});
}
if (!res.headersSent) return loading(res);
return;
}
}
+35 -15
View File
@@ -1,16 +1,16 @@
# MCP 服务集合
三个 MCP(Model Context Protocol)服务,各占一个目录,由仓库根 `docker-compose.yml` 统一编排:
四个 MCP(Model Context Protocol)服务,各占一个目录,由仓库根 `docker-compose.yml` 统一编排:
| 目录 | 容器名 | 作用 | 容器内端口 | MCP 端点 |
|---|---|---|---|---|
| `web_search/` | `mcp_web_search` | 免费网页搜索(Parallel / Exa,无需 key) | `3000` | `POST /` |
| `image_task/` | `mcp_image_task` | 图片生成 / 编辑(智谱原生或任意 OpenAI 兼容 `/images/generations`,单工具 op=create/get) | `3000` | `POST /mcp` |
| `web_search/` | `mcp_web_search` | 网页搜索(默认免费 Parallel / Exa,可换成自建 `/search` 上游) | `3000` | `POST /` |
| `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` |
| `asr/` | `mcp_asr` | 语音转文字(上游 OpenAI 兼容 `/audio/transcriptions`),**额外带一个给输入框用的 `POST /transcribe`** | `3000` | `POST /mcp` |
**这些服务一个宿主机端口都不占**——它们只挂在 `agent-mcp-net` 上,由 `agent-core` / `agent-executor`
按容器名访问。所以整台服务器对外只需要开 agent-core 那一个端口(`AGENT_PORT`,默认 8090)。
(要从宿主机 curl 调试时,把根 `docker-compose.yml` 里对应服务注释掉的 `ports` 两行打开。)
## 部署
@@ -27,30 +27,49 @@ docker compose up -d --build
mcp_servers:
- name: web_search
url: "http://mcp_web_search:3000/"
# 可选:换成自己的搜索接口(不配 = 内置免费后端 Parallel / Exa)
# headers:
# Authorization: Bearer <key>
# X-Web-Search-Base-Url: "https://<host>/v1"
- name: image_task
url: "http://mcp_image_task:3000/mcp"
- name: video_task
url: "http://mcp_video_task:3000/mcp"
# 可选:语音转写(低频,建议 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
```
服务没起来时,core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。工具发现只在启动时做一次,失败后会自动按 2s / 20s / 1min 重试 3 次;三次都失败则需重启 core。三个服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。
服务没起来时,core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。工具发现只在启动时做一次,失败后会自动按 2s / 20s / 1min 重试 3 次;三次都失败则需重启 core。四个服务都配了 `/health` 健康检查,`docker ps` 可直接看状态。
> 从旧的「agent + mcp 双仓库」部署升级:先在旧 mcp 仓库目录 `docker compose down`(只需一次,否则同名容器与网络会冲突),再 `up` 本栈。
`image_task` / `video_task` 的 token **不由服务端保存**——每个请求从 `Authorization` header 读取
(agent 侧配在 `config.yml` 的 `mcp_servers[].headers`)。`video_task` 用智谱 token;
`image_task` 用对应上游(智谱或 OpenAI 兼容网关)的 token,上游地址与模型分别由
`X-Image-Task-Base-Url` / `X-Image-Task-Model` 指定。所以这里不用配任何密钥。
`image_task` 走任意 OpenAI 兼容的 images 上游:文生图 `/images/generations`、图生图 `/images/edits`,
上游地址与模型分别由 `X-Image-Task-Base-Url` / `X-Image-Task-Model` 指定(两者都必填)。
所以这两个服务不用配任何密钥。
`web_search` 同理:默认走内置免费后端(Parallel → Exa,无需 key);想换成自己的搜索接口,
就在这段 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` 里即可(不写就用默认值;开了端口记得调试完注释回去):
| 变量 | 默认 | 说明 |
|---|---|---|
| `WEB_SEARCH_PORT` | `8081` | 只在临时打开 web_search 调试端口时用 |
| `IMAGE_TASK_PORT` | `8082` | 只在临时打开 image_task 调试端口时用 |
| `VIDEO_TASK_PORT` | `8083` | 只在临时打开 video_task 调试端口(MCP 口,仅本机短时调试)时用 |
本栈默认不给 MCP 服务映射宿主机端口(它们只在 `agent-mcp-net` 内网可达)。要从宿主机直连,
自行在 `docker-compose.yml` 给对应服务加 `ports` 即可。
## 图片是怎么到智谱手上的(只有 video_task 关心)
@@ -75,9 +94,10 @@ AI 把拿到的 URL 当 image_url 交给 video_task:3000/mcp
| 服务 | 公网暴露 | 说明 |
|---|---|---|
| `mcp_web_search` | 无 | 服务端无鉴权,**永远不要映射出去**(会被白嫖搜索额度);agent 走内网访问 |
| `mcp_web_search` | 无 | 服务端无鉴权,**永远不要映射出去**(会被白嫖搜索额度;配了自定义上游时还会把你的 key 白送出去);agent 走内网访问 |
| `mcp_image_task` | 无 | token 由调用方自带,暴露后可被拿去消耗你的上游图片额度 |
| `mcp_video_task` | 无 | 它需要的公开临时 URL 由 agent 侧集成的工具提供,自己不占端口 |
| `mcp_asr` | 无 | `/mcp` 与 `/transcribe` 都无鉴权,只能由 core 经内网调用;它不存密钥(上游参数随请求带入) |
## 单独调试
+2
View File
@@ -0,0 +1,2 @@
node_modules
*.md
+33
View File
@@ -0,0 +1,33 @@
FROM node:22-slim
# 国内构建慢:apt 默认源在国外,apt-get update 能卡十几分钟。默认换成腾讯云镜像。
# 境外构建或想换源:docker compose build --build-arg DEBIAN_MIRROR=deb.debian.org mcp_asr
# 腾讯云 CVM 上想更快可用内网镜像 mirrors.tencentyun.com(仅腾讯云内网可达)。
ARG DEBIAN_MIRROR=mirrors.cloud.tencent.com
# 换 apt 源:bookworm/trixie 可能是 /etc/apt/sources.list,也可能是 deb822 的
# /etc/apt/sources.list.d/*.sources,直接用 grep 扫一遍、只替换域名,两种格式都盖住
#(路径 /debian、/debian-security 保持不变)。与 executor/Dockerfile 同一套做法。
RUN set -eux; \
files="$(grep -rl 'deb.debian.org' /etc/apt/ 2>/dev/null || true)"; \
if [ -n "$files" ]; then sed -i "s|deb.debian.org|${DEBIAN_MIRROR}|g" $files; fi; \
grep -rn "${DEBIAN_MIRROR}" /etc/apt/ | head -5 || true
ENV DEBIAN_FRONTEND=noninteractive
# ffmpeg 只装在这里(core 镜像保持干净):WebView 录出来是 webm/opus,iOS 是 mp4/aac,
# 云端只认 wav/mp3——统一在容器内转成 16k 单声道 wav,前端与引擎两头都不用关心格式。
RUN apt-get update \
&& apt-get install -y --no-install-recommends ffmpeg ca-certificates \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
# 零依赖:不需要 npm install(也就没有 registry 慢/被墙的问题)
COPY package.json ./
COPY src ./src
ENV PORT=3000
EXPOSE 3000
CMD ["node", "src/server.js"]
+121
View File
@@ -0,0 +1,121 @@
# mcp/asr — 语音识别服务
一个容器,两个入口,共用同一套转写实现:
| 入口 | 谁在用 | 说明 |
|---|---|---|
| `POST /transcribe` | `agent-core` 的 `/api/asr/transcribe`(H5 输入框) | 普通 HTTP,音频二进制进、`{text}` 出。**不经过模型、不消耗 token、1~3s** |
| `POST /mcp` | 模型(MCP 工具 `transcribe_audio`) | 转写任务目录里已有的音频,参数是公网 URL(与 `video_task` 的 `image_url` 同构) |
| `GET /health` | compose healthcheck | `{ok, service}`(无状态服务,不反映上游配置) |
端口 `3000` **只在 `agent-mcp-net` 内网**,不映射宿主机——本服务自身没有鉴权,暴露即被白嫖。
对外唯一入口仍是 `agent-core`(`/api/asr` 走登录态鉴权)。
## 为什么不是「录音 → 上传附件 → 模型调工具」
那要额外一次完整模型往返(3~10s + token),识别结果落进聊天记录而不是输入框,用户还没法改错字。
输入法级别的功能必须绕开模型;`/mcp` 那个口只留给「转写一段已上传的录音」这种低频需求。
## 部署
```bash
# 1) 配上游:写进仓库根 config.yml 的 mcp_servers(与 image_task 同构),容器不存任何密钥
# - 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) 起服务
docker compose up -d --build mcp_asr
docker compose restart agent-core # core 要在启动时读到 config.yml 与 ASR_URL
curl -s http://127.0.0.1:8090/api/asr/status # {"enabled":true,...}
```
`agent-core` 的环境变量 `ASR_URL`(compose 里固定为 `http://mcp_asr:3000`)是部署接线;
真正的开关是 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` 都能用。**本服务不保存、也不预设任何平台**:
key / base_url / model 全部由调用方随每个请求用 header 带入(与 `image_task` 同构)。
| Header | 必填 | 说明 |
|---|---|---|
| `X-ASR-Base-Url` | 是 | 上游地址,如 `https://<host>/v1`(服务自己拼 `/audio/transcriptions`) |
| `X-ASR-Model` | 是 | 模型名,如 `glm-asr` / `whisper-1` |
| `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 的机器跑不动能用的
whisper(固定 30 秒窗口,`small` 单次要 15~30 秒),需要私有化就把这个容器放到另一台机器,
只改 core 的 `ASR_URL` 指向它。
## HTTP 接口
```bash
# 任意格式(webm / mp4 / mp3 / wav / ogg / aac / flac),服务端用 ffmpeg 归一化
curl -s -X POST http://mcp_asr:3000/transcribe \
-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
# → {"text":"打开今天的日报","ms":842,"model":"whisper-1"}
```
- 上限 20MB。**只有超过 `ASR_MAX_CHUNK_SEC`(默认 25s)才切**:套壳是流式的,一次请求本就是一�句话,
直接一次送出去(不跑静音检测);长音频(浏览器整段上传 / `/mcp`)才需要断开。
- 切点尽量落在停顿上:只在距上限最后 `ASR_CUT_LOOKBACK_SEC`(默认 6s)的窗口里找静音区间中点,
挑不到才硬切——硬切会把字劈成两半,而两段之间没有上下文,接缝处的字就丢了。
段数因此最少(≈ 时长/25),不存在“切太碎”的退化。单段不短于 `ASR_MIN_SEG_SEC`(默认 1s)。
- 单段失败不连坐:其余段照常返回(长录音里偶发静音段很常见);**全部**段失败才报错。
- 同时最多 `ASR_MAX_CONCURRENT`(默认 2)个转写请求,超了回 429。
## MCP 工具
```yaml
# config.yml
mcp_servers:
- name: asr
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
```
`transcribe_audio({ url })`:本地文件先用内置工具 `mint_public_link` 换成公网短链,
再把链接传进来(和 `video_task` 要 `image_url` 是同一套路)。
## 环境变量速查
| 变量 | 默认 | 说明 |
|---|---|---|
| `ASR_MAX_BYTES` | 20971520 | 单次上传上限 |
| `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_LOG_LEVEL` | `info` | debug / info / warn / error / none |
| `FFMPEG_BIN` | `ffmpeg` | 归一化 / 静音检测工具路径 |
上游参数(key / base_url / model)**不是环境变量**,见上面「上游」一节。
## 客户端怎么录音
浏览器侧只有 HTTPS 才允许开麦;**Android 套壳 App 用原生录音再把 base64 交给页面**,
http 页面也能用。桥的契约与 Kotlin 示例见 [docs/voice-input.md](../../docs/voice-input.md)。
+10
View File
@@ -0,0 +1,10 @@
{
"name": "mcp_asr",
"version": "1.0.0",
"description": "ASR service: POST /transcribe for the H5 composer, POST /mcp for the model (tool transcribe_audio). Zero dependencies.",
"type": "module",
"main": "src/server.js",
"scripts": {
"start": "node src/server.js"
}
}
+565
View File
@@ -0,0 +1,565 @@
#!/usr/bin/env node
// ASR(语音转文字)服务。一个进程两个入口,共用同一套转写实现:
//
// POST /transcribe 普通 HTTP —— 给 agent-core 的输入框用:录完音直接拿文字,
// 不经过模型、不花 token、延迟 1~3s。
// POST /mcp Streamable HTTP MCP —— 工具 transcribe_audio({url}),给模型转写
// 会话目录里的音频(本地文件先 mint_public_link 换公网短链,与 video_task 同构)。
//
// 为什么不直接用 MCP 工具做语音输入:MCP 是模型协议,走一次工具调用要多一轮模型往返
//(3~10s + token),识别结果还会落进聊天记录而不是输入框,用户没法改错字。输入法级别的
// 功能必须绕开模型。
//
// 为什么零依赖(不用 express / MCP SDK):core 的 MCP 客户端只发 initialize / tools/list /
// tools/call 三种请求,手写这几十行 JSON-RPC 就够;本机内存只有 2G,省掉 SDK 与 express
// 的常驻开销(本服务空载约 35MB)。
//
// 转写走上游的 OpenAI 兼容 /audio/transcriptions(任何平台都行)。上游三要素——key、base_url、
// model——一律由调用方随请求 header 带入,本容器不存任何平台密钥、也不认任何平台默认值。
// 音频一律先经 ffmpeg 归一化成 16kHz 单声道 wav:WebView 录出来是 webm/opus,iOS 是 mp4/aac,
// 上游只认 wav/mp3,归一化后两端都自由。
//
// 超长兜底:只有超过单次上限(默认 25s)才断开重发,切点尽量落在停顿上。
// 套壳是流式的(客户端已按停顿切好,一次请求就是一句话),所以这里多数请求不会被切;
// 真正用得上的是浏览器整段上传与 /mcp 转写已有长音频。
import http from 'node:http';
import { spawn } from 'node:child_process';
import { randomUUID } from 'node:crypto';
import fs from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
// ── 配置 ──────────────────────────────────────────────────────────────────
const PORT = Number(process.env.PORT || 3000);
// 上游参数逐请求带入(与 mcp/image_task 同构:密钥由调用方提供,服务端不保存):
// Authorization: Bearer <key> ← 免鉴权的自建服务可省
// X-ASR-Base-Url: https://.../v1
// 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 是给长音频留的余量。
const MAX_BYTES = Math.max(1024 * 1024, Number(process.env.ASR_MAX_BYTES || 20 * 1024 * 1024));
// ── 超长兜底切分 ──────────────────────────────────────────────────────
// 谁需要它:套壳是流式的(客户端已经按停顿切好,每次请求就是一句话),
// 所以这里绝大多数请求都 ≤ 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。
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 上并发再高只会互相拖慢。
const MAX_CONCURRENT = Math.max(1, Number(process.env.ASR_MAX_CONCURRENT || 2));
const FFMPEG = String(process.env.FFMPEG_BIN || 'ffmpeg').trim();
const LOG_LEVEL = String(process.env.ASR_LOG_LEVEL || 'info').toLowerCase();
const LEVELS = { debug: 10, info: 20, warn: 30, error: 40, none: 99 };
function log(level, msg) {
if ((LEVELS[level] || 20) < (LEVELS[LOG_LEVEL] == null ? 20 : LEVELS[LOG_LEVEL])) return;
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 ────────────────────────────────────
function run(cmd, args, timeoutMs) {
return new Promise((resolve, reject) => {
let child;
try {
child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
} catch (e) {
return reject(e);
}
let out = '';
let err = '';
let settled = false;
const timer = setTimeout(() => {
if (settled) return;
settled = true;
try { child.kill('SIGKILL'); } catch (_) { /* 已退出 */ }
reject(new Error(cmd + ' 超时(' + timeoutMs + 'ms)'));
}, timeoutMs);
timer.unref();
child.stdout.on('data', (d) => { out += d; });
child.stderr.on('data', (d) => { err += d; });
child.on('error', (e) => {
if (settled) return;
settled = true;
clearTimeout(timer);
reject(e); // ENOENT:二进制没装(如没装 ffmpeg)
});
child.on('close', (code) => {
if (settled) return;
settled = true;
clearTimeout(timer);
if (code === 0) resolve({ stdout: out, stderr: err });
else reject(new Error(cmd + ' 退出码 ' + code + ':' + ((err || out).slice(-400) || '无输出')));
});
});
}
// ── 音频:归一化成 16k 单声道 wav(再把超长音频切片) ───────────────────────
async function toWav(buf, ext) {
const id = randomUUID();
const inPath = path.join(os.tmpdir(), 'asr-in-' + id + (ext ? '.' + ext : ''));
const wavPath = path.join(os.tmpdir(), 'asr-out-' + id + '.wav');
try {
await fs.writeFile(inPath, buf);
await run(FFMPEG, [
'-hide_banner', '-loglevel', 'error', '-y',
'-i', inPath,
'-vn', '-ac', '1', '-ar', '16000', '-c:a', 'pcm_s16le', '-f', 'wav',
wavPath,
], 60000);
return wavPath;
} catch (e) {
await fs.rm(inPath, { force: true }).catch(() => {});
await fs.rm(wavPath, { force: true }).catch(() => {});
// ffmpeg 的 stderr 很有用(定位是封装不对还是文件截断),但只进日志——
// 回给前端的长英文堆栈对用户毫无意义,toast 里只会显示第一行。
log('warn', '音频解码失败:' + String(e && e.message || e));
const err = new Error('音频解码失败(格式不支持或文件损坏)');
err.status = 400;
throw err;
} finally {
await fs.rm(inPath, { force: true }).catch(() => {});
}
}
// ── 停顿检测与切点规划 ─────────────────────────────────────────────────
// 用 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 base = path.basename(wavPath, '.wav');
const parts = [];
for (let i = 0; i + 1 < cuts.length; i++) {
const p = path.join(dir, base + '-part-' + String(i).padStart(3, '0') + '.wav');
await run(FFMPEG, [
'-hide_banner', '-loglevel', 'error', '-y',
'-ss', String(cuts[i]), '-i', wavPath, '-t', String(cuts[i + 1] - cuts[i]),
'-c', 'copy', p,
], 60000);
parts.push(p);
}
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;
}
// ── 引擎 ──────────────────────────────────────────────────────────────────
function extractText(obj) {
if (!obj) return '';
if (typeof obj === 'string') return obj;
if (typeof obj.text === 'string') return obj.text;
if (obj.result && typeof obj.result.text === 'string') return obj.result.text;
return '';
}
async function runCloud(wavPath, up) {
assertUpstream(up);
const buf = await fs.readFile(wavPath);
const form = new FormData();
form.append('model', up.model);
form.append('file', new Blob([buf], { type: 'audio/wav' }), 'audio.wav');
let res;
try {
res = await fetch(up.base + '/audio/transcriptions', {
method: 'POST',
headers: up.auth ? { Authorization: up.auth } : {},
body: form,
signal: AbortSignal.timeout(60000),
});
} catch (e) {
const err = new Error('调用上游语音识别失败:' + String(e && e.message || e));
err.status = 502;
throw err;
}
const raw = await res.text();
if (!res.ok) {
// 智谱对“解码后没有可识别语音”的音频回 400/1210 no audio segment found。
// 这通常不是服务故障(录音是静音、或浏览器只录到空白),给一句人话,别把上游 JSON 丢给用户。
let upstreamMsg = raw.slice(0, 300);
let upstreamCode = '';
try {
const obj = JSON.parse(raw);
if (obj && obj.error) {
upstreamMsg = String(obj.error.message || upstreamMsg);
upstreamCode = String(obj.error.code || '');
}
} catch (_) { /* 非 JSON,保留原文 */ }
const noSpeech = /no audio segment/i.test(upstreamMsg) || upstreamCode === '1210';
const err = new Error(noSpeech
? '没有识别到语音内容(录到的是静音,或音频解码后为空)'
: '上游识别失败 HTTP ' + res.status + ':' + upstreamMsg);
err.status = noSpeech ? 400 : 502;
err.upstream = upstreamMsg;
throw err;
}
let obj = null;
try { obj = JSON.parse(raw); } catch (_) { return raw.trim(); }
const text = extractText(obj);
if (!text) {
// 上游对「这段里没人声」会回 200 + 空 text(如 glm-asr 的 {duration,text:"",usage})。
// 这是**正常结果**,不是故障:给 400 让上层只记一行 warn(5xx 才打堆栈),
// 前端按「没识别到」处理、页面侧单段失败也会被跳过。
const err = new Error('没有识别到语音内容(这段音频里没有可识别的人声)');
err.status = 400;
err.upstream = raw.slice(0, 300);
throw err;
}
return text;
}
// 归一化后 wav 的实测音量(仅 debug 级别调用):用于区分“文件坏了”和“录到的是静音”。
// volumedetect 跟解码共用一次遍历,开销很小,但只在排查时跑。
async function wavLevel(wavPath) {
const r = await run(FFMPEG, [
'-hide_banner', '-nostats', '-i', wavPath, '-af', 'volumedetect', '-f', 'null', '-',
], 30000);
const mean = /mean_volume:\s*(-?[\d.]+) dB/.exec(r.stderr);
const max = /max_volume:\s*(-?[\d.]+) dB/.exec(r.stderr);
return (mean ? mean[1] : '?') + ' / ' + (max ? max[1] : '?') + ' dB';
}
// 转写一段音频缓冲:归一化 →(超长则切片)→ 逐段识别 → 拼接。
async function transcribeBuffer(buf, opts) {
const up = (opts && opts.up) || {};
assertUpstream(up);
const wavPath = await toWav(buf, opts && opts.ext);
const parts = [];
try {
const st = await fs.stat(wavPath);
const seconds = st.size / 32000; // 16k/单声道/16bit
// 每次请求都打一行:原始字节 → 归一化时长。排查“上游说没声音”时第一眼看这个。
log('info', '归一化:' + buf.length + 'B (' + ((opts && opts.ext) || '?') + ') → '
+ seconds.toFixed(1) + 's wav');
// 只有超长才切:套壳是流式的,每次请求本来就是一�句话(1~5s),
// 这里直接一次送出去,不用白白跑一趟 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) {
try {
return (await runCloud(wavPath, up)).trim();
} catch (e) {
// 只在上游判定“没有语音”时量一遍音量(正常路径零开销):
// 静音是 -91dB,正常语音 -20dB 上下,一眼就能分清是设备没收到声还是文件坏了。
if (e && e.status === 400) {
log('warn', '音量(mean/max): ' + await wavLevel(wavPath).catch(() => '?'));
}
throw e;
}
}
const out = [];
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 {
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) {
if (!firstErr) firstErr = e;
log('warn', ' part ' + (i + 1) + '/' + parts.length + ' ' + range
+ ' 识别失败(跳过):' + String(e && e.message || e).slice(0, 200));
}
}
// 全部失败才报错:否则前端只会看到 200 + 空文本,分不清是「没说话」还是「上游挂了」。
// 部分失败保持静默降级(长录音里某一段坏了不该连坐)。
if (!out.length && firstErr) throw firstErr;
return joinText(out);
} finally {
await fs.rm(wavPath, { force: true }).catch(() => {});
for (const p of parts) await fs.rm(p, { force: true }).catch(() => {});
}
}
// ── HTTP 小工具 ───────────────────────────────────────────────────────────
function json(res, code, obj) {
if (res.headersSent) return;
const body = JSON.stringify(obj);
res.writeHead(code, {
'Content-Type': 'application/json; charset=utf-8',
'Content-Length': Buffer.byteLength(body),
'Cache-Control': 'no-store',
});
res.end(body);
}
function readBody(req, limit) {
return new Promise((resolve, reject) => {
const chunks = [];
let n = 0;
let failed = false;
req.on('data', (c) => {
if (failed) return;
n += c.length;
if (n > limit) {
failed = true;
const e = new Error('音频过大(上限 ' + Math.round(limit / 1048576) + 'MB)');
e.status = 413;
reject(e);
return;
}
chunks.push(c);
});
req.on('end', () => { if (!failed) resolve(Buffer.concat(chunks)); });
req.on('error', (e) => { if (!failed) reject(e); });
});
}
const EXT_BY_MIME = {
'audio/webm': 'webm', 'audio/ogg': 'ogg', 'audio/mp4': 'm4a', 'audio/x-m4a': 'm4a',
'audio/mpeg': 'mp3', 'audio/mp3': 'mp3', 'audio/wav': 'wav', 'audio/x-wav': 'wav',
'audio/aac': 'aac', 'audio/flac': 'flac', 'audio/amr': 'amr',
};
function extOf(contentType) {
const k = String(contentType || '').split(';')[0].trim().toLowerCase();
return EXT_BY_MIME[k] || '';
}
// ── 入口 1:POST /transcribe(普通 HTTP,给输入框) ────────────────────────
let active = 0;
async function handleTranscribe(req, res, url) {
if (active >= MAX_CONCURRENT) {
return json(res, 429, { error: '语音识别繁忙,请稍后再试' });
}
// 先判配置再读 body:没配上游时不必白读 20MB
const up = upstreamOf(req);
assertUpstream(up);
const buf = await readBody(req, MAX_BYTES);
if (!buf.length) return json(res, 400, { error: '未收到音频数据' });
active++;
const t0 = Date.now();
try {
const text = await transcribeBuffer(buf, { ext: extOf(req.headers['content-type']), up });
log('info', 'transcribed ' + buf.length + 'B → ' + text.length + ' 字,' + (Date.now() - t0) + 'ms');
json(res, 200, { text, ms: Date.now() - t0, model: up.model });
} finally {
active--;
}
}
// ── 入口 2:POST /mcp(Streamable HTTP,给模型) ──────────────────────────
const TOOL = {
name: 'transcribe_audio',
description:
'Transcribe an audio file to text. Provide a publicly reachable http(s) URL '
+ '(mp3 / wav / m4a / webm / ogg / aac / flac, <= 20MB). '
+ 'For a file inside the current task directory, first call the built-in mint_public_link tool '
+ 'to get a temporary public URL, then pass that URL here.',
inputSchema: {
type: 'object',
properties: {
url: { type: 'string', description: 'Publicly reachable http(s) URL of the audio file.' },
},
required: ['url'],
},
};
async function fetchAudio(urlStr) {
let u;
try { u = new URL(urlStr); } catch (_) { throw new Error('url 不是合法链接'); }
if (u.protocol !== 'http:' && u.protocol !== 'https:') throw new Error('只支持 http(s) 链接');
const res = await fetch(u, { redirect: 'follow', signal: AbortSignal.timeout(30000) });
if (!res.ok) throw new Error('下载音频失败 HTTP ' + res.status);
const buf = Buffer.from(await res.arrayBuffer());
if (!buf.length) throw new Error('下载到的音频为空');
if (buf.length > MAX_BYTES) throw new Error('音频过大(上限 ' + Math.round(MAX_BYTES / 1048576) + 'MB)');
return { buf, ext: extOf(res.headers.get('content-type')) };
}
async function handleMcp(req, res) {
const raw = await readBody(req, 1024 * 1024);
let msg;
try { msg = JSON.parse(raw.toString('utf8')); } catch (_) {
return json(res, 400, { jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
}
const id = msg && msg.id !== undefined ? msg.id : null;
const method = msg && msg.method;
const params = (msg && msg.params) || {};
const ok = (result) => json(res, 200, { jsonrpc: '2.0', id, result });
const fail = (code, message) => json(res, 200, { jsonrpc: '2.0', id, error: { code, message } });
if (method === 'initialize') {
return ok({
protocolVersion: '2024-11-05',
capabilities: { tools: {} },
serverInfo: { name: 'asr', version: '1.0.0' },
});
}
// 无状态实现:不返回 Mcp-Session-Id,core 也就不会带;通知直接回空结果(core 不校验)。
if (method === 'notifications/initialized' || method === 'notifications/cancelled') return ok({});
if (method === 'ping') return ok({});
if (method === 'tools/list') return ok({ tools: [TOOL] });
if (method === 'tools/call') {
if (params.name !== TOOL.name) return fail(-32602, 'Unknown tool: ' + params.name);
const args = params.arguments || {};
const urlStr = String(args.url || '').trim();
if (!urlStr) return ok({ isError: true, content: [{ type: 'text', text: '缺少 url 参数' }] });
try {
const { buf, ext } = await fetchAudio(urlStr);
const text = await transcribeBuffer(buf, { ext, up: upstreamOf(req) });
return ok({ content: [{ type: 'text', text }] });
} catch (e) {
return ok({ isError: true, content: [{ type: 'text', text: '转写失败:' + String(e && e.message || e) }] });
}
}
return fail(-32601, 'Method not found: ' + method);
}
// ── 服务 ──────────────────────────────────────────────────────────────────
const server = http.createServer((req, res) => {
let url;
try { url = new URL(req.url, 'http://localhost'); } catch (_) {
return json(res, 400, { error: 'bad url' });
}
const done = (p) => {
Promise.resolve(p).catch((e) => {
const code = (e && e.status) || 500;
// 4xx 是可预期的输入问题(坏音频、没配 key),只记一行;5xx 才带堆栈
log(code >= 500 ? 'error' : 'warn', String(e && e.message || e) + (code >= 500 && e && e.stack ? '\n' + e.stack : ''));
if (!res.headersSent) json(res, code, { error: String(e && e.message || e) });
else try { res.end(); } catch (_) { /* 已断 */ }
});
};
if (req.method === 'GET' && url.pathname === '/health') {
// 无状态服务:健康 = 进程活着。上游参数逐请求带入,没有全局「configured」可言。
return json(res, 200, { ok: true, service: 'asr' });
}
if (req.method === 'POST' && url.pathname === '/transcribe') return done(handleTranscribe(req, res, url));
if (url.pathname === '/mcp') {
if (req.method !== 'POST') return json(res, 405, { error: 'only POST /mcp' });
return done(handleMcp(req, res));
}
return json(res, 404, { error: 'not found' });
});
let shuttingDown = false;
function shutdown(sig) {
if (shuttingDown) return;
shuttingDown = true;
log('info', '收到 ' + sig + ',退出');
server.close(() => process.exit(0));
setTimeout(() => process.exit(0), 3000).unref();
}
process.on('SIGTERM', () => shutdown('SIGTERM'));
process.on('SIGINT', () => shutdown('SIGINT'));
server.listen(PORT, '0.0.0.0', () => {
log('info', 'listening on ' + PORT + '(上游 key/base_url/model 由调用方随请求 header 带入)');
});
+53 -90
View File
@@ -3,12 +3,9 @@
一个基于 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) 的图片生成 / 编辑服务。
对外只有一个工具 `image_task`,用 `op` 区分动作(`create` / `get`),异步任务契约与 `video_task` 一致。
上游支持两种协议,由 `X-Image-Task-Base-Url` 选择:
| 通道 | 上游 | 请求体 |
|---|---|---|
| 智谱原生 | `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? }` |
上游必须是 OpenAI 兼容的 images 端点:文生图走 `/images/generations`,图生图走 `/images/edits`
(智谱、各类网关走同一套协议)。`X-Image-Task-Base-Url` / `X-Image-Task-Model` / `Authorization`
三个 header 都必填,服务不存密钥、也不预设厂商或默认模型。
- 协议:MCP **Streamable HTTP**(单端点 `/mcp`,支持 SSE 流)
- 端口:容器内 `3000`(**不映射宿主机**,只在 `agent-mcp-net` 内被 agent 访问)
@@ -25,8 +22,8 @@ cd /root/workspace/tools/agent
docker compose up -d --build mcp_image_task
```
服务容器名 `mcp_image_task`。要从宿主机 curl 调试,把根 `docker-compose.yml` 里
`mcp_image_task` 注释掉的 `ports` 两行打开(默认 8082),调试完记得注释回去。
服务容器名 `mcp_image_task`,**默认不占宿主机端口**,由 agent 走 `agent-mcp-net` 按容器名访问。
要从宿主机 curl 调试,自行给该服务加 `ports` 映射。
```bash
# 不占端口的健康检查
@@ -43,7 +40,7 @@ docker exec mcp_image_task node -e "fetch('http://localhost:3000/health').then(r
"url": "http://localhost:8082/mcp",
"headers": {
"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"
}
}
@@ -78,13 +75,14 @@ docker exec mcp_image_task node -e "fetch('http://localhost:3000/health').then(r
`image` 是模式开关:
- 不传 → **文生图**;
- 传一个公网 URL → **图生图 / 编辑**。
- 不传 → **文生图**,请求 `POST <base>/images/generations`;
- 传一个公网 URL → **图生图 / 编辑**,服务先把这张图拉下来,再以 multipart 上传到
`POST <base>/images/edits`。
本地图片先用 `mint_public_link` 换成公网 URL,再传给 `image`。
> 尺寸、质量、模型、上游地址都**不是**工具参数:它们属于部署策略,由调用方在 header 里固定,
> 避免 AI 乱填尺寸档位或模型名白烧额度。智谱原生通道也不接受尺寸,直接走上游默认值。
> 避免 AI 乱填尺寸档位或模型名白烧额度。尺寸/质量直接走上游默认值。
### 返回
@@ -93,7 +91,7 @@ docker exec mcp_image_task node -e "fetch('http://localhost:3000/health').then(r
```jsonc
{
"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
{
"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 | 必填 | 说明 |
|---|---|---|
| `Authorization` | ✅ | `Bearer <key>`,原样作为上游 Bearer token |
| `X-Image-Task-Base-Url` | ❌ | 别名或完整 URL;缺省 `zhipu` |
| `X-Image-Task-Model` | 见下 | 模型名原样透传 |
| `X-Image-Task-Base-Url` | ✅ | 上游 base URL(完整 `http(s)` 地址,如 `https://<host>/v1`);若已给到 `/images/generations` 或 `/images/edits` 会自动剥回 base,再按模式拼端点 |
| `X-Image-Task-Model` | ✅ | 模型名原样透传 |
### Base-Url 别名
| 值 | 实际地址 | 协议 |
|---|---|---|
| `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。
地址与模型只由 header 决定,AI 看不到也填不了;换模型 = 改 header 后重启 core。
### 图生图
`image` 只对 OpenAI 兼容通道生效:
图生图**不能**走 `/images/generations`,必须走 `/images/edits`。服务会先把 `image` URL 下载成字节
(独立 60s 超时,单图上限 20MB,响应需是 `image/*`,如 png / jpeg / webp / gif / bmp),再以 multipart 上传:
| Base-Url | 传 `image` |
|---|---|
| `zhipu` | 直接返回错误:智谱不支持图生图(只做文生图) |
| 网关 URL | 上游请求体带 `images: [url]` |
```text
POST <base>/images/edits
Content-Type: multipart/form-data; boundary=...
### 请求体差异
model=<header 里的模型>
prompt=<prompt>
image=@<下载到的参考图> # 字段名 image,文件名按 MIME 补扩展名
n=1
response_format=url
```
| 字段 | 智谱原生 | OpenAI 兼容 |
|---|---|---|
| `model` / `prompt` | ✅ | ✅ |
| `n` | ❌ | 固定 `1` |
| `response_format` | ❌ | 固定 `"url"` |
| `size` / `quality` | ❌ | ❌(交给上游默认值) |
| `images` | ❌ | 传图时带,数组形式 `[url]` |
选 multipart 而不是 JSON + base64 data URL:参考图已经在本地手里,直接当文件传可省掉 base64 的
1/3 体积膨胀,也避开网关对超大 JSON 体的限制。
### 请求体
- 文生图:JSON `{ model, prompt, n: 1, response_format: "url" }` → `/images/generations`
- 图生图:multipart(字段见上)→ `/images/edits`
`size` / `quality` 一律不传,交给上游默认值。两种模式的成功响应都按 `data[0].url` 取图。
---
## 配置示例
### 智谱直连(默认)
智谱与网关走同一套协议,只换地址与模型:
```yaml
- name: image_task
url: "http://mcp_image_task:3000/mcp"
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"
mode: skill
```
### OpenAI 兼容网关(文生图)
```yaml
- name: image_task
url: "http://mcp_image_task:3000/mcp"
@@ -196,20 +177,6 @@ X-Image-Task-Base-Url: "https://wb.ai.foresh.com/v1"
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 状态 | 表现 |
|---|---|---|
| 缺 `Authorization` | `200`(MCP 工具返回) | `isError: true`,提示补 header |
| `X-Image-Task-Base-Url` 非法 | `200`(MCP 工具返回) | `isError: true`,列出可用别名 |
| 非 zhipu 通道缺 `X-Image-Task-Model` | `200`(MCP 工具返回) | `isError: true`,提示补 header |
| zhipu 通道传了 `image` | `200`(MCP 工具返回) | `isError: true`,提示智谱不支持图生图,改用 OpenAI 兼容端点 |
| 缺 `X-Image-Task-Base-Url` / 不是完整 http(s) URL | `200`(MCP 工具返回) | `isError: true`,提示填完整地址 |
| 缺 `X-Image-Task-Model` | `200`(MCP 工具返回) | `isError: true`,提示补 header |
| `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=get` 查不到任务 | `200`(MCP 工具返回) | `isError: true`,提示 unknown task_id |
| 上游 4xx/5xx | `200`(MCP 工具返回) | 在 `op=get` 中以 `task_status: FAIL` 呈现,正文含上游状态码和 body |
| 上游只回 `b64_json` | `200`(MCP 工具返回) | `task_status: FAIL`,提示本服务只接受 URL |
| 网络失败 / 超时(>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" \
-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 \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-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 "Mcp-Session-Id: $SESSION" \
-d '{
@@ -284,7 +253,7 @@ curl -s -X POST http://localhost:8082/mcp \
}
}'
# 4. 图生图(OpenAI 兼容通道)
# 4. 图生图
curl -s -X POST http://localhost:8082/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
@@ -353,18 +322,10 @@ image_task/
- token / 上游地址 / 模型在 `create` 那一刻从请求 header 捕获进闭包,后台完成前不再读取
- **每 session 一个 transport + server**:通过 `Mcp-Session-Id` 复用
- **模型 / 上游地址不入 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` 并给出明确错误
### 默认模型
```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: 为什么只支持一张参考图?**
A: 当前上游契约只稳定支持单张;`image` 因此是单个 URL 字符串。
**Q: 图生图为什么在 zhipu 通道报错?**
A: 智谱原生接口不支持图生图。把 `X-Image-Task-Base-Url` 指向支持 `images` 字段的 OpenAI 兼容网关即可。
**Q: 图生图报错?**
A: 图生图走 `/images/edits` + multipart(字段名 `image`)。若上游模型不支持编辑、或网关不认这种入参,
上游会回 4xx,在 `op=get` 里以 `task_status: FAIL` 呈现。换一个支持 `/images/edits` 的模型即可。
**Q: 本地图片怎么传?**
A: 先调用 agent 内置的 `mint_public_link` 工具,把会话目录里的文件换成短期公网 URL,再传给 `image`。本服务不接受文件上传或 base64,上游服务器也无法访问你的本地路径。
A: 先调用 agent 内置的 `mint_public_link` 工具,把会话目录里的文件换成短期公网 URL,再传给 `image`。
本服务不接受文件上传或 base64(MCP 请求体不放图片字节),参考图由服务自己从这个 URL 拉取。
**Q: 上游是同步接口,为什么对外做成异步?**
A: 和 `video_task` 保持同一套任务型契约;同时避免一次生图把 core 的 `tools/call` 拖超时。
+1 -1
View File
@@ -1,7 +1,7 @@
{
"name": "mcp_image_task",
"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",
"main": "src/mcp-server.js",
"scripts": {
+183 -93
View File
@@ -6,20 +6,19 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";
// 上游地址既支持完整 URL,也支持别名。zhipu 走智谱原生协议(body 只有
// model/prompt);其余地址一律按 OpenAI 兼容的 /images/generations 协议
// (body 加 n / response_format=url)。别名目前只保留 zhipu。
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";
// 上游必须是 OpenAI 兼容的端点:文生图走 /images/generations,图生图走 /images/edits。
// Base-Url / 模型 / 凭据全部由调用方随每个请求用 header 带入(X-Image-Task-Base-Url /
// X-Image-Task-Model / Authorization),服务自己不存、也不预设任何厂商。
// 上游同步调用耗时上限(出图几十秒量级,留足余量)。
// 超时后任务记为 FAIL,避免上游挂而不回时永远卡在 PROCESSING。
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 处理器时,内核不会对其执行默认
// 终止动作,docker stop/restart 会白等满 10s 宽限期才被 SIGKILL。
@@ -84,45 +83,36 @@ function pickModel(headers) {
return pickHeaderString(headers, "x-image-task-model");
}
// 解析 Base-Url:别名优先,否则必须是 http(s) URL。
// 返回 { provider, url }:url 是最终 POST 的完整地址。
function resolveEndpoint(rawBase) {
const raw = String(rawBase || "zhipu").trim().replace(/\/+$/, "");
const alias = BASE_URL_ALIASES[raw.toLowerCase()];
const base = alias || raw;
let host;
try {
if (!/^https?:\/\//i.test(base)) throw new Error("not http(s)");
host = new URL(base).hostname.toLowerCase();
} catch {
// 解析 Base-Url:必须是完整 http(s) URL。允许调用方直接填到 /images/generations 或
// /images/edits(老配置、照抄文档的写法),统一剥回 base,端点由 mode 决定——
// 否则图生图会被错发到 generations。
function resolveBaseUrl(rawBase) {
const base = String(rawBase || "").trim().replace(/\/+$/, "");
if (!base) {
throw new Error(
`Invalid X-Image-Task-Base-Url "${raw}": use an alias (${Object.keys(BASE_URL_ALIASES).join(", ")}) ` +
"or a full http(s) URL."
"Missing X-Image-Task-Base-Url: pass the upstream base URL (e.g. https://<host>/v1)."
);
}
// 已经给到 /images/generations 就直接用;否则补在 base 后面。
const url = /\/images\/generations$/i.test(base)
? base
: base + "/images/generations";
const provider =
host === ZHIPU_HOST_SUFFIX || host.endsWith("." + ZHIPU_HOST_SUFFIX)
? "zhipu"
: "openai";
return { provider, url };
if (!/^https?:\/\//i.test(base)) {
throw new Error(
`Invalid X-Image-Task-Base-Url "${base}": must be a full http(s) URL.`
);
}
return base.replace(/\/images\/(generations|edits)$/i, "");
}
// 模型只由 header 决定,AI 看不到也填不了。
// zhipu 通道有默认模型;其他通道必须显式给 —— 否则会把 CogView 发到网关,
// 换来的只是一个含义不明的 400。
function resolveModel(headers, provider) {
// mode=edit 走 /images/edits(图生图),否则走 /images/generations(文生图)。
function resolveEndpoint(base, mode) {
return base + (mode === "edit" ? "/images/edits" : "/images/generations");
}
// 模型只由 header 决定,AI 看不到也填不了。不猜缺省值:猜错只会换来含义不明的 400。
function resolveModel(headers) {
const model = pickModel(headers);
if (model) return model;
if (provider === "zhipu") return DEFAULT_MODEL;
throw new Error(
"X-Image-Task-Model is required when X-Image-Task-Base-Url is not the zhipu alias."
);
if (!model) {
throw new Error("Missing X-Image-Task-Model: pass the upstream model name.");
}
return model;
}
// 一次解析出本次请求的上游、凭据、模型。
@@ -132,31 +122,24 @@ function resolveTarget(headers) {
if (!token) {
throw new Error('Missing Authorization: use "Authorization: Bearer <token>".');
}
const { provider, url } = resolveEndpoint(pickBaseUrl(headers));
return { provider, url, token, model: resolveModel(headers, provider) };
return {
base: resolveBaseUrl(pickBaseUrl(headers)),
token,
model: resolveModel(headers),
};
}
async function callImagesGenerations({ provider, url, token, model, prompt, image }) {
// 智谱原生只认 model/prompt;OpenAI 兼容通道固定单图,并要求返回 URL
// (b64_json 几十 MB,既塞不进任务表也没法给模型看)。尺寸/质量一律不传,
// 交给上游默认值 —— 各家(尤其 CogView)对尺寸的限制并不一致。
// 传了 image 就是图生图;上游字段是数组,所以这里包一层。
const body =
provider === "zhipu"
? { model, prompt }
: Object.assign(
{ model, prompt, n: 1, response_format: "url" },
image ? { images: [image] } : null
);
// 统一的上游 POST:超时、错误体解析都在这层,JSON 与 multipart 共用。
// contentType 为空表示交给 fetch 自己写(multipart 必须这样,boundary 由它生成)。
async function postUpstream({ url, token, body, contentType }) {
const headers = { Authorization: `Bearer ${token}` };
if (contentType) headers["Content-Type"] = contentType;
let resp;
try {
resp = await fetch(url, {
method: "POST",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json",
},
body: JSON.stringify(body),
headers,
body,
signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
});
} catch (e) {
@@ -175,9 +158,8 @@ async function callImagesGenerations({ provider, url, token, model, prompt, imag
data = { raw: text };
}
if (!resp.ok) {
const label = provider === "zhipu" ? "Zhipu" : "OpenAI-compatible";
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.detail = data;
@@ -186,6 +168,126 @@ async function callImagesGenerations({ provider, url, token, model, prompt, imag
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 存:它会把任务表撑爆,模型也读不了。
function extractUrls(data) {
if (!data) return [];
@@ -207,7 +309,7 @@ function hasInlineBase64(data) {
}
// ===== 自维护任务表(异步语义全靠这层模拟) =====
// 上游智谱 images 接口是同步阻塞的,但对外要和 video_task 一样提供
// 上游智谱/网关的 images 接口是同步阻塞的,但对外要和 video_task 一样提供
// create(立即返回 task_id)+ get(轮询结果)的异步契约:
// create 登记 PROCESSING 后把同步调用丢到后台跑,get 从表里读最新状态。
//
@@ -239,14 +341,21 @@ function pruneTasks() {
// 后台跑同步上游调用,结果回写任务表(fire-and-forget,不 await)
function runImageTask({ task, target, prompt, image }) {
callImagesGenerations({
provider: target.provider,
url: target.url,
token: target.token,
model: target.model,
prompt,
image,
})
const upstream = image
? callImagesEdits({
url: resolveEndpoint(target.base, "edit"),
token: target.token,
model: target.model,
prompt,
image,
})
: callImagesGenerations({
url: resolveEndpoint(target.base, "generation"),
token: target.token,
model: target.model,
prompt,
});
upstream
.then((data) => {
task.finishedAt = Date.now();
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 换成公网链接。
if (args.image !== undefined && typeof args.image !== "string") {
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();
const taskId = randomUUID();
const task = {
status: "PROCESSING",
provider: target.provider,
model: target.model,
prompt,
createdAt: Date.now(),
@@ -350,7 +444,6 @@ async function handleCreate({ args, headers }) {
const mode = image ? "edit" : "text-to-image";
const summary =
`Model: ${target.model}\n` +
`Provider: ${target.provider}\n` +
`Mode: ${mode}\n` +
`task_id: ${taskId}\n` +
`task_status: PROCESSING\n` +
@@ -411,7 +504,6 @@ async function handleGet({ args }) {
text:
`task_id: ${taskId}\n` +
`model: ${task.model}\n` +
`provider: ${task.provider}\n` +
`elapsed: ${elapsed}s\n` +
`task_status: PROCESSING\n` +
`\n` +
@@ -429,7 +521,6 @@ async function handleGet({ args }) {
type: "text",
text:
`task_id: ${taskId}\n` +
`provider: ${task.provider}\n` +
`elapsed: ${elapsedSeconds(task)}s\n` +
`task_status: FAIL\n` +
`error: ${task.error}`,
@@ -447,7 +538,6 @@ async function handleGet({ args }) {
const summary =
`task_id: ${taskId}\n` +
`model: ${task.model}\n` +
`provider: ${task.provider}\n` +
`elapsed: ${elapsedSeconds(task)}s\n` +
`task_status: SUCCESS\n` +
`${lines}`;
+2 -3
View File
@@ -23,8 +23,7 @@ docker compose up -d --build mcp_video_task
```
服务容器名 `mcp_video_task`,**默认不占宿主机端口**:由 agent 走 `agent-mcp-net` 按容器名访问
(`http://mcp_video_task:3000/mcp`)。需要从宿主机 curl 调试时,去仓库根 `docker-compose.yml`
把 `mcp_video_task` 注释掉的 `ports` 两行打开(映的是 MCP 端口 3000,仅本机短时调试用)。
(`http://mcp_video_task:3000/mcp`)。要从宿主机 curl 调试,自行给该服务加 `ports` 映射。
```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。
+43 -6
View File
@@ -1,15 +1,49 @@
# 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` 启动**。
## 三路上游
| 条件 | 走哪 | 说明 |
| --- | --- | --- |
| 请求带了 `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 端点封装 + 响应解析 |
| `mcp.js` | MCP 协议层:`web_search` 工具定义 + JSON-RPC 分发 |
| `core.js` | 搜索后端:自定义 `/search` + Parallel / Exa 免费 MCP 端点封装 + 响应解析 |
| `mcp.js` | MCP 协议层:`web_search` 工具定义 + JSON-RPC 分发 + 从 header 取上游参数 |
| `server.js` | 入口:CLI 参数 + stdio / HTTP/SSE 双传输 |
## 本地启动
@@ -33,13 +67,16 @@ MCP 端点:
- `EXA_API_KEY` — 提升 Exa 匿名限额
- `SEARCH_TIMEOUT_MS` — 上游搜索超时,默认 30000
上游地址 / 鉴权**不是**环境变量:由调用方随每个请求用 header 带入(见上面「三路上游」),
agent 侧写在 `config.yml` 的 `mcp_servers[name=web_search].headers`。换接口只改 YAML + 重启 core,
不碰 `.env`、不重建镜像;容器自身不存任何平台密钥。
## Docker
`docker-compose.yml` 中的 `mcp_web_search` 服务直接构建本目录,Dockerfile 已改为拷贝源码启动(不再有 `npm install -g`)。
容器内监听 3000,**默认不占宿主端口**:agent 走 `agent-mcp-net` 按容器名访问
(`http://mcp_web_search:3000/`)。需要从宿主机 curl 调试时,把仓库根 `docker-compose.yml` 里
`mcp_web_search` 注释掉的 `ports` 两行打开(默认写的是 8081),调试完记得注释回去。
(`http://mcp_web_search:3000/`)。要从宿主机 curl 调试,自行给该服务加 `ports` 映射。
```bash
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}
```
该服务**无服务端鉴权**(上游是免费端点),**永远不要**对外映射端口——会被白嫆搜索额度。
该服务**无服务端鉴权**,**永远不要**对外映射端口——会被白嫖搜索额度(自定义上游时还会把你的 key 白送出去)。
+107 -13
View File
@@ -1,9 +1,13 @@
/**
* 零依赖搜索核心:Parallel(默认,匿名免 key)与 Exa(备用)两个免费后端的统一封装。
* 零依赖搜索核心:三路上游,统一归一化成 `{ url, title?, snippet?, publishedAt? }[]`。
*
* 只用 Node 内置 fetch,不依赖任何 npm 包。两个后端都是公开的免费 MCP 端点,
* 本模块以 JSON-RPC `tools/call` 的方式直接调用它们,并归一化成统一的结果结构:
* `{ url, title?, snippet?, publishedAt? }[]`。
* - 自定义上游(`X-Web-Search-Base-Url` + `Authorization`):任意 `POST {base}/search`,
* 请求体 `{ query, max_results }`、响应 `{ results: [{ title, url, snippet }] }`。
* - 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)。
*/
@@ -13,9 +17,22 @@ export const PARALLEL_MCP_URL = 'https://search.parallel.ai/mcp';
/** Exa 免费 MCP 端点(匿名可用;EXA_API_KEY 可提升限额)。 */
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 请求。 */
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 载荷。
@@ -74,7 +91,7 @@ export function extractToolText(body) {
}
/** Parallel 响应解析:text 是内嵌 JSON `{ results: [...] }`。 */
export function mapParallelResponse(text) {
export function mapParallelResponse(text, maxSnippetLength) {
let payload;
try {
payload = JSON.parse(text);
@@ -84,10 +101,11 @@ export function mapParallelResponse(text) {
const sources = [];
for (const item of payload.results ?? []) {
if (!item.url) continue;
const snippet = item.excerpts?.length > 0 ? capSnippet(item.excerpts.join(' '), maxSnippetLength) : '';
sources.push({
url: item.url,
...(item.title ? { title: item.title } : {}),
...(item.excerpts?.length > 0 ? { snippet: item.excerpts.join(' ') } : {}),
...(snippet ? { snippet } : {}),
...(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 sources = [];
for (const block of blocks) {
@@ -114,28 +132,104 @@ export function parseExaText(text) {
const title = block.match(/^Title: (.+)$/m)?.[1]?.trim();
const published = block.match(/^Published: (.+)$/m)?.[1]?.trim();
const highlights = block.split(/^Highlights:\s*$/m)[1]?.trim();
const snippet = capSnippet(highlights, maxSnippetLength);
sources.push({
url,
...(title ? { title } : {}),
...(highlights ? { snippet: highlights.slice(0, 500) } : {}),
...(snippet ? { snippet } : {}),
...(published && published !== 'N/A' ? { publishedAt: published } : {}),
});
}
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 搜索(默认免费后端)。 */
export async function parallelSearch(query, maxResults) {
export async function parallelSearch(query, maxResults, maxSnippetLength) {
const text = await callMcpTool(PARALLEL_MCP_URL, 'web_search', {
objective: query,
search_queries: [query],
}, AbortSignal.timeout(REQUEST_TIMEOUT_MS));
const sources = mapParallelResponse(text);
const sources = mapParallelResponse(text, maxSnippetLength);
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 可选,用于提升匿名限额)。 */
export async function exaSearch(query, maxResults, apiKey) {
export async function exaSearch(query, maxResults, apiKey, maxSnippetLength) {
const endpoint = apiKey
? `${EXA_MCP_URL}?exaApiKey=${encodeURIComponent(apiKey)}`
: EXA_MCP_URL;
@@ -145,6 +239,6 @@ export async function exaSearch(query, maxResults, apiKey) {
numResults: maxResults ?? 8,
livecrawl: 'fallback',
}, AbortSignal.timeout(REQUEST_TIMEOUT_MS));
const sources = parseExaText(text);
const sources = parseExaText(text, maxSnippetLength);
return maxResults !== undefined ? sources.slice(0, maxResults) : sources;
}
+59 -16
View File
@@ -2,34 +2,59 @@
* MCP(Model Context Protocol)协议层:工具清单 + JSON-RPC 分发。
*
* 与传输无关(stdio / HTTP 都在 server.js 里),只负责把一条 JSON-RPC
* 消息变成 JSON-RPC 响应。支持的 method 与上游 dsh-web-search-free 一致:
* initialize / tools/list / tools/call / ping。
* 消息变成 JSON-RPC 响应。支持的 method: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 VERSION = '1.0.0';
export const VERSION = '1.1.0';
const DEFAULT_PROTOCOL = '2025-03-26';
const HDR_AUTH = 'authorization';
const HDR_BASE = 'x-web-search-base-url';
/** 暴露给 MCP 客户端的工具清单。 */
const TOOLS = [
{
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: {
type: 'object',
properties: {
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)' },
maxSnippetLength: { type: 'integer', minimum: 1, description: 'Truncate each snippet to this many characters (default: keep full text)' },
},
required: ['query'],
},
},
];
/** 执行一次 tools/call;失败时抛 { code, message } 表示工具级错误。 */
async function callTool(name, args) {
/** 从请求 header 取上游两要素;Authorization 允许写裸 key(自动补 Bearer)。 */
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}` };
const params = args ?? {};
@@ -38,20 +63,36 @@ async function callTool(name, args) {
: null;
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)
? Math.max(1, Math.floor(params.numResults))
: 8;
// 截断是调用方的选择:不传就原样返回整段 snippet(上游可能给整篇正文,由调用方自己控上下文)
const rawMaxLen = Number(params.maxSnippetLength);
const maxSnippetLength = Number.isFinite(rawMaxLen) && rawMaxLen >= 1 ? Math.floor(rawMaxLen) : undefined;
const sources = provider === 'exa'
? await exaSearch(query, numResults, process.env.EXA_API_KEY)
: await parallelSearch(query, numResults);
const up = upstreamOf(headers);
let sources;
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) }] };
}
/** 处理一条请求消息,返回 result;失败时抛 { code, message }。 */
async function handleRequest(message) {
async function handleRequest(message, headers) {
switch (message.method) {
case 'initialize':
return {
@@ -62,7 +103,7 @@ async function handleRequest(message) {
case 'tools/list':
return { tools: TOOLS };
case 'tools/call':
return callTool(message.params?.name, message.params?.arguments);
return callTool(message.params?.name, message.params?.arguments, headers);
case 'ping':
return {};
default:
@@ -72,9 +113,11 @@ async function handleRequest(message) {
/**
* 解析并执行一条 JSON 消息。
* @param {string} raw JSON-RPC 文本
* @param {object} [headers] 本次 HTTP 请求的 header(stdio 模式没有,上游参数就走免费后端)
* @returns 响应信封对象;notification(无 id)返回 null;非法 JSON 返回 undefined。
*/
export async function dispatch(raw) {
export async function dispatch(raw, headers) {
let message;
try {
message = JSON.parse(raw);
@@ -83,7 +126,7 @@ export async function dispatch(raw) {
}
if (message.id === undefined) return null; // 通知不响应
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) {
const e = error;
return {
+2 -2
View File
@@ -1,8 +1,8 @@
{
"name": "web_search",
"version": "1.0.0",
"version": "1.1.0",
"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",
"type": "module",
"main": "server.js",
+9 -2
View File
@@ -1,16 +1,22 @@
#!/usr/bin/env node
/**
* MCP server 入口 —— 免费网页搜索(Parallel 默认 / Exa 备用,匿名免 key)。
* MCP server 入口 —— 网页搜索(自定义 /search 上游,或内置免费 Parallel / Exa)。
*
* 本地重构版(上游:@sheep233_/dsh-web-search-free),零运行时依赖,直接 node 启动。
*
* ## 双传输
* - **stdio**(默认):`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`
* - 兼容 Streamable HTTP(`POST /`)与老式 SSE(`GET /sse` + `POST /messages`)
* - `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(可选,上游超时)。
*/
import { createInterface } from 'node:readline';
@@ -88,7 +94,8 @@ function runHttp(host, port) {
let body = '';
req.on('data', (chunk) => { body += chunk.toString(); });
req.on('end', () => {
void dispatch(body).then((response) => {
// header 必须随消息带进协议层:上游地址 / 鉴权都是逐请求带入的(容器不存密钥)
void dispatch(body, req.headers).then((response) => {
if (response === null) { // 通知
res.writeHead(202).end();
return;
+107 -226
View File
@@ -1,255 +1,136 @@
#!/bin/bash
# init.sh — 生成 .env 与 config.yml。
# init.sh — 首次部署准备:生成 .env、探测公网地址、创建初始管理员。幂等。
#
# 只读环境变量,不依赖任何外部文件;**全部可选**,什么都不给也能直接跑。
# ./scripts/init.sh # 已有 .env / config.yml 均不覆盖
#
# 用法:
# ./scripts/init.sh # 全用默认值(无模型、admin/admin)
# 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 复用 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 一般不用给:不给就自动生成并复用(见下)
#
# 微信接入(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.<时间戳>)。
# 可选变量:PUBLIC_IP、AGENT_PORT、AUTH_USER / AUTH_PASSWORD(默认 admin / admin)、
# EXECUTOR_TOKEN / WXBOT_TOKEN / AUTH_SECRET(不给则生成并复用)。
set -euo pipefail
# ============================================================
# 路径与默认值
# ============================================================
REPO_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
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"
CONFIG_YML="$REPO_DIR/config.yml"
BIGMODEL_KEY="${BIGMODEL_KEY:-}"
DEEPSEEK_KEY="${DEEPSEEK_KEY:-}"
QWEN_KEY="${QWEN_KEY:-}"
PUBLIC_IP="${PUBLIC_IP:-}"
PORT_INPUT="${AGENT_PORT:-}"
AUTH_USER="${AUTH_USER:-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:-}"
log() { echo -e "\n\033[1;32m===== $* =====\033[0m"; }
info() { echo -e "\033[1;36m[INFO]\033[0m $*"; }
warn() { echo -e "\n\033[1;33m[WARN]\033[0m $*"; }
info() { echo -e "\033[1;36m[INFO]\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)
local n="${1:-32}"
gen_hex() {
if command -v openssl >/dev/null 2>&1; then
openssl rand -hex "$n"
openssl rand -hex 32
else
head -c "$n" /dev/urandom | od -An -tx1 | tr -d ' \n'
head -c 32 /dev/urandom | od -An -tx1 | tr -d ' \n'
fi
}
# ============================================================
# 1. 生成 .env(密钥只生成一次,之后复用 → 重跑不掉登录态、不改 executor token)
# ============================================================
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)}"
# 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)}"
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 即全部接线)
# AGENT_PORT: agent-core 映射到宿主机的端口
EXECUTOR_TOKEN=$EXECUTOR_TOKEN
AUTH_SECRET=$AUTH_SECRET
WXBOT_TOKEN=$WXBOT_TOKEN
AGENT_PORT=$AGENT_PORT
EOF
info "EXECUTOR_TOKEN / AUTH_SECRET / WXBOT_TOKEN 已就位(沿用已有 .env 的值,没有则新生成)"
# --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
env_get() {
[ -f "$ENV_FILE" ] || return 0
awk -F= -v k="$1" '$1==k { sub(/^[^=]*=/, ""); print; exit }' "$ENV_FILE" || true
}
enabled_plats=()
if [ -n "$BIGMODEL_KEY" ]; then enabled_plats+=("bigmodel"); fi
if [ -n "$DEEPSEEK_KEY" ]; then enabled_plats+=("deepseek"); fi
if [ -n "$QWEN_KEY" ]; then enabled_plats+=("qwen"); fi
yaml_q() {
local s="${1//\\/\\\\}"
s="${s//\"/\\\"}"
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 "# 只含 deploy 相关段(platforms / auth / mcp_servers / public_link),其余走 server/config.js 默认值。"
echo "# 生成时间: $(date '+%Y-%m-%d %H:%M:%S')"
echo "# 已启用平台: ${enabled_plats[*]:-(无)}"
echo
if [ "${#enabled_plats[@]}" -eq 0 ]; then
echo "platforms: [] # 没有配置平台 key(BIGMODEL_KEY / DEEPSEEK_KEY / QWEN_KEY)"
else
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
echo "# 由 scripts/init.sh 生成;重跑复用已有密钥,并保留其它变量。"
echo "EXECUTOR_TOKEN=$EXECUTOR_TOKEN"
echo "WXBOT_TOKEN=$WXBOT_TOKEN"
echo "AUTH_SECRET=$AUTH_SECRET"
echo "AGENT_PORT=$AGENT_PORT"
echo "PUBLIC_BASE_URL=$PUBLIC_BASE_URL"
if [ -n "$EXTRAS" ]; then
echo
printf '%s\n' "$EXTRAS"
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:
secret: "$AUTH_SECRET"
secret: $(yaml_q "$AUTH_SECRET")
users:
- user: $AUTH_USER
password: "$AUTH_PASSWORD"
role: admin # 初始账号为管理员;其余用户的增删/角色/默认模型在前端「设置→用户」里配
mcp_servers:
- name: web_search
url: "http://mcp_web_search:3000/"
- user: $(yaml_q "$AUTH_USER")
password: $(yaml_q "$AUTH_PASSWORD")
role: admin
EOF
info "已创建,初始管理员 $AUTH_USER"
CREATED=1
fi
if [ -n "$BIGMODEL_KEY" ]; then
cat <<EOF
- name: image_task
url: "http://mcp_image_task:3000/mcp"
headers:
Authorization: "Bearer $BIGMODEL_KEY"
mode: skill # 不下发给模型,以技能形式暴露(skill 工具里 list/get/run)
- 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
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 " MCP 服务 : web_search / image_task / video_task(同栈,随 compose 启动)"
echo " 微信接入 : WXBOT_TOKEN 已就位(compose 注入 core 与 wxbot 两侧;wxbot 无需配置文件)"
echo "---------------------------------------------"
log "完成 ✅"
# ---------- 汇总 ----------
title "汇总"
echo " 访问地址 : ${PUBLIC_BASE_URL:-(未设置)}"
if [ "$CREATED" = "1" ]; then
echo " 初始账号 : $AUTH_USER${AUTH_PASSWORD:+ / }$([ "$AUTH_PASSWORD" = "admin" ] && echo 'admin(登录后请修改)' || echo '<AUTH_PASSWORD 传入值>')"
fi
echo " 下一步 : docker compose up -d --build"
+1 -2
View File
@@ -359,8 +359,7 @@ print_next_steps() {
备注:
- 上面若提示需要重启(内核/核心库更新),建议先 reboot,再执行第 ③ 步
- init.sh 可重复执行:.env 里的密钥复用,config.yml 会先备份为 .bak.<时间戳>
- 只刷新密钥、不动配置:./scripts/init.sh --env-only
- init.sh 可重复执行:已有的 .env 与 config.yml 都不会被覆盖
EOF
}
+2
View File
@@ -53,6 +53,7 @@ input_schema:
output_schema:
# 输出描述
visit_url: /app/{task_id}/ # 可选:页面类技能的访问路径模板
required: true # 可选:清单行首标 **required**,提示该域不要手写等价实现
thinking: true # 可选:get 时自动开启本回合的深度思考
---
```
@@ -61,6 +62,7 @@ thinking: true # 可选:get 时自动开启本回合的深度思
- `description`:一句话描述技能功能,用于 `op=list` 的清单展示。
- `thinking`:(可选)为 `true` 时,模型调用 `get` 会自动开启深度思考(合并模型的
`thinking_params`),开启后保持,直到用户手动关闭;模型未配置思考参数时不生效。只影响模型回合,不影响脚本本身。
- `required`:(可选)为 `true` 时,模型可见的技能清单里该行行首标 `**required**`,表示这个领域不要手写等价脚本(如 `office` / `x2pdf`)。纯提示,不做强制校验,也不会自动调用。
- `input_schema`:输入参数的 JSON Schema 定义,用于参数校验和文档生成。
- `output_schema`:输出结果的描述(可选)。
- `visit_url`:(可选)页面类技能声明的访问路径模板,`{task_id}` 占位执行时替换为会话 id。`run` 成功后由 core(tools/executor.js)拼上 `public_link.base_url`,在输出末尾追加一行「访问地址:<完整 URL>」——技能进程跑在 executor 隔离视图里不知道公网地址,完整链接只能 core 补;AI 拿到相对路径会原样转给用户,而相对路径打不开。
+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 模式返回的字段结构与测试断言不一致)。属既有问题,本次未动。
+3
View File
@@ -18,6 +18,7 @@ skills/document-photo-to-pdf/
web/index.html ← 审核页模板的单一事实源
tasks/<session-id>/
out/ ← 原始校正页图(PNG,自然尺寸,文件名与 PDF 同名)
.app/doc-review/
index.html ← 指向 web/index.html 的符号链接(不含数据注入)
<batch_id>/p1.jpg ... ← 本批缩略图(长边 1200,JPEG)
@@ -110,6 +111,8 @@ requested_at TEXT, started_at TEXT, finished_at TEXT
## 页面交互约定
- 顶部标题条(白底,参考 H5 全屏预览):左侧 PDF 名,右侧下载 PDF,最右 X 返回会话。
- 加载失败(无批次 / `data.db` 缺 `doc_review_batch` 表 / data.db 被删)只保留标题条:
X 仍可返回会话、下载置灰,编辑区与底栏隐藏。所以 X 的绑定在 `start()` 里,不能放 `boot()`。
- 重新生成 PDF 不在顶栏:放在照片区底部(stage 与预览各一个,按当前视图显示;桌面只用
stage),仅在存在未保存修改时出现。
- 底部只保留翻页和当前页名,不再放操作按钮。
+14 -5
View File
@@ -1,6 +1,6 @@
---
name: document-photo-to-pdf
description: 把手机拍摄的纸质文档照片裁剪、拉正,合并为 PDF,并给出可预览/微调的审核页
description: 纸质文档(合同/发票/证件/书页)拍照/扫描件校正后,导出 PDF 和 out/ 下的单页 PNG 原图(未调色未缩放);自动找纸边、透视拉正、多页合并,附审核页微调
visit_url: /app/{task_id}/doc-review/
input_schema:
type: object
@@ -25,12 +25,20 @@ input_schema:
## 返回值
- `ok:true`:`summary` 一句话摘要,`pdf` 文件名;末尾附完整「访问地址」。把 PDF 和地址
一起给用户。
- `ok:false`:转述 `error.message` / `error.hint`,忽略访问地址。
- `ok:true`:`summary` 一句话摘要,`pdf` 文件名,`images` 是 `out/` 下的原图路径;
末尾附完整「访问地址」。务必把 PDF、地址和图片路径一起给用户——自动找的纸边不一定准,
用户在审核页拖角/旋转后点「重新生成 PDF」即可就地修正,不必重传。
此时可直接收尾,不必额外复跑或逐页读图;但要在回话里带出 `summary` 的状态档位和需要人看的页
(`needs_corners` / `review` / `failed` 各有几页),不要只报"已生成"。
- `ok:false`:一张都没出件(参数错误、图打不开、渲染失败、写盘失败)。此时没有 PDF、
也没有审核批次,访问地址打开是空的,**无意义**;只需转述 `error.message` / `error.hint`。
每次运行还会把校正后的单页原图(未调色、未缩放、无白边)导出到 `out/`,文件名与 PDF
同名:`合同_校正.pdf` → `out/合同_校正-01.png`、`out/合同_校正-02.png`。不需要图片时
忽略 `images` 即可。
```json
{"ok":true,"summary":"3 页已生成;1 页建议在审核页确认","pdf":"合同_校正.pdf"}
{"ok":true,"summary":"3 页已生成;1 页建议在审核页确认;原始页图见 out/","pdf":"合同_校正.pdf","images":["out/合同_校正-01.png","out/合同_校正-02.png","out/合同_校正-03.png"]}
访问地址:https://agent.ai.foresh.com/app/task-20261023-001/doc-review/
```
@@ -50,3 +58,4 @@ input_schema:
- 支持 jpg/png/webp/bmp/tif;HEIC 不支持。
- 一图一纸;同框多纸只取最大。
- 建议 ≤20 页;更多或 300dpi 可能超 120s,可分批。
- `out/` 里的原图是自然尺寸(不缩放、不调色),页与页尺寸可能不同;PDF 仍按纸张/批次统一。
@@ -252,6 +252,9 @@ def largest_connected(mask_small):
return out
QUAD_INFO = {}
# ---------------------------------------------------------------- 纸面掩膜
def otsu_threshold(score):
@@ -274,39 +277,313 @@ def otsu_threshold(score):
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):
"""返回 (raw, eroded)。
"""返回 (raw, eroded, info)。
raw:未腐蚀的纸面掩膜,用于回退几何,避免角点内收。
eroded:腐蚀后的掩膜,只用于限定边缘搜索环带。
info:选中的候选参数与打分(用于审核页/排查)。
相比旧实现:不再把一组固定阈值当真理(旧值没有用真实样张标定)。
这里跑一梯子候选,按“像不像一张纸”打分选最好的那个——关键是
solidity / 最小外接矩形填充率要高高、贴画面边缘要低低。
“白纸放在亮背景(蓝花布、塑料袋、白台面)上”这类场景下,旧阈值会把
背景并进纸面,掩膜一路贴到画面边缘,后续拟合出的“纸边”其实是照片边框。
"""
d = P["detect"]
H, W = arr.shape[:2]
S, V = rgb_to_sv(arr)
score = (V * (1.0 - S)).astype(np.float32)
th = max(otsu_threshold(score), d["paper_otsu_floor"])
bright = (score > th) & (V > d["paper_v_min"]) & (S < d["paper_s_max"])
base_th = float(otsu_threshold(score))
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"],
min(bs.shape) // d["paper_close_div"])))
m = fill_holes(m)
m = largest_connected(m)
m = closing(m, _odd(max(d["paper_close_min"],
min(bs.shape) // d["paper_close2_div"])))
m = fill_holes(m)
best = None
tried = []
for cand in d["mask_ladder"]:
th = base_th * float(cand["o"])
bright = ((score > th) & (V > float(cand["v"]))
& (S < float(cand["s"])))
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"]))
if factor > 1:
raw = upsample_nearest(raw_small, H, W)
raw = upsample_nearest(m, H, W)
eroded = upsample_nearest(eroded_small, H, W)
else:
raw, eroded = raw_small, eroded_small
return raw, eroded
raw, eroded = m, eroded_small
return raw, eroded, info
# ---------------------------------------------------------------- 边缘图
@@ -411,28 +688,33 @@ def _side_line(p0, p1):
def detect_quad_corners(paper_raw, points, P):
"""从掩膜边界 + 边缘点估四角,返回 (corners, fallback_sides)。"""
"""从掩膜边界 + 边缘点估四角,返回 (corners, fallback_sides)。
与旧实现的区别:初始四边形不再用“四个方向极值点”(遇圆角/毛刺会把
四个锚点挤到同一段弧上,导致相邻边近乎平行、角点飞出去),而是用
掩膜的最小外接矩形——它天然凸、天然有序,再在此基础上用真实边缘点
逐边收紧。最后再用 quad_ok() 看门,不合格就退回矩形本身。
"""
d = P["detect"]
base = mask_boundary_points(paper_raw, P)
if len(base) < 40:
return [], [0, 1, 2, 3]
bx, by = base[:, 0], base[:, 1]
anchors = np.array([
base[int(np.argmin(bx + by))], # 左上
base[int(np.argmax(bx - by))], # 右上
base[int(np.argmax(bx + by))], # 右下
base[int(np.argmin(bx - by))], # 左下
], dtype=np.float64)
rect = min_area_rect(base)
if rect is None:
return [], [0, 1, 2, 3]
anchors = order_quad(rect)
init = [_side_line(anchors[i], anchors[(i + 1) % 4]) for i in range(4)]
# 用整条掩膜边界重拟合每一边(排除两端,避开角点圆角)
base_lines = []
side_ok = []
for i in range(4):
sl = init[i]
if sl is None:
base_lines.append(None)
side_ok.append(False)
continue
n, c, u, L = sl
p0 = anchors[i]
@@ -441,11 +723,18 @@ def detect_quad_corners(paper_raw, points, P):
m = d["boundary_side_margin"]
sel = base[(dist <= d["group_tol_px"]) &
(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"])
base_lines.append((n2, c2))
else:
base_lines.append((n, c))
side_ok.append(ok)
final_lines = list(base_lines)
fallback_sides = [0, 1, 2, 3]
@@ -476,7 +765,11 @@ def detect_quad_corners(paper_raw, points, P):
m = d["boundary_side_margin"]
proj = (sel - p0) @ u
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"])
final_lines[i] = (n2, c2)
else:
@@ -484,28 +777,62 @@ def detect_quad_corners(paper_raw, points, P):
H, W = paper_raw.shape
oob = d["corner_oob_frac"]
out = []
for i in range(4):
chosen = None
for lines in (final_lines, base_lines):
def _intersect_all(lines):
"""四条直线两两求交得到四角;任一条缺失/越界就返回 None。"""
q = []
for i in range(4):
l1, l2 = lines[i - 1], lines[i]
if l1 is None or l2 is None:
continue
return None
det = l1[0][0] * l2[0][1] - l2[0][0] * l1[0][1]
if abs(det) < 1e-3:
continue
return None
p = _intersect(l1[0], l1[1], l2[0], l2[1])
if p is None:
continue
if (-oob * W <= p[0] <= (1.0 + oob) * W and
return None
if not (-oob * W <= p[0] <= (1.0 + oob) * W and
-oob * H <= p[1] <= (1.0 + oob) * H):
chosen = (float(p[0]), float(p[1]))
break
if chosen is None:
chosen = (float(anchors[i][0]), float(anchors[i][1]))
if i not in fallback_sides:
fallback_sides.append(i)
out.append(chosen)
return None
q.append([float(p[0]), float(p[1])])
return q
# 候选几何:矩形(保守)、掩膜边界拟合(贴合纸面)、边缘点拟合(贴合真实边缘)
candidates = [("rect", [list(map(float, p)) for p in anchors])]
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))
@@ -562,7 +889,7 @@ def detect(img, P):
arr = np.asarray(pil).astype(np.float32) / 255.0
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)
info = {
@@ -575,6 +902,7 @@ def detect(img, P):
"fallback": True,
"fallback_sides": [0, 1, 2, 3],
}
info.update(mask_info)
if frac < 0.005 or not paper_raw.any():
return [], info
@@ -596,9 +924,26 @@ def detect(img, P):
info["edge_pixels"] = int(cand.sum())
info["fallback_sides"] = 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:
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"] = {
k: float(v) for k, v in border_coverage_exact(
cand, paper_eroded,
@@ -606,3 +951,196 @@ def detect(img, P):
}
src_pts = [(float(x / scale), float(y / scale)) for x, y in corners]
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
@@ -5,7 +5,7 @@
- 所有 quad 都是“转正后原图”坐标;
- 目标尺寸把 PDF 画布内容区(页面尺寸 - 四周留白)的一条边填满,可放大低分辨率照片,
避免同一批页面因原图像素多少而大小不一;
- 不做中间 PNG,页面图直接进内存后一次性写 PDF。
- raw 页图(裁剪 + 透视拉正、自然尺寸、不调色)由 warp_raw 产出,PDF 页从它派生。
"""
import os
import statistics
@@ -13,7 +13,7 @@ import statistics
import numpy as np
from PIL import Image
from homography import brighten, warp_perspective
from homography import brighten, warp_perspective, warp_perspective_pil
# ---------------------------------------------------------------- 纸张
@@ -135,8 +135,27 @@ def target_size(quad, paper, page_orientation, P, out_ratio=None):
return max(1, int(round(tw))), max(1, int(round(th))), (cw, ch)
def warp_raw(img, quad):
"""只做裁剪 + 透视拉正:自然尺寸、不调色。raw 页图的唯一来源。"""
return warp_perspective_pil(img, quad, None)
def page_for_pdf(raw, size, P):
"""从 raw 页图派生 PDF 页:先调色,再按目标尺寸缩放(LANCZOS)。
与旧 warp_page 的差别只在采样顺序:先在自然尺寸做透视(超采样),
再缩到画布内容区,缩小时比直接按目标尺寸采样更少混叠。
"""
r = P["render"]
spec = P["enhance"].get(r.get("enhance") or r["default_enhance"])
page = tone(raw, spec, r["brighten_target"], r["brighten_pct"])
if page.size != tuple(size):
page = page.resize(tuple(size), Image.LANCZOS)
return page
def warp_page(img, quad, size, P):
"""透视校正 + 按 P["render"]["enhance"] 调色。"""
"""旧路径:直接按目标尺寸 warp + 调色。PIL 实现出问题时回退用。"""
r = P["render"]
page = warp_perspective(img, quad, size,
chunk_rows=r["warp_chunk_rows"])
@@ -19,6 +19,15 @@ def _solve_h(src, dst):
return vt[-1].reshape(3, 3)
def natural_size(quad):
"""四边形按自然边长对应的输出尺寸(与 warp_perspective 的 out_size=None 一致)。"""
q = np.asarray(quad, dtype=np.float64)
tl, tr, br, bl = q
w = int(round(max(np.linalg.norm(tr - tl), np.linalg.norm(br - bl))))
h = int(round(max(np.linalg.norm(bl - tl), np.linalg.norm(br - tr))))
return max(1, w), max(1, h)
def warp_perspective(img, quad, out_size=None, fill=(255, 255, 255),
chunk_rows=256):
"""把 quad 指定的四边形透视校正到 out_size。
@@ -29,12 +38,9 @@ def warp_perspective(img, quad, out_size=None, fill=(255, 255, 255),
arr = np.asarray(img if img.mode == "RGB" else img.convert("RGB"))
src_h, src_w = arr.shape[:2]
quad = np.asarray(quad, dtype=np.float64)
tl, tr, br, bl = quad
if out_size is None:
w = int(round(max(np.linalg.norm(tr - tl), np.linalg.norm(br - bl))))
h = int(round(max(np.linalg.norm(bl - tl), np.linalg.norm(br - tr))))
out_size = (w, h)
out_size = natural_size(quad)
out_w = max(1, int(out_size[0]))
out_h = max(1, int(out_size[1]))
@@ -80,6 +86,29 @@ def warp_perspective(img, quad, out_size=None, fill=(255, 255, 255),
return Image.fromarray(out)
def warp_perspective_pil(img, quad, out_size=None, fill=(255, 255, 255)):
"""PIL(C) 实现的透视校正,采样约定与 warp_perspective 一致。
out_size=None 时按四边形自然边长输出。10MP 约 0.3s,比上面的 numpy
逐像素实现快约 10 倍;实测两者平均差 0.26 灰度级、89% 像素完全一致。
只用于 raw 页图导出;PDF 出件仍走 numpy 版本,避免改变既有输出的像素。
"""
if out_size is None:
out_size = natural_size(quad)
ow = max(1, int(out_size[0]))
oh = max(1, int(out_size[1]))
dst = np.array([[0, 0], [ow - 1, 0], [ow - 1, oh - 1], [0, oh - 1]],
dtype=np.float64)
H = np.linalg.inv(_solve_h(np.asarray(quad, dtype=np.float64), dst))
H = H / H[2, 2]
coeffs = (H[0, 0], H[0, 1], H[0, 2],
H[1, 0], H[1, 1], H[1, 2],
H[2, 0], H[2, 1])
src = img if img.mode == "RGB" else img.convert("RGB")
return src.transform((ow, oh), Image.PERSPECTIVE, coeffs, Image.BILINEAR,
fillcolor=fill)
def brighten(img, target=245, pct=97):
"""全局等比提亮:把 pct 分位映射到 target,保持相对对比度。"""
arr = np.asarray(img if img.mode == "RGB" else img.convert("RGB")).astype(np.float32)
@@ -15,6 +15,8 @@ P = {
"detect": {
"max_side": 1600, # 检测降采样长边;越大越准越慢
"min_edge_points": 40, # 单边拟合所需最少点数,低于则回退掩膜线
"side_support_frac": 0.25, # 单边支撑度:点数至少要达边长的这个比例,
# 不足则这条边退回矩形边(防止角点被甩飞)
"group_tol_px": 22.0, # 边线点归属容差(处理图像素)
"robust_px": 2.0, # 稳健拟合的残差基准(处理图像素)
"mask_erode_kernel": 3, # 掩膜内收核;3 = 半径 1 像素
@@ -25,6 +27,8 @@ P = {
"paper_close_div": 60, # 第一次闭运算核 = min(H,W)//该值
"paper_close_min": 5, # 形态学核最小值
"paper_close2_div": 80, # 第二次闭运算核 = min(H,W)//该值
"paper_open_div": 90, # 开运算核 = min(H,W)//该值(去布面高光碎点/细桥)
"paper_open_min": 5,
"band_div": 45, # 搜索环带宽度 = H//该值
"band_min": 15, # 环带宽度下限
"edge_local_gain": 1.55, # 边缘图局部阈值增益
@@ -42,14 +46,65 @@ P = {
"coverage_tol_min": 10,
"corner_oob_frac": 0.15, # 角点越界允许幅度(相对画面长边)
"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": {
"oob_max_pct": 15.0, # 越界超过此值判失败
"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, # 外侧暗像素占比低于此值只告警
"repair": True, # 校验不过时先尝试“重拟合”而不是直接扔兜底框
"repair_fallback": "rect", # rect = 用掩膜的最小外接矩形;off = 直接兜底框
"coverage_warn": 0.40, # 四边覆盖率低于此值告警(未标定)
"aspect_deadband": 0.10, # 0.9~1.1 视为接近正方形,不参与方向投票
"paper_mismatch_pct": 20.0, # 与批次中位宽高比偏差超过此值告警
+121 -15
View File
@@ -4,9 +4,9 @@
两种用法共用一条出件内核:
全自动:{"images": [...], "output": "..."}
只出 PDF,不碰 .app/、不写 data.db。
出 PDF,并把校正后的单页原图导出到 out/(不碰 .app/、不写 data.db)。
半自动:{"images": [...], "review": "always|auto"}
出 PDF,并把审核页发布到 .app/doc-review/、运行记录写进 data.db。
出 PDF 和 out/ 页图,并把审核页发布到 .app/doc-review/、运行记录写进 data.db。
重生成:{"batch_id": "dr..."}
从 data.db 读上次的源图/输出/编辑,覆盖同名 PDF;args 带 edits 时以 edits
为准,不带时读 doc_review_job.edits,再退化为当前页记录(按现在的角点再渲染)。
@@ -17,6 +17,7 @@ stdout 只输出一个 JSON 对象;进度、警告、异常都在字段里,
import io
import json
import os
import re
import statistics
import sys
import time
@@ -28,7 +29,7 @@ HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "doc_deskew"))
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
import compose # noqa: E402
import check # noqa: E402
@@ -288,6 +289,26 @@ def _targets(args, batch_id):
return output, root, None, None
def _png_dir(cwd):
d = os.path.join(cwd, "out")
if os.path.exists(d) and not os.path.isdir(d):
raise ValueError("out 已存在且不是目录:%s" % d)
os.makedirs(d, exist_ok=True)
return d
def _clean_pngs(d, stem, keep):
"""删掉本 PDF 前缀下编号大于本次出页数的旧页图;不动目录里其它文件。"""
pat = re.compile(r"^" + re.escape(stem) + r"-(\d+)\.png$")
for name in os.listdir(d):
m = pat.match(name)
if m and int(m.group(1)) > keep:
try:
os.remove(os.path.join(d, name))
except OSError:
pass
def _mark_error(conn, batch_id, message):
if not conn or not batch_id:
return
@@ -464,8 +485,51 @@ def process(args, t0):
v = {"ok": False, "metrics": {},
"failures": ["校验异常:%s" % e], "warnings": []}
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 也要跟着换成兜底框,否则“恢复自动”会把无效角点拖回来。
meta["detected_corners"] = meta["corners"]
meta["corners"] = _fallback_quad(meta["source_size"], P)
@@ -490,6 +554,25 @@ def process(args, t0):
_mark_error(conn, batch_id, res["summary"])
return res
# 出件顺序先定下来:raw 页图按最终 PDF 页序编号(文件名与 PDF 同名)。
plan_by_idx = {m["index"]: (i, s, m) for (i, s, m) in plan}
ordered_idx = []
if ed and ed.get("order"):
for v in ed["order"]:
if v in plan_by_idx and v not in ordered_idx:
ordered_idx.append(v)
for i in sorted(plan_by_idx):
if i not in ordered_idx:
ordered_idx.append(i)
plan = [plan_by_idx[i] for i in ordered_idx]
# raw 页图固定落会话根下的 out/;重生成页数变少时,成功后清掉多余编号。
png_dir = _png_dir(os.getcwd())
pdf_stem = os.path.splitext(os.path.basename(output))[0]
png_pad = max(2, len(str(len(plan))))
png_n = 0
png_paths = []
# ---------------- 批次方向
aspects = [m["aspect"] for (_, _, m) in plan]
batch_orientation, _, median_aspect = \
@@ -585,7 +668,7 @@ def process(args, t0):
try:
img = load_image(src)
try:
page = compose.warp_page(img, out_corners, (tw, th), P)
raw = compose.warp_raw(img, out_corners)
finally:
img.close()
except Exception as e:
@@ -599,6 +682,29 @@ def process(args, t0):
out_meta[idx] = {"page": None, "canvas": None, "error": err}
continue
try:
page = compose.page_for_pdf(raw, (tw, th), P)
except Exception as e:
err = _err("INTERNAL",
"第 %d 页生成 PDF 页面失败:%s" % (idx, e), idx,
"重试;若持续出现请反馈")
meta["status"] = "render_failed"
meta["reason"] = "render_failed"
meta["error"] = err
meta["warnings"].append(err["message"])
out_meta[idx] = {"page": None, "canvas": None, "error": err}
continue
# raw 页图:自然尺寸、不调色、无白边。编号跟最终页序走。
png_n += 1
png_name = "%s-%0*d.png" % (pdf_stem, png_pad, png_n)
png_path = os.path.join(png_dir, png_name)
try:
raw.save(png_path, "PNG", compress_level=6)
png_paths.append(_rel(os.getcwd(), png_path))
except Exception as e:
meta["warnings"].append("第 %d 页原图导出失败:%s" % (idx, e))
meta["out_size"] = [int(tw), int(th)]
meta["canvas_size"] = [int(canvas[0]), int(canvas[1])]
meta["page_orientation"] = page_orient
@@ -639,15 +745,9 @@ def process(args, t0):
"方向与批次不一致,已旋转 %d°;文字方向需人工确认" % applied)
# ---------------- 页序 / PDF
order = []
if ed and ed.get("order"):
for v in ed["order"]:
if v in out_meta and out_meta[v].get("page") is not None \
and v not in order:
order.append(v)
for idx in sorted(out_meta.keys()):
if out_meta[idx].get("page") is not None and idx not in order:
order.append(idx)
# plan 已按 ed.order + 源序号排好;只保留真正出页成功的。
order = [i for (i, _s, _m) in plan
if out_meta.get(i, {}).get("page") is not None]
ordered_pages = [out_meta[i]["page"] for i in order]
ordered_canvases = [out_meta[i]["canvas"] for i in order]
@@ -667,6 +767,9 @@ def process(args, t0):
_mark_error(conn, batch_id, res["summary"])
return res
# PDF 落盘成功后再清多余页图:失败时保留上一份,避免两边都不完整。
_clean_pngs(png_dir, pdf_stem, png_n)
# ---------------- 检验
try:
checks = check.inspect_pdf(output, len(ordered_pages),
@@ -771,6 +874,8 @@ def process(args, t0):
len(ordered_pages), len(warnings))
else:
summary = "%d 页已生成" % len(ordered_pages)
if png_paths:
summary += ";原始页图见 out/"
# ---------------- 写 data.db
if use_db:
@@ -821,6 +926,7 @@ def process(args, t0):
"ok": True,
"summary": summary,
"pdf": _rel(session_root, output),
"images": png_paths,
}
except Exception as e:
+31 -12
View File
@@ -131,6 +131,9 @@ body{display:flex;flex-direction:column;height:100%;height:100dvh}
.hint{color:#6f8098;font-size:11px;margin:12px 0 0}
#warnings div{margin-top:4px;line-height:1.45}
/* 空状态(无审核数据):只剩白色标题条可用,编辑区/底栏不显示 */
body.is-empty .top,body.is-empty .footbar,body.is-empty #prevwrap{display:none}
#toast{position:fixed;left:50%;bottom:calc(20px + env(safe-area-inset-bottom));
transform:translateX(-50%);background:rgba(24,34,50,.96);color:#e8edf5;
padding:9px 16px;border-radius:99px;font-size:13px;opacity:0;pointer-events:none;
@@ -187,14 +190,14 @@ body{display:flex;flex-direction:column;height:100%;height:100dvh}
<div class="h" id="h2"></div>
<div class="h" id="h3"></div>
<canvas id="loupe"></canvas>
<button class="regen" type="button" style="display:none">重新生成 PDF</button>
<button class="regen" type="button" style="display:none">重新生成</button>
</div>
<div id="prevwrap">
<div class="pbadge mtag">校正预览</div>
<div class="pbadge" id="pvPage">1/1</div>
<div class="box" id="pbox"><canvas id="preview"></canvas></div>
<button class="regen" type="button" style="display:none">重新生成 PDF</button>
<button class="regen" type="button" style="display:none">重新生成</button>
</div>
<div class="footbar" id="footbar">
@@ -356,16 +359,16 @@ function loadBatch() {
}
function showEmpty(msg) {
document.body.classList.add("is-empty");
var st = document.getElementById("stage");
if (st) {
st.innerHTML = "";
var d = document.createElement("div");
d.style.cssText = "padding:40px;text-align:center;color:#8a93a5;font-size:14px;line-height:1.7";
d.style.cssText = "padding:40px 28px;text-align:center;color:#8a93a5;font-size:14px;" +
"line-height:1.8;max-width:520px;margin:0 auto";
d.textContent = msg;
st.appendChild(d);
}
var foot = document.getElementById("name");
if (foot) foot.textContent = msg;
}
function loadSaved() {
@@ -825,7 +828,7 @@ function setBusy(on) {
var bs = document.querySelectorAll(".regen");
for (var i = 0; i < bs.length; i++) {
bs[i].disabled = on;
bs[i].textContent = on ? "生成中…" : "重新生成 PDF";
bs[i].textContent = on ? "生成中…" : "重新生成";
}
}
@@ -837,7 +840,7 @@ function updateActions() {
var bs = document.querySelectorAll(".regen");
for (var i = 0; i < bs.length; i++) {
bs[i].style.display = dirty ? "inline-flex" : "none";
if (!S.busy) bs[i].textContent = "重新生成 PDF";
if (!S.busy) bs[i].textContent = "重新生成";
}
}
@@ -1012,10 +1015,6 @@ function boot() {
var regens = document.querySelectorAll(".regen");
for (var i = 0; i < regens.length; i++) regens[i].onclick = applyChanges;
document.getElementById("back").onclick = function(){
location.href = TASK ? ("/?s=" + encodeURIComponent(TASK)) : "/";
};
document.getElementById("pdf").onclick = downloadPdf;
document.getElementById("rot").onclick = function(){
if (S.busy) return;
@@ -1047,12 +1046,32 @@ function boot() {
updateActions();
}
// 顶栏在任何加载结果下都要能用:返回会话的 X 在空状态/加载失败时也得生效,
// 所以绑定放在 start() 里(boot 只在加载成功后跑)。
function bindTop() {
var back = document.getElementById("back");
if (back) back.onclick = function(){
location.href = TASK ? ("/?s=" + encodeURIComponent(TASK)) : "/";
};
var pdf = document.getElementById("pdf");
if (pdf) { pdf.disabled = true; pdf.onclick = downloadPdf; }
}
function start() {
bindTop();
loadBatch().then(function(){
loadSaved();
boot();
}).catch(function(e){
showEmpty("加载审核批次失败:" + (e && e.message || e));
var m = String(e && e.message || e);
// visit_url 是通用地址:没跑过本技能的会话、data.db 被删的会话都可能被打开
if (/no such table/i.test(m)) {
m = "这个会话还没有审核数据:可能还没生成过 PDF,或 data.db 被删了。" +
"回到对话让 AI 重新生成一次。";
} else {
m = "加载审核批次失败:" + m;
}
showEmpty(m);
});
}
+1 -1
View File
@@ -1,6 +1,6 @@
---
name: image-process
description: 图像处理(Pillow)。查看图片信息、格式转换、缩放、裁剪、压缩、文字水印、九宫格切片、多图拼图。仅做确定性图像处理,不做 AI 生成/修图
description: 普通图片/截图的确定性编辑(Pillow):查看信息、转格式、缩放、裁剪、压缩、加水印、九宫格切片、多图拼图
input_schema:
type: object
properties:
+1 -1
View File
@@ -50,7 +50,7 @@ agent-core 的 `wechat_bindings` 表;扫码二维码呈现在 agent-core 的 W
## 部署
```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 agent-core # core 带 WXBOT_URL/WXBOT_TOKEN 重建(compose 检测到 env 变化自动 recreate)
```