cactus-react-native 1.4.0 → 1.5.0

package/src/classes/CactusLM.ts

@@ -13,12 +13,12 @@ import type {
   CactusLMImageEmbedResult,
   CactusLMParams,
 } from '../types/CactusLM';
-import type { CactusModel } from '../types/CactusModel';
 import { Telemetry } from '../telemetry/Telemetry';
 import { CactusConfig } from '../config/CactusConfig';
-import { Database } from '../api/Database';
 import { getErrorMessage } from '../utils/error';
 import { RemoteLM } from '../api/RemoteLM';
+import models from '../models';
+import type { CactusModel } from '../types/common';
 
 export class CactusLM {
   private readonly cactus = new Cactus();
@@ -26,25 +26,46 @@ export class CactusLM {
   private readonly model: string;
   private readonly contextSize: number;
   private readonly corpusDir?: string;
+  private readonly options: {
+    quantization: 'int4' | 'int8';
+    pro: boolean;
+  };
 
   private isDownloading = false;
   private isInitialized = false;
   private isGenerating = false;
 
-  private static readonly defaultModel = 'qwen3-0.6';
+  private static readonly defaultModel = 'qwen3-0.6b';
   private static readonly defaultContextSize = 2048;
+  private static readonly defaultOptions = {
+    quantization: 'int4' as const,
+    pro: false,
+  };
+  private static readonly quantizationExceptions: {
+    [model: string]: 'int4' | 'int8';
+  } = {
+    'gemma-3-270m-it': 'int8' as const,
+    'functiongemma-270m-it': 'int8' as const,
+  };
   private static readonly defaultCompleteOptions = {
     maxTokens: 512,
   };
   private static readonly defaultCompleteMode = 'local';
   private static readonly defaultEmbedBufferSize = 2048;
 
-  constructor({ model, contextSize, corpusDir }: CactusLMParams = {}) {
+  constructor({ model, contextSize, corpusDir, options }: CactusLMParams = {}) {
     Telemetry.init(CactusConfig.telemetryToken);
 
     this.model = model ?? CactusLM.defaultModel;
     this.contextSize = contextSize ?? CactusLM.defaultContextSize;
     this.corpusDir = corpusDir;
+    this.options = {
+      quantization:
+        options?.quantization ??
+        CactusLM.quantizationExceptions[this.model] ??
+        CactusLM.defaultOptions.quantization,
+      pro: options?.pro ?? CactusLM.defaultOptions.pro,
+    };
   }
 
   public async download({
@@ -59,17 +80,25 @@ export class CactusLM {
       throw new Error('CactusLM is already downloading');
     }
 
-    if (await CactusFileSystem.modelExists(this.model)) {
+    if (await CactusFileSystem.modelExists(this.getModelName())) {
+      console.log('Model already exists', this.getModelName());
       onProgress?.(1.0);
       return;
     }
 
     this.isDownloading = true;
     try {
-      const model = await Database.getModel(this.model);
+      const modelConfig =
+        models[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.model,
-        model.downloadUrl,
+        this.getModelName(),
+        url,
         onProgress
       );
     } finally {
@@ -86,10 +115,13 @@ export class CactusLM {
     if (this.isModelPath(this.model)) {
       modelPath = this.model.replace('file://', '');
     } else {
-      if (!(await CactusFileSystem.modelExists(this.model))) {
-        throw new Error(`Model "${this.model}" is not downloaded`);
+      if (!(await CactusFileSystem.modelExists(this.getModelName()))) {
+        console.log('Model not found:', this.getModelName());
+        throw new Error(
+          `Model "${this.model}" with options ${JSON.stringify(this.options)} is not downloaded`
+        );
       }
-      modelPath = await CactusFileSystem.getModelPath(this.model);
+      modelPath = await CactusFileSystem.getModelPath(this.getModelName());
     }
 
     try {
@@ -255,15 +287,15 @@ export class CactusLM {
     this.isInitialized = false;
   }
 
-  public async getModels(): Promise<CactusModel[]> {
-    const models = await Database.getModels();
-    for (const model of models) {
-      model.isDownloaded = await CactusFileSystem.modelExists(model.slug);
-    }
-    return models;
+  public getModels(): CactusModel[] {
+    return Object.values(models).filter((model) => model.completion);
   }
 
   private isModelPath(model: string): boolean {
     return model.startsWith('file://') || model.startsWith('/');
   }
+
+  private getModelName(): string {
+    return `${this.model}-${this.options.quantization}${this.options.pro ? '-pro' : ''}`;
+  }
 }

package/src/classes/CactusSTT.ts

@@ -6,37 +6,56 @@ import type {
   CactusSTTParams,
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
+  CactusSTTStreamTranscribeInsertParams,
+  CactusSTTStreamTranscribeProcessParams,
+  CactusSTTStreamTranscribeProcessResult,
+  CactusSTTStreamTranscribeFinalizeResult,
 } from '../types/CactusSTT';
 import { Telemetry } from '../telemetry/Telemetry';
 import { CactusConfig } from '../config/CactusConfig';
-import { Database } from '../api/Database';
 import { getErrorMessage } from '../utils/error';
-import type { CactusSTTModel } from '../types/CactusSTTModel';
+import models from '../models';
+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;
+  };
 
   private isDownloading = false;
   private isInitialized = false;
   private isGenerating = false;
 
+  private isStreamTranscribeInitialized = false;
+
   private static readonly defaultModel = 'whisper-small';
   private static readonly defaultContextSize = 2048;
+  private static readonly defaultOptions = {
+    quantization: 'int4' as const,
+    pro: false,
+  };
   private static readonly defaultPrompt =
     '<|startoftranscript|><|en|><|transcribe|><|notimestamps|>';
   private static readonly defaultTranscribeOptions = {
-    maxTokens: 512,
+    maxTokens: 384,
   };
   private static readonly defaultEmbedBufferSize = 4096;
 
-  constructor({ model, contextSize }: CactusSTTParams = {}) {
+  constructor({ model, contextSize, options }: CactusSTTParams = {}) {
     Telemetry.init(CactusConfig.telemetryToken);
 
     this.model = model ?? CactusSTT.defaultModel;
     this.contextSize = contextSize ?? CactusSTT.defaultContextSize;
+    this.options = {
+      quantization:
+        options?.quantization ?? CactusSTT.defaultOptions.quantization,
+      pro: options?.pro ?? CactusSTT.defaultOptions.pro,
+    };
   }
 
   public async download({
@@ -51,17 +70,25 @@ export class CactusSTT {
       throw new Error('CactusSTT is already downloading');
     }
 
-    if (await CactusFileSystem.modelExists(this.model)) {
+    if (await CactusFileSystem.modelExists(this.getModelName())) {
+      console.log('Model already exists', this.getModelName());
       onProgress?.(1.0);
       return;
     }
 
     this.isDownloading = true;
     try {
-      const model = await Database.getSTTModel(this.model);
+      const modelConfig =
+        models[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.model,
-        model.downloadUrl,
+        this.getModelName(),
+        url,
         onProgress
       );
     } finally {
@@ -78,10 +105,13 @@ export class CactusSTT {
     if (this.isModelPath(this.model)) {
       modelPath = this.model.replace('file://', '');
     } else {
-      if (!(await CactusFileSystem.modelExists(this.model))) {
-        throw new Error(`Model "${this.model}" is not downloaded`);
+      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.model);
+      modelPath = await CactusFileSystem.getModelPath(this.getModelName());
     }
 
     try {
@@ -137,6 +167,76 @@ export class CactusSTT {
     }
   }
 
+  public async streamTranscribeInit(): Promise<void> {
+    if (this.isStreamTranscribeInitialized) {
+      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;
+    }
+  }
+
+  public async streamTranscribeProcess({
+    options,
+  }: CactusSTTStreamTranscribeProcessParams = {}): Promise<CactusSTTStreamTranscribeProcessResult> {
+    if (!this.isStreamTranscribeInitialized) {
+      throw new Error('CactusSTT stream transcribe is not initialized');
+    }
+
+    try {
+      const result = await this.cactus.streamTranscribeProcess(options);
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  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 streamTranscribeDestroy(): Promise<void> {
+    if (!this.isStreamTranscribeInitialized) {
+      return;
+    }
+
+    try {
+      await this.cactus.streamTranscribeDestroy();
+      this.isStreamTranscribeInitialized = false;
+    } catch (error) {
+      throw error;
+    }
+  }
+
   public async audioEmbed({
     audioPath,
   }: CactusSTTAudioEmbedParams): Promise<CactusSTTAudioEmbedResult> {
@@ -177,20 +277,21 @@ export class CactusSTT {
     }
 
     await this.stop();
+    await this.streamTranscribeDestroy();
     await this.cactus.destroy();
 
     this.isInitialized = false;
   }
 
-  public async getModels(): Promise<CactusSTTModel[]> {
-    const models = await Database.getSTTModels();
-    for (const model of models) {
-      model.isDownloaded = await CactusFileSystem.modelExists(model.slug);
-    }
-    return models;
+  public getModels(): CactusModel[] {
+    return Object.values(models).filter((model) => model.speech);
   }
 
   private isModelPath(model: string): boolean {
     return model.startsWith('file://') || model.startsWith('/');
   }
+
+  private getModelName(): string {
+    return `${this.model}-${this.options.quantization}${this.options.pro ? '-pro' : ''}`;
+  }
 }

package/src/hooks/useCactusLM.ts

@@ -16,15 +16,19 @@ import type {
   CactusLMImageEmbedResult,
   CactusLMDownloadParams,
 } from '../types/CactusLM';
-import type { CactusModel } from '../types/CactusModel';
+import type { CactusModel } from '../types/common';
 
 export const useCactusLM = ({
-  model = 'qwen3-0.6',
+  model = 'qwen3-0.6b',
   contextSize = 2048,
   corpusDir = undefined,
+  options: modelOptions = {
+    quantization: undefined,
+    pro: false,
+  },
 }: CactusLMParams = {}) => {
   const [cactusLM, setCactusLM] = useState(
-    () => new CactusLM({ model, contextSize, corpusDir })
+    () => new CactusLM({ model, contextSize, corpusDir, options: modelOptions })
   );
 
   // State
@@ -44,7 +48,17 @@ export const useCactusLM = ({
   }, [model]);
 
   useEffect(() => {
-    setCactusLM(new CactusLM({ model, contextSize, corpusDir }));
+    setCactusLM(
+      new CactusLM({
+        model,
+        contextSize,
+        corpusDir,
+        options: {
+          quantization: modelOptions.quantization,
+          pro: modelOptions.pro,
+        },
+      })
+    );
 
     setCompletion('');
     setIsGenerating(false);
@@ -73,7 +87,13 @@ export const useCactusLM = ({
     return () => {
       mounted = false;
     };
-  }, [model, contextSize, corpusDir]);
+  }, [
+    model,
+    contextSize,
+    corpusDir,
+    modelOptions.quantization,
+    modelOptions.pro,
+  ]);
 
   useEffect(() => {
     return () => {

package/src/hooks/useCactusSTT.ts

@@ -9,20 +9,32 @@ import type {
   CactusSTTDownloadParams,
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
+  CactusSTTStreamTranscribeInsertParams,
+  CactusSTTStreamTranscribeProcessParams,
+  CactusSTTStreamTranscribeProcessResult,
+  CactusSTTStreamTranscribeFinalizeResult,
 } from '../types/CactusSTT';
-import type { CactusSTTModel } from '../types/CactusSTTModel';
+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 })
+    () => new CactusSTT({ model, contextSize, options: modelOptions })
   );
 
   // State
   const [transcription, setTranscription] = useState('');
+  const [streamTranscribeConfirmed, setStreamTranscribeConfirmed] =
+    useState('');
+  const [streamTranscribePending, setStreamTranscribePending] = useState('');
   const [isGenerating, setIsGenerating] = useState(false);
+  const [isStreamTranscribing, setIsStreamTranscribing] = useState(false);
   const [isInitializing, setIsInitializing] = useState(false);
   const [isDownloaded, setIsDownloaded] = useState(false);
   const [isDownloading, setIsDownloading] = useState(false);
@@ -37,10 +49,22 @@ export const useCactusSTT = ({
   }, [model]);
 
   useEffect(() => {
-    setCactusSTT(new CactusSTT({ model, contextSize }));
+    setCactusSTT(
+      new CactusSTT({
+        model,
+        contextSize,
+        options: {
+          quantization: modelOptions.quantization,
+          pro: modelOptions.pro,
+        },
+      })
+    );
 
     setTranscription('');
+    setStreamTranscribeConfirmed('');
+    setStreamTranscribePending('');
     setIsGenerating(false);
+    setIsStreamTranscribing(false);
     setIsInitializing(false);
     setIsDownloaded(false);
     setIsDownloading(false);
@@ -66,7 +90,7 @@ export const useCactusSTT = ({
     return () => {
       mounted = false;
     };
-  }, [model, contextSize]);
+  }, [model, contextSize, modelOptions.quantization, modelOptions.pro]);
 
   useEffect(() => {
     return () => {
@@ -220,6 +244,83 @@ 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 streamTranscribeInsert = useCallback(
+    async ({ audio }: CactusSTTStreamTranscribeInsertParams): Promise<void> => {
+      setError(null);
+      try {
+        await cactusSTT.streamTranscribeInsert({ audio });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      }
+    },
+    [cactusSTT]
+  );
+
+  const streamTranscribeProcess = useCallback(
+    async ({
+      options,
+    }: CactusSTTStreamTranscribeProcessParams = {}): Promise<CactusSTTStreamTranscribeProcessResult> => {
+      setError(null);
+      try {
+        const result = await cactusSTT.streamTranscribeProcess({ options });
+        setStreamTranscribeConfirmed((prev) => prev + result.confirmed);
+        setStreamTranscribePending(result.pending);
+        return result;
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      }
+    },
+    [cactusSTT]
+  );
+
+  const streamTranscribeFinalize =
+    useCallback(async (): Promise<CactusSTTStreamTranscribeFinalizeResult> => {
+      setError(null);
+      try {
+        const result = await cactusSTT.streamTranscribeFinalize();
+        setStreamTranscribeConfirmed((prev) => prev + result.confirmed);
+        setStreamTranscribePending('');
+        setIsStreamTranscribing(false);
+        return result;
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      }
+    }, [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 {
@@ -251,10 +352,13 @@ export const useCactusSTT = ({
       throw e;
     } finally {
       setTranscription('');
+      setStreamTranscribeConfirmed('');
+      setStreamTranscribePending('');
+      setIsStreamTranscribing(false);
     }
   }, [cactusSTT]);
 
-  const getModels = useCallback(async (): Promise<CactusSTTModel[]> => {
+  const getModels = useCallback(async (): Promise<CactusModel[]> => {
     setError(null);
     try {
       return await cactusSTT.getModels();
@@ -266,7 +370,10 @@ export const useCactusSTT = ({
 
   return {
     transcription,
+    streamTranscribeConfirmed,
+    streamTranscribePending,
     isGenerating,
+    isStreamTranscribing,
     isInitializing,
     isDownloaded,
     isDownloading,
@@ -277,6 +384,11 @@ export const useCactusSTT = ({
     init,
     transcribe,
     audioEmbed,
+    streamTranscribeInit,
+    streamTranscribeInsert,
+    streamTranscribeProcess,
+    streamTranscribeFinalize,
+    streamTranscribeDestroy,
     reset,
     stop,
     destroy,

package/src/index.tsx

@@ -9,8 +9,7 @@ export { useCactusSTT } from './hooks/useCactusSTT';
 export { useCactusIndex } from './hooks/useCactusIndex';
 
 // Types
-export type { CactusModel } from './types/CactusModel';
-export type { CactusSTTModel } from './types/CactusSTTModel';
+export type { CactusModel, ModelOptions } from './types/common';
 export type {
   CactusLMParams,
   CactusLMDownloadParams,
@@ -36,6 +35,11 @@ export type {
   CactusSTTTranscribeResult,
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
+  CactusSTTStreamTranscribeInsertParams,
+  StreamTranscribeProcessOptions,
+  CactusSTTStreamTranscribeProcessParams,
+  CactusSTTStreamTranscribeProcessResult,
+  CactusSTTStreamTranscribeFinalizeResult,
 } from './types/CactusSTT';
 export type {
   CactusIndexParams,