Skip to main content

rigspark_runtime/
native_chat.rs

1use crate::{
2    harness::{
3        DeltaSink, HarnessError, HarnessMessage, HarnessRequest, LocalHarness,
4        NativeRemoteTransport,
5    },
6    harness_registry::HarnessRegistry,
7    library::Library,
8    memory::{CaptureOptions, MemoryStore},
9    memory_backend::BackendEmbedder,
10    opencode::NativeOpenCodeRunner,
11    process_control::minimal_env,
12    state::{Config, StateStore},
13};
14use std::collections::BTreeMap;
15use tokio_util::sync::CancellationToken;
16
17pub struct NativeChatOptions {
18    pub provider: String,
19    pub model: Option<String>,
20    pub message: String,
21    pub agent: Option<String>,
22    pub skills: Vec<String>,
23    pub capture: bool,
24}
25pub fn timestamp() -> Result<String, HarnessError> {
26    time::OffsetDateTime::now_utc()
27        .format(&time::format_description::well_known::Rfc3339)
28        .map_err(|_| HarnessError::Invalid)
29}
30
31fn local_model(
32    requested: Option<&str>,
33    active: &crate::state::ServerState,
34    catalog: &rigspark_core::catalog::Catalog,
35) -> Result<(String, String), HarnessError> {
36    let runtime_id = active
37        .runtime_model_id
38        .as_deref()
39        .unwrap_or(&active.model_id);
40    let Some(requested) = requested else {
41        return Ok((runtime_id.into(), active.model_id.clone()));
42    };
43    if requested == active.model_id || requested == runtime_id {
44        return Ok((runtime_id.into(), active.model_id.clone()));
45    }
46    let resolved =
47        rigspark_core::catalog::resolve(catalog, requested).map_err(|_| HarnessError::Invalid)?;
48    if active.backend != "ollama" && resolved.model.id != active.model_id {
49        return Err(HarnessError::Invalid);
50    }
51    let runtime_id = if resolved.model.id == active.model_id {
52        runtime_id.to_owned()
53    } else {
54        resolved
55            .model
56            .source
57            .ollama
58            .clone()
59            .ok_or(HarnessError::Invalid)?
60    };
61    Ok((runtime_id, resolved.model.id.clone()))
62}
63pub async fn run(
64    options: &NativeChatOptions,
65    cancel: &CancellationToken,
66    sink: &mut DeltaSink<'_>,
67) -> Result<serde_json::Value, HarnessError> {
68    run_with_history(options, None, None, cancel, sink).await
69}
70pub async fn run_with_history(
71    options: &NativeChatOptions,
72    history: Option<&[HarnessMessage]>,
73    expected: Option<&crate::state::RuntimeState>,
74    cancel: &CancellationToken,
75    sink: &mut DeltaSink<'_>,
76) -> Result<serde_json::Value, HarnessError> {
77    if let Some(history) = history {
78        if history.len() > 19
79            || history
80                .iter()
81                .any(|message| !["user", "assistant"].contains(&message.role.as_str()))
82        {
83            return Err(HarnessError::Invalid);
84        }
85        HarnessRequest {
86            model: String::new(),
87            messages: history.to_vec(),
88            temperature: None,
89        }
90        .validate()?;
91    }
92    if options.message.trim().is_empty() || options.message.len() > 1024 * 1024 {
93        return Err(HarnessError::Invalid);
94    }
95    let config = Config::load().map_err(|_| HarnessError::Invalid)?;
96    let state = StateStore::new(config.clone());
97    let current = state.read().map_err(|_| HarnessError::Unavailable)?;
98    if expected.is_some_and(|expected| expected != &current) {
99        return Err(HarnessError::Drift);
100    }
101    let active = current.active;
102    let runtime = crate::native_runtime::NativeRuntime::new(config.clone())?;
103    let adapters = runtime.adapters();
104    let backends = adapters.registry();
105    let probe = &runtime.probe;
106    let remote = NativeRemoteTransport::new()?;
107    let mut env: BTreeMap<String, String> = minimal_env().into_iter().collect();
108    for name in [
109        "OPENAI_API_KEY",
110        "ANTHROPIC_API_KEY",
111        "OPENAI_COMPAT_BASE_URL",
112        "OPENAI_COMPAT_API_KEY",
113        "RIGSPARK_OPENCODE_UNRESTRICTED",
114    ] {
115        if let Ok(value) = std::env::var(name) {
116            env.insert(name.into(), value);
117        }
118    }
119    let opencode = NativeOpenCodeRunner {
120        binary: runtime.binary("opencode"),
121        env: env.clone(),
122    };
123    let registry = HarnessRegistry::builtins(
124        LocalHarness {
125            state: &state,
126            registry: &backends,
127            probe,
128        },
129        &remote,
130        &opencode,
131        &env,
132    )?;
133    let harness = registry.get(&options.provider)?;
134    if !harness.available().await {
135        return Err(HarnessError::Unavailable);
136    }
137    let (model, memory_owner) = if options.provider == "local" {
138        let loaded = crate::catalog_update::CatalogStore::official(&config.home)
139            .load()
140            .map_err(|_| HarnessError::Invalid)?;
141        local_model(
142            options.model.as_deref(),
143            active.as_ref().ok_or(HarnessError::Unavailable)?,
144            &loaded.catalog,
145        )?
146    } else {
147        (options.model.clone().unwrap_or_default(), String::new())
148    };
149    let mut messages = Vec::new();
150    if let Some(prompt) = Library::new(&config.home)
151        .compose(options.agent.as_deref(), &options.skills)
152        .map_err(|_| HarnessError::Invalid)?
153    {
154        messages.push(HarnessMessage {
155            role: "system".into(),
156            content: prompt,
157        });
158    }
159    let memory = if options.provider == "local" && options.capture {
160        let memory = MemoryStore::open(&config.home, &memory_owner, &timestamp()?)
161            .map_err(|_| HarnessError::Invalid)?;
162        let source = memory.load().map_err(|_| HarnessError::Invalid)?;
163        if let Some(persona) = source.system_prompt {
164            messages.push(HarnessMessage {
165                role: "system".into(),
166                content: persona,
167            });
168        }
169        if source.facts_present {
170            messages.push(HarnessMessage {
171                role: "system".into(),
172                content: source.facts_text,
173            });
174        }
175        if history.is_none() {
176            messages.extend(source.turns.into_iter().map(|turn| HarnessMessage {
177                role: turn.role,
178                content: turn.content,
179            }));
180        }
181        Some(memory)
182    } else {
183        None
184    };
185    if let Some(history) = history {
186        messages.extend_from_slice(history);
187    }
188    messages.push(HarnessMessage {
189        role: "user".into(),
190        content: options.message.clone(),
191    });
192    let mut emitted_bytes = 0usize;
193    let mut bounded_sink = |text: &str| {
194        emitted_bytes = emitted_bytes.saturating_add(text.len());
195        if history.is_some() && emitted_bytes > 1024 * 1024 {
196            return Err(HarnessError::Limit);
197        }
198        sink(text)
199    };
200    let response = harness
201        .chat(
202            &HarnessRequest {
203                model,
204                messages,
205                temperature: None,
206            },
207            cancel,
208            &mut bounded_sink,
209        )
210        .await?;
211    if history.is_some() && response.len() > 1024 * 1024 {
212        return Err(HarnessError::Limit);
213    }
214    if cancel.is_cancelled() {
215        return Err(HarnessError::Cancelled);
216    }
217    let mut captured = None;
218    if let Some(memory) = memory {
219        let backend = active
220            .as_ref()
221            .ok_or(HarnessError::Unavailable)?
222            .backend
223            .as_str();
224        let unsupported = !backends
225            .get(backend)
226            .map_err(|_| HarnessError::Unavailable)?
227            .can_embed();
228        let embedder = BackendEmbedder {
229            state: &state,
230            registry: &backends,
231            probe,
232            model: memory
233                .read_meta()
234                .map_err(|_| HarnessError::Invalid)?
235                .embedding
236                .map(|meta| meta.model)
237                .unwrap_or_else(|| "nomic-embed-text".into()),
238        };
239        captured = Some(
240            memory
241                .capture(
242                    &options.message,
243                    &response,
244                    CaptureOptions {
245                        timestamp: &timestamp()?,
246                        embedder: (!unsupported)
247                            .then_some(&embedder as &dyn crate::memory::Embedder),
248                        embedding_unsupported: unsupported,
249                    },
250                    cancel,
251                )
252                .await
253                .is_ok(),
254        );
255    }
256    Ok(serde_json::json!({"content":response,"harness":options.provider,"memoryCaptured":captured}))
257}
258
259#[cfg(test)]
260mod tests {
261    use super::*;
262
263    fn local_model(
264        requested: Option<&str>,
265        active: &crate::state::ServerState,
266    ) -> Result<(String, String), HarnessError> {
267        let catalog = rigspark_core::catalog::Catalog::parse(rigspark_core::MODELS_JSON).unwrap();
268        super::local_model(requested, active, &catalog)
269    }
270
271    fn active(backend: &str) -> crate::state::ServerState {
272        serde_json::from_value(serde_json::json!({
273            "backend": backend, "modelId": "llama3.1:8b", "endpoint": "http://127.0.0.1:11434",
274            "port": 11434, "ownedByUs": false
275        }))
276        .unwrap()
277    }
278
279    #[test]
280    fn local_cli_model_resolves_fuzzy_ids_and_keeps_memory_with_selected_model() {
281        let current = active("ollama");
282        assert_eq!(
283            local_model(Some("llama3.1:8"), &current).unwrap(),
284            ("llama3.1:8b".into(), "llama3.1:8b".into())
285        );
286        assert!(local_model(Some("llama3.1"), &current).is_err());
287        assert_eq!(
288            local_model(Some("qwen2.5:7b"), &current).unwrap(),
289            ("qwen2.5:7b".into(), "qwen2.5:7b".into())
290        );
291        assert!(local_model(Some("unknown-fixture-model"), &current).is_err());
292    }
293
294    #[test]
295    fn installed_context_variants_do_not_require_catalog_resolution() {
296        let mut current = active("ollama");
297        current.model_id = "uncatalogued:local".into();
298        current.runtime_model_id = Some("llmup-context-test:65536".into());
299        for requested in [
300            None,
301            Some("uncatalogued:local"),
302            Some("llmup-context-test:65536"),
303        ] {
304            assert_eq!(
305                local_model(requested, &current).unwrap(),
306                (
307                    "llmup-context-test:65536".into(),
308                    "uncatalogued:local".into()
309                )
310            );
311        }
312    }
313
314    #[test]
315    fn single_model_backends_reject_other_models_before_inference() {
316        for backend in ["mlx", "llamacpp", "lmstudio"] {
317            assert!(local_model(Some("qwen2.5:7b"), &active(backend)).is_err());
318            assert!(local_model(Some("llama3.1:8"), &active(backend)).is_ok());
319        }
320    }
321}