react-native-nobodywho 2.4.0 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nobodywho",
-  "version": "2.4.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/chat.ts

@@ -1,6 +1,7 @@
 import {
   RustChat,
   SamplerConfig,
+  MtpConfig,
   type ChatStats,
 } from "../generated/ts/nobodywho";
 import { Model } from "./model";
@@ -31,6 +32,12 @@ export class Chat {
   /** @internal */
   private readonly _inner: RustChat;
 
+  /**
+   * `threadCount` is the number of CPU threads used for inference. Omit it to detect the
+   * device's physical core count (performance cores only, on Apple silicon) — hyperthreads
+   * and efficiency cores make inference slower, not faster. Lower it to leave CPU headroom
+   * for the rest of the app.
+   */
   constructor(opts: {
     model: Model;
     systemPrompt?: string;
@@ -38,6 +45,8 @@ export class Chat {
     templateVariables?: Record<string, boolean>;
     tools?: Tool[];
     sampler?: SamplerConfig;
+    mtp?: Partial<MtpConfig>;
+    threadCount?: number;
   }) {
     this._inner = new RustChat(
       opts.model._inner,
@@ -46,6 +55,8 @@ export class Chat {
       opts.templateVariables ? new Map(Object.entries(opts.templateVariables)) : undefined,
       opts.tools?.map((t) => t._inner) ?? undefined,
       opts.sampler ?? undefined,
+      opts.mtp !== undefined ? MtpConfig.create(opts.mtp) : undefined,
+      opts.threadCount ?? undefined,
     );
   }
 
@@ -65,17 +76,21 @@ export class Chat {
     modelPath: string;
     useGpu?: boolean;
     projectionModelPath?: string;
+    draftModelPath?: string;
     systemPrompt?: string;
     contextSize?: number;
     templateVariables?: Record<string, boolean>;
     tools?: Tool[];
     sampler?: SamplerConfig;
+    mtp?: Partial<MtpConfig>;
+    threadCount?: number;
     onDownloadProgress?: (downloaded: number, total: number) => void;
   }): Promise<Chat> {
     const model = await Model.load({
       modelPath: opts.modelPath,
       useGpu: opts.useGpu,
       projectionModelPath: opts.projectionModelPath,
+      draftModelPath: opts.draftModelPath,
       onDownloadProgress: opts.onDownloadProgress,
     });
     return new Chat({ model, ...opts });
@@ -173,6 +188,10 @@ export class Chat {
     return this._inner.getStats();
   }
 
+  async mtpAcceptanceRate(): Promise<number | undefined> {
+    return this._inner.mtpAcceptanceRate();
+  }
+
   /**
    * Immediately free the underlying Rust resources (model context, KV cache, etc.).
    * After calling this, the Chat instance is no longer usable.

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/model.ts

@@ -36,15 +36,19 @@ export class Model {
   /**
    * Load a GGUF model from a local path or remote URL.
    *
-   * @param opts.modelPath - Path to the GGUF model file, or a `hf://owner/repo/file.gguf` / `https://` URL to download and cache automatically
+   * @param opts.modelPath - Local path, `hf://` or `https://` URL, or `auto` for memory-based model selection
    * @param opts.useGpu - Use GPU acceleration if available (default: true)
    * @param opts.projectionModelPath - Path to a multimodal projector file for vision models
+   * @param opts.draftModelPath - Optional MTP draft-heads gguf. Loading it lets `Chat`
+   *   instances opt into MTP speculative decoding via `new Chat({ ..., mtp: true })`.
+   *   Adds around 5% to VRAM usage.
    * @param opts.onDownloadProgress - Invoked with `(downloaded, total)` byte counts while a remote model is being downloaded. Throttled to ~10 Hz with a guaranteed final emit on completion. Not invoked for cached/local files.
    */
   static async load(opts: {
     modelPath: string;
     useGpu?: boolean;
     projectionModelPath?: string;
+    draftModelPath?: string;
     onDownloadProgress?: (downloaded: number, total: number) => void;
   }): Promise<Model> {
     const cb = opts.onDownloadProgress;
@@ -55,6 +59,7 @@ export class Model {
       opts.modelPath,
       opts.useGpu ?? true,
       opts.projectionModelPath,
+      opts.draftModelPath,
       progressCallback,
     );
     return new Model(inner);

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/text_to_speech.ts

@@ -0,0 +1,87 @@
+import {
+  RustTextToSpeech,
+  loadTextToSpeech,
+  type RustTextToSpeechInterface,
+} from "../generated/ts/nobodywho";
+
+export type TextToSpeechArchitecture = "kokoro" | "pocket-tts" | "supertonic";
+export type TextToSpeechDevice = "auto" | "cpu" | "cuda";
+
+export type TextToSpeechOptions = {
+  source: string;
+  architecture?: TextToSpeechArchitecture;
+  voice?: string;
+  language?: string;
+  speed?: number;
+  steps?: number;
+  silenceDuration?: number;
+  precision?: "int8" | "fp32";
+  temperature?: number;
+  huggingfaceToken?: string;
+  device?: TextToSpeechDevice;
+};
+
+/** Text-to-speech synthesizer that returns WAV bytes. */
+export class TextToSpeech {
+  /** @internal */
+  private _inner: RustTextToSpeechInterface;
+
+  /** Create a TextToSpeech synthesizer synchronously. */
+  constructor(opts: TextToSpeechOptions) {
+    this._inner = new RustTextToSpeech(
+      opts.source,
+      opts.architecture,
+      opts.voice,
+      opts.language,
+      opts.speed,
+      opts.steps,
+      opts.silenceDuration,
+      opts.precision,
+      opts.temperature,
+      opts.huggingfaceToken,
+      opts.device ?? "auto",
+    );
+  }
+
+  private static fromInner(inner: RustTextToSpeechInterface): TextToSpeech {
+    const tts = Object.create(TextToSpeech.prototype) as TextToSpeech;
+    tts._inner = inner;
+    return tts;
+  }
+
+  /** Create a TextToSpeech synthesizer asynchronously. */
+  static async load(opts: TextToSpeechOptions): Promise<TextToSpeech> {
+    const inner = await loadTextToSpeech(
+      opts.source,
+      opts.architecture,
+      opts.voice,
+      opts.language,
+      opts.speed,
+      opts.steps,
+      opts.silenceDuration,
+      opts.precision,
+      opts.temperature,
+      opts.huggingfaceToken,
+      opts.device ?? "auto",
+    );
+    return TextToSpeech.fromInner(inner);
+  }
+
+  /** Synthesize text and return WAV bytes. */
+  async synthesize(text: string): Promise<Uint8Array> {
+    return new Uint8Array(await this._inner.synthesizeAsync(text));
+  }
+
+  /** Synthesize text synchronously and return WAV bytes. */
+  synthesizeSync(text: string): Uint8Array {
+    return new Uint8Array(this._inner.synthesize(text));
+  }
+
+  /**
+   * Immediately free the underlying Rust resources.
+   * 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";

package/src/tts.ts

@@ -1,78 +0,0 @@
-import {
-  RustTts,
-  loadTts,
-  type RustTtsInterface,
-} from "../generated/ts/nobodywho";
-
-export type TtsArchitecture = "kokoro" | "supertonic";
-export type TtsDevice = "auto" | "cpu" | "cuda";
-
-export type TtsOptions = {
-  source: string;
-  architecture?: TtsArchitecture;
-  voice?: string;
-  language?: string;
-  speed?: number;
-  steps?: number;
-  silenceDuration?: number;
-  device?: TtsDevice;
-};
-
-/** Text-to-speech synthesizer that returns WAV bytes. */
-export class Tts {
-  /** @internal */
-  private _inner: RustTtsInterface;
-
-  /** Create a TTS synthesizer synchronously. */
-  constructor(opts: TtsOptions) {
-    this._inner = new RustTts(
-      opts.source,
-      opts.architecture,
-      opts.voice,
-      opts.language,
-      opts.speed,
-      opts.steps,
-      opts.silenceDuration,
-      opts.device ?? "auto",
-    );
-  }
-
-  private static fromInner(inner: RustTtsInterface): Tts {
-    const tts = Object.create(Tts.prototype) as Tts;
-    tts._inner = inner;
-    return tts;
-  }
-
-  /** Create a TTS synthesizer asynchronously. */
-  static async load(opts: TtsOptions): Promise<Tts> {
-    const inner = await loadTts(
-      opts.source,
-      opts.architecture,
-      opts.voice,
-      opts.language,
-      opts.speed,
-      opts.steps,
-      opts.silenceDuration,
-      opts.device ?? "auto",
-    );
-    return Tts.fromInner(inner);
-  }
-
-  /** Synthesize text and return WAV bytes. */
-  async synthesize(text: string): Promise<Uint8Array> {
-    return new Uint8Array(await this._inner.synthesizeAsync(text));
-  }
-
-  /** Synthesize text synchronously and return WAV bytes. */
-  synthesizeSync(text: string): Uint8Array {
-    return new Uint8Array(this._inner.synthesize(text));
-  }
-
-  /**
-   * Immediately free the underlying Rust resources.
-   * After calling this, the Tts instance is no longer usable.
-   */
-  destroy(): void {
-    (this._inner as any).uniffiDestroy();
-  }
-}