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}