@runanywhere/core 0.17.7 → 0.18.0

package/ios/PlatformAdapterBridge.m

@@ -7,6 +7,7 @@
 
 #import <Foundation/Foundation.h>
 #import <UIKit/UIKit.h>
+#import "PlatformDownloadBridge.h"
 
 // Import the generated Swift header from the pod
 #if __has_include(<RunAnywhereCore/RunAnywhereCore-Swift.h>)
@@ -29,6 +30,206 @@
 @end
 #endif
 
+// =============================================================================
+// HTTP Download (Platform Adapter)
+// =============================================================================
+
+static const int RAC_SUCCESS = 0;
+static const int RAC_ERROR_INVALID_PARAMETER = -106;
+static const int RAC_ERROR_DOWNLOAD_FAILED = -153;
+static const int RAC_ERROR_CANCELLED = -380;
+
+@interface RunAnywhereHttpDownloadTaskInfo : NSObject
+@property(nonatomic, copy) NSString* taskId;
+@property(nonatomic, copy) NSString* destinationPath;
+@property(nonatomic, assign) BOOL cancelled;
+@end
+
+@implementation RunAnywhereHttpDownloadTaskInfo
+@end
+
+@interface RunAnywhereHttpDownloadManager : NSObject <NSURLSessionDownloadDelegate>
+@property(nonatomic, strong) NSURLSession* session;
+@property(nonatomic, strong) NSMutableDictionary<NSNumber*, RunAnywhereHttpDownloadTaskInfo*>* taskInfoByIdentifier;
+@property(nonatomic, strong) NSMutableDictionary<NSString*, NSURLSessionDownloadTask*>* taskById;
+@property(nonatomic, strong) NSMutableDictionary<NSString*, NSString*>* completedPathById;
++ (instancetype)shared;
+- (int)startDownload:(NSString*)url destination:(NSString*)destination taskId:(NSString*)taskId;
+- (BOOL)cancelDownload:(NSString*)taskId;
+@end
+
+@implementation RunAnywhereHttpDownloadManager
+
++ (instancetype)shared {
+    static RunAnywhereHttpDownloadManager* instance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [[RunAnywhereHttpDownloadManager alloc] init];
+    });
+    return instance;
+}
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        NSURLSessionConfiguration* config = [NSURLSessionConfiguration defaultSessionConfiguration];
+        NSOperationQueue* queue = [[NSOperationQueue alloc] init];
+        queue.maxConcurrentOperationCount = 4;
+        _session = [NSURLSession sessionWithConfiguration:config delegate:self delegateQueue:queue];
+        _taskInfoByIdentifier = [NSMutableDictionary dictionary];
+        _taskById = [NSMutableDictionary dictionary];
+        _completedPathById = [NSMutableDictionary dictionary];
+    }
+    return self;
+}
+
+- (int)startDownload:(NSString*)url destination:(NSString*)destination taskId:(NSString*)taskId {
+    if (url.length == 0 || destination.length == 0 || taskId.length == 0) {
+        return RAC_ERROR_INVALID_PARAMETER;
+    }
+
+    NSURL* downloadURL = [NSURL URLWithString:url];
+    if (!downloadURL) {
+        return RAC_ERROR_INVALID_PARAMETER;
+    }
+
+    NSURLSessionDownloadTask* task = [self.session downloadTaskWithURL:downloadURL];
+    RunAnywhereHttpDownloadTaskInfo* info = [[RunAnywhereHttpDownloadTaskInfo alloc] init];
+    info.taskId = taskId;
+    info.destinationPath = destination;
+    info.cancelled = NO;
+
+    @synchronized (self) {
+        self.taskInfoByIdentifier[@(task.taskIdentifier)] = info;
+        self.taskById[taskId] = task;
+    }
+
+    [task resume];
+    return RAC_SUCCESS;
+}
+
+- (BOOL)cancelDownload:(NSString*)taskId {
+    if (taskId.length == 0) {
+        return NO;
+    }
+
+    NSURLSessionDownloadTask* task = nil;
+    @synchronized (self) {
+        task = self.taskById[taskId];
+        if (task) {
+            RunAnywhereHttpDownloadTaskInfo* info = self.taskInfoByIdentifier[@(task.taskIdentifier)];
+            if (info) {
+                info.cancelled = YES;
+            }
+        }
+    }
+
+    if (!task) {
+        return NO;
+    }
+
+    [task cancel];
+    return YES;
+}
+
+#pragma mark - NSURLSessionDownloadDelegate
+
+- (void)URLSession:(NSURLSession*)session
+      downloadTask:(NSURLSessionDownloadTask*)downloadTask
+ didWriteData:(int64_t)bytesWritten
+ totalBytesWritten:(int64_t)totalBytesWritten
+totalBytesExpectedToWrite:(int64_t)totalBytesExpectedToWrite {
+    (void)session;
+    RunAnywhereHttpDownloadTaskInfo* info = nil;
+    @synchronized (self) {
+        info = self.taskInfoByIdentifier[@(downloadTask.taskIdentifier)];
+    }
+    if (!info) {
+        return;
+    }
+    RunAnywhereHttpDownloadReportProgress(
+        info.taskId.UTF8String,
+        totalBytesWritten,
+        totalBytesExpectedToWrite > 0 ? totalBytesExpectedToWrite : 0
+    );
+}
+
+- (void)URLSession:(NSURLSession*)session
+      downloadTask:(NSURLSessionDownloadTask*)downloadTask
+didFinishDownloadingToURL:(NSURL*)location {
+    (void)session;
+    RunAnywhereHttpDownloadTaskInfo* info = nil;
+    @synchronized (self) {
+        info = self.taskInfoByIdentifier[@(downloadTask.taskIdentifier)];
+    }
+    if (!info) {
+        return;
+    }
+
+    NSString* destination = info.destinationPath;
+    NSString* destinationDir = [destination stringByDeletingLastPathComponent];
+    NSError* error = nil;
+    [[NSFileManager defaultManager] createDirectoryAtPath:destinationDir
+                              withIntermediateDirectories:YES
+                                               attributes:nil
+                                                    error:&error];
+    if (error) {
+        return;
+    }
+
+    if ([[NSFileManager defaultManager] fileExistsAtPath:destination]) {
+        [[NSFileManager defaultManager] removeItemAtPath:destination error:nil];
+    }
+
+    if ([[NSFileManager defaultManager] moveItemAtURL:location
+                                                toURL:[NSURL fileURLWithPath:destination]
+                                                error:&error]) {
+        @synchronized (self) {
+            self.completedPathById[info.taskId] = destination;
+        }
+    }
+}
+
+- (void)URLSession:(NSURLSession*)session
+              task:(NSURLSessionTask*)task
+didCompleteWithError:(NSError*)error {
+    (void)session;
+    RunAnywhereHttpDownloadTaskInfo* info = nil;
+    NSString* completedPath = nil;
+
+    @synchronized (self) {
+        info = self.taskInfoByIdentifier[@(task.taskIdentifier)];
+        if (info) {
+            [self.taskInfoByIdentifier removeObjectForKey:@(task.taskIdentifier)];
+            [self.taskById removeObjectForKey:info.taskId];
+            completedPath = self.completedPathById[info.taskId];
+            if (completedPath) {
+                [self.completedPathById removeObjectForKey:info.taskId];
+            }
+        }
+    }
+
+    if (!info) {
+        return;
+    }
+
+    int result = RAC_SUCCESS;
+    if (error) {
+        if (info.cancelled || error.code == NSURLErrorCancelled) {
+            result = RAC_ERROR_CANCELLED;
+        } else {
+            result = RAC_ERROR_DOWNLOAD_FAILED;
+        }
+    } else if (!completedPath) {
+        result = RAC_ERROR_DOWNLOAD_FAILED;
+    }
+
+    const char* pathCString = completedPath ? completedPath.UTF8String : NULL;
+    RunAnywhereHttpDownloadReportComplete(info.taskId.UTF8String, result, pathCString);
+}
+
+@end
+
 // ============================================================================
 // Secure Storage (Keychain)
 // ============================================================================
@@ -568,3 +769,45 @@ bool PlatformAdapter_httpPostSync(
     }
 }
 
+// ============================================================================
+// HTTP Download (Async)
+// ============================================================================
+
+int PlatformAdapter_httpDownload(
+    const char* url,
+    const char* destinationPath,
+    const char* taskId
+) {
+    @autoreleasepool {
+        if (!url || !destinationPath || !taskId) {
+            return RAC_ERROR_INVALID_PARAMETER;
+        }
+
+        NSString* urlStr = [NSString stringWithUTF8String:url];
+        NSString* destStr = [NSString stringWithUTF8String:destinationPath];
+        NSString* taskStr = [NSString stringWithUTF8String:taskId];
+
+        if (!urlStr || !destStr || !taskStr) {
+            return RAC_ERROR_INVALID_PARAMETER;
+        }
+
+        return [[RunAnywhereHttpDownloadManager shared] startDownload:urlStr
+                                                          destination:destStr
+                                                               taskId:taskStr];
+    }
+}
+
+bool PlatformAdapter_httpDownloadCancel(const char* taskId) {
+    @autoreleasepool {
+        if (!taskId) {
+            return false;
+        }
+
+        NSString* taskStr = [NSString stringWithUTF8String:taskId];
+        if (!taskStr) {
+            return false;
+        }
+
+        return [[RunAnywhereHttpDownloadManager shared] cancelDownload:taskStr];
+    }
+}

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

@@ -86,6 +86,10 @@ namespace margelo::nitro::runanywhere {
       prototype.registerHybridMethod("voiceAgentGenerateResponse", &HybridRunAnywhereCoreSpec::voiceAgentGenerateResponse);
       prototype.registerHybridMethod("voiceAgentSynthesizeSpeech", &HybridRunAnywhereCoreSpec::voiceAgentSynthesizeSpeech);
       prototype.registerHybridMethod("cleanupVoiceAgent", &HybridRunAnywhereCoreSpec::cleanupVoiceAgent);
+      prototype.registerHybridMethod("parseToolCallFromOutput", &HybridRunAnywhereCoreSpec::parseToolCallFromOutput);
+      prototype.registerHybridMethod("formatToolsForPrompt", &HybridRunAnywhereCoreSpec::formatToolsForPrompt);
+      prototype.registerHybridMethod("buildInitialPrompt", &HybridRunAnywhereCoreSpec::buildInitialPrompt);
+      prototype.registerHybridMethod("buildFollowupPrompt", &HybridRunAnywhereCoreSpec::buildFollowupPrompt);
     });
   }
 

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

@@ -125,6 +125,10 @@ namespace margelo::nitro::runanywhere {
       virtual std::shared_ptr<Promise<std::string>> voiceAgentGenerateResponse(const std::string& prompt) = 0;
       virtual std::shared_ptr<Promise<std::string>> voiceAgentSynthesizeSpeech(const std::string& text) = 0;
       virtual std::shared_ptr<Promise<void>> cleanupVoiceAgent() = 0;
+      virtual std::shared_ptr<Promise<std::string>> parseToolCallFromOutput(const std::string& llmOutput) = 0;
+      virtual std::shared_ptr<Promise<std::string>> formatToolsForPrompt(const std::string& toolsJson, const std::string& format) = 0;
+      virtual std::shared_ptr<Promise<std::string>> buildInitialPrompt(const std::string& userPrompt, const std::string& toolsJson, const std::string& optionsJson) = 0;
+      virtual std::shared_ptr<Promise<std::string>> buildFollowupPrompt(const std::string& originalPrompt, const std::string& toolsPrompt, const std::string& toolName, const std::string& resultJson, bool keepToolsAvailable) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runanywhere/core",
-  "version": "0.17.7",
+  "version": "0.18.0",
   "description": "Core SDK for RunAnywhere React Native - includes RACommons bindings, native bridges, and public API",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -18,7 +18,11 @@
     "src",
     "cpp",
     "ios",
-    "android",
+    "!ios/build",
+    "android/src",
+    "android/build.gradle",
+    "android/CMakeLists.txt",
+    "android/consumer-rules.pro",
     "nitrogen",
     "nitro.json",
     "react-native.config.js",
@@ -67,8 +71,8 @@
   },
   "devDependencies": {
     "@types/react": "~19.1.0",
-    "nitrogen": "^0.33.2",
-    "react-native-nitro-modules": "0.33.2",
+    "nitrogen": "^0.31.10",
+    "react-native-nitro-modules": "^0.31.10",
     "typescript": "~5.9.2"
   },
   "create-react-native-library": {

package/src/Foundation/Security/SecureStorageService.ts

@@ -25,10 +25,9 @@ import type { SDKEnvironment } from '../../types';
  * These methods are optional and may not be available on all platforms
  */
 interface SecureStorageNativeModule {
-  secureStorageIsAvailable?: () => Promise<boolean>;
-  secureStorageStore?: (key: string, value: string) => Promise<void>;
-  secureStorageRetrieve?: (key: string) => Promise<string | null>;
-  secureStorageDelete?: (key: string) => Promise<void>;
+  secureStorageSet?: (key: string, value: string) => Promise<boolean>;
+  secureStorageGet?: (key: string) => Promise<string | null>;
+  secureStorageDelete?: (key: string) => Promise<boolean>;
   secureStorageExists?: (key: string) => Promise<boolean>;
 }
 
@@ -92,6 +91,9 @@ class SecureStorageServiceImpl {
       const native = requireNativeModule() as unknown as SecureStorageNativeModule;
 
       // Use the new native method
+      if (!native.secureStorageSet) {
+        throw new Error('secureStorageSet is not available on this platform');
+      }
       const success = await native.secureStorageSet(key, value);
 
       if (!success) {
@@ -130,6 +132,9 @@ class SecureStorageServiceImpl {
       const native = requireNativeModule() as unknown as SecureStorageNativeModule;
 
       // Use the new native method
+      if (!native.secureStorageGet) {
+        throw new Error('secureStorageGet is not available on this platform');
+      }
       const value = await native.secureStorageGet(key);
 
       if (value !== null && value !== undefined) {
@@ -163,7 +168,7 @@ class SecureStorageServiceImpl {
       const native = requireNativeModule() as unknown as SecureStorageNativeModule;
 
       // Use the new native method
-      await native.secureStorageDelete(key);
+      await native.secureStorageDelete?.(key);
 
       // Remove from cache
       this.cache.delete(key);
@@ -199,7 +204,8 @@ class SecureStorageServiceImpl {
       const native = requireNativeModule() as unknown as SecureStorageNativeModule;
 
       // Use the new native method
-      return await native.secureStorageExists(key);
+      const result = await native.secureStorageExists?.(key);
+      return result ?? false;
     } catch {
       return false;
     }

package/src/Public/Extensions/RunAnywhere+Models.ts

@@ -217,9 +217,11 @@ export async function registerModel(options: {
     id: options.id ?? generateModelId(options.url),
     name: options.name,
     category: options.category ?? ModelCategory.Language,
-    format: options.url.includes('.gguf')
-      ? ModelFormat.GGUF
-      : ModelFormat.GGUF,
+    format: options.url.includes('.zip')
+      ? ModelFormat.Zip
+      : options.url.includes('.gguf')
+        ? ModelFormat.GGUF
+        : ModelFormat.GGUF,
     downloadURL: options.url,
     localPath: undefined,
     downloadSize: undefined,

package/src/Public/Extensions/RunAnywhere+STT.ts

@@ -124,6 +124,9 @@ export async function transcribe(
 
   try {
     const result = JSON.parse(resultJson);
+    if (result.error) {
+      throw new Error(result.error);
+    }
     return {
       text: result.text ?? '',
       segments: result.segments ?? [],
@@ -132,9 +135,11 @@ export async function transcribe(
       duration: result.duration ?? 0,
       alternatives: result.alternatives ?? [],
     };
-  } catch {
+  } catch (err) {
+    if (err instanceof Error) throw err;
     if (resultJson.includes('error')) {
-      throw new Error(resultJson);
+      const errorMatch = resultJson.match(/"error":\s*"([^"]+)"/);
+      throw new Error(errorMatch ? errorMatch[1] : resultJson);
     }
     return {
       text: resultJson,