cactus-react-native 1.5.0 → 1.10.0

package/src/native/Cactus.ts

@@ -3,17 +3,20 @@ 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,
+  CactusSTTDetectLanguageOptions,
+  CactusSTTDetectLanguageResult,
 } from '../types/CactusSTT';
+import type { CactusVADOptions, CactusVADResult } from '../types/CactusVAD';
 
 export class Cactus {
   private readonly hybridCactus =
@@ -21,20 +24,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 +67,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 +91,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 +135,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 +149,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,68 +171,140 @@ 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 detectLanguage(
+    audio: string | number[],
+    options?: CactusSTTDetectLanguageOptions
+  ): Promise<CactusSTTDetectLanguageResult> {
+    if (typeof audio === 'string') {
+      audio = audio.replace('file://', '');
+    }
+
+    const optionsJson = options
+      ? JSON.stringify({ use_vad: options.useVad })
+      : undefined;
+
+    const response = await this.hybridCactus.detectLanguage(
+      audio,
+      1024,
+      optionsJson
+    );
 
     try {
       const parsed = JSON.parse(response);
 
       return {
-        success: parsed.success,
-        confirmed: parsed.confirmed,
+        language: parsed.language,
+        confidence: parsed.confidence,
       };
     } catch {
-      throw new Error('Unable to parse stream transcribe finalize response');
+      throw new Error('Unable to parse detect language response');
     }
   }
 
-  public streamTranscribeDestroy(): Promise<void> {
-    return this.hybridCactus.streamTranscribeDestroy();
+  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 {
+        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 VAD response');
+    }
   }
 
   public embed(
@@ -260,4 +349,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,19 @@ 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>;
+  detectLanguage(
+    audio: string | number[],
+    responseBufferSize: number,
+    optionsJson?: string
+  ): Promise<string>;
+  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 +50,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 {

package/src/types/CactusLM.ts

@@ -1,32 +1,37 @@
-import { type ModelOptions } from './common';
+import { type CactusModelOptions } from './common';
 
 export interface CactusLMParams {
   model?: string;
-  contextSize?: number;
   corpusDir?: string;
-  options?: ModelOptions;
+  cacheIndex?: boolean;
+  options?: CactusModelOptions;
 }
 
 export interface CactusLMDownloadParams {
   onProgress?: (progress: number) => void;
 }
 
-export interface Message {
+export interface CactusLMMessage {
   role: 'user' | 'assistant' | 'system';
   content?: string;
   images?: string[];
 }
 
-export interface CompleteOptions {
+export interface CactusLMCompleteOptions {
   temperature?: number;
   topP?: number;
   topK?: number;
   maxTokens?: number;
   stopSequences?: string[];
   forceTools?: boolean;
+  telemetryEnabled?: boolean;
+  confidenceThreshold?: number;
+  toolRagTopK?: number;
+  includeStopSequences?: boolean;
+  useVad?: boolean;
 }
 
-export interface Tool {
+export interface CactusLMTool {
   name: string;
   description: string;
   parameters: {
@@ -42,11 +47,10 @@ export interface Tool {
 }
 
 export interface CactusLMCompleteParams {
-  messages: Message[];
-  options?: CompleteOptions;
-  tools?: Tool[];
+  messages: CactusLMMessage[];
+  options?: CactusLMCompleteOptions;
+  tools?: CactusLMTool[];
   onToken?: (token: string) => void;
-  mode?: 'local' | 'hybrid';
 }
 
 export interface CactusLMCompleteResult {
@@ -56,12 +60,16 @@ export interface CactusLMCompleteResult {
     name: string;
     arguments: { [key: string]: any };
   }[];
+  cloudHandoff?: boolean;
+  confidence?: number;
   timeToFirstTokenMs: number;
   totalTimeMs: number;
-  tokensPerSecond: number;
   prefillTokens: number;
+  prefillTps: number;
   decodeTokens: number;
+  decodeTps: number;
   totalTokens: number;
+  ramUsageMb?: number;
 }
 
 export interface CactusLMTokenizeParams {

package/src/types/CactusSTT.ts

@@ -1,39 +1,47 @@
-import { type ModelOptions } from './common';
+import { type CactusModelOptions } from './common';
 
 export interface CactusSTTParams {
   model?: string;
-  contextSize?: number;
-  options?: ModelOptions;
+  options?: CactusModelOptions;
 }
 
 export interface CactusSTTDownloadParams {
   onProgress?: (progress: number) => void;
 }
 
-export interface TranscribeOptions {
+export interface CactusSTTTranscribeOptions {
   temperature?: number;
   topP?: number;
   topK?: number;
   maxTokens?: number;
   stopSequences?: string[];
+  useVad?: boolean;
+  telemetryEnabled?: boolean;
+  confidenceThreshold?: number;
+  cloudHandoffThreshold?: number;
+  includeStopSequences?: boolean;
 }
 
 export interface CactusSTTTranscribeParams {
   audio: string | number[];
   prompt?: string;
-  options?: TranscribeOptions;
+  options?: CactusSTTTranscribeOptions;
   onToken?: (token: string) => void;
 }
 
 export interface CactusSTTTranscribeResult {
   success: boolean;
   response: string;
+  cloudHandoff?: boolean;
+  confidence?: number;
   timeToFirstTokenMs: number;
   totalTimeMs: number;
-  tokensPerSecond: number;
   prefillTokens: number;
+  prefillTps: number;
   decodeTokens: number;
+  decodeTps: number;
   totalTokens: number;
+  ramUsageMb?: number;
 }
 
 export interface CactusSTTAudioEmbedParams {
@@ -44,25 +52,51 @@ export interface CactusSTTAudioEmbedResult {
   embedding: number[];
 }
 
-export interface CactusSTTStreamTranscribeInsertParams {
-  audio: number[];
-}
-
-export interface StreamTranscribeProcessOptions {
+export interface CactusSTTStreamTranscribeStartOptions {
   confirmationThreshold?: number;
+  minChunkSize?: number;
+  telemetryEnabled?: boolean;
 }
 
 export interface CactusSTTStreamTranscribeProcessParams {
-  options?: StreamTranscribeProcessOptions;
+  audio: number[];
 }
 
 export interface CactusSTTStreamTranscribeProcessResult {
   success: boolean;
   confirmed: string;
   pending: string;
+  bufferDurationMs?: number;
+  confidence?: number;
+  cloudHandoff?: boolean;
+  cloudResult?: string;
+  cloudJobId?: number;
+  cloudResultJobId?: number;
+  timeToFirstTokenMs?: number;
+  totalTimeMs?: number;
+  prefillTokens?: number;
+  prefillTps?: number;
+  decodeTokens?: number;
+  decodeTps?: number;
+  totalTokens?: number;
+  ramUsageMb?: number;
 }
 
-export interface CactusSTTStreamTranscribeFinalizeResult {
+export interface CactusSTTStreamTranscribeStopResult {
   success: boolean;
   confirmed: string;
 }
+
+export interface CactusSTTDetectLanguageOptions {
+  useVad?: boolean;
+}
+
+export interface CactusSTTDetectLanguageParams {
+  audio: string | number[];
+  options?: CactusSTTDetectLanguageOptions;
+}
+
+export interface CactusSTTDetectLanguageResult {
+  language: string;
+  confidence?: number;
+}

package/src/types/CactusVAD.ts

@@ -0,0 +1,39 @@
+import type { CactusModelOptions } from './common';
+
+export interface CactusVADParams {
+  model?: string;
+  options?: CactusModelOptions;
+}
+
+export interface CactusVADDownloadParams {
+  onProgress?: (progress: number) => void;
+}
+
+export interface CactusVADOptions {
+  threshold?: number;
+  negThreshold?: number;
+  minSpeechDurationMs?: number;
+  maxSpeechDurationS?: number;
+  minSilenceDurationMs?: number;
+  speechPadMs?: number;
+  windowSizeSamples?: number;
+  samplingRate?: number;
+  minSilenceAtMaxSpeech?: number;
+  useMaxPossSilAtMaxSpeech?: boolean;
+}
+
+export interface CactusVADSegment {
+  start: number;
+  end: number;
+}
+
+export interface CactusVADResult {
+  segments: CactusVADSegment[];
+  totalTime: number;
+  ramUsage: number;
+}
+
+export interface CactusVADVadParams {
+  audio: string | number[];
+  options?: CactusVADOptions;
+}

package/src/types/common.ts

@@ -1,9 +1,4 @@
 export interface CactusModel {
-  completion: boolean;
-  tools: boolean;
-  vision: boolean;
-  embed: boolean;
-  speech: boolean;
   quantization: {
     int4: {
       sizeMb: number;
@@ -22,7 +17,7 @@ export interface CactusModel {
   };
 }
 
-export interface ModelOptions {
+export interface CactusModelOptions {
   quantization?: 'int4' | 'int8';
   pro?: boolean;
 }

package/android/src/main/java/com/margelo/nitro/cactus/HybridCactusCrypto.kt

@@ -1,46 +0,0 @@
-package com.margelo.nitro.cactus
-
-import com.margelo.nitro.core.Promise
-import java.nio.ByteBuffer
-import java.security.MessageDigest
-import java.util.Locale
-import java.util.UUID
-
-class HybridCactusCrypto : HybridCactusCryptoSpec() {
-  override fun uuidv5(
-    namespaceUuid: String,
-    name: String,
-  ): Promise<String> =
-    Promise.async {
-      val nsUuid =
-        try {
-          UUID.fromString(namespaceUuid)
-        } catch (e: IllegalArgumentException) {
-          throw IllegalArgumentException("Invalid namespace UUID")
-        }
-
-      val nsBytes =
-        ByteBuffer
-          .allocate(16)
-          .apply {
-            putLong(nsUuid.mostSignificantBits)
-            putLong(nsUuid.leastSignificantBits)
-          }.array()
-      val nameBytes = name.toByteArray(Charsets.UTF_8)
-
-      val sha1 =
-        MessageDigest
-          .getInstance("SHA-1")
-          .apply { update(nsBytes) }
-          .digest(nameBytes)
-      val uuidBytes = sha1.copyOfRange(0, 16)
-      uuidBytes[6] = (uuidBytes[6].toInt() and 0x0F or 0x50).toByte()
-      uuidBytes[8] = (uuidBytes[8].toInt() and 0x3F or 0x80).toByte()
-
-      val bb = ByteBuffer.wrap(uuidBytes)
-
-      val uuid = UUID(bb.long, bb.long)
-
-      uuid.toString().lowercase(Locale.ROOT)
-    }
-}

package/android/src/main/java/com/margelo/nitro/cactus/HybridCactusDeviceInfo.kt

@@ -1,27 +0,0 @@
-package com.margelo.nitro.cactus
-
-import android.os.Build
-import android.provider.Settings
-import com.margelo.nitro.NitroModules
-import com.margelo.nitro.core.Promise
-
-class HybridCactusDeviceInfo : HybridCactusDeviceInfoSpec() {
-  private val context = NitroModules.applicationContext ?: error("Android context not found")
-
-  override fun getAppIdentifier(): Promise<String?> = Promise.async { context.packageName }
-
-  override fun getDeviceInfo(): Promise<DeviceInfo> =
-    Promise.async {
-      DeviceInfo(
-        brand = Build.MANUFACTURER,
-        model = Build.MODEL,
-        device_id =
-          Settings.Secure.getString(
-            context.contentResolver,
-            Settings.Secure.ANDROID_ID,
-          ),
-        os = "Android",
-        os_version = Build.VERSION.RELEASE,
-      )
-    }
-}