react-native-nobodywho 2.5.0 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nobodywho",
-  "version": "2.5.0",
+  "version": "3.0.0",
   "description": "Run LLMs locally with offline inference — React Native bindings",
   "main": "src/wrapper.ts",
   "types": "src/wrapper.ts",

package/src/encoder.ts

@@ -46,6 +46,11 @@ export class Encoder {
     return this._inner.encode(text);
   }
 
+  /** Encode multiple texts, preserving input order. */
+  async encodeBatch(texts: string[]): Promise<number[][]> {
+    return this._inner.encodeBatch(texts);
+  }
+
   /**
    * Immediately free the underlying Rust resources.
    * After calling this, the Encoder instance is no longer usable.

package/src/{stt.ts → speech_to_text.ts}

@@ -1,8 +1,8 @@
-import type { RustSttInterface } from "../generated/ts/nobodywho";
+import type { RustSpeechToTextInterface } from "../generated/ts/nobodywho";
 import * as nobodywho from "../generated/ts/nobodywho";
 import { TokenStream } from "./streaming";
 
-export type SttOptions = {
+export type SpeechToTextOptions = {
   source: string;
   language?: string;
   quantization?: string;
@@ -13,7 +13,7 @@ export type SttOptions = {
  *
  * @example
  * ```typescript
- * const stt = new STT({
+ * const stt = await SpeechToText.load({
  *   source: "hf://onnx-community/whisper-base",
  *   language: "en",
  * });
@@ -26,24 +26,32 @@ export type SttOptions = {
  * const text = await stream.completed();
  * ```
  */
-export class STT {
+export class SpeechToText {
   /** @internal */
-  private readonly _inner: RustSttInterface;
+  private readonly _inner: RustSpeechToTextInterface;
+
+  /** @internal */
+  private constructor(inner: RustSpeechToTextInterface) {
+    this._inner = inner;
+  }
 
   /**
-   * @param opts - See {@link SttOptions}.
+   * Load a Whisper SpeechToText model.
+   *
+   * @param opts - See {@link SpeechToTextOptions}.
    */
-  constructor(opts: SttOptions) {
-    this._inner = new nobodywho.RustStt(
+  static async load(opts: SpeechToTextOptions): Promise<SpeechToText> {
+    const inner = await nobodywho.loadSpeechToText(
       opts.source,
       opts.language,
       opts.quantization,
     );
+    return new SpeechToText(inner);
   }
 
   /**
    * Transcribe an audio file (WAV / MP3).
-   * Returns an `STTStream` to consume tokens as they arrive.
+   * Returns an `SpeechToTextStream` to consume tokens as they arrive.
    */
   transcribeFile(path: string): TokenStream {
     return new TokenStream(this._inner.transcribeFile(path));

package/src/{tts.ts → text_to_speech.ts}

@@ -1,15 +1,15 @@
 import {
-  RustTts,
-  loadTts,
-  type RustTtsInterface,
+  RustTextToSpeech,
+  loadTextToSpeech,
+  type RustTextToSpeechInterface,
 } from "../generated/ts/nobodywho";
 
-export type TtsArchitecture = "kokoro" | "pocket-tts" | "supertonic";
-export type TtsDevice = "auto" | "cpu" | "cuda";
+export type TextToSpeechArchitecture = "kokoro" | "pocket-tts" | "supertonic";
+export type TextToSpeechDevice = "auto" | "cpu" | "cuda";
 
-export type TtsOptions = {
+export type TextToSpeechOptions = {
   source: string;
-  architecture?: TtsArchitecture;
+  architecture?: TextToSpeechArchitecture;
   voice?: string;
   language?: string;
   speed?: number;
@@ -18,17 +18,17 @@ export type TtsOptions = {
   precision?: "int8" | "fp32";
   temperature?: number;
   huggingfaceToken?: string;
-  device?: TtsDevice;
+  device?: TextToSpeechDevice;
 };
 
 /** Text-to-speech synthesizer that returns WAV bytes. */
-export class Tts {
+export class TextToSpeech {
   /** @internal */
-  private _inner: RustTtsInterface;
+  private _inner: RustTextToSpeechInterface;
 
-  /** Create a TTS synthesizer synchronously. */
-  constructor(opts: TtsOptions) {
-    this._inner = new RustTts(
+  /** Create a TextToSpeech synthesizer synchronously. */
+  constructor(opts: TextToSpeechOptions) {
+    this._inner = new RustTextToSpeech(
       opts.source,
       opts.architecture,
       opts.voice,
@@ -43,15 +43,15 @@ export class Tts {
     );
   }
 
-  private static fromInner(inner: RustTtsInterface): Tts {
-    const tts = Object.create(Tts.prototype) as Tts;
+  private static fromInner(inner: RustTextToSpeechInterface): TextToSpeech {
+    const tts = Object.create(TextToSpeech.prototype) as TextToSpeech;
     tts._inner = inner;
     return tts;
   }
 
-  /** Create a TTS synthesizer asynchronously. */
-  static async load(opts: TtsOptions): Promise<Tts> {
-    const inner = await loadTts(
+  /** Create a TextToSpeech synthesizer asynchronously. */
+  static async load(opts: TextToSpeechOptions): Promise<TextToSpeech> {
+    const inner = await loadTextToSpeech(
       opts.source,
       opts.architecture,
       opts.voice,
@@ -64,7 +64,7 @@ export class Tts {
       opts.huggingfaceToken,
       opts.device ?? "auto",
     );
-    return Tts.fromInner(inner);
+    return TextToSpeech.fromInner(inner);
   }
 
   /** Synthesize text and return WAV bytes. */
@@ -79,7 +79,7 @@ export class Tts {
 
   /**
    * Immediately free the underlying Rust resources.
-   * After calling this, the Tts instance is no longer usable.
+   * After calling this, the TextToSpeech instance is no longer usable.
    */
   destroy(): void {
     (this._inner as any).uniffiDestroy();

package/src/vad.ts

@@ -0,0 +1,104 @@
+import type { RustVoiceActivityDetectionInterface, VoiceActivityDetectionEvent } from "../generated/ts/nobodywho";
+import * as nobodywho from "../generated/ts/nobodywho";
+
+export { VoiceActivityDetectionEvent } from "../generated/ts/nobodywho";
+
+export type VoiceActivityDetectionOptions = {
+  source?: string;
+  sampleRate: number;
+  threshold?: number;
+  minSilenceDurationMs?: number;
+  minSpeechDurationMs?: number;
+  prerollDurationMs?: number;
+};
+
+/**
+ * Voice activity detection from live, streaming audio, backed by Silero VAD.
+ *
+ * @example
+ * ```typescript
+ * const vad = await VoiceActivityDetection.load({ sampleRate: 16000 });
+ *
+ * // Feed each newest chunk as it arrives (not the whole buffer — VoiceActivityDetection
+ * // tracks the current turn internally).
+ * if (vad.push(chunk) === VoiceActivityDetectionEvent.SpeechEnded) {
+ *   const audio = vad.finish();
+ *   // audio: Int16Array-like number[] spanning SpeechStarted (with a
+ *   // small pre-roll) through SpeechEnded.
+ * }
+ * ```
+ */
+export class VoiceActivityDetection {
+  /** @internal */
+  private readonly _inner: RustVoiceActivityDetectionInterface;
+
+  /** @internal */
+  private constructor(inner: RustVoiceActivityDetectionInterface) {
+    this._inner = inner;
+  }
+
+  /**
+   * Load a voice activity detector.
+   *
+   * @param opts - See {@link VoiceActivityDetectionOptions}.
+   */
+  static async load(opts: VoiceActivityDetectionOptions): Promise<VoiceActivityDetection> {
+    const inner = await nobodywho.loadVoiceActivityDetection(
+      opts.source,
+      opts.sampleRate,
+      opts.threshold,
+      opts.minSilenceDurationMs,
+      opts.minSpeechDurationMs,
+      opts.prerollDurationMs,
+      undefined,
+    );
+    return new VoiceActivityDetection(inner);
+  }
+
+  /**
+   * Feed the newest chunk of audio (not the whole accumulated buffer —
+   * `VoiceActivityDetection` tracks the current turn internally). Always
+   * returns the current confirmed state: `Speech`/`Silence` if unchanged
+   * since the last call, or `SpeechStarted`/`SpeechEnded` on the call that
+   * confirmed the transition.
+   *
+   * @param chunk - Flat array of signed 16-bit samples (mono).
+   */
+  push(chunk: Int16Array | number[]): VoiceActivityDetectionEvent {
+    const arr = chunk instanceof Int16Array ? Array.from(chunk) : chunk;
+    return this._inner.push(arr);
+  }
+
+  /**
+   * Return the current turn's captured audio (from the confirmed
+   * `SpeechStarted`, including a small pre-roll, through to `SpeechEnded`)
+   * and reset internal state for the next turn. Empty if speech was never
+   * confirmed.
+   */
+  finish(): number[] {
+    return this._inner.finish();
+  }
+
+  /**
+   * Detect every speech segment in a complete audio buffer, returning
+   * each segment's audio (with a short pre-roll) in order. Unlike `push`,
+   * correctly finds every segment regardless of buffer size — use this
+   * for offline/batch processing instead of live streaming.
+   *
+   * @example
+   * ```typescript
+   * for (const audio of vad.segment(fullRecording)) {
+   *   transcribe(audio);
+   * }
+   * ```
+   */
+  segment(samples: Int16Array | number[]): number[][] {
+    const arr = samples instanceof Int16Array ? Array.from(samples) : samples;
+    return this._inner.segment(arr);
+  }
+
+  /** Release native resources. Call when done with this handle. */
+  destroy(): void {
+    (this._inner as any).uniffiDestroy?.();
+  }
+}

package/src/wrapper.ts

@@ -2,7 +2,7 @@
  * NobodyWho — React Native bindings for local LLM inference.
  *
  * This is the public entry point. It re-exports the public API:
- * - Wrapper classes: Model, Chat, Encoder, CrossEncoder, Tts, Tool, TokenStream, Prompt
+ * - Wrapper classes: Model, Chat, Encoder, CrossEncoder, TextToSpeech, Tool, TokenStream, Prompt
  * - Direct re-exports: SamplerBuilder, SamplerConfig
  * - Types: Message, Asset, ToolCall
  * - Utilities: SamplerPresets, cosineSimilarity, downloadModel
@@ -57,10 +57,11 @@ export async function downloadModel(opts: {
 // Wrapper classes
 export { Model } from "./model";
 export { Chat } from "./chat";
-export { STT } from "./stt";
+export { SpeechToText } from "./speech_to_text";
+export { VoiceActivityDetection } from "./vad";
 export { Encoder } from "./encoder";
 export { CrossEncoder } from "./cross_encoder";
-export { Tts } from "./tts";
+export { TextToSpeech } from "./text_to_speech";
 export { Prompt } from "./prompt";
 export { Tool } from "./tool";
 export { TokenStream } from "./streaming";
@@ -85,8 +86,10 @@ export type {
   CachedModel,
   ChatStats,
 } from "../generated/ts/nobodywho";
-export type { TtsArchitecture, TtsDevice, TtsOptions } from "./tts";
-export type { SttOptions } from "./stt";
+export type { TextToSpeechArchitecture, TextToSpeechDevice, TextToSpeechOptions } from "./text_to_speech";
+export type { SpeechToTextOptions } from "./speech_to_text";
+export { VoiceActivityDetectionEvent } from "./vad";
+export type { VoiceActivityDetectionOptions } from "./vad";
 
 // Ergonomic wrapper additions.
 export { SamplerPresets } from "./sampler_presets";