cactus-react-native 1.2.1 → 1.5.0

package/src/classes/CactusLM.ts

@@ -3,18 +3,22 @@ import type {
   CactusLMDownloadParams,
   CactusLMCompleteParams,
   CactusLMCompleteResult,
+  CactusLMTokenizeParams,
+  CactusLMTokenizeResult,
+  CactusLMScoreWindowParams,
+  CactusLMScoreWindowResult,
   CactusLMEmbedParams,
   CactusLMEmbedResult,
   CactusLMImageEmbedParams,
   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();
@@ -22,45 +26,79 @@ 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({
     onProgress,
   }: CactusLMDownloadParams = {}): Promise<void> {
+    if (this.isModelPath(this.model)) {
+      onProgress?.(1.0);
+      return;
+    }
+
     if (this.isDownloading) {
       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 {
@@ -73,12 +111,19 @@ export class CactusLM {
       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.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.getModelName());
     }
 
-    const modelPath = await CactusFileSystem.getModelPath(this.model);
-
     try {
       await this.cactus.init(modelPath, this.contextSize, this.corpusDir);
       Telemetry.logInit(this.model, true);
@@ -153,8 +198,26 @@ export class CactusLM {
     }
   }
 
+  public async tokenize({
+    text,
+  }: CactusLMTokenizeParams): Promise<CactusLMTokenizeResult> {
+    return { tokens: await this.cactus.tokenize(text) };
+  }
+
+  public async scoreWindow({
+    tokens,
+    start,
+    end,
+    context,
+  }: CactusLMScoreWindowParams): Promise<CactusLMScoreWindowResult> {
+    return {
+      score: await this.cactus.scoreWindow(tokens, start, end, context),
+    };
+  }
+
   public async embed({
     text,
+    normalize = false,
   }: CactusLMEmbedParams): Promise<CactusLMEmbedResult> {
     if (this.isGenerating) {
       throw new Error('CactusLM is already generating');
@@ -166,7 +229,8 @@ export class CactusLM {
     try {
       const embedding = await this.cactus.embed(
         text,
-        CactusLM.defaultEmbedBufferSize
+        CactusLM.defaultEmbedBufferSize,
+        normalize
       );
       Telemetry.logEmbedding(this.model, true);
       return { embedding };
@@ -223,11 +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,57 +6,89 @@ 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({
     onProgress,
   }: CactusSTTDownloadParams = {}): Promise<void> {
+    if (this.isModelPath(this.model)) {
+      onProgress?.(1.0);
+      return;
+    }
+
     if (this.isDownloading) {
       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 {
@@ -69,12 +101,19 @@ 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.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 modelPath = await CactusFileSystem.getModelPath(this.model);
-
     try {
       await this.cactus.init(modelPath, this.contextSize);
       Telemetry.logInit(this.model, true);
@@ -86,7 +125,7 @@ export class CactusSTT {
   }
 
   public async transcribe({
-    audioFilePath,
+    audio,
     prompt,
     options,
     onToken,
@@ -107,7 +146,7 @@ export class CactusSTT {
     this.isGenerating = true;
     try {
       const result = await this.cactus.transcribe(
-        audioFilePath,
+        audio,
         prompt,
         responseBufferSize,
         options,
@@ -128,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> {
@@ -168,16 +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/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.1';
+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,
+  };
+};