apoc 0.9.1

Agentic process control for LLMs
Documentation
use std::collections::BTreeMap;

use serde::{Deserialize, Serialize};

use crate::model::ExecutionExport;

use super::config::GuestRequest;

pub const PROTOCOL_VERSION: u16 = 1;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SessionFrame {
    #[serde(rename = "type")]
    pub kind: String,
    pub protocol_version: u16,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exec_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub argv: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timeout_ms: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub memory_mb: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pids_max: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub env: Option<BTreeMap<String, String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workspace: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exports: Option<Vec<ExecutionExport>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tty: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signal: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exit_code: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error_code: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub export_index: Option<usize>,
}

impl SessionFrame {
    pub fn start(request: &GuestRequest) -> Self {
        Self {
            kind: "exec_start".to_string(),
            protocol_version: PROTOCOL_VERSION,
            request_id: Some(request.request_id.clone()),
            exec_id: Some(request.request_id.clone()),
            argv: Some(request.argv.clone()),
            timeout_ms: Some(request.timeout_ms),
            memory_mb: Some(request.memory_mb),
            pids_max: Some(request.pids_max),
            env: Some(request.env.clone()),
            cwd: Some(request.cwd.clone()),
            workspace: request.workspace.clone(),
            exports: Some(request.exports.clone()),
            tty: Some(request.tty),
            data: None,
            signal: None,
            exit_code: None,
            error_code: None,
            export_index: None,
        }
    }

    pub fn input(execution_id: &str, data: String) -> Self {
        Self::control("stdin", execution_id, Some(data), None)
    }

    pub fn signal(execution_id: &str, signal: String) -> Self {
        Self::control("signal", execution_id, None, Some(signal))
    }

    pub fn close(execution_id: &str) -> Self {
        Self::control("close", execution_id, None, None)
    }

    fn control(
        kind: &str,
        execution_id: &str,
        data: Option<String>,
        signal: Option<String>,
    ) -> Self {
        Self {
            kind: kind.to_string(),
            protocol_version: PROTOCOL_VERSION,
            request_id: None,
            exec_id: Some(execution_id.to_string()),
            argv: None,
            timeout_ms: None,
            memory_mb: None,
            pids_max: None,
            env: None,
            cwd: None,
            workspace: None,
            exports: None,
            tty: None,
            data,
            signal,
            exit_code: None,
            error_code: None,
            export_index: None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn start_frame_matches_guest_protocol_shape() {
        let request = GuestRequest {
            request_id: "native-1".to_string(),
            argv: vec!["/bin/true".to_string()],
            cwd: "/workspace".to_string(),
            env: BTreeMap::new(),
            workspace: Some("/workspace".to_string()),
            exports: Vec::new(),
            tty: false,
            timeout_ms: 1_000,
            memory_mb: 512,
            pids_max: 64,
        };
        let value = serde_json::to_value(SessionFrame::start(&request)).unwrap();
        assert_eq!(value["type"], "exec_start");
        assert_eq!(value["protocol_version"], 1);
        assert_eq!(value["exec_id"], "native-1");
        assert!(value.get("signal").is_none());
    }
}