feat: voice mode asr

.gitignore

@@ -4,6 +4,9 @@ cli
 .codex
 VersperClaw
 
+# Prebuilt native binaries (tracked in claude-code/ reference)
+vendor/audio-capture/
+
 # Desktop (Tauri) build artifacts
 desktop/src-tauri/target/
 desktop/src-tauri/binaries/

package.json

@@ -2,6 +2,9 @@
   "name": "claude-code-source-snapshot",
   "version": "2.1.87",
   "private": true,
+  "workspaces": [
+    "packages/*"
+  ],
   "description": "Reconstructed Bun CLI workspace for the Claude Code source snapshot.",
   "type": "module",
   "packageManager": "bun@1.3.11",
@@ -57,10 +60,13 @@
     "@opentelemetry/semantic-conventions": "^1.40.0",
     "@smithy/core": "^3.23.13",
     "@smithy/node-http-handler": "^4.5.1",
+    "@tavily/core": "^0.6.1",
     "@yukiakai/tls-fetch": "^2.0.2",
     "ajv": "^8.18.0",
     "asciichart": "^1.5.25",
+    "audio-capture-napi": "workspace:*",
     "auto-bind": "^5.0.1",
+    "axios": "^1.15.2",
     "bidi-js": "^1.0.3",
     "cacache": "^20.0.4",
     "chalk": "^5.6.2",
@@ -69,6 +75,7 @@
     "cli-highlight": "^2.1.11",
     "code-excerpt": "^4.0.0",
     "diff": "^8.0.4",
+    "doubaoime-asr": "^0.1.0",
     "emoji-regex": "^10.6.0",
     "env-paths": "^4.0.0",
     "execa": "^9.6.1",
@@ -112,7 +119,6 @@
     "ws": "^8.20.0",
     "xss": "^1.0.15",
     "yaml": "^2.8.3",
-    "@tavily/core": "^0.6.1",
     "zod": "^4.3.6"
   },
   "devDependencies": {

packages/audio-capture-napi/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "audio-capture-napi",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts"
+}

packages/audio-capture-napi/src/index.ts

@@ -0,0 +1,181 @@
+import { createRequire } from 'node:module'
+import { dirname, resolve, sep } from 'node:path'
+import { fileURLToPath } from 'node:url'
+// createRequire works in both Bun and Node.js ESM contexts.
+// Needed because this package is "type": "module" but uses require() for
+// loading native .node addons — bare require is not available in Node.js ESM.
+const nodeRequire = createRequire(import.meta.url)
+
+/**
+ * Resolve the "vendor root" directory where native .node binaries live.
+ *
+ * - Dev mode:  import.meta.url → packages/audio-capture-napi/src/index.ts
+ *              → vendor root = <project>/vendor/
+ * - Bun build: import.meta.url → dist/chunk-xxx.js
+ *              → vendor root = <project>/dist/vendor/
+ * - Vite build: import.meta.url → dist/chunks/chunk-xxx.js
+ *              → vendor root = <project>/dist/vendor/
+ */
+function getVendorRoot(): string {
+  const filePath = fileURLToPath(import.meta.url)
+  const dir = dirname(filePath)
+  const parts = dir.split(sep)
+  const distIdx = parts.lastIndexOf('dist')
+  if (distIdx !== -1) {
+    return parts.slice(0, distIdx + 1).join(sep) + sep + 'vendor'
+  }
+  // Dev mode — go up from packages/audio-capture-napi/src/ to project root
+  return resolve(dir, '..', '..', '..', 'vendor')
+}
+
+type AudioCaptureNapi = {
+  startRecording(onData: (data: Buffer) => void, onEnd: () => void): boolean
+  stopRecording(): void
+  isRecording(): boolean
+  startPlayback(sampleRate: number, channels: number): boolean
+  writePlaybackData(data: Buffer): void
+  stopPlayback(): void
+  isPlaying(): boolean
+  // TCC microphone authorization status (macOS only):
+  // 0 = notDetermined, 1 = restricted, 2 = denied, 3 = authorized.
+  // Linux: always returns 3 (authorized) — no system-level microphone permission API.
+  // Windows: returns 3 (authorized) if registry key absent or allowed,
+  //          2 (denied) if microphone access is explicitly denied.
+  microphoneAuthorizationStatus?(): number
+}
+
+let cachedModule: AudioCaptureNapi | null = null
+let loadAttempted = false
+
+function loadModule(): AudioCaptureNapi | null {
+  if (loadAttempted) {
+    return cachedModule
+  }
+  loadAttempted = true
+
+  // Supported platforms: macOS (darwin), Linux, Windows (win32)
+  const platform = process.platform
+  if (platform !== 'darwin' && platform !== 'linux' && platform !== 'win32') {
+    return null
+  }
+
+  // Candidate 1: native-embed path (bun compile). AUDIO_CAPTURE_NODE_PATH is
+  // defined at build time in build-with-plugins.ts for native builds only — the
+  // define resolves it to the static literal "../../audio-capture.node" so bun
+  // compile can rewrite it to /$bunfs/root/audio-capture.node. MUST stay a
+  // direct require(env var) — bun cannot analyze require(variable) from a loop.
+  if (process.env.AUDIO_CAPTURE_NODE_PATH) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      cachedModule = nodeRequire(
+        process.env.AUDIO_CAPTURE_NODE_PATH,
+      ) as AudioCaptureNapi
+      return cachedModule
+    } catch {
+      // fall through to runtime fallbacks below
+    }
+  }
+
+  // Candidates 2-5: resolved vendor path + relative fallbacks.
+  // The primary candidate uses getVendorRoot() to find the correct dist root
+  // regardless of chunk nesting depth. Relative fallbacks cover edge cases.
+  const platformDir = `${process.arch}-${platform}`
+  const binaryRel = `audio-capture/${platformDir}/audio-capture.node`
+  const vendorRoot = getVendorRoot()
+  const fallbacks = [
+    resolve(vendorRoot, binaryRel),
+    `./vendor/${binaryRel}`,
+    `../vendor/${binaryRel}`,
+    `../../vendor/${binaryRel}`,
+    `${process.cwd()}/vendor/${binaryRel}`,
+  ]
+  for (const p of fallbacks) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      cachedModule = nodeRequire(p) as AudioCaptureNapi
+      return cachedModule
+    } catch {
+      // try next
+    }
+  }
+  return null
+}
+
+export function isNativeAudioAvailable(): boolean {
+  return loadModule() !== null
+}
+
+export function startNativeRecording(
+  onData: (data: Buffer) => void,
+  onEnd: () => void,
+): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.startRecording(onData, onEnd)
+}
+
+export function stopNativeRecording(): void {
+  const mod = loadModule()
+  if (!mod) {
+    return
+  }
+  mod.stopRecording()
+}
+
+export function isNativeRecordingActive(): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.isRecording()
+}
+
+export function startNativePlayback(
+  sampleRate: number,
+  channels: number,
+): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.startPlayback(sampleRate, channels)
+}
+
+export function writeNativePlaybackData(data: Buffer): void {
+  const mod = loadModule()
+  if (!mod) {
+    return
+  }
+  mod.writePlaybackData(data)
+}
+
+export function stopNativePlayback(): void {
+  const mod = loadModule()
+  if (!mod) {
+    return
+  }
+  mod.stopPlayback()
+}
+
+export function isNativePlaying(): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.isPlaying()
+}
+
+// Returns the microphone authorization status.
+// On macOS, returns the TCC status: 0=notDetermined, 1=restricted, 2=denied, 3=authorized.
+// On Linux, always returns 3 (authorized) — no system-level mic permission API.
+// On Windows, returns 3 (authorized) if registry key absent or allowed, 2 (denied) if explicitly denied.
+// Returns 0 (notDetermined) if the native module is unavailable.
+export function microphoneAuthorizationStatus(): number {
+  const mod = loadModule()
+  if (!mod || !mod.microphoneAuthorizationStatus) {
+    return 0
+  }
+  return mod.microphoneAuthorizationStatus()
+}

packages/audio-capture-napi/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

scripts/build.ts

@@ -1,5 +1,5 @@
-import { chmodSync, existsSync, mkdirSync } from 'fs'
-import { dirname } from 'path'
+import { chmodSync, cpSync, existsSync, mkdirSync } from 'fs'
+import { dirname, join } from 'path'
 
 const pkg = await Bun.file(new URL('../package.json', import.meta.url)).json() as {
   name: string
@@ -203,5 +203,15 @@ if (existsSync(outfile)) {
   chmodSync(outfile, 0o755)
 }
 
+// Copy vendor audio-capture binaries to dist/ for runtime resolution
+if (!compile) {
+  const distDir = dirname(outfile)
+  const vendorDir = join(distDir, 'vendor')
+  if (!existsSync(vendorDir)) {
+    cpSync('vendor', vendorDir, { recursive: true })
+    console.log(`Copied vendor/ → ${vendorDir}/`)
+  }
+}
+
 console.log(`Built ${outfile}`)
 

src/commands/voice/index.ts

@@ -1,17 +1,16 @@
 import type { Command } from '../../commands.js'
 import {
+  isVoiceAvailable,
   isVoiceGrowthBookEnabled,
-  isVoiceModeEnabled,
 } from '../../voice/voiceModeEnabled.js'
 
 const voice = {
   type: 'local',
   name: 'voice',
   description: 'Toggle voice mode',
-  availability: ['claude-ai'],
   isEnabled: () => isVoiceGrowthBookEnabled(),
   get isHidden() {
-    return !isVoiceModeEnabled()
+    return !isVoiceAvailable()
   },
   supportsNonInteractive: false,
   load: () => import('./voice.js'),

src/commands/voice/voice.ts

@@ -9,22 +9,13 @@ import {
   getInitialSettings,
   updateSettingsForSource,
 } from '../../utils/settings/settings.js'
-import { isVoiceModeEnabled } from '../../voice/voiceModeEnabled.js'
+import { isVoiceAvailable } from '../../voice/voiceModeEnabled.js'
 
 const LANG_HINT_MAX_SHOWS = 2
 
 export const call: LocalCommandCall = async () => {
-  // Check auth and kill-switch before allowing voice mode
-  if (!isVoiceModeEnabled()) {
-    // Differentiate: OAuth-less users get an auth hint, everyone else
-    // gets nothing (command shouldn't be reachable when the kill-switch is on).
-    if (!isAnthropicAuthEnabled()) {
-      return {
-        type: 'text' as const,
-        value:
-          'Voice mode requires a Claude.ai account. Please run /login to sign in.',
-      }
-    }
+  // Check only the GrowthBook kill-switch — voice might use Doubao (no auth)
+  if (!isVoiceAvailable()) {
     return {
       type: 'text' as const,
       value: 'Voice mode is not available.',
@@ -60,6 +51,28 @@ export const call: LocalCommandCall = async () => {
   )
   const { checkRecordingAvailability } = await import('../../services/voice.js')
 
+  // Determine available STT backend: prefer Anthropic, fall back to Doubao
+  const hasAnthropicAuth = isAnthropicAuthEnabled() && isVoiceStreamAvailable()
+  let useDoubao = false
+  if (!hasAnthropicAuth) {
+    const { isDoubaoAvailable } = await import('../../services/doubaoSTT.js')
+    if (!(await isDoubaoAvailable())) {
+      // Neither backend is available
+      if (!isAnthropicAuthEnabled()) {
+        return {
+          type: 'text' as const,
+          value:
+            'Voice mode requires a Claude.ai account or the Doubao ASR backend. Please run /login to sign in, or install Doubao ASR.',
+        }
+      }
+      return {
+        type: 'text' as const,
+        value: 'Voice mode is not available.',
+      }
+    }
+    useDoubao = true
+  }
+
   // Check recording availability (microphone access)
   const recording = await checkRecordingAvailability()
   if (!recording.available) {
@@ -70,15 +83,6 @@ export const call: LocalCommandCall = async () => {
     }
   }
 
-  // Check for API key
-  if (!isVoiceStreamAvailable()) {
-    return {
-      type: 'text' as const,
-      value:
-        'Voice mode requires a Claude.ai account. Please run /login to sign in.',
-    }
-  }
-
   // Check for recording tools
   const { checkVoiceDependencies, requestMicrophonePermission } = await import(
     '../../services/voice.js'
@@ -111,8 +115,11 @@ export const call: LocalCommandCall = async () => {
     }
   }
 
-  // All checks passed — enable voice
-  const result = updateSettingsForSource('userSettings', { voiceEnabled: true })
+  // All checks passed — enable voice and store backend choice
+  const result = updateSettingsForSource('userSettings', {
+    voiceEnabled: true,
+    ...(useDoubao ? { voiceProvider: 'doubao' as const } : { voiceProvider: 'anthropic' as const }),
+  })
   if (result.error) {
     return {
       type: 'text' as const,
@@ -143,8 +150,9 @@ export const call: LocalCommandCall = async () => {
       voiceLangHintLastLanguage: stt.code,
     }))
   }
+  const backendNote = useDoubao ? ' [Doubao ASR]' : ''
   return {
     type: 'text' as const,
-    value: `Voice mode enabled. Hold ${key} to record.${langNote}`,
+    value: `Voice mode enabled. Hold ${key} to record.${langNote}${backendNote}`,
   }
 }

src/hooks/useVoice.ts

@@ -9,6 +9,7 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { useSetVoiceState } from '../context/voice.js'
 import { useTerminalFocus } from '../ink/hooks/use-terminal-focus.js'
+import { isDoubaoAvailableSync } from '../services/doubaoSTT.js'
 import {
   type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
   logEvent,
@@ -20,6 +21,7 @@ import {
   isVoiceStreamAvailable,
   type VoiceStreamConnection,
 } from '../services/voiceStreamSTT.js'
+import { connectDoubaoStream } from '../services/doubaoSTT.js'
 import { logForDebugging } from '../utils/debug.js'
 import { toError } from '../utils/errors.js'
 import { getSystemLocaleLanguage } from '../utils/intl.js'
@@ -133,6 +135,10 @@ export function normalizeLanguageForSTT(language: string | undefined): {
   return { code: DEFAULT_STT_LANGUAGE, fellBackFrom: language }
 }
 
+function isDoubaoProvider(): boolean {
+  return getInitialSettings().voiceProvider === 'doubao'
+}
+
 // Lazy-loaded voice module. We defer importing voice.ts (and its native
 // audio-capture-napi dependency) until voice input is actually activated.
 // On macOS, loading the native audio module can trigger a TCC microphone
@@ -574,7 +580,7 @@ export function useVoice({
   // stop when it loses focus. This enables a "multi-clauding army"
   // workflow where voice input follows window focus.
   useEffect(() => {
-    if (!enabled || !focusMode) {
+    if (!enabled || !focusMode || isDoubaoProvider()) {
       // Focus mode was disabled while a focus-driven recording was active —
       // stop the recording so it doesn't linger until the silence timer fires.
       if (focusTriggeredRef.current && stateRef.current === 'recording') {
@@ -778,7 +784,17 @@ export function useVoice({
 
     const attemptConnect = (keyterms: string[]): void => {
       const myAttemptGen = attemptGenRef.current
-      void connectVoiceStream(
+      // Select STT backend based on settings.voiceProvider
+      const connectFn = isDoubaoProvider()
+        ? (
+            cbs: Parameters<typeof connectDoubaoStream>[0],
+            opts: Parameters<typeof connectDoubaoStream>[1],
+          ) => connectDoubaoStream(cbs, opts)
+        : (
+            cbs: Parameters<typeof connectVoiceStream>[0],
+            opts: Parameters<typeof connectVoiceStream>[1],
+          ) => connectVoiceStream(cbs, opts)
+      void connectFn(
         {
           onTranscript: (text: string, isFinal: boolean) => {
             if (isStale()) return
@@ -1007,7 +1023,12 @@ export function useVoice({
       })
     }
 
-    void getVoiceKeyterms().then(attemptConnect)
+    // Doubao backend doesn't use keyterms — skip the async fetch
+    if (isDoubaoProvider()) {
+      attemptConnect([])
+    } else {
+      void getVoiceKeyterms().then(attemptConnect)
+    }
   }
 
   // ── Hold-to-talk handler ────────────────────────────────────────────
@@ -1021,7 +1042,10 @@ export function useVoice({
   // delay of ~500ms on macOS).
   const handleKeyEvent = useCallback(
     (fallbackMs = REPEAT_FALLBACK_MS): void => {
-      if (!enabled || !isVoiceStreamAvailable()) {
+      const sttAvailable = isDoubaoProvider()
+        ? isDoubaoAvailableSync()
+        : isVoiceStreamAvailable()
+      if (!enabled || !sttAvailable) {
         return
       }
 

src/services/doubaoSTT.ts

@@ -0,0 +1,258 @@
+// Doubao (豆包) ASR speech-to-text adapter for voice mode.
+//
+// Wraps the doubaoime-asr npm package to expose the same interface as
+// voiceStreamSTT.ts. The doubao backend uses an AsyncGenerator-based
+// streaming protocol internally; this adapter bridges it to the
+// send/finalize/close pattern used by useVoice.ts.
+
+import { homedir } from 'node:os'
+import type { ASRResponse } from 'doubaoime-asr'
+import type {
+  FinalizeSource,
+  VoiceStreamCallbacks,
+  VoiceStreamConnection,
+} from './voiceStreamSTT.js'
+import { logForDebugging } from '../utils/debug.js'
+import { logError } from '../utils/log.js'
+
+// Re-export FinalizeSource so useVoice can import from either module
+export type { FinalizeSource } from './voiceStreamSTT.js'
+
+// ─── AsyncIterable audio queue ─────────────────────────────────────────
+
+// A push-based queue that implements AsyncIterable<Uint8Array>.
+// send() pushes chunks; push(null) signals end-of-stream.
+class AudioChunkQueue {
+  private chunks: (Uint8Array | null)[] = []
+  private waiting: ((result: IteratorResult<Uint8Array>) => void) | null = null
+  private done = false
+
+  push(chunk: Uint8Array | null): void {
+    if (this.done) return
+    if (chunk === null) {
+      this.done = true
+      if (this.waiting) {
+        const resolve = this.waiting
+        this.waiting = null
+        resolve({ value: undefined, done: true })
+      }
+      return
+    }
+    if (this.waiting) {
+      const resolve = this.waiting
+      this.waiting = null
+      resolve({ value: chunk, done: false })
+    } else {
+      this.chunks.push(chunk)
+    }
+  }
+
+  abort(): void {
+    this.done = true
+    this.chunks.length = 0
+    if (this.waiting) {
+      const resolve = this.waiting
+      this.waiting = null
+      resolve({ value: undefined, done: true })
+    }
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<Uint8Array> {
+    return {
+      next: async (): Promise<IteratorResult<Uint8Array>> => {
+        if (this.chunks.length > 0) {
+          const chunk = this.chunks.shift()!
+          return { value: chunk, done: false }
+        }
+        if (this.done) {
+          return { value: undefined, done: true }
+        }
+        return new Promise<IteratorResult<Uint8Array>>(resolve => {
+          this.waiting = resolve
+        })
+      },
+    }
+  }
+}
+
+// ─── Availability ────────────────────────────────────────────────────────
+
+let doubaoAvailable: boolean | null = null
+
+export async function isDoubaoAvailable(): Promise<boolean> {
+  if (doubaoAvailable !== null) return doubaoAvailable
+  try {
+    await import('doubaoime-asr')
+    doubaoAvailable = true
+  } catch {
+    doubaoAvailable = false
+  }
+  return doubaoAvailable
+}
+
+// Synchronous check — returns cached result or optimistic true when
+// VOICE_PROVIDER=doubao is set and no cached result exists yet.
+// The actual import happens in connectDoubaoStream which reports errors.
+export function isDoubaoAvailableSync(): boolean {
+  if (doubaoAvailable !== null) return doubaoAvailable
+  return true
+}
+
+// ─── Connection ──────────────────────────────────────────────────────────
+
+export async function connectDoubaoStream(
+  callbacks: VoiceStreamCallbacks,
+  _options?: { language?: string },
+): Promise<VoiceStreamConnection | null> {
+  let doubaoAsr: typeof import('doubaoime-asr')
+  try {
+    doubaoAsr = await import('doubaoime-asr')
+  } catch (err) {
+    logError(
+      new Error(
+        `[doubao-asr] Failed to import doubaoime-asr package: ${String(err)}`,
+      ),
+    )
+    callbacks.onError(`doubaoime-asr package import failed: ${String(err)}`, {
+      fatal: true,
+    })
+    return null
+  }
+
+  const { transcribeRealtime, ASRConfig, ResponseType } = doubaoAsr
+
+  const queue = new AudioChunkQueue()
+  let finalized = false
+
+  // Resolve handle for finalize() promise — wrapped in an object to avoid
+  // TypeScript closure-scope type narrowing issues (TS2349 "not callable").
+  const finalizeHandle: { resolve: ((source: FinalizeSource) => void) | null } =
+    { resolve: null }
+
+  const connection: VoiceStreamConnection = {
+    send(audioChunk: Buffer): void {
+      if (finalized) return
+      queue.push(
+        new Uint8Array(
+          audioChunk.buffer,
+          audioChunk.byteOffset,
+          audioChunk.byteLength,
+        ),
+      )
+    },
+    finalize(): Promise<FinalizeSource> {
+      if (finalized) return Promise.resolve<FinalizeSource>('ws_already_closed')
+      finalized = true
+      queue.push(null) // signal end-of-stream to the generator
+      // Doubao returns FINAL_RESULT during recording — by the time the user
+      // releases the key, all transcripts are already in accumulatedRef.
+      // Resolve immediately so the UI skips the 'processing' state and goes
+      // straight to displaying the result.
+      logForDebugging('[doubao-asr] Finalize — resolving immediately')
+      return Promise.resolve<FinalizeSource>('post_closestream_endpoint')
+    },
+    close(): void {
+      finalized = true
+      queue.abort()
+      const r = finalizeHandle.resolve
+      finalizeHandle.resolve = null
+      if (r) r('ws_close')
+      callbacks.onClose()
+    },
+    isConnected(): boolean {
+      return true
+    },
+  }
+
+  // Start the ASR session in the background
+  const config = new ASRConfig({
+    credentialPath: `${homedir()}/.claude/tts/doubao/credentials.json`,
+  })
+
+  // Ensure credentials are initialized (may auto-generate)
+  try {
+    await config.ensureCredentials()
+  } catch (err) {
+    logError(
+      new Error(
+        `[doubao-asr] Credential initialization failed: ${String(err)}`,
+      ),
+    )
+    callbacks.onError(`Doubao ASR 凭证初始化失败: ${String(err)}`, {
+      fatal: true,
+    })
+    return null
+  }
+
+  // Fire onReady immediately — unlike the Anthropic WebSocket which needs to
+  // wait for a handshake, the doubao backend accepts audio through the queue
+  // and handles connection internally. The caller (useVoice.ts) needs onReady
+  // to fire before it will route audio chunks via connection.send().
+  logForDebugging('[doubao-asr] Firing onReady immediately')
+  callbacks.onReady(connection)
+
+  // Consume the AsyncGenerator in the background
+  void (async () => {
+    try {
+      const audioSource: AsyncIterable<Uint8Array> = queue
+      const gen: AsyncGenerator<ASRResponse> = transcribeRealtime(audioSource, {
+        config,
+      })
+
+      for await (const resp of gen) {
+        if (
+          finalized &&
+          resp.type !== ResponseType.FINAL_RESULT &&
+          resp.type !== ResponseType.SESSION_FINISHED
+        ) {
+          continue
+        }
+
+        switch (resp.type) {
+          case ResponseType.SESSION_STARTED:
+            logForDebugging('[doubao-asr] Session started')
+            break
+          case ResponseType.VAD_START:
+            logForDebugging('[doubao-asr] VAD detected speech start')
+            break
+          case ResponseType.INTERIM_RESULT:
+            if (resp.text) {
+              callbacks.onTranscript(resp.text, false)
+            }
+            break
+          case ResponseType.FINAL_RESULT:
+            if (resp.text) {
+              callbacks.onTranscript(resp.text, true)
+            }
+            break
+          case ResponseType.ERROR:
+            logError(new Error(`[doubao-asr] Error: ${resp.errorMsg}`))
+            if (!finalized) {
+              callbacks.onError(resp.errorMsg || 'Doubao ASR 识别错误')
+            }
+            break
+          case ResponseType.SESSION_FINISHED:
+            logForDebugging('[doubao-asr] Session finished')
+            break
+          default:
+            break
+        }
+      }
+
+      // Generator exhausted naturally
+      const r = finalizeHandle.resolve
+      finalizeHandle.resolve = null
+      if (r) r('post_closestream_endpoint')
+    } catch (err) {
+      logError(new Error(`[doubao-asr] Stream error: ${String(err)}`))
+      if (!finalized) {
+        callbacks.onError(`Doubao ASR 连接错误: ${String(err)}`)
+      }
+      const r2 = finalizeHandle.resolve
+      finalizeHandle.resolve = null
+      if (r2) r2('ws_close')
+    }
+  })()
+
+  return connection
+}

src/utils/settings/types.ts

@@ -867,6 +867,12 @@ export const SettingsSchema = lazySchema(() =>
               .boolean()
               .optional()
               .describe('Enable voice mode (hold-to-talk dictation)'),
+            voiceProvider: z
+              .enum(['anthropic', 'doubao'])
+              .optional()
+              .describe(
+                'Voice STT backend: "anthropic" (default) or "doubao" (Doubao ASR)',
+              ),
           }
         : {}),
       ...(feature('KAIROS')

src/voice/voiceModeEnabled.ts

@@ -44,11 +44,18 @@ export function hasVoiceAuth(): boolean {
 }
 
 /**
- * Full runtime check: auth + GrowthBook kill-switch. Callers: `/voice`
- * (voice.ts, voice/index.ts), ConfigTool, VoiceModeNotice — command-time
- * paths where a fresh keychain read is acceptable. For React render
- * paths use useVoiceEnabled() instead (memoizes the auth half).
+ * Full runtime check for Anthropic voice_stream backend.
+ * Returns true when both auth + GrowthBook kill-switch pass.
  */
 export function isVoiceModeEnabled(): boolean {
   return hasVoiceAuth() && isVoiceGrowthBookEnabled()
 }
+
+/**
+ * Check if voice mode can be activated with any STT backend.
+ * Always returns true when VOICE_MODE feature flag is on and GrowthBook
+ * kill-switch is off — the Doubao backend does not require Anthropic auth.
+ */
+export function isVoiceAvailable(): boolean {
+  return feature('VOICE_MODE')
+}

vendor/audio-capture-src/index.ts

@@ -0,0 +1,147 @@
+type AudioCaptureNapi = {
+  startRecording(onData: (data: Buffer) => void, onEnd: () => void): boolean
+  stopRecording(): void
+  isRecording(): boolean
+  startPlayback(sampleRate: number, channels: number): boolean
+  writePlaybackData(data: Buffer): void
+  stopPlayback(): void
+  isPlaying(): boolean
+  // TCC microphone authorization status (macOS only):
+  // 0 = notDetermined, 1 = restricted, 2 = denied, 3 = authorized.
+  // Linux: always returns 3 (authorized) — no system-level microphone permission API.
+  // Windows: returns 3 (authorized) if registry key absent or allowed,
+  //          2 (denied) if microphone access is explicitly denied.
+  microphoneAuthorizationStatus?(): number
+}
+
+let cachedModule: AudioCaptureNapi | null = null
+let loadAttempted = false
+
+function loadModule(): AudioCaptureNapi | null {
+  if (loadAttempted) {
+    return cachedModule
+  }
+  loadAttempted = true
+
+  // Supported platforms: macOS (darwin), Linux, Windows (win32)
+  const platform = process.platform
+  if (platform !== 'darwin' && platform !== 'linux' && platform !== 'win32') {
+    return null
+  }
+
+  // Candidate 1: native-embed path (bun compile). AUDIO_CAPTURE_NODE_PATH is
+  // defined at build time in build-with-plugins.ts for native builds only — the
+  // define resolves it to the static literal "../../audio-capture.node" so bun
+  // compile can rewrite it to /$bunfs/root/audio-capture.node. MUST stay a
+  // direct require(env var) — bun cannot analyze require(variable) from a loop.
+  if (process.env.AUDIO_CAPTURE_NODE_PATH) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      cachedModule = require(
+        process.env.AUDIO_CAPTURE_NODE_PATH,
+      ) as AudioCaptureNapi
+      return cachedModule
+    } catch {
+      // fall through to runtime fallbacks below
+    }
+  }
+
+  // Candidates 2/3: npm-install and dev/source layouts. Dynamic require is
+  // fine here — in bundled output (node --target build) require() resolves at
+  // runtime relative to cli.js at the package root; in dev it resolves
+  // relative to this file (vendor/audio-capture-src/index.ts).
+  const platformDir = `${process.arch}-${platform}`
+  const fallbacks = [
+    `./vendor/audio-capture/${platformDir}/audio-capture.node`,
+    `../audio-capture/${platformDir}/audio-capture.node`,
+  ]
+  for (const p of fallbacks) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      cachedModule = require(p) as AudioCaptureNapi
+      return cachedModule
+    } catch {
+      // try next
+    }
+  }
+  return null
+}
+
+export function isNativeAudioAvailable(): boolean {
+  return loadModule() !== null
+}
+
+export function startNativeRecording(
+  onData: (data: Buffer) => void,
+  onEnd: () => void,
+): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.startRecording(onData, onEnd)
+}
+
+export function stopNativeRecording(): void {
+  const mod = loadModule()
+  if (!mod) {
+    return
+  }
+  mod.stopRecording()
+}
+
+export function isNativeRecordingActive(): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.isRecording()
+}
+
+export function startNativePlayback(
+  sampleRate: number,
+  channels: number,
+): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.startPlayback(sampleRate, channels)
+}
+
+export function writeNativePlaybackData(data: Buffer): void {
+  const mod = loadModule()
+  if (!mod) {
+    return
+  }
+  mod.writePlaybackData(data)
+}
+
+export function stopNativePlayback(): void {
+  const mod = loadModule()
+  if (!mod) {
+    return
+  }
+  mod.stopPlayback()
+}
+
+export function isNativePlaying(): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.isPlaying()
+}
+
+// Returns the microphone authorization status.
+// On macOS, returns the TCC status: 0=notDetermined, 1=restricted, 2=denied, 3=authorized.
+// On Linux, always returns 3 (authorized) — no system-level mic permission API.
+// On Windows, returns 3 (authorized) if registry key absent or allowed, 2 (denied) if explicitly denied.
+// Returns 0 (notDetermined) if the native module is unavailable.
+export function microphoneAuthorizationStatus(): number {
+  const mod = loadModule()
+  if (!mod || !mod.microphoneAuthorizationStatus) {
+    return 0
+  }
+  return mod.microphoneAuthorizationStatus()
+}