release: v0.1.13

Ship MCP wire-format fixes, guard-mode enforcement, and coordinator/vendor normalization improvements.

Author: dantelex

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "gpukill"
-version = "0.1.12"
+version = "0.1.13"
 edition = "2021"
 authors = ["Kage <info@treadie.com>"]
 description = "A CLI tool for GPU management and monitoring supporting NVIDIA, AMD, Intel, and Apple Silicon GPUs"

mcp/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gpukill-mcp"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2021"
 authors = ["GPU Kill Team"]
 description = "MCP server for GPU Kill - AI-accessible GPU management"

mcp/src/resources.rs

@@ -87,6 +87,21 @@ impl ResourceHandler {
 
     async fn get_gpu_list(&self) -> anyhow::Result<ResourceContents> {
         let gpus = self.gpu_manager.get_all_snapshots()?;
+        let processes = self.gpu_manager.get_all_processes()?;
+        let mut processes_by_gpu: HashMap<u16, Vec<GpuProcess>> = HashMap::new();
+
+        for proc in processes {
+            processes_by_gpu
+                .entry(proc.gpu_index)
+                .or_default()
+                .push(GpuProcess {
+                    pid: proc.pid,
+                    name: proc.proc_name,
+                    memory_usage: proc.used_mem_mb as f64,
+                    user: Some(proc.user),
+                });
+        }
+
         let gpu_info: Vec<GpuInfo> = gpus
             .into_iter()
             .map(|gpu| GpuInfo {
@@ -98,16 +113,10 @@ impl ResourceHandler {
                 utilization: gpu.util_pct as f64,
                 temperature: Some(gpu.temp_c as f64),
                 power_usage: Some(gpu.power_w as f64),
-                processes: gpu
-                    .top_proc
-                    .map(|proc| GpuProcess {
-                        pid: proc.pid,
-                        name: proc.proc_name,
-                        memory_usage: proc.used_mem_mb as f64,
-                        user: Some(proc.user),
-                    })
-                    .into_iter()
-                    .collect(),
+                processes: processes_by_gpu
+                    .get(&gpu.gpu_index)
+                    .cloned()
+                    .unwrap_or_default(),
             })
             .collect();
 
@@ -122,19 +131,16 @@ impl ResourceHandler {
     }
 
     async fn get_gpu_processes(&self) -> anyhow::Result<ResourceContents> {
-        let gpus = self.gpu_manager.get_all_snapshots()?;
-        let mut all_processes = Vec::new();
-
-        for gpu in gpus {
-            if let Some(proc) = gpu.top_proc {
-                all_processes.push(GpuProcess {
-                    pid: proc.pid,
-                    name: proc.proc_name,
-                    memory_usage: proc.used_mem_mb as f64,
-                    user: Some(proc.user),
-                });
-            }
-        }
+        let processes = self.gpu_manager.get_all_processes()?;
+        let all_processes: Vec<GpuProcess> = processes
+            .into_iter()
+            .map(|proc| GpuProcess {
+                pid: proc.pid,
+                name: proc.proc_name,
+                memory_usage: proc.used_mem_mb as f64,
+                user: Some(proc.user),
+            })
+            .collect();
 
         let json_text = serde_json::to_string_pretty(&all_processes)?;
 

mcp/src/server.rs

@@ -5,6 +5,7 @@ use crate::tools::ToolHandler;
 use crate::types::*;
 use crate::MCP_VERSION;
 use anyhow::Result;
+use axum::response::IntoResponse;
 use serde_json::json;
 use std::sync::Arc;
 use tokio::sync::RwLock;
@@ -29,8 +30,9 @@ impl GpuKillMCPServer {
     }
 
     /// Handle an MCP request
-    pub async fn handle_request(&self, request: JsonRpcRequest) -> Result<JsonRpcResponse> {
+    pub async fn handle_request(&self, request: JsonRpcRequest) -> Result<Option<JsonRpcResponse>> {
         debug!("Handling MCP request: {}", request.method);
+        let request_id = request.id.clone();
 
         let result = match request.method.as_str() {
             "initialize" => self.handle_initialize(request.params).await,
@@ -42,24 +44,24 @@ impl GpuKillMCPServer {
         };
 
         match result {
-            Ok(data) => Ok(JsonRpcResponse {
+            Ok(data) => Ok(request_id.map(|id| JsonRpcResponse {
                 jsonrpc: "2.0".to_string(),
-                id: request.id,
+                id,
                 result: Some(data),
                 error: None,
-            }),
+            })),
             Err(e) => {
                 error!("Error handling request {}: {}", request.method, e);
-                Ok(JsonRpcResponse {
+                Ok(request_id.map(|id| JsonRpcResponse {
                     jsonrpc: "2.0".to_string(),
-                    id: request.id,
+                    id,
                     result: None,
                     error: Some(JsonRpcError {
                         code: -32603,
                         message: "Internal error".to_string(),
                         data: Some(json!({ "details": e.to_string() })),
                     }),
-                })
+                }))
             }
         }
     }
@@ -107,7 +109,7 @@ impl GpuKillMCPServer {
             .ok_or_else(|| anyhow::anyhow!("Missing uri parameter"))?;
 
         let contents = self.resource_handler.get_resource(uri).await?;
-        Ok(json!({ "contents": contents }))
+        Ok(json!({ "contents": [contents] }))
     }
 
     async fn handle_tools_list(&self) -> Result<serde_json::Value> {
@@ -153,21 +155,14 @@ impl GpuKillMCPServer {
                     move |request: axum::extract::Json<JsonRpcRequest>| {
                         let server = server.clone();
                         async move {
-                            let request_id = request.0.id.clone();
                             match server.handle_request(request.0).await {
-                                Ok(response) => axum::response::Json(response),
+                                Ok(Some(response)) => {
+                                    axum::response::Json(response).into_response()
+                                }
+                                Ok(None) => axum::http::StatusCode::NO_CONTENT.into_response(),
                                 Err(e) => {
                                     error!("Failed to handle HTTP request: {}", e);
-                                    axum::response::Json(JsonRpcResponse {
-                                        jsonrpc: "2.0".to_string(),
-                                        id: request_id,
-                                        result: None,
-                                        error: Some(JsonRpcError {
-                                            code: -32603,
-                                            message: "Internal error".to_string(),
-                                            data: Some(json!({ "details": e.to_string() })),
-                                        }),
-                                    })
+                                    axum::http::StatusCode::INTERNAL_SERVER_ERROR.into_response()
                                 }
                             }
                         }