Skip to main content

rigspark_runtime/
native_runtime.rs

1use crate::{
2    adapters::{BackendKind, RuntimeAdapter},
3    command::NativeCommandRunner,
4    http::NativeTransport,
5    identity::NativeProcessProbe,
6    lifecycle::Registry,
7    process_control::{NativeProcessControl, resolve_binary, resolve_bitnet_server},
8    special_adapters::{LmStudioAdapter, MlxAdapter},
9    state::Config,
10};
11use std::path::PathBuf;
12
13pub struct NativeRuntime {
14    http: NativeTransport,
15    pub probe: NativeProcessProbe,
16    control: NativeProcessControl,
17    commands: NativeCommandRunner,
18    home: PathBuf,
19    config: Config,
20    ollama_models: PathBuf,
21}
22pub struct NativeAdapters<'runtime> {
23    ollama: RuntimeAdapter<'runtime>,
24    llama: RuntimeAdapter<'runtime>,
25    bitnet: RuntimeAdapter<'runtime>,
26    mlx: MlxAdapter<'runtime>,
27    studio: LmStudioAdapter<'runtime>,
28}
29impl NativeRuntime {
30    pub fn new(config: Config) -> Result<Self, crate::harness::HarnessError> {
31        let home = std::env::var_os("HOME")
32            .or_else(|| std::env::var_os("USERPROFILE"))
33            .map(PathBuf::from)
34            .ok_or(crate::harness::HarnessError::Invalid)?;
35        let ollama_models = std::env::var_os("OLLAMA_MODELS")
36            .map(PathBuf::from)
37            .unwrap_or_else(|| home.join(".ollama/models"));
38        crate::command::OllamaCommandContext::new("http://127.0.0.1:11434", &ollama_models)
39            .map_err(|_| crate::harness::HarnessError::Invalid)?;
40        Ok(Self {
41            http: NativeTransport::new().map_err(|_| crate::harness::HarnessError::Transport)?,
42            probe: NativeProcessProbe,
43            control: NativeProcessControl,
44            commands: NativeCommandRunner,
45            home,
46            config,
47            ollama_models,
48        })
49    }
50    pub fn binary(&self, name: &str) -> PathBuf {
51        let resolved = if name == "bitnet" {
52            resolve_bitnet_server()
53        } else {
54            resolve_binary(name)
55        };
56        resolved.unwrap_or_else(|_| self.config.home.join(".unavailable").join(name))
57    }
58    pub fn adapters(&self) -> NativeAdapters<'_> {
59        let mut ollama = RuntimeAdapter::new(
60            BackendKind::Ollama,
61            self.binary("ollama"),
62            &self.http,
63            &self.probe,
64            &self.control,
65        );
66        ollama.ollama_models = Some(self.ollama_models.clone());
67        NativeAdapters {
68            ollama,
69            llama: RuntimeAdapter::new(
70                BackendKind::LlamaCpp,
71                self.binary("llama-server"),
72                &self.http,
73                &self.probe,
74                &self.control,
75            ),
76            bitnet: RuntimeAdapter::new(
77                BackendKind::BitNet,
78                self.binary("bitnet"),
79                &self.http,
80                &self.probe,
81                &self.control,
82            ),
83            mlx: MlxAdapter {
84                binary: self.binary("python3"),
85                http: &self.http,
86                probe: &self.probe,
87                control: &self.control,
88                commands: &self.commands,
89                token: None,
90            },
91            studio: LmStudioAdapter {
92                binary: self.binary("lms"),
93                trusted_executables: crate::application::studio_trust(&self.home),
94                http: &self.http,
95                probe: &self.probe,
96                commands: &self.commands,
97                token: std::env::var("LM_API_TOKEN").ok(),
98            },
99        }
100    }
101}
102impl NativeAdapters<'_> {
103    pub fn registry(&self) -> Registry<'_> {
104        Registry::new(vec![
105            &self.ollama,
106            &self.llama,
107            &self.mlx,
108            &self.studio,
109            &self.bitnet,
110        ])
111    }
112}