cactus-react-native 1.5.0 → 1.10.0

package/src/classes/CactusSTT.ts

@@ -6,22 +6,20 @@ import type {
   CactusSTTParams,
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
-  CactusSTTStreamTranscribeInsertParams,
+  CactusSTTStreamTranscribeStartOptions,
   CactusSTTStreamTranscribeProcessParams,
   CactusSTTStreamTranscribeProcessResult,
-  CactusSTTStreamTranscribeFinalizeResult,
+  CactusSTTStreamTranscribeStopResult,
+  CactusSTTDetectLanguageParams,
+  CactusSTTDetectLanguageResult,
 } from '../types/CactusSTT';
-import { Telemetry } from '../telemetry/Telemetry';
-import { CactusConfig } from '../config/CactusConfig';
-import { getErrorMessage } from '../utils/error';
-import models from '../models';
+import { getRegistry } from '../modelRegistry';
 import type { CactusModel } from '../types/common';
 
 export class CactusSTT {
   private readonly cactus = new Cactus();
 
   private readonly model: string;
-  private readonly contextSize: number;
   private readonly options: {
     quantization: 'int4' | 'int8';
     pro: boolean;
@@ -30,13 +28,11 @@ export class CactusSTT {
   private isDownloading = false;
   private isInitialized = false;
   private isGenerating = false;
-
-  private isStreamTranscribeInitialized = false;
+  private isStreamTranscribing = false;
 
   private static readonly defaultModel = 'whisper-small';
-  private static readonly defaultContextSize = 2048;
   private static readonly defaultOptions = {
-    quantization: 'int4' as const,
+    quantization: 'int8' as const,
     pro: false,
   };
   private static readonly defaultPrompt =
@@ -46,11 +42,8 @@ export class CactusSTT {
   };
   private static readonly defaultEmbedBufferSize = 4096;
 
-  constructor({ model, contextSize, options }: CactusSTTParams = {}) {
-    Telemetry.init(CactusConfig.telemetryToken);
-
+  constructor({ model, options }: CactusSTTParams = {}) {
     this.model = model ?? CactusSTT.defaultModel;
-    this.contextSize = contextSize ?? CactusSTT.defaultContextSize;
     this.options = {
       quantization:
         options?.quantization ?? CactusSTT.defaultOptions.quantization,
@@ -78,8 +71,9 @@ export class CactusSTT {
 
     this.isDownloading = true;
     try {
+      const registry = await getRegistry();
       const modelConfig =
-        models[this.model]?.quantization[this.options.quantization];
+        registry[this.model]?.quantization[this.options.quantization];
       const url = this.options.pro ? modelConfig?.pro?.apple : modelConfig?.url;
 
       if (!url) {
@@ -114,14 +108,10 @@ export class CactusSTT {
       modelPath = await CactusFileSystem.getModelPath(this.getModelName());
     }
 
-    try {
-      await this.cactus.init(modelPath, this.contextSize);
-      Telemetry.logInit(this.model, true);
-      this.isInitialized = true;
-    } catch (error) {
-      Telemetry.logInit(this.model, false, getErrorMessage(error));
-      throw error;
-    }
+    const cacheDir = await CactusFileSystem.getCactusDirectory();
+    await this.cactus.setTelemetryEnvironment(cacheDir);
+    await this.cactus.init(modelPath);
+    this.isInitialized = true;
   }
 
   public async transcribe({
@@ -145,95 +135,67 @@ export class CactusSTT {
 
     this.isGenerating = true;
     try {
-      const result = await this.cactus.transcribe(
+      return await this.cactus.transcribe(
         audio,
         prompt,
         responseBufferSize,
         options,
         onToken
       );
-      Telemetry.logTranscribe(
-        this.model,
-        result.success,
-        result.success ? undefined : result.response,
-        result
-      );
-      return result;
-    } catch (error) {
-      Telemetry.logTranscribe(this.model, false, getErrorMessage(error));
-      throw error;
     } finally {
       this.isGenerating = false;
     }
   }
 
-  public async streamTranscribeInit(): Promise<void> {
-    if (this.isStreamTranscribeInitialized) {
+  public async streamTranscribeStart(
+    options?: CactusSTTStreamTranscribeStartOptions
+  ): Promise<void> {
+    if (this.isStreamTranscribing) {
       return;
     }
 
     await this.init();
-
-    try {
-      await this.cactus.streamTranscribeInit();
-      this.isStreamTranscribeInitialized = true;
-    } catch (error) {
-      throw error;
-    }
+    await this.cactus.streamTranscribeStart(options);
+    this.isStreamTranscribing = true;
   }
 
-  public async streamTranscribeInsert({
+  public async streamTranscribeProcess({
     audio,
-  }: CactusSTTStreamTranscribeInsertParams): Promise<void> {
-    if (!this.isStreamTranscribeInitialized) {
-      throw new Error('CactusSTT stream transcribe is not initialized');
+  }: CactusSTTStreamTranscribeProcessParams): Promise<CactusSTTStreamTranscribeProcessResult> {
+    if (!this.isStreamTranscribing) {
+      throw new Error('CactusSTT stream transcribe is not started');
     }
 
-    try {
-      await this.cactus.streamTranscribeInsert(audio);
-    } catch (error) {
-      throw error;
-    }
+    return this.cactus.streamTranscribeProcess(audio);
   }
 
-  public async streamTranscribeProcess({
-    options,
-  }: CactusSTTStreamTranscribeProcessParams = {}): Promise<CactusSTTStreamTranscribeProcessResult> {
-    if (!this.isStreamTranscribeInitialized) {
-      throw new Error('CactusSTT stream transcribe is not initialized');
+  public async streamTranscribeStop(): Promise<CactusSTTStreamTranscribeStopResult> {
+    if (!this.isStreamTranscribing) {
+      throw new Error('CactusSTT stream transcribe is not started');
     }
 
     try {
-      const result = await this.cactus.streamTranscribeProcess(options);
-      return result;
-    } catch (error) {
-      throw error;
+      return await this.cactus.streamTranscribeStop();
+    } finally {
+      this.isStreamTranscribing = false;
     }
   }
 
-  public async streamTranscribeFinalize(): Promise<CactusSTTStreamTranscribeFinalizeResult> {
-    if (!this.isStreamTranscribeInitialized) {
-      throw new Error('CactusSTT stream transcribe is not initialized');
-    }
-
-    try {
-      const result = await this.cactus.streamTranscribeFinalize();
-      return result;
-    } catch (error) {
-      throw error;
+  public async detectLanguage({
+    audio,
+    options,
+  }: CactusSTTDetectLanguageParams): Promise<CactusSTTDetectLanguageResult> {
+    if (this.isGenerating) {
+      throw new Error('CactusSTT is already generating');
     }
-  }
 
-  public async streamTranscribeDestroy(): Promise<void> {
-    if (!this.isStreamTranscribeInitialized) {
-      return;
-    }
+    await this.init();
 
+    this.isGenerating = true;
     try {
-      await this.cactus.streamTranscribeDestroy();
-      this.isStreamTranscribeInitialized = false;
-    } catch (error) {
-      throw error;
+      return await this.cactus.detectLanguage(audio, options);
+    } finally {
+      this.isGenerating = false;
     }
   }
 
@@ -252,11 +214,7 @@ export class CactusSTT {
         audioPath,
         CactusSTT.defaultEmbedBufferSize
       );
-      Telemetry.logAudioEmbedding(this.model, true);
       return { embedding };
-    } catch (error) {
-      Telemetry.logAudioEmbedding(this.model, false, getErrorMessage(error));
-      throw error;
     } finally {
       this.isGenerating = false;
     }
@@ -277,21 +235,25 @@ export class CactusSTT {
     }
 
     await this.stop();
-    await this.streamTranscribeDestroy();
-    await this.cactus.destroy();
 
+    if (this.isStreamTranscribing) {
+      await this.cactus.streamTranscribeStop().catch(() => {});
+      this.isStreamTranscribing = false;
+    }
+
+    await this.cactus.destroy();
     this.isInitialized = false;
   }
 
-  public getModels(): CactusModel[] {
-    return Object.values(models).filter((model) => model.speech);
+  public async getModels(): Promise<CactusModel[]> {
+    return Object.values(await getRegistry());
   }
 
   private isModelPath(model: string): boolean {
     return model.startsWith('file://') || model.startsWith('/');
   }
 
-  private getModelName(): string {
+  public getModelName(): string {
     return `${this.model}-${this.options.quantization}${this.options.pro ? '-pro' : ''}`;
   }
 }

package/src/classes/CactusVAD.ts

@@ -0,0 +1,129 @@
+import { Cactus, CactusFileSystem } from '../native';
+import type {
+  CactusVADParams,
+  CactusVADDownloadParams,
+  CactusVADVadParams,
+  CactusVADResult,
+} from '../types/CactusVAD';
+import { getRegistry } from '../modelRegistry';
+import type { CactusModel } from '../types/common';
+
+export class CactusVAD {
+  private readonly cactus = new Cactus();
+
+  private readonly model: string;
+  private readonly options: {
+    quantization: 'int4' | 'int8';
+    pro: boolean;
+  };
+
+  private isDownloading = false;
+  private isInitialized = false;
+
+  private static readonly defaultModel = 'silero-vad';
+  private static readonly defaultOptions = {
+    quantization: 'int8' as const,
+    pro: false,
+  };
+
+  constructor({ model, options }: CactusVADParams = {}) {
+    this.model = model ?? CactusVAD.defaultModel;
+    this.options = {
+      quantization:
+        options?.quantization ?? CactusVAD.defaultOptions.quantization,
+      pro: options?.pro ?? CactusVAD.defaultOptions.pro,
+    };
+  }
+
+  public async download({
+    onProgress,
+  }: CactusVADDownloadParams = {}): Promise<void> {
+    if (this.isModelPath(this.model)) {
+      onProgress?.(1.0);
+      return;
+    }
+
+    if (this.isDownloading) {
+      throw new Error('CactusVAD is already downloading');
+    }
+
+    if (await CactusFileSystem.modelExists(this.getModelName())) {
+      console.log('Model already exists', this.getModelName());
+      onProgress?.(1.0);
+      return;
+    }
+
+    this.isDownloading = true;
+    try {
+      const registry = await getRegistry();
+      const modelConfig =
+        registry[this.model]?.quantization[this.options.quantization];
+      const url = this.options.pro ? modelConfig?.pro?.apple : modelConfig?.url;
+
+      if (!url) {
+        throw new Error(`Model ${this.model} with specified options not found`);
+      }
+
+      await CactusFileSystem.downloadModel(
+        this.getModelName(),
+        url,
+        onProgress
+      );
+    } finally {
+      this.isDownloading = false;
+    }
+  }
+
+  public async init(): Promise<void> {
+    if (this.isInitialized) {
+      return;
+    }
+
+    let modelPath: string;
+    if (this.isModelPath(this.model)) {
+      modelPath = this.model.replace('file://', '');
+    } else {
+      if (!(await CactusFileSystem.modelExists(this.getModelName()))) {
+        console.log('Model does not exist', this.getModelName());
+        throw new Error(
+          `Model "${this.model}" with options ${JSON.stringify(this.options)} is not downloaded`
+        );
+      }
+      modelPath = await CactusFileSystem.getModelPath(this.getModelName());
+    }
+
+    const cacheDir = await CactusFileSystem.getCactusDirectory();
+    await this.cactus.setTelemetryEnvironment(cacheDir);
+    await this.cactus.init(modelPath);
+    this.isInitialized = true;
+  }
+
+  public async vad({
+    audio,
+    options,
+  }: CactusVADVadParams): Promise<CactusVADResult> {
+    await this.init();
+    return this.cactus.vad(audio, options);
+  }
+
+  public async destroy(): Promise<void> {
+    if (!this.isInitialized) {
+      return;
+    }
+
+    await this.cactus.destroy();
+    this.isInitialized = false;
+  }
+
+  public async getModels(): Promise<CactusModel[]> {
+    return Object.values(await getRegistry());
+  }
+
+  private isModelPath(model: string): boolean {
+    return model.startsWith('file://') || model.startsWith('/');
+  }
+
+  public getModelName(): string {
+    return `${this.model}-${this.options.quantization}${this.options.pro ? '-pro' : ''}`;
+  }
+}

package/src/hooks/useCactusLM.ts

@@ -20,15 +20,15 @@ import type { CactusModel } from '../types/common';
 
 export const useCactusLM = ({
   model = 'qwen3-0.6b',
-  contextSize = 2048,
   corpusDir = undefined,
+  cacheIndex = false,
   options: modelOptions = {
     quantization: undefined,
     pro: false,
   },
 }: CactusLMParams = {}) => {
   const [cactusLM, setCactusLM] = useState(
-    () => new CactusLM({ model, contextSize, corpusDir, options: modelOptions })
+    () => new CactusLM({ model, corpusDir, cacheIndex, options: modelOptions })
   );
 
   // State
@@ -48,17 +48,16 @@ export const useCactusLM = ({
   }, [model]);
 
   useEffect(() => {
-    setCactusLM(
-      new CactusLM({
-        model,
-        contextSize,
-        corpusDir,
-        options: {
-          quantization: modelOptions.quantization,
-          pro: modelOptions.pro,
-        },
-      })
-    );
+    const newInstance = new CactusLM({
+      model,
+      corpusDir,
+      cacheIndex,
+      options: {
+        quantization: modelOptions.quantization,
+        pro: modelOptions.pro,
+      },
+    });
+    setCactusLM(newInstance);
 
     setCompletion('');
     setIsGenerating(false);
@@ -69,7 +68,7 @@ export const useCactusLM = ({
     setError(null);
 
     let mounted = true;
-    CactusFileSystem.modelExists(model)
+    CactusFileSystem.modelExists(newInstance.getModelName())
       .then((exists) => {
         if (!mounted) {
           return;
@@ -89,8 +88,8 @@ export const useCactusLM = ({
     };
   }, [
     model,
-    contextSize,
     corpusDir,
+    cacheIndex,
     modelOptions.quantization,
     modelOptions.pro,
   ]);
@@ -193,7 +192,6 @@ export const useCactusLM = ({
       options,
       tools,
       onToken,
-      mode,
     }: CactusLMCompleteParams): Promise<CactusLMCompleteResult> => {
       if (isGenerating) {
         const message = 'CactusLM is already generating';
@@ -213,7 +211,6 @@ export const useCactusLM = ({
             setCompletion((prev) => prev + token);
             onToken?.(token);
           },
-          mode,
         });
       } catch (e) {
         setError(getErrorMessage(e));