cactus-react-native 1.4.0 → 1.7.0

package/nitrogen/generated/ios/Cactus-Swift-Cxx-Bridge.hpp

@@ -8,31 +8,18 @@
 #pragma once
 
 // Forward declarations of C++ defined types
-// Forward declaration of `DeviceInfo` to properly resolve imports.
-namespace margelo::nitro::cactus { struct DeviceInfo; }
-// Forward declaration of `HybridCactusCryptoSpec` to properly resolve imports.
-namespace margelo::nitro::cactus { class HybridCactusCryptoSpec; }
-// Forward declaration of `HybridCactusDeviceInfoSpec` to properly resolve imports.
-namespace margelo::nitro::cactus { class HybridCactusDeviceInfoSpec; }
 // Forward declaration of `HybridCactusFileSystemSpec` to properly resolve imports.
 namespace margelo::nitro::cactus { class HybridCactusFileSystemSpec; }
 // Forward declaration of `HybridCactusImageSpec` to properly resolve imports.
 namespace margelo::nitro::cactus { class HybridCactusImageSpec; }
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridCactusCryptoSpec_cxx` to properly resolve imports.
-namespace Cactus { class HybridCactusCryptoSpec_cxx; }
-// Forward declaration of `HybridCactusDeviceInfoSpec_cxx` to properly resolve imports.
-namespace Cactus { class HybridCactusDeviceInfoSpec_cxx; }
 // Forward declaration of `HybridCactusFileSystemSpec_cxx` to properly resolve imports.
 namespace Cactus { class HybridCactusFileSystemSpec_cxx; }
 // Forward declaration of `HybridCactusImageSpec_cxx` to properly resolve imports.
 namespace Cactus { class HybridCactusImageSpec_cxx; }
 
 // Include C++ defined types
-#include "DeviceInfo.hpp"
-#include "HybridCactusCryptoSpec.hpp"
-#include "HybridCactusDeviceInfoSpec.hpp"
 #include "HybridCactusFileSystemSpec.hpp"
 #include "HybridCactusImageSpec.hpp"
 #include <NitroModules/Promise.hpp>
@@ -106,140 +93,6 @@ namespace margelo::nitro::cactus::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<HybridCactusCryptoSpec>
-  /**
-   * Specialized version of `std::shared_ptr<HybridCactusCryptoSpec>`.
-   */
-  using std__shared_ptr_HybridCactusCryptoSpec_ = std::shared_ptr<HybridCactusCryptoSpec>;
-  std::shared_ptr<HybridCactusCryptoSpec> create_std__shared_ptr_HybridCactusCryptoSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
-  void* NON_NULL get_std__shared_ptr_HybridCactusCryptoSpec_(std__shared_ptr_HybridCactusCryptoSpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<HybridCactusCryptoSpec>
-  using std__weak_ptr_HybridCactusCryptoSpec_ = std::weak_ptr<HybridCactusCryptoSpec>;
-  inline std__weak_ptr_HybridCactusCryptoSpec_ weakify_std__shared_ptr_HybridCactusCryptoSpec_(const std::shared_ptr<HybridCactusCryptoSpec>& strong) noexcept { return strong; }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
-  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
-  }
-  
-  // pragma MARK: std::optional<std::string>
-  /**
-   * Specialized version of `std::optional<std::string>`.
-   */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
-    return std::optional<std::string>(value);
-  }
-  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return *optional;
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<std::optional<std::string>>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<std::optional<std::string>>>`.
-   */
-  using std__shared_ptr_Promise_std__optional_std__string___ = std::shared_ptr<Promise<std::optional<std::string>>>;
-  inline std::shared_ptr<Promise<std::optional<std::string>>> create_std__shared_ptr_Promise_std__optional_std__string___() noexcept {
-    return Promise<std::optional<std::string>>::create();
-  }
-  inline PromiseHolder<std::optional<std::string>> wrap_std__shared_ptr_Promise_std__optional_std__string___(std::shared_ptr<Promise<std::optional<std::string>>> promise) noexcept {
-    return PromiseHolder<std::optional<std::string>>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const std::optional<std::string>& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const std::optional<std::string>&)>`.
-   */
-  using Func_void_std__optional_std__string_ = std::function<void(const std::optional<std::string>& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::optional<std::string>& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__optional_std__string__Wrapper final {
-  public:
-    explicit Func_void_std__optional_std__string__Wrapper(std::function<void(const std::optional<std::string>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::string>& /* result */)>>(std::move(func))) {}
-    inline void call(std::optional<std::string> result) const noexcept {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const std::optional<std::string>& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_std__optional_std__string_ create_Func_void_std__optional_std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_std__optional_std__string__Wrapper wrap_Func_void_std__optional_std__string_(Func_void_std__optional_std__string_ value) noexcept {
-    return Func_void_std__optional_std__string__Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<DeviceInfo>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<DeviceInfo>>`.
-   */
-  using std__shared_ptr_Promise_DeviceInfo__ = std::shared_ptr<Promise<DeviceInfo>>;
-  inline std::shared_ptr<Promise<DeviceInfo>> create_std__shared_ptr_Promise_DeviceInfo__() noexcept {
-    return Promise<DeviceInfo>::create();
-  }
-  inline PromiseHolder<DeviceInfo> wrap_std__shared_ptr_Promise_DeviceInfo__(std::shared_ptr<Promise<DeviceInfo>> promise) noexcept {
-    return PromiseHolder<DeviceInfo>(std::move(promise));
-  }
-  
-  // pragma MARK: std::function<void(const DeviceInfo& /* result */)>
-  /**
-   * Specialized version of `std::function<void(const DeviceInfo&)>`.
-   */
-  using Func_void_DeviceInfo = std::function<void(const DeviceInfo& /* result */)>;
-  /**
-   * Wrapper class for a `std::function<void(const DeviceInfo& / * result * /)>`, this can be used from Swift.
-   */
-  class Func_void_DeviceInfo_Wrapper final {
-  public:
-    explicit Func_void_DeviceInfo_Wrapper(std::function<void(const DeviceInfo& /* result */)>&& func): _function(std::make_unique<std::function<void(const DeviceInfo& /* result */)>>(std::move(func))) {}
-    inline void call(DeviceInfo result) const noexcept {
-      _function->operator()(result);
-    }
-  private:
-    std::unique_ptr<std::function<void(const DeviceInfo& /* result */)>> _function;
-  } SWIFT_NONCOPYABLE;
-  Func_void_DeviceInfo create_Func_void_DeviceInfo(void* NON_NULL swiftClosureWrapper) noexcept;
-  inline Func_void_DeviceInfo_Wrapper wrap_Func_void_DeviceInfo(Func_void_DeviceInfo value) noexcept {
-    return Func_void_DeviceInfo_Wrapper(std::move(value));
-  }
-  
-  // pragma MARK: std::shared_ptr<HybridCactusDeviceInfoSpec>
-  /**
-   * Specialized version of `std::shared_ptr<HybridCactusDeviceInfoSpec>`.
-   */
-  using std__shared_ptr_HybridCactusDeviceInfoSpec_ = std::shared_ptr<HybridCactusDeviceInfoSpec>;
-  std::shared_ptr<HybridCactusDeviceInfoSpec> create_std__shared_ptr_HybridCactusDeviceInfoSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
-  void* NON_NULL get_std__shared_ptr_HybridCactusDeviceInfoSpec_(std__shared_ptr_HybridCactusDeviceInfoSpec_ cppType);
-  
-  // pragma MARK: std::weak_ptr<HybridCactusDeviceInfoSpec>
-  using std__weak_ptr_HybridCactusDeviceInfoSpec_ = std::weak_ptr<HybridCactusDeviceInfoSpec>;
-  inline std__weak_ptr_HybridCactusDeviceInfoSpec_ weakify_std__shared_ptr_HybridCactusDeviceInfoSpec_(const std::shared_ptr<HybridCactusDeviceInfoSpec>& strong) noexcept { return strong; }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::string>>>>
-  using Result_std__shared_ptr_Promise_std__optional_std__string____ = Result<std::shared_ptr<Promise<std::optional<std::string>>>>;
-  inline Result_std__shared_ptr_Promise_std__optional_std__string____ create_Result_std__shared_ptr_Promise_std__optional_std__string____(const std::shared_ptr<Promise<std::optional<std::string>>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<std::string>>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_std__optional_std__string____ create_Result_std__shared_ptr_Promise_std__optional_std__string____(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<std::optional<std::string>>>>::withError(error);
-  }
-  
-  // pragma MARK: Result<std::shared_ptr<Promise<DeviceInfo>>>
-  using Result_std__shared_ptr_Promise_DeviceInfo___ = Result<std::shared_ptr<Promise<DeviceInfo>>>;
-  inline Result_std__shared_ptr_Promise_DeviceInfo___ create_Result_std__shared_ptr_Promise_DeviceInfo___(const std::shared_ptr<Promise<DeviceInfo>>& value) noexcept {
-    return Result<std::shared_ptr<Promise<DeviceInfo>>>::withValue(value);
-  }
-  inline Result_std__shared_ptr_Promise_DeviceInfo___ create_Result_std__shared_ptr_Promise_DeviceInfo___(const std::exception_ptr& error) noexcept {
-    return Result<std::shared_ptr<Promise<DeviceInfo>>>::withError(error);
-  }
-  
   // pragma MARK: std::shared_ptr<Promise<bool>>
   /**
    * Specialized version of `std::shared_ptr<Promise<bool>>`.
@@ -357,6 +210,15 @@ namespace margelo::nitro::cactus::bridge::swift {
   using std__weak_ptr_HybridCactusFileSystemSpec_ = std::weak_ptr<HybridCactusFileSystemSpec>;
   inline std__weak_ptr_HybridCactusFileSystemSpec_ weakify_std__shared_ptr_HybridCactusFileSystemSpec_(const std::shared_ptr<HybridCactusFileSystemSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
+  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
   using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
   inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {

package/nitrogen/generated/ios/Cactus-Swift-Cxx-Umbrella.hpp

@@ -8,21 +8,12 @@
 #pragma once
 
 // Forward declarations of C++ defined types
-// Forward declaration of `DeviceInfo` to properly resolve imports.
-namespace margelo::nitro::cactus { struct DeviceInfo; }
-// Forward declaration of `HybridCactusCryptoSpec` to properly resolve imports.
-namespace margelo::nitro::cactus { class HybridCactusCryptoSpec; }
-// Forward declaration of `HybridCactusDeviceInfoSpec` to properly resolve imports.
-namespace margelo::nitro::cactus { class HybridCactusDeviceInfoSpec; }
 // Forward declaration of `HybridCactusFileSystemSpec` to properly resolve imports.
 namespace margelo::nitro::cactus { class HybridCactusFileSystemSpec; }
 // Forward declaration of `HybridCactusImageSpec` to properly resolve imports.
 namespace margelo::nitro::cactus { class HybridCactusImageSpec; }
 
 // Include C++ defined types
-#include "DeviceInfo.hpp"
-#include "HybridCactusCryptoSpec.hpp"
-#include "HybridCactusDeviceInfoSpec.hpp"
 #include "HybridCactusFileSystemSpec.hpp"
 #include "HybridCactusImageSpec.hpp"
 #include <NitroModules/Promise.hpp>
@@ -43,10 +34,6 @@ namespace margelo::nitro::cactus { class HybridCactusImageSpec; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridCactusCryptoSpec_cxx` to properly resolve imports.
-namespace Cactus { class HybridCactusCryptoSpec_cxx; }
-// Forward declaration of `HybridCactusDeviceInfoSpec_cxx` to properly resolve imports.
-namespace Cactus { class HybridCactusDeviceInfoSpec_cxx; }
 // Forward declaration of `HybridCactusFileSystemSpec_cxx` to properly resolve imports.
 namespace Cactus { class HybridCactusFileSystemSpec_cxx; }
 // Forward declaration of `HybridCactusImageSpec_cxx` to properly resolve imports.

package/nitrogen/generated/ios/CactusAutolinking.mm

@@ -12,10 +12,7 @@
 
 #include "HybridCactus.hpp"
 #include "HybridCactusIndex.hpp"
-#include "HybridCactusUtil.hpp"
 #include "HybridCactusFileSystemSpecSwift.hpp"
-#include "HybridCactusCryptoSpecSwift.hpp"
-#include "HybridCactusDeviceInfoSpecSwift.hpp"
 #include "HybridCactusImageSpecSwift.hpp"
 
 @interface CactusAutolinking : NSObject
@@ -45,15 +42,6 @@
       return std::make_shared<HybridCactusIndex>();
     }
   );
-  HybridObjectRegistry::registerHybridObjectConstructor(
-    "CactusUtil",
-    []() -> std::shared_ptr<HybridObject> {
-      static_assert(std::is_default_constructible_v<HybridCactusUtil>,
-                    "The HybridObject \"HybridCactusUtil\" is not default-constructible! "
-                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
-      return std::make_shared<HybridCactusUtil>();
-    }
-  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "CactusFileSystem",
     []() -> std::shared_ptr<HybridObject> {
@@ -61,20 +49,6 @@
       return hybridObject;
     }
   );
-  HybridObjectRegistry::registerHybridObjectConstructor(
-    "CactusCrypto",
-    []() -> std::shared_ptr<HybridObject> {
-      std::shared_ptr<HybridCactusCryptoSpec> hybridObject = Cactus::CactusAutolinking::createCactusCrypto();
-      return hybridObject;
-    }
-  );
-  HybridObjectRegistry::registerHybridObjectConstructor(
-    "CactusDeviceInfo",
-    []() -> std::shared_ptr<HybridObject> {
-      std::shared_ptr<HybridCactusDeviceInfoSpec> hybridObject = Cactus::CactusAutolinking::createCactusDeviceInfo();
-      return hybridObject;
-    }
-  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "CactusImage",
     []() -> std::shared_ptr<HybridObject> {

package/nitrogen/generated/ios/CactusAutolinking.swift

@@ -23,36 +23,6 @@ public final class CactusAutolinking {
     }()
   }
   
-  /**
-   * Creates an instance of a Swift class that implements `HybridCactusCryptoSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridCactusCryptoSpec_cxx`)
-   *
-   * This is generated by Nitrogen and will initialize the class specified
-   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridCactusCrypto`).
-   */
-  public static func createCactusCrypto() -> bridge.std__shared_ptr_HybridCactusCryptoSpec_ {
-    let hybridObject = HybridCactusCrypto()
-    return { () -> bridge.std__shared_ptr_HybridCactusCryptoSpec_ in
-      let __cxxWrapped = hybridObject.getCxxWrapper()
-      return __cxxWrapped.getCxxPart()
-    }()
-  }
-  
-  /**
-   * Creates an instance of a Swift class that implements `HybridCactusDeviceInfoSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridCactusDeviceInfoSpec_cxx`)
-   *
-   * This is generated by Nitrogen and will initialize the class specified
-   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridCactusDeviceInfo`).
-   */
-  public static func createCactusDeviceInfo() -> bridge.std__shared_ptr_HybridCactusDeviceInfoSpec_ {
-    let hybridObject = HybridCactusDeviceInfo()
-    return { () -> bridge.std__shared_ptr_HybridCactusDeviceInfoSpec_ in
-      let __cxxWrapped = hybridObject.getCxxWrapper()
-      return __cxxWrapped.getCxxPart()
-    }()
-  }
-  
   /**
    * Creates an instance of a Swift class that implements `HybridCactusImageSpec`,
    * and wraps it in a Swift class that can directly interop with C++ (`HybridCactusImageSpec_cxx`)

package/nitrogen/generated/shared/c++/HybridCactusSpec.cpp

@@ -19,12 +19,17 @@ namespace margelo::nitro::cactus {
       prototype.registerHybridMethod("tokenize", &HybridCactusSpec::tokenize);
       prototype.registerHybridMethod("scoreWindow", &HybridCactusSpec::scoreWindow);
       prototype.registerHybridMethod("transcribe", &HybridCactusSpec::transcribe);
+      prototype.registerHybridMethod("streamTranscribeStart", &HybridCactusSpec::streamTranscribeStart);
+      prototype.registerHybridMethod("streamTranscribeProcess", &HybridCactusSpec::streamTranscribeProcess);
+      prototype.registerHybridMethod("streamTranscribeStop", &HybridCactusSpec::streamTranscribeStop);
+      prototype.registerHybridMethod("vad", &HybridCactusSpec::vad);
       prototype.registerHybridMethod("embed", &HybridCactusSpec::embed);
       prototype.registerHybridMethod("imageEmbed", &HybridCactusSpec::imageEmbed);
       prototype.registerHybridMethod("audioEmbed", &HybridCactusSpec::audioEmbed);
       prototype.registerHybridMethod("reset", &HybridCactusSpec::reset);
       prototype.registerHybridMethod("stop", &HybridCactusSpec::stop);
       prototype.registerHybridMethod("destroy", &HybridCactusSpec::destroy);
+      prototype.registerHybridMethod("setTelemetryEnvironment", &HybridCactusSpec::setTelemetryEnvironment);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridCactusSpec.hpp

@@ -53,17 +53,22 @@ namespace margelo::nitro::cactus {
 
     public:
       // Methods
-      virtual std::shared_ptr<Promise<void>> init(const std::string& modelPath, double contextSize, const std::optional<std::string>& corpusDir) = 0;
+      virtual std::shared_ptr<Promise<void>> init(const std::string& modelPath, const std::optional<std::string>& corpusDir, std::optional<bool> cacheIndex) = 0;
       virtual std::shared_ptr<Promise<std::string>> complete(const std::string& messagesJson, double responseBufferSize, const std::optional<std::string>& optionsJson, const std::optional<std::string>& toolsJson, const std::optional<std::function<void(const std::string& /* token */, double /* tokenId */)>>& callback) = 0;
       virtual std::shared_ptr<Promise<std::vector<double>>> tokenize(const std::string& text) = 0;
       virtual std::shared_ptr<Promise<std::string>> scoreWindow(const std::vector<double>& tokens, double start, double end, double context) = 0;
       virtual std::shared_ptr<Promise<std::string>> transcribe(const std::variant<std::vector<double>, std::string>& audio, const std::string& prompt, double responseBufferSize, const std::optional<std::string>& optionsJson, const std::optional<std::function<void(const std::string& /* token */, double /* tokenId */)>>& callback) = 0;
+      virtual std::shared_ptr<Promise<void>> streamTranscribeStart(const std::optional<std::string>& optionsJson) = 0;
+      virtual std::shared_ptr<Promise<std::string>> streamTranscribeProcess(const std::vector<double>& audio) = 0;
+      virtual std::shared_ptr<Promise<std::string>> streamTranscribeStop() = 0;
+      virtual std::shared_ptr<Promise<std::string>> vad(const std::variant<std::vector<double>, std::string>& audio, double responseBufferSize, const std::optional<std::string>& optionsJson) = 0;
       virtual std::shared_ptr<Promise<std::vector<double>>> embed(const std::string& text, double embeddingBufferSize, bool normalize) = 0;
       virtual std::shared_ptr<Promise<std::vector<double>>> imageEmbed(const std::string& imagePath, double embeddingBufferSize) = 0;
       virtual std::shared_ptr<Promise<std::vector<double>>> audioEmbed(const std::string& audioPath, double embeddingBufferSize) = 0;
       virtual std::shared_ptr<Promise<void>> reset() = 0;
       virtual std::shared_ptr<Promise<void>> stop() = 0;
       virtual std::shared_ptr<Promise<void>> destroy() = 0;
+      virtual std::shared_ptr<Promise<void>> setTelemetryEnvironment(const std::string& cacheDir) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cactus-react-native",
-  "version": "1.4.0",
+  "version": "1.7.0",
   "description": "Run AI models locally on mobile devices",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -83,7 +83,7 @@
     "react": "19.1.0",
     "react-native": "0.81.1",
     "react-native-builder-bob": "^0.40.14",
-    "react-native-nitro-modules": "^0.31.10",
+    "react-native-nitro-modules": "^0.33.9",
     "release-it": "^19.0.4",
     "turbo": "^2.5.6",
     "typescript": "^5.9.2"
@@ -91,7 +91,7 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "^0.31.3"
+    "react-native-nitro-modules": "^0.33.9"
   },
   "workspaces": [
     "example"

package/src/classes/CactusLM.ts

@@ -13,38 +13,51 @@ import type {
   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 { getRegistry } from '../modelRegistry';
+import type { CactusModel } from '../types/common';
 
 export class CactusLM {
   private readonly cactus = new Cactus();
 
   private readonly model: string;
-  private readonly contextSize: number;
   private readonly corpusDir?: string;
+  private readonly cacheIndex: boolean;
+  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 defaultContextSize = 2048;
+  private static readonly defaultModel = 'qwen3-0.6b';
+  private static readonly defaultOptions = {
+    quantization: 'int8' 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 = {}) {
-    Telemetry.init(CactusConfig.telemetryToken);
-
+  constructor({ model, corpusDir, cacheIndex, options }: CactusLMParams = {}) {
     this.model = model ?? CactusLM.defaultModel;
-    this.contextSize = contextSize ?? CactusLM.defaultContextSize;
     this.corpusDir = corpusDir;
+    this.cacheIndex = cacheIndex ?? false;
+    this.options = {
+      quantization:
+        options?.quantization ??
+        CactusLM.quantizationExceptions[this.model] ??
+        CactusLM.defaultOptions.quantization,
+      pro: options?.pro ?? CactusLM.defaultOptions.pro,
+    };
   }
 
   public async download({
@@ -59,17 +72,26 @@ export class CactusLM {
       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 registry = await getRegistry();
+      const modelConfig =
+        registry[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 {
@@ -86,20 +108,19 @@ export class CactusLM {
     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`);
+      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.model);
+      modelPath = await CactusFileSystem.getModelPath(this.getModelName());
     }
 
-    try {
-      await this.cactus.init(modelPath, this.contextSize, this.corpusDir);
-      Telemetry.logInit(this.model, true);
-      this.isInitialized = true;
-    } catch (error) {
-      Telemetry.logInit(this.model, false, getErrorMessage(error));
-      throw error;
-    }
+    const cacheDir = await CactusFileSystem.getCactusDirectory();
+    await this.cactus.setTelemetryEnvironment(cacheDir);
+    await this.cactus.init(modelPath, this.corpusDir, this.cacheIndex);
+    this.isInitialized = true;
   }
 
   public async complete({
@@ -107,7 +128,6 @@ export class CactusLM {
     options,
     tools,
     onToken,
-    mode,
   }: CactusLMCompleteParams): Promise<CactusLMCompleteResult> {
     if (this.isGenerating) {
       throw new Error('CactusLM is already generating');
@@ -118,49 +138,22 @@ export class CactusLM {
       type: 'function' as const,
       function: tool,
     }));
-    mode = mode ?? CactusLM.defaultCompleteMode;
 
     const responseBufferSize =
       8 * (options.maxTokens ?? CactusLM.defaultCompleteOptions.maxTokens) +
       256;
 
-    try {
-      await this.init();
+    await this.init();
 
-      this.isGenerating = true;
-      const result = await this.cactus.complete(
+    this.isGenerating = true;
+    try {
+      return await this.cactus.complete(
         messages,
         responseBufferSize,
         options,
         toolsInternal,
         onToken
       );
-      Telemetry.logCompletion(
-        this.model,
-        result.success,
-        result.success ? undefined : result.response,
-        result
-      );
-      return result;
-    } catch (localError) {
-      if (mode === 'local') {
-        Telemetry.logCompletion(this.model, false, getErrorMessage(localError));
-        throw localError;
-      }
-
-      Telemetry.logCompletion(
-        this.model,
-        false,
-        `Local completion error: ${getErrorMessage(localError)}. Falling back to remote completion.`
-      );
-
-      try {
-        return RemoteLM.complete(messages, options, toolsInternal, onToken);
-      } catch (remoteError) {
-        throw new Error(
-          `Remote completion error: ${getErrorMessage(remoteError)}`
-        );
-      }
     } finally {
       this.isGenerating = false;
     }
@@ -200,11 +193,7 @@ export class CactusLM {
         CactusLM.defaultEmbedBufferSize,
         normalize
       );
-      Telemetry.logEmbedding(this.model, true);
       return { embedding };
-    } catch (error) {
-      Telemetry.logEmbedding(this.model, false, getErrorMessage(error));
-      throw error;
     } finally {
       this.isGenerating = false;
     }
@@ -225,11 +214,7 @@ export class CactusLM {
         imagePath,
         CactusLM.defaultEmbedBufferSize
       );
-      Telemetry.logImageEmbedding(this.model, true);
       return { embedding };
-    } catch (error) {
-      Telemetry.logImageEmbedding(this.model, false, getErrorMessage(error));
-      throw error;
     } finally {
       this.isGenerating = false;
     }
@@ -256,14 +241,14 @@ export class CactusLM {
   }
 
   public async getModels(): Promise<CactusModel[]> {
-    const models = await Database.getModels();
-    for (const model of models) {
-      model.isDownloaded = await CactusFileSystem.modelExists(model.slug);
-    }
-    return models;
+    return Object.values(await getRegistry());
   }
 
   private isModelPath(model: string): boolean {
     return model.startsWith('file://') || model.startsWith('/');
   }
+
+  public getModelName(): string {
+    return `${this.model}-${this.options.quantization}${this.options.pro ? '-pro' : ''}`;
+  }
 }