opencode-voice 0.1.0

package/src/providers/streaming.ts

@@ -0,0 +1,187 @@
+import type {
+  ProviderConfig,
+  TranscriptionEvent,
+  TranscriptionProvider,
+  VoiceProvider,
+} from "../types.ts";
+
+type StreamingConfig = {
+  keepaliveIntervalMs?: number;
+  reconnectMaxRetries?: number;
+};
+
+const MAX_BUFFER_BYTES = 30 * 32 * 1000;
+
+export abstract class StreamingProvider implements TranscriptionProvider {
+  abstract readonly name: VoiceProvider;
+
+  private transcriptCallback: ((event: TranscriptionEvent) => void) | null =
+    null;
+  private errorCallback: ((err: Error) => void) | null = null;
+  private ws: WebSocket | null = null;
+  private keepaliveTimer: ReturnType<typeof setInterval> | null = null;
+  private reconnectAttempts = 0;
+  private userDisconnected = false;
+  private audioBuffer: Uint8Array[] = [];
+  protected providerConfig: ProviderConfig = {};
+
+  private readonly keepaliveIntervalMs: number;
+  private readonly reconnectMaxRetries: number;
+
+  constructor(config?: StreamingConfig) {
+    this.keepaliveIntervalMs = config?.keepaliveIntervalMs ?? 8000;
+    this.reconnectMaxRetries = config?.reconnectMaxRetries ?? 3;
+  }
+
+  async connect(config: ProviderConfig): Promise<void> {
+    this.stopKeepalive();
+    this.providerConfig = config;
+    this.userDisconnected = false;
+    this.reconnectAttempts = 0;
+    this.audioBuffer = [];
+    await this.openWebSocket();
+  }
+
+  sendAudio(chunk: Uint8Array): void {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(chunk);
+      return;
+    }
+
+    const currentSize = this.audioBuffer.reduce(
+      (size, bufferedChunk) => size + bufferedChunk.length,
+      0,
+    );
+
+    if (currentSize < MAX_BUFFER_BYTES) {
+      this.audioBuffer.push(chunk);
+    }
+  }
+
+  onTranscript(callback: (event: TranscriptionEvent) => void): void {
+    this.transcriptCallback = callback;
+  }
+
+  onError(callback: (err: Error) => void): void {
+    this.errorCallback = callback;
+  }
+
+  async disconnect(): Promise<void> {
+    this.userDisconnected = true;
+    this.stopKeepalive();
+
+    if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
+      this.ws.close(1000, "User disconnected");
+    }
+
+    this.ws = null;
+  }
+
+  private async openWebSocket(): Promise<void> {
+    return await new Promise((resolve, reject) => {
+      let socket: WebSocket;
+
+      try {
+        socket = this.createWebSocket(this.providerConfig);
+      } catch (error) {
+        reject(error);
+        return;
+      }
+
+      this.ws = socket;
+
+      const onOpen = () => {
+        this.reconnectAttempts = 0;
+        this.startKeepalive();
+
+        for (const chunk of this.audioBuffer) {
+          this.ws?.send(chunk);
+        }
+
+        this.audioBuffer = [];
+        resolve();
+      };
+
+      const onError = (_event: Event) => {
+        if (socket.readyState === WebSocket.CONNECTING) {
+          reject(new Error("WebSocket connection failed"));
+          return;
+        }
+
+        this.errorCallback?.(new Error("WebSocket error"));
+      };
+
+      const onClose = (event: CloseEvent) => {
+        this.stopKeepalive();
+
+        if (this.ws === socket) {
+          this.ws = socket.readyState === WebSocket.CLOSED ? socket : this.ws;
+        }
+
+        if (!this.userDisconnected && event.code !== 1000) {
+          this.scheduleReconnect();
+        }
+      };
+
+      const onMessage = (event: MessageEvent) => {
+        const parsed = this.parseMessage(event.data);
+        if (parsed) {
+          this.transcriptCallback?.(parsed);
+        }
+      };
+
+      socket.addEventListener("open", onOpen);
+      socket.addEventListener("error", onError);
+      socket.addEventListener("close", onClose);
+      socket.addEventListener("message", onMessage);
+    });
+  }
+
+  private scheduleReconnect(): void {
+    if (this.reconnectAttempts >= this.reconnectMaxRetries) {
+      this.errorCallback?.(
+        new Error(
+          `WebSocket reconnect failed after ${this.reconnectMaxRetries} attempts`,
+        ),
+      );
+      return;
+    }
+
+    const delay = Math.min(1000 * 2 ** this.reconnectAttempts, 10000);
+    this.reconnectAttempts++;
+
+    setTimeout(async () => {
+      if (this.userDisconnected) {
+        return;
+      }
+
+      try {
+        await this.openWebSocket();
+      } catch {
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+
+  private startKeepalive(): void {
+    this.stopKeepalive();
+    this.keepaliveTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(this.buildKeepAliveFrame());
+      }
+    }, this.keepaliveIntervalMs);
+  }
+
+  private stopKeepalive(): void {
+    if (this.keepaliveTimer !== null) {
+      clearInterval(this.keepaliveTimer);
+      this.keepaliveTimer = null;
+    }
+  }
+
+  protected abstract createWebSocket(config: ProviderConfig): WebSocket;
+
+  protected abstract parseMessage(data: unknown): TranscriptionEvent | null;
+
+  protected abstract buildKeepAliveFrame(): string | Uint8Array;
+}

package/src/providers/wav-utils.ts

@@ -0,0 +1,53 @@
+function buildWavHeader(
+  dataLength: number,
+  sampleRate: number = 16000,
+): Uint8Array {
+  const header = new ArrayBuffer(44);
+  const view = new DataView(header);
+  const numChannels = 1;
+  const bitsPerSample = 16;
+  const byteRate = sampleRate * numChannels * (bitsPerSample / 8);
+  const blockAlign = numChannels * (bitsPerSample / 8);
+
+  // RIFF chunk
+  view.setUint8(0, 0x52);
+  view.setUint8(1, 0x49);
+  view.setUint8(2, 0x46);
+  view.setUint8(3, 0x46); // "RIFF"
+  view.setUint32(4, 36 + dataLength, true);
+  view.setUint8(8, 0x57);
+  view.setUint8(9, 0x41);
+  view.setUint8(10, 0x56);
+  view.setUint8(11, 0x45); // "WAVE"
+  // fmt chunk
+  view.setUint8(12, 0x66);
+  view.setUint8(13, 0x6d);
+  view.setUint8(14, 0x74);
+  view.setUint8(15, 0x20); // "fmt "
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true); // PCM format
+  view.setUint16(22, numChannels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, byteRate, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bitsPerSample, true);
+  // data chunk
+  view.setUint8(36, 0x64);
+  view.setUint8(37, 0x61);
+  view.setUint8(38, 0x74);
+  view.setUint8(39, 0x61); // "data"
+  view.setUint32(40, dataLength, true);
+
+  return new Uint8Array(header);
+}
+
+export function wrapInWav(
+  pcm: Uint8Array,
+  sampleRate: number = 16000,
+): Uint8Array {
+  const header = buildWavHeader(pcm.length, sampleRate);
+  const wav = new Uint8Array(header.length + pcm.length);
+  wav.set(header, 0);
+  wav.set(pcm, header.length);
+  return wav;
+}

package/src/session.ts

@@ -0,0 +1,147 @@
+import type { Recorder } from "./audio/recorder";
+import type {
+  ProviderConfig,
+  TranscriptionEvent,
+  TranscriptionProvider,
+  VoiceSessionState,
+} from "./types";
+
+export type VoiceSessionOptions = {
+  recorder: Recorder;
+  provider: TranscriptionProvider;
+  providerConfig: Record<string, unknown>;
+  onTranscript: (event: TranscriptionEvent) => void;
+  onStateChange: (state: VoiceSessionState) => void;
+  onError: (error: Error) => void;
+  debounceMs?: number;
+};
+
+export class VoiceSession {
+  private state: VoiceSessionState = "idle";
+  private lastToggleAt = 0;
+  private readonly debounceMs: number;
+
+  constructor(private readonly opts: VoiceSessionOptions) {
+    this.debounceMs = opts.debounceMs ?? 500;
+  }
+
+  getState(): VoiceSessionState {
+    return this.state;
+  }
+
+  async toggle(): Promise<void> {
+    const now = Date.now();
+    if (now - this.lastToggleAt < this.debounceMs) {
+      return;
+    }
+    this.lastToggleAt = now;
+
+    if (this.state === "idle") {
+      await this.startRecording();
+      return;
+    }
+
+    if (this.state === "recording") {
+      await this.stopRecording();
+    }
+  }
+
+  private async startRecording(): Promise<void> {
+    this.setState("recording");
+
+    try {
+      this.opts.recorder.onError((error) => {
+        this.handleRuntimeError(error);
+      });
+
+      await this.opts.provider.connect(
+        this.opts.providerConfig as ProviderConfig,
+      );
+
+      this.opts.provider.onTranscript((event) => {
+        this.opts.onTranscript(event);
+      });
+
+      this.opts.provider.onError((error) => {
+        this.handleRuntimeError(error);
+      });
+
+      const stream = await this.opts.recorder.start();
+
+      void this.pipeAudio(stream).catch((error) => {
+        if (this.state === "recording") {
+          this.handleRuntimeError(error);
+        }
+      });
+    } catch (error) {
+      this.setState("error");
+      this.opts.onError(
+        error instanceof Error ? error : new Error(String(error)),
+      );
+    }
+  }
+
+  private async stopRecording(): Promise<void> {
+    this.setState("processing");
+
+    try {
+      await this.opts.recorder.stop();
+      await this.opts.provider.disconnect();
+    } catch {
+      // Ignore cleanup errors
+    } finally {
+      this.setState("idle");
+    }
+  }
+
+  private async pipeAudio(stream: ReadableStream<Uint8Array>): Promise<void> {
+    const reader = stream.getReader();
+
+    try {
+      while (this.state === "recording") {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        if (value) {
+          this.opts.provider.sendAudio(value);
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  private handleRuntimeError(error: Error): void {
+    if (this.state === "error") {
+      return;
+    }
+
+    this.setState("error");
+    void this.opts.recorder.stop().catch(() => {});
+    this.opts.onError(error);
+  }
+
+  private setState(state: VoiceSessionState): void {
+    this.state = state;
+    this.opts.onStateChange(state);
+  }
+
+  async dispose(): Promise<void> {
+    if (this.state === "recording") {
+      await this.stopRecording();
+      return;
+    }
+
+    if (this.state === "error") {
+      try {
+        await this.opts.recorder.stop();
+        await this.opts.provider.disconnect();
+      } catch {
+        // Ignore cleanup errors during disposal
+      }
+    }
+
+    this.setState("idle");
+  }
+}

package/src/types.ts

@@ -0,0 +1,90 @@
+// Voice provider identifiers
+export type VoiceProvider = "deepgram" | "groq" | "openai-whisper";
+
+// Main plugin configuration (loaded from plugin options or env vars)
+export type VoiceConfig = {
+  provider: VoiceProvider;
+  language?: string; // default: undefined (auto-detect by provider)
+  chunkDurationMs?: number; // for chunked providers: chunk size in ms
+  keybind?: string; // default: "ctrl+shift+v"
+};
+
+// Per-provider runtime config (API key, model, etc.)
+export type ProviderConfig = {
+  apiKey?: string;
+  model?: string;
+  [key: string]: unknown;
+};
+
+// Transcription event emitted by providers
+export type TranscriptionEvent = {
+  text: string;
+  isFinal: boolean;
+  confidence?: number; // 0–1, optional
+};
+
+// Provider abstraction interface
+export interface TranscriptionProvider {
+  readonly name: VoiceProvider;
+  connect(config: ProviderConfig): Promise<void>;
+  sendAudio(chunk: Uint8Array): void;
+  onTranscript(callback: (event: TranscriptionEvent) => void): void;
+  onError(callback: (error: Error) => void): void;
+  disconnect(): Promise<void>;
+}
+
+// Audio capture configuration
+export type RecorderOptions = {
+  sampleRate?: number; // default: 16000
+  channels?: number; // default: 1
+  bitDepth?: number; // default: 16
+};
+
+// Detected recording tool
+export type RecordingTool = "sox" | "ffmpeg" | "arecord" | "powershell";
+
+// Voice session state machine states
+export type VoiceSessionState = "idle" | "recording" | "processing" | "error";
+
+// Custom error types
+export class VoiceError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "VoiceError";
+  }
+}
+
+export class RecorderError extends VoiceError {
+  constructor(message: string) {
+    super(message);
+    this.name = "RecorderError";
+  }
+}
+
+export class AuthError extends VoiceError {
+  constructor(message: string) {
+    super(message);
+    this.name = "AuthError";
+  }
+}
+
+export class RateLimitError extends VoiceError {
+  constructor(message: string) {
+    super(message);
+    this.name = "RateLimitError";
+  }
+}
+
+export class ProviderError extends VoiceError {
+  constructor(message: string) {
+    super(message);
+    this.name = "ProviderError";
+  }
+}
+
+export class ConfigError extends VoiceError {
+  constructor(message: string) {
+    super(message);
+    this.name = "ConfigError";
+  }
+}

package/src/ui/recording-indicator.tsx

@@ -0,0 +1,83 @@
+import {
+  createSignal,
+  createEffect,
+  onCleanup,
+  Show,
+  type Component,
+} from "solid-js";
+
+export type RecordingIndicatorProps = {
+  isRecording: () => boolean;
+  interimText: () => string;
+};
+
+// Animation frames for the recording indicator
+export const ANIMATION_FRAMES = ["●", "● ●", "● ● ●"];
+
+/**
+ * Creates the recording indicator state logic (extracted for testability)
+ */
+export function createRecordingIndicatorState() {
+  const [frame, setFrame] = createSignal(0);
+
+  let timer: ReturnType<typeof setInterval> | null = null;
+
+  function startAnimation() {
+    if (timer !== null) return;
+    timer = setInterval(() => {
+      setFrame((f) => (f + 1) % ANIMATION_FRAMES.length);
+    }, 500);
+  }
+
+  function stopAnimation() {
+    if (timer !== null) {
+      clearInterval(timer);
+      timer = null;
+    }
+    // Always reset frame even if timer was already null
+    setFrame(0);
+  }
+
+  function getCurrentFrame(): string {
+    return ANIMATION_FRAMES[frame()];
+  }
+
+  return { frame, startAnimation, stopAnimation, getCurrentFrame };
+}
+
+/**
+ * Recording indicator component for OpenCode's home_bottom slot.
+ * Shows when recording is active, hides when idle.
+ */
+export const RecordingIndicator: Component<RecordingIndicatorProps> = (
+  props,
+) => {
+  const state = createRecordingIndicatorState();
+
+  createEffect(() => {
+    if (props.isRecording()) {
+      state.startAnimation();
+    } else {
+      state.stopAnimation();
+    }
+  });
+
+  onCleanup(() => {
+    state.stopAnimation();
+  });
+
+  return (
+    <Show when={props.isRecording()}>
+      <div>
+        <span style={{ color: "red" }}>
+          {state.getCurrentFrame()} Recording...
+        </span>
+        <Show when={props.interimText().length > 0}>
+          <span style={{ opacity: 0.7 }}> {props.interimText()}</span>
+        </Show>
+      </div>
+    </Show>
+  );
+};
+
+export default RecordingIndicator;