muthr 0.1.24

A zero-trust orchestrator that automates secure inference and isolated execution of local AI agents.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use serde_json::{Map, Value};
use std::fs;
use std::path::{Path, PathBuf};

use crate::preset::Preset;

fn replace_placeholders_in_value(value: &mut Value, replacements: &[(&str, &str)]) {
    match value {
        Value::String(s) => {
            for (from, to) in replacements {
                *s = s.replace(from, to);
            }
        }
        Value::Array(arr) => arr
            .iter_mut()
            .for_each(|v| replace_placeholders_in_value(v, replacements)),
        Value::Object(map) => map
            .values_mut()
            .for_each(|v| replace_placeholders_in_value(v, replacements)),
        _ => {}
    }
}

pub fn generate_runtime_config(
    preset: &Preset,
    port: u16,
    mount_point: &Path,
) -> Result<PathBuf, color_eyre::Report> {
    let home = std::env::var("HOME")?;
    let template_path = PathBuf::from(&home).join(".config/muthr/clients/opencode-config.json");

    let content = fs::read_to_string(&template_path)?;
    let primary_slot = preset
        .slots
        .first()
        .ok_or_else(|| color_eyre::eyre::eyre!("No slots found in preset"))?;

    let model_id = format!("01-{}", primary_slot.name);
    let ctx_window = primary_slot.ctx_size.unwrap_or(200000);

    let mut config: Value = serde_json::from_str(&content)?;

    let ctx_str = ctx_window.to_string();
    let port_str = port.to_string();
    let mount_str = mount_point.to_string_lossy().into_owned();

    let replacements: Vec<(&str, &str)> = vec![
        ("__CTX_WINDOW__", ctx_str.as_str()),
        ("__DEFAULT_MODEL__", model_id.as_str()),
        ("__LLAMA_PORT__", port_str.as_str()),
        ("__INJECTED_MOUNT_POINT__", mount_str.as_str()),
    ];

    replace_placeholders_in_value(&mut config, &replacements);

    if let Some(obj) = config.as_object_mut() {
        obj.insert(
            "model".to_string(),
            Value::String(format!("llama-cpp/{}", model_id)),
        );
        obj.insert(
            "small_model".to_string(),
            Value::String(format!("llama-cpp/{}", model_id)),
        );

        if let Some(agent) = obj.get_mut("agent").and_then(|a| a.as_object_mut()) {
            for (_name, agent_cfg) in agent.iter_mut() {
                if let Some(agent_obj) = agent_cfg.as_object_mut() {
                    agent_obj.insert(
                        "model".to_string(),
                        Value::String(format!("llama-cpp/{}", model_id)),
                    );
                }
            }
        }

        if let Some(provider) = obj.get_mut("provider").and_then(|p| p.get_mut("llama-cpp")) {
            if let Some(p_obj) = provider.as_object_mut() {
                let mut options = Map::new();
                options.insert(
                    "baseURL".to_string(),
                    Value::String(format!("http://host.lima.internal:{}/v1", port)),
                );
                p_obj.insert("options".to_string(), Value::Object(options));

                let mut models_map = Map::new();
                let mut inner_model = Map::new();
                inner_model.insert("name".to_string(), Value::String(model_id.clone()));
                inner_model.insert("tools".to_string(), Value::Bool(true));
                inner_model.insert(
                    "context_window".to_string(),
                    Value::Number(ctx_window.into()),
                );

                let mut limit_map = Map::new();
                limit_map.insert("context".to_string(), Value::Number(ctx_window.into()));
                limit_map.insert("output".to_string(), Value::Number(8192.into()));
                inner_model.insert("limit".to_string(), Value::Object(limit_map));

                models_map.insert(model_id, Value::Object(inner_model));
                p_obj.insert("models".to_string(), Value::Object(models_map));
            }
        }
    }

    let runtime_dir = PathBuf::from(&home).join(".cache/muthr/opencode_runtimes");
    fs::create_dir_all(&runtime_dir)?;

    let runtime_path = runtime_dir.join(format!("opencode-runtime-{}.json", preset.name));
    fs::write(&runtime_path, serde_json::to_string_pretty(&config)?)?;

    Ok(runtime_path)
}