cactus-react-native 1.2.0 → 1.4.0

package/src/classes/CactusSTT.ts

@@ -7,11 +7,11 @@ import type {
   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';
+import type { CactusSTTModel } from '../types/CactusSTTModel';
 
 export class CactusSTT {
   private readonly cactus = new Cactus();
@@ -32,8 +32,6 @@ export class CactusSTT {
   };
   private static readonly defaultEmbedBufferSize = 4096;
 
-  private static cactusModelsCache: CactusModel[] | null = null;
-
   constructor({ model, contextSize }: CactusSTTParams = {}) {
     Telemetry.init(CactusConfig.telemetryToken);
 
@@ -44,6 +42,11 @@ export class CactusSTT {
   public async download({
     onProgress,
   }: CactusSTTDownloadParams = {}): Promise<void> {
+    if (this.isModelPath(this.model)) {
+      onProgress?.(1.0);
+      return;
+    }
+
     if (this.isDownloading) {
       throw new Error('CactusSTT is already downloading');
     }
@@ -55,9 +58,10 @@ export class CactusSTT {
 
     this.isDownloading = true;
     try {
+      const model = await Database.getSTTModel(this.model);
       await CactusFileSystem.downloadModel(
         this.model,
-        `https://vlqqczxwyaodtcdmdmlw.supabase.co/storage/v1/object/public/voice-models/${this.model}.zip`,
+        model.downloadUrl,
         onProgress
       );
     } finally {
@@ -70,12 +74,16 @@ export class CactusSTT {
       return;
     }
 
-    if (!(await CactusFileSystem.modelExists(this.model))) {
-      throw new Error(`Model "${this.model}" is not downloaded`);
+    let modelPath: string;
+    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`);
+      }
+      modelPath = await CactusFileSystem.getModelPath(this.model);
     }
 
-    const modelPath = await CactusFileSystem.getModelPath(this.model);
-
     try {
       await this.cactus.init(modelPath, this.contextSize);
       Telemetry.logInit(this.model, true);
@@ -87,7 +95,7 @@ export class CactusSTT {
   }
 
   public async transcribe({
-    audioFilePath,
+    audio,
     prompt,
     options,
     onToken,
@@ -108,7 +116,7 @@ export class CactusSTT {
     this.isGenerating = true;
     try {
       const result = await this.cactus.transcribe(
-        audioFilePath,
+        audio,
         prompt,
         responseBufferSize,
         options,
@@ -174,15 +182,15 @@ export class CactusSTT {
     this.isInitialized = false;
   }
 
-  public async getModels(): Promise<CactusModel[]> {
-    if (CactusSTT.cactusModelsCache) {
-      return CactusSTT.cactusModelsCache;
-    }
-    const models = await Database.getModels();
+  public async getModels(): Promise<CactusSTTModel[]> {
+    const models = await Database.getSTTModels();
     for (const model of models) {
       model.isDownloaded = await CactusFileSystem.modelExists(model.slug);
     }
-    CactusSTT.cactusModelsCache = models;
     return models;
   }
+
+  private isModelPath(model: string): boolean {
+    return model.startsWith('file://') || model.startsWith('/');
+  }
 }

package/src/config/CactusConfig.ts

@@ -5,4 +5,7 @@ export class CactusConfig {
 
   // Hybrid mode
   public static cactusToken?: string;
+
+  // Pro features
+  public static cactusProKey?: string;
 }

package/src/constants/packageVersion.ts

@@ -1 +1 @@
-export const packageVersion = '1.2.0';
+export const packageVersion = '1.4.0';

package/src/hooks/useCactusIndex.ts

@@ -0,0 +1,195 @@
+import { useCallback, useEffect, useState } from 'react';
+import { CactusIndex } from '../classes/CactusIndex';
+import { getErrorMessage } from '../utils/error';
+import type {
+  CactusIndexParams,
+  CactusIndexAddParams,
+  CactusIndexGetParams,
+  CactusIndexGetResult,
+  CactusIndexQueryParams,
+  CactusIndexQueryResult,
+  CactusIndexDeleteParams,
+} from '../types/CactusIndex';
+
+export const useCactusIndex = ({ name, embeddingDim }: CactusIndexParams) => {
+  const [cactusIndex, setCactusIndex] = useState(
+    () => new CactusIndex(name, embeddingDim)
+  );
+
+  // State
+  const [isInitializing, setIsInitializing] = useState(false);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    setCactusIndex(new CactusIndex(name, embeddingDim));
+
+    setIsInitializing(false);
+    setIsProcessing(false);
+    setError(null);
+  }, [name, embeddingDim]);
+
+  useEffect(() => {
+    return () => {
+      cactusIndex.destroy().catch(() => {});
+    };
+  }, [cactusIndex]);
+
+  const init = useCallback(async () => {
+    if (isInitializing) {
+      const message = 'CactusIndex is already initializing';
+      setError(message);
+      throw new Error(message);
+    }
+
+    setError(null);
+    setIsInitializing(true);
+    try {
+      await cactusIndex.init();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    } finally {
+      setIsInitializing(false);
+    }
+  }, [cactusIndex, isInitializing]);
+
+  const add = useCallback(
+    async ({
+      ids,
+      documents,
+      metadatas,
+      embeddings,
+    }: CactusIndexAddParams): Promise<void> => {
+      if (isProcessing) {
+        const message = 'CactusIndex is already processing';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsProcessing(true);
+      try {
+        await cactusIndex.add({ ids, documents, metadatas, embeddings });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [cactusIndex, isProcessing]
+  );
+
+  const _delete = useCallback(
+    async ({ ids }: CactusIndexDeleteParams): Promise<void> => {
+      if (isProcessing) {
+        const message = 'CactusIndex is already processing';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsProcessing(true);
+      try {
+        await cactusIndex.delete({ ids });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [cactusIndex, isProcessing]
+  );
+
+  const get = useCallback(
+    async ({ ids }: CactusIndexGetParams): Promise<CactusIndexGetResult> => {
+      if (isProcessing) {
+        const message = 'CactusIndex is already processing';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsProcessing(true);
+      try {
+        return await cactusIndex.get({ ids });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [cactusIndex, isProcessing]
+  );
+
+  const query = useCallback(
+    async ({
+      embeddings,
+      options,
+    }: CactusIndexQueryParams): Promise<CactusIndexQueryResult> => {
+      if (isProcessing) {
+        const message = 'CactusIndex is already processing';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsProcessing(true);
+      try {
+        return await cactusIndex.query({ embeddings, options });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsProcessing(false);
+      }
+    },
+    [cactusIndex, isProcessing]
+  );
+
+  const compact = useCallback(async () => {
+    if (isProcessing) {
+      const message = 'CactusIndex is already processing';
+      setError(message);
+      throw new Error(message);
+    }
+
+    setError(null);
+    setIsProcessing(true);
+    try {
+      await cactusIndex.compact();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    } finally {
+      setIsProcessing(false);
+    }
+  }, [cactusIndex, isProcessing]);
+
+  const destroy = useCallback(async () => {
+    setError(null);
+    try {
+      await cactusIndex.destroy();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    }
+  }, [cactusIndex]);
+
+  return {
+    isInitializing,
+    isProcessing,
+    error,
+
+    init,
+    add,
+    delete: _delete,
+    get,
+    query,
+    compact,
+    destroy,
+  };
+};

package/src/hooks/useCactusLM.ts

@@ -4,12 +4,16 @@ import { CactusFileSystem } from '../native';
 import { getErrorMessage } from '../utils/error';
 import type {
   CactusLMParams,
+  CactusLMCompleteParams,
   CactusLMCompleteResult,
+  CactusLMTokenizeParams,
+  CactusLMTokenizeResult,
+  CactusLMScoreWindowParams,
+  CactusLMScoreWindowResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
   CactusLMImageEmbedParams,
   CactusLMImageEmbedResult,
-  CactusLMCompleteParams,
   CactusLMDownloadParams,
 } from '../types/CactusLM';
 import type { CactusModel } from '../types/CactusModel';
@@ -201,8 +205,62 @@ export const useCactusLM = ({
     [cactusLM, isGenerating]
   );
 
+  const tokenize = useCallback(
+    async ({
+      text,
+    }: CactusLMTokenizeParams): Promise<CactusLMTokenizeResult> => {
+      if (isGenerating) {
+        const message = 'CactusLM is already generating';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsGenerating(true);
+      try {
+        return await cactusLM.tokenize({ text });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [cactusLM, isGenerating]
+  );
+
+  const scoreWindow = useCallback(
+    async ({
+      tokens,
+      start,
+      end,
+      context,
+    }: CactusLMScoreWindowParams): Promise<CactusLMScoreWindowResult> => {
+      if (isGenerating) {
+        const message = 'CactusLM is already generating';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+      setIsGenerating(true);
+      try {
+        return await cactusLM.scoreWindow({ tokens, start, end, context });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [cactusLM, isGenerating]
+  );
+
   const embed = useCallback(
-    async ({ text }: CactusLMEmbedParams): Promise<CactusLMEmbedResult> => {
+    async ({
+      text,
+      normalize = false,
+    }: CactusLMEmbedParams): Promise<CactusLMEmbedResult> => {
       if (isGenerating) {
         const message = 'CactusLM is already generating';
         setError(message);
@@ -212,7 +270,7 @@ export const useCactusLM = ({
       setError(null);
       setIsGenerating(true);
       try {
-        return await cactusLM.embed({ text });
+        return await cactusLM.embed({ text, normalize });
       } catch (e) {
         setError(getErrorMessage(e));
         throw e;
@@ -303,6 +361,8 @@ export const useCactusLM = ({
     download,
     init,
     complete,
+    tokenize,
+    scoreWindow,
     embed,
     imageEmbed,
     reset,

package/src/hooks/useCactusSTT.ts

@@ -10,7 +10,7 @@ import type {
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
 } from '../types/CactusSTT';
-import type { CactusModel } from '../types/CactusModel';
+import type { CactusSTTModel } from '../types/CactusSTTModel';
 
 export const useCactusSTT = ({
   model = 'whisper-small',
@@ -162,7 +162,7 @@ export const useCactusSTT = ({
 
   const transcribe = useCallback(
     async ({
-      audioFilePath,
+      audio,
       prompt,
       options,
       onToken,
@@ -178,7 +178,7 @@ export const useCactusSTT = ({
       setIsGenerating(true);
       try {
         return await cactusSTT.transcribe({
-          audioFilePath,
+          audio,
           prompt,
           options,
           onToken: (token) => {
@@ -254,7 +254,7 @@ export const useCactusSTT = ({
     }
   }, [cactusSTT]);
 
-  const getModels = useCallback(async (): Promise<CactusModel[]> => {
+  const getModels = useCallback(async (): Promise<CactusSTTModel[]> => {
     setError(null);
     try {
       return await cactusSTT.getModels();

package/src/index.tsx

@@ -1,13 +1,16 @@
 // Classes
 export { CactusLM } from './classes/CactusLM';
 export { CactusSTT } from './classes/CactusSTT';
+export { CactusIndex } from './classes/CactusIndex';
 
 // Hooks
 export { useCactusLM } from './hooks/useCactusLM';
 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 {
   CactusLMParams,
   CactusLMDownloadParams,
@@ -16,6 +19,10 @@ export type {
   Tool,
   CactusLMCompleteParams,
   CactusLMCompleteResult,
+  CactusLMTokenizeParams,
+  CactusLMTokenizeResult,
+  CactusLMScoreWindowParams,
+  CactusLMScoreWindowResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
   CactusLMImageEmbedParams,
@@ -30,6 +37,16 @@ export type {
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
 } from './types/CactusSTT';
+export type {
+  CactusIndexParams,
+  CactusIndexAddParams,
+  CactusIndexGetParams,
+  CactusIndexGetResult,
+  IndexQueryOptions,
+  CactusIndexQueryParams,
+  CactusIndexQueryResult,
+  CactusIndexDeleteParams,
+} from './types/CactusIndex';
 
 // Config
 export { CactusConfig } from './config/CactusConfig';

package/src/native/Cactus.ts

@@ -37,6 +37,7 @@ export class Cactus {
         messagesInternal.push(message);
         continue;
       }
+
       const resizedImages: string[] = [];
       for (const imagePath of message.images) {
         const resizedImage = await CactusImage.resize(
@@ -47,6 +48,7 @@ export class Cactus {
         );
         resizedImages.push(resizedImage);
       }
+
       messagesInternal.push({ ...message, images: resizedImages });
     }
 
@@ -58,6 +60,7 @@ export class Cactus {
           top_k: options.topK,
           max_tokens: options.maxTokens,
           stop_sequences: options.stopSequences,
+          force_tools: options.forceTools,
         })
       : undefined;
     const toolsJson = JSON.stringify(tools);
@@ -89,13 +92,41 @@ export class Cactus {
     }
   }
 
+  public tokenize(text: string): Promise<number[]> {
+    return this.hybridCactus.tokenize(text);
+  }
+
+  public async scoreWindow(
+    tokens: number[],
+    start: number,
+    end: number,
+    context: number
+  ): Promise<number> {
+    const response = await this.hybridCactus.scoreWindow(
+      tokens,
+      start,
+      end,
+      context
+    );
+    try {
+      const parsed = JSON.parse(response);
+      return parsed.logprob;
+    } catch {
+      throw new Error('Unable to parse score window response');
+    }
+  }
+
   public async transcribe(
-    audioFilePath: string,
+    audio: string | number[],
     prompt: string,
     responseBufferSize: number,
     options?: TranscribeOptions,
     callback?: (token: string, tokenId: number) => void
   ): Promise<CactusSTTTranscribeResult> {
+    if (typeof audio === 'string') {
+      audio = audio.replace('file://', '');
+    }
+
     const optionsJson = options
       ? JSON.stringify({
           temperature: options.temperature,
@@ -107,7 +138,7 @@ export class Cactus {
       : undefined;
 
     const response = await this.hybridCactus.transcribe(
-      audioFilePath.replace('file://', ''),
+      audio,
       prompt,
       responseBufferSize,
       optionsJson,
@@ -132,8 +163,12 @@ export class Cactus {
     }
   }
 
-  public embed(text: string, embeddingBufferSize: number): Promise<number[]> {
-    return this.hybridCactus.embed(text, embeddingBufferSize);
+  public embed(
+    text: string,
+    embeddingBufferSize: number,
+    normalize: boolean
+  ): Promise<number[]> {
+    return this.hybridCactus.embed(text, embeddingBufferSize, normalize);
   }
 
   public async imageEmbed(

package/src/native/CactusFileSystem.ts

@@ -33,6 +33,10 @@ export class CactusFileSystem {
     return this.hybridCactusFileSystem.getModelPath(model);
   }
 
+  public static getIndexPath(name: string): Promise<string> {
+    return this.hybridCactusFileSystem.getIndexPath(name);
+  }
+
   public static downloadModel(
     model: string,
     url: string,

package/src/native/CactusIndex.ts

@@ -0,0 +1,54 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { CactusIndex as CactusIndexSpec } from '../specs/CactusIndex.nitro';
+import type {
+  CactusIndexGetResult,
+  CactusIndexQueryResult,
+  IndexQueryOptions,
+} from '../types/CactusIndex';
+
+export class CactusIndex {
+  private readonly hybridCactusIndex =
+    NitroModules.createHybridObject<CactusIndexSpec>('CactusIndex');
+
+  public init(indexPath: string, embeddingDim: number): Promise<void> {
+    return this.hybridCactusIndex.init(indexPath, embeddingDim);
+  }
+
+  public add(
+    ids: number[],
+    documents: string[],
+    embeddings: number[][],
+    metadatas?: string[]
+  ): Promise<void> {
+    return this.hybridCactusIndex.add(ids, documents, embeddings, metadatas);
+  }
+
+  public delete(ids: number[]): Promise<void> {
+    return this.hybridCactusIndex._delete(ids);
+  }
+
+  public get(ids: number[]): Promise<CactusIndexGetResult> {
+    return this.hybridCactusIndex.get(ids);
+  }
+
+  public query(
+    embeddings: number[][],
+    options?: IndexQueryOptions
+  ): Promise<CactusIndexQueryResult> {
+    const optionsJson = options
+      ? JSON.stringify({
+          top_k: options.topK,
+          score_threshold: options.scoreThreshold,
+        })
+      : undefined;
+    return this.hybridCactusIndex.query(embeddings, optionsJson);
+  }
+
+  public compact(): Promise<void> {
+    return this.hybridCactusIndex.compact();
+  }
+
+  public destroy(): Promise<void> {
+    return this.hybridCactusIndex.destroy();
+  }
+}

package/src/native/CactusUtil.ts

@@ -2,6 +2,8 @@ import { NitroModules } from 'react-native-nitro-modules';
 import type { CactusUtil as CactusUtilSpec } from '../specs/CactusUtil.nitro';
 import { Platform } from 'react-native';
 import { CactusFileSystem } from './CactusFileSystem';
+import { CactusConfig } from '../config/CactusConfig';
+import { Database } from '../api/Database';
 
 export class CactusUtil {
   private static readonly hybridCactusUtil =
@@ -10,7 +12,7 @@ export class CactusUtil {
   public static async registerApp(encryptedData: string): Promise<string> {
     if (Platform.OS === 'android') {
       const cactusDirectory = await CactusFileSystem.getCactusDirectory();
-      this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
+      await this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
     }
 
     return this.hybridCactusUtil.registerApp(encryptedData);
@@ -19,9 +21,23 @@ export class CactusUtil {
   public static async getDeviceId(): Promise<string | null> {
     if (Platform.OS === 'android') {
       const cactusDirectory = await CactusFileSystem.getCactusDirectory();
-      this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
+      await this.hybridCactusUtil.setAndroidDataDirectory(cactusDirectory);
     }
 
-    return this.hybridCactusUtil.getDeviceId();
+    const deviceId = await this.hybridCactusUtil.getDeviceId(
+      CactusConfig.cactusProKey
+    );
+
+    if (!deviceId) {
+      return null;
+    }
+
+    if (deviceId?.indexOf('|') !== -1) {
+      const parts = deviceId.split('|');
+      CactusConfig.cactusProKey = parts[1];
+      return await Database.registerDevice({ deviceId: parts[0] });
+    }
+
+    return deviceId;
   }
 }

package/src/native/index.ts

@@ -1,4 +1,5 @@
 export { Cactus } from './Cactus';
+export { CactusIndex } from './CactusIndex';
 export { CactusCrypto } from './CactusCrypto';
 export { CactusDeviceInfo } from './CactusDeviceInfo';
 export { CactusFileSystem } from './CactusFileSystem';