cactus-react-native 1.5.0 → 1.7.0

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,37 @@ 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;
 }

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,
-      )
-    }
-}

package/cpp/HybridCactusUtil.cpp

@@ -1,47 +0,0 @@
-#include "HybridCactusUtil.hpp"
-
-namespace margelo::nitro::cactus {
-
-HybridCactusUtil::HybridCactusUtil() : HybridObject(TAG) {}
-
-std::shared_ptr<Promise<std::string>>
-HybridCactusUtil::registerApp(const std::string &encryptedData) {
-  return Promise<std::string>::async([this, encryptedData]() -> std::string {
-    std::lock_guard<std::mutex> lock(this->_mutex);
-
-    const char *raw = register_app(encryptedData.c_str());
-
-    if (raw == nullptr) {
-      throw std::runtime_error("Failed to register app");
-    }
-
-    std::string registerAppStr(raw);
-    free_string(raw);
-
-    return registerAppStr;
-  });
-}
-
-std::shared_ptr<Promise<std::optional<std::string>>>
-HybridCactusUtil::getDeviceId(const std::optional<std::string> &token) {
-  return Promise<std::optional<std::string>>::async(
-      [this, token]() -> std::optional<std::string> {
-        std::lock_guard<std::mutex> lock(this->_mutex);
-
-        const char *deviceId = get_device_id(token ? token->c_str() : nullptr);
-        return deviceId ? std::optional<std::string>(deviceId) : std::nullopt;
-      });
-}
-
-std::shared_ptr<Promise<void>>
-HybridCactusUtil::setAndroidDataDirectory(const std::string &dataDir) {
-  return Promise<void>::async([this, dataDir]() -> void {
-    std::lock_guard<std::mutex> lock(this->_mutex);
-
-#ifdef __ANDROID__
-    set_android_data_directory(dataDir.c_str());
-#endif
-  });
-}
-
-} // namespace margelo::nitro::cactus

package/cpp/HybridCactusUtil.hpp

@@ -1,27 +0,0 @@
-#pragma once
-#include "HybridCactusUtilSpec.hpp"
-
-#include "cactus_util.h"
-
-#include <mutex>
-
-namespace margelo::nitro::cactus {
-
-class HybridCactusUtil : public HybridCactusUtilSpec {
-public:
-  HybridCactusUtil();
-
-  std::shared_ptr<Promise<std::string>>
-  registerApp(const std::string &encryptedData) override;
-
-  std::shared_ptr<Promise<std::optional<std::string>>>
-  getDeviceId(const std::optional<std::string> &token) override;
-
-  std::shared_ptr<Promise<void>>
-  setAndroidDataDirectory(const std::string &dataDir) override;
-
-private:
-  std::mutex _mutex;
-};
-
-} // namespace margelo::nitro::cactus

package/cpp/cactus_util.h

@@ -1,25 +0,0 @@
-#ifndef cactus_util_H
-#define cactus_util_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-const char* register_app(const char* encrypted_data);
-
-const char* get_device_id(const char* current_token);
-
-// Helper function to free memory allocated by register_app
-void free_string(const char* str);
-
-#ifdef __ANDROID__
-// Function to set the Android app data directory
-// This should be called from Flutter/Java side before any other functions
-void set_android_data_directory(const char* data_dir);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

package/ios/HybridCactusCrypto.swift

@@ -1,37 +0,0 @@
-import CryptoKit
-import NitroModules
-
-class HybridCactusCrypto: HybridCactusCryptoSpec {
-  func uuidv5(namespaceUuid: String, name: String) throws -> Promise<String> {
-    return Promise.async {
-      guard let ns = UUID(uuidString: namespaceUuid) else {
-        throw RuntimeError.error(withMessage: "Invalid namespace UUID")
-      }
-
-      var nsBytes = ns.uuid
-      var data = withUnsafeBytes(of: &nsBytes) { Data($0) }
-      data.append(Data(name.utf8))
-
-      let digest = Insecure.SHA1.hash(data: data)
-      var bytes = Data(digest.prefix(16))
-      bytes.withUnsafeMutableBytes { raw in
-        let b = raw.bindMemory(to: UInt8.self)
-        b[6] = (b[6] & 0x0F) | 0x50
-        b[8] = (b[8] & 0x3F) | 0x80
-      }
-
-      let tuple = bytes.withUnsafeBytes { ptr -> uuid_t in
-        let b = ptr.bindMemory(to: UInt8.self)
-        return uuid_t(
-          b[0], b[1], b[2], b[3],
-          b[4], b[5], b[6], b[7],
-          b[8], b[9], b[10], b[11],
-          b[12], b[13], b[14], b[15])
-      }
-
-      let uuid = UUID(uuid: tuple)
-
-      return uuid.uuidString.lowercased()
-    }
-  }
-}

package/ios/HybridCactusDeviceInfo.swift

@@ -1,32 +0,0 @@
-import NitroModules
-import UIKit
-
-class HybridCactusDeviceInfo: HybridCactusDeviceInfoSpec {
-  func getAppIdentifier() throws -> Promise<String?> {
-    return Promise.async { Bundle.main.bundleIdentifier }
-  }
-
-  func getDeviceInfo() throws -> Promise<DeviceInfo> {
-    return Promise.async {
-      let device = await MainActor.run { UIDevice.current }
-      return await DeviceInfo(
-        brand: "Apple",
-        model: self.deviceModelIdentifier(),
-        device_id: device.identifierForVendor?.uuidString,
-        os: device.systemName,
-        os_version: device.systemVersion
-      )
-    }
-  }
-  
-  private func deviceModelIdentifier() -> String {
-    var systemInfo = utsname()
-    uname(&systemInfo)
-    let machineMirror = Mirror(reflecting: systemInfo.machine)
-    let identifier = machineMirror.children.reduce("") { identifier, element in
-      guard let value = element.value as? Int8, value != 0 else { return identifier }
-      return identifier + String(UnicodeScalar(UInt8(value)))
-    }
-    return identifier
-  }
-}