Skip to main content

rigspark_runtime/
harness.rs

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        };
548        Ok(
549            crate::agent::AgentChat::chat(self, &request, cancel, on_delta)
550                .await?
551                .content,
552        )
553    }
554}
555#[async_trait::async_trait]
556impl crate::agent::AgentChat for LocalHarness<'_> {
557    async fn chat(
558        &self,
559        input: &crate::ollama_inference::ChatInput,
560        cancel: &CancellationToken,
561        on_delta: &mut DeltaSink<'_>,
562    ) -> Result<crate::ollama_inference::ChatResult, HarnessError> {
563        if input.messages.len() > 10000
564            || input.tools.len() > 1024
565            || input.temperature.is_some_and(|value| !value.is_finite())
566            || serde_json::to_vec(input)
567                .map_err(|_| HarnessError::Invalid)?
568                .len()
569                > 4 * 1024 * 1024
570        {
571            return Err(HarnessError::Invalid);
572        }
573        let prior = self.state.read().map_err(|_| HarnessError::Unavailable)?;
574        let mut active = prior.active.clone().ok_or(HarnessError::Unavailable)?;
575        let adapter = self
576            .registry
577            .get(&active.backend)
578            .map_err(|_| HarnessError::Unavailable)?;
579        let observed = crate::process_control::listener(self.probe, &active.endpoint, cancel)
580            .await
581            .map_err(|_| HarnessError::Drift)?;
582        let live = crate::identity::capture(&active, &observed, adapter.trusts(&observed.identity))
583            .map_err(|_| HarnessError::Drift)?;
584        active.pid = Some(live.expected.pid);
585        active.process_executable = Some(live.expected.executable);
586        active.process_started_at = Some(live.expected.started);
587        let mut request = input.clone();
588        if request.model.is_empty() {
589            request.model = active
590                .runtime_model_id
591                .clone()
592                .unwrap_or_else(|| active.model_id.clone());
593        }
594        let stream_cancel = cancel.child_token();
595        let mut emitted = 0usize;
596        let mut sink_error = None;
597        let mut emit = |text: &str| {
598            if sink_error.is_some() || stream_cancel.is_cancelled() {
599                return;
600            }
601            emitted = emitted.saturating_add(text.len());
602            let result = if emitted > 16 * 1024 * 1024 {
603                Err(HarnessError::Limit)
604            } else {
605                on_delta(text)
606            };
607            if let Err(error) = result {
608                sink_error = Some(error);
609                stream_cancel.cancel();
610            }
611        };
612        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};
613        if let Some(error) = sink_error {
614            return Err(error);
615        }
616        let response = response
617            .map_err(|_| HarnessError::Timeout)?
618            .map_err(|_| HarnessError::Transport)?;
619        if self.state.read().map_err(|_| HarnessError::Drift)? != prior {
620            return Err(HarnessError::Drift);
621        }
622        if response.content.len() > 16 * 1024 * 1024 {
623            return Err(HarnessError::Limit);
624        }
625        Ok(response)
626    }
627}