@goodandready/dsh-tts 0.1.1 → 0.2.0

package/lib/client.js

@@ -53,22 +53,141 @@ window.__ModuleLoader__.load({
       document.head.appendChild(tag)
     }
 
-    const player = { audio: null, after: '', enabled: false }
+    // Проигрыватель.
+    //
+    // Раньше каждый пришедший кусок немедленно вытеснял предыдущий: при чтении
+    // ответа целиком это было незаметно, а при чтении по ходу слышался бы
+    // только последний. Теперь это очередь: следующее начинается, когда
+    // закончилось предыдущее.
+    const player = {
+      audio: null,
+      after: '',
+      enabled: false,
+      rate: 1,
+      chime: 'ding',
+      queue: [],
+      busy: false,
+      paused: false,
+      listeners: new Set(),
+    }
+
+    function playerChanged() {
+      for (const listener of [...player.listeners]) {
+        try { listener() } catch (listenerFailure) { /* чужой слушатель не наша забота */ }
+      }
+    }
+
+    function usePlayer() {
+      const [, force] = React.useReducer((n) => n + 1, 0)
+      React.useEffect(() => {
+        player.listeners.add(force)
+        return () => { player.listeners.delete(force) }
+      }, [])
+      return player
+    }
+
+    // Короткий сигнал рисуем сами: файл не нужен, значит нечего качать,
+    // хранить и настраивать.
+    function playChime(kind) {
+      return new Promise((resolve) => {
+        try {
+          const AC = window.AudioContext || window.webkitAudioContext
+          if (!AC) { resolve(); return }
+          const audioCtx = new AC()
+          const gain = audioCtx.createGain()
+          gain.connect(audioCtx.destination)
+          const tones = kind === 'beep' ? [880, 880] : [660, 990]
+          let at = audioCtx.currentTime
+          for (const freq of tones) {
+            const osc = audioCtx.createOscillator()
+            osc.frequency.value = freq
+            osc.connect(gain)
+            gain.gain.setValueAtTime(0.0001, at)
+            gain.gain.exponentialRampToValueAtTime(0.25, at + 0.02)
+            gain.gain.exponentialRampToValueAtTime(0.0001, at + 0.18)
+            osc.start(at)
+            osc.stop(at + 0.2)
+            at += 0.22
+          }
+          setTimeout(() => { try { audioCtx.close() } catch (already) { /* закрыт */ } resolve() }, 600)
+        } catch (noAudio) { resolve() }
+      })
+    }
+
+    // Провайдер не смог — читаем голосом браузера. Хуже по звучанию, но
+    // молчание хуже вдвойне: человек не узнает, что ответ готов.
+    function speakInBrowser(text) {
+      return new Promise((resolve) => {
+        try {
+          if (!window.speechSynthesis || !text) { resolve(); return }
+          const utterance = new SpeechSynthesisUtterance(String(text))
+          utterance.rate = Math.max(0.5, Math.min(2, player.rate || 1))
+          utterance.onend = () => resolve()
+          utterance.onerror = () => resolve()
+          window.speechSynthesis.speak(utterance)
+        } catch (noSpeech) { resolve() }
+      })
+    }
+
+    function playAudio(item) {
+      return new Promise((resolve) => {
+        try {
+          const bin = atob(item.audioBase64)
+          const bytes = new Uint8Array(bin.length)
+          for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i)
+          const blob = new Blob([bytes], { type: item.mime || 'audio/mpeg' })
+          const url = URL.createObjectURL(blob)
+          const audio = new Audio(url)
+          audio.playbackRate = Math.max(0.5, Math.min(2, player.rate || 1))
+          player.audio = audio
+          playerChanged()
+          const done = () => { URL.revokeObjectURL(url); player.audio = null; playerChanged(); resolve() }
+          audio.onended = done
+          audio.onerror = done
+          audio.play().catch(() => {
+            // Браузер не даёт играть без действия человека — не считаем это
+            // поломкой, просто ничего не звучит.
+            done()
+          })
+        } catch (cannotDecode) { resolve() }
+      })
+    }
 
-    function playItem(item) {
-      if (!item || item.error || !item.audioBase64) return
+    async function drainQueue() {
+      if (player.busy) return
+      player.busy = true
+      playerChanged()
       try {
-        if (player.audio) { try { player.audio.pause() } catch (e) { /* ignore */ } }
-        const bin = atob(item.audioBase64)
-        const bytes = new Uint8Array(bin.length)
-        for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i)
-        const blob = new Blob([bytes], { type: item.mime || 'audio/mpeg' })
-        const url = URL.createObjectURL(blob)
-        const audio = new Audio(url)
-        player.audio = audio
-        audio.onended = () => { URL.revokeObjectURL(url) }
-        audio.play().catch(() => { URL.revokeObjectURL(url) })
-      } catch (e) { /* autoplay policy or decode */ }
+        while (player.queue.length) {
+          if (player.paused) break
+          const item = player.queue.shift()
+          if (!item || item.kind === 'reserved') continue
+          if (item.kind === 'chime') { await playChime(item.chime || player.chime); continue }
+          if (item.audioBase64) await playAudio(item)
+          else if (item.error && item.text) await speakInBrowser(item.text)
+        }
+      } finally {
+        player.busy = false
+        playerChanged()
+      }
+    }
+
+    function stopPlayback() {
+      player.queue.length = 0
+      player.paused = false
+      if (player.audio) { try { player.audio.pause() } catch (already) { /* стоит */ } }
+      player.audio = null
+      try { if (window.speechSynthesis) window.speechSynthesis.cancel() } catch (noSpeech) { /* нет синтеза */ }
+      playerChanged()
+    }
+
+    function togglePause() {
+      player.paused = !player.paused
+      if (player.audio) {
+        try { player.paused ? player.audio.pause() : player.audio.play() } catch (already) { /* всё равно */ }
+      }
+      if (!player.paused) drainQueue()
+      playerChanged()
     }
 
     async function pollPending() {
@@ -77,17 +196,22 @@ window.__ModuleLoader__.load({
         if (!st.ok) return
         const meta = await st.json()
         player.enabled = !!(meta && meta.speakReplies)
+        if (meta && typeof meta.rate === 'number') player.rate = meta.rate
+        if (meta && meta.chime) player.chime = meta.chime
         if (!player.enabled) return
         const res = await fetch('/dsh-tts/pending?after=' + encodeURIComponent(player.after || ''), { cache: 'no-store' })
         if (!res.ok) return
         const data = await res.json()
         const items = data && Array.isArray(data.items) ? data.items : []
-        for (let i = 0; i < items.length; i++) {
-          const item = items[i]
+        for (const item of items) {
+          // Место в очереди занято, но синтез ещё идёт — подождём следующего
+          // опроса, иначе порядок фраз рассыплется.
+          if (item.kind === 'reserved') break
           player.after = item.id
-          playItem(item)
+          player.queue.push(item)
         }
-      } catch (e) { /* host restarting */ }
+        if (player.queue.length) drainQueue()
+      } catch (hostRestarting) { /* хост перезапускается */ }
     }
 
     function credOf(map, provider) {
@@ -243,6 +367,21 @@ window.__ModuleLoader__.load({
         commitKey(provider, raw).catch((e) => setErr(String(e && e.message ? e.message : e)))
       }
 
+      const boolField = (key, label, hint) => React.createElement('label', { className: 'dts-field' }, label,
+        React.createElement('input', {
+          type: 'checkbox', checked: !!(draft && draft[key]), disabled: !writable,
+          onChange: (e) => setTop(key, e.target.checked),
+        }),
+        React.createElement('span', { className: 'dts-sub' }, hint))
+
+      const numberField = (key, label, hint, step) => React.createElement('label', { className: 'dts-field' }, label,
+        React.createElement('input', {
+          type: 'number', step: step || 1,
+          value: draft && draft[key] !== undefined ? draft[key] : '', disabled: !writable,
+          onChange: (e) => setTop(key, Number(e.target.value)),
+        }),
+        React.createElement('span', { className: 'dts-sub' }, hint))
+
       const textField = (key, label, hint) => React.createElement('label', { className: 'dts-field' }, label,
         React.createElement('input', {
           value: draft && draft[key] !== undefined ? draft[key] : '', disabled: !writable,
@@ -278,6 +417,14 @@ window.__ModuleLoader__.load({
         ),
         React.createElement('div', { className: 'dts-block' },
           React.createElement('div', { className: 'dts-h' }, 'General'),
+          boolField('speakAsItGoes', 'Speak as it goes',
+            'Read each reply the moment it lands, sentence by sentence, instead of waiting for the whole turn.'),
+          numberField('rate', 'Playback speed', '0.5 to 2. Synthesis is untouched; the browser plays faster or slower.', 0.1),
+          boolField('announceApproval', 'Announce approvals',
+            'Say it out loud and play a chime when the agent stops for an approval or asks a question.'),
+          textField('approvalText', 'Approval wording', 'Said when an approval is asked for; the tool name is appended.'),
+          textField('questionText', 'Question wording', 'Said when the agent asks a question. Empty disables it.'),
+          textField('chime', 'Chime', 'ding, beep or none.'),
           textField('language', 'Language', 'Hint for voices that need a locale (eSpeak, Azure SSML).'),
           textField('piperModel', 'Piper model path', 'Absolute path to an ONNX model. Leave empty to skip Piper.'),
           textField('piperBin', 'Piper binary', 'Looked up in PATH unless absolute.'),
@@ -293,6 +440,34 @@ window.__ModuleLoader__.load({
       )
     }
 
+    // Кнопка в строке ввода: видно, что сейчас читается, и можно остановить.
+    function SpeakerControl() {
+      const p = usePlayer()
+      const active = !!p.audio || p.queue.length > 0 || p.busy
+      if (!active) return null
+      return React.createElement('div', { style: { display: 'inline-flex', gap: '4px', alignItems: 'center' } },
+        React.createElement('button', {
+          type: 'button',
+          className: 'dts-link',
+          title: p.paused ? 'Продолжить чтение' : 'Пауза',
+          onClick: togglePause,
+        }, p.paused ? '▶' : '❚❚'),
+        React.createElement('button', {
+          type: 'button',
+          className: 'dts-link',
+          title: 'Прекратить чтение',
+          onClick: stopPlayback,
+        }, '■'),
+      )
+    }
+
+    function registerSpeaker(ctx) {
+      ctx.slots.inject('conversation.input.dock', () => ctx.slots.register(
+        { name: 'conversation.input.dock', id: '@goodandready/dsh-tts', order: 5, label: () => 'Чтение' },
+        SpeakerControl,
+      ))
+    }
+
     function registerSettings(ctx) {
       ctx.slots.inject('settings.section', () => ctx.slots.register(
         { name: 'settings.section', id: '@goodandready/dsh-tts', order: 32, label: () => 'Speech', inject: () => ({ ctx: ctx }) },
@@ -303,6 +478,7 @@ window.__ModuleLoader__.load({
     exports.inject = ['slots']
     exports.apply = function apply(ctx) {
       registerSettings(ctx)
+      registerSpeaker(ctx)
       setInterval(pollPending, 1000)
     }
     return module.exports

package/lib/index.js

@@ -3,7 +3,7 @@ import { defineTool } from '@deepseek-ai/dsh-tools'
 import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { runChain } from './chain.js'
 import { makeProviders, PROVIDER_KEYS, DEFAULT_MODELS, DEFAULT_VOICES } from './providers.js'
-import { assistantText, stripForSpeech } from './text.js'
+import { assistantText, stripForSpeech, splitSentences } from './text.js'
 import {
   CLOUD_PROVIDERS,
   assertCredentialRef,
@@ -32,6 +32,36 @@ export const Config = z.object({
   speakReplies: z.boolean().default(false)
     .description('When on, speak each finished agent reply in the Web UI.'),
   language: z.string().default('ru'),
+  speakAsItGoes: z
+    .boolean()
+    .description('Speak each reply as it lands instead of waiting for the whole turn to finish. '
+      + 'Long answers start sounding almost at once because they are synthesized sentence by sentence.')
+    .default(true),
+  sentenceChars: z
+    .number()
+    .description('Upper bound of one spoken piece when speaking as it goes.')
+    .default(320),
+  rate: z
+    .number()
+    .description('Playback speed, 0.5 to 2. Synthesis is untouched; the browser plays faster or slower.')
+    .default(1),
+  announceApproval: z
+    .boolean()
+    .description('Say out loud when the agent stops and waits for an approval, and play a short chime. '
+      + 'Useful when you walk away from a long run.')
+    .default(true),
+  approvalText: z
+    .string()
+    .description('What to say when an approval is asked for. The tool name is appended.')
+    .default('Требуется подтверждение'),
+  questionText: z
+    .string()
+    .description('What to say when the agent asks a question. Empty disables it.')
+    .default('Агент задал вопрос'),
+  chime: z
+    .string()
+    .description('Short sound before an announcement: ding, beep or none.')
+    .default('ding'),
   maxChars: z.number().default(4000)
     .description('Longer replies are truncated before synthesis.'),
   chain: z.array(ChainEntry)
@@ -48,6 +78,9 @@ export const Config = z.object({
   azureKeyEnv: z.string().default('AZURE_SPEECH_KEY'),
   azureRegion: z.string().default('')
     .description('Azure Speech region, e.g. eastus. Required for the azure provider.'),
+  siliconflowKeyEnv: z.string().description('Credential holding the SiliconFlow key.').default('SILICONFLOW_API_KEY'),
+  deepinfraKeyEnv: z.string().description('Credential holding the DeepInfra key.').default('DEEPINFRA_API_KEY'),
+  fireworksKeyEnv: z.string().description('Credential holding the Fireworks key.').default('FIREWORKS_API_KEY'),
   groqKeyEnv: z.string().default('GROQ_API_KEY'),
   deepgramKeyEnv: z.string().default('DEEPGRAM_API_KEY'),
   openrouterKeyEnv: z.string().default('OPENROUTER_API_KEY'),
@@ -199,26 +232,94 @@ export function apply(ctx, config) {
     return runChain(order, providers)
   }
 
+  // Синтез одной фразы с постановкой в очередь. Порядок сохраняется: номер
+  // выдаётся сразу, а не когда ответит провайдер, — иначе короткие фразы
+  // обгоняли бы длинные.
+  function speakPiece(sid, text, cfg, kind) {
+    if (!text) return
+    const id = `u${++utteranceSeq}`
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
+    reserve(id)
+    synthesize(text, cfg, controller.signal)
+      .then((out) => settle(id, {
+        id,
+        sessionId: sid,
+        kind: kind || 'speech',
+        provider: out.provider,
+        mime: out.mime,
+        audioBase64: Buffer.from(out.audio).toString('base64'),
+        tookMs: out.tookMs,
+      }))
+      .catch((err) => settle(id, { id, sessionId: sid, kind: kind || 'speech', text, error: String(err && err.message || err) }))
+      .finally(() => clearTimeout(timer))
+  }
+
+  // Объявление: сначала короткий сигнал, затем фраза. Сигнал — не файл, его
+  // рисует сам браузер, поэтому ничего не качается и не хранится.
+  function announce(sid, text, cfg) {
+    if (cfg.chime && cfg.chime !== 'none') {
+      enqueue({ id: `u${++utteranceSeq}`, sessionId: sid, kind: 'chime', chime: cfg.chime })
+    }
+    speakPiece(sid, text, cfg, 'notice')
+  }
+
   function enqueue(item) {
     pending.push(item)
     const max = live().maxQueue || 8
     while (pending.length > max) pending.shift()
   }
 
+  // Место в очереди занимается до синтеза, чтобы порядок фраз совпадал с
+  // порядком речи, а не с тем, кто быстрее ответил.
+  function reserve(id) {
+    enqueue({ id, kind: 'reserved' })
+  }
+
+  function settle(id, item) {
+    const at = pending.findIndex((row) => row.id === id)
+    if (at === -1) { enqueue(item); return }
+    pending[at] = item
+  }
+
   ctx.effect(() => ctx.on('session/event', (session, event) => {
     const cfg = live()
     if (!cfg.speakReplies) return
     const sid = session && session.id
     if (!sid) return
+    // Агент упёрся в подтверждение и ждёт человека. Об этом стоит сказать
+    // вслух: иначе про остановку узнаёшь, когда вернёшься к экрану.
+    if (event.type === 'approval/asked') {
+      if (!cfg.announceApproval) return
+      const tool = event.data && event.data.toolName
+      announce(sid, cfg.approvalText + (tool ? ': ' + tool : ''), cfg)
+      return
+    }
+    if (event.type === 'question/requested') {
+      if (!cfg.announceApproval || !cfg.questionText) return
+      announce(sid, cfg.questionText, cfg)
+      return
+    }
+
     if (event.type === 'assistant/message') {
       const text = assistantText(event.data && event.data.message)
       if (!text) return
+      // Читаем по ходу: каждый пришедший кусок ответа озвучивается сразу,
+      // предложениями, и очередь проигрывается по порядку. Ждать конца хода
+      // значит молчать всё время, пока агент работает.
+      if (cfg.speakAsItGoes) {
+        const ready = stripForSpeech(text, cfg.maxChars)
+        for (const piece of splitSentences(ready, cfg.sentenceChars)) speakPiece(sid, piece, cfg)
+        return
+      }
       const cur = collectors.get(sid) || { parts: [] }
       cur.parts.push(text)
       collectors.set(sid, cur)
       return
     }
     if (event.type !== 'turn/end') return
+    // При чтении по ходу к концу хода уже всё сказано.
+    if (cfg.speakAsItGoes) { collectors.delete(sid); return }
     const cur = collectors.get(sid)
     collectors.delete(sid)
     const raw = cur && Array.isArray(cur.parts) ? cur.parts.join('\n') : ''
@@ -257,6 +358,8 @@ export function apply(ctx, config) {
       writeJson(res, 200, {
         ok: true,
         speakReplies: cfg.speakReplies,
+        rate: cfg.rate,
+        chime: cfg.chime,
         language: cfg.language,
         chain: cfg.chain,
         providers: PROVIDER_KEYS,

package/lib/providers.js

@@ -2,10 +2,23 @@ import { edgeSpeak, espeakSpeak, piperSpeak } from './local.js'
 
 export const PROVIDER_KEYS = [
   'openai', 'elevenlabs', 'google', 'azure', 'groq', 'deepgram', 'openrouter',
+  'siliconflow', 'deepinfra', 'fireworks',
   'edge', 'piper', 'espeak',
 ]
 
+// Провайдеры, говорящие на языке OpenAI: тот же путь /audio/speech, отличаются
+// только адресом, моделью и именем ключа. Каждый адрес проверен запросом без
+// ключа — все отвечают 401, то есть путь существует и ждёт ключ.
+export const OPENAI_COMPATIBLE = {
+  siliconflow: { baseUrl: 'https://api.siliconflow.cn/v1', keyEnv: 'SILICONFLOW_API_KEY' },
+  deepinfra: { baseUrl: 'https://api.deepinfra.com/v1/openai', keyEnv: 'DEEPINFRA_API_KEY' },
+  fireworks: { baseUrl: 'https://api.fireworks.ai/inference/v1', keyEnv: 'FIREWORKS_API_KEY' },
+}
+
 export const DEFAULT_MODELS = {
+  siliconflow: 'FunAudioLLM/CosyVoice2-0.5B',
+  deepinfra: 'hexgrad/Kokoro-82M',
+  fireworks: 'kokoro',
   openai: 'gpt-4o-mini-tts',
   elevenlabs: 'eleven_multilingual_v2',
   google: 'gemini-2.5-flash-preview-tts',
@@ -19,6 +32,9 @@ export const DEFAULT_MODELS = {
 }
 
 export const DEFAULT_VOICES = {
+  siliconflow: 'FunAudioLLM/CosyVoice2-0.5B:alex',
+  deepinfra: 'af_bella',
+  fireworks: 'af_bella',
   openai: 'alloy',
   elevenlabs: '21m00Tcm4TlvDq8ikWAM',
   google: 'Kore',
@@ -64,6 +80,32 @@ export function makeProviders(deps, req) {
     return { ok: audio.length > 0, provider: 'openai', audio, mime: 'audio/mpeg', reason: audio.length ? '' : 'empty audio' }
   }
 
+  // Одна реализация на всех, кто говорит на языке OpenAI: адрес и имя ключа
+  // берутся из таблицы, остальное совпадает буква в букву.
+  function openaiCompatible(key) {
+    const spec = OPENAI_COMPATIBLE[key]
+    return async function speak() {
+      const keyEnv = (cfg[key + 'KeyEnv'] || spec.keyEnv)
+      const token = await resolveKey(keyEnv)
+      if (!token) return { ok: false, provider: key, reason: `no ${keyEnv}` }
+      const base = cfg[key + 'BaseUrl'] || spec.baseUrl
+      const res = await fetchImpl(base + '/audio/speech', {
+        method: 'POST',
+        headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+        body: JSON.stringify({
+          model: pick(DEFAULT_MODELS, models, key),
+          input: text,
+          voice: pick(DEFAULT_VOICES, voices, key),
+          response_format: 'mp3',
+        }),
+        signal,
+      })
+      if (!res.ok) throw new Error(`${key} HTTP ${res.status}`)
+      const audio = asBuffer(Buffer.from(await res.arrayBuffer()))
+      return { ok: audio.length > 0, provider: key, audio, mime: 'audio/mpeg', reason: audio.length ? '' : 'empty audio' }
+    }
+  }
+
   async function elevenlabs() {
     const key = await resolveKey(cfg.elevenlabsKeyEnv)
     if (!key) return { ok: false, provider: 'elevenlabs', reason: `no ${cfg.elevenlabsKeyEnv}` }
@@ -217,7 +259,10 @@ export function makeProviders(deps, req) {
     }
   }
 
-  return { openai, elevenlabs, google, azure, groq, deepgram, openrouter, edge, piper, espeak }
+  const compatible = {}
+  for (const key of Object.keys(OPENAI_COMPATIBLE)) compatible[key] = openaiCompatible(key)
+
+  return { openai, elevenlabs, google, azure, groq, deepgram, openrouter, ...compatible, edge, piper, espeak }
 }
 
 function escapeXml(s) {

package/lib/text.js

@@ -29,3 +29,40 @@ export function assistantText(message) {
   if (!message) return ''
   return blocksToText(message.content)
 }
+
+/**
+ * Режет текст на куски по границам предложений.
+ *
+ * Нужно, чтобы чтение начиналось почти сразу: длинный ответ синтезируется
+ * целиком долго, а первое предложение — быстро. Куски короче нижнего порога
+ * прилипают к следующему: отдельная фраза «Да.» звучит рвано.
+ *
+ * @param text {string} уже очищенный текст
+ * @param maxChars {number} верхняя граница куска
+ * @returns {string[]}
+ */
+export function splitSentences(text, maxChars) {
+  const limit = Number(maxChars) > 0 ? Number(maxChars) : 320
+  const min = Math.min(60, Math.floor(limit / 3))
+  const source = String(text || '').trim()
+  if (!source) return []
+
+  const pieces = []
+  let current = ''
+  // Границей считаем точку, вопрос, восклицание, многоточие и перевод строки.
+  for (const part of source.split(/(?<=[.!?…])\s+|\n+/)) {
+    const chunk = String(part || '').trim()
+    if (!chunk) continue
+    if (!current) { current = chunk } else if (current.length < min) { current += ' ' + chunk }
+    else { pieces.push(current); current = chunk }
+    // Кусок длиннее предела режем по словам: провайдеры не любят простыни.
+    while (current.length > limit) {
+      let cut = current.lastIndexOf(' ', limit)
+      if (cut < min) cut = limit
+      pieces.push(current.slice(0, cut).trim())
+      current = current.slice(cut).trim()
+    }
+  }
+  if (current) pieces.push(current)
+  return pieces.filter(Boolean)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-tts",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Text-to-speech for DeepSeek Harness: speak agent replies in the Web UI with a provider fallback chain (OpenAI, ElevenLabs, Google, Azure, Groq, Deepgram, OpenRouter, Edge, Piper, eSpeak).",
   "license": "MIT",
   "type": "module",
@@ -31,7 +31,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/GooDAnDReaDY/dsh-tts.git"
+    "url": "git+https://github.com/GooDAnDReaDY/dsh-tts.git"
   },
   "homepage": "https://github.com/GooDAnDReaDY/dsh-tts",
   "bugs": {
@@ -59,5 +59,8 @@
     "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
     "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
     "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }