//! Smoke test / demo for the Alter-Ego serving system. //! //! Default: builds a randomly-initialized small SAN (no trained checkpoint or //! network needed) and runs the real-time loop. //! //! With `--ckpt `: loads a real checkpoint produced by the Kaggle training //! pipeline (`training/kernels/train.py`) — proving the Python->Rust format //! compatibility — and runs a few turns against the trained model. use std::sync::Arc; use rand::Rng; use alter_ego_serve::checkpoint::load_checkpoint; use alter_ego_serve::ecosystem::Ecosystem; use alter_ego_serve::model::{Judge, MockJudge, Needle2Judge, SanConfig}; #[cfg(not(needle_ffi))] compile_error!( "The alter-ego engine is a resident (in-process) model and requires the \ GNU target (x86_64-pc-windows-gnu). It is set as the default in \ .cargo/config.toml — build with `cargo build`, not the MSVC target." ); #[tokio::main] async fn main() -> anyhow::Result<()> { env_logger::init(); let args: Vec = std::env::args().collect(); let get = |flag: &str| { args.iter() .position(|a| a == flag) .and_then(|p| args.get(p + 1).cloned()) }; if let Some(path) = get("--tokenizer") { // validate early so failures are loud alter_ego_serve::tokenizer_bpe::HfBpe::from_file(&path)?; println!("tokenizer OK: {path}"); } if let Some(n) = get("--calibrate") { let n: usize = n.parse().unwrap_or(200); let jd = get("--judge"); return run_calibration(n, jd.as_deref()).await; } if let Some(spec) = get("--pack") { // --pack dir:out.aeg let (dir, out) = spec.split_once(':').expect("--pack dir:out.aeg"); let n = alter_ego_serve::bundle::pack_dir(dir, out, None)?; println!("packed {n} files -> {out}"); return Ok(()); } if let Some(spec) = get("--unpack") { let (inp, dir) = spec.split_once(':').expect("--unpack in.aeg:dir"); let n = alter_ego_serve::bundle::unpack(inp, dir)?; println!("unpacked {n} entries -> {dir}"); return Ok(()); } if let Some(n) = get("--bench") { alter_ego_serve::bench::run(n.parse().unwrap_or(30)); return Ok(()); } if args.iter().any(|a| a == "--serve") { let port: u16 = get("--port").and_then(|p| p.parse().ok()).unwrap_or(8080); let ckpt = args.iter().position(|a| a == "--ckpt").map(|p| args[p + 1].clone()); let tok = get("--tokenizer"); let jd = get("--judge"); return run_server(port, ckpt.as_deref(), tok.as_deref(), jd.as_deref()).await; } for (flag, writer) in [ ("--export-safetensors", 0usize), ("--export-gguf", 1usize), ] { if let Some(path) = get(flag) { let (params, cfg) = load_params_for_export( args.iter().position(|a| a == "--ckpt").map(|p| args[p + 1].clone()).as_deref(), )?; match writer { 0 => alter_ego_serve::export::write_safetensors(¶ms, &path)?, _ => alter_ego_serve::export::write_gguf_gpt2(¶ms, &cfg, &path)?, } println!("exported {flag} -> {path} ({} tensors)", params.len()); return Ok(()); } } let judge_dir = get("--judge"); if let Some(pos) = args.iter().position(|a| a == "--ckpt") { let dir = args.get(pos + 1).expect("missing path after --ckpt"); return run_real_checkpoint(dir, judge_dir.as_deref()).await; } run_smoke_test().await } fn prod_cfg() -> alter_ego_serve::model::SanConfig { alter_ego_serve::model::SanConfig { vocab: 8192, d_model: 512, n_layers: 16, ffn_ratio: 4, n_heads: 8, max_seq_len: 256, tied_embeddings: true, } } fn load_params_for_export( ckpt: Option<&str>, ) -> anyhow::Result<(std::collections::HashMap>, alter_ego_serve::model::SanConfig)> { let cfg = prod_cfg(); match ckpt { Some(dir) => { let (params, meta) = alter_ego_serve::checkpoint::load_checkpoint(std::path::Path::new(dir), true)?; println!("export source: checkpoint step={} tensors={}", meta.step, params.len()); Ok((params, cfg)) } None => { println!("export source: deterministic random base (no --ckpt given)"); let s = alter_ego_serve::main_helpers::random_student(&cfg); Ok((s.params, cfg)) } } } async fn run_calibration(n: usize, judge_dir: Option<&str>) -> anyhow::Result<()> { use alter_ego_serve::calibration; use alter_ego_serve::model::{Judge, MockJudge}; let judge: Box = match judge_dir { Some("cactus") => build_cactus_judge()?, _ => Box::new(MockJudge), }; calibration::set_judge(judge); let data = calibration::generate(n); let (base, best_w, best) = calibration::run(&data); println!("=== Alter-Ego trust calibration (n={n}) ==="); println!( "baseline weights: acc={:.3} P={:.3} R={:.3} F1={:.3}", base.accuracy(), base.precision(), base.recall(), base.f1() ); println!( "grid best: sv={:.2} nv={:.2} vf={:.2} | acc={:.3} P={:.3} R={:.3} F1={:.3}", best_w.safety, best_w.novelty, best_w.verifiability, best.accuracy(), best.precision(), best.recall(), best.f1() ); Ok(()) } async fn run_server( port: u16, ckpt_dir: Option<&str>, tokenizer_path: Option<&str>, judge_dir: Option<&str>, ) -> anyhow::Result<()> { use alter_ego_serve::server::{router, AppState}; use alter_ego_serve::tokenizer_bpe::{Detokenizer, HfBpe, StubDetok}; let cfg = prod_cfg(); let mut eco = match ckpt_dir { Some(dir) => { let (params, meta) = alter_ego_serve::checkpoint::load_checkpoint(std::path::Path::new(dir), true)?; println!("skull online: step={} tensors={}", meta.step, params.len()); Ecosystem::from_checkpoint(params, cfg.clone(), make_judge(judge_dir)?, 1024, 0.01)? } None => { let student = alter_ego_serve::main_helpers::random_student(&cfg); Ecosystem::new(student, make_judge(judge_dir)?, 1024, 0.01) } }; if let Some(tp) = tokenizer_path { let t = HfBpe::from_file(tp)?; eco.set_tokenizer(Box::new(t)); println!("tokenizer attached: {tp}"); } let detok: Box = match tokenizer_path { Some(tp) => Box::new(HfBpe::from_file(tp)?), None => Box::new(StubDetok), }; let state = Arc::new(AppState { eco: tokio::sync::Mutex::new(eco), model_id: "alter-ego-local".into(), detok, }); let app = router(state.clone()); // E3 wiring: background LoRA micro-steps on the VALIDATED backlog + // ledger re-validation + skill maintenance, strictly between turns. let bg = state; tokio::spawn(async move { let mut iv = tokio::time::interval(std::time::Duration::from_secs(20)); iv.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay); loop { iv.tick().await; let mut eco = bg.eco.lock().await; let _ = eco.background_micro_steps(8); let _ = eco.revalidate_queued(8); let _r = eco.skill_maintenance(); } }); let addr = format!("0.0.0.0:{port}"); println!("OpenAI-compatible API listening on http://{addr}/v1"); let listener = tokio::net::TcpListener::bind(&addr).await?; axum::serve(listener, app).await?; Ok(()) } /// Load a real Kaggle-trained checkpoint and run the loop against it. async fn run_real_checkpoint(dir: &str, judge_dir: Option<&str>) -> anyhow::Result<()> { println!("Loading checkpoint from {dir} ..."); let (params, meta) = load_checkpoint(std::path::Path::new(dir), true)?; println!( "checkpoint: step={} tokens={} tensors={}", meta.step, meta.tokens, params.len() ); // Architecture must match training/kernels/train.py (CFG["student"]). let cfg = SanConfig { vocab: 8192, d_model: 512, n_layers: 16, ffn_ratio: 4, n_heads: 8, max_seq_len: 256, tied_embeddings: true, }; let student = alter_ego_serve::model::San::from_params(params, cfg.clone())?; // Use the real alter-ego judge if a judge checkpoint is supplied. let judge: Box = match judge_dir.as_deref() { Some("cactus") => build_cactus_judge()?, Some(jd) => { println!("Loading alter-ego judge (San) from {jd} ..."); Box::new(Needle2Judge::from_checkpoint(jd, cfg.clone())?) } None => Box::new(MockJudge), }; let mut orch = Ecosystem::new(student, judge, 1024, 0.01); let mut rng = rand::thread_rng(); for turn in 0..4 { let input: Vec = (0..16).map(|_| rng.gen_range(0..cfg.vocab as u32)).collect(); let res = orch.turn(&input, 8)?; println!( "[turn {turn}] verdict={} trust={:.3} out_tokens={}", res.verdict, res.score.total, res.output_ids.len() ); tokio::time::sleep(std::time::Duration::from_millis(20)).await; } println!( "real-checkpoint memory: episodic={} semantic={} replay={}", orch.memory.episodic.len(), orch.memory.semantic.len(), orch.memory.replay.items.len() ); println!("real-checkpoint load OK"); Ok(()) } /// Dependency-free smoke test with a randomly-initialized small model. async fn run_smoke_test() -> anyhow::Result<()> { let cfg = SanConfig { vocab: 512, d_model: 64, n_layers: 4, ffn_ratio: 4, n_heads: 4, max_seq_len: 64, tied_embeddings: true, }; let student = alter_ego_serve::model::San::from_params(build_random_params(&cfg), cfg.clone())?; let mut orch = Ecosystem::new(student, Box::new(MockJudge), 1024, 0.01); println!( "Alter-Ego serving smoke test | vocab={} d={} layers={}", cfg.vocab, cfg.d_model, cfg.n_layers ); let mut rng = rand::thread_rng(); for turn in 0..8 { let input: Vec = (0..48).map(|_| rng.gen_range(0..cfg.vocab as u32)).collect(); let res = orch.turn(&input, 6)?; println!( "[turn {turn}] verdict={} trust={:.3} (struct={:.2} cons={:.2} verif={:.2} nov={:.2} safe={:.2}) out_tokens={}", res.verdict, res.score.total, res.score.structural, res.score.consistency, res.score.verifiability, res.score.novelty, res.score.safety, res.output_ids.len() ); tokio::time::sleep(std::time::Duration::from_millis(20)).await; } println!( "memory: episodic={} semantic={} replay={}", orch.memory.episodic.len(), orch.memory.semantic.len(), orch.memory.replay.items.len() ); println!("smoke test OK"); Ok(()) } fn build_random_params(cfg: &SanConfig) -> std::collections::HashMap> { let mut rng = rand::thread_rng(); let d = cfg.d_model; let ffn = cfg.ffn_ratio * d; let v = cfg.vocab; let l = cfg.n_layers; let maxlen = cfg.max_seq_len; let mut p = std::collections::HashMap::new(); p.insert("tok_emb.weight".into(), rand_arr(v, d, &mut rng)); p.insert("pos".into(), rand_arr(maxlen, d, &mut rng)); p.insert("head.weight".into(), rand_arr(v, d, &mut rng)); for i in 0..l { p.insert(format!("blocks.{i}.ln1.weight"), rand_arr(1, d, &mut rng)); p.insert(format!("blocks.{i}.ln1.bias"), rand_arr(1, d, &mut rng)); p.insert(format!("blocks.{i}.attn.qkv.weight"), rand_arr(3 * d, d, &mut rng)); p.insert(format!("blocks.{i}.attn.qkv.bias"), rand_arr(1, 3 * d, &mut rng)); p.insert(format!("blocks.{i}.attn.o.weight"), rand_arr(d, d, &mut rng)); p.insert(format!("blocks.{i}.attn.o.bias"), rand_arr(1, d, &mut rng)); p.insert(format!("blocks.{i}.ln2.weight"), rand_arr(1, d, &mut rng)); p.insert(format!("blocks.{i}.ln2.bias"), rand_arr(1, d, &mut rng)); p.insert(format!("blocks.{i}.mlp.0.weight"), rand_arr(ffn, d, &mut rng)); p.insert(format!("blocks.{i}.mlp.0.bias"), rand_arr(1, ffn, &mut rng)); p.insert(format!("blocks.{i}.mlp.2.weight"), rand_arr(d, ffn, &mut rng)); p.insert(format!("blocks.{i}.mlp.2.bias"), rand_arr(1, d, &mut rng)); } p.insert("ln_f.weight".into(), rand_arr(1, d, &mut rng)); p.insert("ln_f.bias".into(), rand_arr(1, d, &mut rng)); p } fn rand_arr(rows: usize, cols: usize, rng: &mut impl Rng) -> ndarray::Array2 { let data: Vec = (0..rows * cols).map(|_| (rng.gen::() - 0.5) * 0.1).collect(); ndarray::Array2::from_shape_vec((rows, cols), data).unwrap() } /// Build the Cactus-Needle alter-ego judge as a *resident* model: the engine /// is loaded in-process (no subprocess, no Python at inference time). This is /// the alter ego of the unified ecosystem, time-sliced alongside the student. fn make_judge(judge_dir: Option<&str>) -> anyhow::Result> { match judge_dir { Some("cactus") => build_cactus_judge(), Some(p) => Ok(Box::new(Needle2Judge::from_checkpoint(p, prod_cfg())?)), None => Ok(Box::new(MockJudge)), } } #[allow(dead_code)] fn build_cactus_judge_unused_marker() {} fn build_cactus_judge() -> anyhow::Result> { #[cfg(needle_ffi)] { println!("Using Cactus-Needle (Needle 2) alter-ego judge [in-process engine]"); Ok(Box::new(alter_ego_serve::NeedleModel::new("needle/needle2.cact")?)) } #[cfg(not(needle_ffi))] { // Unreachable: the compile_error! above fires first on the MSVC target. anyhow::bail!("needle_ffi not enabled — build with the GNU target") } }