@micrantha/react-native-amaryllis 0.1.0

package/android/src/main/java/com/micrantha/amaryllis/AmaryllisModule.kt

@@ -0,0 +1,165 @@
+package com.micrantha.amaryllis
+
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+@ReactModule(name = AmaryllisModule.NAME)
+class AmaryllisModule(reactContext: ReactApplicationContext) :
+  NativeAmaryllisSpec(reactContext) {
+
+  private val amaryllis = Amaryllis()
+
+  override fun getName() = NAME
+
+  @ReactMethod
+  override fun init(config: ReadableMap, promise: Promise): Unit = try {
+    amaryllis.init(reactApplicationContext.applicationContext, config)
+    promise.resolve(null)
+  } catch (e: Amaryllis.InvalidModelPathException) {
+    promise.reject(ERROR_CODE_INFER, "invalid model path", e)
+  } catch (e: Throwable) {
+    promise.reject(ERROR_CODE_INFER, "unable to configure", e)
+  }
+
+  @ReactMethod
+  override fun newSession(params: ReadableMap?, promise: Promise) {
+    try {
+      amaryllis.newSession(params)
+    } catch (e: Amaryllis.NotInitializedException) {
+      Log.e(NAME, "sdk is not initialized", e)
+      promise.reject(ERROR_CODE_INFER, "sdk is not initialized", e)
+    } catch (e: Throwable) {
+      Log.e(NAME, "unable to initialize session", e)
+      promise.reject(ERROR_CODE_SESSION, "please initialize the sdk first", e)
+    }
+  }
+
+  @ReactMethod
+  override fun generate(params: ReadableMap, promise: Promise) {
+    try {
+      val result = amaryllis.generate(params)
+      promise.resolve(result)
+    } catch (e: Amaryllis.SessionRequiredException) {
+      Log.e(NAME, "session is required", e)
+      promise.reject(ERROR_CODE_SESSION, "session is required", e)
+    } catch (e: Amaryllis.NotInitializedException) {
+      Log.e(NAME, "sdk is not initialized", e)
+      promise.reject(ERROR_CODE_INFER, "sdk is not initialized", e)
+    } catch (e: Throwable) {
+      Log.e(NAME, "unable to generate response", e)
+      promise.reject(ERROR_CODE_INFER, "unable to generate response", e)
+    }
+  }
+
+  @ReactMethod
+  override fun generateAsync(params: ReadableMap, promise: Promise) {
+    try {
+      amaryllis.generateAsync(params) { partialResult, done ->
+        if (done) {
+          sendEvent(EVENT_ON_FINAL_RESULT, partialResult ?: "")
+        } else {
+          sendEvent(EVENT_ON_PARTIAL_RESULT, partialResult ?: "")
+        }
+      }
+      promise.resolve(null)
+    } catch (e: Amaryllis.SessionRequiredException) {
+      Log.e(NAME, "session is required", e)
+      promise.reject(ERROR_CODE_SESSION, "session is required", e)
+    } catch (e: Amaryllis.NotInitializedException) {
+      Log.e(NAME, "sdk is not initialized", e)
+      promise.reject(ERROR_CODE_INFER, "sdk is not initialized", e)
+    } catch (e: Throwable) {
+      Log.e(NAME, "unable to generate response", e)
+      sendEvent(EVENT_ON_ERROR, "unable to generate response")
+      promise.reject(ERROR_CODE_INFER, "unable to generate response", e)
+    }
+  }
+
+  @ReactMethod
+  override fun close() {
+    Log.d(NAME, "closing")
+    amaryllis.close()
+  }
+
+  @ReactMethod
+  override fun cancelAsync() {
+    amaryllis.cancelAsync()
+  }
+
+  @Override
+  fun addListener(eventName: String) {
+    // No-op
+  }
+
+  @Override
+  fun removeListeners(count: Int) {
+    // No-op
+  }
+
+  private fun sendEvent(event: String, data: String) {
+    Log.d(NAME, "sending event $event")
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(event, data)
+  }
+
+  override fun getConstants() = mapOf(
+    // events
+    "EVENT_ON_PARTIAL_RESULT" to EVENT_ON_PARTIAL_RESULT,
+    "EVENT_ON_FINAL_RESULT" to EVENT_ON_FINAL_RESULT,
+    "EVENT_ON_ERROR" to EVENT_ON_ERROR,
+    // errors
+    "ERROR_CODE_INFER" to ERROR_CODE_INFER,
+    "ERROR_CODE_SESSION" to ERROR_CODE_SESSION,
+    // params
+    "PARAM_IMAGES" to PARAM_IMAGES,
+    "PARAM_PROMPT" to PARAM_PROMPT,
+    "PARAM_MAX_TOP_K" to PARAM_MAX_TOP_K,
+    "PARAM_MAX_TOKENS" to PARAM_MAX_TOKENS,
+    "PARAM_MAX_NUM_IMAGES" to PARAM_MAX_NUM_IMAGES,
+    "PARAM_VISION_ENCODER" to PARAM_VISION_ENCODER,
+    "PARAM_VISION_ADAPTER" to PARAM_VISION_ADAPTER,
+    "PARAM_MODEL_PATH" to PARAM_MODEL_PATH,
+    "PARAM_TEMPERATURE" to PARAM_TEMPERATURE,
+    "PARAM_RANDOM_SEED" to PARAM_RANDOM_SEED,
+    "PARAM_LORA_PATH" to PARAM_LORA_PATH,
+    "PARAM_TOP_K" to PARAM_TOP_K,
+    "PARAM_TOP_P" to PARAM_TOP_P,
+    "PARAM_ENABLE_VISION" to PARAM_ENABLE_VISION
+  )
+
+  companion object {
+    const val NAME = "Amaryllis"
+
+    // Events
+    const val EVENT_ON_PARTIAL_RESULT = "onPartialResult"
+    const val EVENT_ON_FINAL_RESULT = "onFinalResult"
+    const val EVENT_ON_ERROR = "onError"
+
+    // Errors
+    const val ERROR_CODE_INFER = "ERR_INFER"
+    const val ERROR_CODE_SESSION = "ERR_SESSION"
+
+    // Params
+    const val PARAM_IMAGES = "images"
+    const val PARAM_PROMPT = "prompt"
+    const val PARAM_MAX_TOP_K = "maxTopK"
+    const val PARAM_MAX_TOKENS = "maxTokens"
+    const val PARAM_MAX_NUM_IMAGES = "maxNumImages"
+    const val PARAM_VISION_ENCODER = "visionEncoderPath"
+    const val PARAM_VISION_ADAPTER = "visionAdapterPath"
+    const val PARAM_MODEL_PATH = "modelPath"
+    const val PARAM_TEMPERATURE = "temperature"
+    const val PARAM_RANDOM_SEED = "randomSeed"
+    const val PARAM_LORA_PATH = "loraPath"
+    const val PARAM_TOP_K = "topK"
+    const val PARAM_TOP_P = "topP"
+    const val PARAM_ENABLE_VISION = "enableVisionModality"
+  }
+}

package/android/src/main/java/com/micrantha/amaryllis/AmaryllisPackage.kt

@@ -0,0 +1,32 @@
+package com.micrantha.amaryllis
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class AmaryllisPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == AmaryllisModule.NAME) {
+      AmaryllisModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[AmaryllisModule.NAME] = ReactModuleInfo(
+        name = AmaryllisModule.NAME,
+        className = AmaryllisModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+      moduleInfos
+    }
+  }
+}

package/ios/Amaryllis.h

@@ -0,0 +1,49 @@
+//
+//  Header.h
+//  Pods
+//
+//  Created by Ryan Jennings on 2025-09-05.
+//
+
+#ifndef Amaryllis_h
+#define Amaryllis_h
+
+typedef void (^PartialResponseHandler)(NSString *_Nullable partialResponse,
+                                       NSError *_Nullable error);
+typedef void (^CompletionHandler)(void);
+
+@interface Amaryllis : NSObject
+
+- (void) initWithParams: (NSDictionary *_Nonnull) params error: (NSError *_Nullable*_Nullable) error;
+- (void) newSessionWithParams: (NSDictionary *_Nonnull) params error: (NSError *_Nullable*_Nullable) error;
+- (NSString *_Nullable) generateWithParams: (NSDictionary *_Nonnull) params error: (NSError *_Nullable*_Nullable) error;
+- (void) generateAsyncWithParams: (NSDictionary *_Nonnull) params error: (NSError *_Nullable*_Nullable) error
+                        response: (PartialResponseHandler _Nullable ) progress completion: (CompletionHandler _Nullable ) completion;
+- (void) close;
+@end
+
+extern NSString *_Nonnull const AmaryllisErrorDomain;
+
+extern NSString *_Nonnull const PARAM_IMAGES;
+extern NSString *_Nonnull const PARAM_PROMPT;
+extern NSString *_Nonnull const PARAM_MAX_TOP_K;
+extern NSString *_Nonnull const PARAM_MAX_TOKENS;
+extern NSString *_Nonnull const PARAM_MAX_NUM_IMAGES;
+extern NSString *_Nonnull const PARAM_VISION_ENCODER;
+extern NSString *_Nonnull const PARAM_VISION_ADAPTER;
+extern NSString *_Nonnull const PARAM_MODEL_PATH;
+extern NSString *_Nonnull const PARAM_TEMPERATURE;
+extern NSString *_Nonnull const PARAM_RANDOM_SEED;
+extern NSString *_Nonnull const PARAM_LORA_PATH;
+extern NSString *_Nonnull const PARAM_TOP_K;
+extern NSString *_Nonnull const PARAM_TOP_P;
+extern NSString *_Nonnull const PARAM_ENABLE_VISION;
+
+typedef NS_ENUM(NSInteger, AmaryllisErrorCode) {
+    AmaryllisErrorCodeInvalidModelPath = 1001,
+    AmaryllisErrorCodeNotInitialized = 1002,
+    AmaryllisErrorCodeNoSession = 1003,
+    AmaryllisInvalidArgument = 1004
+};
+
+#endif /* Header_h */

package/ios/Amaryllis.m

@@ -0,0 +1,201 @@
+//
+//  Amaryllis.m
+//  Amaryllis
+//
+//  Created by Ryan Jennings on 2025-09-05.
+//
+
+#import <Foundation/Foundation.h>
+#import <MediaPipeTasksGenAI/MediaPipeTasksGenAI.h>
+#import "Amaryllis.h"
+
+NSString *const PARAM_IMAGES = @"images";
+NSString *const PARAM_PROMPT = @"prompt";
+NSString *const PARAM_MAX_TOP_K = @"maxTopK";
+NSString *const PARAM_MAX_TOKENS = @"maxTokens";
+NSString *const PARAM_MAX_NUM_IMAGES = @"maxNumImages";
+NSString *const PARAM_VISION_ENCODER = @"visionEncoderPath";
+NSString *const PARAM_VISION_ADAPTER = @"visionAdapterPath";
+NSString *const PARAM_MODEL_PATH = @"modelPath";
+NSString *const PARAM_TEMPERATURE = @"temperature";
+NSString *const PARAM_RANDOM_SEED = @"randomSeed";
+NSString *const PARAM_LORA_PATH = @"loraPath";
+NSString *const PARAM_TOP_K = @"topK";
+NSString *const PARAM_TOP_P = @"topP";
+NSString *const PARAM_ENABLE_VISION = @"enableVisionModality";
+
+NSString *const AmaryllisErrorDomain = @"com.example.amaryllis";
+
+static NSString *const ERR_NOT_INITIALIZED = @"please initialize the SDK first";
+static NSString *const ERR_INVALID_ARGUMENT = @"invalid argument provided";
+static NSString *const ERR_NO_SESSION = @"new session required";
+
+@interface Amaryllis ()
+
+@property(nonatomic, strong) MPPLLMInference *llmInference;
+@property(nonatomic, strong) MPPLLMInferenceSession *session;
+
+@end
+
+@implementation Amaryllis
+
+- (void) initWithParams: (NSDictionary*) params error: (NSError**) error {
+
+  NSString *modelPath = params[PARAM_MODEL_PATH];
+
+  MPPLLMInferenceOptions *taskOptions = [[MPPLLMInferenceOptions alloc]
+                                         initWithModelPath:modelPath];
+  taskOptions.maxTopk = [params[PARAM_MAX_TOP_K] intValue];
+  taskOptions.maxTokens = [params[PARAM_MAX_TOKENS] intValue];
+  taskOptions.maxImages = [params[PARAM_MAX_NUM_IMAGES] intValue];
+  taskOptions.visionAdapterPath = params[PARAM_VISION_ADAPTER];
+  taskOptions.visionEncoderPath = params[PARAM_VISION_ENCODER];
+
+  NSLog(@"Initializing llm inference");
+
+  self.llmInference = [[MPPLLMInference alloc] initWithOptions:taskOptions
+                                                         error:error];
+}
+
+- (void) newSessionWithParams: (NSDictionary *) params error: (NSError **) error {
+  if (![self validateInitialized:error]) {
+    return;
+  }
+
+  MPPLLMInferenceSessionOptions *sessionOptions =
+      [[MPPLLMInferenceSessionOptions alloc] init];
+  sessionOptions.topk = [params[PARAM_TOP_K] intValue];
+  sessionOptions.topp = [params[PARAM_TOP_P] floatValue];
+  sessionOptions.temperature = [params[PARAM_TEMPERATURE] floatValue];
+  sessionOptions.loraPath = params[PARAM_LORA_PATH];
+  sessionOptions.randomSeed = [params[PARAM_RANDOM_SEED] intValue];
+  sessionOptions.enableVisionModality =
+      [params[PARAM_ENABLE_VISION] boolValue];
+
+  NSLog(@"starting new session");
+
+  self.session =
+      [[MPPLLMInferenceSession alloc] initWithLlmInference:self.llmInference
+                                                   options:sessionOptions
+                                                     error:error];
+}
+
+- (NSString *) generateWithParams: (NSDictionary *) params error: (NSError **) error {
+
+  if (![self validateInitialized:error]) {
+    return nil;
+  }
+
+  if (self.session) {
+    if (![self updateSessionFromParams:params error:error]) {
+      return nil;
+    }
+
+    return [self.session generateResponseAndReturnError:error];
+  }
+
+  if (![self validateNoSession:params error:error]) {
+    return nil;
+  }
+
+  return [self.llmInference generateResponseWithInputText:params[PARAM_PROMPT] error:error];
+}
+
+- (void) generateAsyncWithParams: (NSDictionary *) params error: (NSError **) error response: (PartialResponseHandler) progress completion: (CompletionHandler) completion {
+
+  if (![self validateInitialized:error]) {
+    return;
+  }
+
+  if (self.session) {
+
+    if (![self updateSessionFromParams:params error:error]) {
+      return;
+    }
+
+    [self.session generateResponseAsyncAndReturnError:error
+                                             progress:progress
+                                           completion:completion];
+
+  } else {
+
+    if (![self validateNoSession:params error:error]) {
+      return;
+    }
+
+    [self.llmInference generateResponseAsyncWithInputText:params[PARAM_PROMPT]
+                                                    error:error
+                                                 progress:progress
+                                               completion:completion];
+  }
+}
+
+- (void) close {
+  self.session = nil;
+  self.llmInference = nil;
+}
+
+#pragma mark - Helpers
+
+- (BOOL)updateSessionFromParams:(NSDictionary *)params error: (NSError **) error {
+
+  NSString *prompt = params ? params[PARAM_PROMPT] : nil;
+  NSArray *images = params ? params[PARAM_IMAGES] : nil;
+
+  if (!prompt && !images) {
+    *error = [NSError errorWithDomain:AmaryllisErrorDomain code:AmaryllisInvalidArgument userInfo:@{NSLocalizedDescriptionKey: ERR_INVALID_ARGUMENT}];
+    return NO;
+  }
+
+  [self.session addQueryChunkWithInputText:prompt error:error];
+
+  if (error) return NO;
+
+  if (images) {
+    for (NSString *path in images) {
+      CGImageRef image = [self imageFromPath:path];
+      [self.session addImageWithImage:image error:error];
+      CGImageRelease(image);
+      if (error) {
+        return NO;
+      }
+    }
+  }
+  return YES;
+}
+
+- (BOOL)validateNoSession:(NSDictionary *)params
+                    error: (NSError **) error {
+  if (params && params[PARAM_IMAGES]) {
+    *error = [NSError errorWithDomain:AmaryllisErrorDomain code:AmaryllisErrorCodeNoSession userInfo:@{NSLocalizedDescriptionKey: ERR_NO_SESSION}];
+    return NO;
+  }
+  return YES;
+}
+
+- (CGImageRef)imageFromPath:(NSString *)path {
+  UIImage *uiImage = [UIImage imageWithContentsOfFile:path];
+  if (!uiImage)
+    return nil;
+
+  // Resize to 512x512 if necessary
+  CGSize targetSize = CGSizeMake(512, 512);
+  UIGraphicsBeginImageContextWithOptions(targetSize, NO, 1.0);
+  [uiImage drawInRect:CGRectMake(0, 0, targetSize.width, targetSize.height)];
+  UIImage *resized = UIGraphicsGetImageFromCurrentImageContext();
+  UIGraphicsEndImageContext();
+
+  // Convert to MLImage
+  return CGImageRetain(resized.CGImage);
+}
+
+- (BOOL) validateInitialized: (NSError**) error {
+  if (self.llmInference == nil) {
+    *error = [NSError errorWithDomain:AmaryllisErrorDomain
+                                code:AmaryllisErrorCodeNotInitialized
+                            userInfo:@{NSLocalizedDescriptionKey: ERR_NOT_INITIALIZED}];
+    return NO;
+  }
+  return YES;
+}
+@end

package/ios/AmaryllisModule.h

@@ -0,0 +1,6 @@
+#import <AmaryllisSpec/AmaryllisSpec.h>
+#import <React/RCTEventEmitter.h>
+
+@interface AmaryllisModule : RCTEventEmitter <NativeAmaryllisSpec>
+
+@end

package/ios/AmaryllisModule.mm

@@ -0,0 +1,166 @@
+#import "AmaryllisModule.h"
+#import "Amaryllis.h"
+#import <ReactCommon/RCTTurboModule.h>
+
+static NSString *const EVENT_ON_PARTIAL_RESULT = @"onPartialResult";
+static NSString *const EVENT_ON_FINAL_RESULT = @"onFinalResult";
+static NSString *const EVENT_ON_ERROR = @"onError";
+static NSString *const ERROR_CODE_INFER = @"ERR_INFER";
+static NSString *const ERROR_CODE_SESSION = @"ERR_SESSION";
+
+@interface AmaryllisModule ()
+
+@property(nonatomic, strong) Amaryllis *amaryllis;
+
+@end
+
+@implementation AmaryllisModule
+
+RCT_EXPORT_MODULE(Amaryllis)
+
+- (instancetype) init {
+  self = [super init];
+  self.amaryllis = [[Amaryllis alloc] init];
+  return self;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeAmaryllisSpecJSI>(params);
+}
+#pragma mark - Event Emitter
+
+- (NSArray *)supportedEvents {
+  return @[ EVENT_ON_PARTIAL_RESULT, EVENT_ON_FINAL_RESULT, EVENT_ON_ERROR ];
+}
+
+#pragma mark - Configure Engine
+
+- (void)init:(nonnull NSDictionary *)config
+       resolve:(nonnull RCTPromiseResolveBlock)resolve
+        reject:(nonnull RCTPromiseRejectBlock)reject {
+  NSError *error = nil;
+  
+  @try {
+   
+    [self.amaryllis initWithParams:config error:&error];
+
+    if (error) {
+      reject(ERROR_CODE_INFER, @"unable to initialize inference", error);
+      return;
+    }
+
+    resolve(nil);
+  } @catch (NSException *exception) {
+    NSLog(@"Amaryllis: error initializing (%@)", exception.description);
+    reject(ERROR_CODE_INFER, @"unable to configure", nil);
+  }
+}
+
+- (void)newSession:(NSDictionary *)params
+           resolve:(nonnull RCTPromiseResolveBlock)resolve
+            reject:(nonnull RCTPromiseRejectBlock)reject {
+  NSError *error = nil;
+  
+  @try {
+    
+    [self.amaryllis newSessionWithParams: params error: &error];
+    
+    if (error) {
+      reject(ERROR_CODE_INFER, @"unable to initialize inference", error);
+      return;
+    }
+
+    resolve(nil);
+  } @catch (NSException *exception) {
+    NSLog(@"Amaryllis: error create new session (%@)", exception.description);
+    [self sendEventWithName:EVENT_ON_ERROR body:nil];
+    reject(ERROR_CODE_SESSION, @"unable to create session", nil);
+  }
+}
+
+#pragma mark - Generate Sync
+
+- (void)generate:(nonnull NSDictionary *)params
+         resolve:(nonnull RCTPromiseResolveBlock)resolve
+          reject:(nonnull RCTPromiseRejectBlock)reject {
+  @try {
+    NSError *error = nil;
+    NSString *result = [self.amaryllis generateWithParams: params error:&error];
+
+    if (error) {
+      reject(ERROR_CODE_INFER, @"unable to generate response", error);
+      return;
+    }
+    resolve(result);
+  } @catch (NSException *exception) {
+    NSLog(@"Amaryllis: error generating inference (%@)", exception.description);
+    reject(ERROR_CODE_INFER, @"unable to generate response", nil);
+  }
+}
+
+#pragma mark - Generate Async
+
+- (void)generateAsync:(nonnull NSDictionary *)params
+              resolve:(nonnull RCTPromiseResolveBlock)resolve
+               reject:(nonnull RCTPromiseRejectBlock)reject {
+  @try {
+    NSError *error = nil;
+
+    PartialResponseHandler progress = ^(NSString *result, NSError *err) {
+      if (!err) {
+        [self sendEventWithName:EVENT_ON_PARTIAL_RESULT body:result];
+      } else {
+        [self sendEventWithName:EVENT_ON_ERROR body:err];
+      }
+    };
+
+    CompletionHandler completion = ^{
+      [self sendEventWithName:EVENT_ON_FINAL_RESULT body:nil];
+    };
+
+    [self.amaryllis generateAsyncWithParams:params error:&error response:progress completion:completion];
+    
+    resolve(nil);
+  } @catch (NSException *exception) {
+    NSLog(@"Amaryllis: error generating inference (%@)", exception.description);
+    [self sendEventWithName:EVENT_ON_ERROR body:nil];
+    reject(ERROR_CODE_INFER, @"unable to generate response", nil);
+  }
+}
+
+#pragma mark - Close Engine
+
+- (void) close {
+  [self.amaryllis close];
+}
+
+- (void) cancelAsync {}
+
+- (NSDictionary *)constantsToExport {
+  return @{
+    @"EVENT_ON_PARTIAL_RESULT" : EVENT_ON_PARTIAL_RESULT,
+    @"EVENT_ON_FINAL_RESULT" : EVENT_ON_FINAL_RESULT,
+    @"EVENT_ON_ERROR" : EVENT_ON_ERROR,
+    // errors
+    @"ERROR_CODE_INFER" : ERROR_CODE_INFER,
+    @"ERROR_CODE_SESSION" : ERROR_CODE_SESSION,
+    // params
+    @"PARAM_IMAGES" : PARAM_IMAGES,
+    @"PARAM_PROMPT" : PARAM_PROMPT,
+    @"PARAM_MAX_TOP_K" : PARAM_MAX_TOP_K,
+    @"PARAM_MAX_TOKENS" : PARAM_MAX_TOKENS,
+    @"PARAM_MAX_NUM_IMAGES" : PARAM_MAX_NUM_IMAGES,
+    @"PARAM_VISION_ENCODER" : PARAM_VISION_ENCODER,
+    @"PARAM_VISION_ADAPTER" : PARAM_VISION_ADAPTER,
+    @"PARAM_MODEL_PATH" : PARAM_MODEL_PATH,
+    @"PARAM_TEMPERATURE" : PARAM_TEMPERATURE,
+    @"PARAM_RANDOM_SEED" : PARAM_RANDOM_SEED,
+    @"PARAM_LORA_PATH" : PARAM_LORA_PATH,
+    @"PARAM_TOP_K" : PARAM_TOP_K,
+    @"PARAM_TOP_P" : PARAM_TOP_P,
+    @"PARAM_ENABLE_VISION" : PARAM_ENABLE_VISION,
+  };
+}
+
+@end

package/lib/module/Amaryllis.js

@@ -0,0 +1,56 @@
+"use strict";
+
+const EVENT_ON_PARTIAL_RESULT = 'onPartialResult';
+const EVENT_ON_FINAL_RESULT = 'onFinalResult';
+const EVENT_ON_ERROR = 'onError';
+export class LlmPipe {
+  subscriptions = [];
+  constructor(params) {
+    this.llmNative = params.nativeModule;
+    this.llmEmitter = params.eventEmitter;
+  }
+  async init(params) {
+    await this.llmNative.init(params);
+  }
+  newSession(params) {
+    return this.llmNative.newSession(params);
+  }
+  async generate(params) {
+    return await this.llmNative.generate(params);
+  }
+  async generateAsync(params, callbacks) {
+    if (callbacks) {
+      this.setupAsyncCallbacks(callbacks);
+    }
+    return await this.llmNative.generateAsync(params);
+  }
+  close() {
+    this.llmNative.close();
+    this.cancelAsync();
+  }
+  cancelAsync() {
+    this.llmNative.cancelAsync();
+    this.subscriptions.forEach(sub => sub.remove());
+  }
+  setupAsyncCallbacks(callbacks) {
+    if (callbacks.onPartialResult) {
+      this.subscriptions.push(this.llmEmitter.addListener(EVENT_ON_PARTIAL_RESULT, result => {
+        callbacks.onPartialResult?.(result);
+      }));
+    }
+    if (callbacks.onFinalResult) {
+      this.subscriptions.push(this.llmEmitter.addListener(EVENT_ON_FINAL_RESULT, result => {
+        callbacks.onFinalResult?.(result);
+        this.cancelAsync();
+      }));
+    }
+    if (callbacks.onError) {
+      this.subscriptions.push(this.llmEmitter.addListener(EVENT_ON_ERROR, error => {
+        callbacks.onError?.(new Error(error));
+        this.cancelAsync();
+      }));
+    }
+  }
+}
+export default LlmPipe;
+//# sourceMappingURL=Amaryllis.js.map

package/lib/module/Amaryllis.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EVENT_ON_PARTIAL_RESULT","EVENT_ON_FINAL_RESULT","EVENT_ON_ERROR","LlmPipe","subscriptions","constructor","params","llmNative","nativeModule","llmEmitter","eventEmitter","init","newSession","generate","generateAsync","callbacks","setupAsyncCallbacks","close","cancelAsync","forEach","sub","remove","onPartialResult","push","addListener","result","onFinalResult","onError","error","Error"],"sourceRoot":"../../src","sources":["Amaryllis.ts"],"mappings":";;AAYA,MAAMA,uBAAuB,GAAG,iBAAiB;AACjD,MAAMC,qBAAqB,GAAG,eAAe;AAC7C,MAAMC,cAAc,GAAG,SAAS;AAEhC,OAAO,MAAMC,OAAO,CAAsB;EACxCC,aAAa,GAA2B,EAAE;EAI1CC,WAAWA,CAACC,MAAqB,EAAE;IACjC,IAAI,CAACC,SAAS,GAAGD,MAAM,CAACE,YAAY;IACpC,IAAI,CAACC,UAAU,GAAGH,MAAM,CAACI,YAAY;EACvC;EAEA,MAAMC,IAAIA,CAACL,MAAuB,EAAiB;IACjD,MAAM,IAAI,CAACC,SAAS,CAACI,IAAI,CAACL,MAAM,CAAC;EACnC;EAEAM,UAAUA,CAACN,MAAwB,EAAiB;IAClD,OAAO,IAAI,CAACC,SAAS,CAACK,UAAU,CAACN,MAAM,CAAC;EAC1C;EAEA,MAAMO,QAAQA,CAACP,MAAwB,EAAmB;IACxD,OAAO,MAAM,IAAI,CAACC,SAAS,CAACM,QAAQ,CAACP,MAAM,CAAC;EAC9C;EAEA,MAAMQ,aAAaA,CACjBR,MAAwB,EACxBS,SAAwB,EACT;IACf,IAAIA,SAAS,EAAE;MACb,IAAI,CAACC,mBAAmB,CAACD,SAAS,CAAC;IACrC;IAEA,OAAO,MAAM,IAAI,CAACR,SAAS,CAACO,aAAa,CAACR,MAAM,CAAC;EACnD;EAEAW,KAAKA,CAAA,EAAS;IACZ,IAAI,CAACV,SAAS,CAACU,KAAK,CAAC,CAAC;IACtB,IAAI,CAACC,WAAW,CAAC,CAAC;EACpB;EAEAA,WAAWA,CAAA,EAAS;IAClB,IAAI,CAACX,SAAS,CAACW,WAAW,CAAC,CAAC;IAC5B,IAAI,CAACd,aAAa,CAACe,OAAO,CAAEC,GAAG,IAAKA,GAAG,CAACC,MAAM,CAAC,CAAC,CAAC;EACnD;EAEAL,mBAAmBA,CAACD,SAAuB,EAAQ;IACjD,IAAIA,SAAS,CAACO,eAAe,EAAE;MAC7B,IAAI,CAAClB,aAAa,CAACmB,IAAI,CACrB,IAAI,CAACd,UAAU,CAACe,WAAW,CACzBxB,uBAAuB,EACtByB,MAAc,IAAK;QAClBV,SAAS,CAACO,eAAe,GAAGG,MAAM,CAAC;MACrC,CACF,CACF,CAAC;IACH;IAEA,IAAIV,SAAS,CAACW,aAAa,EAAE;MAC3B,IAAI,CAACtB,aAAa,CAACmB,IAAI,CACrB,IAAI,CAACd,UAAU,CAACe,WAAW,CAACvB,qBAAqB,EAAGwB,MAAc,IAAK;QACrEV,SAAS,CAACW,aAAa,GAAGD,MAAM,CAAC;QACjC,IAAI,CAACP,WAAW,CAAC,CAAC;MACpB,CAAC,CACH,CAAC;IACH;IACA,IAAIH,SAAS,CAACY,OAAO,EAAE;MACrB,IAAI,CAACvB,aAAa,CAACmB,IAAI,CACrB,IAAI,CAACd,UAAU,CAACe,WAAW,CAACtB,cAAc,EAAG0B,KAAa,IAAK;QAC7Db,SAAS,CAACY,OAAO,GAAG,IAAIE,KAAK,CAACD,KAAK,CAAC,CAAC;QACrC,IAAI,CAACV,WAAW,CAAC,CAAC;MACpB,CAAC,CACH,CAAC;IACH;EACF;AACF;AAEA,eAAef,OAAO","ignoreList":[]}