Hugging Face's logo

SaylorTwift
/
codex

agent
coding-agent
cli
llm
tool-use
Model card Files
xet
 Community
codex
File size: 4,090 Bytes
bb5a19b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
use schemars::JsonSchema;
use serde::Deserialize;
use serde::Serialize;
use std::collections::BTreeMap;

#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema)]
#[serde(rename_all = "lowercase")]
pub enum AllowDenyRequirementToml {
    Allow,
    Deny,
}

#[derive(Deserialize, Debug, Clone, Default, PartialEq, Eq)]
pub struct BrowserUseOriginPolicyToml {
    pub access: Option<AllowDenyRequirementToml>,
    pub downloads: Option<AllowDenyRequirementToml>,
    pub uploads: Option<AllowDenyRequirementToml>,
    pub full_cdp_access: Option<AllowDenyRequirementToml>,
    pub auto_review: Option<AllowDenyRequirementToml>,
    pub persistent_approval: Option<bool>,
    pub access_approval_lifetime: Option<BrowserUseAccessApprovalLifetimeToml>,
}

impl BrowserUseOriginPolicyToml {
    fn is_empty(&self) -> bool {
        self.access.is_none()
            && self.downloads.is_none()
            && self.uploads.is_none()
            && self.full_cdp_access.is_none()
            && self.auto_review.is_none()
            && self.persistent_approval.is_none()
            && self.access_approval_lifetime.is_none()
    }
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum BrowserUseAccessApprovalLifetimeToml {
    Turn,
    Thread,
}

#[derive(Deserialize, Debug, Clone, Default, PartialEq, Eq)]
pub struct BrowserUseRequirementsToml {
    pub allow_webmcp: Option<bool>,
    pub allow_history_access: Option<bool>,
    pub disable_auto_review: Option<bool>,
    pub allow_global_persistent_approval: Option<bool>,
    pub default_origin_policy: Option<BrowserUseOriginPolicyToml>,
    pub origins: Option<BTreeMap<String, BrowserUseOriginPolicyToml>>,
}

impl BrowserUseRequirementsToml {
    pub fn is_empty(&self) -> bool {
        self.allow_webmcp.is_none()
            && self.allow_history_access.is_none()
            && self.disable_auto_review.is_none()
            && self.allow_global_persistent_approval.is_none()
            && self
                .default_origin_policy
                .as_ref()
                .is_none_or(BrowserUseOriginPolicyToml::is_empty)
            && self
                .origins
                .as_ref()
                .is_none_or(|origins| origins.values().all(BrowserUseOriginPolicyToml::is_empty))
    }
}

#[derive(Deserialize, Debug, Clone, Default, PartialEq, Eq)]
pub struct ComputerUseMacosRequirementsToml {
    pub bundle_ids: Option<BTreeMap<String, AllowDenyRequirementToml>>,
}

#[derive(Deserialize, Debug, Clone, Default, PartialEq, Eq)]
pub struct ComputerUseWindowsRequirementsToml {
    pub aumids: Option<BTreeMap<String, AllowDenyRequirementToml>>,
    pub exes: Option<Vec<ComputerUseWindowsExeRequirementToml>>,
}

#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct ComputerUseWindowsExeRequirementToml {
    pub publisher_name: String,
    pub product_name: String,
    pub binary_name: Option<String>,
    pub access: AllowDenyRequirementToml,
}

#[derive(Deserialize, Debug, Clone, Default, PartialEq, Eq)]
pub struct ComputerUseRequirementsToml {
    pub allow_locked_computer_use: Option<bool>,
    pub allow_persistent_approval: Option<bool>,
    pub default_app_access: Option<AllowDenyRequirementToml>,
    pub macos: Option<ComputerUseMacosRequirementsToml>,
    pub windows: Option<ComputerUseWindowsRequirementsToml>,
}

impl ComputerUseRequirementsToml {
    pub fn is_empty(&self) -> bool {
        self.allow_locked_computer_use.is_none()
            && self.allow_persistent_approval.is_none()
            && self.default_app_access.is_none()
            && self
                .macos
                .as_ref()
                .is_none_or(|macos| macos.bundle_ids.as_ref().is_none_or(BTreeMap::is_empty))
            && self.windows.as_ref().is_none_or(|windows| {
                windows.aumids.as_ref().is_none_or(BTreeMap::is_empty)
                    && windows.exes.as_ref().is_none_or(Vec::is_empty)
            })
    }
}

#[cfg(test)]
#[path = "browser_computer_use_requirements_tests.rs"]
mod tests;