@runanywhere/core 0.17.8 → 0.18.0

package/cpp/bridges/InitBridge.cpp

@@ -7,13 +7,16 @@
  */
 
 #include "InitBridge.hpp"
+#include "PlatformDownloadBridge.h"
 #include "rac_model_paths.h"
 #include "rac_environment.h"  // For rac_sdk_init, rac_sdk_config_t
 #include <cstring>
 #include <cstdlib>
 #include <chrono>
+#include <atomic>
 #include <mutex>
 #include <tuple>
+#include <unordered_map>
 
 // Platform-specific logging and bridges
 #if defined(ANDROID) || defined(__ANDROID__)
@@ -48,6 +51,8 @@ extern jmethodID g_getCoreCountMethod;
 extern jmethodID g_getArchitectureMethod;
 extern jmethodID g_getGPUFamilyMethod;
 extern jmethodID g_isTabletMethod;
+extern jmethodID g_httpDownloadMethod;
+extern jmethodID g_httpDownloadCancelMethod;
 // HttpResponse field IDs
 extern jfieldID g_httpResponse_successField;
 extern jfieldID g_httpResponse_statusCodeField;
@@ -427,6 +432,62 @@ namespace AndroidBridge {
         jboolean result = env->CallStaticBooleanMethod(g_platformAdapterBridgeClass, g_isTabletMethod);
         return result == JNI_TRUE;
     }
+
+    rac_result_t httpDownload(const char* url, const char* destinationPath, const char* taskId) {
+        JNIEnv* env = getJNIEnv();
+        if (!env) return RAC_ERROR_NOT_SUPPORTED;
+
+        if (!g_platformAdapterBridgeClass || !g_httpDownloadMethod) {
+            LOGE("PlatformAdapterBridge class or httpDownload method not cached");
+            return RAC_ERROR_NOT_SUPPORTED;
+        }
+
+        jstring jUrl = env->NewStringUTF(url ? url : "");
+        jstring jDest = env->NewStringUTF(destinationPath ? destinationPath : "");
+        jstring jTaskId = env->NewStringUTF(taskId ? taskId : "");
+
+        jint result = env->CallStaticIntMethod(g_platformAdapterBridgeClass,
+                                               g_httpDownloadMethod,
+                                               jUrl,
+                                               jDest,
+                                               jTaskId);
+
+        env->DeleteLocalRef(jUrl);
+        env->DeleteLocalRef(jDest);
+        env->DeleteLocalRef(jTaskId);
+
+        if (env->ExceptionCheck()) {
+            env->ExceptionClear();
+            LOGE("Exception in httpDownload");
+            return RAC_ERROR_DOWNLOAD_FAILED;
+        }
+
+        return static_cast<rac_result_t>(result);
+    }
+
+    bool httpDownloadCancel(const char* taskId) {
+        JNIEnv* env = getJNIEnv();
+        if (!env) return false;
+
+        if (!g_platformAdapterBridgeClass || !g_httpDownloadCancelMethod) {
+            LOGE("PlatformAdapterBridge class or httpDownloadCancel method not cached");
+            return false;
+        }
+
+        jstring jTaskId = env->NewStringUTF(taskId ? taskId : "");
+        jboolean result = env->CallStaticBooleanMethod(g_platformAdapterBridgeClass,
+                                                       g_httpDownloadCancelMethod,
+                                                       jTaskId);
+        env->DeleteLocalRef(jTaskId);
+
+        if (env->ExceptionCheck()) {
+            env->ExceptionClear();
+            LOGE("Exception in httpDownloadCancel");
+            return false;
+        }
+
+        return result == JNI_TRUE;
+    }
 } // namespace AndroidBridge
 #elif defined(__APPLE__)
 #include <cstdio>
@@ -461,6 +522,14 @@ extern "C" {
         char** outResponseBody,
         char** outErrorMessage
     );
+
+    int PlatformAdapter_httpDownload(
+        const char* url,
+        const char* destinationPath,
+        const char* taskId
+    );
+
+    bool PlatformAdapter_httpDownloadCancel(const char* taskId);
 }
 #define LOGI(...) printf("[InitBridge] "); printf(__VA_ARGS__); printf("\n")
 #define LOGD(...) printf("[InitBridge DEBUG] "); printf(__VA_ARGS__); printf("\n")
@@ -483,6 +552,20 @@ namespace bridges {
 
 static PlatformCallbacks* g_platformCallbacks = nullptr;
 
+// =============================================================================
+// HTTP download callback state (platform adapter)
+// =============================================================================
+
+struct http_download_context {
+    rac_http_progress_callback_fn progress_callback;
+    rac_http_complete_callback_fn complete_callback;
+    void* user_data;
+};
+
+static std::mutex g_http_download_mutex;
+static std::unordered_map<std::string, http_download_context> g_http_downloads;
+static std::atomic<uint64_t> g_http_download_counter{0};
+
 // =============================================================================
 // C Callback Implementations (called by RACommons)
 // =============================================================================
@@ -702,6 +785,134 @@ static void platformTrackErrorCallback(const char* errorJson, void* userData) {
     }
 }
 
+// =============================================================================
+// HTTP Download Callbacks (Platform Adapter)
+// =============================================================================
+
+static int reportHttpDownloadProgressInternal(const char* task_id,
+                                              int64_t downloaded_bytes,
+                                              int64_t total_bytes) {
+    if (!task_id) {
+        return RAC_ERROR_INVALID_ARGUMENT;
+    }
+
+    std::lock_guard<std::mutex> lock(g_http_download_mutex);
+    auto it = g_http_downloads.find(task_id);
+    if (it == g_http_downloads.end()) {
+        return RAC_ERROR_NOT_FOUND;
+    }
+
+    if (it->second.progress_callback) {
+        it->second.progress_callback(downloaded_bytes, total_bytes, it->second.user_data);
+    }
+
+    return RAC_SUCCESS;
+}
+
+static int reportHttpDownloadCompleteInternal(const char* task_id,
+                                              int result,
+                                              const char* downloaded_path) {
+    if (!task_id) {
+        return RAC_ERROR_INVALID_ARGUMENT;
+    }
+
+    http_download_context ctx{};
+    {
+        std::lock_guard<std::mutex> lock(g_http_download_mutex);
+        auto it = g_http_downloads.find(task_id);
+        if (it == g_http_downloads.end()) {
+            return RAC_ERROR_NOT_FOUND;
+        }
+        ctx = it->second;
+        g_http_downloads.erase(it);
+    }
+
+    if (ctx.complete_callback) {
+        ctx.complete_callback(static_cast<rac_result_t>(result), downloaded_path, ctx.user_data);
+    }
+
+    return RAC_SUCCESS;
+}
+
+static rac_result_t platformHttpDownloadCallback(const char* url,
+                                                 const char* destination_path,
+                                                 rac_http_progress_callback_fn progress_callback,
+                                                 rac_http_complete_callback_fn complete_callback,
+                                                 void* callback_user_data,
+                                                 char** out_task_id,
+                                                 void* user_data) {
+    (void)user_data;
+
+    if (!url || !destination_path || !out_task_id) {
+        return RAC_ERROR_INVALID_ARGUMENT;
+    }
+
+    std::string task_id =
+        "http_" + std::to_string(g_http_download_counter.fetch_add(1, std::memory_order_relaxed));
+
+    *out_task_id = strdup(task_id.c_str());
+    if (!*out_task_id) {
+        return RAC_ERROR_OUT_OF_MEMORY;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(g_http_download_mutex);
+        g_http_downloads[task_id] = {progress_callback, complete_callback, callback_user_data};
+    }
+
+    rac_result_t start_result = RAC_ERROR_NOT_SUPPORTED;
+
+#if defined(ANDROID) || defined(__ANDROID__)
+    start_result = AndroidBridge::httpDownload(url, destination_path, task_id.c_str());
+#elif defined(__APPLE__)
+    start_result = static_cast<rac_result_t>(
+        PlatformAdapter_httpDownload(url, destination_path, task_id.c_str()));
+#endif
+
+    if (start_result != RAC_SUCCESS) {
+        http_download_context ctx{};
+        {
+            std::lock_guard<std::mutex> lock(g_http_download_mutex);
+            auto it = g_http_downloads.find(task_id);
+            if (it != g_http_downloads.end()) {
+                ctx = it->second;
+                g_http_downloads.erase(it);
+            }
+        }
+
+        if (ctx.complete_callback) {
+            ctx.complete_callback(start_result, nullptr, ctx.user_data);
+        }
+    }
+
+    return start_result;
+}
+
+static rac_result_t platformHttpDownloadCancelCallback(const char* task_id, void* user_data) {
+    (void)user_data;
+
+    if (!task_id) {
+        return RAC_ERROR_INVALID_ARGUMENT;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(g_http_download_mutex);
+        if (g_http_downloads.find(task_id) == g_http_downloads.end()) {
+            return RAC_ERROR_NOT_FOUND;
+        }
+    }
+
+    bool cancelled = false;
+
+#if defined(ANDROID) || defined(__ANDROID__)
+    cancelled = AndroidBridge::httpDownloadCancel(task_id);
+#elif defined(__APPLE__)
+    cancelled = PlatformAdapter_httpDownloadCancel(task_id);
+#endif
+
+    return cancelled ? RAC_SUCCESS : RAC_ERROR_CANCELLED;
+}
+
 // =============================================================================
 // InitBridge Implementation
 // =============================================================================
@@ -757,9 +968,9 @@ void InitBridge::registerPlatformAdapter() {
     // Error tracking
     adapter_.track_error = platformTrackErrorCallback;
 
-    // HTTP download (handled by JS layer)
-    adapter_.http_download = nullptr;
-    adapter_.http_download_cancel = nullptr;
+    // HTTP download (platform adapter)
+    adapter_.http_download = platformHttpDownloadCallback;
+    adapter_.http_download_cancel = platformHttpDownloadCancelCallback;
 
     // Archive extraction (handled by JS layer)
     adapter_.extract_archive = nullptr;
@@ -1271,3 +1482,23 @@ std::tuple<bool, int, std::string, std::string> InitBridge::httpPostSync(
 
 } // namespace bridges
 } // namespace runanywhere
+
+// =============================================================================
+// Global C API for platform download reporting
+// =============================================================================
+
+extern "C" int RunAnywhereHttpDownloadReportProgress(const char* task_id,
+                                                     int64_t downloaded_bytes,
+                                                     int64_t total_bytes) {
+    return runanywhere::bridges::reportHttpDownloadProgressInternal(task_id,
+                                                                    downloaded_bytes,
+                                                                    total_bytes);
+}
+
+extern "C" int RunAnywhereHttpDownloadReportComplete(const char* task_id,
+                                                     int result,
+                                                     const char* downloaded_path) {
+    return runanywhere::bridges::reportHttpDownloadCompleteInternal(task_id,
+                                                                    result,
+                                                                    downloaded_path);
+}

package/cpp/bridges/PlatformDownloadBridge.h

@@ -0,0 +1,44 @@
+/**
+ * PlatformDownloadBridge.h
+ *
+ * C callbacks for platform HTTP download progress/completion reporting.
+ * Used by iOS/Android platform adapters to report async download state
+ * back into the C++ bridge.
+ */
+
+#ifndef RUNANYWHERE_PLATFORM_DOWNLOAD_BRIDGE_H
+#define RUNANYWHERE_PLATFORM_DOWNLOAD_BRIDGE_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Report HTTP download progress for a task.
+ * @param task_id Task identifier
+ * @param downloaded_bytes Bytes downloaded so far
+ * @param total_bytes Total bytes (0 if unknown)
+ * @return RAC_SUCCESS on success, error code otherwise
+ */
+int RunAnywhereHttpDownloadReportProgress(const char* task_id,
+                                          int64_t downloaded_bytes,
+                                          int64_t total_bytes);
+
+/**
+ * Report HTTP download completion for a task.
+ * @param task_id Task identifier
+ * @param result RAC_SUCCESS or error code
+ * @param downloaded_path Path to downloaded file (NULL on failure)
+ * @return RAC_SUCCESS on success, error code otherwise
+ */
+int RunAnywhereHttpDownloadReportComplete(const char* task_id,
+                                          int result,
+                                          const char* downloaded_path);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // RUNANYWHERE_PLATFORM_DOWNLOAD_BRIDGE_H

package/cpp/bridges/ToolCallingBridge.cpp

@@ -0,0 +1,188 @@
+/**
+ * @file ToolCallingBridge.cpp
+ * @brief Tool Calling bridge implementation - THIN WRAPPER
+ *
+ * *** ALL LOGIC IS IN runanywhere-commons (rac_tool_calling.h) ***
+ *
+ * This bridge just wraps the C API functions from commons.
+ * NO LOCAL PARSING LOGIC - everything calls through to commons.
+ */
+
+#include "ToolCallingBridge.hpp"
+#include <rac_tool_calling.h>
+#include <nlohmann/json.hpp>
+#include <cstring>
+
+using json = nlohmann::json;
+
+namespace runanywhere {
+namespace bridges {
+
+ToolCallingBridge& ToolCallingBridge::shared() {
+    static ToolCallingBridge instance;
+    return instance;
+}
+
+std::string ToolCallingBridge::parseToolCall(const std::string& llmOutput) {
+    rac_tool_call_t result = {};  // Zero-initialize for safety
+    rac_result_t rc = rac_tool_call_parse(llmOutput.c_str(), &result);
+
+    // Handle parse failure defensively - return safe default
+    if (rc != RAC_SUCCESS) {
+        json fallback;
+        fallback["hasToolCall"] = false;
+        fallback["cleanText"] = llmOutput;
+        return fallback.dump();
+    }
+
+    // Build JSON response using nlohmann/json
+    json response;
+    response["hasToolCall"] = result.has_tool_call == RAC_TRUE;
+    response["cleanText"] = result.clean_text ? result.clean_text : llmOutput;
+
+    if (result.has_tool_call == RAC_TRUE) {
+        response["toolName"] = result.tool_name ? result.tool_name : "";
+
+        if (result.arguments_json) {
+            try {
+                response["argumentsJson"] = json::parse(result.arguments_json);
+            } catch (...) {
+                response["argumentsJson"] = json::object();
+            }
+        } else {
+            response["argumentsJson"] = json::object();
+        }
+        response["callId"] = result.call_id;
+    }
+
+    rac_tool_call_free(&result);
+    return response.dump();
+}
+
+std::string ToolCallingBridge::formatToolsPrompt(const std::string& toolsJson, const std::string& format) {
+    if (toolsJson.empty() || toolsJson == "[]") {
+        return "";
+    }
+
+    char* prompt = nullptr;
+    rac_result_t rc = rac_tool_call_format_prompt_json_with_format_name(
+        toolsJson.c_str(),
+        format.c_str(),
+        &prompt
+    );
+
+    if (rc != RAC_SUCCESS || !prompt) {
+        return "";
+    }
+
+    std::string result(prompt);
+    rac_free(prompt);
+    return result;
+}
+
+std::string ToolCallingBridge::buildInitialPrompt(
+    const std::string& userPrompt,
+    const std::string& toolsJson,
+    const std::string& optionsJson
+) {
+    // Start with default options
+    rac_tool_calling_options_t options = {
+        5,                          // max_tool_calls
+        RAC_TRUE,                   // auto_execute
+        0.7f,                       // temperature
+        1024,                       // max_tokens
+        nullptr,                    // system_prompt
+        RAC_FALSE,                  // replace_system_prompt
+        RAC_FALSE,                  // keep_tools_available
+        RAC_TOOL_FORMAT_DEFAULT     // format
+    };
+
+    // Parse optionsJson if provided
+    if (!optionsJson.empty()) {
+        try {
+            json opts = json::parse(optionsJson);
+
+            if (opts.contains("maxToolCalls") && opts["maxToolCalls"].is_number_integer()) {
+                options.max_tool_calls = opts["maxToolCalls"].get<int32_t>();
+            }
+            if (opts.contains("autoExecute") && opts["autoExecute"].is_boolean()) {
+                options.auto_execute = opts["autoExecute"].get<bool>() ? RAC_TRUE : RAC_FALSE;
+            }
+            if (opts.contains("temperature") && opts["temperature"].is_number()) {
+                options.temperature = opts["temperature"].get<float>();
+            }
+            if (opts.contains("maxTokens") && opts["maxTokens"].is_number_integer()) {
+                options.max_tokens = opts["maxTokens"].get<int32_t>();
+            }
+            if (opts.contains("format") && opts["format"].is_string()) {
+                options.format = rac_tool_call_format_from_name(opts["format"].get<std::string>().c_str());
+            }
+            if (opts.contains("replaceSystemPrompt") && opts["replaceSystemPrompt"].is_boolean()) {
+                options.replace_system_prompt = opts["replaceSystemPrompt"].get<bool>() ? RAC_TRUE : RAC_FALSE;
+            }
+            if (opts.contains("keepToolsAvailable") && opts["keepToolsAvailable"].is_boolean()) {
+                options.keep_tools_available = opts["keepToolsAvailable"].get<bool>() ? RAC_TRUE : RAC_FALSE;
+            }
+        } catch (...) {
+            // JSON parse failed, keep defaults
+        }
+    }
+
+    char* prompt = nullptr;
+    rac_result_t rc = rac_tool_call_build_initial_prompt(
+        userPrompt.c_str(),
+        toolsJson.c_str(),
+        &options,
+        &prompt
+    );
+
+    if (rc != RAC_SUCCESS || !prompt) {
+        return userPrompt;
+    }
+
+    std::string result(prompt);
+    rac_free(prompt);
+    return result;
+}
+
+std::string ToolCallingBridge::buildFollowupPrompt(
+    const std::string& originalPrompt,
+    const std::string& toolsPrompt,
+    const std::string& toolName,
+    const std::string& resultJson,
+    bool keepToolsAvailable
+) {
+    char* prompt = nullptr;
+    rac_result_t rc = rac_tool_call_build_followup_prompt(
+        originalPrompt.c_str(),
+        toolsPrompt.empty() ? nullptr : toolsPrompt.c_str(),
+        toolName.c_str(),
+        resultJson.c_str(),
+        keepToolsAvailable ? RAC_TRUE : RAC_FALSE,
+        &prompt
+    );
+
+    if (rc != RAC_SUCCESS || !prompt) {
+        return "";
+    }
+
+    std::string result(prompt);
+    rac_free(prompt);
+    return result;
+}
+
+std::string ToolCallingBridge::normalizeJson(const std::string& jsonStr) {
+    char* normalized = nullptr;
+    rac_result_t rc = rac_tool_call_normalize_json(jsonStr.c_str(), &normalized);
+
+    if (rc != RAC_SUCCESS || !normalized) {
+        return jsonStr;
+    }
+
+    std::string result(normalized);
+    rac_free(normalized);
+    return result;
+}
+
+} // namespace bridges
+} // namespace runanywhere

package/cpp/bridges/ToolCallingBridge.hpp

@@ -0,0 +1,98 @@
+/**
+ * @file ToolCallingBridge.hpp
+ * @brief Tool Calling bridge for React Native - THIN WRAPPER
+ *
+ * *** SINGLE SOURCE OF TRUTH FOR TOOL CALLING LOGIC IS IN COMMONS C++ ***
+ *
+ * All parsing logic is in runanywhere-commons (rac_tool_calling.h).
+ * This bridge just wraps the C API for JSI access.
+ *
+ * ARCHITECTURE:
+ * - Commons C++: ALL parsing, prompt formatting, JSON normalization
+ * - This bridge: Thin wrapper that calls rac_tool_call_* functions
+ * - TypeScript: Tool registry, execution (needs JS APIs)
+ */
+
+#pragma once
+
+#include <string>
+
+namespace runanywhere {
+namespace bridges {
+
+/**
+ * Tool Calling bridge - thin wrapper around commons API
+ *
+ * *** NO LOCAL PARSING LOGIC - ALL CALLS GO TO COMMONS ***
+ */
+class ToolCallingBridge {
+public:
+    static ToolCallingBridge& shared();
+
+    /**
+     * Format tool definitions into a system prompt.
+     * Calls rac_tool_call_format_prompt_json_with_format_name() from commons.
+     *
+     * @param toolsJson JSON array of tool definitions
+     * @param format Format name ("default" or "lfm2")
+     * @return Formatted system prompt string
+     */
+    std::string formatToolsPrompt(const std::string& toolsJson, const std::string& format = "default");
+
+    /**
+     * Parse LLM output for tool calls.
+     * Calls rac_tool_call_parse() from commons.
+     *
+     * @param llmOutput Raw LLM output text
+     * @return JSON string with hasToolCall, toolName, argumentsJson, cleanText
+     */
+    std::string parseToolCall(const std::string& llmOutput);
+
+    /**
+     * Build initial prompt with tools and user query.
+     * Calls rac_tool_call_build_initial_prompt() from commons.
+     *
+     * @param userPrompt User's question/request
+     * @param toolsJson JSON array of tool definitions
+     * @param optionsJson Options as JSON (nullable)
+     * @return Complete formatted prompt
+     */
+    std::string buildInitialPrompt(const std::string& userPrompt,
+                                   const std::string& toolsJson,
+                                   const std::string& optionsJson);
+
+    /**
+     * Build follow-up prompt after tool execution.
+     * Calls rac_tool_call_build_followup_prompt() from commons.
+     *
+     * @param originalPrompt Original user prompt
+     * @param toolsPrompt Formatted tools prompt (can be empty)
+     * @param toolName Name of executed tool
+     * @param resultJson Tool result as JSON
+     * @param keepToolsAvailable Whether to keep tools in follow-up
+     * @return Follow-up prompt string
+     */
+    std::string buildFollowupPrompt(const std::string& originalPrompt,
+                                    const std::string& toolsPrompt,
+                                    const std::string& toolName,
+                                    const std::string& resultJson,
+                                    bool keepToolsAvailable);
+
+    /**
+     * Normalize JSON by adding quotes around unquoted keys.
+     * Calls rac_tool_call_normalize_json() from commons.
+     *
+     * @param jsonStr Raw JSON possibly with unquoted keys
+     * @return Normalized JSON string
+     */
+    std::string normalizeJson(const std::string& jsonStr);
+
+private:
+    ToolCallingBridge() = default;
+    ~ToolCallingBridge() = default;
+    ToolCallingBridge(const ToolCallingBridge&) = delete;
+    ToolCallingBridge& operator=(const ToolCallingBridge&) = delete;
+};
+
+} // namespace bridges
+} // namespace runanywhere