cactus-react-native 1.5.0 → 1.7.0

package/src/hooks/useCactusVAD.ts

@@ -0,0 +1,215 @@
+import { useCallback, useEffect, useState, useRef } from 'react';
+import { CactusVAD } from '../classes/CactusVAD';
+import { CactusFileSystem } from '../native';
+import { getErrorMessage } from '../utils/error';
+import type {
+  CactusVADParams,
+  CactusVADDownloadParams,
+  CactusVADVadParams,
+  CactusVADResult,
+} from '../types/CactusVAD';
+import type { CactusModel } from '../types/common';
+
+export const useCactusVAD = ({
+  model = 'silero-vad',
+  options: modelOptions = {
+    quantization: undefined,
+    pro: false,
+  },
+}: CactusVADParams = {}) => {
+  const [cactusVAD, setCactusVAD] = useState(
+    () => new CactusVAD({ model, options: modelOptions })
+  );
+
+  const [isInitializing, setIsInitializing] = useState(false);
+  const [isDownloaded, setIsDownloaded] = useState(false);
+  const [isDownloading, setIsDownloading] = useState(false);
+  const [downloadProgress, setDownloadProgress] = useState(0);
+  const [error, setError] = useState<string | null>(null);
+
+  const currentModelRef = useRef(model);
+  const currentDownloadIdRef = useRef(0);
+
+  useEffect(() => {
+    currentModelRef.current = model;
+  }, [model]);
+
+  useEffect(() => {
+    const newInstance = new CactusVAD({
+      model,
+      options: {
+        quantization: modelOptions.quantization,
+        pro: modelOptions.pro,
+      },
+    });
+    setCactusVAD(newInstance);
+
+    setIsInitializing(false);
+    setIsDownloaded(false);
+    setIsDownloading(false);
+    setDownloadProgress(0);
+    setError(null);
+
+    let mounted = true;
+    CactusFileSystem.modelExists(newInstance.getModelName())
+      .then((exists) => {
+        if (!mounted) {
+          return;
+        }
+        setIsDownloaded(exists);
+      })
+      .catch((e) => {
+        if (!mounted) {
+          return;
+        }
+        setIsDownloaded(false);
+        setError(getErrorMessage(e));
+      });
+
+    return () => {
+      mounted = false;
+    };
+  }, [model, modelOptions.quantization, modelOptions.pro]);
+
+  useEffect(() => {
+    return () => {
+      cactusVAD.destroy().catch(() => {});
+    };
+  }, [cactusVAD]);
+
+  const download = useCallback(
+    async ({ onProgress }: CactusVADDownloadParams = {}) => {
+      if (isDownloading) {
+        const message = 'CactusVAD is already downloading';
+        setError(message);
+        throw new Error(message);
+      }
+
+      setError(null);
+
+      if (isDownloaded) {
+        return;
+      }
+
+      const thisModel = currentModelRef.current;
+      const thisDownloadId = ++currentDownloadIdRef.current;
+
+      setDownloadProgress(0);
+      setIsDownloading(true);
+      try {
+        await cactusVAD.download({
+          onProgress: (progress) => {
+            if (
+              currentModelRef.current !== thisModel ||
+              currentDownloadIdRef.current !== thisDownloadId
+            ) {
+              return;
+            }
+
+            setDownloadProgress(progress);
+            onProgress?.(progress);
+          },
+        });
+
+        if (
+          currentModelRef.current !== thisModel ||
+          currentDownloadIdRef.current !== thisDownloadId
+        ) {
+          return;
+        }
+
+        setIsDownloaded(true);
+      } catch (e) {
+        if (
+          currentModelRef.current !== thisModel ||
+          currentDownloadIdRef.current !== thisDownloadId
+        ) {
+          return;
+        }
+
+        setError(getErrorMessage(e));
+        throw e;
+      } finally {
+        if (
+          currentModelRef.current !== thisModel ||
+          currentDownloadIdRef.current !== thisDownloadId
+        ) {
+          return;
+        }
+
+        setIsDownloading(false);
+        setDownloadProgress(0);
+      }
+    },
+    [cactusVAD, isDownloading, isDownloaded]
+  );
+
+  const init = useCallback(async () => {
+    if (isInitializing) {
+      const message = 'CactusVAD is already initializing';
+      setError(message);
+      throw new Error(message);
+    }
+
+    setError(null);
+    setIsInitializing(true);
+    try {
+      await cactusVAD.init();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    } finally {
+      setIsInitializing(false);
+    }
+  }, [cactusVAD, isInitializing]);
+
+  const vad = useCallback(
+    async ({
+      audio,
+      options,
+    }: CactusVADVadParams): Promise<CactusVADResult> => {
+      setError(null);
+      try {
+        return await cactusVAD.vad({ audio, options });
+      } catch (e) {
+        setError(getErrorMessage(e));
+        throw e;
+      }
+    },
+    [cactusVAD]
+  );
+
+  const destroy = useCallback(async () => {
+    setError(null);
+    try {
+      await cactusVAD.destroy();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    }
+  }, [cactusVAD]);
+
+  const getModels = useCallback(async (): Promise<CactusModel[]> => {
+    setError(null);
+    try {
+      return await cactusVAD.getModels();
+    } catch (e) {
+      setError(getErrorMessage(e));
+      throw e;
+    }
+  }, [cactusVAD]);
+
+  return {
+    isInitializing,
+    isDownloaded,
+    isDownloading,
+    downloadProgress,
+    error,
+
+    download,
+    init,
+    vad,
+    destroy,
+    getModels,
+  };
+};

package/src/index.tsx

@@ -1,21 +1,23 @@
 // Classes
 export { CactusLM } from './classes/CactusLM';
 export { CactusSTT } from './classes/CactusSTT';
+export { CactusVAD } from './classes/CactusVAD';
 export { CactusIndex } from './classes/CactusIndex';
 
 // Hooks
 export { useCactusLM } from './hooks/useCactusLM';
 export { useCactusSTT } from './hooks/useCactusSTT';
+export { useCactusVAD } from './hooks/useCactusVAD';
 export { useCactusIndex } from './hooks/useCactusIndex';
 
 // Types
-export type { CactusModel, ModelOptions } from './types/common';
+export type { CactusModel, CactusModelOptions } from './types/common';
 export type {
   CactusLMParams,
   CactusLMDownloadParams,
-  Message,
-  CompleteOptions,
-  Tool,
+  CactusLMMessage,
+  CactusLMCompleteOptions,
+  CactusLMTool,
   CactusLMCompleteParams,
   CactusLMCompleteResult,
   CactusLMTokenizeParams,
@@ -30,27 +32,31 @@ export type {
 export type {
   CactusSTTParams,
   CactusSTTDownloadParams,
-  TranscribeOptions,
+  CactusSTTTranscribeOptions,
   CactusSTTTranscribeParams,
   CactusSTTTranscribeResult,
   CactusSTTAudioEmbedParams,
   CactusSTTAudioEmbedResult,
-  CactusSTTStreamTranscribeInsertParams,
-  StreamTranscribeProcessOptions,
+  CactusSTTStreamTranscribeStartOptions,
   CactusSTTStreamTranscribeProcessParams,
   CactusSTTStreamTranscribeProcessResult,
-  CactusSTTStreamTranscribeFinalizeResult,
+  CactusSTTStreamTranscribeStopResult,
 } from './types/CactusSTT';
+export type {
+  CactusVADParams,
+  CactusVADDownloadParams,
+  CactusVADVadParams,
+  CactusVADOptions,
+  CactusVADSegment,
+  CactusVADResult,
+} from './types/CactusVAD';
 export type {
   CactusIndexParams,
   CactusIndexAddParams,
   CactusIndexGetParams,
   CactusIndexGetResult,
-  IndexQueryOptions,
+  CactusIndexQueryOptions,
   CactusIndexQueryParams,
   CactusIndexQueryResult,
   CactusIndexDeleteParams,
 } from './types/CactusIndex';
-
-// Config
-export { CactusConfig } from './config/CactusConfig';

package/src/modelRegistry.ts

@@ -0,0 +1,65 @@
+import type { CactusModel } from './types/common';
+
+const VERSION = 'v1.7';
+
+let registryPromise: Promise<{ [key: string]: CactusModel }> | null = null;
+
+export function getRegistry(): Promise<{ [key: string]: CactusModel }> {
+  return (registryPromise ??= fetchRegistry());
+}
+
+async function fetchRegistry(): Promise<{ [key: string]: CactusModel }> {
+  const response = await fetch(
+    'https://huggingface.co/api/models?author=Cactus-Compute&full=true'
+  ).catch((e) => {
+    registryPromise = null;
+    throw e;
+  });
+  if (!response.ok) {
+    registryPromise = null;
+    throw new Error(`Failed to fetch model registry: ${response.status}`);
+  }
+
+  const models: any[] = await response.json();
+  const registry: { [key: string]: CactusModel } = {};
+
+  for (const { id, siblings = [] } of models) {
+    const weights: string[] = siblings
+      .map((s: any) => s.rfilename)
+      .filter((f: string) => f.startsWith('weights/') && f.endsWith('.zip'));
+
+    if (
+      !weights.some((f) => f.endsWith('-int4.zip')) ||
+      !weights.some((f) => f.endsWith('-int8.zip'))
+    )
+      continue;
+
+    const key = weights
+      .find((f) => f.endsWith('-int4.zip'))!
+      .replace('weights/', '')
+      .replace('-int4.zip', '');
+
+    const base = `https://huggingface.co/${id}/resolve/${VERSION}/weights/${key}`;
+
+    registry[key] = {
+      quantization: {
+        int4: {
+          sizeMb: 0,
+          url: `${base}-int4.zip`,
+          ...(weights.some((f) => f.endsWith('-int4-apple.zip'))
+            ? { pro: { apple: `${base}-int4-apple.zip` } }
+            : {}),
+        },
+        int8: {
+          sizeMb: 0,
+          url: `${base}-int8.zip`,
+          ...(weights.some((f) => f.endsWith('-int8-apple.zip'))
+            ? { pro: { apple: `${base}-int8-apple.zip` } }
+            : {}),
+        },
+      },
+    };
+  }
+
+  return registry;
+}

package/src/native/Cactus.ts

@@ -3,17 +3,18 @@ import type { Cactus as CactusSpec } from '../specs/Cactus.nitro';
 import { CactusImage } from './CactusImage';
 import type {
   CactusLMCompleteResult,
-  Message,
-  CompleteOptions,
-  Tool,
+  CactusLMMessage,
+  CactusLMCompleteOptions,
+  CactusLMTool,
 } from '../types/CactusLM';
 import type {
   CactusSTTTranscribeResult,
-  TranscribeOptions,
+  CactusSTTTranscribeOptions,
+  CactusSTTStreamTranscribeStartOptions,
   CactusSTTStreamTranscribeProcessResult,
-  StreamTranscribeProcessOptions,
-  CactusSTTStreamTranscribeFinalizeResult,
+  CactusSTTStreamTranscribeStopResult,
 } from '../types/CactusSTT';
+import type { CactusVADOptions, CactusVADResult } from '../types/CactusVAD';
 
 export class Cactus {
   private readonly hybridCactus =
@@ -21,20 +22,20 @@ export class Cactus {
 
   public init(
     modelPath: string,
-    contextSize: number,
-    corpusDir?: string
+    corpusDir?: string,
+    cacheIndex?: boolean
   ): Promise<void> {
-    return this.hybridCactus.init(modelPath, contextSize, corpusDir);
+    return this.hybridCactus.init(modelPath, corpusDir, cacheIndex ?? false);
   }
 
   public async complete(
-    messages: Message[],
+    messages: CactusLMMessage[],
     responseBufferSize: number,
-    options?: CompleteOptions,
-    tools?: { type: 'function'; function: Tool }[],
+    options?: CactusLMCompleteOptions,
+    tools?: { type: 'function'; function: CactusLMTool }[],
     callback?: (token: string, tokenId: number) => void
   ): Promise<CactusLMCompleteResult> {
-    const messagesInternal: Message[] = [];
+    const messagesInternal: CactusLMMessage[] = [];
     for (const message of messages) {
       if (!message.images) {
         messagesInternal.push(message);
@@ -64,6 +65,11 @@ export class Cactus {
           max_tokens: options.maxTokens,
           stop_sequences: options.stopSequences,
           force_tools: options.forceTools,
+          telemetry_enabled: options.telemetryEnabled,
+          confidence_threshold: options.confidenceThreshold,
+          tool_rag_top_k: options.toolRagTopK,
+          include_stop_sequences: options.includeStopSequences,
+          use_vad: options.useVad,
         })
       : undefined;
     const toolsJson = JSON.stringify(tools);
@@ -83,12 +89,16 @@ export class Cactus {
         success: parsed.success,
         response: parsed.response,
         functionCalls: parsed.function_calls,
+        cloudHandoff: parsed.cloud_handoff,
+        confidence: parsed.confidence,
         timeToFirstTokenMs: parsed.time_to_first_token_ms,
         totalTimeMs: parsed.total_time_ms,
-        tokensPerSecond: parsed.tokens_per_second,
         prefillTokens: parsed.prefill_tokens,
+        prefillTps: parsed.prefill_tps,
         decodeTokens: parsed.decode_tokens,
+        decodeTps: parsed.decode_tps,
         totalTokens: parsed.total_tokens,
+        ramUsageMb: parsed.ram_usage_mb,
       };
     } catch {
       throw new Error('Unable to parse completion response');
@@ -123,7 +133,7 @@ export class Cactus {
     audio: string | number[],
     prompt: string,
     responseBufferSize: number,
-    options?: TranscribeOptions,
+    options?: CactusSTTTranscribeOptions,
     callback?: (token: string, tokenId: number) => void
   ): Promise<CactusSTTTranscribeResult> {
     if (typeof audio === 'string') {
@@ -137,6 +147,11 @@ export class Cactus {
           top_k: options.topK,
           max_tokens: options.maxTokens,
           stop_sequences: options.stopSequences,
+          use_vad: options.useVad,
+          telemetry_enabled: options.telemetryEnabled,
+          confidence_threshold: options.confidenceThreshold,
+          cloud_handoff_threshold: options.cloudHandoffThreshold,
+          include_stop_sequences: options.includeStopSequences,
         })
       : undefined;
 
@@ -154,70 +169,112 @@ export class Cactus {
       return {
         success: parsed.success,
         response: parsed.response,
+        cloudHandoff: parsed.cloud_handoff,
+        confidence: parsed.confidence,
         timeToFirstTokenMs: parsed.time_to_first_token_ms,
         totalTimeMs: parsed.total_time_ms,
-        tokensPerSecond: parsed.tokens_per_second,
         prefillTokens: parsed.prefill_tokens,
+        prefillTps: parsed.prefill_tps,
         decodeTokens: parsed.decode_tokens,
+        decodeTps: parsed.decode_tps,
         totalTokens: parsed.total_tokens,
+        ramUsageMb: parsed.ram_usage_mb,
       };
     } catch {
       throw new Error('Unable to parse transcription response');
     }
   }
 
-  public streamTranscribeInit(): Promise<void> {
-    return this.hybridCactus.streamTranscribeInit();
-  }
-
-  public streamTranscribeInsert(audio: number[]): Promise<void> {
-    return this.hybridCactus.streamTranscribeInsert(audio);
-  }
-
-  public async streamTranscribeProcess(
-    options?: StreamTranscribeProcessOptions
-  ): Promise<CactusSTTStreamTranscribeProcessResult> {
+  public streamTranscribeStart(
+    options?: CactusSTTStreamTranscribeStartOptions
+  ): Promise<void> {
     const optionsJson = options
       ? JSON.stringify({
           confirmation_threshold: options.confirmationThreshold,
+          min_chunk_size: options.minChunkSize,
+          telemetry_enabled: options.telemetryEnabled,
         })
       : undefined;
+    return this.hybridCactus.streamTranscribeStart(optionsJson);
+  }
 
-    const response =
-      await this.hybridCactus.streamTranscribeProcess(optionsJson);
-
+  public async streamTranscribeProcess(
+    audio: number[]
+  ): Promise<CactusSTTStreamTranscribeProcessResult> {
+    const response = await this.hybridCactus.streamTranscribeProcess(audio);
     try {
       const parsed = JSON.parse(response);
-
       return {
         success: parsed.success,
         confirmed: parsed.confirmed,
         pending: parsed.pending,
+        bufferDurationMs: parsed.buffer_duration_ms,
+        confidence: parsed.confidence,
+        cloudHandoff: parsed.cloud_handoff,
+        cloudResult: parsed.cloud_result,
+        cloudJobId: parsed.cloud_job_id,
+        cloudResultJobId: parsed.cloud_result_job_id,
+        timeToFirstTokenMs: parsed.time_to_first_token_ms,
+        totalTimeMs: parsed.total_time_ms,
+        prefillTokens: parsed.prefill_tokens,
+        prefillTps: parsed.prefill_tps,
+        decodeTokens: parsed.decode_tokens,
+        decodeTps: parsed.decode_tps,
+        totalTokens: parsed.total_tokens,
+        ramUsageMb: parsed.ram_usage_mb,
       };
     } catch {
       throw new Error('Unable to parse stream transcribe process response');
     }
   }
 
-  public async streamTranscribeFinalize(): Promise<CactusSTTStreamTranscribeFinalizeResult> {
-    const response = await this.hybridCactus.streamTranscribeFinalize();
-
+  public async streamTranscribeStop(): Promise<CactusSTTStreamTranscribeStopResult> {
+    const response = await this.hybridCactus.streamTranscribeStop();
     try {
       const parsed = JSON.parse(response);
+      return { success: parsed.success, confirmed: parsed.confirmed };
+    } catch {
+      throw new Error('Unable to parse stream transcribe stop response');
+    }
+  }
 
+  public async vad(
+    audio: string | number[],
+    options?: CactusVADOptions
+  ): Promise<CactusVADResult> {
+    if (typeof audio === 'string') {
+      audio = audio.replace('file://', '');
+    }
+    const optionsJson = options
+      ? JSON.stringify({
+          threshold: options.threshold,
+          neg_threshold: options.negThreshold,
+          min_speech_duration_ms: options.minSpeechDurationMs,
+          max_speech_duration_s: options.maxSpeechDurationS,
+          min_silence_duration_ms: options.minSilenceDurationMs,
+          speech_pad_ms: options.speechPadMs,
+          window_size_samples: options.windowSizeSamples,
+          sampling_rate: options.samplingRate,
+          min_silence_at_max_speech: options.minSilenceAtMaxSpeech,
+          use_max_poss_sil_at_max_speech: options.useMaxPossSilAtMaxSpeech,
+        })
+      : undefined;
+    const response = await this.hybridCactus.vad(audio, 65536, optionsJson);
+    try {
+      const parsed = JSON.parse(response);
       return {
-        success: parsed.success,
-        confirmed: parsed.confirmed,
+        segments: parsed.segments.map((s: { start: number; end: number }) => ({
+          start: s.start,
+          end: s.end,
+        })),
+        totalTime: parsed.total_time_ms,
+        ramUsage: parsed.ram_usage_mb,
       };
     } catch {
-      throw new Error('Unable to parse stream transcribe finalize response');
+      throw new Error('Unable to parse VAD response');
     }
   }
 
-  public streamTranscribeDestroy(): Promise<void> {
-    return this.hybridCactus.streamTranscribeDestroy();
-  }
-
   public embed(
     text: string,
     embeddingBufferSize: number,
@@ -260,4 +317,8 @@ export class Cactus {
   public destroy(): Promise<void> {
     return this.hybridCactus.destroy();
   }
+
+  public setTelemetryEnvironment(cacheDir: string): Promise<void> {
+    return this.hybridCactus.setTelemetryEnvironment(cacheDir);
+  }
 }

package/src/native/CactusIndex.ts

@@ -3,7 +3,7 @@ import type { CactusIndex as CactusIndexSpec } from '../specs/CactusIndex.nitro'
 import type {
   CactusIndexGetResult,
   CactusIndexQueryResult,
-  IndexQueryOptions,
+  CactusIndexQueryOptions,
 } from '../types/CactusIndex';
 
 export class CactusIndex {
@@ -33,7 +33,7 @@ export class CactusIndex {
 
   public query(
     embeddings: number[][],
-    options?: IndexQueryOptions
+    options?: CactusIndexQueryOptions
   ): Promise<CactusIndexQueryResult> {
     const optionsJson = options
       ? JSON.stringify({

package/src/native/index.ts

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

package/src/specs/Cactus.nitro.ts

@@ -3,8 +3,8 @@ import type { HybridObject } from 'react-native-nitro-modules';
 export interface Cactus extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   init(
     modelPath: string,
-    contextSize: number,
-    corpusDir?: string
+    corpusDir?: string,
+    cacheIndex?: boolean
   ): Promise<void>;
   complete(
     messagesJson: string,
@@ -27,11 +27,14 @@ export interface Cactus extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
     optionsJson?: string,
     callback?: (token: string, tokenId: number) => void
   ): Promise<string>;
-  streamTranscribeInit(): Promise<void>;
-  streamTranscribeInsert(audio: number[]): Promise<void>;
-  streamTranscribeProcess(optionsJson?: string): Promise<string>;
-  streamTranscribeFinalize(): Promise<string>;
-  streamTranscribeDestroy(): Promise<void>;
+  streamTranscribeStart(optionsJson?: string): Promise<void>;
+  streamTranscribeProcess(audio: number[]): Promise<string>;
+  streamTranscribeStop(): Promise<string>;
+  vad(
+    audio: string | number[],
+    responseBufferSize: number,
+    optionsJson?: string
+  ): Promise<string>;
   embed(
     text: string,
     embeddingBufferSize: number,
@@ -42,4 +45,5 @@ export interface Cactus extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   reset(): Promise<void>;
   stop(): Promise<void>;
   destroy(): Promise<void>;
+  setTelemetryEnvironment(cacheDir: string): Promise<void>;
 }

package/src/types/CactusIndex.ts

@@ -20,14 +20,14 @@ export interface CactusIndexGetResult {
   embeddings: number[][];
 }
 
-export interface IndexQueryOptions {
+export interface CactusIndexQueryOptions {
   topK?: number;
   scoreThreshold?: number;
 }
 
 export interface CactusIndexQueryParams {
   embeddings: number[][];
-  options?: IndexQueryOptions;
+  options?: CactusIndexQueryOptions;
 }
 
 export interface CactusIndexQueryResult {