1use futures_util::TryStreamExt;
2use serde::{Deserialize, Serialize};
3use serde_json::{Value, json};
4use std::{collections::BTreeMap, pin::Pin, time::Duration};
5use tokio::io::{AsyncRead, AsyncReadExt};
6use tokio_util::sync::CancellationToken;
7
8#[derive(Debug, thiserror::Error)]
9pub enum HarnessError {
10 #[error("invalid harness input or configuration")]
11 Invalid,
12 #[error("provider is unavailable")]
13 Unavailable,
14 #[error("provider transport failed")]
15 Transport,
16 #[error("provider returned HTTP {0}")]
17 Status(u16),
18 #[error("invalid provider response")]
19 Response,
20 #[error("harness output exceeds limit")]
21 Limit,
22 #[error("harness request cancelled")]
23 Cancelled,
24 #[error("harness request timed out")]
25 Timeout,
26 #[error("active runtime changed")]
27 Drift,
28}
29pub struct Secret(String);
30impl Secret {
31 pub fn new(raw: &str) -> Result<Self, HarnessError> {
32 let value = raw.trim();
33 if value.is_empty()
34 || value.len() > 4096
35 || value.bytes().any(|byte| !(32..=126).contains(&byte))
36 {
37 return Err(HarnessError::Invalid);
38 }
39 Ok(Self(value.into()))
40 }
41 pub(crate) fn expose(&self) -> &str {
42 &self.0
43 }
44}
45impl std::fmt::Debug for Secret {
46 fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
47 formatter.write_str("[REDACTED]")
48 }
49}
50#[derive(Debug, Clone, Serialize, Deserialize)]
51#[serde(deny_unknown_fields)]
52pub struct HarnessMessage {
53 pub role: String,
54 pub content: String,
55}
56#[derive(Debug, Clone, Serialize, Deserialize)]
57#[serde(deny_unknown_fields)]
58pub struct HarnessRequest {
59 pub model: String,
60 pub messages: Vec<HarnessMessage>,
61 pub temperature: Option<f64>,
62}
63impl HarnessRequest {
64 pub fn validate(&self) -> Result<(), HarnessError> {
65 if self.model.len() > 8192
66 || self.model.chars().any(char::is_control)
67 || self.messages.len() > 10000
68 || self
69 .messages
70 .iter()
71 .any(|message| !["system", "user", "assistant"].contains(&message.role.as_str()))
72 || self
73 .messages
74 .iter()
75 .map(|message| message.content.len())
76 .sum::<usize>()
77 > 4 * 1024 * 1024
78 || self.temperature.is_some_and(|value| !value.is_finite())
79 {
80 return Err(HarnessError::Invalid);
81 }
82 Ok(())
83 }
84}
85#[derive(Debug, Clone, Copy, PartialEq, Eq)]
86pub enum Provider {
87 OpenAi,
88 Claude,
89 Compatible,
90}
91pub struct RemoteRequest {
92 pub url: url::Url,
93 pub body: Value,
94 pub headers: BTreeMap<String, String>,
95}
96pub struct RemoteResponse {
97 pub status: u16,
98 pub body: Pin<Box<dyn AsyncRead + Send>>,
99}
100#[async_trait::async_trait]
101pub trait RemoteTransport: Send + Sync {
102 async fn send(&self, request: RemoteRequest) -> Result<RemoteResponse, HarnessError>;
103}
104pub struct NativeRemoteTransport {
105 client: reqwest::Client,
106}
107struct Resolver;
108impl reqwest::dns::Resolve for Resolver {
109 fn resolve(&self, name: reqwest::dns::Name) -> reqwest::dns::Resolving {
110 Box::pin(async move {
111 if name.as_str() == "localhost" {
112 return Ok(Box::new(
113 [
114 std::net::SocketAddr::from(([127, 0, 0, 1], 0)),
115 std::net::SocketAddr::from(([0, 0, 0, 0, 0, 0, 0, 1], 0)),
116 ]
117 .into_iter(),
118 ) as reqwest::dns::Addrs);
119 }
120 let addresses = tokio::time::timeout(
121 Duration::from_secs(5),
122 tokio::net::lookup_host((name.as_str(), 0)),
123 )
124 .await
125 .map_err(|_| std::io::Error::other("DNS timeout"))??;
126 let addresses = crate::acquire::public_addresses(addresses.take(65).collect())
127 .map_err(std::io::Error::other)?;
128 Ok(Box::new(addresses.into_iter()) as reqwest::dns::Addrs)
129 })
130 }
131}
132impl NativeRemoteTransport {
133 pub fn new() -> Result<Self, HarnessError> {
134 Ok(Self {
135 client: reqwest::Client::builder()
136 .redirect(reqwest::redirect::Policy::none())
137 .no_proxy()
138 .dns_resolver(std::sync::Arc::new(Resolver))
139 .connect_timeout(Duration::from_secs(10))
140 .timeout(Duration::from_secs(120))
141 .build()
142 .map_err(|_| HarnessError::Transport)?,
143 })
144 }
145}
146pub fn external_url(raw: &str) -> Result<url::Url, HarnessError> {
147 if raw.len() > 2048 || raw.chars().any(char::is_control) {
148 return Err(HarnessError::Invalid);
149 }
150 let url = url::Url::parse(raw).map_err(|_| HarnessError::Invalid)?;
151 if !url.username().is_empty() || url.password().is_some() || url.fragment().is_some() {
152 return Err(HarnessError::Invalid);
153 }
154 let local = match url.host() {
155 Some(url::Host::Ipv4(address)) => address.is_loopback(),
156 Some(url::Host::Ipv6(address)) => address.is_loopback(),
157 Some(url::Host::Domain(domain)) => domain == "localhost",
158 None => return Err(HarnessError::Invalid),
159 };
160 if (url.scheme() != "https" && !(local && url.scheme() == "http"))
161 || (!local
162 && url.host().is_some_and(|host| match host {
163 url::Host::Ipv4(address) => {
164 crate::acquire::public_addresses(vec![std::net::SocketAddr::new(
165 address.into(),
166 443,
167 )])
168 .is_err()
169 }
170 url::Host::Ipv6(address) => {
171 crate::acquire::public_addresses(vec![std::net::SocketAddr::new(
172 address.into(),
173 443,
174 )])
175 .is_err()
176 }
177 _ => false,
178 }))
179 {
180 return Err(HarnessError::Invalid);
181 }
182 Ok(url)
183}
184#[async_trait::async_trait]
185impl RemoteTransport for NativeRemoteTransport {
186 async fn send(&self, request: RemoteRequest) -> Result<RemoteResponse, HarnessError> {
187 external_url(request.url.as_str())?;
188 let mut builder = self.client.post(request.url).json(&request.body);
189 for (name, value) in request.headers {
190 let mut header = reqwest::header::HeaderValue::from_str(&value)
191 .map_err(|_| HarnessError::Invalid)?;
192 header.set_sensitive(true);
193 builder = builder.header(name, header);
194 }
195 let response = builder.send().await.map_err(|_| HarnessError::Transport)?;
196 let status = response.status().as_u16();
197 Ok(RemoteResponse {
198 status,
199 body: Box::pin(tokio_util::io::StreamReader::new(
200 response
201 .bytes_stream()
202 .map_err(|_| std::io::Error::other("provider body failed")),
203 )),
204 })
205 }
206}
207pub type DeltaSink<'sink> =
208 dyn for<'text> FnMut(&'text str) -> Result<(), HarnessError> + Send + 'sink;
209#[async_trait::async_trait]
210pub trait ChatHarness: Send + Sync {
211 fn name(&self) -> &'static str;
212 async fn available(&self) -> bool;
213 async fn chat(
214 &self,
215 request: &HarnessRequest,
216 cancel: &CancellationToken,
217 on_delta: &mut DeltaSink<'_>,
218 ) -> Result<String, HarnessError>;
219}
220pub struct RemoteHarness<'runtime> {
221 provider: Provider,
222 url: url::Url,
223 key: Option<Secret>,
224 transport: &'runtime dyn RemoteTransport,
225 maximum: usize,
226}
227impl<'runtime> RemoteHarness<'runtime> {
228 pub fn new(
229 provider: Provider,
230 endpoint: &str,
231 key: Option<Secret>,
232 transport: &'runtime dyn RemoteTransport,
233 ) -> Result<Self, HarnessError> {
234 let url = external_url(endpoint)?;
235 let required = match provider {
236 Provider::OpenAi => Some("api.openai.com"),
237 Provider::Claude => Some("api.anthropic.com"),
238 Provider::Compatible => None,
239 };
240 if required.is_some_and(|host| url.scheme() != "https" || url.host_str() != Some(host))
241 || required.is_some() && key.is_none()
242 {
243 return Err(HarnessError::Invalid);
244 }
245 Ok(Self {
246 provider,
247 url,
248 key,
249 transport,
250 maximum: 16 * 1024 * 1024,
251 })
252 }
253 pub fn with_limit(mut self, maximum: usize) -> Result<Self, HarnessError> {
254 if maximum == 0 || maximum > 16 * 1024 * 1024 {
255 return Err(HarnessError::Invalid);
256 }
257 self.maximum = maximum;
258 Ok(self)
259 }
260 pub async fn chat(
261 &self,
262 input: &HarnessRequest,
263 cancel: &CancellationToken,
264 on_delta: &mut DeltaSink<'_>,
265 ) -> Result<String, HarnessError> {
266 input.validate()?;
267 if cancel.is_cancelled() {
268 return Err(HarnessError::Cancelled);
269 }
270 let model = if input.model.is_empty() {
271 match self.provider {
272 Provider::OpenAi => "gpt-4o-mini",
273 Provider::Claude => "claude-3-5-haiku-20241022",
274 Provider::Compatible => "local-model",
275 }
276 } else {
277 &input.model
278 };
279 let messages:Vec<_>=input.messages.iter().filter(|message|self.provider!=Provider::Claude||message.role!="system").map(|message|json!({"role":message.role,"content":rigspark_core::reports::strip_control(&message.content)})).collect();
280 let mut body = json!({"model":model,"messages":messages,"stream":true});
281 crate::usage::begin();
282 if self.provider != Provider::Claude {
283 body["stream_options"] = json!({"include_usage":true});
284 }
285 if self.provider == Provider::Claude {
286 body["max_tokens"] = json!(1024);
287 }
288 if let Some(temperature) = input.temperature {
289 body["temperature"] = json!(temperature);
290 }
291 let mut headers = BTreeMap::new();
292 if let Some(key) = &self.key {
293 if self.provider == Provider::Claude {
294 headers.insert("x-api-key".into(), key.expose().into());
295 headers.insert("anthropic-version".into(), "2023-06-01".into());
296 } else {
297 headers.insert("authorization".into(), format!("Bearer {}", key.expose()));
298 }
299 }
300 let operation = async {
301 let response = self
302 .transport
303 .send(RemoteRequest {
304 url: self.url.clone(),
305 body,
306 headers,
307 })
308 .await?;
309 if !(200..300).contains(&response.status) {
310 return Err(HarnessError::Status(response.status));
311 }
312 let mut output = String::new();
313 let mut redactor = crate::redaction::StreamRedactor::new(
314 self.key.iter().map(|key| key.expose().to_owned()),
315 );
316 let mut done = false;
317 consume_sse(response.body, self.maximum, &mut |frame| {
318 if done {
319 return Ok(());
320 }
321 if frame_is_done(frame) {
322 done = true;
323 return Ok(());
324 }
325 let text = redactor.push(&parse_frame(self.provider, frame)?);
326 if output.len() + text.len() > self.maximum {
327 return Err(HarnessError::Limit);
328 }
329 if !text.is_empty() {
330 on_delta(&text)?;
331 output.push_str(&text);
332 }
333 Ok(())
334 })
335 .await?;
336 let pending = redactor.finish();
337 if output.len() + pending.len() > self.maximum {
338 return Err(HarnessError::Limit);
339 }
340 if !pending.is_empty() {
341 on_delta(&pending)?;
342 output.push_str(&pending);
343 }
344 Ok(output)
345 };
346 tokio::select! {biased;_=cancel.cancelled()=>Err(HarnessError::Cancelled),result=tokio::time::timeout(Duration::from_secs(120),operation)=>result.map_err(|_|HarnessError::Timeout)?}
347 }
348}
349#[async_trait::async_trait]
350impl ChatHarness for RemoteHarness<'_> {
351 fn name(&self) -> &'static str {
352 match self.provider {
353 Provider::OpenAi => "openai",
354 Provider::Claude => "claude",
355 Provider::Compatible => "openai-compatible",
356 }
357 }
358 async fn available(&self) -> bool {
359 self.provider == Provider::Compatible || self.key.is_some()
360 }
361 async fn chat(
362 &self,
363 request: &HarnessRequest,
364 cancel: &CancellationToken,
365 on_delta: &mut DeltaSink<'_>,
366 ) -> Result<String, HarnessError> {
367 RemoteHarness::chat(self, request, cancel, on_delta).await
368 }
369}
370pub async fn consume_sse(
371 mut body: Pin<Box<dyn AsyncRead + Send>>,
372 maximum: usize,
373 on_frame: &mut (dyn FnMut(&str) -> Result<(), HarnessError> + Send),
374) -> Result<(), HarnessError> {
375 let mut bytes = Vec::new();
376 let mut buffer = vec![0u8; 8192];
377 let mut total = 0;
378 let mut frame = String::new();
379 loop {
380 let count = body
381 .read(&mut buffer)
382 .await
383 .map_err(|_| HarnessError::Transport)?;
384 if count == 0 {
385 break;
386 }
387 total += count;
388 if total > maximum {
389 return Err(HarnessError::Limit);
390 }
391 bytes.extend_from_slice(&buffer[..count]);
392 while let Some(end) = bytes.iter().position(|byte| *byte == b'\n') {
393 let line = std::str::from_utf8(&bytes[..end])
394 .map_err(|_| HarnessError::Response)?
395 .trim_end_matches('\r');
396 if line.is_empty() {
397 if !frame.is_empty() {
398 on_frame(&frame)?;
399 frame.clear();
400 }
401 } else {
402 frame.push_str(line);
403 frame.push('\n');
404 }
405 bytes.drain(..=end);
406 if frame.len() > 1048576 {
407 return Err(HarnessError::Limit);
408 }
409 }
410 if bytes.len() > 1048576 {
411 return Err(HarnessError::Limit);
412 }
413 }
414 if !bytes.is_empty() {
415 frame.push_str(std::str::from_utf8(&bytes).map_err(|_| HarnessError::Response)?);
416 }
417 if !frame.is_empty() {
418 on_frame(&frame)?;
419 }
420 Ok(())
421}
422fn frame_data(frame: &str) -> String {
423 frame
424 .lines()
425 .filter_map(|line| line.strip_prefix("data:"))
426 .collect::<Vec<_>>()
427 .join("\n")
428}
429fn frame_is_done(frame: &str) -> bool {
430 frame_data(frame).trim() == "[DONE]"
431}
432fn parse_frame(provider: Provider, frame: &str) -> Result<String, HarnessError> {
433 let raw = frame_data(frame);
434 let raw = raw.trim();
435 if raw.is_empty() {
436 return Ok(String::new());
437 }
438 let value: Value = match serde_json::from_str(raw) {
439 Ok(value) => value,
440 Err(_) if provider == Provider::Claude => return Ok(String::new()),
441 Err(_) => return Err(HarnessError::Response),
442 };
443 crate::usage::record(
444 &value,
445 if provider == Provider::Claude {
446 crate::usage::Provider::Claude
447 } else {
448 crate::usage::Provider::OpenAi
449 },
450 );
451 let mut result = String::new();
452 if provider == Provider::Claude {
453 if value["delta"]["type"] == "text_delta" {
454 if let Some(text) = value["delta"]["text"].as_str() {
455 result.push_str(text);
456 }
457 } else if let Some(parts) = value["message"]["content"].as_array() {
458 for part in parts {
459 if part["type"] == "text"
460 && let Some(text) = part["text"].as_str()
461 {
462 result.push_str(text);
463 }
464 }
465 }
466 } else {
467 let choices = value["choices"].as_array().ok_or(HarnessError::Response)?;
468 for choice in choices {
469 let content = &choice["delta"]["content"];
470 if let Some(text) = content.as_str() {
471 result.push_str(text);
472 } else if let Some(parts) = content.as_array() {
473 for part in parts {
474 if let Some(text) = part["text"].as_str() {
475 result.push_str(text);
476 }
477 }
478 }
479 }
480 }
481 Ok(rigspark_core::reports::strip_control(&result))
482}
483pub struct LocalHarness<'runtime> {
484 pub state: &'runtime crate::state::StateStore,
485 pub registry: &'runtime crate::lifecycle::Registry<'runtime>,
486 pub probe: &'runtime dyn crate::identity::ProcessProbe,
487}
488pub struct BoundLocalAgent<'bound, 'runtime> {
489 local: &'bound LocalHarness<'runtime>,
490 expected: crate::state::RuntimeState,
491}
492impl LocalHarness<'_> {
493 pub fn bind(&self) -> Result<BoundLocalAgent<'_, '_>, crate::memory::MemoryError> {
494 Ok(BoundLocalAgent {
495 local: self,
496 expected: self.state.read()?,
497 })
498 }
499}
500#[async_trait::async_trait]
501impl crate::agent::AgentChat for BoundLocalAgent<'_, '_> {
502 async fn chat(
503 &self,
504 input: &crate::ollama_inference::ChatInput,
505 cancel: &CancellationToken,
506 sink: &mut DeltaSink<'_>,
507 ) -> Result<crate::ollama_inference::ChatResult, HarnessError> {
508 if self.local.state.read().map_err(|_| HarnessError::Drift)? != self.expected {
509 return Err(HarnessError::Drift);
510 }
511 let result = crate::agent::AgentChat::chat(self.local, input, cancel, sink).await?;
512 if self.local.state.read().map_err(|_| HarnessError::Drift)? != self.expected {
513 return Err(HarnessError::Drift);
514 }
515 Ok(result)
516 }
517}
518#[async_trait::async_trait]
519impl ChatHarness for LocalHarness<'_> {
520 fn name(&self) -> &'static str {
521 "local"
522 }
523 async fn available(&self) -> bool {
524 self.state.read().is_ok_and(|state| state.active.is_some())
525 }
526 async fn chat(
527 &self,
528 input: &HarnessRequest,
529 cancel: &CancellationToken,
530 on_delta: &mut DeltaSink<'_>,
531 ) -> Result<String, HarnessError> {
532 input.validate()?;
533 let request = crate::ollama_inference::ChatInput {
534 model: input.model.clone(),
535 messages: input
536 .messages
537 .iter()
538 .map(|message| crate::ollama_inference::ChatMessage {
539 role: message.role.clone(),
540 content: message.content.clone(),
541 tool_calls: Vec::new(),
542 tool_name: None,
543 })
544 .collect(),
545 tools: Vec::new(),
546 temperature: input.temperature,
547 slot: None,
548 };
549 Ok(
550 crate::agent::AgentChat::chat(self, &request, cancel, on_delta)
551 .await?
552 .content,
553 )
554 }
555}
556#[async_trait::async_trait]
557impl crate::agent::AgentChat for LocalHarness<'_> {
558 async fn chat(
559 &self,
560 input: &crate::ollama_inference::ChatInput,
561 cancel: &CancellationToken,
562 on_delta: &mut DeltaSink<'_>,
563 ) -> Result<crate::ollama_inference::ChatResult, HarnessError> {
564 if input.messages.len() > 10000
565 || input.tools.len() > 1024
566 || input.temperature.is_some_and(|value| !value.is_finite())
567 || serde_json::to_vec(input)
568 .map_err(|_| HarnessError::Invalid)?
569 .len()
570 > 4 * 1024 * 1024
571 {
572 return Err(HarnessError::Invalid);
573 }
574 let prior = self.state.read().map_err(|_| HarnessError::Unavailable)?;
575 let mut active = prior.active.clone().ok_or(HarnessError::Unavailable)?;
576 let adapter = self
577 .registry
578 .get(&active.backend)
579 .map_err(|_| HarnessError::Unavailable)?;
580 let observed = crate::process_control::listener(self.probe, &active.endpoint, cancel)
581 .await
582 .map_err(|_| HarnessError::Drift)?;
583 let live = crate::identity::capture(&active, &observed, adapter.trusts(&observed.identity))
584 .map_err(|_| HarnessError::Drift)?;
585 active.pid = Some(live.expected.pid);
586 active.process_executable = Some(live.expected.executable);
587 active.process_started_at = Some(live.expected.started);
588 let mut request = input.clone();
589 if request.model.is_empty() {
590 request.model = active
591 .runtime_model_id
592 .clone()
593 .unwrap_or_else(|| active.model_id.clone());
594 }
595 let stream_cancel = cancel.child_token();
596 let mut emitted = 0usize;
597 let mut sink_error = None;
598 let mut emit = |text: &str| {
599 if sink_error.is_some() || stream_cancel.is_cancelled() {
600 return;
601 }
602 emitted = emitted.saturating_add(text.len());
603 let result = if emitted > 16 * 1024 * 1024 {
604 Err(HarnessError::Limit)
605 } else {
606 on_delta(text)
607 };
608 if let Err(error) = result {
609 sink_error = Some(error);
610 stream_cancel.cancel();
611 }
612 };
613 let response = tokio::select! {biased;_=cancel.cancelled()=>return Err(HarnessError::Cancelled),result=tokio::time::timeout(Duration::from_secs(120),adapter.chat_stream(&active,&request,&stream_cancel,&mut emit))=>result};
614 if let Some(error) = sink_error {
615 return Err(error);
616 }
617 let response = response
618 .map_err(|_| HarnessError::Timeout)?
619 .map_err(|_| HarnessError::Transport)?;
620 if self.state.read().map_err(|_| HarnessError::Drift)? != prior {
621 return Err(HarnessError::Drift);
622 }
623 if response.content.len() > 16 * 1024 * 1024 {
624 return Err(HarnessError::Limit);
625 }
626 Ok(response)
627 }
628}