fix(vllm): show the owning node idle timeout on peer model rows

Signed-off-by: nvrithik <rithikv@nvidia.com>

Author: nvrithik

desktop/docs/services-backend.md

@@ -155,6 +155,13 @@ remote control surface where supported.
 
 ### Engine settings
 
+Engine status includes the optional `idle_timeout_s` field for engines with an
+idle-unload limit (0 means never unload). The engine manager's pinned `ec`
+status endpoint and the broker's `engine:remote-get-installed` relay preserve
+this owner-reported value. The bridge uses it for remote model expiry labels,
+scoped to the owning node and engine, and updates them on the existing remote
+status refresh. No idle-timeout field is added to discovery records.
+
 Ports and the engine arguments are one authoritative, revisioned record owned by
 the node running the engine. The broker exposes `engine:{get,preview,apply}-settings`
 and relays a request naming another node to that peer's engine manager, so a

desktop/docs/services-parity.md

@@ -196,7 +196,11 @@ first request or a Load loads the model, it unloads after an idle limit (five
 minutes by default, `get_idle_timeout` and `set_idle_timeout`, shown as the
 model row's expiry control), and Eject (`unload_model`, a `stop_engine` action)
 unloads it on demand while the engine stays on; the card shows an idle engine
-as "Idle · loads on next request" (`idle` on the engine status). Its model list
+as "Idle · loads on next request" (`idle` on the engine status). Model rows use
+the owning node's `idle_timeout_s` from engine status for the expiry labels,
+including when viewed on a peer. Remote labels update on the existing engine
+status refresh (every 20 seconds); until a value is reported, vLLM uses its
+five-minute default. Its model list
 (`list_models` on disk) is kept while stopped. It downloads and deletes
 through the shared Hugging Face cache (`pull_model` is an `hf_pull` action,
 `delete_model` an `hf_cache` delete that refuses the model an engine process

desktop/src/electron/service-bridge/modular-state.ts

@@ -84,6 +84,13 @@ interface RemoteEngineFacts {
     running: boolean
     healthy: boolean
     port: number
+    idleTimeoutSeconds?: number
+}
+
+function readIdleTimeoutSeconds(value: JsonValue | undefined): number | undefined {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= 86400
+        ? value
+        : undefined
 }
 
 interface ModularNode {
@@ -1402,6 +1409,10 @@ class ModularBridgeState {
             port: numberValue(obj.port),
             idle: booleanValue(obj.idle)
         })
+        const seconds = readIdleTimeoutSeconds(obj.idle_timeout_s)
+        if (EnginesWithIdleTimeout.includes(engineType) && seconds !== undefined) {
+            this.setEngineIdleSeconds(engineType, seconds)
+        }
         // A fresh authoritative state is the resolution of whatever op was in
         // flight (start/stop done, install `done`+installed, uninstall removed).
         // Drop the optimistic status without re-emitting here — the emit below
@@ -1411,10 +1422,15 @@ class ModularBridgeState {
     }
 
     /** The expiry the models of an engine show: its idle limit, or the default. */
-    private expiryFor(engineType: EngineType): ModelExpiry {
-        const seconds = this.idleSeconds.get(engineType)
+    private expiryFor(engineType: EngineType, nodeId = this.selfId): ModelExpiry {
+        if (!EnginesWithIdleTimeout.includes(engineType)) return '10m'
+        const seconds =
+            nodeId && nodeId !== this.selfId
+                ? this.remoteEngineFacts.get(this.remoteOpKey(nodeId, engineType))
+                      ?.idleTimeoutSeconds
+                : this.idleSeconds.get(engineType)
         if (seconds !== undefined) return idleSecondsToExpiry(seconds)
-        return EnginesWithIdleTimeout.includes(engineType) ? DefaultIdleExpiry : '10m'
+        return DefaultIdleExpiry
     }
 
     /**
@@ -1877,7 +1893,8 @@ class ModularBridgeState {
                 installed: booleanValue(engineObj.installed),
                 running: booleanValue(engineObj.running),
                 healthy: booleanValue(engineObj.healthy),
-                port: numberValue(engineObj.port)
+                port: numberValue(engineObj.port),
+                idleTimeoutSeconds: readIdleTimeoutSeconds(engineObj.idle_timeout_s)
             })
             seen.add(engineType)
         }
@@ -1908,7 +1925,8 @@ class ModularBridgeState {
             installed: booleanValue(obj.installed),
             running: booleanValue(obj.running),
             healthy: booleanValue(obj.healthy),
-            port: numberValue(obj.port)
+            port: numberValue(obj.port),
+            idleTimeoutSeconds: readIdleTimeoutSeconds(obj.idle_timeout_s)
         })
         this.emitRemoteEngineStatus(nodeId, engineType)
     }
@@ -2088,11 +2106,12 @@ class ModularBridgeState {
 
     private toEngineModels(node: ModularNode, engine: ProxyEngine): EngineModels {
         const loaded = loadedNamesForEngine(node, engine)
+        const expiry = this.expiryFor(engine, node.id)
         return {
             engineType: engine,
             nodeId: node.id,
             models: this.modelsForEngine(node, engine).map(name =>
-                modelItem(name, loaded.has(name))
+                modelItem(name, loaded.has(name), expiry)
             )
         }
     }