Fix build: minimal deps + mock inference, keep new UI & orchestrator

Cargo.toml

@@ -6,20 +6,32 @@ description = "Zero-trust medical AI triage gateway – AMD Hackathon 2026"
 
 [dependencies]
 tokio = { version = "1", features = ["full"] }
-axum = { version = "0.8", features = ["macros"] }
-tower-http = { version = "0.6", features = ["trace", "cors"] }
+axum = { version = "0.7", features = ["macros"] }
+tower = "0.4"
+tower-http = { version = "0.5", features = ["trace", "cors"] }
 
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 
 tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 anyhow = "1.0"
 
+# PII Shield
+regex = "1"
+
+# Web3 (CID + Base)
+sha2 = "0.10"
 hex = "0.4"
+cid = "0.11"
+alloy = { version = "0.7", features = ["full"] }
+alloy-provider = "0.7"
+alloy-signer-local = "0.7"
 
-# Minimal dependencies for now (real Candle added locally later)
-# candle-core = "0.8"   # commented until we test locally with MI300X
+# Environment
+dotenvy = "0.15"
 
 [profile.release]
+lto = true
+codegen-units = 1
 opt-level = 3

src/inference/qwen.rs

@@ -1,102 +1,13 @@
-use anyhow::{Context, Result};
-use candle_core::{DType, Device, Tensor};
-use candle_nn::VarBuilder;
-use candle_transformers::generation::{LogitsProcessor, Sampling};
-use candle_transformers::models::qwen2::{Config, Model};
-use hf_hub::api::sync::Api;
-use tokenizers::Tokenizer;
-use std::sync::Arc;
-use tokio::sync::OnceCell;
-
-static MODEL: OnceCell<Arc<LoadedModel>> = OnceCell::const_new();
-
-struct LoadedModel {
-    model: Model,
-    tokenizer: Tokenizer,
-    device: Device,
-    model_name: String,
-}
-
-async fn load_model() -> Result<Arc<LoadedModel>> {
-    MODEL
-        .get_or_try_init(|| async {
-            let use_7b = std::env::var("FORCE_0_5B").unwrap_or_default() != "1";
-            let (model_id, model_name) = if use_7b {
-                ("Qwen/Qwen2.5-7B-Instruct", "7B")
-            } else {
-                ("Qwen/Qwen2.5-0.5B-Instruct", "0.5B")
-            };
-
-            let device = if std::env::var("ENABLE_ROCM").unwrap_or_default() == "1" {
-                Device::new_hip(0).unwrap_or_else(|e| {
-                    tracing::warn!("HIP device not available: {}; falling back to CPU", e);
-                    Device::Cpu
-                })
-            } else {
-                Device::Cpu
-            };
-
-            tracing::info!("Loading model {} on {:?}", model_id, device);
-
-            let api = Api::new()?;
-            let repo = api.model(model_id.to_string());
-            let model_path = repo.get("model.safetensors")?;
-            let config_path = repo.get("config.json")?;
-            let tokenizer_path = repo.get("tokenizer.json")?;
-
-            let config: Config = serde_json::from_reader(std::fs::File::open(config_path)?)?;
-            let vb = unsafe { VarBuilder::from_mmaped_safetensors(&[model_path], DType::F32, &device)? };
-            let model = Model::new(&config, vb)?;
-            let tokenizer = Tokenizer::from_file(tokenizer_path).map_err(|e| anyhow::anyhow!(e))?;
-
-            Ok(Arc::new(LoadedModel { model, tokenizer, device, model_name: model_name.to_string() }))
-        })
-        .await
-        .map(Arc::clone)
-}
+use anyhow::Result;
 
+/// Mock inference for local testing / HF Space CPU.
 /// Returns (generated_text, model_used, device_info)
-pub async fn generate(redacted_prompt: &str) -> Result<(String, String, String)> {
-    match load_model().await {
-        Ok(loaded) => {
-            let prompt = format!("<|im_start|>user\n{}\n<|im_end|>\n<|im_start|>assistant\n", redacted_prompt);
-            let tokens = loaded.tokenizer.encode(prompt, true).map_err(|e| anyhow::anyhow!(e))?;
-            let input_ids = Tensor::new(tokens.get_ids(), &loaded.device)?.unsqueeze(0)?;
-            let mut output_ids = input_ids.clone();
-            let mut logits_processor = LogitsProcessor::from_sampling(Sampling::TopKTopP {
-                k: 50,
-                p: 0.9,
-                temperature: 0.7,
-            });
-            let eos_token_id = loaded.tokenizer.token_to_id("<|im_end|>").unwrap_or(151643);
-            let max_new_tokens = 250;
-            let mut generated_text = String::new();
-
-            // Candle currently recomputes full attention for each token.
-            // A KV cache would speed this up and is the first post‑hackathon optimisation.
-            // For real‑time streaming (SSE), the loop can yield tokens as they are sampled.
-            for _ in 0..max_new_tokens {
-                let logits = loaded.model.forward(&output_ids)?.squeeze(1)?;
-                let next_token = logits_processor.sample(&logits)?;
-                if next_token == eos_token_id {
-                    break;
-                }
-                output_ids = Tensor::cat(&[output_ids, next_token.unsqueeze(0)?.unsqueeze(0)?], 1)?;
-                if let Ok(text) = loaded.tokenizer.decode(&[next_token as u32], false) {
-                    generated_text.push_str(&text);
-                }
-            }
-
-            let device_info = format!("{:?}", loaded.device);
-            if generated_text.is_empty() {
-                Ok(("Unable to generate output.".to_string(), loaded.model_name.clone(), device_info))
-            } else {
-                Ok((generated_text.trim().to_string(), loaded.model_name.clone(), device_info))
-            }
-        }
-        Err(e) => {
-            tracing::warn!("Model load failed: {}; falling back to mock", e);
-            Ok(("Triage result: non‑urgent (mock – model unavailable)".to_string(), "mock".to_string(), "CPU (fallback)".to_string()))
-        }
-    }
+pub async fn generate(_redacted_prompt: &str) -> Result<(String, String, String)> {
+    tracing::info!("[MOCK] Inference skipped – returning placeholder");
+    tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+    Ok((
+        "Triage result: non‑urgent (mock)".to_string(),
+        "mock".to_string(),
+        "CPU (mock)".to_string(),
+    ))
 }