Skip to content
Python
6.0 KB
Raw Blame
use crate::{Error, Result};
use serde::{Deserialize, Serialize};
use std::path::PathBuf;

#[derive(Default, Clone, Serialize)]
pub struct SessionOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    initial_history: Option<Vec<crate::HistoryItem>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    auto_approver_context: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    compaction: Option<crate::CompactionOptions>,
    #[serde(skip_serializing_if = "Option::is_none")]
    safety: Option<crate::guardrails::Config>,
    #[serde(skip_serializing_if = "Option::is_none")]
    compliance: Option<openworker_runtime::compliance::Config>,
    #[serde(skip_serializing_if = "Option::is_none")]
    model: Option<crate::Model>,
    #[serde(skip_serializing_if = "Option::is_none")]
    workspace: Option<PathBuf>,
    #[serde(skip_serializing_if = "Option::is_none")]
    scratch: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    auto_skip_questions: Option<bool>,
}
impl SessionOptions {
    /// Durable default for action review; does not grant tool permissions.
    pub fn auto_approver_context(mut self, text: impl Into<String>) -> Self {
        self.auto_approver_context = Some(text.into());
        self
    }
    pub fn compaction(mut self, options: crate::CompactionOptions) -> Self {
        self.compaction = Some(options);
        self
    }
    /// Seed a new session with a complete portable transcript. No tool runs.
    pub fn initial_history(mut self, history: Vec<crate::HistoryItem>) -> Self {
        self.initial_history = Some(history);
        self
    }
    pub fn compliance(mut self, config: openworker_runtime::compliance::Config) -> Self {
        self.compliance = Some(config);
        self
    }
    pub fn safety(mut self, config: crate::guardrails::Config) -> Self {
        self.safety = Some(config);
        self
    }
    /// Override this agent's question policy for the new session only.
    pub fn auto_skip_questions(mut self, enabled: bool) -> Self {
        self.auto_skip_questions = Some(enabled);
        self
    }
    pub fn model(mut self, model: crate::Model) -> Self {
        self.model = Some(model);
        self
    }
    pub fn workspace(mut self, path: impl Into<PathBuf>) -> Self {
        self.workspace = Some(path.into());
        self
    }
    pub fn scratch(mut self, enabled: bool) -> Self {
        self.scratch = Some(enabled);
        self
    }
}

#[derive(Clone, Serialize, Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct DesktopOptions {
    pub inherit_env: Vec<String>,
    pub safety: crate::guardrails::Config,
    pub compliance: Option<openworker_runtime::compliance::Config>,
    pub compliance_sinks: Vec<openworker_runtime::compliance_export::Sink>,
    pub mcp_servers: Vec<crate::McpServer>,
    pub persist_sessions: bool,
    pub session_dir: Option<PathBuf>,
    pub scratch_dir: Option<PathBuf>,
    pub compaction: openworker_runtime::compaction::Config,
}
impl Default for DesktopOptions {
    fn default() -> Self {
        Self {
            inherit_env: vec![],
            safety: Default::default(),
            compliance: None,
            compliance_sinks: vec![],
            mcp_servers: vec![],
            persist_sessions: true,
            session_dir: None,
            scratch_dir: None,
            compaction: Default::default(),
        }
    }
}
pub(crate) fn default_state_dir() -> Result<PathBuf> {
    let exe = std::env::current_exe()
        .map_err(|_| Error::Setup("Application executable is unavailable".into()))?;
    let app = std::env::var("OPENWORKER_APP_ID")
        .ok()
        .or_else(|| exe.file_stem().and_then(|s| s.to_str()).map(str::to_owned))
        .ok_or_else(|| Error::Setup("Specify an application state directory".into()))?;
    if !openworker_runtime::bundle::safe_name(&app) {
        return Err(Error::InvalidInput(
            "Use an alphanumeric app ID or specify state_dir".into(),
        ));
    }
    let home = std::env::var_os(if cfg!(windows) { "USERPROFILE" } else { "HOME" })
        .ok_or_else(|| Error::Setup("User home unavailable; specify state_dir".into()))?;
    Ok(PathBuf::from(home)
        .join(".openworker")
        .join(app)
        .join("state"))
}
pub(crate) fn default_executable() -> Result<PathBuf> {
    if let Some(value) = std::env::var_os("OPENWORKER_EXECUTABLE") {
        let path = PathBuf::from(value);
        if path.is_absolute() && path.is_file() {
            return Ok(path);
        }
        return Err(Error::Setup(
            "OPENWORKER_EXECUTABLE must name an absolute bundled executable".into(),
        ));
    }
    let exe = std::env::current_exe()
        .map_err(|_| Error::Setup("Application executable unavailable".into()))?;
    let dir = exe
        .parent()
        .ok_or_else(|| Error::Setup("Application executable directory unavailable".into()))?;
    let name = if cfg!(windows) {
        "openworker-harness.exe"
    } else {
        "openworker-harness"
    };
    for path in [
        dir.join(name),
        dir.join("resources").join(name),
        dir.join("../Resources").join(name),
    ] {
        if path.is_file() {
            return path
                .canonicalize()
                .map_err(|_| Error::Setup("Bundled harness is inaccessible".into()));
        }
    }
    Err(Error::Setup(
        "Bundled openworker-harness not found; use a desktop starter or set executable explicitly"
            .into(),
    ))
}

/// Per-message options. Session and application safety requirements remain active.
#[derive(Clone, Default)]
pub struct TurnOptions {
    pub submission_id: Option<String>,
    pub limits: Option<crate::TurnLimits>,
    pub safety: Option<crate::guardrails::Config>,
    /// Trusted application instructions for this turn only, not user text.
    pub instruction_addendum: Option<String>,
    /// Replaces session guidance for this turn only; empty string clears it.
    pub auto_approver_context: Option<String>,
    pub compaction: Option<crate::CompactionOptions>,
    pub output: Option<crate::OutputOptions>,
}