Sync dev/main

examples/android/RunAnywhereAI/app/src/main/java/com/runanywhere/runanywhereai/RunAnywhereApplication.kt

@@ -313,6 +313,21 @@ class RunAnywhereApplication : Application() {
             framework = InferenceFramework.LLAMA_CPP,
             memoryRequirement = 400_000_000,
         )
+        // LFM2-Tool models - For tool calling / function calling support
+        RunAnywhere.registerModel(
+            id = "lfm2-1.2b-tool-q4_k_m",
+            name = "LiquidAI LFM2 1.2B Tool Q4_K_M",
+            url = "https://huggingface.co/LiquidAI/LFM2-1.2B-Tool-GGUF/resolve/main/LFM2-1.2B-Tool-Q4_K_M.gguf",
+            framework = InferenceFramework.LLAMA_CPP,
+            memoryRequirement = 800_000_000,
+        )
+        RunAnywhere.registerModel(
+            id = "lfm2-1.2b-tool-q8_0",
+            name = "LiquidAI LFM2 1.2B Tool Q8_0",
+            url = "https://huggingface.co/LiquidAI/LFM2-1.2B-Tool-GGUF/resolve/main/LFM2-1.2B-Tool-Q8_0.gguf",
+            framework = InferenceFramework.LLAMA_CPP,
+            memoryRequirement = 1_400_000_000,
+        )
         Log.i("RunAnywhereApp", "✅ LLM models registered")
 
         // Register ONNX STT and TTS models

examples/android/RunAnywhereAI/app/src/main/java/com/runanywhere/runanywhereai/domain/models/ChatMessage.kt

@@ -117,6 +117,19 @@ data class PerformanceSummary(
     val successRate: Double = 1.0,
 )
 
+/**
+ * App-local tool call info.
+ * Matches iOS ToolCallInfo exactly.
+ */
+@Serializable
+data class ToolCallInfo(
+    val toolName: String,
+    val arguments: String,  // JSON string for display
+    val result: String? = null,  // JSON string for display
+    val success: Boolean,
+    val error: String? = null,
+)
+
 /**
  * App-specific ChatMessage for conversations.
  * Self-contained with app-local types.
@@ -130,6 +143,7 @@ data class ChatMessage(
     val timestamp: Long = System.currentTimeMillis(),
     val analytics: MessageAnalytics? = null,
     val modelInfo: MessageModelInfo? = null,
+    val toolCallInfo: ToolCallInfo? = null,
     val metadata: Map<String, String>? = null,
 ) {
     val isFromUser: Boolean get() = role == MessageRole.USER
@@ -158,6 +172,7 @@ data class ChatMessage(
             thinkingContent: String? = null,
             analytics: MessageAnalytics? = null,
             modelInfo: MessageModelInfo? = null,
+            toolCallInfo: ToolCallInfo? = null,
             metadata: Map<String, String>? = null,
         ): ChatMessage =
             ChatMessage(
@@ -166,6 +181,7 @@ data class ChatMessage(
                 thinkingContent = thinkingContent,
                 analytics = analytics,
                 modelInfo = modelInfo,
+                toolCallInfo = toolCallInfo,
                 metadata = metadata,
             )
 

examples/android/RunAnywhereAI/app/src/main/java/com/runanywhere/runanywhereai/presentation/chat/ChatScreen.kt

@@ -44,7 +44,9 @@ import com.runanywhere.runanywhereai.data.ConversationStore
 import com.runanywhere.runanywhereai.domain.models.ChatMessage
 import com.runanywhere.runanywhereai.domain.models.Conversation
 import com.runanywhere.runanywhereai.domain.models.MessageRole
+import com.runanywhere.runanywhereai.presentation.settings.ToolSettingsViewModel
 import com.runanywhere.runanywhereai.ui.theme.AppColors
+import android.app.Application
 import com.runanywhere.runanywhereai.ui.theme.AppTypography
 import com.runanywhere.runanywhereai.ui.theme.Dimensions
 import kotlinx.coroutines.launch
@@ -238,6 +240,20 @@ fun ChatScreen(viewModel: ChatViewModel = viewModel()) {
                 color = MaterialTheme.colorScheme.outline,
             )
 
+            // Tool calling indicator - matching iOS
+            val toolContext = LocalContext.current
+            val application = toolContext.applicationContext as Application
+            val toolSettingsViewModel = remember { ToolSettingsViewModel.getInstance(application) }
+            val toolState by toolSettingsViewModel.uiState.collectAsStateWithLifecycle()
+
+            AnimatedVisibility(
+                visible = toolState.toolCallingEnabled && toolState.registeredTools.isNotEmpty(),
+                enter = fadeIn() + expandVertically(),
+                exit = fadeOut() + shrinkVertically(),
+            ) {
+                ToolCallingBadge(toolCount = toolState.registeredTools.size)
+            }
+
             // Model selection prompt (when no model loaded) - matching iOS
             AnimatedVisibility(
                 visible = !uiState.isModelLoaded,
@@ -457,6 +473,8 @@ fun MessageBubbleView(
     message: ChatMessage,
     isGenerating: Boolean = false,
 ) {
+    var showToolCallSheet by remember { mutableStateOf(false) }
+
     val alignment =
         if (message.role == MessageRole.USER) {
             Arrangement.End
@@ -498,6 +516,15 @@ fun MessageBubbleView(
                 Spacer(modifier = Modifier.height(Dimensions.small))
             }
 
+            // Tool call indicator (for assistant messages with tool calls) - matching iOS
+            if (message.role == MessageRole.ASSISTANT && message.toolCallInfo != null) {
+                com.runanywhere.runanywhereai.presentation.chat.components.ToolCallIndicator(
+                    toolCallInfo = message.toolCallInfo,
+                    onTap = { showToolCallSheet = true },
+                )
+                Spacer(modifier = Modifier.height(Dimensions.small))
+            }
+
             // Thinking toggle (if thinking content exists) - matching iOS
             message.thinkingContent?.let { thinking ->
                 ThinkingToggle(
@@ -650,6 +677,14 @@ fun MessageBubbleView(
             Spacer(modifier = Modifier.width(Dimensions.messageBubbleMinSpacing))
         }
     }
+
+    // Tool call detail sheet - matching iOS
+    if (showToolCallSheet && message.toolCallInfo != null) {
+        com.runanywhere.runanywhereai.presentation.chat.components.ToolCallDetailSheet(
+            toolCallInfo = message.toolCallInfo,
+            onDismiss = { showToolCallSheet = false },
+        )
+    }
 }
 
 // Helper function to format timestamp - matching iOS
@@ -1118,6 +1153,42 @@ fun EmptyStateView(
 // MODEL SELECTION PROMPT
 // ====================
 
+/**
+ * Tool calling indicator badge - matching iOS ChatInterfaceView toolCallingBadge
+ */
+@Composable
+fun ToolCallingBadge(toolCount: Int) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = Dimensions.mediumLarge, vertical = Dimensions.small),
+        horizontalArrangement = Arrangement.Center,
+    ) {
+        Row(
+            modifier = Modifier
+                .background(
+                    color = AppColors.primaryAccent.copy(alpha = 0.1f),
+                    shape = RoundedCornerShape(6.dp)
+                )
+                .padding(horizontal = 10.dp, vertical = 4.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(6.dp),
+        ) {
+            Icon(
+                imageVector = Icons.Default.Build,
+                contentDescription = "Tools enabled",
+                modifier = Modifier.size(10.dp),
+                tint = AppColors.primaryAccent,
+            )
+            Text(
+                text = "Tools enabled ($toolCount)",
+                style = AppTypography.caption2,
+                color = AppColors.primaryAccent,
+            )
+        }
+    }
+}
+
 @Composable
 fun ModelSelectionPrompt(onSelectModel: () -> Unit) {
     Surface(

examples/android/RunAnywhereAI/app/src/main/java/com/runanywhere/runanywhereai/presentation/chat/ChatViewModel.kt

@@ -12,6 +12,8 @@ import com.runanywhere.runanywhereai.domain.models.Conversation
 import com.runanywhere.runanywhereai.domain.models.MessageAnalytics
 import com.runanywhere.runanywhereai.domain.models.MessageModelInfo
 import com.runanywhere.runanywhereai.domain.models.MessageRole
+import com.runanywhere.runanywhereai.domain.models.ToolCallInfo
+import com.runanywhere.sdk.public.extensions.LLM.ToolValue
 import com.runanywhere.sdk.public.RunAnywhere
 import com.runanywhere.sdk.public.events.EventBus
 import com.runanywhere.sdk.public.events.LLMEvent
@@ -23,8 +25,19 @@ import com.runanywhere.sdk.public.extensions.generate
 import com.runanywhere.sdk.public.extensions.generateStream
 import com.runanywhere.sdk.public.extensions.isLLMModelLoaded
 import com.runanywhere.sdk.public.extensions.loadLLMModel
+import com.runanywhere.sdk.public.extensions.LLM.ToolCallingOptions
+import com.runanywhere.sdk.public.extensions.LLM.ToolCallFormat
+import com.runanywhere.sdk.public.extensions.LLM.RunAnywhereToolCalling
+import com.runanywhere.runanywhereai.presentation.settings.ToolSettingsViewModel
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.buildJsonObject
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.filterIsInstance
@@ -202,7 +215,15 @@ class ChatViewModel(application: Application) : AndroidViewModel(application) {
                     // Clear metrics from previous generation
                     tokensPerSecondHistory.clear()
 
-                    if (currentState.useStreaming) {
+                    // Check if tool calling is enabled and tools are registered
+                    val toolViewModel = ToolSettingsViewModel.getInstance(app)
+                    val useToolCalling = toolViewModel.toolCallingEnabled
+                    val registeredTools = RunAnywhereToolCalling.getRegisteredTools()
+
+                    if (useToolCalling && registeredTools.isNotEmpty()) {
+                        Log.i(TAG, "🔧 Using tool calling with ${registeredTools.size} tools")
+                        generateWithToolCalling(prompt, assistantMessage.id)
+                    } else if (currentState.useStreaming) {
                         generateWithStreaming(prompt, assistantMessage.id)
                     } else {
                         generateWithoutStreaming(prompt, assistantMessage.id)
@@ -213,6 +234,90 @@ class ChatViewModel(application: Application) : AndroidViewModel(application) {
             }
     }
 
+    /**
+     * Generate with tool calling support
+     * Matches iOS generateWithToolCalling pattern
+     */
+    private suspend fun generateWithToolCalling(
+        prompt: String,
+        messageId: String,
+    ) {
+        val startTime = System.currentTimeMillis()
+
+        try {
+            // Detect the appropriate tool call format based on loaded model
+            // Note: loadedModelName can be null if model state changes during generation
+            val modelName = _uiState.value.loadedModelName
+            if (modelName == null) {
+                Log.w(TAG, "⚠️ Tool calling initiated but model name is null, using default format")
+            }
+            val toolViewModel = ToolSettingsViewModel.getInstance(app)
+            val format = toolViewModel.detectToolCallFormat(modelName)
+
+            Log.i(TAG, "🔧 Tool calling with format: $format for model: ${modelName ?: "unknown"}")
+
+            // Create tool calling options
+            val toolOptions = ToolCallingOptions(
+                maxToolCalls = 3,
+                autoExecute = true,
+                temperature = 0.7f,
+                maxTokens = 1024,
+                format = format
+            )
+
+            // Generate with tools
+            val result = RunAnywhereToolCalling.generateWithTools(prompt, toolOptions)
+            val endTime = System.currentTimeMillis()
+
+            // Update the assistant message with the result
+            val response = result.text
+            updateAssistantMessage(messageId, response, null)
+
+            // Log tool calls and create tool call info
+            if (result.toolCalls.isNotEmpty()) {
+                Log.i(TAG, "🔧 Tool calls made: ${result.toolCalls.map { it.toolName }}")
+                result.toolResults.forEach { toolResult ->
+                    Log.i(TAG, "📋 Tool result: ${toolResult.toolName} - success: ${toolResult.success}")
+                }
+
+                // Create ToolCallInfo from the first tool call and result
+                val firstToolCall = result.toolCalls.first()
+                val firstToolResult = result.toolResults.firstOrNull { it.toolName == firstToolCall.toolName }
+
+                val toolCallInfo = ToolCallInfo(
+                    toolName = firstToolCall.toolName,
+                    arguments = formatToolValueMapToJson(firstToolCall.arguments),
+                    result = firstToolResult?.result?.let { formatToolValueMapToJson(it) },
+                    success = firstToolResult?.success ?: false,
+                    error = firstToolResult?.error,
+                )
+
+                updateAssistantMessageWithToolCallInfo(messageId, toolCallInfo)
+            }
+
+            // Create analytics
+            val analytics = createMessageAnalytics(
+                startTime = startTime,
+                endTime = endTime,
+                firstTokenTime = null,
+                thinkingStartTime = null,
+                thinkingEndTime = null,
+                inputText = prompt,
+                outputText = response,
+                thinkingText = null,
+                wasInterrupted = false,
+            )
+
+            updateAssistantMessageWithAnalytics(messageId, analytics)
+
+        } catch (e: Exception) {
+            Log.e(TAG, "Tool calling failed", e)
+            throw e
+        } finally {
+            _uiState.value = _uiState.value.copy(isGenerating = false)
+        }
+    }
+
     /**
      * Generate with streaming support and thinking mode
      * Matches iOS streaming generation pattern
@@ -456,6 +561,23 @@ class ChatViewModel(application: Application) : AndroidViewModel(application) {
         _uiState.value = _uiState.value.copy(messages = updatedMessages)
     }
 
+    private fun updateAssistantMessageWithToolCallInfo(
+        messageId: String,
+        toolCallInfo: ToolCallInfo,
+    ) {
+        val currentMessages = _uiState.value.messages
+        val updatedMessages =
+            currentMessages.map { message ->
+                if (message.id == messageId) {
+                    message.copy(toolCallInfo = toolCallInfo)
+                } else {
+                    message
+                }
+            }
+
+        _uiState.value = _uiState.value.copy(messages = updatedMessages)
+    }
+
     /**
      * Create message analytics using app-local types
      */
@@ -724,6 +846,38 @@ class ChatViewModel(application: Application) : AndroidViewModel(application) {
         _uiState.value = _uiState.value.copy(error = null)
     }
 
+    /**
+     * Format a ToolValue map to JSON string for display.
+     * Uses kotlinx.serialization for proper JSON escaping of special characters.
+     */
+    private fun formatToolValueMapToJson(map: Map<String, ToolValue>): String {
+        val jsonObject = buildJsonObject {
+            map.forEach { (key, value) ->
+                put(key, formatToolValueToJsonElement(value))
+            }
+        }
+        return Json.encodeToString(JsonObject.serializer(), jsonObject)
+    }
+
+    /**
+     * Convert a ToolValue to the appropriate JsonElement type.
+     * Handles all ToolValue variants with proper JSON escaping.
+     */
+    private fun formatToolValueToJsonElement(value: ToolValue): JsonElement {
+        return when (value) {
+            is ToolValue.StringValue -> JsonPrimitive(value.value)
+            is ToolValue.NumberValue -> JsonPrimitive(value.value)
+            is ToolValue.BoolValue -> JsonPrimitive(value.value)
+            is ToolValue.NullValue -> JsonNull
+            is ToolValue.ArrayValue -> buildJsonArray {
+                value.value.forEach { add(formatToolValueToJsonElement(it)) }
+            }
+            is ToolValue.ObjectValue -> buildJsonObject {
+                value.value.forEach { (k, v) -> put(k, formatToolValueToJsonElement(v)) }
+            }
+        }
+    }
+
     companion object {
         private const val TAG = "ChatViewModel"
     }