feat: grop free stt

bun.lock

@@ -68,6 +68,7 @@
         "fuse.js": "^7.1.0",
         "get-east-asian-width": "^1.5.0",
         "google-auth-library": "^10.6.2",
+        "groq-sdk": "^1.2.1",
         "highlight.js": "^11.11.1",
         "https-proxy-agent": "^8.0.0",
         "ignore": "^7.0.5",
@@ -730,6 +731,8 @@
 
     "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
 
+    "groq-sdk": ["groq-sdk@1.2.1", "", { "bin": { "groq-sdk": "bin/cli" } }, "sha512-dsDSWJRJf+n2dPiCv7zU3IsJbrh7jfSPqi6vc1q0TTK1oUF6bn+wv4P2VFdynkHpuJ0TTJ57vlpT87judPgVPA=="],
+
     "gtoken": ["gtoken@7.1.0", "", { "dependencies": { "gaxios": "^6.0.0", "jws": "^4.0.0" } }, "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw=="],
 
     "has-flag": ["has-flag@5.0.1", "", {}, "sha512-CsNUt5x9LUdx6hnk/E2SZLsDyvfqANZSUq4+D3D8RzDJ2M+HDTIkF60ibS1vHaK55vzgiZw1bEPFG9yH7l33wA=="],

package.json

@@ -86,6 +86,7 @@
     "fuse.js": "^7.1.0",
     "get-east-asian-width": "^1.5.0",
     "google-auth-library": "^10.6.2",
+    "groq-sdk": "^1.2.1",
     "highlight.js": "^11.11.1",
     "https-proxy-agent": "^8.0.0",
     "ignore": "^7.0.5",

src/components/friend/frontend/components/SettingsPanel.tsx

@@ -12,7 +12,7 @@ interface DanceItem {
   builtin?: boolean
 }
 
-type SttProvider = 'browser' | 'anthropic' | 'local' | 'doubao'
+type SttProvider = 'browser' | 'groq' | 'anthropic' | 'local' | 'doubao'
 
 interface SettingsPanelProps {
   visible: boolean
@@ -495,7 +495,7 @@ export function SettingsPanel({
               <div style={{ marginTop: 8 }}>
                 <div style={labelStyle}>{t('语音识别 (STT)', 'Speech Recognition (STT)')}</div>
                 <div style={{ display: 'flex', gap: 4, flexWrap: 'wrap' }}>
-                  {(['browser', 'anthropic', 'local', 'doubao'] as const).map((p) => (
+                  {(['browser', 'groq', 'anthropic', 'local', 'doubao'] as const).map((p) => (
                     <button
                       key={p}
                       onClick={() => onSttProviderChange?.(p)}
@@ -509,7 +509,7 @@ export function SettingsPanel({
                         borderColor: p === sttProvider ? 'rgba(100, 160, 255, 0.6)' : 'rgba(255, 255, 255, 0.15)',
                       }}
                     >
-                      {{ browser: t('浏览器', 'Browser'), anthropic: 'Anthropic', local: 'Whisper', doubao: 'Doubao' }[p]}
+                      {{ browser: t('浏览器', 'Browser'), groq: 'Groq', anthropic: 'Anthropic', local: 'Whisper', doubao: 'Doubao' }[p]}
                     </button>
                   ))}
                 </div>

src/components/friend/frontend/hooks/useServerStt.ts

@@ -14,7 +14,7 @@ import { useRef, useCallback, useState } from 'react'
 
 const FRIEND_API_BASE = 'http://127.0.0.1:3456/plugins/friend'
 
-export type SttProvider = 'browser' | 'anthropic' | 'local' | 'doubao'
+export type SttProvider = 'browser' | 'groq' | 'anthropic' | 'local' | 'doubao'
 
 export function useServerStt() {
   const [connected, setConnected] = useState(false)

src/friend/FriendService.ts

@@ -235,12 +235,22 @@ class FriendService {
 
   /**
    * Auto-detect the first available STT provider.
-   * Tries: local Whisper → Anthropic Voice Stream → Doubao ASR
+   * Tries: Groq Whisper (cloud, API key) → local Whisper → Anthropic Voice Stream → Doubao ASR
    */
   private async detectAvailableSttProvider(): Promise<string> {
     console.log('[FriendService] detectAvailableSttProvider: checking available providers...');
 
-    // Check local Whisper first (no external API keys needed)
+    // Check Groq API key first (fastest — no Python, just a REST call)
+    // Keys are resolved from: prefs → process.env → ~/.claude/settings.json
+    try {
+      const { isGroqAvailable } = await import('../services/voice/groqSTT.js');
+      if (isGroqAvailable()) {
+        console.log('[FriendService] detectAvailableSttProvider: Groq API key found');
+        return 'groq';
+      }
+    } catch { /* ignore */ }
+
+    // Check local Whisper (no external API keys needed)
     try {
       const { checkLocalWhisperAvailable } = await import(
         '../services/voice/whisperSTT.js'
@@ -438,6 +448,13 @@ class FriendService {
         return await connectDoubaoStream(callbacks, { language: language || 'zh' });
       }
 
+      case 'groq': {
+        const { connectGroqStream } = await import(
+          '../services/voice/groqSTT.js'
+        );
+        return await connectGroqStream(callbacks, { language });
+      }
+
       default:
         throw new Error(`Unknown STT provider: ${provider}`);
     }

src/friend/prefs.ts

@@ -22,10 +22,12 @@ export interface FriendPrefs {
   language?: 'zh' | 'en';
   currentDance?: string;
   hideMood?: boolean;
-  /** STT provider: browser | anthropic | local | doubao */
-  sttProvider?: 'browser' | 'anthropic' | 'local' | 'doubao';
+  /** STT provider: browser | anthropic | local | doubao | groq */
+  sttProvider?: 'browser' | 'anthropic' | 'local' | 'doubao' | 'groq';
   /** STT language override (e.g. 'en', 'zh', 'ja') */
   sttLanguage?: string;
+  /** GROQ_API_KEY for Groq Whisper STT (cloud, fast, no Python needed) */
+  groqApiKey?: string;
 }
 
 const homeDir = process.env.HOME || process.env.USERPROFILE || '';

src/server/api/friend.ts

@@ -309,6 +309,7 @@ export async function handleFriendApi(req: Request, url: URL): Promise<Response>
       if (body.hideMood !== undefined) patch.hideMood = body.hideMood;
       if (body.sttProvider !== undefined) patch.sttProvider = body.sttProvider;
       if (body.sttLanguage !== undefined) patch.sttLanguage = body.sttLanguage;
+      if (body.groqApiKey !== undefined) patch.groqApiKey = body.groqApiKey;
       setPrefs(updatePrefs(patch));
       return jsonResponse({ ok: true });
     }

src/services/voice/groqSTT.ts

@@ -0,0 +1,200 @@
+/**
+ * Groq Whisper STT — cloud-based speech-to-text via Groq LPU API.
+ *
+ * Uses the official groq-sdk npm package. Tries whisper-large-v3 first,
+ * falls back to whisper-large-v3-turbo on rate-limit (429) errors.
+ *
+ * No Python subprocess needed. Pure TypeScript.
+ */
+
+import Groq from 'groq-sdk'
+import { readFileSync, existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import type { VoiceStreamCallbacks, VoiceStreamConnection, FinalizeSource } from '../voiceStreamSTT.js'
+
+const MODELS = ['whisper-large-v3', 'whisper-large-v3-turbo'] as const
+
+export type GroqSttOptions = {
+  /** Explicit API key (highest priority) */
+  apiKey?: string
+  model?: string
+  language?: string
+}
+
+/**
+ * Resolve the Groq API key from multiple sources (priority order):
+ * 1. Explicitly passed `apiKey` option
+ * 2. `getPrefs().groqApiKey` (from friend.json)
+ * 3. `process.env.GROQ_API_KEY`
+ * 4. `~/.claude/settings.json` → env.groqApiKey
+ */
+export function resolveGroqApiKey(explicitKey?: string): string | undefined {
+  if (explicitKey) return explicitKey
+  if (process.env.GROQ_API_KEY) return process.env.GROQ_API_KEY
+
+  // Fallback: read from ~/.claude/settings.json
+  try {
+    const settingsPath = join(homedir(), '.claude', 'settings.json')
+    if (existsSync(settingsPath)) {
+      const raw = readFileSync(settingsPath, 'utf-8')
+      const settings = JSON.parse(raw)
+      if (settings.env?.groqApiKey) {
+        return settings.env.groqApiKey
+      }
+      if (settings.env?.GROQ_API_KEY) {
+        return settings.env.GROQ_API_KEY
+      }
+    }
+  } catch { /* ignore */ }
+
+  return undefined
+}
+
+/**
+ * Connect to Groq Whisper STT as a stream-like connection.
+ *
+ * `send(chunk)` buffers audio PCM data. `finalize()` sends the full buffer
+ * to the Groq API, trying whisper-large-v3 first, falling back to
+ * whisper-large-v3-turbo on rate-limit.
+ */
+export function connectGroqStream(
+  callbacks: VoiceStreamCallbacks,
+  options: GroqSttOptions,
+): Promise<VoiceStreamConnection | null> {
+  return new Promise(resolve => {
+    const chunks: Buffer[] = []
+    let finalized = false
+
+    const connection: VoiceStreamConnection = {
+      send(chunk: Buffer) {
+        if (finalized) return
+        chunks.push(Buffer.from(chunk))
+      },
+
+      async finalize(): Promise<FinalizeSource> {
+        if (finalized) return 'ws_already_closed'
+        finalized = true
+
+        if (chunks.length === 0) {
+          callbacks.onClose()
+          return 'no_data_timeout'
+        }
+
+        const audioBuf = Buffer.concat(chunks)
+
+        try {
+          // Resolve API key
+          const apiKey = resolveGroqApiKey(options.apiKey)
+          if (!apiKey) {
+            throw new Error(
+              'Groq API key not found. Set GROQ_API_KEY env var or add "groqApiKey" to ~/.claude/settings.json env block.',
+            )
+          }
+
+          const client = new Groq({ apiKey })
+
+          // Convert raw PCM to WAV buffer
+          const wavBuf = pcmToWav(audioBuf, 16000)
+          const wavFile = new File([wavBuf], 'audio.wav', { type: 'audio/wav' })
+
+          // Try whisper-large-v3 first, fallback to -turbo on 429
+          const preferredModel = options.model || MODELS[0]
+          const modelsToTry = preferredModel === MODELS[1]
+            ? [MODELS[1]]
+            : [preferredModel, MODELS[1]]
+
+          let lastError: Error | null = null
+
+          for (const model of modelsToTry) {
+            try {
+              const transcription = await client.audio.transcriptions.create({
+                file: wavFile,
+                model,
+                temperature: 0,
+                response_format: 'verbose_json',
+                ...(options.language ? { language: options.language } : {}),
+              })
+
+              if (transcription.text) {
+                callbacks.onTranscript(transcription.text, true)
+              } else {
+                callbacks.onTranscript('', true)
+              }
+
+              lastError = null
+              break // success
+            } catch (err: any) {
+              lastError = err
+              // Only retry on rate-limit (429) or server errors
+              if (err.status === 429 || err.status >= 500) {
+                console.warn(`[GroqSTT] model ${model} failed (${err.status}), trying next...`)
+                continue
+              }
+              // Other errors are fatal — don't retry
+              throw err
+            }
+          }
+
+          if (lastError) throw lastError
+        } catch (err) {
+          callbacks.onError(
+            `Groq STT error: ${err instanceof Error ? err.message : String(err)}`,
+            { fatal: true },
+          )
+        } finally {
+          callbacks.onClose()
+        }
+
+        return 'post_closestream_endpoint'
+      },
+
+      close() {
+        finalized = true
+        callbacks.onClose()
+      },
+
+      isConnected() {
+        return true
+      },
+    }
+
+    callbacks.onReady(connection)
+    resolve(connection)
+  })
+}
+
+/**
+ * Check if a Groq API key is available somewhere.
+ */
+export function isGroqAvailable(explicitKey?: string): boolean {
+  return !!resolveGroqApiKey(explicitKey)
+}
+
+/**
+ * Convert 16-bit mono PCM data (16000 Hz) to a WAV buffer.
+ */
+function pcmToWav(pcmData: Buffer, sampleRate: number): Buffer {
+  const numChannels = 1
+  const bitsPerSample = 16
+  const byteRate = sampleRate * numChannels * (bitsPerSample / 8)
+  const blockAlign = numChannels * (bitsPerSample / 8)
+  const dataSize = pcmData.length
+
+  const header = Buffer.alloc(44)
+  header.write('RIFF', 0)
+  header.writeUInt32LE(36 + dataSize, 4)
+  header.write('WAVE', 8)
+  header.write('fmt ', 12)
+  header.writeUInt32LE(16, 16)
+  header.writeUInt16LE(1, 20)
+  header.writeUInt16LE(numChannels, 22)
+  header.writeUInt32LE(sampleRate, 24)
+  header.writeUInt32LE(byteRate, 28)
+  header.writeUInt16LE(blockAlign, 32)
+  header.writeUInt16LE(bitsPerSample, 34)
+  header.write('data', 36)
+  header.writeUInt32LE(dataSize, 40)
+
+  return Buffer.concat([header, pcmData])
+}