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"
));
}
}