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 != ¤t) {
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, ×tamp()?)
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: ×tamp()?,
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"), ¤t).unwrap(),
273 ("llama3.1:8b".into(), "llama3.1:8b".into())
274 );
275 assert!(local_model(Some("llama3.1"), ¤t).is_err());
276 assert_eq!(
277 local_model(Some("qwen2.5:7b"), ¤t).unwrap(),
278 ("qwen2.5:7b".into(), "qwen2.5:7b".into())
279 );
280 assert!(local_model(Some("unknown-fixture-model"), ¤t).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, ¤t).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}