cactus-react-native 1.5.0 → 1.7.0

package/src/classes/CactusSTT.ts

@@ -6,22 +6,18 @@ import type {
   CactusSTTParams,
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
-  CactusSTTStreamTranscribeInsertParams,
+  CactusSTTStreamTranscribeStartOptions,
   CactusSTTStreamTranscribeProcessParams,
   CactusSTTStreamTranscribeProcessResult,
-  CactusSTTStreamTranscribeFinalizeResult,
+  CactusSTTStreamTranscribeStopResult,
 } 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 +26,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 +40,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 +69,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 +106,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 +133,49 @@ 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;
-    }
-  }
-
-  public async streamTranscribeInsert({
-    audio,
-  }: CactusSTTStreamTranscribeInsertParams): Promise<void> {
-    if (!this.isStreamTranscribeInitialized) {
-      throw new Error('CactusSTT stream transcribe is not initialized');
-    }
-
-    try {
-      await this.cactus.streamTranscribeInsert(audio);
-    } catch (error) {
-      throw error;
-    }
+    await this.cactus.streamTranscribeStart(options);
+    this.isStreamTranscribing = true;
   }
 
   public async streamTranscribeProcess({
-    options,
-  }: CactusSTTStreamTranscribeProcessParams = {}): Promise<CactusSTTStreamTranscribeProcessResult> {
-    if (!this.isStreamTranscribeInitialized) {
-      throw new Error('CactusSTT stream transcribe is not initialized');
+    audio,
+  }: CactusSTTStreamTranscribeProcessParams): Promise<CactusSTTStreamTranscribeProcessResult> {
+    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 this.cactus.streamTranscribeProcess(audio);
   }
 
-  public async streamTranscribeFinalize(): Promise<CactusSTTStreamTranscribeFinalizeResult> {
-    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.streamTranscribeFinalize();
-      return result;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  public async streamTranscribeDestroy(): Promise<void> {
-    if (!this.isStreamTranscribeInitialized) {
-      return;
-    }
-
-    try {
-      await this.cactus.streamTranscribeDestroy();
-      this.isStreamTranscribeInitialized = false;
-    } catch (error) {
-      throw error;
+      return await this.cactus.streamTranscribeStop();
+    } finally {
+      this.isStreamTranscribing = false;
     }
   }
 
@@ -252,11 +194,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 +215,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));

package/src/hooks/useCactusSTT.ts

@@ -9,23 +9,22 @@ import type {
   CactusSTTDownloadParams,
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
-  CactusSTTStreamTranscribeInsertParams,
+  CactusSTTStreamTranscribeStartOptions,
   CactusSTTStreamTranscribeProcessParams,
   CactusSTTStreamTranscribeProcessResult,
-  CactusSTTStreamTranscribeFinalizeResult,
+  CactusSTTStreamTranscribeStopResult,
 } from '../types/CactusSTT';
 import type { CactusModel } from '../types/common';
 
 export const useCactusSTT = ({
   model = 'whisper-small',
-  contextSize = 2048,
   options: modelOptions = {
     quantization: undefined,
     pro: false,
   },
 }: CactusSTTParams = {}) => {
   const [cactusSTT, setCactusSTT] = useState(
-    () => new CactusSTT({ model, contextSize, options: modelOptions })
+    () => new CactusSTT({ model, options: modelOptions })
   );
 
   // State
@@ -49,16 +48,14 @@ export const useCactusSTT = ({
   }, [model]);
 
   useEffect(() => {
-    setCactusSTT(
-      new CactusSTT({
-        model,
-        contextSize,
-        options: {
-          quantization: modelOptions.quantization,
-          pro: modelOptions.pro,
-        },
-      })
-    );
+    const newInstance = new CactusSTT({
+      model,
+      options: {
+        quantization: modelOptions.quantization,
+        pro: modelOptions.pro,
+      },
+    });
+    setCactusSTT(newInstance);
 
     setTranscription('');
     setStreamTranscribeConfirmed('');
@@ -72,25 +69,21 @@ export const useCactusSTT = ({
     setError(null);
 
     let mounted = true;
-    CactusFileSystem.modelExists(model)
+    CactusFileSystem.modelExists(newInstance.getModelName())
       .then((exists) => {
-        if (!mounted) {
-          return;
-        }
-        setIsDownloaded(exists);
+        if (mounted) setIsDownloaded(exists);
       })
       .catch((e) => {
-        if (!mounted) {
-          return;
+        if (mounted) {
+          setIsDownloaded(false);
+          setError(getErrorMessage(e));
         }
-        setIsDownloaded(false);
-        setError(getErrorMessage(e));
       });
 
     return () => {
       mounted = false;
     };
-  }, [model, contextSize, modelOptions.quantization, modelOptions.pro]);
+  }, [model, modelOptions.quantization, modelOptions.pro]);
 
   useEffect(() => {
     return () => {
@@ -115,49 +108,29 @@ export const useCactusSTT = ({
       const thisModel = currentModelRef.current;
       const thisDownloadId = ++currentDownloadIdRef.current;
 
+      const isCurrent = () =>
+        currentModelRef.current === thisModel &&
+        currentDownloadIdRef.current === thisDownloadId;
+
       setDownloadProgress(0);
       setIsDownloading(true);
       try {
         await cactusSTT.download({
           onProgress: (progress) => {
-            if (
-              currentModelRef.current !== thisModel ||
-              currentDownloadIdRef.current !== thisDownloadId
-            ) {
-              return;
-            }
-
+            if (!isCurrent()) return;
             setDownloadProgress(progress);
             onProgress?.(progress);
           },
         });
 
-        if (
-          currentModelRef.current !== thisModel ||
-          currentDownloadIdRef.current !== thisDownloadId
-        ) {
-          return;
-        }
-
+        if (!isCurrent()) return;
         setIsDownloaded(true);
       } catch (e) {
-        if (
-          currentModelRef.current !== thisModel ||
-          currentDownloadIdRef.current !== thisDownloadId
-        ) {
-          return;
-        }
-
+        if (!isCurrent()) return;
         setError(getErrorMessage(e));
         throw e;
       } finally {
-        if (
-          currentModelRef.current !== thisModel ||
-          currentDownloadIdRef.current !== thisDownloadId
-        ) {
-          return;
-        }
-
+        if (!isCurrent()) return;
         setIsDownloading(false);
         setDownloadProgress(0);
       }
@@ -244,44 +217,34 @@ export const useCactusSTT = ({
     [cactusSTT, isGenerating]
   );
 
-  const streamTranscribeInit = useCallback(async () => {
-    if (isStreamTranscribing) {
-      return;
-    }
-
-    setError(null);
-    setStreamTranscribeConfirmed('');
-    setStreamTranscribePending('');
-    setIsStreamTranscribing(true);
-    try {
-      await cactusSTT.streamTranscribeInit();
-    } catch (e) {
-      setError(getErrorMessage(e));
-      setIsStreamTranscribing(false);
-      throw e;
-    }
-  }, [cactusSTT, isStreamTranscribing]);
+  const streamTranscribeStart = useCallback(
+    async (options?: CactusSTTStreamTranscribeStartOptions) => {
+      if (isStreamTranscribing) {
+        return;
+      }
 
-  const streamTranscribeInsert = useCallback(
-    async ({ audio }: CactusSTTStreamTranscribeInsertParams): Promise<void> => {
       setError(null);
+      setStreamTranscribeConfirmed('');
+      setStreamTranscribePending('');
+      setIsStreamTranscribing(true);
       try {
-        await cactusSTT.streamTranscribeInsert({ audio });
+        await cactusSTT.streamTranscribeStart(options);
       } catch (e) {
         setError(getErrorMessage(e));
+        setIsStreamTranscribing(false);
         throw e;
       }
     },
-    [cactusSTT]
+    [cactusSTT, isStreamTranscribing]
   );
 
   const streamTranscribeProcess = useCallback(
     async ({
-      options,
-    }: CactusSTTStreamTranscribeProcessParams = {}): Promise<CactusSTTStreamTranscribeProcessResult> => {
+      audio,
+    }: CactusSTTStreamTranscribeProcessParams): Promise<CactusSTTStreamTranscribeProcessResult> => {
       setError(null);
       try {
-        const result = await cactusSTT.streamTranscribeProcess({ options });
+        const result = await cactusSTT.streamTranscribeProcess({ audio });
         setStreamTranscribeConfirmed((prev) => prev + result.confirmed);
         setStreamTranscribePending(result.pending);
         return result;
@@ -293,34 +256,22 @@ export const useCactusSTT = ({
     [cactusSTT]
   );
 
-  const streamTranscribeFinalize =
-    useCallback(async (): Promise<CactusSTTStreamTranscribeFinalizeResult> => {
+  const streamTranscribeStop =
+    useCallback(async (): Promise<CactusSTTStreamTranscribeStopResult> => {
       setError(null);
       try {
-        const result = await cactusSTT.streamTranscribeFinalize();
+        const result = await cactusSTT.streamTranscribeStop();
         setStreamTranscribeConfirmed((prev) => prev + result.confirmed);
         setStreamTranscribePending('');
-        setIsStreamTranscribing(false);
         return result;
       } catch (e) {
         setError(getErrorMessage(e));
         throw e;
+      } finally {
+        setIsStreamTranscribing(false);
       }
     }, [cactusSTT]);
 
-  const streamTranscribeDestroy = useCallback(async (): Promise<void> => {
-    setError(null);
-    try {
-      await cactusSTT.streamTranscribeDestroy();
-    } catch (e) {
-      setError(getErrorMessage(e));
-      throw e;
-    } finally {
-      setIsStreamTranscribing(false);
-      setStreamTranscribePending('');
-    }
-  }, [cactusSTT]);
-
   const stop = useCallback(async () => {
     setError(null);
     try {
@@ -384,13 +335,11 @@ export const useCactusSTT = ({
     init,
     transcribe,
     audioEmbed,
-    streamTranscribeInit,
-    streamTranscribeInsert,
+    streamTranscribeStart,
     streamTranscribeProcess,
-    streamTranscribeFinalize,
-    streamTranscribeDestroy,
-    reset,
+    streamTranscribeStop,
     stop,
+    reset,
     destroy,
     getModels,
   };