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 != ¤t) {
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, ×tamp()?)
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 let mut embedding_skipped = None;
219 if let Some(memory) = memory {
220 let backend = active
221 .as_ref()
222 .ok_or(HarnessError::Unavailable)?
223 .backend
224 .as_str();
225 let unsupported = !backends
226 .get(backend)
227 .map_err(|_| HarnessError::Unavailable)?
228 .can_embed();
229 let embedder = BackendEmbedder {
230 state: &state,
231 registry: &backends,
232 probe,
233 model: memory
234 .read_meta()
235 .map_err(|_| HarnessError::Invalid)?
236 .embedding
237 .map(|meta| meta.model)
238 .unwrap_or_else(|| "nomic-embed-text".into()),
239 };
240 let outcome = memory
241 .capture(
242 &options.message,
243 &response,
244 CaptureOptions {
245 timestamp: ×tamp()?,
246 embedder: (!unsupported).then_some(&embedder as &dyn crate::memory::Embedder),
247 embedding_unsupported: unsupported,
248 },
249 cancel,
250 )
251 .await;
252 embedding_skipped = outcome
253 .as_ref()
254 .ok()
255 .and_then(|result| result.embedding_skipped.clone());
256 captured = Some(outcome.is_ok());
257 }
258 let mut report = serde_json::json!({"content":response,"harness":options.provider,"memoryCaptured":captured});
259 if let Some(reason) = embedding_skipped {
260 report["embeddingSkipped"] = serde_json::json!(reason);
261 }
262 Ok(report)
263}
264
265#[cfg(test)]
266mod tests {
267 use super::*;
268
269 fn local_model(
270 requested: Option<&str>,
271 active: &crate::state::ServerState,
272 ) -> Result<(String, String), HarnessError> {
273 let catalog = rigspark_core::catalog::Catalog::parse(rigspark_core::MODELS_JSON).unwrap();
274 super::local_model(requested, active, &catalog)
275 }
276
277 fn active(backend: &str) -> crate::state::ServerState {
278 serde_json::from_value(serde_json::json!({
279 "backend": backend, "modelId": "llama3.1:8b", "endpoint": "http://127.0.0.1:11434",
280 "port": 11434, "ownedByUs": false
281 }))
282 .unwrap()
283 }
284
285 #[test]
286 fn local_cli_model_resolves_fuzzy_ids_and_keeps_memory_with_selected_model() {
287 let current = active("ollama");
288 assert_eq!(
289 local_model(Some("llama3.1:8"), ¤t).unwrap(),
290 ("llama3.1:8b".into(), "llama3.1:8b".into())
291 );
292 assert!(local_model(Some("llama3.1"), ¤t).is_err());
293 assert_eq!(
294 local_model(Some("qwen2.5:7b"), ¤t).unwrap(),
295 ("qwen2.5:7b".into(), "qwen2.5:7b".into())
296 );
297 assert!(local_model(Some("unknown-fixture-model"), ¤t).is_err());
298 }
299
300 #[test]
301 fn installed_context_variants_do_not_require_catalog_resolution() {
302 let mut current = active("ollama");
303 current.model_id = "uncatalogued:local".into();
304 current.runtime_model_id = Some("llmup-context-test:65536".into());
305 for requested in [
306 None,
307 Some("uncatalogued:local"),
308 Some("llmup-context-test:65536"),
309 ] {
310 assert_eq!(
311 local_model(requested, ¤t).unwrap(),
312 (
313 "llmup-context-test:65536".into(),
314 "uncatalogued:local".into()
315 )
316 );
317 }
318 }
319
320 #[test]
321 fn single_model_backends_reject_other_models_before_inference() {
322 for backend in ["mlx", "llamacpp", "lmstudio"] {
323 assert!(local_model(Some("qwen2.5:7b"), &active(backend)).is_err());
324 assert!(local_model(Some("llama3.1:8"), &active(backend)).is_ok());
325 }
326 }
327}