codex-sdk-rs 0.1.0

Rust SDK for the OpenAI Codex app server
Documentation
use serde::Serialize;
use serde_json::{Map, Value};

use crate::{
    ApprovalMode, Error, Personality, ReasoningEffort, ReasoningSummary, Sandbox, SortDirection,
    ThreadListCwdFilter, ThreadSortKey, ThreadSource, ThreadSourceKind, ThreadStartSource,
};

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadStartOptions {
    #[serde(skip)]
    pub approval_mode: ApprovalMode,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub base_instructions: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config: Option<Map<String, Value>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub developer_instructions: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ephemeral: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_provider: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub personality: Option<Personality>,
    #[serde(skip)]
    pub sandbox: Option<Sandbox>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_tier: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub session_start_source: Option<ThreadStartSource>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thread_source: Option<ThreadSource>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadListOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub archived: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cursor: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cwd: Option<ThreadListCwdFilter>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_providers: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub search_term: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_direction: Option<SortDirection>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_key: Option<ThreadSortKey>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source_kinds: Option<Vec<ThreadSourceKind>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub use_state_db_only: Option<bool>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadResumeOptions {
    #[serde(skip)]
    pub approval_mode: Option<ApprovalMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub base_instructions: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config: Option<Map<String, Value>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub developer_instructions: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_provider: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub personality: Option<Personality>,
    #[serde(skip)]
    pub sandbox: Option<Sandbox>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_tier: Option<String>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ThreadForkOptions {
    #[serde(skip)]
    pub approval_mode: Option<ApprovalMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub base_instructions: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config: Option<Map<String, Value>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub developer_instructions: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ephemeral: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_provider: Option<String>,
    #[serde(skip)]
    pub sandbox: Option<Sandbox>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_tier: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thread_source: Option<ThreadSource>,
}

#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TurnOptions {
    #[serde(skip)]
    pub approval_mode: Option<ApprovalMode>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cwd: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub effort: Option<ReasoningEffort>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output_schema: Option<Map<String, Value>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub personality: Option<Personality>,
    #[serde(skip)]
    pub sandbox: Option<Sandbox>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub service_tier: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub summary: Option<ReasoningSummary>,
}

pub(crate) fn serialize_options<T: Serialize>(options: &T) -> crate::Result<Map<String, Value>> {
    let Value::Object(values) = serde_json::to_value(options)? else {
        return Err(Error::InvalidConfiguration(
            "options must serialize as an object".into(),
        ));
    };
    Ok(values)
}

pub(crate) fn apply_approval_mode(values: &mut Map<String, Value>, mode: Option<ApprovalMode>) {
    match mode {
        None => {}
        Some(ApprovalMode::AutoReview) => {
            values.insert("approvalPolicy".into(), Value::String("on-request".into()));
            values.insert(
                "approvalsReviewer".into(),
                Value::String("auto_review".into()),
            );
        }
        Some(ApprovalMode::DenyAll) => {
            values.insert("approvalPolicy".into(), Value::String("never".into()));
        }
    }
}

pub(crate) fn apply_sandbox_mode(values: &mut Map<String, Value>, sandbox: Option<Sandbox>) {
    if let Some(sandbox) = sandbox {
        values.insert("sandbox".into(), Value::String(sandbox.mode().into()));
    }
}

pub(crate) fn apply_sandbox_policy(values: &mut Map<String, Value>, sandbox: Option<Sandbox>) {
    if let Some(sandbox) = sandbox {
        values.insert("sandboxPolicy".into(), sandbox.policy());
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde::Serializer;
    use serde_json::json;

    struct Scalar;

    impl Serialize for Scalar {
        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_bool(true)
        }
    }

    #[test]
    fn option_helpers_encode_all_approval_and_sandbox_modes() {
        let mut values = Map::new();
        apply_approval_mode(&mut values, None);
        apply_sandbox_mode(&mut values, None);
        apply_sandbox_policy(&mut values, None);
        assert!(values.is_empty());

        apply_approval_mode(&mut values, Some(ApprovalMode::AutoReview));
        assert_eq!(values["approvalPolicy"], "on-request");
        assert_eq!(values["approvalsReviewer"], "auto_review");

        apply_approval_mode(&mut values, Some(ApprovalMode::DenyAll));
        assert_eq!(values["approvalPolicy"], "never");
        apply_sandbox_mode(&mut values, Some(Sandbox::FullAccess));
        assert_eq!(values["sandbox"], "danger-full-access");
        apply_sandbox_policy(&mut values, Some(Sandbox::WorkspaceWrite));
        assert_eq!(
            values["sandboxPolicy"],
            json!({
                "excludeSlashTmp":false,
                "excludeTmpdirEnvVar":false,
                "networkAccess":false,
                "type":"workspaceWrite",
                "writableRoots":[]
            })
        );
    }

    #[test]
    fn serialize_options_rejects_non_objects() {
        assert!(matches!(
            serialize_options(&Scalar),
            Err(Error::InvalidConfiguration(message))
                if message == "options must serialize as an object"
        ));
    }
}