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