rigspark-runtime 3.0.3

Hardware detection, backend adapters, lifecycle, memory and harness runtime for rigspark.
Documentation
use crate::harness::{
    ChatHarness, DeltaSink, HarnessError, HarnessRequest, LocalHarness, Provider, RemoteHarness,
    RemoteTransport, Secret,
};
use crate::opencode::{OpenCodeHarness, OpenCodeRunner};
use std::collections::{BTreeMap, HashSet};
use tokio_util::sync::CancellationToken;

pub struct HarnessRegistry<'runtime> {
    harnesses: Vec<Box<dyn ChatHarness + 'runtime>>,
}
impl<'runtime> HarnessRegistry<'runtime> {
    pub fn new(harnesses: Vec<Box<dyn ChatHarness + 'runtime>>) -> Result<Self, HarnessError> {
        let mut names = HashSet::new();
        if harnesses.len() > 32
            || harnesses
                .iter()
                .any(|harness| !names.insert(harness.name()))
        {
            return Err(HarnessError::Invalid);
        }
        Ok(Self { harnesses })
    }
    pub fn all(&self) -> Vec<&str> {
        self.harnesses
            .iter()
            .map(|harness| harness.name())
            .collect()
    }
    pub fn get(&self, name: &str) -> Result<&dyn ChatHarness, HarnessError> {
        self.harnesses
            .iter()
            .find(|harness| harness.name() == name)
            .map(|harness| harness.as_ref())
            .ok_or(HarnessError::Invalid)
    }
    pub async fn available(&self) -> Vec<&str> {
        let probes = self.harnesses.iter().map(|harness| async move {
            tokio::time::timeout(std::time::Duration::from_secs(2), harness.available())
                .await
                .unwrap_or(false)
                .then_some(harness.name())
        });
        futures_util::future::join_all(probes)
            .await
            .into_iter()
            .flatten()
            .collect()
    }
    pub fn builtins(
        local: LocalHarness<'runtime>,
        transport: &'runtime dyn RemoteTransport,
        opencode: &'runtime dyn OpenCodeRunner,
        env: &BTreeMap<String, String>,
    ) -> Result<Self, HarnessError> {
        let mut harnesses: Vec<Box<dyn ChatHarness + 'runtime>> = vec![Box::new(local)];
        for (provider, name, key_name, endpoint) in [
            (
                Provider::Claude,
                "claude",
                "ANTHROPIC_API_KEY",
                Some("https://api.anthropic.com/v1/messages"),
            ),
            (
                Provider::OpenAi,
                "openai",
                "OPENAI_API_KEY",
                Some("https://api.openai.com/v1/chat/completions"),
            ),
            (
                Provider::Compatible,
                "openai-compatible",
                "OPENAI_COMPAT_API_KEY",
                env.get("OPENAI_COMPAT_BASE_URL").map(String::as_str),
            ),
        ] {
            let key = env
                .get(key_name)
                .map(|value| Secret::new(value))
                .transpose();
            let harness = match (endpoint, key) {
                (Some(endpoint), Ok(key)) if provider == Provider::Compatible || key.is_some() => {
                    RemoteHarness::new(provider, endpoint, key, transport).ok()
                }
                _ => None,
            };
            harnesses.push(match harness {
                Some(harness) => Box::new(harness),
                None => Box::new(Unavailable(name)),
            });
        }
        let unrestricted = env
            .get("RIGSPARK_OPENCODE_UNRESTRICTED")
            .is_some_and(|value| {
                ["1", "true", "yes", "on"].contains(&value.to_ascii_lowercase().as_str())
            });
        harnesses.push(Box::new(OpenCodeHarness {
            runner: opencode,
            unrestricted,
        }));
        Self::new(harnesses)
    }
}
struct Unavailable(&'static str);
#[async_trait::async_trait]
impl ChatHarness for Unavailable {
    fn name(&self) -> &'static str {
        self.0
    }
    async fn available(&self) -> bool {
        false
    }
    async fn chat(
        &self,
        _: &HarnessRequest,
        _: &CancellationToken,
        _: &mut DeltaSink<'_>,
    ) -> Result<String, HarnessError> {
        Err(HarnessError::Unavailable)
    }
}