Skip to main content

codex_sdk_rs/
options.rs

1use serde::Serialize;
2use serde_json::{Map, Value};
3
4use crate::{
5    ApprovalMode, Error, Personality, ReasoningEffort, ReasoningSummary, Sandbox, SortDirection,
6    ThreadListCwdFilter, ThreadSortKey, ThreadSource, ThreadSourceKind, ThreadStartSource,
7};
8
9#[derive(Clone, Debug, Default, PartialEq, Serialize)]
10#[serde(rename_all = "camelCase")]
11pub struct ThreadStartOptions {
12    #[serde(skip)]
13    pub approval_mode: ApprovalMode,
14    #[serde(skip_serializing_if = "Option::is_none")]
15    pub base_instructions: Option<String>,
16    #[serde(skip_serializing_if = "Option::is_none")]
17    pub config: Option<Map<String, Value>>,
18    #[serde(skip_serializing_if = "Option::is_none")]
19    pub cwd: Option<String>,
20    #[serde(skip_serializing_if = "Option::is_none")]
21    pub developer_instructions: Option<String>,
22    #[serde(skip_serializing_if = "Option::is_none")]
23    pub ephemeral: Option<bool>,
24    #[serde(skip_serializing_if = "Option::is_none")]
25    pub model: Option<String>,
26    #[serde(skip_serializing_if = "Option::is_none")]
27    pub model_provider: Option<String>,
28    #[serde(skip_serializing_if = "Option::is_none")]
29    pub personality: Option<Personality>,
30    #[serde(skip)]
31    pub sandbox: Option<Sandbox>,
32    #[serde(skip_serializing_if = "Option::is_none")]
33    pub service_name: Option<String>,
34    #[serde(skip_serializing_if = "Option::is_none")]
35    pub service_tier: Option<String>,
36    #[serde(skip_serializing_if = "Option::is_none")]
37    pub session_start_source: Option<ThreadStartSource>,
38    #[serde(skip_serializing_if = "Option::is_none")]
39    pub thread_source: Option<ThreadSource>,
40}
41
42#[derive(Clone, Debug, Default, PartialEq, Serialize)]
43#[serde(rename_all = "camelCase")]
44pub struct ThreadListOptions {
45    #[serde(skip_serializing_if = "Option::is_none")]
46    pub archived: Option<bool>,
47    #[serde(skip_serializing_if = "Option::is_none")]
48    pub cursor: Option<String>,
49    #[serde(skip_serializing_if = "Option::is_none")]
50    pub cwd: Option<ThreadListCwdFilter>,
51    #[serde(skip_serializing_if = "Option::is_none")]
52    pub limit: Option<u32>,
53    #[serde(skip_serializing_if = "Option::is_none")]
54    pub model_providers: Option<Vec<String>>,
55    #[serde(skip_serializing_if = "Option::is_none")]
56    pub search_term: Option<String>,
57    #[serde(skip_serializing_if = "Option::is_none")]
58    pub sort_direction: Option<SortDirection>,
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub sort_key: Option<ThreadSortKey>,
61    #[serde(skip_serializing_if = "Option::is_none")]
62    pub source_kinds: Option<Vec<ThreadSourceKind>>,
63    #[serde(skip_serializing_if = "Option::is_none")]
64    pub use_state_db_only: Option<bool>,
65}
66
67#[derive(Clone, Debug, Default, PartialEq, Serialize)]
68#[serde(rename_all = "camelCase")]
69pub struct ThreadResumeOptions {
70    #[serde(skip)]
71    pub approval_mode: Option<ApprovalMode>,
72    #[serde(skip_serializing_if = "Option::is_none")]
73    pub base_instructions: Option<String>,
74    #[serde(skip_serializing_if = "Option::is_none")]
75    pub config: Option<Map<String, Value>>,
76    #[serde(skip_serializing_if = "Option::is_none")]
77    pub cwd: Option<String>,
78    #[serde(skip_serializing_if = "Option::is_none")]
79    pub developer_instructions: Option<String>,
80    #[serde(skip_serializing_if = "Option::is_none")]
81    pub model: Option<String>,
82    #[serde(skip_serializing_if = "Option::is_none")]
83    pub model_provider: Option<String>,
84    #[serde(skip_serializing_if = "Option::is_none")]
85    pub personality: Option<Personality>,
86    #[serde(skip)]
87    pub sandbox: Option<Sandbox>,
88    #[serde(skip_serializing_if = "Option::is_none")]
89    pub service_tier: Option<String>,
90}
91
92#[derive(Clone, Debug, Default, PartialEq, Serialize)]
93#[serde(rename_all = "camelCase")]
94pub struct ThreadForkOptions {
95    #[serde(skip)]
96    pub approval_mode: Option<ApprovalMode>,
97    #[serde(skip_serializing_if = "Option::is_none")]
98    pub base_instructions: Option<String>,
99    #[serde(skip_serializing_if = "Option::is_none")]
100    pub config: Option<Map<String, Value>>,
101    #[serde(skip_serializing_if = "Option::is_none")]
102    pub cwd: Option<String>,
103    #[serde(skip_serializing_if = "Option::is_none")]
104    pub developer_instructions: Option<String>,
105    #[serde(skip_serializing_if = "Option::is_none")]
106    pub ephemeral: Option<bool>,
107    #[serde(skip_serializing_if = "Option::is_none")]
108    pub model: Option<String>,
109    #[serde(skip_serializing_if = "Option::is_none")]
110    pub model_provider: Option<String>,
111    #[serde(skip)]
112    pub sandbox: Option<Sandbox>,
113    #[serde(skip_serializing_if = "Option::is_none")]
114    pub service_tier: Option<String>,
115    #[serde(skip_serializing_if = "Option::is_none")]
116    pub thread_source: Option<ThreadSource>,
117}
118
119#[derive(Clone, Debug, Default, PartialEq, Serialize)]
120#[serde(rename_all = "camelCase")]
121pub struct TurnOptions {
122    #[serde(skip)]
123    pub approval_mode: Option<ApprovalMode>,
124    #[serde(skip_serializing_if = "Option::is_none")]
125    pub cwd: Option<String>,
126    #[serde(skip_serializing_if = "Option::is_none")]
127    pub effort: Option<ReasoningEffort>,
128    #[serde(skip_serializing_if = "Option::is_none")]
129    pub model: Option<String>,
130    #[serde(skip_serializing_if = "Option::is_none")]
131    pub output_schema: Option<Map<String, Value>>,
132    #[serde(skip_serializing_if = "Option::is_none")]
133    pub personality: Option<Personality>,
134    #[serde(skip)]
135    pub sandbox: Option<Sandbox>,
136    #[serde(skip_serializing_if = "Option::is_none")]
137    pub service_tier: Option<String>,
138    #[serde(skip_serializing_if = "Option::is_none")]
139    pub summary: Option<ReasoningSummary>,
140}
141
142pub(crate) fn serialize_options<T: Serialize>(options: &T) -> crate::Result<Map<String, Value>> {
143    let Value::Object(values) = serde_json::to_value(options)? else {
144        return Err(Error::InvalidConfiguration(
145            "options must serialize as an object".into(),
146        ));
147    };
148    Ok(values)
149}
150
151pub(crate) fn apply_approval_mode(values: &mut Map<String, Value>, mode: Option<ApprovalMode>) {
152    match mode {
153        None => {}
154        Some(ApprovalMode::AutoReview) => {
155            values.insert("approvalPolicy".into(), Value::String("on-request".into()));
156            values.insert(
157                "approvalsReviewer".into(),
158                Value::String("auto_review".into()),
159            );
160        }
161        Some(ApprovalMode::DenyAll) => {
162            values.insert("approvalPolicy".into(), Value::String("never".into()));
163        }
164    }
165}
166
167pub(crate) fn apply_sandbox_mode(values: &mut Map<String, Value>, sandbox: Option<Sandbox>) {
168    if let Some(sandbox) = sandbox {
169        values.insert("sandbox".into(), Value::String(sandbox.mode().into()));
170    }
171}
172
173pub(crate) fn apply_sandbox_policy(values: &mut Map<String, Value>, sandbox: Option<Sandbox>) {
174    if let Some(sandbox) = sandbox {
175        values.insert("sandboxPolicy".into(), sandbox.policy());
176    }
177}
178
179#[cfg(test)]
180mod tests {
181    use super::*;
182    use serde::Serializer;
183    use serde_json::json;
184
185    struct Scalar;
186
187    impl Serialize for Scalar {
188        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
189        where
190            S: Serializer,
191        {
192            serializer.serialize_bool(true)
193        }
194    }
195
196    #[test]
197    fn option_helpers_encode_all_approval_and_sandbox_modes() {
198        let mut values = Map::new();
199        apply_approval_mode(&mut values, None);
200        apply_sandbox_mode(&mut values, None);
201        apply_sandbox_policy(&mut values, None);
202        assert!(values.is_empty());
203
204        apply_approval_mode(&mut values, Some(ApprovalMode::AutoReview));
205        assert_eq!(values["approvalPolicy"], "on-request");
206        assert_eq!(values["approvalsReviewer"], "auto_review");
207
208        apply_approval_mode(&mut values, Some(ApprovalMode::DenyAll));
209        assert_eq!(values["approvalPolicy"], "never");
210        apply_sandbox_mode(&mut values, Some(Sandbox::FullAccess));
211        assert_eq!(values["sandbox"], "danger-full-access");
212        apply_sandbox_policy(&mut values, Some(Sandbox::WorkspaceWrite));
213        assert_eq!(
214            values["sandboxPolicy"],
215            json!({
216                "excludeSlashTmp":false,
217                "excludeTmpdirEnvVar":false,
218                "networkAccess":false,
219                "type":"workspaceWrite",
220                "writableRoots":[]
221            })
222        );
223    }
224
225    #[test]
226    fn serialize_options_rejects_non_objects() {
227        assert!(matches!(
228            serialize_options(&Scalar),
229            Err(Error::InvalidConfiguration(message))
230                if message == "options must serialize as an object"
231        ));
232    }
233}