5 Commits
Author SHA1 Message Date
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
15 changed files with 912 additions and 529 deletions
+3
View File
@@ -18,6 +18,9 @@ AUTH_SECRET=change-me-openssl-rand-hex-32
# agent-core 映射到宿主机的端口(默认 8090),改这里就不用动 docker-compose.yml # agent-core 映射到宿主机的端口(默认 8090),改这里就不用动 docker-compose.yml
# AGENT_PORT=8090 # AGENT_PORT=8090
# agent-core 拼接 /transcribe 的基地址(默认内网 mcp_asr)。填外网地址即可把语音识别放到另一台机器,
# 写成空值(ASR_URL=)则关闭语音输入。
# ASR_URL=http://mcp_asr:3000
# ---- 仅调试:临时把对应 MCP 服务映射到宿主机端口(默认注释掉;改完记得注释回去)---- # ---- 仅调试:临时把对应 MCP 服务映射到宿主机端口(默认注释掉;改完记得注释回去)----
# WEB_SEARCH_PORT=8081 # WEB_SEARCH_PORT=8081
+3 -2
View File
@@ -83,8 +83,9 @@ flowchart TD
### 环境变量(接线全靠根 `.env` + compose) ### 环境变量(接线全靠根 `.env` + compose)
`AGENT_CONFIG`、`PORT`、`EXECUTOR_URL`、`EXECUTOR_TOKEN`、`WXBOT_URL`、`WXBOT_TOKEN`、 `AGENT_CONFIG`、`PORT`、`EXECUTOR_URL`、`EXECUTOR_TOKEN`、`WXBOT_URL`、`WXBOT_TOKEN`、
`ASR_URL`、`ASR_API_KEY`、`VIRTUAL_HOST`、`PREVIEW_PROXIES`、`EXECUTOR_LOG_LEVEL`、`WXBOT_LOG_LEVEL`。 `ASR_URL`、`VIRTUAL_HOST`、`PREVIEW_PROXIES`、`EXECUTOR_LOG_LEVEL`、`WXBOT_LOG_LEVEL`、`ASR_LOG_LEVEL`。
密钥生成:`./scripts/init.sh`(幂等,重跑不掉登录态)。 密钥生成:`./scripts/init.sh`(幂等,重跑不掉登录态)。语音识别的上游 key/base/model 不在 env,
写在 `config.yml` 的 `mcp_servers[name=asr].headers`(容器不存平台密钥)。
## 三条主链路 ## 三条主链路
+33 -16
View File
@@ -60,9 +60,9 @@ PUBLIC_IP=1.2.3.4 \
脚本会生成: 脚本会生成:
- `.env`:`EXECUTOR_TOKEN`、`WXBOT_TOKEN`、`AGENT_PORT` 等部署变量。 - `.env`:`EXECUTOR_TOKEN`、`WXBOT_TOKEN`、`AGENT_PORT` 等部署变量。
- `config.yml`:模型平台、登录账号、MCP 服务、公网前缀。 - `config.yml`:模型平台、登录账号、`web_search`、公网前缀。
`image_task` / `video_task` 两个 MCP 服务复用 `BIGMODEL_KEY`(智谱与 BigModel 是同一个 key);未配置 `BIGMODEL_KEY` 时它们以 `mode: disable` 写入配置。 脚本只自动启用**模型平台**与 `web_search`。`image_task` / `video_task` / `asr` 需要各自的上游 key,脚本不替它猜平台、也不复用模型平台的 key——它们以**注释模板**写进 `mcp_servers`(url 与 header 名已填好),填上 key 后取消注释并重启 core 即生效。
`AUTH_USER` / `AUTH_PASSWORD` 不传时默认是 `admin` / `admin`,首次部署务必改掉。 `AUTH_USER` / `AUTH_PASSWORD` 不传时默认是 `admin` / `admin`,首次部署务必改掉。
@@ -95,24 +95,41 @@ http://<服务器 IP>:<AGENT_PORT>
### 4. 同栈 MCP 服务 ### 4. 同栈 MCP 服务
`init.sh` 默认把仓库内 `mcp/` 的服务写进 `config.yml`: `init.sh` 只自动启用 `web_search`;其余三个需要上游 key 的服务以**注释模板**写入(url 与 header 名已填好),填 key 后取消注释再重启 core 即生效:
```yaml ```yaml
mcp_servers: mcp_servers:
- name: web_search - name: web_search
url: "http://mcp_web_search:3000/" url: "http://mcp_web_search:3000/"
- name: image_task
url: "http://mcp_image_task:3000/mcp" # - name: image_task
- name: video_task # url: "http://mcp_image_task:3000/mcp"
url: "http://mcp_video_task:3000/mcp" # headers:
- name: asr # Authorization: Bearer <upstream-api-key>
url: "http://mcp_asr:3000/mcp" # X-Image-Task-Base-Url: "zhipu" # 或任意 OpenAI 兼容网关地址
mode: skill # X-Image-Task-Model: "CogView-4"
# mode: skill
# - name: video_task
# url: "http://mcp_video_task:3000/mcp"
# headers:
# Authorization: Bearer <zhipu-api-key>
# mode: skill
# - name: asr
# url: "http://mcp_asr:3000/mcp"
# headers:
# Authorization: Bearer <key> # 免鉴权的自建服务可省
# X-ASR-Base-Url: "https://<host>/v1"
# X-ASR-Model: "whisper-1"
# mode: skill
``` ```
`web_search` / `image_task` / `video_task` / `asr` 与 core 由同一个根 `docker-compose.yml` 启动,没有先后顺序,也不占宿主机端口。工具说明、header 覆盖项与调试方式见 [mcp/README.md](mcp/README.md)。 `web_search` / `image_task` / `video_task` / `asr` 四个容器与 core 由同一个根 `docker-compose.yml` 启动(与是否写进配置无关),没有先后顺序,也不占宿主机端口。工具说明、header 覆盖项与调试方式见 [mcp/README.md](mcp/README.md)。
语音输入(H5 输入框里说话)走的是另一条路:客户端录音 → `POST /api/asr/transcribe` → `mcp_asr` 的 `/transcribe`,**不经过模型、不消耗 token**,结果插入输入框可编辑。客户端录音契约(Android 套壳原生桥 / 浏览器 MediaRecorder)见 [docs/voice-input.md](docs/voice-input.md);`ASR_URL` 置空即整体关闭。 `ASR_URL`(在 `.env` 里覆盖)是 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);`ASR_URL` 置空、或删掉 `asr` 那段,即整体关闭。
`mcp_asr` 自己**不存任何平台密钥**:上游 key / base_url / model 都由 core 从这里那段 `asr.headers` 随请求带进去,换平台只改 YAML(不用重建镜像、不用动 `.env`),也不预设任何厂商。
接入栈外的 MCP 服务:在设置页添加 `url` / `headers`,或在 `config.yml` 的 `mcp_servers` 追加一项。服务不可达时 core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。 接入栈外的 MCP 服务:在设置页添加 `url` / `headers`,或在 `config.yml` 的 `mcp_servers` 追加一项。服务不可达时 core 只在启动日志里告警,不影响 Web 主流程,但对应工具不会下发给模型。
@@ -244,8 +261,8 @@ platforms:
| `PORT` | core 监听端口,容器内 `8090` | | `PORT` | core 监听端口,容器内 `8090` |
| `EXECUTOR_URL` | `agent-executor` 地址;空则命令在 core 进程内本地执行,仅适合开发 | | `EXECUTOR_URL` | `agent-executor` 地址;空则命令在 core 进程内本地执行,仅适合开发 |
| `EXECUTOR_TOKEN` | core ↔ executor 的 Bearer token,两侧同值 | | `EXECUTOR_TOKEN` | core ↔ executor 的 Bearer token,两侧同值 |
| `ASR_URL` | `mcp_asr` 地址(compose 为 `http://mcp_asr:3000`);置空则语音输入关闭 | | `ASR_URL` | core 拼接 `/transcribe` 的基地址(默认 `http://mcp_asr:3000`)。可填外网地址把 `mcp_asr` 放到另一台机器;写成空值则语音输入关闭 |
| `ASR_API_KEY` / `ASR_API_BASE` / `ASR_MODEL` | `mcp_asr` 的上游语音识别密钥与地址(默认智谱 `glm-asr`) | | `ASR_LOG_LEVEL` | `mcp_asr` 日志等级 |
| `WXBOT_URL` | wxbot 地址;置空则微信功能整体关闭 | | `WXBOT_URL` | wxbot 地址;置空则微信功能整体关闭 |
| `WXBOT_TOKEN` | core ↔ wxbot 的共享 token | | `WXBOT_TOKEN` | core ↔ wxbot 的共享 token |
| `VIRTUAL_HOST` | 设置后 `public_link.base_url` 强制取 `https://<第一个域名>` | | `VIRTUAL_HOST` | 设置后 `public_link.base_url` 强制取 `https://<第一个域名>` |
@@ -415,8 +432,8 @@ curl -s http://127.0.0.1:8090/api/health
|---|---| |---|---|
| 启动时报 `network agent-mcp-net has active endpoints` | 旧的双仓库部署残留:先停旧的 mcp 仓库(`docker compose down`),再 `up` 本栈 | | 启动时报 `network agent-mcp-net has active endpoints` | 旧的双仓库部署残留:先停旧的 mcp 仓库(`docker compose down`),再 `up` 本栈 |
| 套壳 App 填了服务器地址仍连不上 | 先 `curl <地址>/api/health` 看是否返回 `service:agent-core`;再查 Android 9+ 默认禁止明文 HTTP(需 `usesCleartextTraffic`)与 https 自签证书 | | 套壳 App 填了服务器地址仍连不上 | 先 `curl <地址>/api/health` 看是否返回 `service:agent-core`;再查 Android 9+ 默认禁止明文 HTTP(需 `usesCleartextTraffic`)与 https 自签证书 |
| 麦克风按钮不显示 | `ASR_URL` 为空(未部署 `mcp_asr`);或浏览器以 `http://<IP>` 访问且没有原生录音桥(非安全上下文开不了麦,见 `docs/voice-input.md`) | | 麦克风按钮不显示 | `ASR_URL` 为空(未部署 `mcp_asr`);或 `config.yml` 的 `mcp_servers` 里没有启用的 `asr` 段 / 该段缺 `X-ASR-Base-Url`(`GET /api/asr/status` 会返回 `reason`);或浏览器以 `http://<IP>` 访问且没有原生录音桥(非安全上下文开不了麦,见 `docs/voice-input.md`) |
| 点麦克风提示「语音识别服务不可用」 | `mcp_asr` 未起来或 `ASR_API_KEY` 为空:`docker compose logs --tail=50 mcp_asr` | | 点麦克风提示「语音识别服务不可用」 | `mcp_asr` 未起来(`docker compose logs --tail=50 mcp_asr`);或 `config.yml` 的 `asr.headers` 缺 `X-ASR-Base-Url` / `X-ASR-Model` |
| `config.yml` 变成目录 | 启动前文件不存在,Docker 自动建了同名目录;停容器、删目录、放入配置文件 | | `config.yml` 变成目录 | 启动前文件不存在,Docker 自动建了同名目录;停容器、删目录、放入配置文件 |
| 没有可用模型 | `platforms` 为空或模型全部禁用;在设置页添加后重启 | | 没有可用模型 | `platforms` 为空或模型全部禁用;在设置页添加后重启 |
| 创建会话报「无可用模型」 | 模型池为空,或指定模型所在平台没有 key | | 创建会话报「无可用模型」 | 模型池为空,或指定模型所在平台没有 key |
+1 -1
View File
@@ -266,7 +266,7 @@ preview-proxy.earlyGuard
express.static(public) express.static(public)
/api/sessions ×4 ← sessions / messages / files / skill-run(通用执行面) /api/sessions ×4 ← sessions / messages / files / skill-run(通用执行面)
/api/skills /api/skills
/api/asr ← 语音识别代理:/transcribe 走登录态;ASR_URL 空则 503 /api/asr ← 语音识别代理:/transcribe 走登录态;ASR_URL 空或配置里无可用 asr 段则 503
/api/config ← requireAdmin /api/config ← requireAdmin
/api/platforms /api/platforms
/api/system ← /restart 需 admin,其余登录即可 /api/system ← /restart 需 admin,其余登录即可
+8 -1
View File
@@ -84,10 +84,17 @@ auth: # users 留空 = 不启用登
# disable=不连接、不发现。旧字段 enable 已废弃;mode: silent 已移除(改用 skill),写进配置会启动报错。 # disable=不连接、不发现。旧字段 enable 已废弃;mode: silent 已移除(改用 skill),写进配置会启动报错。
# #
# 语音识别(mcp/asr)建议用 skill:转写音频是低频能力,不必把 schema 塞进每轮请求。 # 语音识别(mcp/asr)建议用 skill:转写音频是低频能力,不必把 schema 塞进每轮请求。
# 上游参数(key / base_url / model)由 core 随请求带给 mcp_asr,容器自己不存密钥,
# 也不预设任何平台——任何 OpenAI 兼容的 /audio/transcriptions 都行。免鉴权的自建服务可省 Authorization。
# - name: asr # - name: asr
# url: "http://mcp_asr:3000/mcp" # url: "http://mcp_asr:3000/mcp"
# headers:
# Authorization: Bearer <key>
# X-ASR-Base-Url: "https://<host>/v1"
# X-ASR-Model: "whisper-1"
# mode: skill # mode: skill
# 注意:输入框里的语音输入走的是 core 的 /api/asr(由 compose 的 ASR_URL 接线),不经这个工具,也不消耗 token。 # 注意:输入框里的语音输入走的是 core 的 /api/asr(由 compose 的 ASR_URL 接线),也读这一段的 headers;
# 不经工具、不消耗 token。mode: disable 或删掉这段 = 麦克风入口关闭。
mcp_servers: [] mcp_servers: []
public_link: public_link:
+13 -6
View File
@@ -423,14 +423,14 @@ footer { position: relative; flex: none; padding: 8px 12px calc(10px + env(safe-
/* 录音中给一个极浅底色作反馈(文字同时变成「松开 结束」) */ /* 录音中给一个极浅底色作反馈(文字同时变成「松开 结束」) */
#voice-hold.recording { background: var(--surface); } #voice-hold.recording { background: var(--surface); }
/* 录音期间:输入卡内容整体让位给遮罩(透明渐变不能把按钮/文字透出来) */ /* 录音期间:输入卡内容整体让位给遮罩(遮罩不再透光,按钮/文字留着会和提示叠字) */
body.voice-active .input-shell { border-color: transparent; box-shadow: none; } body.voice-active .input-shell { border-color: transparent; box-shadow: none; }
body.voice-active .input-shell > *:not(#voice-overlay) { visibility: hidden; } body.voice-active .input-shell > *:not(#voice-overlay) { visibility: hidden; }
body.voice-active .attach-chips { visibility: hidden; } body.voice-active .attach-chips { visibility: hidden; }
body.voice-active .scroll-bottom-btn { display: none; } body.voice-active .scroll-bottom-btn { display: none; }
/* 按住说话的遮罩:左右贴屏幕两边;底部一直铺到屏幕底(含 footer 的 10px 内边距与安全区), /* 按住说话的遮罩:左右贴屏幕两边;底部一直铺到屏幕底(含 footer 的 10px 内边距与安全区),
向上多铺 72px 让渐变淡出。 向上多铺 72px 把输入卡上方那一条会话流也盖住。
声波中心对齐「按住 说话」那一行:padding-bottom 70px + 安全区 = 声波中心对齐「按住 说话」那一行:padding-bottom 70px + 安全区 =
59(声波中心到输入卡底部)+ 11(遮罩底边向下外扩的 1px 边框 + 10px footer 内边距)。 */ 59(声波中心到输入卡底部)+ 11(遮罩底边向下外扩的 1px 边框 + 10px footer 内边距)。 */
#voice-overlay { #voice-overlay {
@@ -442,18 +442,25 @@ body.voice-active .scroll-bottom-btn { display: none; }
display: flex; flex-direction: column; align-items: center; justify-content: flex-end; display: flex; flex-direction: column; align-items: center; justify-content: flex-end;
gap: 20px; gap: 20px;
padding-bottom: calc(70px + env(safe-area-inset-bottom, 0px)); padding-bottom: calc(70px + env(safe-area-inset-bottom, 0px));
/* 极淡的蓝调,从下往上淡出(“几乎看不出来,仔细看才有一层”) */ /* 底色必须是**不透明**的 var(--page):早先只铺一层 9% 蓝渐变,遮罩伸进会话流的那一段
background: linear-gradient(to top, rgba(57, 100, 254, .09), rgba(57, 100, 254, 0)); 会把底下的消息文字透出来,「松手传送」看着就成了半透明。
顶层那 20px 由透明渐变到 --page 只是把上边缘与会话流接上,别把整块都做成渐变。 */
background:
linear-gradient(to top, rgba(57, 100, 254, .09), rgba(57, 100, 254, 0) 70%),
linear-gradient(to bottom, rgba(255, 255, 255, 0), var(--page) 20px);
color: var(--active); color: var(--active);
pointer-events: auto; touch-action: none; pointer-events: auto; touch-action: none;
transition: background .15s linear, color .15s linear; transition: background .15s linear, color .15s linear;
} }
/* 上滑取消态:整体换成极淡的红调,声波/文案同步变红 */ /* 上滑取消态:整体换成极淡的红调,声波/文案同步变红 */
#voice-overlay.cancel { #voice-overlay.cancel {
background: linear-gradient(to top, rgba(192, 57, 43, .09), rgba(192, 57, 43, 0)); background:
linear-gradient(to top, rgba(192, 57, 43, .09), rgba(192, 57, 43, 0) 70%),
linear-gradient(to bottom, rgba(255, 255, 255, 0), var(--page) 20px);
color: #c0392b; color: #c0392b;
} }
.vo-hint { font-size: 13px; line-height: 18px; color: var(--gray); letter-spacing: .2px; } /* 提示文案落在外挂层上,用比 --gray 深一档的中灰:13px 的字在浅灰上发虚 */
.vo-hint { font-size: 13px; line-height: 18px; color: #5f6672; letter-spacing: .2px; }
.vo-wave { display: flex; align-items: center; justify-content: center; gap: 3px; height: 34px; max-width: 100%; } .vo-wave { display: flex; align-items: center; justify-content: center; gap: 3px; height: 34px; max-width: 100%; }
/* 柱子高度用 scaleY 而不是 height:只走合成层,不触发重排 */ /* 柱子高度用 scaleY 而不是 height:只走合成层,不触发重排 */
.vo-wave i { .vo-wave i {
+312 -174
View File
@@ -8,10 +8,12 @@
// · 松手:取消态 → 丢弃 + 轻提示;否则转写后**直接发送** // · 松手:取消态 → 丢弃 + 轻提示;否则转写后**直接发送**
// · 发送键位置变成键盘按钮,点一下回文本模式并聚焦输入框(移动端弹键盘) // · 发送键位置变成键盘按钮,点一下回文本模式并聚焦输入框(移动端弹键盘)
// //
// 录音在客户端:套壳原生桥(http 页面也能用)或 HTTPS 下的 MediaRecorder; // 录音在客户端,两条路,下游是同一套:
// 转写在服务端 mcp_asr(经 core 的 /api/asr 中转)。 // · 套壳原生桥(http 页面也能用):壳把 16k/单声道 PCM 以 ~100ms 分片推给页面。
// 电平:浏览器用 AnalyserNode 算 RMS;套壳上报 onNativeVoiceAmp(原始 getMaxAmplitude)。 // · 浏览器(需 HTTPS):AudioContext + ScriptProcessor 自己采 PCM,降采样到 16k 后约 20ms 一片。
// 归一化/门限/平滑全部在页面侧做,壳不做任何换算。 // 两条路都汇到 pushChunk():判停顿、切段、逐段上传、最后合并发送,只有一份实现。
// 于是大部分识别在说话过程中就做完了,松手通常只剩最后一段要等。
// 电平在页面侧算(PCM 峰值),壳和浏览器都不做任何换算。
// //
// 包在 IIFE 里:前端是共享全局作用域的经典脚本,顶层声明会和其他文件撞名。 // 包在 IIFE 里:前端是共享全局作用域的经典脚本,顶层声明会和其他文件撞名。
@@ -28,11 +30,13 @@
const native = (window.AgentNative && typeof window.AgentNative.startVoice === 'function') const native = (window.AgentNative && typeof window.AgentNative.startVoice === 'function')
? window.AgentNative : null; ? window.AgentNative : null;
const webOk = !!(window.isSecureContext && navigator.mediaDevices const webOk = !!(window.isSecureContext && navigator.mediaDevices
&& typeof navigator.mediaDevices.getUserMedia === 'function' && window.MediaRecorder); && typeof navigator.mediaDevices.getUserMedia === 'function'
&& (window.AudioContext || window.webkitAudioContext));
const MAX_MS = 60000; // 单次录音上限 const MAX_MS = 180000; // 单次录音上限(流式上传后不再受 60s 限制)
const MIN_MS = 500; // 短于这个时长按误触处理,不上传 const MIN_MS = 500; // 短于这个时长按误触处理,不上传
const NO_RESULT_MS = 3000; // 松开后壳迟迟不回音频(比如还在等权限)→ 复位 const FLUSH_MS = 60000; // 松手后等尾段识别完的上限(超过就当失败)
const OUT_RATE = 16000; // 页面内部统一按 16k 处理:VAD 时长与段长上限都按它算
const BAR_COUNT = 45; // 声波柱数(要足够宽,手指按住时两侧仍能看到) const BAR_COUNT = 45; // 声波柱数(要足够宽,手指按住时两侧仍能看到)
// 两端矮、中间高的包络:看起来像一段声波而不是一排等高柱子 // 两端矮、中间高的包络:看起来像一段声波而不是一排等高柱子
@@ -58,12 +62,30 @@
let discard = false; // 本次录音太短/已取消:结果到了也丢掉 let discard = false; // 本次录音太短/已取消:结果到了也丢掉
let recordStartAt = 0; let recordStartAt = 0;
let stopTimer = null; let stopTimer = null;
let hardTimer = null;
let watchdog = null;
let rec = null;
let stream = null; let stream = null;
let chunks = []; // 浏览器采集:ScriptProcessor 直接给 Float32 PCM,这里降到 16k 后喂 pushChunk
let mime = ''; let procNode = null;
let capRate = 0; // AudioContext 的真实采样率(通常 44.1k/48k)
let dsAcc = 0; // 降采样:当前输出周期内的样本和
let dsN = 0;
let dsPhase = 0; // 小数相位,跨分片累计 → 长期不漂移
// 流式:壳推的分片 / 浏览器自己采的分片,都在这里断句后逐段上传
let pcmRate = 16000; // 当前流的采样率(契约要求 16k)
let segChunks = []; // 当前段的 PCM 分片(Int16Array)
let segLen = 0; // 当前段总采样数
let silLen = 0; // 段尾连续静音采样数
let textParts = []; // 各段识别结果(按顺序)
let chain = Promise.resolve(); // 串行上传链:保证拼接顺序 = 说话顺序
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; // 单段上限:连续说话没停顿就硬切(上游单次上限)
// 电平与渲染 // 电平与渲染
let rafId = 0; let rafId = 0;
@@ -71,13 +93,11 @@
let levelCur = 0; let levelCur = 0;
let lastRealLevelAt = 0; let lastRealLevelAt = 0;
let audioCtx = null; let audioCtx = null;
let analyser = null;
let audioBuf = null;
let srcNode = null; let srcNode = null;
function clamp01(v) { return v < 0 ? 0 : v > 1 ? 1 : v; } function clamp01(v) { return v < 0 ? 0 : v > 1 ? 1 : v; }
// 电平归一化的唯一实现:浏览器(RMS)和壳(峰值幅度)都在这里落到 0~1。 // 电平归一化的唯一实现:两条录音路径的 PCM 峰值都在这里落到 0~1。
// 低于 -55dB 视为静音,-5dB 及以上视为满幅;要调灵敏度只改这两个常量。 // 低于 -55dB 视为静音,-5dB 及以上视为满幅;要调灵敏度只改这两个常量。
const LEVEL_FLOOR_DB = -55; const LEVEL_FLOOR_DB = -55;
const LEVEL_RANGE_DB = 50; const LEVEL_RANGE_DB = 50;
@@ -121,22 +141,9 @@
rafId = 0; rafId = 0;
if (!overlay || overlay.classList.contains('hidden')) return; if (!overlay || overlay.classList.contains('hidden')) return;
let animate = false; // 电平只有一个来源:pushChunk() 每收到一片 PCM 就更新 levelTarget。
if (analyser && audioBuf) { // 超过 300ms 没有新数据(授权还没给 / 已经停了)→ 静默停在基线,不假动。
analyser.getFloatTimeDomainData(audioBuf); if (Date.now() - lastRealLevelAt > 300) {
let sum = 0;
for (let i = 0; i < audioBuf.length; i++) sum += audioBuf[i] * audioBuf[i];
const rms = Math.sqrt(sum / audioBuf.length);
const db = 20 * Math.log10(rms + 1e-7); // 静音约 -140,正常说话 -35 ~ -12
levelTarget = dbToLevel(db);
animate = true;
} else if (Date.now() - lastRealLevelAt <= 300) {
animate = true; // 壳刚上报过电平
}
if (!animate) {
// 没有电平来源(壳没实现 onNativeVoiceAmp / AnalyserNode 不可用):
// 静默停在基线,不再空转(也绝不能假动)
levelCur = 0; levelCur = 0;
renderBars(0, false); renderBars(0, false);
return; return;
@@ -148,25 +155,68 @@
rafId = requestAnimationFrame(tickMeter); rafId = requestAnimationFrame(tickMeter);
} }
function attachAnalyser() { // iOS Safari 只允许在用户手势里真正启动 AudioContext;getUserMedia 之后那条异步链已经
if (!stream) return; // 脱离手势,那时才 new AudioContext 有可能一直 suspended(一点声音都采不到)。
try { // 所以在 pointerdown 里先把 ctx 建好并 resume,拿到麦克风后直接复用。
function primeAudioCtx() {
if (audioCtx) return true;
const AC = window.AudioContext || window.webkitAudioContext; const AC = window.AudioContext || window.webkitAudioContext;
if (!AC) return; if (!AC) return false;
try {
audioCtx = new AC(); audioCtx = new AC();
analyser = audioCtx.createAnalyser();
analyser.fftSize = 512;
audioBuf = new Float32Array(analyser.fftSize);
srcNode = audioCtx.createMediaStreamSource(stream);
srcNode.connect(analyser); // 不接 destination,不会回放
if (audioCtx.state === 'suspended') audioCtx.resume(); if (audioCtx.state === 'suspended') audioCtx.resume();
startLoop(); // 之前可能在静默态停掉了循环 return true;
} catch (_) { } catch (_) {
analyser = null; audioCtx = null;
audioBuf = null; return false;
} }
} }
// 浏览器:拿 PCM 只能靠 ScriptProcessor(已标废弃,但 Chrome/Safari/Firefox 都还在,
// 且不需要额外加载文件)。AudioWorklet 要 addModule,异步加载会吞掉开头几个字。
function startCapture() {
if (!stream || !primeAudioCtx()) return false;
try {
capRate = audioCtx.sampleRate || 48000;
dsAcc = 0; dsN = 0; dsPhase = 0;
srcNode = audioCtx.createMediaStreamSource(stream);
procNode = audioCtx.createScriptProcessor(1024, 1, 1);
procNode.onaudioprocess = function (ev) {
const pcm = downsampleTo16k(ev.inputBuffer.getChannelData(0));
if (pcm.length) pushChunk(pcm, OUT_RATE);
};
srcNode.connect(procNode);
// 必须接到 destination 才会被驱动;输出缓冲区不写,所以不会外放
procNode.connect(audioCtx.destination);
if (audioCtx.state === 'suspended') audioCtx.resume();
startLoop();
return true;
} catch (_) {
stopMeter(false);
return false;
}
}
// Float32(任意采样率)→ 16k Int16。按「输出周期内取均值」降采样:既是抽点也能压一点高频,
// 且 dsPhase 跨分片累计,长时间录不会整体越走越快/越慢(整数倍抽取会)。
function downsampleTo16k(input) {
const out = new Int16Array(Math.ceil(input.length * OUT_RATE / capRate) + 1);
let n = 0;
for (let i = 0; i < input.length; i++) {
dsAcc += input[i];
dsN++;
dsPhase += OUT_RATE;
if (dsPhase >= capRate) {
dsPhase -= capRate;
const v = Math.round((dsAcc / dsN) * 32767);
out[n++] = v > 32767 ? 32767 : v < -32768 ? -32768 : v;
dsAcc = 0;
dsN = 0;
}
}
return n === out.length ? out : out.subarray(0, n);
}
function startMeter() { function startMeter() {
stopMeter(false); stopMeter(false);
levelTarget = 0; levelTarget = 0;
@@ -177,9 +227,13 @@
function stopMeter(flatten) { function stopMeter(flatten) {
if (rafId) { cancelAnimationFrame(rafId); rafId = 0; } if (rafId) { cancelAnimationFrame(rafId); rafId = 0; }
if (procNode) {
try { procNode.disconnect(); } catch (_) { /* 已断 */ }
procNode.onaudioprocess = null;
procNode = null;
}
if (srcNode) { try { srcNode.disconnect(); } catch (_) { /* 已断 */ } srcNode = null; } if (srcNode) { try { srcNode.disconnect(); } catch (_) { /* 已断 */ } srcNode = null; }
analyser = null; // 采集节点也挂在这个 ctx 上:关掉它浏览器这边就彻底不再送 PCM 了
audioBuf = null;
if (audioCtx) { try { audioCtx.close(); } catch (_) { /* 已关 */ } audioCtx = null; } if (audioCtx) { try { audioCtx.close(); } catch (_) { /* 已关 */ } audioCtx = null; }
if (flatten !== false) { if (flatten !== false) {
for (let i = 0; i < bars.length; i++) bars[i].style.transform = 'scaleY(.12)'; for (let i = 0; i < bars.length; i++) bars[i].style.transform = 'scaleY(.12)';
@@ -206,9 +260,8 @@
pressing = false; pressing = false;
pressY = 0; pressY = 0;
discard = false; discard = false;
abortStream();
if (stopTimer) { clearTimeout(stopTimer); stopTimer = null; } if (stopTimer) { clearTimeout(stopTimer); stopTimer = null; }
if (hardTimer) { clearTimeout(hardTimer); hardTimer = null; }
if (watchdog) { clearTimeout(watchdog); watchdog = null; }
hold.classList.remove('recording'); hold.classList.remove('recording');
setHoldText('按住 说话'); setHoldText('按住 说话');
hideOverlay(); hideOverlay();
@@ -221,14 +274,6 @@
stream = null; stream = null;
} }
function pickMime() {
const list = ['audio/webm;codecs=opus', 'audio/webm', 'audio/mp4', 'audio/ogg;codecs=opus'];
for (let i = 0; i < list.length; i++) {
try { if (MediaRecorder.isTypeSupported(list[i])) return list[i]; } catch (_) { /* 忽略 */ }
}
return '';
}
// ---------- 模式切换 ---------- // ---------- 模式切换 ----------
function enter() { function enter() {
if (!available || mode) return; if (!available || mode) return;
@@ -262,16 +307,16 @@
showOverlay(); showOverlay();
if (native) { if (native) {
// 原生侧即使要弹权限也先当「已开始」:松开时 stopVoice(),壳若还在等权限会忽略, // 原生侧即使要弹权限也先当「已开始」:页面已经开始收分片,壳真开录后会推数据。
// 由 watchdog 兜底复位(只有首次授权那一次会遇到)。 // 首次授权那一次的分片要等用户点允许才会到,之前的静音不计入。
phase = 'recording'; phase = 'recording';
recordStartAt = Date.now(); recordStartAt = Date.now();
gen++; // 新会话:让上一轮迟到的结果全部失效
streamOn = true;
pcmRate = 16000;
clearSeg();
textParts = [];
stopTimer = setTimeout(finishHold, MAX_MS); stopTimer = setTimeout(finishHold, MAX_MS);
hardTimer = setTimeout(function () {
try { if (native.cancelVoice) native.cancelVoice(); } catch (_) { /* 忽略 */ }
resetUI();
toast('录音超时');
}, MAX_MS + NO_RESULT_MS);
try { try {
native.startVoice(); native.startVoice();
} catch (e) { } catch (e) {
@@ -281,7 +326,9 @@
return; return;
} }
phase = 'arming'; // 等 getUserMedia/MediaRecorder 起来 // 浏览器:先拿麦克风(可能要等用户授权),拿到后 startCapture 开始往里推 PCM
phase = 'arming';
primeAudioCtx(); // 必须在手势里建(见 primeAudioCtx 注释)
startWeb(); startWeb();
} }
@@ -295,46 +342,23 @@
return; return;
} }
if (!pressing) { releaseStream(); resetUI(); return; } // 松开得比授权快 if (!pressing) { releaseStream(); resetUI(); return; } // 松开得比授权快
attachAnalyser(); // 声波接同一路 MediaStream
mime = pickMime();
try {
rec = mime ? new MediaRecorder(stream, { mimeType: mime }) : new MediaRecorder(stream);
} catch (_) {
rec = new MediaRecorder(stream);
mime = rec.mimeType || '';
}
chunks = [];
rec.ondataavailable = function (ev) {
if (ev.data && ev.data.size) chunks.push(ev.data);
};
rec.onstop = function () {
const type = mime || 'audio/webm';
const blob = new Blob(chunks, { type: type });
chunks = [];
rec = null;
releaseStream();
if (discard) { discard = false; resetUI(); toast('说话时间太短'); return; }
upload(blob);
};
rec.onerror = function () {
releaseStream();
resetUI();
toast('录音出错');
};
try {
rec.start();
} catch (e) {
releaseStream();
resetUI();
toast('无法开始录音:' + String((e && e.message) || e));
return;
}
// 与套壳同一套状态,只是换成了「自己采 PCM」而不是「等壳推」
phase = 'recording'; phase = 'recording';
recordStartAt = Date.now(); recordStartAt = Date.now();
gen++;
pcmRate = OUT_RATE;
streamOn = true;
clearSeg();
textParts = [];
if (!startCapture()) {
streamOn = false;
releaseStream();
resetUI();
toast('无法开始录音:当前浏览器采不到音频');
return;
}
stopTimer = setTimeout(finishHold, MAX_MS); stopTimer = setTimeout(finishHold, MAX_MS);
hardTimer = setTimeout(resetUI, MAX_MS + NO_RESULT_MS);
} }
// 松手:结束录音(太短则丢弃) // 松手:结束录音(太短则丢弃)
@@ -351,6 +375,18 @@
setOverlayMode(discard ? 'send' : 'busy'); setOverlayMode(discard ? 'send' : 'busy');
stopMeter(); stopMeter();
if (discard) {
abortStream();
releaseStream();
nativeStop(false); // 只停采集,不用管壳知不知道“被丢弃”(页面已经不再收分片)
resetUI();
toast('说话时间太短');
return;
}
// 两条路收口完全一样:把不足一个停顿的尾巴发走(纯静音的尾巴不发),再等所有段回来。
// 大部分段在说话过程中已经识别完了,这里通常只等最后一段。
flushTail();
if (native) { if (native) {
try { try {
native.stopVoice(); native.stopVoice();
@@ -359,57 +395,29 @@
toast('结束录音失败:' + String((e && e.message) || e)); toast('结束录音失败:' + String((e && e.message) || e));
return; return;
} }
// 壳若因为权限弹窗没有真正开录,stopVoice() 会被忽略、结果不会回来 } else {
watchdog = setTimeout(function () { releaseStream(); // 采集节点已经由上面的 stopMeter() 拆掉了
if (phase !== 'busy') return; }
try { if (native.cancelVoice) native.cancelVoice(); } catch (_) { /* 忽略 */ } waitFlush();
resetUI();
}, NO_RESULT_MS);
return;
} }
// 让壳停止采集:优先 cancelVoice(语义明确),壳没实现时退回 stopVoice——
// 否则麦克风会在壳侧一直开着(页面这边已经不再收分片了,但录音还在跑)。
function nativeStop(cancel) {
if (!native) return;
try { try {
if (rec && rec.state !== 'inactive') rec.stop(); if (cancel && native.cancelVoice) native.cancelVoice();
else { releaseStream(); resetUI(); } else if (native.stopVoice) native.stopVoice();
} catch (_) { } catch (_) { /* 已停 */ }
releaseStream();
resetUI();
}
} }
// 放弃本次录音(切模式 / 离开页面 / 上滑取消 / 壳回调 cancelled) // 放弃本次录音(切模式 / 离开页面 / 上滑取消 / 壳回调 cancelled)
function cancelHold() { function cancelHold() {
if (phase === 'idle') return; if (phase === 'idle') return;
const r = rec; abortStream(); // 丢弃已发在途的结果,也不碰输入框
rec = null; releaseStream(); // 浏览器:停麦克风轨道(采集节点由 resetUI → stopMeter 拆)
chunks = []; nativeStop(true);
if (r) { r.onstop = null; r.onerror = null; }
releaseStream();
resetUI(); resetUI();
try {
if (r && r.state !== 'inactive') r.stop();
else if (native && native.cancelVoice) native.cancelVoice();
} catch (_) { /* 已停 */ }
}
// ---------- 上传 + 自动发送 ----------
function upload(blob) {
if (!blob || !blob.size) { resetUI(); toast('没有录到声音'); return; }
phase = 'busy';
setOverlayMode('busy');
req('POST', '/api/asr/transcribe', blob, true, 120000)
.then(function (r) {
const text = String((r && r.text) || '').replace(/\s+/g, ' ').trim();
// 先收遮罩再做后续:toast 固定在 bottom:96px,遮罩还在时弹出来会压住声波
resetUI();
if (!text) { toast('没有识别到内容'); return; }
ta.value = text;
send();
})
.catch(function (e) {
resetUI();
toast('语音识别失败:' + String((e && e.message) || e));
});
} }
// ---------- 按住 / 滑动 / 松开 ---------- // ---------- 按住 / 滑动 / 松开 ----------
@@ -478,43 +486,171 @@
// 录音中离开页面:释放麦克风 // 录音中离开页面:释放麦克风
window.addEventListener('pagehide', cancelHold); window.addEventListener('pagehide', cancelHold);
// ---------- 原生桥回调(契约见 docs/voice-input.md) ---------- // ---------- PCM 处理(两条录音路径共用) ----------
// 实时幅度:套壳每 ~100ms 上报一次 MediaRecorder.getMaxAmplitude() 的**原始值**(0~32767)。 // 壳每 ~100ms 推一片 16bit/单声道小端 PCM;浏览器自己采。采样率、分片大小、门限全部不在别处算。
// 换算、门限、平滑全部在页面侧做——规则只存在这一份,壳不要做任何数学。 function b64ToI16(b64) {
function onNativeAmp(raw) {
if (!native) return;
const amp = Number(raw);
if (!isFinite(amp)) return;
lastRealLevelAt = Date.now();
if (amp <= 0) {
levelTarget = 0;
} else {
const db = 20 * Math.log10(Math.min(amp, 32767) / 32767);
levelTarget = dbToLevel(db);
}
startLoop(); // 静默态下循环已停,下一帧数据到了再启
}
window.onNativeVoiceAmp = onNativeAmp;
window.onNativeVoiceLevel = onNativeAmp; // 旧名兼容:同样按原始幅度解释
window.onNativeVoiceResult = function (b64, mimeType) {
if (phase !== 'busy' && phase !== 'recording') return;
if (watchdog) { clearTimeout(watchdog); watchdog = null; }
if (discard) { discard = false; resetUI(); toast('说话时间太短'); return; }
try {
const bin = atob(String(b64 || '')); const bin = atob(String(b64 || ''));
const arr = new Uint8Array(bin.length); const n = bin.length >> 1;
for (let i = 0; i < bin.length; i++) arr[i] = bin.charCodeAt(i); const out = new Int16Array(n);
upload(new Blob([arr], { type: mimeType || 'audio/mp4' })); for (let i = 0; i < n; i++) out[i] = (bin.charCodeAt(i * 2 + 1) << 8) | bin.charCodeAt(i * 2);
} catch (_) { return out;
resetUI();
toast('语音数据解析失败');
} }
// 这一片 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 = []; segLen = 0; silLen = 0; }
// 把当前段的前 n 个采样作为一段发出去(太短当噪声丢掉)。
// 注意:必须在 clearSeg() 之前调,takeSeg 要读 segChunks。
function emitSegment(n) {
if (n < pcmRate * VAD_MIN_SPEECH_SEC) return;
emit(encodeWav(takeSeg(n), pcmRate));
}
// 串行上传:一段没回来不发下一段(2 vCPU 上并发只会互相拖慢,而且顺序也没法保证)
function emit(blob) {
const my = gen;
chain = chain.then(function () {
if (my !== gen) 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.push(t);
})
.catch(function () { /* 单段失败不连坐,其余段照常出字 */ });
});
}
// 拼接各段:中文直接相连;两侧都是西文字母/数字时补一个空格,
// 否则英文被切开后会粘成 "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 = [];
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);
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();
}
}
// 壳每 ~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);
chain = chain.then(function () {
if (my !== gen) return;
if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
const text = joinText(textParts);
// 先收遮罩再做后续:toast 固定在 bottom:96px,遮罩还在时弹出来会压住声波
resetUI();
if (!text) { toast('没有识别到内容'); return; }
ta.value = text;
send();
});
}
window.onNativeVoiceState = function (s) { window.onNativeVoiceState = function (s) {
if (!native || s !== 'recording' || phase !== 'recording') return; if (!native || s !== 'recording' || phase !== 'recording') return;
// 真正开录:60s 与「太短」判定从这一刻算(首次授权弹窗的时间不算) // 真正开录:180s 与「太短」判定从这一刻算(首次授权弹窗的时间不算)
recordStartAt = Date.now(); recordStartAt = Date.now();
if (stopTimer) clearTimeout(stopTimer); if (stopTimer) clearTimeout(stopTimer);
stopTimer = setTimeout(finishHold, MAX_MS); stopTimer = setTimeout(finishHold, MAX_MS);
@@ -523,6 +659,7 @@
window.onNativeVoiceError = function (code, message) { window.onNativeVoiceError = function (code, message) {
if (phase === 'idle') return; if (phase === 'idle') return;
abortStream();
resetUI(); resetUI();
// 生命周期打断(切后台/换页)属预期,不弹提示 // 生命周期打断(切后台/换页)属预期,不弹提示
if (code === 'cancelled' || code === 'canceled') return; if (code === 'cancelled' || code === 'canceled') return;
@@ -544,10 +681,11 @@
console.info('[voice] 语音入口未启用:没有 window.AgentNative,且当前不是安全上下文(需 HTTPS,或由套壳 App 注入原生桥)'); console.info('[voice] 语音入口未启用:没有 window.AgentNative,且当前不是安全上下文(需 HTTPS,或由套壳 App 注入原生桥)');
return; return;
} }
// 服务端没接线(core 的 ASR_URL 为空)就不给入口;探测失败则照常启用 // 服务端没接线(core 的 ASR_URL 为空,或 config.yml 里没有可用的 asr 段)就不给入口;
// 探测失败则照常启用(不因一次探测失败就永久藏掉入口)。
req('GET', '/api/asr/status').then(function (s) { req('GET', '/api/asr/status').then(function (s) {
if (s && s.enabled === false) { if (s && s.enabled === false) {
console.info('[voice] 语音入口未启用:服务端未配置语音识别(agent-core 的 ASR_URL 为空)'); console.info('[voice] 语音入口未启用:' + ((s && s.reason) || '服务端未配置语音识别'));
return; return;
} }
available = true; available = true;
+60 -5
View File
@@ -4,8 +4,20 @@
// 一个宿主端口都不占(它自身没有鉴权,暴露即被白嫖)。对外唯一的入口仍是 core, // 一个宿主端口都不占(它自身没有鉴权,暴露即被白嫖)。对外唯一的入口仍是 core,
// 鉴权沿用全局登录态(auth.middleware 已挂在 /api 之前)。 // 鉴权沿用全局登录态(auth.middleware 已挂在 /api 之前)。
// //
// 开关:core 的 ASR_URL 为空 = 未部署语音识别,本路由一律 503,前端据此不显示麦克风。 // 上游参数全部来自 config.yml 的 mcp_servers 里那条 asr(与 image_task 完全同构):
// - name: asr
// url: "http://mcp_asr:3000/mcp"
// headers:
// Authorization: Bearer <key> # 免鉴权的自建服务可省
// X-ASR-Base-Url: "https://.../v1"
// X-ASR-Model: "whisper-1"
// mcp_asr 自己不存任何平台密钥(容器 env 一条都不读),所以要换 ASR 平台只改这个文件对应的
// YAML 段 + 重启 core,不碰 .env、不重建镜像。头名与 mcp/asr/src/server.js 的常量一一对应。
//
// 开关:ASR_URL 为空(未部署 mcp_asr)或配置里没有可用的 asr 段 = 关闭,本路由一律 503,
// 前端据此不显示麦克风。ASR_URL 留在 env 是部署接线(容器地址),不属于平台密钥。
const express = require('express'); const express = require('express');
const engine = require('../engine');
const log = require('../log'); const log = require('../log');
const router = express.Router(); const router = express.Router();
@@ -15,6 +27,39 @@ const ASR_URL = String(process.env.ASR_URL || '').trim().replace(/\/+$/, '');
const MAX_BYTES = 20 * 1024 * 1024; const MAX_BYTES = 20 * 1024 * 1024;
const TIMEOUT_MS = 120000; const TIMEOUT_MS = 120000;
// 只转发 ASR 约定的三个头:config.yml 里该条目的其它 header 与本服务无关,没必要透传进内网。
const PASS_HEADERS = ['authorization', 'x-asr-base-url', 'x-asr-model'];
// 取当前生效的 asr 配置段。配置冷加载(engine 里那份是启动时解析的),所以这里读到的就是
// 运行中的值;重启前改 config.yml 不会影响已生效的这份,与其它配置项一致。
function asrEntry() {
let cfg = null;
try { cfg = engine.getConfig(); } catch (_) { cfg = null; } // 启动早期 engine 还没拿到 cfg
const list = (cfg && cfg.mcp_servers) || [];
const s = list.find(function (x) { return x && x.name === 'asr'; });
// mode: disable = 明确关闭(与模型侧工具同一开关:关了就别给麦克风)
if (!s || s.mode === 'disable') return null;
return s;
}
function asrHeaders() {
const s = asrEntry();
if (!s) return null;
const out = {};
for (const [k, v] of Object.entries(s.headers || {})) {
if (PASS_HEADERS.indexOf(String(k).toLowerCase()) >= 0) out[k] = String(v);
}
return out;
}
// 有没有真的能转写:缺 base_url 就转不了(model 也缺的话 mcp_asr 会给出更具体的报错)。
// 只判 base_url 是为了让「配了但漏填 model」在探测阶段仍显示入口,用户点了能拿到明确提示。
function hasUpstream(headers) {
return Object.keys(headers || {}).some(function (k) {
return k.toLowerCase() === 'x-asr-base-url' && String(headers[k] || '').trim();
});
}
// 只接音频二进制。全局 express.json(2mb) 只解析 application/json,两者不冲突。 // 只接音频二进制。全局 express.json(2mb) 只解析 application/json,两者不冲突。
// 注意 WebView 可能发 audio/mp4、audio/webm;codecs=opus,统一按 audio/* 接。 // 注意 WebView 可能发 audio/mp4、audio/webm;codecs=opus,统一按 audio/* 接。
const rawAudio = express.raw({ const rawAudio = express.raw({
@@ -24,12 +69,22 @@ const rawAudio = express.raw({
// 前端可用性探测(按钮是否显示)。不碰网络,纯看接线。 // 前端可用性探测(按钮是否显示)。不碰网络,纯看接线。
router.get('/status', function (req, res) { router.get('/status', function (req, res) {
res.json({ enabled: !!ASR_URL, max_bytes: MAX_BYTES }); if (!ASR_URL) return res.json({ enabled: false, reason: 'core 未设置 ASR_URL' });
if (!asrEntry()) return res.json({ enabled: false, reason: 'config.yml 的 mcp_servers 里没有启用的 asr' });
const headers = asrHeaders();
if (!hasUpstream(headers)) {
return res.json({ enabled: false, reason: 'config.yml 的 asr.headers 缺 X-ASR-Base-Url' });
}
res.json({ enabled: true, max_bytes: MAX_BYTES });
}); });
router.post('/transcribe', rawAudio, async function (req, res) { router.post('/transcribe', rawAudio, async function (req, res) {
if (!ASR_URL) { if (!ASR_URL) {
return res.status(503).json({ error: '语音识别未配置(core 未设置 ASR_URL)' }); return res.status(503).json({ error: '语音识别未部署(core 未设置 ASR_URL)' });
}
const headers = asrHeaders();
if (!headers || !hasUpstream(headers)) {
return res.status(503).json({ error: '语音识别未配置上游(config.yml 的 asr.headers 需设 X-ASR-Base-Url / X-ASR-Model)' });
} }
const buf = req.body; const buf = req.body;
if (!Buffer.isBuffer(buf) || !buf.length) { if (!Buffer.isBuffer(buf) || !buf.length) {
@@ -38,7 +93,7 @@ router.post('/transcribe', rawAudio, async function (req, res) {
try { try {
const r = await fetch(ASR_URL + '/transcribe', { const r = await fetch(ASR_URL + '/transcribe', {
method: 'POST', method: 'POST',
headers: { 'Content-Type': req.headers['content-type'] || 'application/octet-stream' }, headers: Object.assign({ 'Content-Type': req.headers['content-type'] || 'application/octet-stream' }, headers),
body: buf, body: buf,
signal: AbortSignal.timeout(TIMEOUT_MS), signal: AbortSignal.timeout(TIMEOUT_MS),
}); });
@@ -52,7 +107,7 @@ router.post('/transcribe', rawAudio, async function (req, res) {
const code = r.status >= 400 && r.status < 500 ? r.status : 502; const code = r.status >= 400 && r.status < 500 ? r.status : 502;
return res.status(code).json({ error: msg }); return res.status(code).json({ error: msg });
} }
// 原样透传 ASR 的 {text, ms, backend} // 原样透传 ASR 的 {text, ms, model}
res.type('application/json').send(text); res.type('application/json').send(text);
} catch (e) { } catch (e) {
log.warn('asr', '调用 ASR 服务失败:' + String(e && e.message || e)); log.warn('asr', '调用 ASR 服务失败:' + String(e && e.message || e));
+1 -1
View File
@@ -72,7 +72,7 @@ app.use('/api/sessions', require('./routes/files'));
app.use('/api/sessions', require('./routes/skill-run')); app.use('/api/sessions', require('./routes/skill-run'));
app.use('/api/skills', require('./routes/skills')); app.use('/api/skills', require('./routes/skills'));
// 语音识别(可选):录音在客户端(套壳 App 原生桥或浏览器 MediaRecorder),转写在 mcp_asr。 // 语音识别(可选):录音在客户端(套壳 App 原生桥或浏览器 MediaRecorder),转写在 mcp_asr。
// ASR_URL 为空时接口回 503,前端据此不显示麦克风按钮(见 routes/asr.js)。 // ASR_URL 为空、或 config.yml 里没有启用的 asr 段时接口回 503,前端据此不显示麦克风按钮(见 routes/asr.js)。
app.use('/api/asr', require('./routes/asr')); app.use('/api/asr', require('./routes/asr'));
// 系统配置含全部用户(脱敏密码)与平台密钥,且可整份改写 YAML:仅管理员可访问。 // 系统配置含全部用户(脱敏密码)与平台密钥,且可整份改写 YAML:仅管理员可访问。
app.use('/api/config', auth.requireAdmin, require('./routes/config')); app.use('/api/config', auth.requireAdmin, require('./routes/config'));
+9 -6
View File
@@ -24,8 +24,12 @@ services:
# 微信接入 # 微信接入
- WXBOT_URL=http://agent-wxbot:8093 - WXBOT_URL=http://agent-wxbot:8093
- WXBOT_TOKEN=${WXBOT_TOKEN:?WXBOT_TOKEN not set - run scripts/init.sh} - WXBOT_TOKEN=${WXBOT_TOKEN:?WXBOT_TOKEN not set - run scripts/init.sh}
# 语音识别(可选):mcp_asr 的内网地址。置空 = 不启用,前端不显示麦克风按钮。 # 语音识别(可选):core 拼 /transcribe 的基地址。默认指内网 mcp_asr;
- ASR_URL=http://mcp_asr:3000 # 也可以填外网地址(例如 mcp_asr 跑在另一台机器上:http://<ip>:3000)。
# 注意:那台服务要能接受 Authorization / X-ASR-Base-Url / X-ASR-Model 三个 header,
# 且 core 能出网访问它(https 自签证书会因证书校验失败)。
# 想关掉语音输入:在 .env 里写 ASR_URL= (空值,照样不发默认值)或删掉 config.yml 的 asr 段。
- ASR_URL=${ASR_URL-http://mcp_asr:3000}
networks: networks:
- agent-mcp-net - agent-mcp-net
@@ -212,7 +216,9 @@ services:
# 同进程两个入口(见 mcp/asr/src/server.js 头注释): # 同进程两个入口(见 mcp/asr/src/server.js 头注释):
# POST /transcribe ← agent-core 的 /api/asr 转发(输入框,低延迟、不经过模型) # POST /transcribe ← agent-core 的 /api/asr 转发(输入框,低延迟、不经过模型)
# POST /mcp ← 模型的 MCP 工具 transcribe_audio({url})(转写任务目录里的音频) # POST /mcp ← 模型的 MCP 工具 transcribe_audio({url})(转写任务目录里的音频)
# 转写走上游 OpenAI 兼容的 /audio/transcriptions(默认智谱 glm-asr,换平台改 ASR_API_* 即可)。 # 本容器不存任何平台密钥:上游走 OpenAI 兼容的 /audio/transcriptions,key / base_url / model
# 全部由调用方随请求 header 带入(core 从 config.yml 的 mcp_servers 里 asr.headers 取)。
# 换 ASR 平台 → 改 config.yml 后重启 core,本服务不用动、也不用重建镜像。
mcp_asr: mcp_asr:
build: ./mcp/asr build: ./mcp/asr
container_name: mcp_asr container_name: mcp_asr
@@ -224,9 +230,6 @@ services:
retries: 5 retries: 5
start_period: 5s start_period: 5s
environment: environment:
- ASR_API_KEY=${ASR_API_KEY:-}
- ASR_API_BASE=${ASR_API_BASE:-https://open.bigmodel.cn/api/paas/v4}
- ASR_MODEL=${ASR_MODEL:-glm-asr}
- ASR_LOG_LEVEL=${ASR_LOG_LEVEL:-info} - ASR_LOG_LEVEL=${ASR_LOG_LEVEL:-info}
- TZ=Asia/Shanghai - TZ=Asia/Shanghai
networks: networks:
+180 -189
View File
@@ -1,36 +1,48 @@
# 语音输入:客户端录音契约 # 语音输入:客户端录音契约
链路是「按住说话 → 客户端录音 → `POST /api/asr/transcribe` → 转写结果**自动发送**」。 链路是「按住说话 → 端上持续送 PCM → 页面按停顿切段并逐段转写 → 松手后一次性写入输入框并**自动发送**」。
服务端只收音频字节,不关心是谁录的。`public/js/voice.js` 按能力自己选录音方式:
| 页面环境 | 录音方式 | 说明 | `public/js/voice.js` 按能力自己选录音方式:
|---|---|---|
| Android 套壳 App(WebView) | **原生录音 + JS 桥** | WebView 没有 Web Speech API;http 页面也允许 `getUserMedia` 的替代路径 |
| 浏览器 / PWA(HTTPS) | `MediaRecorder` | 标准 `getUserMedia`,不用改壳 |
| 纯浏览器(`http://<IP>`) | 不可用 | 非安全上下文,浏览器拒绝开麦 |
**发送键的四种状态**(`sessions.js` 的 `updateSendBtn` 决定): | 页面环境 | 录音方式 | 实时断句 | 说明 |
|---|---|---|---|
| Android 套壳 App(WebView) | **原生 `AudioRecord` + JS 桥流式推 PCM** | ✅ | WebView 没有 Web Speech API;`http://` 页面也能用 |
| 浏览器 / PWA(HTTPS) | **`AudioContext` + `ScriptProcessor` 采 PCM** | ✅ | 降采样到 16k 后与套壳走**完全同一套** VAD/切段/上传 |
| 纯浏览器(`http://<IP>`) | 不可用 | — | 非安全上下文,浏览器拒绝开麦 |
| `data-state` | 什么时候 | 点击行为 | **为什么必须要流式**:录音只在松手后才上传的话,识别要等整段录完 + 整段识别,长语音尤其慢。
|---|---|---| 流式之后,说话过程中的每个停顿都会立刻切段上传,**松手时通常只剩最后一段要等**。
| `stop` | 生成中且输入框为空 | 停止当前回合(优先级最高,不被语音入口顶掉) |
| `voice` | 空闲、无文字无附件、且语音可用 | 进入语音模式 |
| `keyboard` | 已在语音模式 | 回键盘模式,聚焦输入框(移动端弹键盘) |
| `send` | 其余情况 | 发送 |
「语音可用」= ①有录音能力(原生桥,或安全上下文下的 `MediaRecorder`)②`GET /api/asr/status` 两条录音路径只在「PCM 从哪来」上不同,进到 `pushChunk(pcm, rate)` 之后一模一样:
返回 `enabled !== false`。所以**套壳 App 里即使页面是 `http://`,只要桥注入成功,麦克风入口照样出现**; 电平、静音门限、断句、逐段上传、最后合并发送,代码只有一份。
纯浏览器 `http://<IP>` 不会出现(非安全上下文,浏览器禁止开麦)。
语音模式下输入框被 `#voice-hold` 取代(只有居中文字,无按钮外观):按住后整块输入区被
**全宽遮罩**盖住(`#voice-overlay`,向左右各扩到屏幕边缘),遮罩里是「实时电平声波 + 提示文案」。
手指上滑进入文案区域 → 取消态(声波与文案变红,文案改为「松开取消」),滑回下方恢复;
松手时取消态则**直接丢弃**(不弹 toast——它会盖住声波,取消本身已经有变色/文案反馈),否则转写并直接发送。
松手后遮罩保持到识别结束,文案换成「正在识别…」。发送键变成键盘按钮。
--- ---
## 一、桥的契约 ## 一、交互与页面行为(壳只需要知道这些)
1. 用户按住 `#voice-hold` → 页面开始录音(套壳调 `startVoice()`,浏览器自己 `getUserMedia`),同时把整块输入区换成全宽遮罩(实时声波 + 提示文案)。
2. 壳推 / 浏览器采的 PCM 进来后,页面自己判停顿(连续静音 ≥0.5s)→ 立即 POST 该段 → 结果攒在内存里。
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 停顿与 25s 段长都是按 16k 估算的。
- iOS Safari:`AudioContext` 必须在手势里创建/resume;`await getUserMedia` 之后已脱离手势,
所以按下(`pointerdown`)时就先把 ctx 建好,拿到麦克风后复用。
- 浏览器只在安全上下文开麦:`http://<IP>` 下麦克风按钮不会出现,只有 HTTPS 域名(或套壳壳内)可用。
---
## 二、桥的契约
### 1. 注入时机 ### 1. 注入时机
@@ -49,69 +61,66 @@ webView.loadUrl(startUrl);
```js ```js
window.AgentNative = { window.AgentNative = {
startVoice(), // 开始录音;失败/拒绝通过 onNativeVoiceError 回报 startVoice(), // 开始录音(可能先弹权限);失败通过 onNativeVoiceError 回报
stopVoice(), // 结束录音;结果通过 onNativeVoiceResult 回传 stopVoice(), // 结束录音;**没有返回值**,页面自己等已发出的分段的识别结果
cancelVoice() // 放弃本次录音(无回调;页面自己已经把状态复位了) cancelVoice() // 放弃本次录音(无回调;页面自己已经把状态复位了)
}; };
``` ```
**线程模型**:这三个方法都跑在 WebView 的 JavaBridge 子线程上,**不是主线程**。
`MediaRecorder` 的所有调用必须收敛到主线程:方法入口先 `mainHandler.post(...)`,
读临时文件 + Base64 才放回子线程。
### 3. 回调(页面定义,壳调用) ### 3. 回调(页面定义,壳调用)
```js ```js
window.onNativeVoiceResult(base64, mime) // mime 例:'audio/mp4' window.onNativeVoiceChunk(base64Pcm, sampleRate) // 必需:流式 PCM 分片
window.onNativeVoiceError(code, message) // 见下方错误码表 window.onNativeVoiceState('recording') // 建议:真正开始录时调一次
window.onNativeVoiceState('recording') // 建议实现:真正开始录时调一次 window.onNativeVoiceError(code, message) // 出错/被打断时调
window.onNativeVoiceAmp(amp) // 建议实现:原始幅度 0~32767,驱动遮罩里的声波
``` ```
- `onNativeVoiceAmp(amp)`:壳只上报 `MediaRecorder.getMaxAmplitude()` 的**原始值** #### `onNativeVoiceChunk(base64Pcm, sampleRate)`
(0~32767,主线程每 100ms 一次),**不要做任何换算**。dB 归一化、静音门限、快攻慢放平滑
全部在页面侧——浏览器(RMS)和壳(峰值)两条路的规则只存在一份。
旧名 `onNativeVoiceLevel` 仍作为别名接受(同样按原始幅度解释)。
不实现也能用:声波静默停在基线上(不空转、不假动)。
JS 侧还要自己做快攻慢放平滑,壳不需要平滑。
- `onNativeVoiceState('recording')`:**按住说话的时长判定依赖它**。页面用这个回调重置
「60 秒上限」和「太短丢弃」的起点,避免首次授权弹窗的时间被算进录音。不实现也不会崩:
页面按点击时刻计时,代价是首次授权那一次会被当成「太短」丢弃(用户再按一次即可)。
- 页面收到 `onNativeVoiceResult` 后会直接发送消息(不经过输入框、不可编辑)。
- 所有回调都必须在**主线程**调 `webView.evaluateJavascript`。
- 字符串一律用 `JSONObject.quote(...)` 拼,不要手写 `'` 转义——异常 message 里可能有
`\`、换行、U+2028,会把整段脚本打断。
### 4. 状态机与错误码 - 内容:**裸 PCM**,`16bit 小端 / 单声道 / 16kHz`(小端是 `AudioRecord` 的原始字节序,直接转 Base64 即可)。
- 节奏:约 **100ms 一片**(1600 采样 = 3200 字节,Base64 后约 4.3KB)。50~200ms 都可接受。
- 壳**不做任何数学**:不判静音、不切段、不算音量。dB 归一化、静音门限、停顿判定、切段
全部在页面侧(`voice.js`),规则只存在一份。
- 声波也是页面用这片 PCM 的峰值算的——**不再需要** `onNativeVoiceAmp` / `getMaxAmplitude`。
- 页面已经复位(用户松手/取消)后再来的分片会被忽略,壳不用刻意等待。
壳侧状态:`IDLE → (WAITING_PERMISSION) → RECORDING → ENCODING → IDLE`。 #### `onNativeVoiceState('recording')`
`startVoice` 只在 `IDLE` 生效,`stopVoice` 只在 `RECORDING` 生效(其余静默忽略)。
**按住时长判定依赖它**:页面用这个回调重置「180 秒上限」与「太短丢弃」的起点,
避免首次授权弹窗的时间被算进录音。不实现也不会崩,但首次授权那一次可能被当成「太短」丢掉。
#### `onNativeVoiceError(code, message)`
| code | 触发时机 | 页面表现 | | code | 触发时机 | 页面表现 |
|---|---|---| |---|---|---|
| `no_permission` | 用户拒绝 / 取消授权弹窗 | toast「需要麦克风权限」 | | `no_permission` | 用户拒绝 / 取消授权弹窗 | toast「录音失败:…」 |
| `start_failed` | `prepare()` / `start()` 抛异常(含回退 MIC 后仍失败) | toast | | `start_failed` | `AudioRecord` 初始化/启动失败(含 16k 不支持) | toast |
| `too_short` | `stop()` 抛异常(录音 < ~1s) | toast「说话时间太短,请按住再说」,**不上传** | | `read_failed` | 采集线程读失败 | toast |
| `read_failed` | 读临时文件失败 | toast | | `forbidden` | 非白名单 URL / 应用不在前台 | toast |
| `cancelled` | 生命周期打断(切后台 / 换页) | **静默复位,不弹提示** | | `cancelled` | 生命周期打断(切后台 / 换页) | **静默复位,不弹提示** |
| 其他未知 code | — | toast 里显示 `message`,没有就显示 code | | 其他未知 code | — | toast 里显示 `message`,没有就显示 code |
**取消语义**:页面在 `stopVoice()` 之后会一直等结果(直到点击后 90 秒的硬超时), **取消语义**:页面在 `stopVoice()` 之后只等自己发出的分段请求(不再等壳回音频),
所以壳在生命周期里取消录音时**必须**回调 `onNativeVoiceError('cancelled','')`, 所以壳在生命周期里中断录音时**仍建议**回调 `onNativeVoiceError('cancelled','')`,
否则按钮会卡在「录音中」。`cancelVoice()` 是页面主动发起的,壳不需要回报。 让页面立刻收遮罩,不必干等。`cancelVoice()` 是页面主动发起的,壳不需要回报。
### 5. 体积与时序 ### 4. 体积与时序
- 16kHz / 32kbps / 单声道 AAC:60 秒 ≈ **240KB**,Base64 后 ≈ **320KB**。 - 每秒 32KB 原始 PCM(16k × 2 字节),Base64 后约 43KB/s;一片 100ms 约 4.3KB。
- `evaluateJavascript` 走 Binder,单次约 1MB 上限;320KB 安全,但**不要再延长单次时长**。 `evaluateJavascript` 走 Binder,单次约 1MB 上限,4.3KB 远低于上限。
真要 2 分钟以上,改成按段回传或本地 HTTP 回传。 - 一次 60 秒的听写 = 约 600 次桥调用、2.6MB 字符串。Android WebView 完全吃得住,
- 松开后页面最多等 3 秒拿音频(等不到就复位,覆盖「壳还在等权限」的情况); 但**不要**把分片缩到 20ms 以下(调用次数会翻 5 倍,收益为零)。
拿到后上传+识别,正常 1~2 秒。 - 页面侧开销:每片扫一遍峰值(1600 个 short),可忽略。
- 按住时间 < 500ms 视为误触:页面直接丢弃,不上传;壳自己的 `too_short` 是第二道保险。
### 5. 壳侧状态机
`IDLE → (WAITING_PERMISSION) → RECORDING → IDLE`
`startVoice` 只在 `IDLE` 生效,`stopVoice` / `cancelVoice` 在非 `RECORDING` 时静默忽略。
--- ---
## 二、Java 参考骨架(纯 Java / minSdk 21) ## 三、Java 参考骨架(纯 Java / minSdk 21)
只演示契约要求的部分;`UrlPolicy`、埋点、通知等按各自工程接。 只演示契约要求的部分;`UrlPolicy`、埋点、通知等按各自工程接。
@@ -121,32 +130,21 @@ window.onNativeVoiceAmp(amp) // 建议实现:原始幅度 0~3276
public final class VoiceBridge { public final class VoiceBridge {
private static final int REQ_MIC = 1001; private static final int REQ_MIC = 1001;
private static final long MAX_MS = 60_000; private static final int RATE = 16000; // 契约固定:16k / 单声道 / 16bit
private static final int CHUNK_MS = 100; // 每 100ms 推一片
private static final long MAX_MS = 180_000; // 页面也会自己停,这里是兜底
private enum State { IDLE, WAITING_PERMISSION, RECORDING, ENCODING } private enum State { IDLE, WAITING_PERMISSION, RECORDING }
private final Activity activity; private final Activity activity;
private final WebView webView; private final WebView webView;
private final Handler main = new Handler(Looper.getMainLooper()); private final Handler main = new Handler(Looper.getMainLooper());
private final Runnable autoStop = this::stopOnMain; private final Runnable autoStop = this::stopOnMain;
// 实时电平:每 100ms 读一次 getMaxAmplitude() 交给页面画声波
private static final long LEVEL_INTERVAL_MS = 100;
private final Runnable levelTick = this::tickLevel;
private void tickLevel() {
MediaRecorder r = recorder;
if (state != State.RECORDING || r == null) return;
int amp = 0;
try { amp = r.getMaxAmplitude(); } catch (Exception ignored) { }
// 原始幅度直接给页面:dB 归一化/门限/平滑全在 JS,壳不做任何数学
js("window.onNativeVoiceAmp && window.onNativeVoiceAmp(" + amp + ")");
main.postDelayed(levelTick, LEVEL_INTERVAL_MS);
}
private State state = State.IDLE; private State state = State.IDLE;
private MediaRecorder recorder; private AudioRecord record;
private File file; private Thread worker;
private volatile boolean running;
public VoiceBridge(Activity activity, WebView webView) { public VoiceBridge(Activity activity, WebView webView) {
this.activity = activity; this.activity = activity;
@@ -159,12 +157,10 @@ public final class VoiceBridge {
@JavascriptInterface public void cancelVoice() { main.post(() -> cancelOnMain(true)); } @JavascriptInterface public void cancelVoice() { main.post(() -> cancelOnMain(true)); }
// ---- 生命周期:由 Activity / WebViewClient 调用 ---- // ---- 生命周期:由 Activity / WebViewClient 调用 ----
// 注意:只取消真正在录/在编码的状态。授权弹窗期间某些 ROM 会走 onPause, // 只在真正录音时取消。授权弹窗期间某些 ROM 会走 onPause,
// 那里如果一并取消,首次授权的两段式流程就断了。 // 那里一并取消的话,首次授权的两段式流程就断了。
public void onPause() { public void onPause() {
main.post(() -> { main.post(() -> { if (state == State.RECORDING) cancelOnMain(true); });
if (state == State.RECORDING || state == State.ENCODING) cancelOnMain(true);
});
} }
public void onDestroy() { main.post(() -> cancelOnMain(false)); } public void onDestroy() { main.post(() -> cancelOnMain(false)); }
public void onPageChanged() { main.post(() -> cancelOnMain(true)); } public void onPageChanged() { main.post(() -> cancelOnMain(true)); }
@@ -177,7 +173,7 @@ public final class VoiceBridge {
boolean ok = grantResults != null && grantResults.length > 0 boolean ok = grantResults != null && grantResults.length > 0
&& grantResults[0] == PackageManager.PERMISSION_GRANTED; && grantResults[0] == PackageManager.PERMISSION_GRANTED;
if (!ok) { fail("no_permission", "需要麦克风权限"); return; } if (!ok) { fail("no_permission", "需要麦克风权限"); return; }
beginRecording(); // 授权后直接开录(体验优先,不要求用户再点一次) beginRecording(); // 授权后直接开录,不让用户再点一次
}); });
} }
@@ -198,105 +194,96 @@ public final class VoiceBridge {
beginRecording(); beginRecording();
} }
@SuppressLint("NewApi")
private void beginRecording() { private void beginRecording() {
int minBuf = AudioRecord.getMinBufferSize(
RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
if (minBuf <= 0) { fail("start_failed", "设备不支持 16kHz 录音"); return; }
// VOICE_RECOGNITION 关掉 AGC/降噪,对 ASR 更友好;个别机型不支持则回退 MIC // VOICE_RECOGNITION 关掉 AGC/降噪,对 ASR 更友好;个别机型不支持则回退 MIC
final AudioRecord r = createRecord(minBuf);
if (r == null) { fail("start_failed", "无法开始录音"); return; }
record = r;
running = true;
state = State.RECORDING;
main.postDelayed(autoStop, MAX_MS);
final int samplesPerChunk = RATE * CHUNK_MS / 1000; // 1600
worker = new Thread(() -> captureLoop(r, samplesPerChunk), "voice-capture");
worker.start();
// 让页面的 180s 从“真的开始录”算(授权弹窗的时间不算)
js("window.onNativeVoiceState && window.onNativeVoiceState('recording')");
}
private AudioRecord createRecord(int minBuf) {
int[] sources = {MediaRecorder.AudioSource.VOICE_RECOGNITION, int[] sources = {MediaRecorder.AudioSource.VOICE_RECOGNITION,
MediaRecorder.AudioSource.MIC}; MediaRecorder.AudioSource.MIC};
for (int source : sources) { for (int source : sources) {
File f = null;
MediaRecorder r = null;
try { try {
f = File.createTempFile("voice", ".m4a", activity.getCacheDir()); AudioRecord t = new AudioRecord(source, RATE, AudioFormat.CHANNEL_IN_MONO,
r = Build.VERSION.SDK_INT >= 31 AudioFormat.ENCODING_PCM_16BIT, Math.max(minBuf * 2, 8192));
? new MediaRecorder(activity) // 无参构造在 API 31 起废弃 if (t.getState() == AudioRecord.STATE_INITIALIZED) return t;
: new MediaRecorder(); t.release();
r.setAudioSource(source); } catch (Exception ignored) { /* 换下一个 source */ }
r.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4); }
r.setAudioEncoder(MediaRecorder.AudioEncoder.AAC); return null;
r.setAudioSamplingRate(16000); }
r.setAudioEncodingBitRate(32000);
r.setAudioChannels(1);
r.setOutputFile(f.getAbsolutePath());
r.prepare();
r.start();
recorder = r; /** 采集线程:阻塞 read → 小端字节 → Base64 → 推给页面。不判静音、不切段。 */
file = f; private void captureLoop(AudioRecord r, int samplesPerChunk) {
state = State.RECORDING; short[] pcm = new short[samplesPerChunk];
main.postDelayed(autoStop, MAX_MS); byte[] bytes = new byte[samplesPerChunk * 2];
main.postDelayed(levelTick, LEVEL_INTERVAL_MS); try {
// 让页面的 60s 从“真的开始录”算(授权弹窗的时间不算) r.startRecording();
js("window.onNativeVoiceState && window.onNativeVoiceState('recording')"); while (running) {
// 不要再额外弹原生 Toast:页面遮罩已经给了全部反馈,弹窗会压住声波 int n = r.read(pcm, 0, pcm.length);
return; if (n <= 0) continue;
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) { } catch (Exception e) {
// 局部变量释放:失败时 recorder 字段还没赋值,releaseQuietly() 管不到它 if (running) fail("read_failed", "录音中断:" + e.getMessage());
if (r != null) { } finally {
try { r.stop(); } catch (Exception ignored) { } try { r.stop(); } catch (Exception ignored) { }
try { r.release(); } catch (Exception ignored) { } try { r.release(); } catch (Exception ignored) { }
} }
delete(f);
}
}
state = State.IDLE;
fail("start_failed", "无法开始录音");
} }
private void stopOnMain() { private void stopOnMain() {
if (state != State.RECORDING) return; if (state != State.RECORDING) return;
main.removeCallbacks(autoStop); main.removeCallbacks(autoStop);
main.removeCallbacks(levelTick); // 停止上报电平 stopCapture();
state = State.ENCODING;
MediaRecorder r = recorder;
File f = file;
recorder = null;
file = null;
boolean stopped = true;
try { r.stop(); } catch (RuntimeException e) { stopped = false; } // 太短会抛
try { r.release(); } catch (Exception ignored) { }
if (!stopped) {
delete(f);
state = State.IDLE; state = State.IDLE;
fail("too_short", "没有录到声音"); // 注意:这里不再回传音频,识别分段已经在录音过程中发完了
return;
}
new Thread(() -> {
try {
byte[] bytes = readAll(f);
String b64 = Base64.encodeToString(bytes, Base64.NO_WRAP);
delete(f);
main.post(() -> {
state = State.IDLE;
js("window.onNativeVoiceResult(" + JSONObject.quote(b64) + ",'audio/mp4')");
});
} catch (Exception e) {
delete(f);
main.post(() -> { state = State.IDLE; fail("read_failed", "读取录音失败"); });
}
}, "voice-encode").start();
} }
/** notify=true:页面在等结果,必须回 cancelled 让它复位;onDestroy 时页面已走,不必回。 */ /** notify=true:页面在等收尾,回 cancelled 让它立刻收遮罩;onDestroy 时页面已走,不必回。 */
private void cancelOnMain(boolean notify) { private void cancelOnMain(boolean notify) {
main.removeCallbacks(autoStop); main.removeCallbacks(autoStop);
main.removeCallbacks(levelTick);
boolean wasActive = state != State.IDLE; boolean wasActive = state != State.IDLE;
releaseQuietly(); stopCapture();
delete(file);
file = null;
state = State.IDLE; state = State.IDLE;
if (notify && wasActive) js("window.onNativeVoiceError('cancelled','')"); if (notify && wasActive) js("window.onNativeVoiceError('cancelled','')");
} }
private void releaseQuietly() { private void stopCapture() {
if (recorder == null) return; running = false;
try { recorder.stop(); } catch (Exception ignored) { } AudioRecord r = record;
try { recorder.release(); } catch (Exception ignored) { } record = null;
recorder = null; if (r != null) {
// 打断阻塞中的 read();stop/release 由采集线程的 finally 做,
// 避免跨线程操作同一个 AudioRecord
try { r.stop(); } catch (Exception ignored) { }
}
Thread w = worker;
worker = null;
if (w != null) w.interrupt();
} }
private void fail(String code, String message) { private void fail(String code, String message) {
@@ -307,20 +294,6 @@ public final class VoiceBridge {
private void js(String script) { private void js(String script) {
webView.post(() -> webView.evaluateJavascript(script, null)); webView.post(() -> webView.evaluateJavascript(script, null));
} }
private static byte[] readAll(File f) throws Exception {
try (FileInputStream in = new FileInputStream(f);
ByteArrayOutputStream out = new ByteArrayOutputStream()) {
byte[] buf = new byte[8192];
int n;
while ((n = in.read(buf)) > 0) out.write(buf, 0, n);
return out.toByteArray();
}
}
private static void delete(File f) {
if (f != null) f.delete();
}
} }
``` ```
@@ -339,54 +312,72 @@ webView.addJavascriptInterface(new VoiceBridge(this, webView), "AgentNative");
// WebViewClient.onPageStarted:URL 变了就 bridge.onPageChanged() // WebViewClient.onPageStarted:URL 变了就 bridge.onPageChanged()
``` ```
**和上一版(MediaRecorder)的差别,别照抄旧代码**:
- 不再有 `MediaRecorder`、临时文件、`onNativeVoiceResult`、`getMaxAmplitude`、60 秒自动停止。
- `stopVoice()` 之后没有任何回传动作,页面会自己等已发出的分段请求。
- 必须在**采集线程**里 `read()`,不能读在主线程;`AudioRecord` 的 stop/release 只由该线程的
`finally` 执行(主线程只调 `stop()` 打断阻塞)。
- 个别设备 16k 不支持时:`getMinBufferSize` 会返回负数。此时要么回滚到 44.1k 并在壳里做
2 点平均降采样到 16k(多几十行),要么直接 `start_failed`。**不要**改推 44.1k 给页面——
页面只按 16k 估算时长与切段。
--- ---
## 三、壳侧必须同步的清单 ## 四、壳侧必须同步的清单
| 项 | 内容 | | 项 | 内容 |
|---|---| |---|---|
| `AndroidManifest.xml` | `<uses-permission android:name="android.permission.RECORD_AUDIO" />` | | `AndroidManifest.xml` | `<uses-permission android:name="android.permission.RECORD_AUDIO" />` |
| `proguard-rules.pro` | 保留桥:`-keepclassmembers class * { @android.webkit.JavascriptInterface <methods>; }`,并删掉「本项目未使用 addJavascriptInterface」的注释 | | `proguard-rules.pro` | 保留桥:`-keepclassmembers class * { @android.webkit.JavascriptInterface <methods>; }`,并删掉「本项目未使用 addJavascriptInterface」的注释 |
| README 安全表 | 从「不使用 JS 桥」改为「仅暴露语音桥:三个无参方法,无文件/存储读取能力」 | | README 安全表 | 「不使用 JS 桥」→「仅暴露语音桥:三个无参方法,无文件/存储读取能力」 |
| README 权限行 | 「只有 INTERNET」→「INTERNET + RECORD_AUDIO」 | | README 权限行 | 「只有 INTERNET」→「INTERNET + RECORD_AUDIO」 |
| 桥的防护 | `UrlPolicy.isAllowed(webView.getUrl())` + `activity.hasWindowFocus()` + 单实例状态机;建议再加一个原生 Toast 提示录音已开始(外部 CDN 脚本与页面同源,能调桥,但用户至少看得见) | | 桥的防护 | `UrlPolicy.isAllowed(webView.getUrl())` + `activity.hasWindowFocus()` + 单实例状态机 |
| 页面导航 | `onPageStarted` 且 URL 变化时取消,避免 base64 打到新页面的回调上 | | 页面导航 | `onPageStarted` 且 URL 变化时取消;分片打到新页面会污染新一轮的缓冲 |
| 录音上限 | 壳侧兜底 180s(页面也会在 180s 时主动 `stopVoice()`),不要做成 60s |
> 触摸时间戳门槛(最近 N 秒内有触摸才允许录音)能进一步防静默录音,但会让无障碍操作不可用, > 触摸时间戳门槛(最近 N 秒内有触摸才允许录音)能进一步防静默录音,但会让无障碍操作不可用,
> 不建议默认开。 > 不建议默认开。
--- ---
## 四、iOS(以后若有 WKWebView 壳) ## 五、iOS(以后若有 WKWebView 壳)
契约相同,换注入方式: 契约相同,只是数据源换成 `AVAudioEngine` 的 tap(`installTapOnBus` 直接把
`AVAudioPCMBuffer` 转成 16bit 小端 PCM,每 ~100ms 一次):
```swift ```swift
// 注入:WKUserScript(source: "window.AgentNative = {...}", injectionTime: .atDocumentStart, ...) // 注入:WKUserScript(source: "window.AgentNative = {...}", injectionTime: .atDocumentStart, ...)
// 录音:AVAudioRecorder(16kHz / 单声道 / m4a) // 推流:webView.evaluateJavaScript("window.onNativeVoiceChunk('\(b64)',16000)")
// 回传:webView.evaluateJavaScript("window.onNativeVoiceResult('\(b64)','audio/mp4')") // 结束:stopVoice() 停 tap 即可,不需要回传文件
``` ```
`Info.plist` 需要 `NSMicrophoneUsageDescription`。 `Info.plist` 需要 `NSMicrophoneUsageDescription`。
## 五、服务端接口 ---
## 六、服务端接口
```http ```http
POST /api/asr/transcribe POST /api/asr/transcribe
Content-Type: audio/mp4 # 或 audio/webm / audio/wav / application/octet-stream Content-Type: audio/wav # 两条路都是 wav:页面自己加的 44 字节头(16k/单声道/16bit)
Cookie: <登录态> # 与页面同一份 HttpOnly cookie Cookie: <登录态> # 与页面同一份 HttpOnly cookie
<音频二进制> <音频二进制>
``` ```
```json ```json
{ "text": "打开今天的日报", "ms": 842, "model": "glm-asr" } { "text": "打开今天的日报", "ms": 842, "model": "whisper-1" }
``` ```
- 上限 20MB,超时 120s;识别失败返回 `{"error": "..."}`(前端直接 toast 出来)。 - 上限 20MB,超时 120s;识别失败返回 `{"error": "..."}`(前端直接 toast 出来)。
- `GET /api/asr/status` → `{"enabled": true}`:`ASR_URL` 没接线时为 `false`。 - 一次「按住说话」会变成 **多次** 请求(每个停顿一次,套壳与浏览器都是)。页面串行发送,保证拼接顺序。
- 单段失败不影响其他段(页面侧吞掉单段错误,继续等下一段);全部失败才提示。
- 服务端只做**超长兜底**:一次请求超过 25s 才切,且切点尽量落在停顿处(端上已经按停顿切好了,
这里多数请求根本不会触发切分)。参数见 `mcp/asr/README.md`。
- `GET /api/asr/status` → `{"enabled": true}`;未接线时 `{"enabled": false, "reason": "..."}`。
## 六、为什么不用浏览器的 Web Speech API ## 七、为什么不用浏览器的 Web Speech API
- Android WebView 没有实现 `SpeechRecognition`;iOS WKWebView 同样不可用(只有 Safari 有)。 - Android WebView 没有实现 `SpeechRecognition`;iOS WKWebView 同样不可用(只有 Safari 有)。
- 桌面 Chrome 的识别走 Google 服务,国内基本报 `network`。 - 桌面 Chrome 的识别走 Google 服务,国内基本报 `network`。
+10 -3
View File
@@ -35,6 +35,10 @@ mcp_servers:
# 可选:语音转写(低频,建议 skill 模式,不占每轮工具表) # 可选:语音转写(低频,建议 skill 模式,不占每轮工具表)
- name: asr - name: asr
url: "http://mcp_asr:3000/mcp" url: "http://mcp_asr:3000/mcp"
headers:
Authorization: Bearer <key> # 免鉴权的自建服务可省
X-ASR-Base-Url: "https://<host>/v1"
X-ASR-Model: "whisper-1"
mode: skill mode: skill
``` ```
@@ -47,8 +51,11 @@ mcp_servers:
`image_task` 用对应上游(智谱或 OpenAI 兼容网关)的 token,上游地址与模型分别由 `image_task` 用对应上游(智谱或 OpenAI 兼容网关)的 token,上游地址与模型分别由
`X-Image-Task-Base-Url` / `X-Image-Task-Model` 指定。所以这两个服务不用配任何密钥。 `X-Image-Task-Base-Url` / `X-Image-Task-Model` 指定。所以这两个服务不用配任何密钥。
`asr` 是例外:输入框那条路(`agent-core` → `POST /transcribe`)不经过 MCP 调用,拿不到 header, `asr` 同理:上游的 key / base_url / model 全部由调用方随请求 header 带入
所以它自己的上游密钥由容器 env `ASR_API_KEY` 提供(写在根 `.env`,已 gitignore,不挂给其他容器)。 (`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` 都能用。
### 调试端口 ### 调试端口
@@ -86,7 +93,7 @@ AI 把拿到的 URL 当 image_url 交给 video_task:3000/mcp
| `mcp_web_search` | 无 | 服务端无鉴权,**永远不要映射出去**(会被白嫖搜索额度);agent 走内网访问 | | `mcp_web_search` | 无 | 服务端无鉴权,**永远不要映射出去**(会被白嫖搜索额度);agent 走内网访问 |
| `mcp_image_task` | 无 | token 由调用方自带,暴露后可被拿去消耗你的上游图片额度 | | `mcp_image_task` | 无 | token 由调用方自带,暴露后可被拿去消耗你的上游图片额度 |
| `mcp_video_task` | 无 | 它需要的公开临时 URL 由 agent 侧集成的工具提供,自己不占端口 | | `mcp_video_task` | 无 | 它需要的公开临时 URL 由 agent 侧集成的工具提供,自己不占端口 |
| `mcp_asr` | 无 | `/mcp` 与 `/transcribe` 都无鉴权,只能由 core 经内网调用;它持有上游 ASR 密钥 | | `mcp_asr` | 无 | `/mcp` 与 `/transcribe` 都无鉴权,只能由 core 经内网调用;它不存密钥(上游参数随请求带入) |
## 单独调试 ## 单独调试
+52 -18
View File
@@ -6,7 +6,7 @@
|---|---|---| |---|---|---|
| `POST /transcribe` | `agent-core` 的 `/api/asr/transcribe`(H5 输入框) | 普通 HTTP,音频二进制进、`{text}` 出。**不经过模型、不消耗 token、1~3s** | | `POST /transcribe` | `agent-core` 的 `/api/asr/transcribe`(H5 输入框) | 普通 HTTP,音频二进制进、`{text}` 出。**不经过模型、不消耗 token、1~3s** |
| `POST /mcp` | 模型(MCP 工具 `transcribe_audio`) | 转写任务目录里已有的音频,参数是公网 URL(与 `video_task` 的 `image_url` 同构) | | `POST /mcp` | 模型(MCP 工具 `transcribe_audio`) | 转写任务目录里已有的音频,参数是公网 URL(与 `video_task` 的 `image_url` 同构) |
| `GET /health` | compose healthcheck | `{ok, model, configured}` | | `GET /health` | compose healthcheck | `{ok, service}`(无状态服务,不反映上游配置) |
端口 `3000` **只在 `agent-mcp-net` 内网**,不映射宿主机——本服务自身没有鉴权,暴露即被白嫖。 端口 `3000` **只在 `agent-mcp-net` 内网**,不映射宿主机——本服务自身没有鉴权,暴露即被白嫖。
对外唯一入口仍是 `agent-core`(`/api/asr` 走登录态鉴权)。 对外唯一入口仍是 `agent-core`(`/api/asr` 走登录态鉴权)。
@@ -19,26 +19,43 @@
## 部署 ## 部署
```bash ```bash
# 1) 配上游密钥(写进仓库根 .env,已 gitignore) # 1) 配上游:写进仓库根 config.yml 的 mcp_servers(与 image_task 同构),容器不存任何密钥
# ASR_API_KEY=你的智谱 token # - name: asr
# url: "http://mcp_asr:3000/mcp"
# headers:
# Authorization: Bearer <key> # 免鉴权的自建服务可省
# X-ASR-Base-Url: "https://<host>/v1"
# X-ASR-Model: "whisper-1"
# mode: skill
# 2) 起服务 # 2) 起服务
docker compose up -d --build mcp_asr docker compose up -d --build mcp_asr
docker compose restart agent-core # core 要在启动时读到 ASR_URL docker compose restart agent-core # core 要在启动时读到 config.yml 与 ASR_URL
curl -s http://127.0.0.1:8090/api/asr/status # {"enabled":true,...} curl -s http://127.0.0.1:8090/api/asr/status # {"enabled":true,...}
``` ```
`agent-core` 的环境变量 `ASR_URL`(compose 里固定为 `http://mcp_asr:3000`)是开关:置空即 `agent-core` 的环境变量 `ASR_URL`(compose 里固定为 `http://mcp_asr:3000`)是部署接线;
不启用,`/api/asr/*` 回 503,前端不显示麦克风按钮。 真正的开关是 config.yml 里那段 `asr`:置为 `mode: disable` 或删掉 = 不启用,`/api/asr/*` 回 503,
前端不显示麦克风按钮。
> 从旧版升级:以前上游 key 写在根 `.env` 的 `ASR_API_KEY`(并默认复用 `BIGMODEL_KEY`),
> 现在容器不再读它。把原来那三个值搬到 `config.yml` 的 `asr.headers` 即可,`.env` 里那行可以删掉;
> 不搬的话语音入口会自动关闭(`GET /api/asr/status` 会返回具体 `reason`)。
## 上游 ## 上游
任何 OpenAI 兼容的 `/audio/transcriptions` 都能用;默认智谱: 任何 OpenAI 兼容的 `/audio/transcriptions` 都能用。**本服务不保存、也不预设任何平台**:
key / base_url / model 全部由调用方随每个请求用 header 带入(与 `image_task` 同构)。
| 变量 | 默认 | | Header | 必填 | 说明 |
|---|---| |---|---|---|
| `ASR_API_BASE` | `https://open.bigmodel.cn/api/paas/v4` | | `X-ASR-Base-Url` | 是 | 上游地址,如 `https://<host>/v1`(服务自己拼 `/audio/transcriptions`) |
| `ASR_API_KEY` | 空(空则 `/transcribe` 回 503) | | `X-ASR-Model` | 是 | 模型名,如 `glm-asr` / `whisper-1` |
| `ASR_MODEL` | `glm-asr` | | `Authorization` | 否 | `Bearer <key>`;写成裸 key 也会自动补 `Bearer `;免鉴权的自建服务可省 |
`agent-core` 从 `config.yml` 的 `mcp_servers[name=asr].headers` 取这三个头,两条入口(`/transcribe`
与 `/mcp`)共用同一处配置——所以换平台只改 YAML + 重启 core,不碰 `.env`、不重建镜像。
缺 `X-ASR-Base-Url` / `X-ASR-Model` 时回 503,并在错误文案里指出缺哪个。
常驻内存约 35~40MB,CPU 基本为 0。没有本地模型可选:2 vCPU / 2GB 的机器跑不动能用的 常驻内存约 35~40MB,CPU 基本为 0。没有本地模型可选:2 vCPU / 2GB 的机器跑不动能用的
whisper(固定 30 秒窗口,`small` 单次要 15~30 秒),需要私有化就把这个容器放到另一台机器, whisper(固定 30 秒窗口,`small` 单次要 15~30 秒),需要私有化就把这个容器放到另一台机器,
@@ -50,13 +67,20 @@ whisper(固定 30 秒窗口,`small` 单次要 15~30 秒),需要私有化
# 任意格式(webm / mp4 / mp3 / wav / ogg / aac / flac),服务端用 ffmpeg 归一化 # 任意格式(webm / mp4 / mp3 / wav / ogg / aac / flac),服务端用 ffmpeg 归一化
curl -s -X POST http://mcp_asr:3000/transcribe \ curl -s -X POST http://mcp_asr:3000/transcribe \
-H 'Content-Type: audio/webm' \ -H 'Content-Type: audio/webm' \
-H 'X-ASR-Base-Url: https://<host>/v1' \
-H 'X-ASR-Model: whisper-1' \
-H 'Authorization: Bearer <key>' \
--data-binary @voice.webm --data-binary @voice.webm
# → {"text":"打开今天的日报","ms":842,"model":"glm-asr"} # → {"text":"打开今天的日报","ms":842,"model":"whisper-1"}
``` ```
- 上限 20MB;超过 `ASR_MAX_CHUNK_SEC`(默认 25s)的音频自动切片后逐段识别再拼接 - 上限 20MB。**只有超过 `ASR_MAX_CHUNK_SEC`(默认 25s)才切**:套壳是流式的,一次请求本就是一�句话,
(多数云端 ASR 单次只吃 ~30s)。 直接一次送出去(不跑静音检测);长音频(浏览器整段上传 / `/mcp`)才需要断开。
- 同时最多 `ASR_MAX_CONCURRENT`(默认 2)个转写,超了回 429。 - 切点尽量落在停顿上:只在距上限最后 `ASR_CUT_LOOKBACK_SEC`(默认 6s)的窗口里找静音区间中点,
挑不到才硬切——硬切会把字劈成两半,而两段之间没有上下文,接缝处的字就丢了。
段数因此最少(≈ 时长/25),不存在“切太碎”的退化。单段不短于 `ASR_MIN_SEG_SEC`(默认 1s)。
- 单段失败不连坐:其余段照常返回(长录音里偶发静音段很常见);**全部**段失败才报错。
- 同时最多 `ASR_MAX_CONCURRENT`(默认 2)个转写请求,超了回 429。
## MCP 工具 ## MCP 工具
@@ -65,6 +89,10 @@ curl -s -X POST http://mcp_asr:3000/transcribe \
mcp_servers: mcp_servers:
- name: asr - name: asr
url: "http://mcp_asr:3000/mcp" url: "http://mcp_asr:3000/mcp"
headers: # 上游参数随请求带入,同「上游」一节
X-ASR-Base-Url: "https://<host>/v1"
X-ASR-Model: "whisper-1"
Authorization: Bearer <key>
mode: skill # 低频能力,别每轮都发 schema mode: skill # 低频能力,别每轮都发 schema
``` ```
@@ -75,11 +103,17 @@ mcp_servers:
| 变量 | 默认 | 说明 | | 变量 | 默认 | 说明 |
|---|---|---| |---|---|---|
| `ASR_API_BASE` / `ASR_API_KEY` / `ASR_MODEL` | 见上 | 上游语音识别 |
| `ASR_MAX_BYTES` | 20971520 | 单次上传上限 | | `ASR_MAX_BYTES` | 20971520 | 单次上传上限 |
| `ASR_MAX_CHUNK_SEC` | `25` | 超长音频切片长度,`0` = 不切 | | `ASR_PAUSE_SEC` | `0.5` | 多长的静音算一个停顿(`silencedetect` 的 `d`,仅在需要切时用) |
| `ASR_SILENCE_DB` | `-35` | 判定“没人说话”的音量门限(正常语音约 -20dB) |
| `ASR_MIN_SEG_SEC` | `1` | 单段最短;避免切出识别不了的碎片 |
| `ASR_MAX_CHUNK_SEC` | `25` | 单段最长;≤ 它就不切(一次请求) |
| `ASR_CUT_LOOKBACK_SEC` | `6` | 切点搜索窗:只在距上限最后这几秒里找停顿 |
| `ASR_MAX_CONCURRENT` | `2` | 并发转写数 | | `ASR_MAX_CONCURRENT` | `2` | 并发转写数 |
| `ASR_LOG_LEVEL` | `info` | debug / info / warn / error / none | | `ASR_LOG_LEVEL` | `info` | debug / info / warn / error / none |
| `FFMPEG_BIN` | `ffmpeg` | 归一化 / 静音检测工具路径 |
上游参数(key / base_url / model)**不是环境变量**,见上面「上游」一节。
## 客户端怎么录音 ## 客户端怎么录音
+179 -47
View File
@@ -14,9 +14,14 @@
// tools/call 三种请求,手写这几十行 JSON-RPC 就够;本机内存只有 2G,省掉 SDK 与 express // tools/call 三种请求,手写这几十行 JSON-RPC 就够;本机内存只有 2G,省掉 SDK 与 express
// 的常驻开销(本服务空载约 35MB)。 // 的常驻开销(本服务空载约 35MB)。
// //
// 转写走上游的 OpenAI 兼容 /audio/transcriptions(默认智谱 glm-asr,换平台改 env 即可)。 // 转写走上游的 OpenAI 兼容 /audio/transcriptions(任何平台都行)。上游三要素——key、base_url、
// model——一律由调用方随请求 header 带入,本容器不存任何平台密钥、也不认任何平台默认值。
// 音频一律先经 ffmpeg 归一化成 16kHz 单声道 wav:WebView 录出来是 webm/opus,iOS 是 mp4/aac, // 音频一律先经 ffmpeg 归一化成 16kHz 单声道 wav:WebView 录出来是 webm/opus,iOS 是 mp4/aac,
// 上游只认 wav/mp3,归一化后两端都自由。 // 上游只认 wav/mp3,归一化后两端都自由。
//
// 超长兜底:只有超过单次上限(默认 25s)才断开重发,切点尽量落在停顿上。
// 套壳是流式的(客户端已按停顿切好,一次请求就是一句话),所以这里多数请求不会被切;
// 真正用得上的是浏览器整段上传与 /mcp 转写已有长音频。
import http from 'node:http'; import http from 'node:http';
import { spawn } from 'node:child_process'; import { spawn } from 'node:child_process';
@@ -25,18 +30,38 @@ import fs from 'node:fs/promises';
import os from 'node:os'; import os from 'node:os';
import path from 'node:path'; import path from 'node:path';
// ── 配置(全部走 env,不读 config.yml:本容器按仓库惯例只拿 env) ────────────── // ── 配置 ──────────────────────────────────────────────────────────────────
const PORT = Number(process.env.PORT || 3000); const PORT = Number(process.env.PORT || 3000);
// 上游:任何 OpenAI 兼容的 /audio/transcriptions(智谱 glm-asr、OpenAI whisper-1 等) // 上游参数逐请求带入(与 mcp/image_task 同构:密钥由调用方提供,服务端不保存):
const API_BASE = String(process.env.ASR_API_BASE || 'https://open.bigmodel.cn/api/paas/v4').trim().replace(/\/+$/, ''); // Authorization: Bearer <key> ← 免鉴权的自建服务可省
const API_KEY = String(process.env.ASR_API_KEY || '').trim(); // X-ASR-Base-Url: https://.../v1
const API_MODEL = String(process.env.ASR_MODEL || 'glm-asr').trim(); // X-ASR-Model: whisper-1
// 为什么不留 env 兜底:两条来源会让「到底生效的是哪个 key」变成靠猜,而且密钥越少地方存越好
//(容器 env 用 docker inspect 就能看,config.yml 至少还受登录态保护)。
const HDR_AUTH = 'authorization';
const HDR_BASE = 'x-asr-base-url';
const HDR_MODEL = 'x-asr-model';
// 单次上传上限。60s 的 AAC 约 240KB、16k wav 约 1.9MB,20MB 是给长音频留的余量。 // 单次上传上限。60s 的 AAC 约 240KB、16k wav 约 1.9MB,20MB 是给长音频留的余量。
const MAX_BYTES = Math.max(1024 * 1024, Number(process.env.ASR_MAX_BYTES || 20 * 1024 * 1024)); const MAX_BYTES = Math.max(1024 * 1024, Number(process.env.ASR_MAX_BYTES || 20 * 1024 * 1024));
// 云端多数 ASR 单次只吃 ~30s:超长音频按这个秒数切片后逐段识别再拼接(0 = 不切)。 // ── 超长兜底切分 ──────────────────────────────────────────────────────
// 谁需要它:套壳是流式的(客户端已经按停顿切好,每次请求就是一句话),
// 所以这里绝大多数请求都 ≤ 25s 直接一次送出去;真正用得上的只有
// 「浏览器整段上传」和「/mcp 转写已有长音频」——它们可能一次给几分钟。
// 切点尽量落在停顿上:硬切会把字劈成两半,而两段之间又没有上下文,接缝处的字就丢了。
// 0.5s 是句子边界:换气/想词的停顿通常 0.3~0.8s,而 0.5s 以下是词内间隔。
const PAUSE_SEC = Math.max(0.1, Number(process.env.ASR_PAUSE_SEC || 0.5));
// 判定为「没人说话」的音量门限:正常语音约 -20dB,安静房间底噪 -60dB 以下。
const SILENCE_DB = Number(process.env.ASR_SILENCE_DB || -35);
// 单段最短:避免最后切出一个没法识别的碎片(并进前一段)。
const MIN_SEG_SEC = Math.max(0, Number(process.env.ASR_MIN_SEG_SEC || 1));
// 单段最长(≈ 上游单次能吃的大致上限):超过它就必须断开。
// 16k/16bit 单声道 wav 恒为 32000 B/s,所以用文件大小就能估时长,不用再起 ffprobe。 // 16k/16bit 单声道 wav 恒为 32000 B/s,所以用文件大小就能估时长,不用再起 ffprobe。
const CHUNK_SEC = Math.max(0, Number(process.env.ASR_MAX_CHUNK_SEC || 25)); const CHUNK_SEC = Math.max(1, Number(process.env.ASR_MAX_CHUNK_SEC || 25));
// 切点搜索窗:只在「距上限还差这么多秒」的范围里找停顿。
// 不从头找是为了每段都尽量接近 25s——否则开头一个 2s 的停顿也会被拿来切,
// 段数无谓变多(请求开销远大于多切一刀的收益)。
const CUT_LOOKBACK_SEC = Math.max(0, Number(process.env.ASR_CUT_LOOKBACK_SEC || 6));
// 同时转写数:2 vCPU 上并发再高只会互相拖慢。 // 同时转写数:2 vCPU 上并发再高只会互相拖慢。
const MAX_CONCURRENT = Math.max(1, Number(process.env.ASR_MAX_CONCURRENT || 2)); const MAX_CONCURRENT = Math.max(1, Number(process.env.ASR_MAX_CONCURRENT || 2));
@@ -49,6 +74,27 @@ function log(level, msg) {
console.log('[asr ' + level + '] ' + msg); console.log('[asr ' + level + '] ' + msg);
} }
// 从请求 header 取上游三要素。Authorization 允许写成裸 key(自动补 Bearer),
// 省得用户还要记各平台前缀有没有写全。
function upstreamOf(req) {
const h = (req && req.headers) || {};
const raw = String(h[HDR_AUTH] || '').trim();
return {
auth: raw ? (/^bearer\s/i.test(raw) ? raw : 'Bearer ' + raw) : '',
base: String(h[HDR_BASE] || '').trim().replace(/\/+$/, ''),
model: String(h[HDR_MODEL] || '').trim(),
};
}
// 缺参数直接 503:这是部署问题(config.yml 没配),不是用户输入问题——回 4xx 会让人以为音频坏了。
function assertUpstream(up) {
const miss = !up.base ? 'X-ASR-Base-Url' : !up.model ? 'X-ASR-Model' : '';
if (!miss) return;
const e = new Error('语音识别未配置上游:config.yml 的 mcp_servers 里 asr 需要 headers.' + miss);
e.status = 503;
throw e;
}
// ── 子进程:统一超时 + 收 stdout/stderr ──────────────────────────────────── // ── 子进程:统一超时 + 收 stdout/stderr ────────────────────────────────────
function run(cmd, args, timeoutMs) { function run(cmd, args, timeoutMs) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
@@ -114,21 +160,83 @@ async function toWav(buf, ext) {
} }
} }
// 按秒切片:只在超过 CHUNK_SEC 时做。切片用 -c copy,纯 PCM 无损。 // ── 停顿检测与切点规划 ─────────────────────────────────────────────────
async function splitWav(wavPath, chunkSec) { // 用 ffmpeg 的 silencedetect 找静音区间:容器里本来就有 ffmpeg,它的判定也处理过
// 重采样/编码的各种边角,比自己扫 PCM 算 RMS 更省心(一次遍历,30s 音频约 50~150ms)。
// 返回 [{start,end}](秒)。末尾那段一直静到文件结束的不会有 silence_end,直接丢掉——
// 尾巴不需要切。
function parseSilences(stderr) {
const out = [];
let cur = null;
for (const line of String(stderr || '').split('\n')) {
const s = /silence_start:\s*(-?[\d.]+)/.exec(line);
if (s) { cur = { start: Number(s[1]), end: null }; out.push(cur); continue; }
const e = /silence_end:\s*(-?[\d.]+)/.exec(line);
if (e && cur) { cur.end = Number(e[1]); cur = null; }
}
return out.filter((p) => p.end != null && p.end > p.start && p.start >= 0);
}
async function detectPauses(wavPath) {
const r = await run(FFMPEG, [
'-hide_banner', '-nostats', '-i', wavPath,
'-af', 'silencedetect=noise=' + SILENCE_DB + 'dB:d=' + PAUSE_SEC,
'-f', 'null', '-',
], 60000);
return parseSilences(r.stderr);
}
// 由「时长 + 静音区间」规划切点,返回 [0, c1, …, duration]。
// 贪心:每次只在「还没超上限」的范围内挑一个切点,因此段数最少(≈ 时长/CHUNK_SEC)。
// 只在最后 CUT_LOOKBACK_SEC 秒里找停顿;找不到就硬切到上限处。
function planCuts(duration, pauses) {
const mids = pauses.map((p) => (p.start + p.end) / 2);
const cuts = [0];
let cur = 0;
while (duration - cur > CHUNK_SEC) {
const limit = cur + CHUNK_SEC;
const floor = Math.max(cur + MIN_SEG_SEC, limit - CUT_LOOKBACK_SEC);
let pick = 0;
for (const t of mids) {
if (t >= floor && t <= limit && t > pick) pick = t; // 取窗口内最靠后的停顿中点
}
if (!pick) pick = limit; // 没有停顿:硬切
// 别切出一个短于 MIN_SEG_SEC 的尾巴(如 25.6s 不该切成 25 + 0.6):对半分
if (duration - pick < MIN_SEG_SEC) pick = cur + (duration - cur) / 2;
cuts.push(pick);
cur = pick;
}
cuts.push(duration);
return cuts;
}
// 按规划好的切点切片。16k/单声道/s16le 的 PCM 用 -c copy 无损切(不重编码)。
async function splitWav(wavPath, cuts) {
const dir = path.dirname(wavPath); const dir = path.dirname(wavPath);
const base = path.basename(wavPath, '.wav'); const base = path.basename(wavPath, '.wav');
const pattern = path.join(dir, base + '-part-%03d.wav'); const parts = [];
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, [ await run(FFMPEG, [
'-hide_banner', '-loglevel', 'error', '-y', '-hide_banner', '-loglevel', 'error', '-y',
'-i', wavPath, '-ss', String(cuts[i]), '-i', wavPath, '-t', String(cuts[i + 1] - cuts[i]),
'-f', 'segment', '-segment_time', String(chunkSec), '-c', 'copy', '-c', 'copy', p,
pattern,
], 60000); ], 60000);
const files = (await fs.readdir(dir)) parts.push(p);
.filter((f) => f.startsWith(base + '-part-') && f.endsWith('.wav')) }
.sort(); return parts;
return files.map((f) => path.join(dir, f)); }
// 拼接各段文本:中文直接相连;两侧都是西文字母/数字时补一个空格,
// 否则英文句子被切开后会粘成 "helloworld"。
function joinText(parts) {
let out = '';
for (const s of parts) {
if (!s) continue;
if (out && /[A-Za-z0-9]$/.test(out) && /^[A-Za-z0-9]/.test(s)) out += ' ';
out += s;
}
return out;
} }
// ── 引擎 ────────────────────────────────────────────────────────────────── // ── 引擎 ──────────────────────────────────────────────────────────────────
@@ -140,21 +248,17 @@ function extractText(obj) {
return ''; return '';
} }
async function runCloud(wavPath) { async function runCloud(wavPath, up) {
if (!API_KEY) { assertUpstream(up);
const e = new Error('语音识别未配置:容器环境变量 ASR_API_KEY 为空');
e.status = 503;
throw e;
}
const buf = await fs.readFile(wavPath); const buf = await fs.readFile(wavPath);
const form = new FormData(); const form = new FormData();
form.append('model', API_MODEL); form.append('model', up.model);
form.append('file', new Blob([buf], { type: 'audio/wav' }), 'audio.wav'); form.append('file', new Blob([buf], { type: 'audio/wav' }), 'audio.wav');
let res; let res;
try { try {
res = await fetch(API_BASE + '/audio/transcriptions', { res = await fetch(up.base + '/audio/transcriptions', {
method: 'POST', method: 'POST',
headers: { Authorization: 'Bearer ' + API_KEY }, headers: up.auth ? { Authorization: up.auth } : {},
body: form, body: form,
signal: AbortSignal.timeout(60000), signal: AbortSignal.timeout(60000),
}); });
@@ -188,8 +292,12 @@ async function runCloud(wavPath) {
try { obj = JSON.parse(raw); } catch (_) { return raw.trim(); } try { obj = JSON.parse(raw); } catch (_) { return raw.trim(); }
const text = extractText(obj); const text = extractText(obj);
if (!text) { if (!text) {
const err = new Error('上游返回为空:' + raw.slice(0, 300)); // 上游对「这段里没人声」会回 200 + 空 text(如 glm-asr 的 {duration,text:"",usage})。
err.status = 502; // 这是**正常结果**,不是故障:给 400 让上层只记一行 warn(5xx 才打堆栈),
// 前端按「没识别到」处理、页面侧单段失败也会被跳过。
const err = new Error('没有识别到语音内容(这段音频里没有可识别的人声)');
err.status = 400;
err.upstream = raw.slice(0, 300);
throw err; throw err;
} }
return text; return text;
@@ -208,6 +316,8 @@ async function wavLevel(wavPath) {
// 转写一段音频缓冲:归一化 →(超长则切片)→ 逐段识别 → 拼接。 // 转写一段音频缓冲:归一化 →(超长则切片)→ 逐段识别 → 拼接。
async function transcribeBuffer(buf, opts) { async function transcribeBuffer(buf, opts) {
const up = (opts && opts.up) || {};
assertUpstream(up);
const wavPath = await toWav(buf, opts && opts.ext); const wavPath = await toWav(buf, opts && opts.ext);
const parts = []; const parts = [];
try { try {
@@ -216,13 +326,25 @@ async function transcribeBuffer(buf, opts) {
// 每次请求都打一行:原始字节 → 归一化时长。排查“上游说没声音”时第一眼看这个。 // 每次请求都打一行:原始字节 → 归一化时长。排查“上游说没声音”时第一眼看这个。
log('info', '归一化:' + buf.length + 'B (' + ((opts && opts.ext) || '?') + ') → ' log('info', '归一化:' + buf.length + 'B (' + ((opts && opts.ext) || '?') + ') → '
+ seconds.toFixed(1) + 's wav'); + seconds.toFixed(1) + 's wav');
if (CHUNK_SEC > 0 && seconds > CHUNK_SEC * 1.2) {
parts.push(...await splitWav(wavPath, CHUNK_SEC)); // 只有超长才切:套壳是流式的,每次请求本来就是一�句话(1~5s),
log('info', '超长音频切成 ' + parts.length + ' 段'); // 这里直接一次送出去,不用白白跑一趟 silencedetect。
let cuts = [0, seconds];
if (seconds > CHUNK_SEC) {
const pauses = await detectPauses(wavPath).catch((e) => {
log('warn', '静音检测失败,按 ' + CHUNK_SEC + 's 硬切:' + String(e && e.message || e).slice(0, 160));
return [];
});
cuts = planCuts(seconds, pauses);
if (cuts.length > 2) {
parts.push(...await splitWav(wavPath, cuts));
log('info', '超长切成 ' + parts.length + ' 段,切点 '
+ cuts.slice(1, -1).map((t) => t.toFixed(1) + 's').join(' / '));
}
} }
if (!parts.length) { if (!parts.length) {
try { try {
return (await runCloud(wavPath)).trim(); return (await runCloud(wavPath, up)).trim();
} catch (e) { } catch (e) {
// 只在上游判定“没有语音”时量一遍音量(正常路径零开销): // 只在上游判定“没有语音”时量一遍音量(正常路径零开销):
// 静音是 -91dB,正常语音 -20dB 上下,一眼就能分清是设备没收到声还是文件坏了。 // 静音是 -91dB,正常语音 -20dB 上下,一眼就能分清是设备没收到声还是文件坏了。
@@ -234,15 +356,26 @@ async function transcribeBuffer(buf, opts) {
} }
const out = []; const out = [];
for (const p of parts) { let firstErr = null;
for (let i = 0; i < parts.length; i++) {
const t0 = Date.now();
const range = cuts[i].toFixed(1) + '–' + cuts[i + 1].toFixed(1) + 's';
// 每段独立识别;单段失败不连累其他段(长录音里偶发静音段常见) // 每段独立识别;单段失败不连累其他段(长录音里偶发静音段常见)
try { try {
out.push((await runCloud(p)).trim()); const text = (await runCloud(parts[i], up)).trim();
log('info', ' part ' + (i + 1) + '/' + parts.length + ' ' + range + ' → '
+ text.length + ' 字 / ' + (Date.now() - t0) + 'ms');
out.push(text);
} catch (e) { } catch (e) {
log('warn', '切片识别失败(跳过):' + String(e && e.message || e).slice(0, 200)); if (!firstErr) firstErr = e;
log('warn', ' part ' + (i + 1) + '/' + parts.length + ' ' + range
+ ' 识别失败(跳过):' + String(e && e.message || e).slice(0, 200));
} }
} }
return out.filter(Boolean).join(''); // 全部失败才报错:否则前端只会看到 200 + 空文本,分不清是「没说话」还是「上游挂了」。
// 部分失败保持静默降级(长录音里某一段坏了不该连坐)。
if (!out.length && firstErr) throw firstErr;
return joinText(out);
} finally { } finally {
await fs.rm(wavPath, { force: true }).catch(() => {}); await fs.rm(wavPath, { force: true }).catch(() => {});
for (const p of parts) await fs.rm(p, { force: true }).catch(() => {}); for (const p of parts) await fs.rm(p, { force: true }).catch(() => {});
@@ -301,15 +434,18 @@ async function handleTranscribe(req, res, url) {
if (active >= MAX_CONCURRENT) { if (active >= MAX_CONCURRENT) {
return json(res, 429, { error: '语音识别繁忙,请稍后再试' }); return json(res, 429, { error: '语音识别繁忙,请稍后再试' });
} }
// 先判配置再读 body:没配上游时不必白读 20MB
const up = upstreamOf(req);
assertUpstream(up);
const buf = await readBody(req, MAX_BYTES); const buf = await readBody(req, MAX_BYTES);
if (!buf.length) return json(res, 400, { error: '未收到音频数据' }); if (!buf.length) return json(res, 400, { error: '未收到音频数据' });
active++; active++;
const t0 = Date.now(); const t0 = Date.now();
try { try {
const text = await transcribeBuffer(buf, { ext: extOf(req.headers['content-type']) }); const text = await transcribeBuffer(buf, { ext: extOf(req.headers['content-type']), up });
log('info', 'transcribed ' + buf.length + 'B → ' + text.length + ' 字,' + (Date.now() - t0) + 'ms'); log('info', 'transcribed ' + buf.length + 'B → ' + text.length + ' 字,' + (Date.now() - t0) + 'ms');
json(res, 200, { text, ms: Date.now() - t0, model: API_MODEL }); json(res, 200, { text, ms: Date.now() - t0, model: up.model });
} finally { } finally {
active--; active--;
} }
@@ -375,7 +511,7 @@ async function handleMcp(req, res) {
if (!urlStr) return ok({ isError: true, content: [{ type: 'text', text: '缺少 url 参数' }] }); if (!urlStr) return ok({ isError: true, content: [{ type: 'text', text: '缺少 url 参数' }] });
try { try {
const { buf, ext } = await fetchAudio(urlStr); const { buf, ext } = await fetchAudio(urlStr);
const text = await transcribeBuffer(buf, { ext }); const text = await transcribeBuffer(buf, { ext, up: upstreamOf(req) });
return ok({ content: [{ type: 'text', text }] }); return ok({ content: [{ type: 'text', text }] });
} catch (e) { } catch (e) {
return ok({ isError: true, content: [{ type: 'text', text: '转写失败:' + String(e && e.message || e) }] }); return ok({ isError: true, content: [{ type: 'text', text: '转写失败:' + String(e && e.message || e) }] });
@@ -402,11 +538,8 @@ const server = http.createServer((req, res) => {
}; };
if (req.method === 'GET' && url.pathname === '/health') { if (req.method === 'GET' && url.pathname === '/health') {
return json(res, 200, { // 无状态服务:健康 = 进程活着。上游参数逐请求带入,没有全局「configured」可言。
ok: true, return json(res, 200, { ok: true, service: 'asr' });
model: API_MODEL,
configured: !!API_KEY,
});
} }
if (req.method === 'POST' && url.pathname === '/transcribe') return done(handleTranscribe(req, res, url)); if (req.method === 'POST' && url.pathname === '/transcribe') return done(handleTranscribe(req, res, url));
if (url.pathname === '/mcp') { if (url.pathname === '/mcp') {
@@ -428,6 +561,5 @@ process.on('SIGTERM', () => shutdown('SIGTERM'));
process.on('SIGINT', () => shutdown('SIGINT')); process.on('SIGINT', () => shutdown('SIGINT'));
server.listen(PORT, '0.0.0.0', () => { server.listen(PORT, '0.0.0.0', () => {
log('info', 'listening on ' + PORT + ',model=' + API_MODEL + ' @ ' + API_BASE); log('info', 'listening on ' + PORT + '(上游 key/base_url/model 由调用方随请求 header 带入)');
if (!API_KEY) log('warn', 'ASR_API_KEY 为空:/transcribe 会返回 503');
}); });
+39 -51
View File
@@ -10,14 +10,14 @@
# #
# 输入(都可选): # 输入(都可选):
# BIGMODEL_KEY / DEEPSEEK_KEY / QWEN_KEY 模型平台 key,填几个启用几个(0~3 个) # BIGMODEL_KEY / DEEPSEEK_KEY / QWEN_KEY 模型平台 key,填几个启用几个(0~3 个)
# image_task / video_task / asr 复用 BIGMODEL_KEY(智谱即 BigModel);
# 未配 BIGMODEL_KEY 时这三个服务写为 mode: disable
# AUTH_USER / AUTH_PASSWORD 登录账号(默认 admin / admin,请自行改掉) # AUTH_USER / AUTH_PASSWORD 登录账号(默认 admin / admin,请自行改掉)
# PUBLIC_IP / AGENT_PORT 对外地址与端口,写进 public_link.base_url; # PUBLIC_IP / AGENT_PORT 对外地址与端口,写进 public_link.base_url;
# PUBLIC_IP 不配置则自动探测公网 IP # PUBLIC_IP 不配置则自动探测公网 IP
# AUTH_SECRET / EXECUTOR_TOKEN / WXBOT_TOKEN 一般不用给:不给就自动生成并复用(见下) # AUTH_SECRET / EXECUTOR_TOKEN / WXBOT_TOKEN 一般不用给:不给就自动生成并复用(见下)
# ASR_API_KEY 语音识别(mcp_asr)的上游 key;不给则复用 BIGMODEL_KEY, #
# 已有 .env 里的值优先(语音输入只是可选能力,留空不影响主流程) # 本脚本只自动写「模型平台 + web_search」。image_task / video_task / asr 需要上游 key,
# 一律以**注释模板**写进 mcp_servers(含默认 url 与 header 名),取消注释并填好 key 即生效——
# 不替用户猜平台、也不复用任何模型平台 key。
# #
# 微信接入(wxbot 已合入根 compose,作为栈内服务):本脚本只负责生成/复用根 .env 的 WXBOT_TOKEN; # 微信接入(wxbot 已合入根 compose,作为栈内服务):本脚本只负责生成/复用根 .env 的 WXBOT_TOKEN;
# wxbot 自身零配置文件(compose 注 env + 内置默认,同 executor 模式),无需任何同步动作。 # wxbot 自身零配置文件(compose 注 env + 内置默认,同 executor 模式),无需任何同步动作。
@@ -53,8 +53,6 @@ EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-}"
AUTH_SECRET="${AUTH_SECRET:-}" AUTH_SECRET="${AUTH_SECRET:-}"
# 微信接入服务 token(core ↔ wxbot 双向共用,compose 两侧同值注入;wxbot 已并入仓库) # 微信接入服务 token(core ↔ wxbot 双向共用,compose 两侧同值注入;wxbot 已并入仓库)
WXBOT_TOKEN="${WXBOT_TOKEN:-}" WXBOT_TOKEN="${WXBOT_TOKEN:-}"
# 语音识别(mcp_asr)的上游 key:独立于模型平台 key,但默认复用 BIGMODEL_KEY(智谱 glm-asr)
ASR_API_KEY="${ASR_API_KEY:-}"
log() { echo -e "\n\033[1;32m===== $* =====\033[0m"; } log() { echo -e "\n\033[1;32m===== $* =====\033[0m"; }
info() { echo -e "\033[1;36m[INFO]\033[0m $*"; } info() { echo -e "\033[1;36m[INFO]\033[0m $*"; }
@@ -78,8 +76,6 @@ if [ -f "$ENV_FILE" ]; then
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(sed -n 's/^EXECUTOR_TOKEN=//p' "$ENV_FILE" | head -1)}" 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)}" 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)}" WXBOT_TOKEN="${WXBOT_TOKEN:-$(sed -n 's/^WXBOT_TOKEN=//p' "$ENV_FILE" | head -1)}"
# ASR_API_KEY 同理复用:手填的 key 不会被重跑抹掉
ASR_API_KEY="${ASR_API_KEY:-$(sed -n 's/^ASR_API_KEY=//p' "$ENV_FILE" | head -1)}"
# AGENT_PORT 同理复用:避免不带参数重跑时把部署机自定义端口重置回 8090(显式传参优先) # AGENT_PORT 同理复用:避免不带参数重跑时把部署机自定义端口重置回 8090(显式传参优先)
AGENT_PORT="${AGENT_PORT_INPUT:-$(sed -n 's/^AGENT_PORT=//p' "$ENV_FILE" | head -1)}" AGENT_PORT="${AGENT_PORT_INPUT:-$(sed -n 's/^AGENT_PORT=//p' "$ENV_FILE" | head -1)}"
AGENT_PORT="${AGENT_PORT:-8090}" AGENT_PORT="${AGENT_PORT:-8090}"
@@ -87,22 +83,20 @@ fi
EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(gen_hex 32)}" EXECUTOR_TOKEN="${EXECUTOR_TOKEN:-$(gen_hex 32)}"
AUTH_SECRET="${AUTH_SECRET:-$(gen_hex 32)}" AUTH_SECRET="${AUTH_SECRET:-$(gen_hex 32)}"
WXBOT_TOKEN="${WXBOT_TOKEN:-$(gen_hex 32)}" WXBOT_TOKEN="${WXBOT_TOKEN:-$(gen_hex 32)}"
ASR_API_KEY="${ASR_API_KEY:-$BIGMODEL_KEY}"
cat > "$ENV_FILE" <<EOF cat > "$ENV_FILE" <<EOF
# 本文件由 scripts/init.sh 生成,勿手改(改配置请重新运行该脚本,或用环境变量覆盖) # 本文件由 scripts/init.sh 生成,勿手改(改配置请重新运行该脚本,或用环境变量覆盖)
# EXECUTOR_TOKEN: core 与 executor 之间的调用鉴权(两侧同值,compose 注入) # EXECUTOR_TOKEN: core 与 executor 之间的调用鉴权(两侧同值,compose 注入)
# AUTH_SECRET: 登录态签名密钥(写进 config.yml 的 auth.secret) # AUTH_SECRET: 登录态签名密钥(写进 config.yml 的 auth.secret)
# WXBOT_TOKEN: core ↔ wxbot 微信接入服务 token(compose 注入两侧;wxbot 零配置文件,env 即全部接线) # WXBOT_TOKEN: core ↔ wxbot 微信接入服务 token(compose 注入两侧;wxbot 零配置文件,env 即全部接线)
# ASR_API_KEY: 语音识别(mcp_asr)的上游 key,空 = 语音输入关闭;默认复用 BIGMODEL_KEY
# AGENT_PORT: agent-core 映射到宿主机的端口 # AGENT_PORT: agent-core 映射到宿主机的端口
# 注意:语音识别(mcp_asr)的上游 key/base_url/model 不在本文件,写在 config.yml 的 asr.headers(容器自己不存密钥)
EXECUTOR_TOKEN=$EXECUTOR_TOKEN EXECUTOR_TOKEN=$EXECUTOR_TOKEN
AUTH_SECRET=$AUTH_SECRET AUTH_SECRET=$AUTH_SECRET
WXBOT_TOKEN=$WXBOT_TOKEN WXBOT_TOKEN=$WXBOT_TOKEN
ASR_API_KEY=$ASR_API_KEY
AGENT_PORT=$AGENT_PORT AGENT_PORT=$AGENT_PORT
EOF EOF
info "EXECUTOR_TOKEN / AUTH_SECRET / WXBOT_TOKEN 已就位(沿用已有 .env 的值,没有则新生成);ASR_API_KEY $([ -n "$ASR_API_KEY" ] && echo 已配置 || echo 为空(语音输入关闭))" info "EXECUTOR_TOKEN / AUTH_SECRET / WXBOT_TOKEN 已就位(沿用已有 .env 的值,没有则新生成)"
# --env-only:只刷密钥,绝不碰 config.yml(平台 key 不在 .env 里,重跑全量会清空已部署配置) # --env-only:只刷密钥,绝不碰 config.yml(平台 key 不在 .env 里,重跑全量会清空已部署配置)
if [ "${ENV_ONLY:-}" = "1" ]; then if [ "${ENV_ONLY:-}" = "1" ]; then
@@ -214,44 +208,40 @@ mcp_servers:
url: "http://mcp_web_search:3000/" url: "http://mcp_web_search:3000/"
EOF EOF
if [ -n "$BIGMODEL_KEY" ]; then # 另外三个服务需要上游 key,默认整段注释掉:脚本不替用户选平台,也不复用模型平台 key。
cat <<EOF # 取消注释 + 填 key 后重启 core 即生效(mode: skill = 不下发到每轮工具表,按技能形式暴露)。
- 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' cat <<'EOF'
- name: image_task
url: "http://mcp_image_task:3000/mcp"
mode: disable # 未配 BIGMODEL_KEY:不连接、不发现;补上 key 后重跑本脚本
- name: video_task
url: "http://mcp_video_task:3000/mcp"
mode: disable # 未配 BIGMODEL_KEY:不连接、不发现;补上 key 后重跑本脚本
EOF
fi
# 语音转写:key 在容器 env(ASR_API_KEY),不经 headers,所以单独按 ASR_API_KEY 判断 # 以下三项默认注释:填好上游 key 再取消注释(重启 core 生效)
if [ -n "$ASR_API_KEY" ]; then #
cat <<'EOF' # 图片生成 / 编辑。X-Image-Task-Base-Url 填 zhipu 走智谱原生通道,
- name: asr # 填网关地址(如 https://<host>/v1)走任意 OpenAI 兼容的 /images/generations。
url: "http://mcp_asr:3000/mcp" # - name: image_task
mode: skill # 语音转写是低频能力,不下发到每轮工具表 # url: "http://mcp_image_task:3000/mcp"
# headers:
# Authorization: Bearer <upstream-api-key>
# X-Image-Task-Base-Url: "zhipu"
# X-Image-Task-Model: "CogView-4"
# mode: skill
#
# 视频生成(智谱 BigModel 异步接口)。模型可选,默认 cogvideox-flash;
# 要换模型再加一行 X-Video-Task-Model(取值见 mcp/video_task/README.md)。
# - name: video_task
# url: "http://mcp_video_task:3000/mcp"
# headers:
# Authorization: Bearer <zhipu-api-key>
# mode: skill
#
# 语音转写(输入框「按住说话」与模型的 transcribe_audio 共用这一段)。
# 任何 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
EOF EOF
else
cat <<'EOF'
- name: asr
url: "http://mcp_asr:3000/mcp"
mode: disable # 未配 ASR_API_KEY:不连接、不发现
EOF
fi
echo echo
cat <<EOF cat <<EOF
@@ -261,7 +251,7 @@ public_link:
EOF EOF
} > "$CONFIG_YML" } > "$CONFIG_YML"
info "平台: ${enabled_plats[*]:-无};图像/视频 MCP: $([ -n "$BIGMODEL_KEY" ] && echo 启用 || echo 未配置(mode: disable))" info "平台: ${enabled_plats[*]:-无};MCP: web_search 已启用,image_task / video_task / asr 为注释模板(填 key 后取消注释)"
# ============================================================ # ============================================================
# 3. 汇总 # 3. 汇总
@@ -272,9 +262,7 @@ echo " 访问地址 : http://${PUBLIC_IP:-<公网IP>}:${AGENT_PORT}"
echo " 账号 : $AUTH_USER" echo " 账号 : $AUTH_USER"
echo " 密码 : $AUTH_PASSWORD" echo " 密码 : $AUTH_PASSWORD"
echo " 平台 : ${enabled_plats[*]:-(无)}" echo " 平台 : ${enabled_plats[*]:-(无)}"
echo " 图像/视频: $([ -n "$BIGMODEL_KEY" ] && echo "image_task / video_task 已启用" || echo "未配置(mode: disable)")" echo " MCP 服务 : web_search 已启用;image_task / video_task / asr 以注释模板写入(填 key 后取消注释)"
echo " 语音输入 : $([ -n "$ASR_API_KEY" ] && echo "mcp_asr 已启用" || echo "未配置(ASR_API_KEY 为空)")"
echo " MCP 服务 : web_search / image_task / video_task / asr(同栈,随 compose 启动)"
echo " 微信接入 : WXBOT_TOKEN 已就位(compose 注入 core 与 wxbot 两侧;wxbot 无需配置文件)" echo " 微信接入 : WXBOT_TOKEN 已就位(compose 注入 core 与 wxbot 两侧;wxbot 无需配置文件)"
echo "---------------------------------------------" echo "---------------------------------------------"
log "完成 ✅" log "完成 ✅"