rigspark-runtime 3.0.3

Hardware detection, backend adapters, lifecycle, memory and harness runtime for rigspark.
Documentation
use crate::{
    context::{ContextBundle, ContextRef, DisclosureStore},
    harness::{ChatHarness, DeltaSink, HarnessError, HarnessMessage, HarnessRequest},
    library::Library,
    memory::{CaptureOptions, MemoryStore},
    sessions::{SessionDoc, SessionError, SessionRepository, StoredMessage},
    workspace::{WorkspaceError, WorkspaceService},
};
use tokio_util::sync::CancellationToken;

#[derive(Debug, thiserror::Error)]
pub enum ChatError {
    #[error("invalid chat request")]
    Invalid,
    #[error("context disclosure requires approval")]
    Disclosure,
    #[error(transparent)]
    Harness(#[from] HarnessError),
    #[error(transparent)]
    Session(#[from] SessionError),
    #[error(transparent)]
    Workspace(#[from] WorkspaceError),
    #[error("library composition failed")]
    Library,
}
pub struct ChatOptions<'request> {
    pub session_id: &'request str,
    pub revision: u64,
    pub provider: &'request str,
    pub model: &'request str,
    pub message: &'request str,
    pub context: &'request [ContextRef],
    pub agent: Option<&'request str>,
    pub skills: &'request [String],
    pub temperature: Option<f64>,
}
pub struct PreparedChat {
    session_id: String,
    revision: u64,
    provider: String,
    message: String,
    request: HarnessRequest,
    context: ContextBundle,
}
impl PreparedChat {
    pub fn context(&self) -> &ContextBundle {
        &self.context
    }
    pub fn provider(&self) -> &str {
        &self.provider
    }
}
pub struct ChatOutcome {
    pub text: String,
    pub session: SessionDoc,
    pub memory_captured: Option<bool>,
}
pub struct AgentRuntime<'runtime> {
    pub chat: &'runtime dyn crate::agent::AgentChat,
    pub manager: &'runtime mut crate::mcp::Manager,
    pub grants: &'runtime mut crate::tool_policy::SessionGrants,
    pub approver: Option<&'runtime dyn crate::agent::ToolApprover>,
    pub workspace_id: Option<&'runtime str>,
    pub max_steps: usize,
}
pub struct ChatService<'service> {
    pub sessions: &'service SessionRepository,
    pub library: &'service Library,
    pub workspace: &'service WorkspaceService,
    pub disclosures: &'service mut DisclosureStore,
}
impl ChatService<'_> {
    pub fn prepare(&self, options: ChatOptions<'_>) -> Result<PreparedChat, ChatError> {
        self.prepare_with_prompt(options, None)
    }
    pub fn prepare_with_prompt(
        &self,
        options: ChatOptions<'_>,
        system_prompt: Option<&str>,
    ) -> Result<PreparedChat, ChatError> {
        if system_prompt.is_some_and(|text| text.encode_utf16().count() > 48 * 1024) {
            return Err(ChatError::Invalid);
        }
        if options.message.trim().is_empty()
            || options.message.encode_utf16().count() > 32768
            || !["local", "claude", "openai", "openai-compatible", "opencode"]
                .contains(&options.provider)
        {
            return Err(ChatError::Invalid);
        }
        let session = self
            .sessions
            .get(options.session_id)?
            .ok_or(ChatError::Invalid)?;
        if session.archived || session.revision != options.revision {
            return Err(SessionError::Conflict.into());
        }
        let context = ContextBundle::resolve(self.workspace, options.context)?;
        let mut messages = Vec::new();
        if let Some(prompt) = system_prompt.filter(|text| !text.trim().is_empty()) {
            messages.push(HarnessMessage {
                role: "system".into(),
                content: crate::sessions::gui_text(prompt),
            });
        }
        if let Some(instructions) = self
            .library
            .compose(options.agent, options.skills)
            .map_err(|_| ChatError::Library)?
        {
            messages.push(HarnessMessage {
                role: "system".into(),
                content: instructions,
            });
        }
        if !context.text.is_empty() {
            messages.push(HarnessMessage {
                role: "system".into(),
                content: context.text.clone(),
            });
        }
        messages.extend(
            session
                .messages
                .iter()
                .skip(session.messages.len().saturating_sub(20))
                .map(|message| HarnessMessage {
                    role: message.role.clone(),
                    content: message.content.clone(),
                }),
        );
        let message = crate::sessions::gui_text(options.message);
        messages.push(HarnessMessage {
            role: "user".into(),
            content: message.clone(),
        });
        let request = HarnessRequest {
            model: options.model.into(),
            messages,
            temperature: options.temperature,
        };
        request.validate()?;
        Ok(PreparedChat {
            session_id: session.id,
            revision: session.revision,
            provider: options.provider.into(),
            message,
            request,
            context,
        })
    }
    pub fn approve_disclosure(&mut self, prepared: &PreparedChat) {
        self.disclosures
            .approve(&prepared.session_id, &prepared.provider, &prepared.context);
    }
    pub async fn run(
        &self,
        prepared: PreparedChat,
        harness: &dyn ChatHarness,
        timestamp: &str,
        memory: Option<(&MemoryStore, CaptureOptions<'_>)>,
        cancel: &CancellationToken,
        sink: &mut DeltaSink<'_>,
    ) -> Result<ChatOutcome, ChatError> {
        if harness.name() != prepared.provider || timestamp.is_empty() || timestamp.len() > 40 {
            return Err(ChatError::Invalid);
        }
        self.authorize(&prepared, timestamp, cancel)?;
        let run = self.sessions.runs.begin(&prepared.session_id, cancel)?;
        let text = tokio::select! { biased; _ = run.token().cancelled() => return Err(HarnessError::Cancelled.into()), result = harness.chat(&prepared.request, run.token(), sink) => result? };
        self.finish(prepared, text, timestamp, memory, &run).await
    }
    pub async fn run_agent(
        &self,
        prepared: PreparedChat,
        runtime: AgentRuntime<'_>,
        timestamp: &str,
        memory: Option<(&MemoryStore, CaptureOptions<'_>)>,
        cancel: &CancellationToken,
        sink: &mut crate::agent::EventSink<'_>,
    ) -> Result<ChatOutcome, ChatError> {
        if prepared.provider != "local" {
            return Err(ChatError::Invalid);
        }
        self.authorize(&prepared, timestamp, cancel)?;
        let run = self.sessions.runs.begin(&prepared.session_id, cancel)?;
        let options = crate::agent::AgentOptions {
            session_id: &prepared.session_id,
            workspace_id: runtime.workspace_id,
            model: &prepared.request.model,
            temperature: prepared.request.temperature,
            max_steps: runtime.max_steps,
            messages: prepared
                .request
                .messages
                .iter()
                .map(|message| crate::ollama_inference::ChatMessage {
                    role: message.role.clone(),
                    content: message.content.clone(),
                    tool_calls: Vec::new(),
                    tool_name: None,
                })
                .collect(),
        };
        let text = crate::agent::run_turn(
            runtime.chat,
            runtime.manager,
            runtime.grants,
            runtime.approver,
            options,
            run.token(),
            sink,
        )
        .await?;
        self.finish(prepared, text, timestamp, memory, &run).await
    }
    fn authorize(
        &self,
        prepared: &PreparedChat,
        timestamp: &str,
        cancel: &CancellationToken,
    ) -> Result<(), ChatError> {
        if timestamp.is_empty() || timestamp.len() > 40 {
            return Err(ChatError::Invalid);
        }
        if !self
            .disclosures
            .allowed(&prepared.session_id, &prepared.provider, &prepared.context)
        {
            return Err(ChatError::Disclosure);
        }
        let current = self
            .sessions
            .get(&prepared.session_id)?
            .ok_or(ChatError::Invalid)?;
        if current.archived || current.revision != prepared.revision {
            return Err(SessionError::Conflict.into());
        }
        if cancel.is_cancelled() {
            return Err(HarnessError::Cancelled.into());
        }
        Ok(())
    }
    async fn finish(
        &self,
        prepared: PreparedChat,
        text: String,
        timestamp: &str,
        memory: Option<(&MemoryStore, CaptureOptions<'_>)>,
        run: &crate::runs::RunLease,
    ) -> Result<ChatOutcome, ChatError> {
        let cancel = run.token();
        if cancel.is_cancelled() {
            return Err(HarnessError::Cancelled.into());
        }
        let session = run.commit(|| {
            self.sessions.append_exchange(
                &prepared.session_id,
                StoredMessage {
                    role: "user".into(),
                    content: prepared.message.clone(),
                    at: timestamp.into(),
                    attachments: (!prepared.context.manifest.is_empty())
                        .then_some(prepared.context.manifest),
                },
                StoredMessage {
                    role: "assistant".into(),
                    content: text.clone(),
                    at: timestamp.into(),
                    attachments: None,
                },
                prepared.revision,
            )
        })?;
        let memory_captured = match memory {
            Some((store, options)) => Some(
                store
                    .capture(&prepared.message, &text, options, cancel)
                    .await
                    .is_ok(),
            ),
            None => None,
        };
        Ok(ChatOutcome {
            text,
            session,
            memory_captured,
        })
    }
}