Add explicit self-serve business usage plan type

codex-rs/backend-client/src/client.rs

@@ -477,6 +477,9 @@ impl Client {
             crate::types::PlanType::Business => AccountPlanType::Business,
             crate::types::PlanType::Enterprise => AccountPlanType::Enterprise,
             crate::types::PlanType::Edu | crate::types::PlanType::Education => AccountPlanType::Edu,
+            crate::types::PlanType::SelfServeBusinessUsage => {
+                AccountPlanType::SelfServeBusinessUsage
+            }
             crate::types::PlanType::Guest
             | crate::types::PlanType::FreeWorkspace
             | crate::types::PlanType::Quorum

codex-rs/codex-backend-openapi-models/src/models/rate_limit_status_payload.rs

@@ -81,4 +81,6 @@ pub enum PlanType {
     Enterprise,
     #[serde(rename = "edu")]
     Edu,
+    #[serde(rename = "self_serve_business_usage_based")]
+    SelfServeBusinessUsage,
 }

codex-rs/core/src/error.rs

@@ -460,9 +460,7 @@ impl std::fmt::Display for UsageLimitReachedError {
                 "You've hit your usage limit.{}",
                 retry_suffix(self.resets_at.as_ref())
             ),
-            Some(PlanType::Unknown(plan))
-                if plan.eq_ignore_ascii_case("self_serve_business_usage_based") =>
-            {
+            Some(PlanType::SelfServeBusinessUsage) => {
                 match self
                     .rate_limits
                     .as_ref()

codex-rs/exec/src/lib.rs

@@ -1397,6 +1397,7 @@ fn local_external_chatgpt_tokens(
         AccountPlanType::Business => "business".to_string(),
         AccountPlanType::Enterprise => "enterprise".to_string(),
         AccountPlanType::Edu => "edu".to_string(),
+        AccountPlanType::SelfServeBusinessUsage => "self_serve_business_usage_based".to_string(),
         AccountPlanType::Unknown => "unknown".to_string(),
     });
 

codex-rs/login/src/auth/manager.rs

@@ -275,6 +275,9 @@ impl CodexAuth {
                 .chatgpt_plan_type
                 .map(|pt| match pt {
                     InternalPlanType::Known(k) => map_known(&k),
+                    InternalPlanType::SelfServeBusinessUsage => {
+                        AccountPlanType::SelfServeBusinessUsage
+                    }
                     InternalPlanType::Unknown(_) => AccountPlanType::Unknown,
                 })
                 .unwrap_or(AccountPlanType::Unknown)

codex-rs/login/src/token_data.rs

@@ -39,6 +39,7 @@ impl IdTokenInfo {
     pub fn get_chatgpt_plan_type(&self) -> Option<String> {
         self.chatgpt_plan_type.as_ref().map(|t| match t {
             PlanType::Known(plan) => format!("{plan:?}"),
+            PlanType::SelfServeBusinessUsage => "self_serve_business_usage_based".to_string(),
             PlanType::Unknown(s) => s.clone(),
         })
     }
@@ -48,15 +49,15 @@ impl IdTokenInfo {
             self.chatgpt_plan_type,
             Some(PlanType::Known(
                 KnownPlan::Team | KnownPlan::Business | KnownPlan::Enterprise | KnownPlan::Edu
-            ))
+            ) | PlanType::SelfServeBusinessUsage)
         )
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(untagged)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PlanType {
     Known(KnownPlan),
+    SelfServeBusinessUsage,
     Unknown(String),
 }
 
@@ -71,11 +72,46 @@ impl PlanType {
             "business" => Self::Known(KnownPlan::Business),
             "enterprise" => Self::Known(KnownPlan::Enterprise),
             "education" | "edu" => Self::Known(KnownPlan::Edu),
+            "self_serve_business_usage_based" => Self::SelfServeBusinessUsage,
             _ => Self::Unknown(raw.to_string()),
         }
     }
 }
 
+impl Serialize for PlanType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let value = match self {
+            Self::Known(plan) => match plan {
+                KnownPlan::Free => "free",
+                KnownPlan::Go => "go",
+                KnownPlan::Plus => "plus",
+                KnownPlan::Pro => "pro",
+                KnownPlan::Team => "team",
+                KnownPlan::Business => "business",
+                KnownPlan::Enterprise => "enterprise",
+                KnownPlan::Edu => "edu",
+            },
+            Self::SelfServeBusinessUsage => "self_serve_business_usage_based",
+            Self::Unknown(raw) => raw,
+        };
+
+        serializer.serialize_str(value)
+    }
+}
+
+impl<'de> Deserialize<'de> for PlanType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let raw = String::deserialize(deserializer)?;
+        Ok(Self::from_raw_value(&raw))
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum KnownPlan {

codex-rs/protocol/src/account.rs

@@ -16,6 +16,9 @@ pub enum PlanType {
     Business,
     Enterprise,
     Edu,
+    #[serde(rename = "self_serve_business_usage_based")]
+    #[ts(rename = "self_serve_business_usage_based")]
+    SelfServeBusinessUsage,
     #[serde(other)]
     Unknown,
 }