@goodandready/dsh-tts 0.3.23 → 0.4.0

package/lib/index.js

@@ -5,11 +5,12 @@ import { runChain } from './chain.js'
 import { makeProviders, PROVIDER_KEYS, DEFAULT_MODELS, DEFAULT_VOICES } from './providers.js'
 import { applyNarrationFilters, applyPronunciation, assistantText, detectLang, speechPhrases, splitSentences, stripForSpeech } from './text.js'
 import { cacheKey, createSpeechCache } from './cache.js'
-import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { createModelManager } from './engines/manager.js'
-import { EngineRegistry } from './engines/types.js'
+import { registerHttpRoutes } from './routes.js'
+import { broadcastStream, clearStreamSubscribers } from './stream-hub.js'
+import { writeJson } from './http-util.js'
 import {
   CLOUD_PROVIDERS,
   assertCredentialRef,
@@ -173,32 +174,6 @@ export const Config = z.object({
   maxQueue: z.number().default(8),
 })
 
-function writeJson(res, code, body) {
-  try {
-    res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' })
-    res.end(JSON.stringify(body))
-  } catch { /* socket closed */ }
-}
-
-function readBody(req, maxBytes) {
-  return new Promise((resolve, reject) => {
-    const chunks = []
-    let size = 0
-    req.on('data', (c) => {
-      size += c.length
-      if (size > maxBytes) { reject(new Error('body too large')); req.destroy(); return }
-      chunks.push(c)
-    })
-    req.on('end', () => resolve(Buffer.concat(chunks)))
-    req.on('error', reject)
-  })
-}
-
-/** Reject cross-site POSTs. Do not require loopback or Origin==Host: the Web UI is used over LAN and reverse proxies. */
-function isTrustedSettingsRequest(request) {
-  return request.headers['sec-fetch-site'] !== 'cross-site'
-}
-
 let utteranceSeq = 0
 
 export function apply(ctx, config) {
@@ -218,19 +193,11 @@ export function apply(ctx, config) {
 
   const pending = []
   const collectors = new Map()
-  const streamSubscribers = new Set()
 
   const modelManager = createModelManager({
     root: process.env.DSH_HOME || path.join(os.homedir(), '.dsh'),
   })
 
-  function broadcastStream(event, data) {
-    const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
-    for (const res of streamSubscribers) {
-      try { res.write(payload) } catch { streamSubscribers.delete(res) }
-    }
-  }
-
   async function resolveKey(ref) {
     try {
       const resolved = await ctx.credentials.resolve(credentialRef(ref))
@@ -306,13 +273,13 @@ export function apply(ctx, config) {
 
   const llm = ctx.llm
 
-  // Счётчики синтеза: в памяти, обнуляются рестартом и DELETE /stats.
+  // In-memory synthesis counters; reset on restart or DELETE /stats.
   const stats = { total: 0, cacheHits: 0, errors: 0, providers: {} }
 
-  // Дедупликация параллельных запросов на синтез (защита от Cache Stampede)
+  // In-flight synthesis deduplication (cache-stampede protection)
   const inFlightSyntheses = new Map()
 
-  // Кэш синтеза живёт рядом с прочими данными харнесса.
+  // Synthesis cache lives next to other harness data.
   const speechCache = createSpeechCache({
     root: process.env.DSH_HOME || path.join(os.homedir(), '.dsh'),
     maxBytes: () => {
@@ -320,11 +287,11 @@ export function apply(ctx, config) {
       return mb > 0 ? mb * 1024 * 1024 : 100 * 1024 * 1024
     },
   })
-  // Порог осмысленности: уникальные длинные куски (чтение по ходу) в кэш
-  // не кладём — иначе он забьётся мусором, который никогда не повторится.
+  // Cache only short repeatable phrases; long unique streaming chunks skip the cache.
+  // Otherwise the cache fills with garbage that never repeats.
   const CACHE_MAX_TEXT = 200
 
-  // Настройки чистки текста считаем на каждый вызов: конфиг живой.
+  // Text-cleaning options are read per call because config is live.
   function cleanOpts(cfg) {
     return { skipCode: cfg.skipCode !== false, phrases: speechPhrases(cfg.language) }
   }
@@ -337,13 +304,13 @@ export function apply(ctx, config) {
     )
   }
 
-  // Пересказ быстрой моделью. Любая неудача — пустая строка, вызывающая
-  // сторона тихо откатывается к обрезке.
+  // Fast-model summary. Any failure returns an empty string and the caller
+  // silently falls back to truncation.
   async function summarizeReply(text, cfg, signal) {
     const sentences = Number(cfg.summarySentences) > 0 ? Number(cfg.summarySentences) : 3
     if (!llm || typeof llm.stream !== 'function') return ''
     const opts = {
-      messages: [{ role: 'user', content: 'Перескажи текст в ' + sentences + ' предложениях на его языке. Только пересказ, без вступлений:\n\n' + text }],
+      messages: [{ role: 'user', content: 'Summarize the text in ' + sentences + ' sentences in the same language as the text. Summary only, no preamble:\n\n' + text }],
       signal,
     }
     const m = String(cfg.summaryModel || '')
@@ -384,15 +351,15 @@ export function apply(ctx, config) {
       models[entry.provider] = entry.model || DEFAULT_MODELS[entry.provider]
       voices[entry.provider] = entry.voice || DEFAULT_VOICES[entry.provider]
     }
-    // Ролевые переопределения: пустые поля наследуют основную цепочку.
+    // Role overrides: empty fields inherit the main chain.
     const ov = (cfg.roles && cfg.roles[role]) || {}
     if (ov.provider && PROVIDER_KEYS.includes(ov.provider)) order.unshift(ov.provider)
     if (order.length) {
       if (ov.model) models[order[0]] = ov.model
       if (ov.voice) voices[order[0]] = ov.voice
     }
-    // Скорость воспроизведения в ключ не входит: ею управляет браузер,
-    // на синтез она не влияет.
+    // Playback rate is browser-side only and is not part of the cache key.
+    // It does not affect synthesis.
     const cacheAllowed = cfg.cache !== false && text.length <= CACHE_MAX_TEXT
     if (cacheAllowed) {
       for (const provider of order) {
@@ -436,9 +403,8 @@ export function apply(ctx, config) {
     return synthPromise
   }
 
-  // Синтез одной фразы с постановкой в очередь. Порядок сохраняется: номер
-  // выдаётся сразу, а не когда ответит провайдер, — иначе короткие фразы
-  // обгоняли бы длинные.
+  // Synthesize one phrase with queue reservation. The id is issued immediately,
+  // not when the provider answers, so short phrases cannot overtake long ones.
   function speakPiece(sid, text, cfg, kind) {
     if (!text) return
     const role = kind === 'notice' ? 'approval' : kind === 'error' ? 'error' : (kind && kind !== 'speech' ? kind : 'reply')
@@ -465,8 +431,8 @@ export function apply(ctx, config) {
       .finally(() => clearTimeout(timer))
   }
 
-  // Объявление: сначала короткий сигнал, затем фраза. Сигнал — не файл, его
-  // рисует сам браузер, поэтому ничего не качается и не хранится.
+  // Announcement: short chime then phrase. The chime is drawn by the browser,
+  // so nothing is downloaded or stored.
   function roleChime(cfg, role) {
     const ov = (cfg.roles && cfg.roles[role]) || {}
     return ov.chime || cfg.chime
@@ -496,8 +462,8 @@ export function apply(ctx, config) {
     }
   }
 
-  // Место в очереди занимается до синтеза, чтобы порядок фраз совпадал с
-  // порядком речи, а не с тем, кто быстрее ответил.
+  // Reserve the queue slot before synthesis so phrase order matches
+  // speech order, not arrival race.
   function reserve(id) {
     enqueue({ id, kind: 'reserved' })
   }
@@ -516,8 +482,8 @@ export function apply(ctx, config) {
     if (!cfg.speakReplies) return
     const sid = session && session.id
     if (!sid) return
-    // Агент упёрся в подтверждение и ждёт человека. Об этом стоит сказать
-    // вслух: иначе про остановку узнаёшь, когда вернёшься к экрану.
+    // The agent is waiting for human approval — worth speaking aloud
+    // so the user notices without watching the screen.
     if (event.type === 'approval/asked') {
       if (!cfg.announceApproval) return
       const tool = event.data && event.data.toolName
@@ -535,9 +501,9 @@ export function apply(ctx, config) {
       const agentName = (event.data && (event.data.agent || (event.data.message && event.data.message.agent) || (event.data.message && event.data.message.author && event.data.message.author.name))) || (session && session.agent) || ''
       const activeRole = (agentName && cfg.roles && cfg.roles[agentName] && cfg.roles[agentName].provider) ? agentName : 'reply'
 
-      // Читаем по ходу: каждый пришедший кусок ответа озвучивается сразу,
-      // предложениями, и очередь проигрывается по порядку. Ждать конца хода
-      // значит молчать всё время, пока агент работает.
+      // Speak as it goes: each incoming chunk is spoken immediately
+      // in sentence pieces; waiting for turn end means silence while the agent works.
+      
       if (cfg.speakAsItGoes) {
         const ready = cleanText(text, cfg)
         for (const piece of splitSentences(ready, cfg.sentenceChars)) speakPiece(sid, piece, cfg, activeRole)
@@ -550,7 +516,7 @@ export function apply(ctx, config) {
       return
     }
     if (event.type !== 'turn/end') return
-    // При чтении по ходу к концу хода уже всё сказано.
+    // With speak-as-it-goes everything was already spoken by turn end.
     if (cfg.speakAsItGoes) { collectors.delete(sid); return }
     const cur = collectors.get(sid)
     collectors.delete(sid)
@@ -581,405 +547,25 @@ export function apply(ctx, config) {
       .finally(() => clearTimeout(timer))
   }), 'dsh-tts: speak finished replies')
 
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/status',
-    handler: async (req, res) => {
-      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
-      const cfg = live()
-      writeJson(res, 200, {
-        ok: true,
-        speakReplies: cfg.speakReplies,
-        enableLocalEngines: cfg.enableLocalEngines,
-        kokoroEnabled: cfg.kokoroEnabled,
-        f5Enabled: cfg.f5Enabled,
-        streamingEnabled: cfg.streamingEnabled,
-        rate: cfg.rate,
-        chime: cfg.chime,
-        bargeIn: cfg.bargeIn,
-        language: cfg.language,
-        chain: cfg.chain,
-        roles: cfg.roles,
-        providers: PROVIDER_KEYS,
-      })
-    },
-  }), 'dsh-tts: /status route')
 
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/stream',
-    handler: async (req, res) => {
-      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
-      try {
-        res.writeHead(200, {
-          'Content-Type': 'text/event-stream',
-          'Cache-Control': 'no-cache, no-transform',
-          'Connection': 'keep-alive',
-        })
-        res.write(': connected\n\n')
-        streamSubscribers.add(res)
-        req.on('close', () => streamSubscribers.delete(res))
-      } catch {
-        streamSubscribers.delete(res)
-      }
-    },
-  }), 'dsh-tts: /stream route')
+  registerHttpRoutes(ctx, {
+    live,
+    modelManager,
+    stats,
+    speechCache,
+    cleanText,
+    synthesize,
+    credentialsView,
+    configResponse,
+    storeProviderKey,
+    clearProviderKey,
+    pending,
+  })
 
   ctx.effect(() => () => {
-    for (const res of streamSubscribers) {
-      try { res.end() } catch {}
-    }
-    streamSubscribers.clear()
+    clearStreamSubscribers()
   }, 'dsh-tts: cleanup stream subscribers')
 
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/models/status',
-    handler: async (req, res) => {
-      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
-      try {
-        const list = await modelManager.listStatus()
-        writeJson(res, 200, { ok: true, models: list })
-      } catch (err) {
-        writeJson(res, 500, { ok: false, error: String(err && err.message || err) })
-      }
-    },
-  }), 'dsh-tts: /models/status route')
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/models/install',
-    handler: async (req, res) => {
-      if (req.method !== 'POST') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } }); return }
-      if (!isTrustedSettingsRequest(req)) {
-        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
-        return
-      }
-      let body = {}
-      try {
-        const raw = await readBody(req, 16 * 1024)
-        body = JSON.parse(raw.toString('utf8') || '{}')
-      } catch (e) {
-        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
-        return
-      }
-      const engine = String(body.engine || '').trim()
-      if (!engine) {
-        writeJson(res, 400, { ok: false, error: { code: 'param', message: 'missing engine parameter' } })
-        return
-      }
-      try {
-        // Fire installation in background or await initial start
-        modelManager.installModel(engine).catch(() => {})
-        const current = await modelManager.getStatus(engine)
-        writeJson(res, 200, { ok: true, model: current })
-      } catch (err) {
-        writeJson(res, 500, { ok: false, error: String(err && err.message || err) })
-      }
-    },
-  }), 'dsh-tts: /models/install route')
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/models/delete',
-    handler: async (req, res) => {
-      if (req.method !== 'DELETE' && req.method !== 'POST') {
-        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'DELETE or POST only' } })
-        return
-      }
-      if (!isTrustedSettingsRequest(req)) {
-        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
-        return
-      }
-      let body = {}
-      try {
-        const raw = await readBody(req, 16 * 1024)
-        body = JSON.parse(raw.toString('utf8') || '{}')
-      } catch { body = {} }
-      const engine = String(body.engine || '').trim()
-      if (!engine) {
-        writeJson(res, 400, { ok: false, error: { code: 'param', message: 'missing engine parameter' } })
-        return
-      }
-      try {
-        const result = await modelManager.deleteModel(engine)
-        writeJson(res, 200, { ok: true, model: result })
-      } catch (err) {
-        writeJson(res, 500, { ok: false, error: String(err && err.message || err) })
-      }
-    },
-  }), 'dsh-tts: /models/delete route')
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/integrations',
-    handler: async (req, res) => {
-      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
-      let voiceInstalled = false
-      let messengerInstalled = false
-
-      try {
-        if (typeof ctx.webServer?.hasRoute === 'function') {
-          voiceInstalled = ctx.webServer.hasRoute('/dsh-voice/status')
-          messengerInstalled = ctx.webServer.hasRoute('/dsh-messenger-gateway/status')
-        }
-      } catch {}
-
-      if (!voiceInstalled) {
-        try {
-          const rootDev = path.join(process.cwd(), '..', 'dsh-voice')
-          const rootNm = path.join(process.cwd(), 'node_modules', '@goodandready', 'dsh-voice')
-          if (fs.existsSync(rootDev) || fs.existsSync(rootNm)) {
-            voiceInstalled = true
-          }
-        } catch {}
-      }
-
-      if (!messengerInstalled) {
-        try {
-          const rootDev = path.join(process.cwd(), '..', 'dsh-messenger-gateway')
-          const rootNm = path.join(process.cwd(), 'node_modules', '@goodandready', 'dsh-messenger-gateway')
-          if (fs.existsSync(rootDev) || fs.existsSync(rootNm)) {
-            messengerInstalled = true
-          }
-        } catch {}
-      }
-
-      writeJson(res, 200, {
-        ok: true,
-        voice: {
-          installed: voiceInstalled,
-          package: '@goodandready/dsh-voice',
-          hint: 'dsh plugin --profile web add @goodandready/dsh-voice',
-        },
-        messenger: {
-          installed: messengerInstalled,
-          package: '@goodandready/dsh-messenger-gateway',
-          hint: 'dsh plugin --profile web add @goodandready/dsh-messenger-gateway',
-        },
-      })
-    },
-  }), 'dsh-tts: /integrations route')
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/cache',
-    handler: async (req, res) => {
-      if (req.method !== 'DELETE') {
-        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'DELETE only' } })
-        return
-      }
-      if (!isTrustedSettingsRequest(req)) {
-        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
-        return
-      }
-      const removed = await speechCache.clear()
-      writeJson(res, 200, { ok: true, removed })
-    },
-  }), 'dsh-tts: /cache route')
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/preview',
-    handler: async (req, res) => {
-      if (req.method !== 'POST') {
-        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
-        return
-      }
-      if (!isTrustedSettingsRequest(req)) {
-        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
-        return
-      }
-      let body = {}
-      try {
-        const raw = await readBody(req, 64 * 1024)
-        body = JSON.parse(raw.toString('utf8') || '{}')
-      } catch (e) {
-        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
-        return
-      }
-      const cfg = live()
-      const phrase = String(cfg.language || '').toLowerCase().startsWith('ru') ? 'Проверка голоса.' : 'Voice check.'
-      try {
-        const probe = Object.assign({}, cfg, {
-          chain: [{ provider: body.provider || '', model: body.model || '', voice: body.voice || '' }],
-        })
-        const out = await synthesize(String(body.text || phrase), probe, null, 'reply')
-        writeJson(res, 200, { ok: true, mime: out.mime, audioBase64: Buffer.from(out.audio).toString('base64') })
-      } catch (e) {
-        writeJson(res, 502, { ok: false, error: { code: 'tts', message: String(e && e.message || e) } })
-      }
-    },
-  }), 'dsh-tts: /preview route')
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/stats',
-    handler: async (req, res) => {
-      if (req.method === 'GET') {
-        writeJson(res, 200, { ok: true, total: stats.total, cacheHits: stats.cacheHits, errors: stats.errors, providers: stats.providers })
-        return
-      }
-      if (req.method !== 'DELETE') {
-        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET or DELETE' } })
-        return
-      }
-      if (!isTrustedSettingsRequest(req)) {
-        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
-        return
-      }
-      stats.total = 0
-      stats.cacheHits = 0
-      stats.errors = 0
-      stats.providers = {}
-      writeJson(res, 200, { ok: true })
-    },
-  }), 'dsh-tts: /stats route')
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/config',
-    handler: async (req, res) => {
-      if (req.method === 'GET') {
-        writeJson(res, 200, await configResponse())
-        return
-      }
-      if (req.method !== 'PUT' && req.method !== 'POST') {
-        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET or PUT' } })
-        return
-      }
-      if (!isTrustedSettingsRequest(req)) {
-        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'dsh-tts: settings writes are same-origin only' } })
-        return
-      }
-      if (!settingsApi) {
-        writeJson(res, 503, { ok: false, error: { code: 'settings', message: 'settings not ready' } })
-        return
-      }
-      let raw
-      try { raw = await readBody(req, 256 * 1024) } catch (e) {
-        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
-        return
-      }
-      let payload
-      try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch {
-        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
-        return
-      }
-      if (payload && typeof payload.config === 'object') {
-        payload = { ...payload.config, keys: payload.keys }
-      }
-      const keys = pendingKeyWrites(payload && payload.keys)
-      const stripped = stripSecretsFromConfig(payload)
-      let parsed
-      try { parsed = Config(stripped) } catch (e) {
-        writeJson(res, 400, { ok: false, error: { code: 'schema', message: String(e && e.message || e) } })
-        return
-      }
-      try {
-        for (const item of keys) {
-          await storeProviderKey(item.provider, item.value)
-        }
-        await settingsApi.replace(parsed)
-        writeJson(res, 200, await configResponse())
-      } catch (e) {
-        writeJson(res, 500, { ok: false, error: { code: 'save', message: String(e && e.message || e) } })
-      }
-    },
-  }), 'dsh-tts: /config route')
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/credential',
-    handler: async (req, res) => {
-      if (req.method !== 'PUT' && req.method !== 'DELETE') {
-        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'PUT or DELETE only' } })
-        return
-      }
-      if (!isTrustedSettingsRequest(req)) {
-        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'dsh-tts: keys are same-origin only' } })
-        return
-      }
-      let payload = {}
-      if (req.method === 'PUT' || (req.headers['content-length'] && Number(req.headers['content-length']) > 0)) {
-        let raw
-        try { raw = await readBody(req, 16 * 1024) } catch (e) {
-          writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
-          return
-        }
-        try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch {
-          writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
-          return
-        }
-      }
-      const provider = typeof payload.provider === 'string' ? payload.provider.trim() : ''
-      if (!needsApiKey(provider)) {
-        writeJson(res, 400, { ok: false, error: { code: 'provider', message: 'unknown cloud provider' } })
-        return
-      }
-      try {
-        if (req.method === 'DELETE') {
-          const ref = await clearProviderKey(provider)
-          writeJson(res, 200, { ok: true, ref, credentials: await credentialsView() })
-          return
-        }
-        const ref = await storeProviderKey(provider, payload.value)
-        writeJson(res, 200, { ok: true, ref, credentials: await credentialsView() })
-      } catch (e) {
-        writeJson(res, 400, { ok: false, error: { code: 'credential', message: String(e && e.message || e) } })
-      }
-    },
-  }), 'dsh-tts: /credential route')
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/pending',
-    handler: async (req, res) => {
-      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
-      const url = new URL(req.url || '/', 'http://127.0.0.1')
-      const after = url.searchParams.get('after') || ''
-      let items = pending.slice()
-      if (after) {
-        const idx = items.findIndex((x) => x.id === after)
-        items = idx >= 0 ? items.slice(idx + 1) : items
-      }
-      writeJson(res, 200, { ok: true, items })
-    },
-  }), 'dsh-tts: /pending route')
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-tts/speak',
-    handler: async (req, res) => {
-      if (req.method !== 'POST') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } }); return }
-      let raw
-      try { raw = await readBody(req, 256 * 1024) } catch (e) {
-        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } }); return
-      }
-      let payload
-      try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { payload = {} }
-      const text = cleanText(payload.text, live())
-      if (!text) { writeJson(res, 400, { ok: false, error: { code: 'no-text', message: 'no text' } }); return }
-      const cfg = live()
-      const controller = new AbortController()
-      const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
-      try {
-        const out = await synthesize(text, cfg, controller.signal)
-        writeJson(res, 200, {
-          ok: true,
-          provider: out.provider,
-          mime: out.mime,
-          audioBase64: Buffer.from(out.audio).toString('base64'),
-          tookMs: out.tookMs,
-        })
-      } catch (e) {
-        writeJson(res, 502, { ok: false, error: { code: 'chain', message: String(e && e.message || e) } })
-      } finally {
-        clearTimeout(timer)
-      }
-    },
-  }), 'dsh-tts: /speak route')
-
   ctx.tools.register(
     defineTool({
       name: 'speak_text',