cactus-react-native 1.0.1 → 1.1.0

package/src/classes/CactusLM.ts

@@ -5,7 +5,8 @@ import type {
   CactusLMCompleteResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
-  CactusLMGetModelsParams,
+  CactusLMImageEmbedParams,
+  CactusLMImageEmbedResult,
   CactusLMParams,
 } from '../types/CactusLM';
 import type { CactusModel } from '../types/CactusModel';
@@ -13,12 +14,14 @@ 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';
 
 export class CactusLM {
   private readonly cactus = new Cactus();
 
   private readonly model: string;
   private readonly contextSize: number;
+  private readonly corpusDir?: string;
 
   private isDownloading = false;
   private isInitialized = false;
@@ -29,13 +32,17 @@ export class CactusLM {
   private static readonly defaultCompleteOptions = {
     maxTokens: 512,
   };
+  private static readonly defaultCompleteMode = 'local';
   private static readonly defaultEmbedBufferSize = 2048;
 
-  private static readonly modelsInfoPath = 'models/info.json';
+  private static cactusModelsCache: CactusModel[] | null = null;
+
+  constructor({ model, contextSize, corpusDir }: CactusLMParams = {}) {
+    Telemetry.init(CactusConfig.telemetryToken);
 
-  constructor({ model, contextSize }: CactusLMParams = {}) {
     this.model = model ?? CactusLM.defaultModel;
     this.contextSize = contextSize ?? CactusLM.defaultContextSize;
+    this.corpusDir = corpusDir;
   }
 
   public async download({
@@ -52,8 +59,12 @@ export class CactusLM {
 
     this.isDownloading = true;
     try {
-      await CactusFileSystem.downloadModel(this.model, onProgress);
-      await this.getModels({ forceRefresh: true });
+      const model = await Database.getModel(this.model);
+      await CactusFileSystem.downloadModel(
+        this.model,
+        model.downloadUrl,
+        onProgress
+      );
     } finally {
       this.isDownloading = false;
     }
@@ -64,10 +75,6 @@ export class CactusLM {
       return;
     }
 
-    if (!Telemetry.isInitialized()) {
-      await Telemetry.init(CactusConfig.telemetryToken);
-    }
-
     if (!(await CactusFileSystem.modelExists(this.model))) {
       throw new Error(`Model "${this.model}" is not downloaded`);
     }
@@ -75,7 +82,7 @@ export class CactusLM {
     const modelPath = await CactusFileSystem.getModelPath(this.model);
 
     try {
-      await this.cactus.init(modelPath, this.contextSize);
+      await this.cactus.init(modelPath, this.contextSize, this.corpusDir);
       Telemetry.logInit(this.model, true);
       this.isInitialized = true;
     } catch (error) {
@@ -89,25 +96,32 @@ export class CactusLM {
     options,
     tools,
     onToken,
+    mode,
   }: CactusLMCompleteParams): Promise<CactusLMCompleteResult> {
     if (this.isGenerating) {
       throw new Error('CactusLM is already generating');
     }
 
-    await this.init();
-
     options = { ...CactusLM.defaultCompleteOptions, ...options };
+    const toolsInternal = tools?.map((tool) => ({
+      type: 'function' as const,
+      function: tool,
+    }));
+    mode = mode ?? CactusLM.defaultCompleteMode;
+
     const responseBufferSize =
       8 * (options.maxTokens ?? CactusLM.defaultCompleteOptions.maxTokens) +
       256;
 
-    this.isGenerating = true;
     try {
+      await this.init();
+
+      this.isGenerating = true;
       const result = await this.cactus.complete(
         messages,
         responseBufferSize,
         options,
-        tools,
+        toolsInternal,
         onToken
       );
       Telemetry.logCompletion(
@@ -117,9 +131,25 @@ export class CactusLM {
         result
       );
       return result;
-    } catch (error) {
-      Telemetry.logCompletion(this.model, false, getErrorMessage(error));
-      throw error;
+    } catch (localError) {
+      if (mode === 'local') {
+        Telemetry.logCompletion(this.model, false, getErrorMessage(localError));
+        throw localError;
+      }
+
+      Telemetry.logCompletion(
+        this.model,
+        false,
+        `Local completion error: ${getErrorMessage(localError)}. Falling back to remote completion.`
+      );
+
+      try {
+        return RemoteLM.complete(messages, options, toolsInternal, onToken);
+      } catch (remoteError) {
+        throw new Error(
+          `Remote completion error: ${getErrorMessage(remoteError)}`
+        );
+      }
     } finally {
       this.isGenerating = false;
     }
@@ -150,6 +180,31 @@ export class CactusLM {
     }
   }
 
+  public async imageEmbed({
+    imagePath,
+  }: CactusLMImageEmbedParams): Promise<CactusLMImageEmbedResult> {
+    if (this.isGenerating) {
+      throw new Error('CactusLM is already generating');
+    }
+
+    await this.init();
+
+    this.isGenerating = true;
+    try {
+      const embedding = await this.cactus.imageEmbed(
+        imagePath,
+        CactusLM.defaultEmbedBufferSize
+      );
+      Telemetry.logImageEmbedding(this.model, true);
+      return { embedding };
+    } catch (error) {
+      Telemetry.logImageEmbedding(this.model, false, getErrorMessage(error));
+      throw error;
+    } finally {
+      this.isGenerating = false;
+    }
+  }
+
   public stop(): Promise<void> {
     return this.cactus.stop();
   }
@@ -170,34 +225,15 @@ export class CactusLM {
     this.isInitialized = false;
   }
 
-  public async getModels({
-    forceRefresh = false,
-  }: CactusLMGetModelsParams = {}): Promise<CactusModel[]> {
-    if (
-      !forceRefresh &&
-      (await CactusFileSystem.fileExists(CactusLM.modelsInfoPath))
-    ) {
-      try {
-        return JSON.parse(
-          await CactusFileSystem.readFile(CactusLM.modelsInfoPath)
-        );
-      } catch {
-        // Delete corrupted models info
-        await CactusFileSystem.deleteFile(CactusLM.modelsInfoPath);
-      }
+  public async getModels(): Promise<CactusModel[]> {
+    if (CactusLM.cactusModelsCache) {
+      return CactusLM.cactusModelsCache;
     }
-
     const models = await Database.getModels();
-
     for (const model of models) {
       model.isDownloaded = await CactusFileSystem.modelExists(model.slug);
     }
-
-    await CactusFileSystem.writeFile(
-      CactusLM.modelsInfoPath,
-      JSON.stringify(models)
-    );
-
+    CactusLM.cactusModelsCache = models;
     return models;
   }
 }

package/src/classes/CactusSTT.ts

@@ -0,0 +1,182 @@
+import { Cactus, CactusFileSystem } from '../native';
+import type {
+  CactusSTTDownloadParams,
+  CactusSTTTranscribeParams,
+  CactusSTTTranscribeResult,
+  CactusSTTParams,
+  CactusSTTAudioEmbedParams,
+  CactusSTTAudioEmbedResult,
+} from '../types/CactusSTT';
+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';
+
+export class CactusSTT {
+  private readonly cactus = new Cactus();
+
+  private readonly model: string;
+  private readonly contextSize: number;
+
+  private isDownloading = false;
+  private isInitialized = false;
+  private isGenerating = false;
+
+  private static readonly defaultModel = 'whisper-small';
+  private static readonly defaultContextSize = 2048;
+  private static readonly defaultTranscribeOptions = {
+    maxTokens: 512,
+  };
+  private static readonly defaultEmbedBufferSize = 32768;
+
+  private static cactusModelsCache: CactusModel[] | null = null;
+
+  constructor({ model, contextSize }: CactusSTTParams = {}) {
+    Telemetry.init(CactusConfig.telemetryToken);
+
+    this.model = model ?? CactusSTT.defaultModel;
+    this.contextSize = contextSize ?? CactusSTT.defaultContextSize;
+  }
+
+  public async download({
+    onProgress,
+  }: CactusSTTDownloadParams = {}): Promise<void> {
+    if (this.isDownloading) {
+      throw new Error('CactusSTT is already downloading');
+    }
+
+    if (await CactusFileSystem.modelExists(this.model)) {
+      onProgress?.(1.0);
+      return;
+    }
+
+    this.isDownloading = true;
+    try {
+      await CactusFileSystem.downloadModel(
+        this.model,
+        `https://vlqqczxwyaodtcdmdmlw.supabase.co/storage/v1/object/public/voice-models/${this.model}.zip`,
+        onProgress
+      );
+    } finally {
+      this.isDownloading = false;
+    }
+  }
+
+  public async init(): Promise<void> {
+    if (this.isInitialized) {
+      return;
+    }
+
+    if (!(await CactusFileSystem.modelExists(this.model))) {
+      throw new Error(`Model "${this.model}" is not downloaded`);
+    }
+
+    const modelPath = await CactusFileSystem.getModelPath(this.model);
+
+    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;
+    }
+  }
+
+  public async transcribe({
+    audioFilePath,
+    prompt = '<|startoftranscript|><|en|><|transcribe|><|notimestamps|>',
+    options,
+    onToken,
+  }: CactusSTTTranscribeParams): Promise<CactusSTTTranscribeResult> {
+    if (this.isGenerating) {
+      throw new Error('CactusSTT is already generating');
+    }
+
+    await this.init();
+
+    options = { ...CactusSTT.defaultTranscribeOptions, ...options };
+    const responseBufferSize = 32768;
+
+    this.isGenerating = true;
+    try {
+      const result = await this.cactus.transcribe(
+        audioFilePath,
+        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 audioEmbed({
+    audioPath,
+  }: CactusSTTAudioEmbedParams): Promise<CactusSTTAudioEmbedResult> {
+    if (this.isGenerating) {
+      throw new Error('CactusSTT is already generating');
+    }
+
+    await this.init();
+
+    this.isGenerating = true;
+    try {
+      const embedding = await this.cactus.audioEmbed(
+        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;
+    }
+  }
+
+  public stop(): Promise<void> {
+    return this.cactus.stop();
+  }
+
+  public async reset(): Promise<void> {
+    await this.stop();
+    return this.cactus.reset();
+  }
+
+  public async destroy(): Promise<void> {
+    if (!this.isInitialized) {
+      return;
+    }
+
+    await this.stop();
+    await this.cactus.destroy();
+
+    this.isInitialized = false;
+  }
+
+  public async getModels(): Promise<CactusModel[]> {
+    if (CactusSTT.cactusModelsCache) {
+      return CactusSTT.cactusModelsCache;
+    }
+    const models = await Database.getModels();
+    for (const model of models) {
+      model.isDownloaded = await CactusFileSystem.modelExists(model.slug);
+    }
+    CactusSTT.cactusModelsCache = models;
+    return models;
+  }
+}

package/src/config/CactusConfig.ts

@@ -1,4 +1,8 @@
 export class CactusConfig {
+  // Telemetry
   public static telemetryToken?: string;
   public static isTelemetryEnabled: boolean = true;
+
+  // Hybrid mode
+  public static cactusToken?: string;
 }

package/src/constants/packageVersion.ts

@@ -1 +1 @@
-export const packageVersion = '1.0.1';
+export const packageVersion = '1.1.0';

package/src/hooks/useCactusLM.ts

@@ -7,7 +7,8 @@ import type {
   CactusLMCompleteResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
-  CactusLMGetModelsParams,
+  CactusLMImageEmbedParams,
+  CactusLMImageEmbedResult,
   CactusLMCompleteParams,
   CactusLMDownloadParams,
 } from '../types/CactusLM';
@@ -16,9 +17,10 @@ import type { CactusModel } from '../types/CactusModel';
 export const useCactusLM = ({
   model = 'qwen3-0.6',
   contextSize = 2048,
+  corpusDir = undefined,
 }: CactusLMParams = {}) => {
   const [cactusLM, setCactusLM] = useState(
-    () => new CactusLM({ model, contextSize })
+    () => new CactusLM({ model, contextSize, corpusDir })
   );
 
   // State
@@ -38,7 +40,7 @@ export const useCactusLM = ({
   }, [model]);
 
   useEffect(() => {
-    setCactusLM(new CactusLM({ model, contextSize }));
+    setCactusLM(new CactusLM({ model, contextSize, corpusDir }));
 
     setCompletion('');
     setIsGenerating(false);
@@ -67,7 +69,7 @@ export const useCactusLM = ({
     return () => {
       mounted = false;
     };
-  }, [model, contextSize]);
+  }, [model, contextSize, corpusDir]);
 
   useEffect(() => {
     return () => {
@@ -83,10 +85,15 @@ export const useCactusLM = ({
         throw new Error(message);
       }
 
+      setError(null);
+
+      if (isDownloaded) {
+        return;
+      }
+
       const thisModel = currentModelRef.current;
       const thisDownloadId = ++currentDownloadIdRef.current;
 
-      setError(null);
       setDownloadProgress(0);
       setIsDownloading(true);
       try {
@@ -134,7 +141,7 @@ export const useCactusLM = ({
         setDownloadProgress(0);
       }
     },
-    [cactusLM, isDownloading]
+    [cactusLM, isDownloading, isDownloaded]
   );
 
   const init = useCallback(async () => {
@@ -162,6 +169,7 @@ export const useCactusLM = ({
       options,
       tools,
       onToken,
+      mode,
     }: CactusLMCompleteParams): Promise<CactusLMCompleteResult> => {
       if (isGenerating) {
         const message = 'CactusLM is already generating';
@@ -181,6 +189,7 @@ export const useCactusLM = ({
             setCompletion((prev) => prev + token);
             onToken?.(token);
           },
+          mode,
         });
       } catch (e) {
         setError(getErrorMessage(e));
@@ -214,6 +223,30 @@ export const useCactusLM = ({
     [cactusLM, isGenerating]
   );
 
+  const imageEmbed = useCallback(
+    async ({
+      imagePath,
+    }: CactusLMImageEmbedParams): Promise<CactusLMImageEmbedResult> => {
+      if (isGenerating) {
+        const message = 'CactusLM is already generating';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsGenerating(true);
+      try {
+        return await cactusLM.imageEmbed({ imagePath });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [cactusLM, isGenerating]
+  );
+
   const stop = useCallback(async () => {
     setError(null);
     try {
@@ -226,40 +259,37 @@ export const useCactusLM = ({
 
   const reset = useCallback(async () => {
     setError(null);
-    setCompletion('');
     try {
       await cactusLM.reset();
     } catch (e) {
       setError(getErrorMessage(e));
       throw e;
+    } finally {
+      setCompletion('');
     }
   }, [cactusLM]);
 
   const destroy = useCallback(async () => {
     setError(null);
-    setCompletion('');
     try {
       await cactusLM.destroy();
     } catch (e) {
       setError(getErrorMessage(e));
       throw e;
+    } finally {
+      setCompletion('');
     }
   }, [cactusLM]);
 
-  const getModels = useCallback(
-    async ({ forceRefresh }: CactusLMGetModelsParams = {}): Promise<
-      CactusModel[]
-    > => {
-      setError(null);
-      try {
-        return await cactusLM.getModels({ forceRefresh });
-      } catch (e) {
-        setError(getErrorMessage(e));
-        throw e;
-      }
-    },
-    [cactusLM]
-  );
+  const getModels = useCallback(async (): Promise<CactusModel[]> => {
+    setError(null);
+    try {
+      return await cactusLM.getModels();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    }
+  }, [cactusLM]);
 
   return {
     completion,
@@ -274,6 +304,7 @@ export const useCactusLM = ({
     init,
     complete,
     embed,
+    imageEmbed,
     reset,
     stop,
     destroy,