unified-agent-api-codex 0.3.5

Async wrapper around the Codex CLI for programmatic prompting
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use crate::CliOverridesPatch;
use serde_json::Value;
use std::process::ExitStatus;

/// Request for `codex cloud` (overview/help).
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CloudOverviewRequest {
    pub overrides: CliOverridesPatch,
}

impl CloudOverviewRequest {
    pub fn new() -> Self {
        Self {
            overrides: CliOverridesPatch::default(),
        }
    }

    pub fn with_overrides(mut self, overrides: CliOverridesPatch) -> Self {
        self.overrides = overrides;
        self
    }
}

impl Default for CloudOverviewRequest {
    fn default() -> Self {
        Self::new()
    }
}

/// Request for `codex cloud list`.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CloudListRequest {
    pub json: bool,
    pub env_id: Option<String>,
    pub limit: Option<u32>,
    pub cursor: Option<String>,
    pub overrides: CliOverridesPatch,
}

impl CloudListRequest {
    pub fn new() -> Self {
        Self {
            json: false,
            env_id: None,
            limit: None,
            cursor: None,
            overrides: CliOverridesPatch::default(),
        }
    }

    pub fn json(mut self, enable: bool) -> Self {
        self.json = enable;
        self
    }

    pub fn env_id(mut self, env_id: impl Into<String>) -> Self {
        let env_id = env_id.into();
        self.env_id = (!env_id.trim().is_empty()).then_some(env_id);
        self
    }

    pub fn limit(mut self, limit: u32) -> Self {
        self.limit = Some(limit);
        self
    }

    pub fn cursor(mut self, cursor: impl Into<String>) -> Self {
        let cursor = cursor.into();
        self.cursor = (!cursor.trim().is_empty()).then_some(cursor);
        self
    }

    pub fn with_overrides(mut self, overrides: CliOverridesPatch) -> Self {
        self.overrides = overrides;
        self
    }
}

impl Default for CloudListRequest {
    fn default() -> Self {
        Self::new()
    }
}

/// Output from `codex cloud list`.
#[derive(Clone, Debug, PartialEq)]
pub struct CloudListOutput {
    pub status: ExitStatus,
    pub stdout: String,
    pub stderr: String,
    /// Parsed JSON output when `--json` was requested.
    pub json: Option<Value>,
}

/// Request for `codex cloud status <TASK_ID>`.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CloudStatusRequest {
    pub task_id: String,
    pub overrides: CliOverridesPatch,
}

impl CloudStatusRequest {
    pub fn new(task_id: impl Into<String>) -> Self {
        Self {
            task_id: task_id.into(),
            overrides: CliOverridesPatch::default(),
        }
    }

    pub fn with_overrides(mut self, overrides: CliOverridesPatch) -> Self {
        self.overrides = overrides;
        self
    }
}

/// Request for `codex cloud exec`.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CloudExecRequest {
    pub env_id: String,
    pub query: Option<String>,
    pub attempts: Option<u32>,
    pub branch: Option<String>,
    pub overrides: CliOverridesPatch,
}

impl CloudExecRequest {
    pub fn new(env_id: impl Into<String>) -> Self {
        Self {
            env_id: env_id.into(),
            query: None,
            attempts: None,
            branch: None,
            overrides: CliOverridesPatch::default(),
        }
    }

    pub fn query(mut self, query: impl Into<String>) -> Self {
        let query = query.into();
        self.query = (!query.trim().is_empty()).then_some(query);
        self
    }

    pub fn attempts(mut self, attempts: u32) -> Self {
        self.attempts = Some(attempts);
        self
    }

    pub fn branch(mut self, branch: impl Into<String>) -> Self {
        let branch = branch.into();
        self.branch = (!branch.trim().is_empty()).then_some(branch);
        self
    }

    pub fn with_overrides(mut self, overrides: CliOverridesPatch) -> Self {
        self.overrides = overrides;
        self
    }
}