@dev-anywhere/relay 0.3.14 → 0.4.2

package/dist/{chunk-DFVUNUQH.js → chunk-ERH2EO6I.js}

@@ -2,10 +2,10 @@
 
 // src/server.ts
 import express from "express";
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 import { createServer } from "http";
 import { homedir } from "os";
-import { dirname as dirname2, resolve } from "path";
+import { dirname as dirname3, resolve } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { WebSocketServer } from "ws";
 
@@ -262,13 +262,213 @@ var MessageEnvelopeSchema = z6.discriminatedUnion("type", [
   })
 ]);
 
+// ../../packages/shared/dist/schemas/voice.js
+import { z as z7 } from "zod";
+var voiceProviderValues = ["aliyun-bailian"];
+var voiceRegionValues = ["cn", "intl"];
+var voiceOptionSourceValues = ["official", "custom"];
+var voiceOptionGenderValues = ["male", "female", "unknown"];
+var VoiceProviderConfigSchema = z7.object({
+  provider: z7.enum(voiceProviderValues),
+  configured: z7.boolean(),
+  region: z7.enum(voiceRegionValues),
+  asrModel: z7.string().min(1),
+  ttsModel: z7.string().min(1),
+  ttsVoice: z7.string().min(1),
+  turnIdleSeconds: z7.number().int().positive().safe().default(3)
+}).strict();
+var VoiceConfigUpdateSchema = z7.object({
+  provider: z7.enum(voiceProviderValues).optional(),
+  apiKey: z7.string().min(1).optional(),
+  clearApiKey: z7.boolean().optional(),
+  region: z7.enum(voiceRegionValues).optional(),
+  asrModel: z7.string().min(1).optional(),
+  ttsModel: z7.string().min(1).optional(),
+  ttsVoice: z7.string().min(1).optional(),
+  turnIdleSeconds: z7.number().int().positive().safe().optional()
+}).strict();
+var VoiceOptionSchema = z7.object({
+  value: z7.string().min(1),
+  label: z7.string().min(1),
+  description: z7.string().min(1).optional(),
+  gender: z7.enum(voiceOptionGenderValues).optional(),
+  age: z7.string().min(1).optional(),
+  model: z7.string().min(1).optional(),
+  source: z7.enum(voiceOptionSourceValues)
+}).strict();
+var VoiceCapabilitiesSchema = z7.object({
+  asrModels: z7.array(VoiceOptionSchema),
+  ttsModels: z7.array(VoiceOptionSchema),
+  ttsVoices: z7.array(VoiceOptionSchema),
+  fetchedAt: z7.number().optional()
+}).strict();
+var BUNDLED_BAILIAN_ASR_MODELS = [
+  {
+    value: "qwen3-asr-flash-realtime",
+    label: "Qwen3 ASR Flash Realtime",
+    source: "official"
+  },
+  {
+    value: "qwen3-asr-flash-realtime-2026-02-10",
+    label: "Qwen3 ASR Flash Realtime \xB7 2026-02-10",
+    source: "official"
+  },
+  {
+    value: "qwen3-asr-flash-realtime-2025-10-27",
+    label: "Qwen3 ASR Flash Realtime \xB7 2025-10-27",
+    source: "official"
+  }
+];
+var BUNDLED_BAILIAN_TTS_MODELS = [
+  {
+    value: "cosyvoice-v3-flash",
+    label: "CosyVoice V3 Flash \xB7 \u7CFB\u7EDF\u97F3\u8272",
+    source: "official"
+  },
+  {
+    value: "cosyvoice-v3-plus",
+    label: "CosyVoice V3 Plus \xB7 \u7CFB\u7EDF\u97F3\u8272",
+    source: "official"
+  },
+  {
+    value: "cosyvoice-v3.5-flash",
+    label: "CosyVoice V3.5 Flash \xB7 \u81EA\u5B9A\u4E49\u97F3\u8272",
+    source: "official"
+  },
+  {
+    value: "cosyvoice-v3.5-plus",
+    label: "CosyVoice V3.5 Plus \xB7 \u81EA\u5B9A\u4E49\u97F3\u8272",
+    source: "official"
+  }
+];
+var BUNDLED_BAILIAN_TTS_VOICES = [
+  {
+    value: "longanyang",
+    label: "\u9F99\u5B89\u6D0B \xB7 \u7537 \xB7 \u9633\u5149\u5927\u7537\u5B69 \xB7 \u5E74\u9F84 20-30",
+    gender: "male",
+    age: "20-30",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longanhuan",
+    label: "\u9F99\u5B89\u6B22 \xB7 \u5973 \xB7 \u6B22\u8131\u5143\u6C14 \xB7 \u5E74\u9F84 20-30",
+    gender: "female",
+    age: "20-30",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longhuhu_v3",
+    label: "\u9F99\u547C\u547C \xB7 \u5973 \xB7 \u5929\u771F\u70C2\u6F2B\u5973\u7AE5 \xB7 \u5E74\u9F84 6-10",
+    gender: "female",
+    age: "6-10",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longpaopao_v3",
+    label: "\u9F99\u6CE1\u6CE1 \xB7 \u672A\u77E5 \xB7 \u98DE\u5929\u6CE1\u6CE1\u97F3 \xB7 \u5E74\u9F84 6-15",
+    gender: "unknown",
+    age: "6-15",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longjielidou_v3",
+    label: "\u9F99\u6770\u529B\u8C46 \xB7 \u7537 \xB7 \u9633\u5149\u987D\u76AE \xB7 \u5E74\u9F84 10",
+    gender: "male",
+    age: "10",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longxian_v3",
+    label: "\u9F99\u4ED9 \xB7 \u5973 \xB7 \u8C6A\u653E\u53EF\u7231 \xB7 \u5E74\u9F84 12",
+    gender: "female",
+    age: "12",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longling_v3",
+    label: "\u9F99\u94C3 \xB7 \u5973 \xB7 \u7A1A\u6C14\u5446\u677F \xB7 \u5E74\u9F84 10",
+    gender: "female",
+    age: "10",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longjiaxin_v3",
+    label: "\u9F99\u5609\u6B23 \xB7 \u5973 \xB7 \u4F18\u96C5\u7CA4\u8BED \xB7 \u5E74\u9F84 30-35",
+    gender: "female",
+    age: "30-35",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longanyue_v3",
+    label: "\u9F99\u5B89\u7CA4 \xB7 \u7537 \xB7 \u6B22\u8131\u7CA4\u8BED \xB7 \u5E74\u9F84 25-35",
+    gender: "male",
+    age: "25-35",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longlaotie_v3",
+    label: "\u9F99\u8001\u94C1 \xB7 \u7537 \xB7 \u4E1C\u5317\u76F4\u7387 \xB7 \u5E74\u9F84 25-30",
+    gender: "male",
+    age: "25-30",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longanyang",
+    label: "\u9F99\u5B89\u6D0B \xB7 \u7537 \xB7 \u9633\u5149\u5927\u7537\u5B69 \xB7 \u5E74\u9F84 20-30",
+    gender: "male",
+    age: "20-30",
+    model: "cosyvoice-v3-plus",
+    source: "official"
+  },
+  {
+    value: "longanhuan",
+    label: "\u9F99\u5B89\u6B22 \xB7 \u5973 \xB7 \u6B22\u8131\u5143\u6C14 \xB7 \u5E74\u9F84 20-30",
+    gender: "female",
+    age: "20-30",
+    model: "cosyvoice-v3-plus",
+    source: "official"
+  }
+];
+function cloneVoiceOption(option) {
+  return { ...option };
+}
+function createBundledBailianVoiceCapabilities(fetchedAt) {
+  return {
+    asrModels: BUNDLED_BAILIAN_ASR_MODELS.map(cloneVoiceOption),
+    ttsModels: BUNDLED_BAILIAN_TTS_MODELS.map(cloneVoiceOption),
+    ttsVoices: BUNDLED_BAILIAN_TTS_VOICES.map(cloneVoiceOption),
+    ...typeof fetchedAt === "number" ? { fetchedAt } : {}
+  };
+}
+var VoiceSummaryReasonSchema = z7.enum([
+  "code",
+  "table",
+  "diff",
+  "log",
+  "stack_trace",
+  "long_list",
+  "long_text",
+  "mixed",
+  "approval"
+]);
+
 // ../../packages/shared/dist/builders/index.js
 function serializeControl(msg) {
   return JSON.stringify(msg);
 }
 
 // ../../packages/shared/dist/schemas/relay-control.js
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // ../../packages/shared/dist/constants/relay-errors.js
 var RelayErrorCode = {
@@ -295,59 +495,59 @@ var ControlErrorCode = {
 };
 
 // ../../packages/shared/dist/schemas/relay-control.js
-var ProxyInfoSchema = z7.object({
+var ProxyInfoSchema = z8.object({
   proxyId: IdSchema,
-  name: z7.string().optional(),
-  online: z7.boolean(),
-  sessions: z7.array(z7.string()).optional()
+  name: z8.string().optional(),
+  online: z8.boolean(),
+  sessions: z8.array(z8.string()).optional()
 });
-var AgentCliAvailabilitySchema = z7.object({
-  available: z7.boolean(),
-  command: z7.string().optional(),
-  error: z7.string().optional(),
-  suggestions: z7.array(z7.string()).optional()
+var AgentCliAvailabilitySchema = z8.object({
+  available: z8.boolean(),
+  command: z8.string().optional(),
+  error: z8.string().optional(),
+  suggestions: z8.array(z8.string()).optional()
 });
-var AgentCliStatusSchema = z7.object({
+var AgentCliStatusSchema = z8.object({
   claude: AgentCliAvailabilitySchema,
   codex: AgentCliAvailabilitySchema
 });
-var DirEntrySchema = z7.object({ name: z7.string(), isDir: z7.boolean() });
-var FileTreeGroupSchema = z7.object({
-  path: z7.string(),
-  entries: z7.array(DirEntrySchema)
+var DirEntrySchema = z8.object({ name: z8.string(), isDir: z8.boolean() });
+var FileTreeGroupSchema = z8.object({
+  path: z8.string(),
+  entries: z8.array(DirEntrySchema)
 });
-var CommandEntrySchema = z7.object({
-  name: z7.string(),
-  description: z7.string(),
-  argumentHint: z7.string().optional(),
-  source: z7.string()
+var CommandEntrySchema = z8.object({
+  name: z8.string(),
+  description: z8.string(),
+  argumentHint: z8.string().optional(),
+  source: z8.string()
 });
-var HistorySessionSchema = z7.object({
-  id: z7.string(),
-  title: z7.string(),
-  projectDir: z7.string(),
-  updatedAt: z7.number(),
-  provider: z7.enum(providerValues).optional()
+var HistorySessionSchema = z8.object({
+  id: z8.string(),
+  title: z8.string(),
+  projectDir: z8.string(),
+  updatedAt: z8.number(),
+  provider: z8.enum(providerValues).optional()
 });
-var SessionHistoryMessageSchema = z7.object({
-  role: z7.enum(["user", "assistant"]),
-  text: z7.string(),
-  timestamp: z7.number().optional(),
-  cursor: z7.string().optional()
+var SessionHistoryMessageSchema = z8.object({
+  role: z8.enum(["user", "assistant"]),
+  text: z8.string(),
+  timestamp: z8.number().optional(),
+  cursor: z8.string().optional()
 });
 var RequestIdShape = { requestId: IdSchema.optional() };
-var ControlErrorCodeSchema = z7.enum(Object.values(ControlErrorCode));
+var ControlErrorCodeSchema = z8.enum(Object.values(ControlErrorCode));
 var RequestErrorShape = {
-  error: z7.string().optional(),
+  error: z8.string().optional(),
   errorCode: ControlErrorCodeSchema.optional()
 };
-var ClipboardImageMimeTypeSchema = z7.enum(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+var ClipboardImageMimeTypeSchema = z8.enum(["image/png", "image/jpeg", "image/webp", "image/gif"]);
 function control(type, shape, directions) {
   return {
     type,
     directions: new Set(Array.isArray(directions) ? directions : directions ? [directions] : []),
-    schema: z7.object({
-      type: z7.literal(type),
+    schema: z8.object({
+      type: z8.literal(type),
       ...shape ?? {}
     })
   };
@@ -355,36 +555,75 @@ function control(type, shape, directions) {
 var relayControlDefinitions = [
   control("proxy_register", {
     proxyId: IdSchema,
-    name: z7.string().optional()
+    name: z8.string().optional()
   }),
   control("proxy_register_response", {
-    status: z7.enum(["new", "reconnected"])
+    status: z8.enum(["new", "reconnected"])
   }),
   control("proxy_list_request", RequestIdShape),
   control("proxy_list_response", {
     ...RequestIdShape,
-    proxies: z7.array(ProxyInfoSchema)
+    proxies: z8.array(ProxyInfoSchema)
   }),
   control("proxy_select", { ...RequestIdShape, proxyId: IdSchema }),
   control("proxy_select_response", {
     ...RequestIdShape,
-    success: z7.boolean(),
+    success: z8.boolean(),
     proxyId: IdSchema.optional(),
     ...RequestErrorShape
   }),
   control("relay_error", {
-    code: z7.enum(Object.values(RelayErrorCode)),
-    message: z7.string(),
+    code: z8.enum(Object.values(RelayErrorCode)),
+    message: z8.string(),
     // 可选 requestId: relay 把 client 发来 raw 的 requestId 字段透传回来,
     // client 侧 waitForMessage 据此把对应 pending request 立即拒掉而不必等到 timeout。
     requestId: IdSchema.optional()
   }),
+  // Voice Pilot config is relay-local: client reads/updates the relay's stored provider settings.
+  control("voice_config_request", RequestIdShape),
+  control("voice_config_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    config: VoiceProviderConfigSchema.optional()
+  }),
+  control("voice_config_update", {
+    ...RequestIdShape,
+    config: VoiceConfigUpdateSchema
+  }),
+  control("voice_config_update_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    success: z8.boolean(),
+    config: VoiceProviderConfigSchema.optional()
+  }),
+  control("voice_config_test", {
+    ...RequestIdShape,
+    config: VoiceConfigUpdateSchema.optional()
+  }),
+  control("voice_config_test_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    success: z8.boolean(),
+    audioBase64: z8.string().optional(),
+    audioSampleRate: z8.number().int().positive().optional(),
+    audioEncoding: z8.literal("pcm_s16le").optional(),
+    transcript: z8.string().optional()
+  }),
+  control("voice_capabilities_request", {
+    ...RequestIdShape,
+    region: z8.enum(voiceRegionValues).optional()
+  }),
+  control("voice_capabilities_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    capabilities: VoiceCapabilitiesSchema.optional()
+  }),
   // 客户端注册协议
   control("client_register", {
     clientId: IdSchema
   }),
   control("client_register_response", {
-    status: z7.enum(["restored", "proxy_offline", "new"]),
+    status: z8.enum(["restored", "proxy_offline", "new"]),
     proxyId: IdSchema.optional()
   }),
   // Proxy 离线通知
@@ -403,51 +642,51 @@ var relayControlDefinitions = [
   control("dir_list_request", {
     proxyId: IdSchema.optional(),
     ...RequestIdShape,
-    path: z7.string()
+    path: z8.string()
   }, "client_to_proxy"),
-  control("dir_list_response", { ...RequestIdShape, ...RequestErrorShape, entries: z7.array(DirEntrySchema), path: z7.string() }, "proxy_to_client"),
+  control("dir_list_response", { ...RequestIdShape, ...RequestErrorShape, entries: z8.array(DirEntrySchema), path: z8.string() }, "proxy_to_client"),
   // 目录创建请求与响应
-  control("dir_create_request", { ...RequestIdShape, path: z7.string() }, "client_to_proxy"),
+  control("dir_create_request", { ...RequestIdShape, path: z8.string() }, "client_to_proxy"),
   control("dir_create_response", {
     ...RequestIdShape,
     ...RequestErrorShape,
-    path: z7.string(),
-    success: z7.boolean()
+    path: z8.string(),
+    success: z8.boolean()
   }, "proxy_to_client"),
   // 命令列表推送，proxy 将可用命令列表推给 client
-  control("command_list_push", { commands: z7.array(CommandEntrySchema) }, "proxy_to_client"),
+  control("command_list_push", { commands: z8.array(CommandEntrySchema) }, "proxy_to_client"),
   // 文件树推送: 按目录分组, 首组 path 即为 session cwd
   // 前端直接把每组写入 tree[path], 与 dir_list_response 共享 cache slot
   control("file_tree_push", {
-    groups: z7.array(FileTreeGroupSchema)
+    groups: z8.array(FileTreeGroupSchema)
   }, "proxy_to_client"),
   // 会话列表请求与权限模式变更
   control("session_list", void 0, ["client_to_proxy", "proxy_to_client"]),
   control("permission_mode_change", {
-    mode: z7.enum(["default", "auto_accept", "plan"]),
+    mode: z8.enum(["default", "auto_accept", "plan"]),
     // sessionId 可选：传入时 proxy 按该会话的 mode 分叉（PTY 发 Tab ANSI），未传走全局日志行为
     sessionId: IdSchema.optional()
   }, "client_to_proxy"),
   // 会话历史浏览
   control("session_history_request", RequestIdShape, "client_to_proxy"),
-  control("session_history_response", { ...RequestIdShape, sessions: z7.array(HistorySessionSchema) }, "proxy_to_client"),
+  control("session_history_response", { ...RequestIdShape, sessions: z8.array(HistorySessionSchema) }, "proxy_to_client"),
   // PTY 语义状态，从 Envelope 迁移到 Control 层
   control("pty_state", { sessionId: IdSchema, payload: PtyStatePayloadSchema }, "proxy_to_client"),
   // Provider 语义状态，来自 Claude/Codex hook 等结构化事件，不从 PTY 字节推断
   control("agent_status", { sessionId: IdSchema, payload: AgentStatusPayloadSchema }, "proxy_to_client"),
   // 终端标题变化，proxy -> client
-  control("terminal_title", { sessionId: IdSchema, title: z7.string() }, "proxy_to_client"),
+  control("terminal_title", { sessionId: IdSchema, title: z8.string() }, "proxy_to_client"),
   // 终端尺寸变化，proxy -> client
-  control("terminal_resize", { sessionId: IdSchema, cols: z7.number().int().positive(), rows: z7.number().int().positive() }, "proxy_to_client"),
-  control("terminal_resize_request", { sessionId: IdSchema, cols: z7.number().int().positive(), rows: z7.number().int().positive() }, "client_to_proxy"),
+  control("terminal_resize", { sessionId: IdSchema, cols: z8.number().int().positive(), rows: z8.number().int().positive() }, "proxy_to_client"),
+  control("terminal_resize_request", { sessionId: IdSchema, cols: z8.number().int().positive(), rows: z8.number().int().positive() }, "client_to_proxy"),
   // 远程终止 JSON 会话，client -> proxy
   control("session_terminate", { sessionId: IdSchema }, "client_to_proxy"),
-  control("session_rename", { ...RequestIdShape, sessionId: IdSchema, name: z7.string() }, "client_to_proxy"),
+  control("session_rename", { ...RequestIdShape, sessionId: IdSchema, name: z8.string() }, "client_to_proxy"),
   control("session_rename_response", {
     ...RequestIdShape,
     sessionId: IdSchema,
-    success: z7.boolean(),
-    name: z7.string().optional(),
+    success: z8.boolean(),
+    name: z8.string().optional(),
     ...RequestErrorShape
   }, "proxy_to_client"),
   // 中断当前 turn，client -> proxy，SIGINT 到 worker 进程让 claude CLI abort 当前流
@@ -455,114 +694,117 @@ var relayControlDefinitions = [
   // turn 完成信号，proxy -> client，对应 claude stream-json 的 result 事件
   control("turn_result", {
     sessionId: IdSchema,
-    success: z7.boolean(),
-    isError: z7.boolean(),
+    success: z8.boolean(),
+    isError: z8.boolean(),
     // stream-json result.result 是本轮最终文本。assistant_message 流丢失或 CLI 未发增量时，
     // Web 用它作为 JSON 模式兜底展示，避免 turn 已结束但界面空白。
-    result: z7.string().optional()
+    result: z8.string().optional()
   }, "proxy_to_client"),
   // 客户端发送到 PTY 的原始字节（ANSI 序列），不追加换行
-  control("remote_input_raw", { sessionId: IdSchema, data: z7.string() }, "client_to_proxy"),
+  control("remote_input_raw", { sessionId: IdSchema, data: z8.string(), traceId: IdSchema.optional() }, "client_to_proxy"),
   control("clipboard_image_upload", {
     ...RequestIdShape,
     sessionId: IdSchema,
     mimeType: ClipboardImageMimeTypeSchema,
-    dataBase64: z7.string().min(1),
-    fileName: z7.string().optional()
+    dataBase64: z8.string().min(1),
+    fileName: z8.string().optional()
   }, "client_to_proxy"),
   control("clipboard_image_upload_response", {
     ...RequestIdShape,
     ...RequestErrorShape,
     sessionId: IdSchema,
-    success: z7.boolean(),
+    success: z8.boolean(),
     // success=false 时 proxy 没有有效 path 可填；保持 optional 以避免占位空字符串通过校验。
-    path: z7.string().optional()
+    path: z8.string().optional()
   }, "proxy_to_client"),
   control("image_preview_request", {
     ...RequestIdShape,
     sessionId: IdSchema,
-    path: z7.string().min(1)
+    path: z8.string().min(1)
   }, "client_to_proxy"),
   control("image_preview_response", {
     ...RequestIdShape,
     ...RequestErrorShape,
     sessionId: IdSchema,
-    success: z7.boolean(),
+    success: z8.boolean(),
     // 同 clipboard_image_upload_response：失败时 proxy 不一定有路径。
-    path: z7.string().optional(),
+    path: z8.string().optional(),
     mimeType: ClipboardImageMimeTypeSchema.optional(),
-    dataBase64: z7.string().optional(),
-    size: z7.number().int().nonnegative().optional()
+    dataBase64: z8.string().optional(),
+    size: z8.number().int().nonnegative().optional()
   }, "proxy_to_client"),
   // 任意文件下载: 与 image_preview 形状对称, 只是 mimeType 不限定为图片;
   // 单租户场景下 path 任意 (不受 previewRoots 限制), 由 proxy 端 size cap 兜底。
   control("file_download_request", {
     ...RequestIdShape,
     sessionId: IdSchema,
-    path: z7.string().min(1)
+    path: z8.string().min(1)
   }, "client_to_proxy"),
   control("file_download_response", {
     ...RequestIdShape,
     ...RequestErrorShape,
     sessionId: IdSchema,
-    success: z7.boolean(),
-    path: z7.string().optional(),
-    mimeType: z7.string().optional(),
-    dataBase64: z7.string().optional(),
-    size: z7.number().int().nonnegative().optional()
+    success: z8.boolean(),
+    path: z8.string().optional(),
+    mimeType: z8.string().optional(),
+    dataBase64: z8.string().optional(),
+    size: z8.number().int().nonnegative().optional()
   }, "proxy_to_client"),
   // 任意文件上传: 复用 clipboard_image_upload 的形状, mimeType 放开 + fileName 必填,
   // 由 proxy 端写入 session cwd 的 .dev-anywhere/uploads/ 子目录, 返回相对路径供 web 拼成 @path。
   control("file_upload_request", {
     ...RequestIdShape,
     sessionId: IdSchema,
-    mimeType: z7.string().min(1),
-    dataBase64: z7.string().min(1),
-    fileName: z7.string().min(1)
+    mimeType: z8.string().min(1),
+    dataBase64: z8.string().min(1),
+    fileName: z8.string().min(1)
   }, "client_to_proxy"),
   control("file_upload_response", {
     ...RequestIdShape,
     ...RequestErrorShape,
     sessionId: IdSchema,
-    success: z7.boolean(),
-    path: z7.string().optional()
+    success: z8.boolean(),
+    path: z8.string().optional()
   }, "proxy_to_client"),
   // 客户端询问 proxy 的环境信息 (home 路径等), client -> proxy -> response
   // FilePathPicker 用 homePath 作为 select 模式下的默认起点, 新建会话时打开即可浏览
   control("proxy_info_request", RequestIdShape, "client_to_proxy"),
-  control("proxy_info", { ...RequestIdShape, homePath: z7.string(), agentCli: AgentCliStatusSchema }, "proxy_to_client"),
-  control("agent_cli_config_update", { ...RequestIdShape, provider: z7.enum(providerValues), path: z7.string().min(1) }, "client_to_proxy"),
+  control("proxy_info", { ...RequestIdShape, homePath: z8.string(), agentCli: AgentCliStatusSchema }, "proxy_to_client"),
+  control("agent_cli_config_update", { ...RequestIdShape, provider: z8.enum(providerValues), path: z8.string().min(1) }, "client_to_proxy"),
   control("agent_cli_config_update_response", {
     ...RequestIdShape,
-    provider: z7.enum(providerValues),
+    provider: z8.enum(providerValues),
     agentCli: AgentCliStatusSchema.optional(),
     ...RequestErrorShape
   }, "proxy_to_client"),
   // 远程创建 JSON 会话，client -> proxy -> response
   control("session_create", {
     ...RequestIdShape,
-    cwd: z7.string(),
-    provider: z7.enum(providerValues),
-    mode: z7.enum(sessionModeValues).optional(),
-    resumeSessionId: z7.string().optional(),
+    cwd: z8.string(),
+    name: z8.string().optional(),
+    provider: z8.enum(providerValues),
+    mode: z8.enum(sessionModeValues).optional(),
+    resumeSessionId: z8.string().optional(),
     // 透传给 claude CLI 的 --permission-mode, undefined 时 proxy 兜底为 "default"
-    permissionMode: z7.enum(["default", "auto", "acceptEdits", "plan", "bypassPermissions", "dontAsk"]).optional()
+    permissionMode: z8.enum(["default", "auto", "acceptEdits", "plan", "bypassPermissions", "dontAsk"]).optional()
   }, "client_to_proxy"),
   control("session_create_response", {
     ...RequestIdShape,
     // 失败路径只送 errorCode/error, sessionId 此时无语义。成功路径才有 id。
     sessionId: IdSchema.optional(),
-    mode: z7.enum(sessionModeValues).optional(),
-    provider: z7.enum(providerValues).optional(),
-    ptyOwner: z7.enum(ptyOwnerValues).optional(),
+    name: z8.string().optional(),
+    nameLocked: z8.boolean().optional(),
+    mode: z8.enum(sessionModeValues).optional(),
+    provider: z8.enum(providerValues).optional(),
+    ptyOwner: z8.enum(ptyOwnerValues).optional(),
     ...RequestErrorShape
   }, "proxy_to_client"),
   // 客户端请求会话历史消息，client -> proxy
   control("session_messages_request", {
     ...RequestIdShape,
     sessionId: IdSchema,
-    limit: z7.number().int().min(1).max(200).optional(),
-    before: z7.string().optional()
+    limit: z8.number().int().min(1).max(200).optional(),
+    before: z8.string().optional()
   }, "client_to_proxy"),
   // 客户端请求会话资源（命令列表 + 文件树），client -> proxy
   control("session_resources_request", { ...RequestIdShape, sessionId: IdSchema }, "client_to_proxy"),
@@ -570,14 +812,14 @@ var relayControlDefinitions = [
     ...RequestIdShape,
     ...RequestErrorShape,
     sessionId: IdSchema,
-    commands: z7.array(CommandEntrySchema),
-    groups: z7.array(FileTreeGroupSchema)
+    commands: z8.array(CommandEntrySchema),
+    groups: z8.array(FileTreeGroupSchema)
   }, "proxy_to_client"),
   // 客户端请求当前 provider 语义状态；不经 relay 缓存，由 proxy 返回当前值
   control("agent_status_request", { ...RequestIdShape, sessionId: IdSchema.optional() }, "client_to_proxy"),
   control("agent_status_response", {
     ...RequestIdShape,
-    statuses: z7.array(z7.object({ sessionId: IdSchema, payload: AgentStatusPayloadSchema }))
+    statuses: z8.array(z8.object({ sessionId: IdSchema, payload: AgentStatusPayloadSchema }))
   }, "proxy_to_client"),
   // 客户端确认已收到审批请求；proxy 只记录送达状态，不把它当成用户决策
   control("permission_request_delivered", { sessionId: IdSchema, requestId: IdSchema }, "client_to_proxy"),
@@ -587,40 +829,56 @@ var relayControlDefinitions = [
   control("permission_decision_result", {
     sessionId: IdSchema,
     requestId: IdSchema,
-    outcome: z7.enum(["allow", "deny"]),
-    delivered: z7.boolean(),
-    message: z7.string().optional()
+    outcome: z8.enum(["allow", "deny"]),
+    delivered: z8.boolean(),
+    message: z8.string().optional()
   }, "proxy_to_client"),
   // proxy 推送当前 pending 的工具审批列表，client 据此恢复审批卡片
   control("pending_approvals_push", {
     sessionId: IdSchema,
-    approvals: z7.array(z7.object({
+    approvals: z8.array(z8.object({
       requestId: IdSchema,
-      toolName: z7.string(),
-      input: z7.record(z7.string(), z7.unknown())
+      toolName: z8.string(),
+      input: z8.record(z8.string(), z8.unknown())
     }))
   }, "proxy_to_client"),
+  // Voice Pilot speech summaries are produced by proxy-side Claude Code so it can read project context.
+  control("voice_summary_request", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    messageId: IdSchema,
+    text: z8.string().min(1),
+    reason: VoiceSummaryReasonSchema
+  }, "client_to_proxy"),
+  control("voice_summary_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: IdSchema,
+    messageId: IdSchema,
+    success: z8.boolean(),
+    summary: z8.string().min(1).optional()
+  }, "proxy_to_client"),
   // 恢复会话时推送历史消息，proxy -> client
   control("session_history_messages", {
     ...RequestIdShape,
     sessionId: IdSchema,
-    before: z7.string().optional(),
-    messages: z7.array(SessionHistoryMessageSchema),
-    hasMore: z7.boolean().optional(),
-    nextBefore: z7.string().optional()
+    before: z8.string().optional(),
+    messages: z8.array(SessionHistoryMessageSchema),
+    hasMore: z8.boolean().optional(),
+    nextBefore: z8.string().optional()
   }, "proxy_to_client"),
   // proxy 重连后同步活跃 session 列表给 relay。session_sync 由 relay 自消费（更新 proxy-session
   // 关联）不转发给 client，因此**没有** direction 标注——RelayControlDirection 只描述转发流。
   control("session_sync", {
-    sessions: z7.array(z7.object({
-      id: z7.string(),
-      mode: z7.enum(sessionModeValues),
-      provider: z7.enum(providerValues),
-      ptyOwner: z7.enum(ptyOwnerValues).optional(),
-      cwd: z7.string().optional(),
-      name: z7.string().optional(),
-      nameLocked: z7.boolean().optional(),
-      state: z7.enum(sessionStateValues)
+    sessions: z8.array(z8.object({
+      id: z8.string(),
+      mode: z8.enum(sessionModeValues),
+      provider: z8.enum(providerValues),
+      ptyOwner: z8.enum(ptyOwnerValues).optional(),
+      cwd: z8.string().optional(),
+      name: z8.string().optional(),
+      nameLocked: z8.boolean().optional(),
+      state: z8.enum(sessionStateValues)
     }))
   }),
   // PTY 会话订阅，client -> proxy，触发 terminal serialize() 返回当前状态
@@ -628,15 +886,15 @@ var relayControlDefinitions = [
   // PTY 会话快照，proxy -> client，serialize() 的全量终端状态
   control("session_snapshot", {
     sessionId: IdSchema,
-    cols: z7.number().int().positive(),
-    rows: z7.number().int().positive(),
-    data: z7.string(),
-    outputSeq: z7.number().int().nonnegative(),
+    cols: z8.number().int().positive(),
+    rows: z8.number().int().positive(),
+    data: z8.string(),
+    outputSeq: z8.number().int().nonnegative(),
     requestId: IdSchema.optional()
   }, "proxy_to_client")
 ];
 var relayControlSchemas = relayControlDefinitions.map((definition) => definition.schema);
-var RelayControlSchema = z7.discriminatedUnion("type", relayControlSchemas);
+var RelayControlSchema = z8.discriminatedUnion("type", relayControlSchemas);
 var ProxyToClientRelayControlTypes = new Set(relayControlDefinitions.filter((definition) => definition.directions.has("proxy_to_client")).map((definition) => definition.type));
 function isProxyToClientRelayControlType(type) {
   return ProxyToClientRelayControlTypes.has(type);
@@ -1275,8 +1533,656 @@ function handleProxyConnection(ws, registry, logger, chaos) {
 }
 
 // src/handlers/client.ts
-import { WebSocket as WebSocket4 } from "ws";
+import { WebSocket as WebSocket6 } from "ws";
+import { nanoid as nanoid3 } from "nanoid";
+
+// src/voice/bailian-asr.ts
+import { EventEmitter } from "events";
 import { nanoid } from "nanoid";
+import { WebSocket as WebSocket4 } from "ws";
+
+// src/voice/bailian-endpoints.ts
+var BAILIAN_HOSTS = {
+  cn: "wss://dashscope.aliyuncs.com",
+  intl: "wss://dashscope-intl.aliyuncs.com"
+};
+function bailianRealtimeUrl(region, model) {
+  const url = `${BAILIAN_HOSTS[region]}/api-ws/v1/realtime`;
+  return model ? `${url}?model=${encodeURIComponent(model)}` : url;
+}
+function bailianInferenceUrl(region) {
+  return `${BAILIAN_HOSTS[region]}/api-ws/v1/inference`;
+}
+
+// src/voice/bailian-asr.ts
+var OPEN = 1;
+var END_OF_SPEECH_SILENCE_MS = 1200;
+function defaultSocketFactory(url, options) {
+  return new WebSocket4(url, options);
+}
+function extractRealtimePreview(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const record = payload;
+  if (typeof record.text === "string" || typeof record.stash === "string") {
+    const text = typeof record.text === "string" ? record.text : "";
+    const stash = typeof record.stash === "string" ? record.stash : "";
+    const preview = `${text}${stash}`;
+    return preview.length > 0 ? preview : null;
+  }
+  const candidates = [
+    record.text,
+    record.transcript,
+    record.delta,
+    record.output && typeof record.output === "object" && record.output.text
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  }
+  return null;
+}
+function extractFinalText(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const record = payload;
+  const candidates = [
+    record.transcript,
+    record.text,
+    record.output && typeof record.output === "object" && record.output.text
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  }
+  return null;
+}
+function extractError(payload) {
+  if (!payload || typeof payload !== "object") return new Error("Bailian ASR error");
+  const record = payload;
+  const nested = record.error && typeof record.error === "object" ? record.error : null;
+  let message = "Bailian ASR error";
+  if (nested && typeof nested.message === "string") {
+    message = nested.message;
+  } else if (typeof record.message === "string") {
+    message = record.message;
+  }
+  return new Error(message);
+}
+var BailianAsrClientImpl = class extends EventEmitter {
+  constructor(config, socketFactory, eventIdFactory) {
+    super();
+    this.config = config;
+    this.eventIdFactory = eventIdFactory;
+    this.socket = socketFactory(bailianRealtimeUrl(config.region, config.model), {
+      headers: {
+        Authorization: `bearer ${config.apiKey}`,
+        "OpenAI-Beta": "realtime=v1"
+      }
+    });
+    this.socket.on("open", () => this.handleOpen());
+    this.socket.on("message", (data) => this.handleMessage(data));
+    this.socket.on(
+      "error",
+      (err) => this.emit("error", err instanceof Error ? err : new Error(String(err)))
+    );
+    this.socket.on(
+      "close",
+      (code, reason) => this.emit("closed", code, reason?.toString("utf8"))
+    );
+  }
+  config;
+  eventIdFactory;
+  socket;
+  isOpen = false;
+  isReady = false;
+  pending = [];
+  sendPcm(chunk) {
+    this.sendWhenReady({
+      event_id: this.eventIdFactory(),
+      type: "input_audio_buffer.append",
+      audio: chunk.toString("base64")
+    });
+  }
+  stop() {
+    this.sendWhenReady({
+      event_id: this.eventIdFactory(),
+      type: "session.finish"
+    });
+  }
+  close() {
+    this.socket.close();
+  }
+  handleOpen() {
+    this.isOpen = true;
+    this.sendNow({
+      event_id: this.eventIdFactory(),
+      type: "session.update",
+      session: {
+        modalities: ["text"],
+        input_audio_format: "pcm",
+        sample_rate: this.config.sampleRate,
+        input_audio_transcription: {
+          language: this.config.language
+        },
+        turn_detection: {
+          type: "server_vad",
+          threshold: 0,
+          silence_duration_ms: END_OF_SPEECH_SILENCE_MS
+        }
+      }
+    });
+  }
+  handleMessage(data) {
+    const text = typeof data === "string" ? data : Buffer.isBuffer(data) ? data.toString("utf8") : "";
+    if (!text) return;
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      return;
+    }
+    const record = payload;
+    const type = typeof record.type === "string" ? record.type : "";
+    if (type.includes("error")) {
+      this.emit("error", extractError(payload));
+      return;
+    }
+    if (type === "conversation.item.input_audio_transcription.failed") {
+      this.emit("error", extractError(payload));
+      return;
+    }
+    if (type === "session.updated") {
+      this.isReady = true;
+      this.emit("ready");
+      this.flushPending();
+      return;
+    }
+    if (type === "conversation.item.input_audio_transcription.text") {
+      const preview = extractRealtimePreview(payload);
+      if (preview) this.emit("partial", preview);
+      return;
+    }
+    if (type === "conversation.item.input_audio_transcription.completed" || type === "session.finished") {
+      const transcript = extractFinalText(payload);
+      if (transcript) {
+        this.emit("final", transcript);
+      }
+    }
+  }
+  sendWhenReady(payload) {
+    const message = JSON.stringify(payload);
+    if ((this.isOpen || this.socket.readyState === OPEN) && this.isReady) {
+      this.socket.send(message);
+      return;
+    }
+    this.pending.push(message);
+  }
+  sendNow(payload) {
+    this.socket.send(JSON.stringify(payload));
+  }
+  flushPending() {
+    for (const message of this.pending) {
+      this.socket.send(message);
+    }
+    this.pending = [];
+  }
+};
+function createBailianAsrClient(config, options = {}) {
+  return new BailianAsrClientImpl(
+    config,
+    options.socketFactory ?? defaultSocketFactory,
+    options.eventIdFactory ?? (() => `event_${nanoid()}`)
+  );
+}
+
+// src/voice/bailian-tts.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { nanoid as nanoid2 } from "nanoid";
+import { WebSocket as WebSocket5 } from "ws";
+var OPEN2 = 1;
+function defaultSocketFactory2(url, options) {
+  return new WebSocket5(url, options);
+}
+function errorFromPayload(payload) {
+  if (!payload || typeof payload !== "object") return new Error("Bailian TTS error");
+  const record = payload;
+  const header = record.header && typeof record.header === "object" ? record.header : null;
+  let message = "Bailian TTS error";
+  if (header && typeof header.error_message === "string") {
+    message = header.error_message;
+  } else if (typeof record.message === "string") {
+    message = record.message;
+  }
+  return new Error(message);
+}
+function eventFromPayload(payload) {
+  if (!payload || typeof payload !== "object") return "";
+  const record = payload;
+  const header = record.header && typeof record.header === "object" ? record.header : null;
+  const event = header ? header.event : void 0;
+  return typeof event === "string" ? event : "";
+}
+var BailianTtsClientImpl = class extends EventEmitter2 {
+  constructor(config, socketFactory, taskIdFactory) {
+    super();
+    this.config = config;
+    this.taskIdFactory = taskIdFactory;
+    this.socket = socketFactory(bailianInferenceUrl(config.region), {
+      headers: { Authorization: `bearer ${config.apiKey}` }
+    });
+    this.socket.on("open", () => this.handleOpen());
+    this.socket.on(
+      "message",
+      (data, isBinary) => this.handleMessage(data, isBinary)
+    );
+    this.socket.on(
+      "error",
+      (err) => this.emit("error", err instanceof Error ? err : new Error(String(err)))
+    );
+    this.socket.on(
+      "close",
+      (code, reason) => this.emit("closed", code, reason?.toString("utf8"))
+    );
+  }
+  config;
+  taskIdFactory;
+  socket;
+  isOpen = false;
+  current = null;
+  speak(text) {
+    if (this.current) {
+      throw new Error("Bailian TTS is already speaking");
+    }
+    this.current = { taskId: this.taskIdFactory(), text };
+    if (this.isOpen || this.socket.readyState === OPEN2) {
+      this.sendRunTask();
+    }
+  }
+  close() {
+    this.socket.close();
+  }
+  handleOpen() {
+    this.isOpen = true;
+    if (this.current) this.sendRunTask();
+  }
+  handleMessage(data, isBinary = false) {
+    const text = this.tryDecodeText(data, isBinary);
+    if (!text) {
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      this.emit("audio", chunk);
+      return;
+    }
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(text);
+      this.emit("audio", chunk);
+      return;
+    }
+    const event = eventFromPayload(payload);
+    if (event === "task-started") {
+      this.emit("started");
+      this.sendTextAndFinish();
+      return;
+    }
+    if (event === "task-finished") {
+      this.emit("finished");
+      this.current = null;
+      return;
+    }
+    if (event === "task-failed" || event === "task-error") {
+      this.emit("error", errorFromPayload(payload));
+      this.current = null;
+    }
+  }
+  tryDecodeText(data, isBinary) {
+    if (typeof data === "string") return data;
+    if (isBinary) return null;
+    if (Buffer.isBuffer(data)) return data.toString("utf8");
+    return null;
+  }
+  sendRunTask() {
+    if (!this.current) return;
+    this.socket.send(
+      JSON.stringify({
+        header: {
+          action: "run-task",
+          task_id: this.current.taskId,
+          streaming: "duplex"
+        },
+        payload: {
+          task_group: "audio",
+          task: "tts",
+          function: "SpeechSynthesizer",
+          model: this.config.model,
+          input: {},
+          parameters: {
+            text_type: "PlainText",
+            voice: this.config.voice,
+            format: "pcm",
+            sample_rate: this.config.sampleRate
+          }
+        }
+      })
+    );
+  }
+  sendTextAndFinish() {
+    if (!this.current) return;
+    this.socket.send(
+      JSON.stringify({
+        header: { action: "continue-task", task_id: this.current.taskId },
+        payload: { input: { text: this.current.text } }
+      })
+    );
+    this.socket.send(
+      JSON.stringify({
+        header: { action: "finish-task", task_id: this.current.taskId },
+        payload: { input: {} }
+      })
+    );
+  }
+};
+function createBailianTtsClient(config, options = {}) {
+  return new BailianTtsClientImpl(
+    config,
+    options.socketFactory ?? defaultSocketFactory2,
+    options.taskIdFactory ?? (() => nanoid2())
+  );
+}
+
+// src/voice/config-test.ts
+var TEST_SAMPLE_RATE = 16e3;
+var ASR_TEST_CHUNK_BYTES = 3200;
+var ASR_TEST_CHUNK_INTERVAL_MS = 100;
+function mergeVoiceConfigForTest(current, update) {
+  return {
+    ...current,
+    provider: "aliyun-bailian",
+    ...update?.clearApiKey ? { apiKey: void 0 } : {},
+    ...update?.apiKey ? { apiKey: update.apiKey } : {},
+    ...update?.region ? { region: update.region } : {},
+    ...update?.asrModel ? { asrModel: update.asrModel } : {},
+    ...update?.ttsModel ? { ttsModel: update.ttsModel } : {},
+    ...update?.ttsVoice ? { ttsVoice: update.ttsVoice } : {},
+    ...update?.turnIdleSeconds ? { turnIdleSeconds: update.turnIdleSeconds } : {}
+  };
+}
+function createBailianVoiceConfigTester(options = {}) {
+  const ttsClientFactory = options.ttsClientFactory ?? createBailianTtsClient;
+  const asrClientFactory = options.asrClientFactory ?? createBailianAsrClient;
+  const sampleText = options.sampleText ?? "\u8BED\u97F3\u52A9\u624B\u6D4B\u8BD5";
+  const timeoutMs = options.timeoutMs ?? 8e3;
+  return {
+    async test(config) {
+      if (!config.apiKey) {
+        return Promise.reject(new Error("\u8BF7\u5148\u586B\u5199\u963F\u91CC\u4E91\u767E\u70BC API Key"));
+      }
+      const audio = await synthesizeTestAudio({
+        config,
+        sampleText,
+        timeoutMs,
+        clientFactory: ttsClientFactory
+      });
+      const transcript = await recognizeTestAudio({
+        config,
+        audio,
+        sampleText,
+        timeoutMs,
+        clientFactory: asrClientFactory
+      });
+      return { audio, sampleRate: TEST_SAMPLE_RATE, transcript };
+    }
+  };
+}
+function synthesizeTestAudio(options) {
+  const { config, sampleText, timeoutMs, clientFactory } = options;
+  const client = clientFactory({
+    apiKey: config.apiKey,
+    region: config.region,
+    model: config.ttsModel,
+    voice: config.ttsVoice,
+    sampleRate: TEST_SAMPLE_RATE
+  });
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const chunks = [];
+    const timer = setTimeout(() => {
+      settle(new Error("TTS \u6D4B\u8BD5\u8D85\u65F6"));
+    }, timeoutMs);
+    function settle(error, audio) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      client.close();
+      if (error) reject(error);
+      else resolve2(audio ?? Buffer.alloc(0));
+    }
+    client.on("audio", (chunk) => {
+      if (chunk.length > 0) chunks.push(chunk);
+    });
+    client.on("finished", () => {
+      if (chunks.length === 0) {
+        settle(new Error("TTS \u6D4B\u8BD5\u6CA1\u6709\u8FD4\u56DE\u97F3\u9891"));
+        return;
+      }
+      settle(void 0, Buffer.concat(chunks));
+    });
+    client.on("error", (error) => settle(error));
+    client.on("closed", () => {
+      if (!settled) settle(new Error("TTS \u6D4B\u8BD5\u8FDE\u63A5\u5DF2\u5173\u95ED"));
+    });
+    try {
+      client.speak(sampleText);
+    } catch (err) {
+      settle(err instanceof Error ? err : new Error("TTS \u6D4B\u8BD5\u542F\u52A8\u5931\u8D25"));
+    }
+  });
+}
+function recognizeTestAudio(options) {
+  const { config, audio, sampleText, timeoutMs, clientFactory } = options;
+  const client = clientFactory({
+    apiKey: config.apiKey,
+    region: config.region,
+    model: config.asrModel,
+    sampleRate: TEST_SAMPLE_RATE,
+    language: "zh"
+  });
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    let streamTimer = null;
+    const timer = setTimeout(() => {
+      settle(new Error("STT \u6D4B\u8BD5\u8D85\u65F6"));
+    }, timeoutMs);
+    function settle(error, transcript) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (streamTimer) clearTimeout(streamTimer);
+      client.close();
+      if (error) reject(error);
+      else resolve2(transcript ?? "");
+    }
+    client.on("ready", () => {
+      let offset = 0;
+      const sendNextChunk = () => {
+        if (settled) return;
+        const chunk = audio.subarray(offset, offset + ASR_TEST_CHUNK_BYTES);
+        if (chunk.length > 0) {
+          client.sendPcm(chunk);
+          offset += chunk.length;
+        }
+        if (offset >= audio.length) {
+          client.stop();
+          return;
+        }
+        streamTimer = setTimeout(sendNextChunk, ASR_TEST_CHUNK_INTERVAL_MS);
+      };
+      sendNextChunk();
+    });
+    client.on("final", (transcript) => {
+      if (matchesExpectedTranscript(transcript, sampleText)) {
+        settle(void 0, transcript);
+        return;
+      }
+      settle(new Error(`STT \u6D4B\u8BD5\u8BC6\u522B\u7ED3\u679C\u4E0D\u5339\u914D\uFF1A${transcript}`));
+    });
+    client.on("error", (error) => settle(error));
+    client.on("closed", () => {
+      if (!settled) settle(new Error("STT \u6D4B\u8BD5\u8FDE\u63A5\u5DF2\u5173\u95ED"));
+    });
+  });
+}
+function matchesExpectedTranscript(actual, expected) {
+  return normalizeTranscript(actual).includes(normalizeTranscript(expected));
+}
+function normalizeTranscript(text) {
+  return text.replace(/[^\p{Script=Han}a-zA-Z0-9]/gu, "").toLowerCase();
+}
+
+// src/voice/client-controls.ts
+function handleVoiceConfigControl(msg, ws, store, logger, providers) {
+  if (msg.type === "voice_config_request") {
+    ws.send(
+      JSON.stringify({
+        type: "voice_config_response",
+        requestId: msg.requestId,
+        config: store.read()
+      })
+    );
+    return true;
+  }
+  if (msg.type === "voice_config_update") {
+    try {
+      const config = store.update(msg.config);
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_update_response",
+          requestId: msg.requestId,
+          success: true,
+          config
+        })
+      );
+    } catch (err) {
+      logger.warn({ err }, "Voice config update failed");
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_update_response",
+          requestId: msg.requestId,
+          success: false,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: err instanceof Error ? err.message : "Voice config update failed"
+        })
+      );
+    }
+    return true;
+  }
+  if (msg.type === "voice_capabilities_request") {
+    if (!providers) {
+      ws.send(
+        JSON.stringify({
+          type: "voice_capabilities_response",
+          requestId: msg.requestId,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: "Voice capabilities provider is not available"
+        })
+      );
+      return true;
+    }
+    const config = { ...store.readSecret(), ...msg.region ? { region: msg.region } : {} };
+    let provider;
+    try {
+      provider = providers.current(config);
+    } catch (err) {
+      logger.warn({ err }, "Voice capabilities provider resolution failed");
+      ws.send(
+        JSON.stringify({
+          type: "voice_capabilities_response",
+          requestId: msg.requestId,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: err instanceof Error ? err.message : "Voice capabilities request failed"
+        })
+      );
+      return true;
+    }
+    void provider.readCapabilities(config).then((capabilities) => {
+      ws.send(
+        JSON.stringify({
+          type: "voice_capabilities_response",
+          requestId: msg.requestId,
+          capabilities
+        })
+      );
+    }).catch((err) => {
+      logger.warn({ err }, "Voice capabilities request failed");
+      ws.send(
+        JSON.stringify({
+          type: "voice_capabilities_response",
+          requestId: msg.requestId,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: err instanceof Error ? err.message : "Voice capabilities request failed"
+        })
+      );
+    });
+    return true;
+  }
+  if (msg.type === "voice_config_test") {
+    if (!providers) {
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_test_response",
+          requestId: msg.requestId,
+          success: false,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: "Voice config tester is not available"
+        })
+      );
+      return true;
+    }
+    const testConfig = mergeVoiceConfigForTest(store.readSecret(), msg.config);
+    let provider;
+    try {
+      provider = providers.current(testConfig);
+    } catch (err) {
+      logger.warn({ err }, "Voice config test provider resolution failed");
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_test_response",
+          requestId: msg.requestId,
+          success: false,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: err instanceof Error ? err.message : "Voice config test failed"
+        })
+      );
+      return true;
+    }
+    void provider.testConfig(testConfig).then((result) => {
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_test_response",
+          requestId: msg.requestId,
+          success: true,
+          ...result.audio ? { audioBase64: result.audio.toString("base64") } : {},
+          ...result.sampleRate ? { audioSampleRate: result.sampleRate } : {},
+          ...result.audio ? { audioEncoding: "pcm_s16le" } : {},
+          ...result.transcript ? { transcript: result.transcript } : {}
+        })
+      );
+    }).catch((err) => {
+      logger.warn({ err }, "Voice config test failed");
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_test_response",
+          requestId: msg.requestId,
+          success: false,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: err instanceof Error ? err.message : "Voice config test failed"
+        })
+      );
+    });
+    return true;
+  }
+  return false;
+}
+
+// src/handlers/client.ts
 var MAX_JSON_MESSAGE_SIZE2 = 1 * 1024 * 1024;
 function handleClientRegister(clientId, clientWs, registry, logger) {
   clientWs.clientId = clientId;
@@ -1334,7 +2240,7 @@ function rejectProxySelect(ws, requestId, proxyId) {
     })
   );
 }
-function handleClientConnection(ws, registry, logger, chaos) {
+function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, voiceProviders) {
   const clientWs = ws;
   clientWs.isAlive = true;
   registry.addClientWs(clientWs);
@@ -1384,6 +2290,9 @@ function handleClientConnection(ws, registry, logger, chaos) {
         }
         return;
       }
+      if (voiceConfigStore && handleVoiceConfigControl(msg, clientWs, voiceConfigStore, logger, voiceProviders)) {
+        return;
+      }
       if (isClientToProxyRelayControlType(msg.type)) {
         const targetProxyId = clientWs.boundProxyId;
         if (!targetProxyId) {
@@ -1391,7 +2300,7 @@ function handleClientConnection(ws, registry, logger, chaos) {
           return;
         }
         const proxyWs = registry.getProxy(targetProxyId);
-        if (proxyWs && proxyWs.readyState === WebSocket4.OPEN) {
+        if (proxyWs && proxyWs.readyState === WebSocket6.OPEN) {
           if (chaos) chaos.send(proxyWs, raw, { direction: "client_to_proxy", type: msg.type });
           else proxyWs.send(raw);
         } else {
@@ -1411,7 +2320,7 @@ function handleClientConnection(ws, registry, logger, chaos) {
           return;
         }
         if (!clientWs.clientId) {
-          clientWs.clientId = `anon-${nanoid(10)}`;
+          clientWs.clientId = `anon-${nanoid3(10)}`;
         }
         const bound = registry.bindClientById(clientWs.clientId, msg.proxyId, clientWs);
         if (!bound) {
@@ -1475,11 +2384,20 @@ function handleClientConnection(ws, registry, logger, chaos) {
 }
 
 // src/heartbeat.ts
+function markAlive(ws) {
+  ws.isAlive = true;
+}
 function setupHeartbeat(wss, interval = 3e4) {
+  wss.on("connection", (ws) => {
+    markAlive(ws);
+    ws.on("pong", () => {
+      markAlive(ws);
+    });
+  });
   return setInterval(() => {
     for (const ws of wss.clients) {
       const sock = ws;
-      if (!sock.isAlive) {
+      if (sock.isAlive === false) {
         sock.terminate();
         continue;
       }
@@ -1490,7 +2408,7 @@ function setupHeartbeat(wss, interval = 3e4) {
 }
 
 // src/chaos.ts
-import { WebSocket as WebSocket5 } from "ws";
+import { WebSocket as WebSocket7 } from "ws";
 function parseRelayChaosFromEnv(env) {
   const enabled = env.DEV_ANYWHERE_RELAY_CHAOS === "1";
   const types = env.DEV_ANYWHERE_RELAY_CHAOS_TYPES?.split(",").map((type) => type.trim()).filter(Boolean);
@@ -1512,7 +2430,7 @@ function createRelayChaos(options, logger) {
     return true;
   }
   function sendNow(ws, data) {
-    if (ws.readyState === WebSocket5.OPEN) {
+    if (ws.readyState === WebSocket7.OPEN) {
       ws.send(data);
     }
   }
@@ -1537,8 +2455,495 @@ function createRelayChaos(options, logger) {
   };
 }
 
+// src/voice/config-store.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var DEFAULT_STORED_CONFIG = {
+  provider: "aliyun-bailian",
+  region: "cn",
+  asrModel: "qwen3-asr-flash-realtime",
+  ttsModel: "cosyvoice-v3-flash",
+  ttsVoice: "longanyang",
+  turnIdleSeconds: 3
+};
+function redacted(config) {
+  return VoiceProviderConfigSchema.parse({
+    provider: config.provider,
+    configured: Boolean(config.apiKey),
+    region: config.region,
+    asrModel: config.asrModel,
+    ttsModel: config.ttsModel,
+    ttsVoice: config.ttsVoice,
+    turnIdleSeconds: config.turnIdleSeconds
+  });
+}
+function mergeDefaults(defaults) {
+  return {
+    ...DEFAULT_STORED_CONFIG,
+    ...defaults
+  };
+}
+function parseStoredConfig(raw, fallback) {
+  if (!raw || typeof raw !== "object") return fallback;
+  const candidate = raw;
+  return {
+    ...fallback,
+    provider: "aliyun-bailian",
+    ...typeof candidate.apiKey === "string" && candidate.apiKey.length > 0 ? { apiKey: candidate.apiKey } : { apiKey: void 0 },
+    ...candidate.region === "cn" || candidate.region === "intl" ? { region: candidate.region } : {},
+    ...typeof candidate.asrModel === "string" && candidate.asrModel.length > 0 ? { asrModel: candidate.asrModel } : {},
+    ...typeof candidate.ttsModel === "string" && candidate.ttsModel.length > 0 ? { ttsModel: candidate.ttsModel } : {},
+    ...typeof candidate.ttsVoice === "string" && candidate.ttsVoice.length > 0 ? { ttsVoice: candidate.ttsVoice } : {},
+    ...typeof candidate.turnIdleSeconds === "number" && Number.isSafeInteger(candidate.turnIdleSeconds) && candidate.turnIdleSeconds > 0 ? { turnIdleSeconds: candidate.turnIdleSeconds } : {}
+  };
+}
+function createVoiceConfigStore(options = {}) {
+  const fallback = mergeDefaults(options.defaults);
+  const filePath = options.dataDir ? join2(options.dataDir, "voice-config.json") : null;
+  let memoryConfig = fallback;
+  function load() {
+    if (!filePath) return memoryConfig;
+    if (!existsSync(filePath)) return fallback;
+    try {
+      return parseStoredConfig(JSON.parse(readFileSync2(filePath, "utf8")), fallback);
+    } catch {
+      return fallback;
+    }
+  }
+  function save(config) {
+    if (!filePath) {
+      memoryConfig = config;
+      return;
+    }
+    mkdirSync(dirname2(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  }
+  return {
+    read() {
+      return redacted(load());
+    },
+    update(update) {
+      const parsed = VoiceConfigUpdateSchema.parse(update);
+      const current = load();
+      const next = {
+        ...current,
+        provider: "aliyun-bailian",
+        ...parsed.clearApiKey ? { apiKey: void 0 } : {},
+        ...parsed.apiKey ? { apiKey: parsed.apiKey } : {},
+        ...parsed.region ? { region: parsed.region } : {},
+        ...parsed.asrModel ? { asrModel: parsed.asrModel } : {},
+        ...parsed.ttsModel ? { ttsModel: parsed.ttsModel } : {},
+        ...parsed.ttsVoice ? { ttsVoice: parsed.ttsVoice } : {},
+        ...parsed.turnIdleSeconds ? { turnIdleSeconds: parsed.turnIdleSeconds } : {}
+      };
+      save(next);
+      return redacted(next);
+    },
+    readSecret() {
+      return load();
+    }
+  };
+}
+
+// src/voice/asr-ws.ts
+import { WebSocket as WebSocket8 } from "ws";
+function sendJson(ws, payload) {
+  if (ws.readyState === WebSocket8.OPEN) {
+    ws.send(JSON.stringify(payload));
+  }
+}
+function toBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (data instanceof ArrayBuffer) return Buffer.from(data);
+  return Buffer.concat(data);
+}
+function parseJson(data) {
+  try {
+    return JSON.parse(toBuffer(data).toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function isStartMessage(payload) {
+  if (!payload || typeof payload !== "object") return false;
+  const record = payload;
+  return record.type === "start" && typeof record.sessionId === "string";
+}
+function handleVoiceAsrConnection(ws, store, logger, providers) {
+  let provider = null;
+  function start(payload) {
+    const config = store.readSecret();
+    if (!config.apiKey) {
+      sendJson(ws, {
+        type: "error",
+        errorCode: "not_configured",
+        error: "Voice provider is not configured"
+      });
+      return;
+    }
+    provider?.close();
+    provider = providers.current(config).createAsrClient(config, {
+      sampleRate: payload.sampleRate ?? 16e3,
+      language: "zh"
+    });
+    provider.on("ready", () => sendJson(ws, { type: "ready" }));
+    provider.on("partial", (text) => sendJson(ws, { type: "partial", text }));
+    provider.on("final", (text) => sendJson(ws, { type: "final", text }));
+    provider.on(
+      "error",
+      (error) => sendJson(ws, { type: "error", error: error.message || "ASR failed" })
+    );
+    provider.on("closed", (code, reason) => sendJson(ws, { type: "closed", code, reason }));
+  }
+  ws.on("message", (data, isBinary) => {
+    if (isBinary) {
+      provider?.sendPcm(toBuffer(data));
+      return;
+    }
+    const payload = parseJson(data);
+    if (isStartMessage(payload)) {
+      start(payload);
+      return;
+    }
+    if (payload && typeof payload === "object" && payload.type === "stop") {
+      provider?.stop();
+    }
+  });
+  ws.on("close", () => {
+    provider?.close();
+    provider = null;
+  });
+  ws.on("error", (err) => {
+    logger.warn({ err }, "Voice ASR websocket error");
+    provider?.close();
+    provider = null;
+  });
+}
+
+// src/voice/tts-ws.ts
+import { WebSocket as WebSocket9 } from "ws";
+function sendJson2(ws, payload) {
+  if (ws.readyState === WebSocket9.OPEN) {
+    ws.send(JSON.stringify(payload));
+  }
+}
+function parseJson2(data) {
+  try {
+    const buffer = Buffer.isBuffer(data) ? data : data instanceof ArrayBuffer ? Buffer.from(data) : Buffer.concat(data);
+    return JSON.parse(buffer.toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function isSpeakMessage(payload) {
+  if (!payload || typeof payload !== "object") return false;
+  const record = payload;
+  return record.type === "speak" && typeof record.requestId === "string" && typeof record.text === "string" && record.text.length > 0;
+}
+function nowMs() {
+  return Date.now();
+}
+function buildStats(requestId, text, config) {
+  return {
+    requestId,
+    textChars: text.length,
+    provider: config.provider,
+    region: config.region,
+    ttsModel: config.ttsModel,
+    ttsVoice: config.ttsVoice,
+    startedAt: nowMs(),
+    firstAudioAt: null,
+    audioBytes: 0,
+    audioChunks: 0
+  };
+}
+function statsLogFields(stats) {
+  const currentTime = nowMs();
+  return {
+    requestId: stats.requestId,
+    textChars: stats.textChars,
+    provider: stats.provider,
+    region: stats.region,
+    ttsModel: stats.ttsModel,
+    ttsVoice: stats.ttsVoice,
+    audioBytes: stats.audioBytes,
+    audioChunks: stats.audioChunks,
+    durationMs: currentTime - stats.startedAt,
+    firstAudioMs: stats.firstAudioAt === null ? null : stats.firstAudioAt - stats.startedAt
+  };
+}
+function closeReasonText(reason) {
+  if (Buffer.isBuffer(reason)) return reason.toString("utf8");
+  return typeof reason === "string" ? reason : "";
+}
+function handleVoiceTtsConnection(ws, store, logger, providers) {
+  let provider = null;
+  let providerConfig = null;
+  let activeRequestId = null;
+  let activeStats = null;
+  function ensureProvider() {
+    if (provider && providerConfig) return { client: provider, config: providerConfig };
+    const config = store.readSecret();
+    if (!config.apiKey) {
+      sendJson2(ws, {
+        type: "error",
+        errorCode: "not_configured",
+        error: "Voice provider is not configured"
+      });
+      return null;
+    }
+    provider = providers.current(config).createTtsClient(config, {
+      sampleRate: 24e3
+    });
+    providerConfig = config;
+    provider.on("started", () => {
+      if (activeStats) logger.info(statsLogFields(activeStats), "Voice TTS started");
+      sendJson2(ws, { type: "started", requestId: activeRequestId });
+    });
+    provider.on("audio", (chunk) => {
+      if (activeStats) {
+        if (activeStats.firstAudioAt === null) activeStats.firstAudioAt = nowMs();
+        activeStats.audioBytes += chunk.byteLength;
+        activeStats.audioChunks += 1;
+      }
+      if (ws.readyState === WebSocket9.OPEN) ws.send(chunk);
+    });
+    provider.on("finished", () => {
+      if (activeStats) logger.info(statsLogFields(activeStats), "Voice TTS finished");
+      sendJson2(ws, { type: "finished", requestId: activeRequestId });
+      activeRequestId = null;
+      activeStats = null;
+    });
+    provider.on("error", (error) => {
+      if (activeStats) {
+        logger.warn(
+          { ...statsLogFields(activeStats), err: error },
+          "Voice TTS provider reported an error"
+        );
+      }
+      sendJson2(ws, {
+        type: "error",
+        requestId: activeRequestId,
+        error: error.message || "TTS failed"
+      });
+      activeRequestId = null;
+      activeStats = null;
+    });
+    provider.on("closed", (code, reason) => {
+      if (activeStats) {
+        logger.warn(
+          { ...statsLogFields(activeStats), code, reason },
+          "Voice TTS provider closed before finishing"
+        );
+        sendJson2(ws, {
+          type: "error",
+          requestId: activeRequestId,
+          errorCode: "provider_closed",
+          error: "Voice TTS provider closed before finishing"
+        });
+        activeRequestId = null;
+        activeStats = null;
+      } else {
+        logger.info({ code, reason }, "Voice TTS provider closed");
+        provider = null;
+        providerConfig = null;
+        return;
+      }
+      sendJson2(ws, { type: "closed", code, reason });
+      provider = null;
+      providerConfig = null;
+    });
+    return { client: provider, config };
+  }
+  ws.on("message", (data) => {
+    const payload = parseJson2(data);
+    if (!isSpeakMessage(payload)) return;
+    if (activeRequestId) {
+      sendJson2(ws, {
+        type: "error",
+        requestId: payload.requestId,
+        errorCode: "busy",
+        error: "Voice TTS is already speaking"
+      });
+      return;
+    }
+    const ensured = ensureProvider();
+    if (!ensured) return;
+    const { client, config } = ensured;
+    activeRequestId = payload.requestId;
+    activeStats = buildStats(payload.requestId, payload.text, config);
+    logger.info(statsLogFields(activeStats), "Voice TTS request received");
+    try {
+      client.speak(payload.text);
+    } catch (err) {
+      if (activeStats) {
+        logger.warn(
+          { ...statsLogFields(activeStats), err },
+          "Voice TTS request failed before provider accepted it"
+        );
+      }
+      sendJson2(ws, {
+        type: "error",
+        requestId: payload.requestId,
+        error: err instanceof Error ? err.message : "Voice TTS failed"
+      });
+      activeRequestId = null;
+      activeStats = null;
+    }
+  });
+  ws.on("close", (code, reason) => {
+    if (activeStats) {
+      logger.warn(
+        { ...statsLogFields(activeStats), code, reason: closeReasonText(reason) },
+        "Voice TTS client websocket closed before finishing"
+      );
+    }
+    const currentProvider = provider;
+    provider = null;
+    providerConfig = null;
+    activeRequestId = null;
+    activeStats = null;
+    currentProvider?.close();
+  });
+  ws.on("error", (err) => {
+    logger.warn({ err }, "Voice TTS websocket error");
+    provider?.close();
+    provider = null;
+    providerConfig = null;
+    activeRequestId = null;
+    activeStats = null;
+  });
+}
+
+// src/voice/capabilities.ts
+var CUSTOMIZATION_ENDPOINTS = {
+  cn: "https://dashscope.aliyuncs.com/api/v1/services/audio/tts/customization",
+  intl: "https://dashscope-intl.aliyuncs.com/api/v1/services/audio/tts/customization"
+};
+function modelFromCustomCosyVoiceId(voiceId) {
+  const match = voiceId.match(/^(cosyvoice-v3(?:\.5)?-(?:flash|plus))-/);
+  return match?.[1];
+}
+async function fetchCustomVoices(fetchImpl, config) {
+  if (!config.apiKey) return [];
+  const response = await fetchImpl(CUSTOMIZATION_ENDPOINTS[config.region], {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: "voice-enrollment",
+      input: {
+        action: "list_voice",
+        page_size: 100,
+        page_index: 0
+      }
+    })
+  });
+  if (!response.ok) return [];
+  const payload = response.json();
+  const voiceList = (await payload).output?.voice_list ?? [];
+  return voiceList.filter((voice) => !voice.status || voice.status === "OK").flatMap((voice) => {
+    if (!voice.voice_id) return [];
+    const model = modelFromCustomCosyVoiceId(voice.voice_id);
+    return [
+      {
+        value: voice.voice_id,
+        label: [voice.voice_id, "\u81EA\u5B9A\u4E49", voice.voice_prompt].filter(Boolean).join(" \xB7 "),
+        ...model ? { model } : {},
+        source: "custom"
+      }
+    ];
+  });
+}
+function createBailianVoiceCapabilitiesProvider(options = {}) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const now = options.now ?? Date.now;
+  return {
+    async read(config) {
+      let customVoices;
+      try {
+        customVoices = await fetchCustomVoices(fetchImpl, config);
+      } catch {
+        customVoices = [];
+      }
+      const bundled = createBundledBailianVoiceCapabilities(now());
+      return {
+        ...bundled,
+        ttsVoices: [...bundled.ttsVoices, ...customVoices]
+      };
+    }
+  };
+}
+
+// src/voice/bailian-provider.ts
+function requireApiKey(config) {
+  if (!config.apiKey) throw new Error("Voice provider is not configured");
+  return config.apiKey;
+}
+function createBailianVoiceProvider(options = {}) {
+  const asrClientFactory = options.asrClientFactory ?? createBailianAsrClient;
+  const ttsClientFactory = options.ttsClientFactory ?? createBailianTtsClient;
+  const capabilitiesProvider = options.capabilitiesProvider ?? createBailianVoiceCapabilitiesProvider();
+  const configTester = options.configTester ?? createBailianVoiceConfigTester({
+    asrClientFactory,
+    ttsClientFactory
+  });
+  return {
+    id: "aliyun-bailian",
+    createAsrClient(config, clientOptions) {
+      return asrClientFactory({
+        apiKey: requireApiKey(config),
+        region: config.region,
+        model: config.asrModel,
+        sampleRate: clientOptions.sampleRate,
+        language: clientOptions.language
+      });
+    },
+    createTtsClient(config, clientOptions) {
+      return ttsClientFactory({
+        apiKey: requireApiKey(config),
+        region: config.region,
+        model: config.ttsModel,
+        voice: config.ttsVoice,
+        sampleRate: clientOptions.sampleRate
+      });
+    },
+    readCapabilities(config) {
+      return capabilitiesProvider.read(config);
+    },
+    testConfig(config) {
+      return configTester.test(config);
+    }
+  };
+}
+
+// src/voice/provider.ts
+function createVoiceProviderRegistry(adapters) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const adapter of adapters) {
+    if (byId.has(adapter.id)) {
+      throw new Error(`Duplicate voice provider: ${adapter.id}`);
+    }
+    byId.set(adapter.id, adapter);
+  }
+  function require2(providerId) {
+    const adapter = byId.get(providerId);
+    if (!adapter) throw new Error(`Unsupported voice provider: ${providerId}`);
+    return adapter;
+  }
+  return {
+    current(config) {
+      return require2(config.provider);
+    },
+    require: require2
+  };
+}
+
 // src/server.ts
-var MODULE_DIR = dirname2(fileURLToPath2(import.meta.url));
+var MODULE_DIR = dirname3(fileURLToPath2(import.meta.url));
 var PACKAGED_FONTS_DIR = resolve(MODULE_DIR, "../assets/fonts");
 function createRelayServer(options) {
   const { heartbeatInterval = 3e4, logger, dataDir, proxyToken, clientToken, chaos } = options;
@@ -1560,6 +2965,18 @@ function createRelayServer(options) {
     );
   }
   const registry = new RelayRegistry();
+  const voiceConfigStore = createVoiceConfigStore({
+    dataDir,
+    defaults: options.voiceDefaults
+  });
+  const voiceProviders = options.voiceProviderRegistry ?? createVoiceProviderRegistry([
+    createBailianVoiceProvider({
+      asrClientFactory: options.voiceAsrClientFactory,
+      ttsClientFactory: options.voiceTtsClientFactory,
+      capabilitiesProvider: options.voiceCapabilitiesProvider,
+      configTester: options.voiceConfigTester
+    })
+  ]);
   const relayChaos = chaos?.enabled ? createRelayChaos(chaos, logger) : void 0;
   if (chaos?.enabled) {
     logger.warn(
@@ -1586,7 +3003,7 @@ function createRelayServer(options) {
       immutable: true
     })
   );
-  if (existsSync(fontAssetDir)) {
+  if (existsSync2(fontAssetDir)) {
     app.use(
       "/fonts",
       express.static(fontAssetDir, {
@@ -1607,6 +3024,8 @@ function createRelayServer(options) {
   const httpServer = createServer(app);
   const proxyWss = new WebSocketServer({ noServer: true });
   const clientWss = new WebSocketServer({ noServer: true });
+  const voiceAsrWss = new WebSocketServer({ noServer: true });
+  const voiceTtsWss = new WebSocketServer({ noServer: true });
   httpServer.on("upgrade", (request, socket, head) => {
     const url = new URL(request.url ?? "/", "http://localhost");
     const { pathname } = url;
@@ -1638,22 +3057,32 @@ function createRelayServer(options) {
       });
       return;
     }
-    if (pathname === "/client") {
+    if (pathname === "/client" || pathname === "/voice/asr" || pathname === "/voice/tts") {
       if (clientTokenRequired) {
         const token = url.searchParams.get("token");
         if (token !== clientToken) {
           logger.warn(
-            { ip: request.socket.remoteAddress },
-            "rejected /client upgrade: invalid token"
+            { ip: request.socket.remoteAddress, pathname },
+            "rejected client-side upgrade: invalid token"
           );
           socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
           socket.destroy();
           return;
         }
       }
-      clientWss.handleUpgrade(request, socket, head, (ws) => {
-        clientWss.emit("connection", ws, request);
-      });
+      if (pathname === "/client") {
+        clientWss.handleUpgrade(request, socket, head, (ws) => {
+          clientWss.emit("connection", ws, request);
+        });
+      } else if (pathname === "/voice/asr") {
+        voiceAsrWss.handleUpgrade(request, socket, head, (ws) => {
+          voiceAsrWss.emit("connection", ws, request);
+        });
+      } else {
+        voiceTtsWss.handleUpgrade(request, socket, head, (ws) => {
+          voiceTtsWss.emit("connection", ws, request);
+        });
+      }
       return;
     }
     socket.destroy();
@@ -1662,31 +3091,61 @@ function createRelayServer(options) {
     handleProxyConnection(ws, registry, logger, relayChaos);
   });
   clientWss.on("connection", (ws) => {
-    handleClientConnection(ws, registry, logger, relayChaos);
+    handleClientConnection(ws, registry, logger, relayChaos, voiceConfigStore, voiceProviders);
+  });
+  voiceAsrWss.on("connection", (ws) => {
+    handleVoiceAsrConnection(ws, voiceConfigStore, logger, voiceProviders);
+  });
+  voiceTtsWss.on("connection", (ws) => {
+    handleVoiceTtsConnection(ws, voiceConfigStore, logger, voiceProviders);
   });
   const proxyHeartbeat = setupHeartbeat(proxyWss, heartbeatInterval);
   const clientHeartbeat = setupHeartbeat(clientWss, heartbeatInterval);
+  const voiceAsrHeartbeat = setupHeartbeat(voiceAsrWss, heartbeatInterval);
+  const voiceTtsHeartbeat = setupHeartbeat(voiceTtsWss, heartbeatInterval);
   async function close() {
     clearInterval(proxyHeartbeat);
     clearInterval(clientHeartbeat);
+    clearInterval(voiceAsrHeartbeat);
+    clearInterval(voiceTtsHeartbeat);
     for (const ws of proxyWss.clients) {
       ws.terminate();
     }
     for (const ws of clientWss.clients) {
       ws.terminate();
     }
-    await new Promise((resolve2, reject) => {
-      proxyWss.close((err) => {
-        if (err) reject(err);
-        else resolve2();
-      });
-    });
-    await new Promise((resolve2, reject) => {
-      clientWss.close((err) => {
-        if (err) reject(err);
-        else resolve2();
-      });
-    });
+    for (const ws of voiceAsrWss.clients) {
+      ws.terminate();
+    }
+    for (const ws of voiceTtsWss.clients) {
+      ws.terminate();
+    }
+    await Promise.all([
+      new Promise((resolve2, reject) => {
+        proxyWss.close((err) => {
+          if (err) reject(err);
+          else resolve2();
+        });
+      }),
+      new Promise((resolve2, reject) => {
+        clientWss.close((err) => {
+          if (err) reject(err);
+          else resolve2();
+        });
+      }),
+      new Promise((resolve2, reject) => {
+        voiceAsrWss.close((err) => {
+          if (err) reject(err);
+          else resolve2();
+        });
+      }),
+      new Promise((resolve2, reject) => {
+        voiceTtsWss.close((err) => {
+          if (err) reject(err);
+          else resolve2();
+        });
+      })
+    ]);
     await new Promise((resolve2, reject) => {
       httpServer.close((err) => {
         if (err) reject(err);
@@ -1702,4 +3161,4 @@ export {
   parseRelayChaosFromEnv,
   createRelayServer
 };
-//# sourceMappingURL=chunk-DFVUNUQH.js.map
+//# sourceMappingURL=chunk-ERH2EO6I.js.map