Download a model onto the machine that will serve it

The Models tab was about this backend's own disk, which is the wrong disk
for every session that runs anywhere else: llama.cpp reads the file where
it runs. So the models of a machine live under that machine's llama.cpp
provider now, beside the settings deciding how each is loaded, and the
download that produces one happens there.

A download is a detached `curl` on that machine, started by a script this
server writes and never spoken to again. Its state is a file beside the
partial, so nothing about it is held here: it survives the app closing,
this backend restarting and a second device watching, and the progress is
`wc -c` of the partial against the size HuggingFace published rather than
anything remembered. A run whose process is gone is reported failed, since
`kill -0` is asked at each listing, and there is no "finished" state -- a
download that finished is a model, in the list beside the ones still
going. Resuming is guarded by the published sha256, which is also checked
before the file takes its real name.

Two other things the same screens wanted:

A provider is drawn as a card rather than as a line of text, bordered
against the machine card it sits in -- the tint it had was one step along
the surface ladder and rendered as one flat block -- with room to tap and
no chevron.

Nothing in a raw block wraps any more; the block scrolls sideways
instead, one offset for all its lines, so a diff or a column-aligned test
run still reads as one.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app/androidApp/src/main/kotlin/com/example/aiapp/ProviderScreen.kt

@@ -68,6 +68,21 @@ fun ProviderScreen(
     // when it did. Both here rather than per row: these act on the whole machine.
     var busy by remember { mutableStateOf<String?>(null) }
     var actionError by remember { mutableStateOf<String?>(null) }
+    var confirmingDelete by remember { mutableStateOf<ProviderModel?>(null) }
+
+    // The machine's own models and what is being fetched onto it. Only for a provider that serves
+    // files off that machine's disk -- everything else names its models rather than holding them,
+    // and a search for a GGUF under the Claude CLI would be an offer that leads nowhere.
+    val kind = (state as? LoadState.Loaded)?.value?.kind
+    val machineModels =
+        rememberMachineModels(
+            settings = settings,
+            machineId = machineId,
+            enabled = kind == "llama_cpp",
+            // A download that became a model is a model this screen has no settings for yet, so
+            // the view it is drawing is now one model short of the truth.
+            onLocalChange = { reload++ },
+        )
 
     LaunchedEffect(reload) {
         state =
@@ -93,7 +108,9 @@ fun ProviderScreen(
         Unit
     }
 
-    Column(Modifier.fillMaxSize().padding(16.dp)) {
+    // The models search at the bottom takes the keyboard, and everything below the field it is
+    // typed in -- the Search button, the results -- is behind it without this.
+    Column(Modifier.fillMaxSize().imePadding().padding(16.dp)) {
         Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
             TextButton(onClick = onBack) { Text("Back") }
         }
@@ -163,10 +180,21 @@ fun ProviderScreen(
                             Spacer(Modifier.height(8.dp))
                         }
                     }
+                    machineModels.actionError?.let { failure ->
+                        item("models-error") {
+                            Text(failure, color = MaterialTheme.colorScheme.error)
+                        }
+                    }
+                    // Above the models: this is what is about to be one of them.
+                    downloadCards(machineModels)
+                    val sizes = machineModels.sizes
                     uniqueItems(view.models, key = { it.id }) { model ->
                         ModelCard(
                             model = model,
                             specs = view.modelParams,
+                            bytes = sizes[model.id],
+                            onDelete =
+                                if (model.id in sizes) ({ confirmingDelete = model }) else null,
                             // Tapping opens the settings; a provider whose models take none has
                             // nothing to open, so the row is not a control.
                             onEdit =
@@ -187,6 +215,7 @@ fun ProviderScreen(
                             enabled = busy == null,
                         )
                     }
+                    if (kind == "llama_cpp") modelSearch(machineModels)
                     if (view.mcpServers.isNotEmpty()) {
                         item("mcp") {
                             Spacer(Modifier.height(12.dp))
@@ -219,6 +248,33 @@ fun ProviderScreen(
         )
     }
 
+    confirmingDelete?.let { model ->
+        AlertDialog(
+            onDismissRequest = { confirmingDelete = null },
+            title = { Text("Delete ${model.label}?") },
+            text = {
+                Text(
+                    "The file is removed from ${(state as? LoadState.Loaded)?.value?.machine ?: "this machine"}. " +
+                        "Nothing here can get it back -- downloading it again is the whole file again. " +
+                        "Sessions using it keep their conversations and cannot start it."
+                )
+            },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        confirmingDelete = null
+                        machineModels.remove(model.id)
+                    }
+                ) {
+                    Text("Delete")
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { confirmingDelete = null }) { Text("Cancel") }
+            },
+        )
+    }
+
     if (confirmingStop) {
         AlertDialog(
             onDismissRequest = { confirmingStop = false },
@@ -311,8 +367,11 @@ private fun ServerCard(
 private fun ModelCard(
     model: ProviderModel,
     specs: List<ParamSpec>,
+    /** How big the file is on the machine, for a provider whose models are files. */
+    bytes: Long?,
     onEdit: (() -> Unit)?,
     onUnload: (() -> Unit)?,
+    onDelete: (() -> Unit)?,
     enabled: Boolean,
 ) {
     Card(
@@ -321,7 +380,20 @@ private fun ModelCard(
             .then(if (onEdit != null && enabled) Modifier.clickable(onClick = onEdit) else Modifier)
     ) {
         Column(Modifier.padding(12.dp)) {
-            Text(model.label, style = MaterialTheme.typography.bodyMedium)
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(
+                    model.label,
+                    style = MaterialTheme.typography.bodyMedium,
+                    modifier = Modifier.weight(1f),
+                )
+                bytes?.let {
+                    Text(
+                        gigabytes(it),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+            }
             // What the server is doing with it, in its own word. Absent means nobody could ask --
             // the server is not running -- and the line is left out rather than guessed at.
             model.status?.let {
@@ -345,8 +417,15 @@ private fun ModelCard(
                     color = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
             }
-            if (onUnload != null) {
-                Row { TextButton(enabled = enabled, onClick = onUnload) { Text("Unload") } }
+            if (onUnload != null || onDelete != null) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    // Both shown whenever this kind of model has them, disabled rather than
+                    // absent: unloading frees memory and deleting frees disk, and a button that
+                    // comes and goes makes its own absence the message.
+                    onUnload?.let { TextButton(enabled = enabled, onClick = it) { Text("Unload") } }
+                    Spacer(Modifier.weight(1f))
+                    onDelete?.let { TextButton(enabled = enabled, onClick = it) { Text("Delete") } }
+                }
             }
         }
     }