@deepseek-ai/dsh-experimental-client-ui-voice-input 0.2.2-alpha.3 → 0.2.2-rc.2

package/src/client/microphone-device.ts

@@ -0,0 +1,20 @@
+/** Browser-local microphone preference shared by settings previews and dictation. */
+import { createSnapshotStore, type SnapshotStore } from '@deepseek-ai/dsh-client-store'
+
+/** An empty id follows the system input; labels store browser names without localized placeholders. */
+export interface MicrophoneDevice {
+  readonly id: string
+  readonly label: string
+}
+
+/**
+ * Restore the browser preference independently of Host recognition settings.
+ * @returns validated device selection, persisted through the shared Client store.
+ */
+export function createMicrophoneDeviceStore(): SnapshotStore<MicrophoneDevice> {
+  const store = createSnapshotStore<MicrophoneDevice>({ id: '', label: '' }, { persist: { name: 'dsh.voice-input.microphone' } })
+  const saved: unknown = store.getSnapshot()
+  if (!saved || typeof saved !== 'object' || !('id' in saved) || typeof saved.id !== 'string'
+    || !('label' in saved) || typeof saved.label !== 'string') store.set({ id: '', label: '' })
+  return store
+}

package/src/client/mount.ts

@@ -0,0 +1,77 @@
+/** Source-safe lifecycle for the optional speech Remote and browser UI. */
+import type { Context } from '@deepseek-ai/cordis'
+import type {} from '@deepseek-ai/dsh-api-remotes/client'
+import type {} from '@deepseek-ai/dsh-experimental-api-speech-to-text/remote'
+import type {} from '@deepseek-ai/dsh-client-locale/client'
+import type {} from '@deepseek-ai/dsh-client-ui-renderer/client'
+import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
+import type { TypertRemoteContribution } from '@deepseek-ai/dsh-typert-protocol'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-store'
+import { VoiceInput, type VoiceInputInjected } from './VoiceInput.tsx'
+import { Recording } from './audio.ts'
+import { createMicrophoneDeviceStore } from './microphone-device.ts'
+import { en, ja, es, fr, de, ru, pt, NS, zh } from './locales.ts'
+import type {} from '@deepseek-ai/dsh-client-ui-plugin-manager/client'
+import { observeReadiness } from './readiness.ts'
+import { VoicePreparation } from './PreparationCard.tsx'
+import { VoiceSetupPrompt } from './VoiceSetupPrompt.tsx'
+
+export const inject = ['remote', 'slots', 'locale']
+
+function registerUi(ctx: Context): void {
+  ctx.effect(() => ctx.locale.register(NS, { zh, en, ja, es, fr, de, ru, pt }))
+  const recordings = new Set<Recording>()
+  const microphone = createMicrophoneDeviceStore()
+  const readiness = observeReadiness(ctx)
+  ctx.effect(() => readiness.dispose)
+  ctx.effect(() => async () => { await Promise.all([...recordings].map(recording => recording.dispose())) })
+  // The Plugins page provides its navigation only while the current Peer may use it.
+  const pluginNavigation = createSnapshotStore(false)
+  ctx.inject(['pluginNavigation'], (scope: Context) => {
+    scope.effect(() => {
+      pluginNavigation.set(true)
+      return () => { pluginNavigation.set(false) }
+    }, 'voice-input: plugin navigation presence')
+  })
+  const actions: VoiceInputInjected = {
+    openSettings: () => { ctx.get('pluginNavigation')?.openBundle('@deepseek-ai/dsh-experimental-voice-input-bundle') },
+    hooks: { speechReadiness: readiness.state, microphoneDevice: microphone, pluginNavigation },
+    selectMicrophone: (device) => { microphone.set(device) },
+    createRecording: () => {
+      const recording = new Recording(() => { recordings.delete(recording) }, microphone.getSnapshot().id)
+      recordings.add(recording)
+      return recording
+    },
+    transcribe: async (request, signal) => await ctx.remote.speech.transcribe(request, signal),
+    configure: async (patch) => { const result = await ctx.remote.speech.configure(patch); if (!result.ok) throw result.error },
+    prepare: async (providerId, options) => {
+      const result = await ctx.remote.speech.prepare(providerId, options); if (!result.ok) throw result.error
+    },
+    cancelPreparation: async (providerId) => {
+      const result = await ctx.remote.speech.cancelPreparation(providerId); if (!result.ok) throw result.error
+    },
+  }
+  ctx.slots.inject('conversation.input.activity', () => ctx.slots.register({
+    name: 'conversation.input.activity', locale: NS, inject: () => actions,
+  }, VoiceInput))
+  ctx.slots.inject('plugins.bundle.config', () => ctx.slots.register({ name: 'plugins.bundle.config',
+    key: '@deepseek-ai/dsh-experimental-voice-input-bundle', locale: NS, inject: () => actions,
+  }, VoicePreparation))
+  ctx.slots.inject('plugins.bundle.activation', () => ctx.slots.register({ name: 'plugins.bundle.activation',
+    key: '@deepseek-ai/dsh-experimental-voice-input-bundle', locale: NS, inject: () => actions,
+  }, VoiceSetupPrompt))
+
+}
+
+/**
+ * Mount this experimental namespace without adding it to stable API Remotes.
+ * @param ctx - Client runtime owning the Remote, dictionaries and slots.
+ * @param contribution - generated speech Remote definitions.
+ * @returns disposer joining UI and Remote withdrawal.
+ */
+export async function mountVoiceInput(ctx: Context, contribution: TypertRemoteContribution): Promise<() => Promise<void>> {
+  const disposeRemote = await ctx.remote.$mount(contribution)
+  const ui = ctx.inject(['remote.speech', 'slots', 'locale'], registerUi)
+  try { await ui } catch (error) { await ui.dispose(); await disposeRemote(); throw error }
+  return async () => { await ui.dispose(); await disposeRemote() }
+}

package/src/client/readiness.ts

@@ -0,0 +1,40 @@
+/** One reconnecting Host readiness mirror shared by every voice UI occurrence. */
+import type { Context } from '@deepseek-ai/cordis'
+import { RemoteStreamCarrierError } from '@deepseek-ai/dsh-api-gateway/client'
+import { createSnapshotStore, type SnapshotStore } from '@deepseek-ai/dsh-client-store'
+import type { SpeechCatalog } from '@deepseek-ai/dsh-experimental-api-speech-to-text/types'
+import type {} from '@deepseek-ai/dsh-experimental-api-speech-to-text/remote'
+
+/** Complete provider state, with a separate transport failure that never rewrites Host readiness. */
+export interface SpeechReadiness {
+  readonly catalog: SpeechCatalog | null
+  readonly connected: boolean
+  readonly error: string | null
+}
+
+/**
+ * Subscribe once per Client plugin, independent of rendered pages and Sessions.
+ * @param ctx - mounted speech Remote owner.
+ * @returns shared readiness snapshot and joined observation cleanup.
+ */
+export function observeReadiness(ctx: Context): { state: SnapshotStore<SpeechReadiness>; dispose: () => Promise<void> } {
+  const state = createSnapshotStore<SpeechReadiness>({ catalog: null, connected: false, error: null })
+  let disposed = false
+  const isDisposed = (): boolean => disposed
+  const fail = (error: unknown): void => {
+    state.set({ ...state.getSnapshot(), connected: false, error: error instanceof Error ? error.message : String(error) })
+  }
+  const stream = ctx.remote.$stream<SpeechCatalog>({
+    name: 'Speech readiness', open: signal => ctx.remote.speech.follow(signal),
+    ended: () => new RemoteStreamCarrierError('Speech readiness stream ended'), carrierFailed: fail,
+  })
+  const observing = (async () => {
+    try {
+      for await (const item of stream) {
+        state.set({ catalog: item.value, connected: true, error: null })
+        item.accept()
+      }
+    } catch (error) { if (!isDisposed()) fail(error) }
+  })()
+  return { state, dispose: async () => { disposed = true; await stream.dispose(); await observing } }
+}

package/src/css-modules.d.ts

@@ -0,0 +1,5 @@
+/** CSS module names emitted by the browser bundle. */
+declare module '*.module.css' {
+  const classes: Record<string, string>
+  export default classes
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+/** Host marker for the optional browser voice input contribution. */
+/** Browser behavior is provided by the client export. */
+export function apply(): void {}