use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use everruns_core::deployment::DeploymentGrade;
use everruns_core::execution_features::{experimental_flag, standard_flag};
#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct FeatureFlags {
pub notifications: bool,
pub evals: bool,
pub skills: bool,
pub memory: bool,
pub knowledge: bool,
pub plugins: bool,
pub app_budgets: bool,
pub agent_versions: bool,
pub voice: bool,
pub agent_delegation: bool,
pub observers: bool,
pub public_chat: bool,
pub webmcp: bool,
pub mcp_events: bool,
pub reports: bool,
pub environments: bool,
pub platform_chat_v2: bool,
pub machine_payments: bool,
#[serde(default)]
pub openai_agents_api: bool,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
#[serde(transparent)]
pub struct FeatureFlagMap(pub BTreeMap<String, bool>);
impl From<&FeatureFlags> for FeatureFlagMap {
fn from(flags: &FeatureFlags) -> Self {
flags.to_map()
}
}
impl From<FeatureFlags> for FeatureFlagMap {
fn from(flags: FeatureFlags) -> Self {
flags.to_map()
}
}
#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
pub struct FeatureFlagDefinition {
pub name: &'static str,
pub label: &'static str,
pub description: &'static str,
pub experimental: bool,
pub platform_managed: bool,
}
fn sandboxes_enabled() -> bool {
let internal = everruns_core::InternalFeatureFlags::from_env();
internal.session_sandbox || internal.container_sandbox
}
pub const API_FEATURE_FLAG_DEFINITIONS: &[FeatureFlagDefinition] = &[
FeatureFlagDefinition {
name: "notifications",
label: "Notifications",
description: "Turns on the in-app notification bell, toasts, and live updates. You get \
alerted in real time when something you care about happens, instead of refreshing \
or checking back manually.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "evals",
label: "Evals",
description: "Lets you define and run behavioral evals against your agents. Use it to \
confirm an agent responds the way you expect and to catch regressions as you change \
prompts or models.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "skills",
label: "Skills",
description: "Create and manage reusable instruction packages that teach agents \
specialized workflows.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "memory",
label: "Memory",
description: "Manage knowledge stores agents can read, including manual notes and \
synchronized files.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "knowledge",
label: "Knowledge indexes",
description: "Connect external document collections and make them searchable by agents.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "plugins",
label: "Plugins",
description: "Install and manage extensions that add integrations, skills, and other \
capabilities.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "app_budgets",
label: "App budgets",
description: "Adds spending limits scoped to individual apps and channels, with automatic \
resets on a schedule. It helps you cap and control costs so a single app or channel \
can't run away with your usage.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "agent_versions",
label: "Agent versions",
description: "Captures immutable snapshots of your agents so you can fork, roll back, and \
pin apps to a specific version. This gives you a safety net to experiment freely \
and return to a known-good agent at any time.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "voice",
label: "Voice",
description: "Enables realtime voice in chat with microphone controls. You can talk to \
your agents and hear responses instead of typing, for a hands-free conversation.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "agent_delegation",
label: "Agent delegation",
description: "Enables outbound agent delegation capabilities, including agent handoffs \
and A2A delegation. When disabled, these capabilities are hidden and cannot be \
assigned.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "platform_chat_v2",
label: "Platform Chat v2",
description: "Runs Platform Chat as one shell: platform operations are the `everruns` \
command alongside ordinary shell tools, over a filesystem holding the product \
documentation and notes that outlive a conversation. The current Platform Chat is \
unchanged and stays the default.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "observers",
label: "Observers",
description: "Runs automatic online scoring on your production sessions. It continuously \
evaluates live conversations so you can monitor quality on real traffic without \
manually reviewing each one.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "environments",
label: "Environments",
description: "Shows where each session's commands run and what that environment can \
actually do, including whether it can run native processes and whether its files \
can be recovered.",
experimental: true,
platform_managed: true,
},
FeatureFlagDefinition {
name: "public_chat",
label: "Public Chat",
description: "Isolated, public-facing chat web app and the public_chat channel.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "webmcp",
label: "WebMCP UI tools",
description: "Exposes a small browser-native tool surface from the authenticated UI so a \
browser agent can search, navigate, and perform confirmed actions in Everruns.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "mcp_events",
label: "MCP Events",
description: "Lets MCP clients such as ChatGPT subscribe to webhooks when a session \
completes, fails, or needs your input.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "reports",
label: "Reports",
description: "Shows the Reports page for exploring usage and cost across sessions, agents, \
and models, and for saving and exporting report queries.",
experimental: true,
platform_managed: false,
},
FeatureFlagDefinition {
name: "openai_agents_api",
label: "OpenAI Agents API runtime",
description: "Allows agents with the OpenAI Agents API runtime capability to run their loop through OpenAI's Agents API instead of the native Everruns loop.",
experimental: true,
platform_managed: true,
},
];
pub fn is_platform_managed(flag: &str) -> bool {
API_FEATURE_FLAG_DEFINITIONS
.iter()
.any(|definition| definition.name == flag && definition.platform_managed)
}
impl FeatureFlags {
pub fn for_org(system: &Self, org_enabled: &std::collections::HashMap<String, bool>) -> Self {
let opt_in = |name: &str, system_on: bool| -> bool {
system_on && org_enabled.get(name).copied().unwrap_or(false)
};
Self {
notifications: opt_in("notifications", system.notifications),
evals: opt_in("evals", system.evals),
skills: opt_in("skills", system.skills),
memory: opt_in("memory", system.memory),
knowledge: opt_in("knowledge", system.knowledge),
plugins: opt_in("plugins", system.plugins),
app_budgets: opt_in("app_budgets", system.app_budgets),
agent_versions: opt_in("agent_versions", system.agent_versions),
voice: opt_in("voice", system.voice),
agent_delegation: opt_in("agent_delegation", system.agent_delegation),
observers: opt_in("observers", system.observers),
platform_chat_v2: opt_in("platform_chat_v2", system.platform_chat_v2),
public_chat: opt_in("public_chat", system.public_chat),
webmcp: opt_in("webmcp", system.webmcp),
mcp_events: opt_in("mcp_events", system.mcp_events),
reports: opt_in("reports", system.reports),
environments: opt_in("environments", system.environments),
machine_payments: system.machine_payments,
openai_agents_api: opt_in("openai_agents_api", system.openai_agents_api),
}
}
pub fn from_env(grade: &DeploymentGrade) -> Self {
Self {
notifications: experimental_flag("FEATURE_NOTIFICATIONS", grade),
evals: experimental_flag("FEATURE_EVALS", grade),
skills: experimental_flag("FEATURE_SKILLS", grade),
memory: experimental_flag("FEATURE_MEMORY", grade),
knowledge: experimental_flag("FEATURE_KNOWLEDGE", grade),
plugins: experimental_flag("FEATURE_PLUGINS", grade),
app_budgets: experimental_flag("FEATURE_APP_BUDGETS", grade),
agent_versions: experimental_flag("FEATURE_AGENT_VERSIONS", grade),
voice: experimental_flag("FEATURE_VOICE", grade),
agent_delegation: experimental_flag("FEATURE_AGENT_DELEGATION", grade),
observers: experimental_flag("FEATURE_OBSERVERS", grade),
platform_chat_v2: experimental_flag("FEATURE_PLATFORM_CHAT_V2", grade),
public_chat: experimental_flag("FEATURE_PUBLIC_CHAT", grade),
webmcp: experimental_flag("FEATURE_WEBMCP", grade),
mcp_events: experimental_flag("FEATURE_MCP_EVENTS", grade),
reports: experimental_flag("FEATURE_REPORTS", grade),
environments: standard_flag(
"FEATURE_ENVIRONMENTS",
sandboxes_enabled() || grade.experimental_features_enabled(),
),
machine_payments: standard_flag("FEATURE_MACHINE_PAYMENTS", false),
openai_agents_api: standard_flag("FEATURE_OPENAI_AGENTS_API", false),
}
}
pub fn current() -> Self {
Self::from_env(&DeploymentGrade::from_env())
}
pub fn to_map(&self) -> FeatureFlagMap {
FeatureFlagMap(BTreeMap::from([
("notifications".to_string(), self.notifications),
("evals".to_string(), self.evals),
("skills".to_string(), self.skills),
("memory".to_string(), self.memory),
("knowledge".to_string(), self.knowledge),
("plugins".to_string(), self.plugins),
("app_budgets".to_string(), self.app_budgets),
("agent_versions".to_string(), self.agent_versions),
("voice".to_string(), self.voice),
("agent_delegation".to_string(), self.agent_delegation),
("observers".to_string(), self.observers),
("environments".to_string(), self.environments),
("public_chat".to_string(), self.public_chat),
("webmcp".to_string(), self.webmcp),
("mcp_events".to_string(), self.mcp_events),
("reports".to_string(), self.reports),
("platform_chat_v2".to_string(), self.platform_chat_v2),
("machine_payments".to_string(), self.machine_payments),
("openai_agents_api".to_string(), self.openai_agents_api),
]))
}
pub fn is_enabled(&self, flag: &str) -> bool {
match flag {
"platform_chat_v2" => self.platform_chat_v2,
"notifications" => self.notifications,
"evals" => self.evals,
"skills" => self.skills,
"memory" => self.memory,
"knowledge" => self.knowledge,
"plugins" => self.plugins,
"app_budgets" => self.app_budgets,
"agent_versions" => self.agent_versions,
"voice" => self.voice,
"agent_delegation" => self.agent_delegation,
"observers" => self.observers,
"environments" => self.environments,
"public_chat" => self.public_chat,
"webmcp" => self.webmcp,
"mcp_events" => self.mcp_events,
"reports" => self.reports,
"machine_payments" => self.machine_payments,
"openai_agents_api" => self.openai_agents_api,
_ => false,
}
}
pub fn is_capability_enabled(&self, capability_id: &str) -> bool {
Self::required_for_capability(capability_id).is_none_or(|flag| self.is_enabled(flag))
}
pub fn required_for_capability(capability_id: &str) -> Option<&'static str> {
match capability_id {
"skills" => Some("skills"),
"memory" => Some("memory"),
"knowledge_index" | "knowledge_base" => Some("knowledge"),
"a2a_agent_delegation" | "ag_ui_delegation" | "agent_handoff" => {
Some("agent_delegation")
}
everruns_core::capabilities::OPENAI_AGENTS_API_RUNTIME_ID => Some("openai_agents_api"),
_ if capability_id.starts_with("skill:") => Some("skills"),
_ if capability_id.starts_with("plugin:") => Some("plugins"),
_ => None,
}
}
#[cfg(test)]
pub fn all_enabled() -> Self {
Self {
notifications: true,
evals: true,
skills: true,
memory: true,
knowledge: true,
plugins: true,
app_budgets: true,
agent_versions: true,
voice: true,
agent_delegation: true,
observers: true,
platform_chat_v2: true,
environments: true,
public_chat: true,
webmcp: true,
mcp_events: true,
reports: true,
machine_payments: true,
openai_agents_api: true,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
fn lock_env() -> std::sync::MutexGuard<'static, ()> {
ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner())
}
fn restore_env(key: &str, prev: Option<String>) {
match prev {
Some(value) => unsafe { std::env::set_var(key, value) },
None => unsafe { std::env::remove_var(key) },
}
}
#[test]
fn test_default_flags() {
let flags = FeatureFlags::default();
assert!(!flags.notifications);
}
#[test]
fn test_experimental_enabled_in_dev() {
let _lock = lock_env();
unsafe { std::env::remove_var("FEATURE_EVALS") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Dev);
assert!(flags.evals);
}
#[test]
fn test_experimental_disabled_in_prod() {
let _lock = lock_env();
unsafe { std::env::remove_var("FEATURE_EVALS") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Prod);
assert!(!flags.evals);
}
#[test]
fn test_env_override_enables_in_prod() {
let _lock = lock_env();
unsafe { std::env::set_var("FEATURE_EVALS", "true") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Prod);
assert!(flags.evals);
unsafe { std::env::remove_var("FEATURE_EVALS") };
}
#[test]
fn test_env_override_disables_in_dev() {
let _lock = lock_env();
unsafe { std::env::set_var("FEATURE_EVALS", "false") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Dev);
assert!(!flags.evals);
unsafe { std::env::remove_var("FEATURE_EVALS") };
}
#[test]
fn environments_follows_sandbox_enablement_in_prod() {
let _lock = lock_env();
let previous_environments = std::env::var("FEATURE_ENVIRONMENTS").ok();
let previous_sandbox = std::env::var("FEATURE_SESSION_SANDBOX").ok();
unsafe { std::env::remove_var("FEATURE_ENVIRONMENTS") };
unsafe { std::env::remove_var("FEATURE_SESSION_SANDBOX") };
assert!(
!FeatureFlags::from_env(&DeploymentGrade::Prod).environments,
"a prod deployment with no sandboxes has nothing to describe"
);
unsafe { std::env::set_var("FEATURE_SESSION_SANDBOX", "true") };
assert!(
FeatureFlags::from_env(&DeploymentGrade::Prod).environments,
"turning sandboxes on should not need a second switch"
);
unsafe { std::env::set_var("FEATURE_ENVIRONMENTS", "false") };
assert!(!FeatureFlags::from_env(&DeploymentGrade::Prod).environments);
restore_env("FEATURE_ENVIRONMENTS", previous_environments);
restore_env("FEATURE_SESSION_SANDBOX", previous_sandbox);
}
#[test]
fn environments_is_org_scoped_but_platform_managed() {
assert!(
API_FEATURE_FLAG_DEFINITIONS
.iter()
.any(|definition| definition.name == "environments" && definition.platform_managed),
"environments is org-scoped but not the org's own decision"
);
assert!(is_platform_managed("environments"));
assert!(!is_platform_managed("skills"));
let system = FeatureFlags {
environments: true,
..FeatureFlags::default()
};
assert!(!FeatureFlags::for_org(&system, &std::collections::HashMap::new()).environments);
let enrolled = std::collections::HashMap::from([("environments".to_string(), true)]);
assert!(FeatureFlags::for_org(&system, &enrolled).environments);
assert!(!FeatureFlags::for_org(&FeatureFlags::default(), &enrolled).environments);
}
#[test]
fn test_is_enabled_dynamic() {
let flags = FeatureFlags {
platform_chat_v2: false,
notifications: true,
evals: true,
skills: true,
memory: true,
knowledge: true,
plugins: true,
app_budgets: true,
agent_versions: true,
voice: true,
agent_delegation: true,
observers: true,
environments: true,
public_chat: true,
webmcp: true,
mcp_events: true,
reports: true,
machine_payments: true,
openai_agents_api: true,
};
assert!(flags.is_enabled("notifications"));
assert!(flags.is_enabled("evals"));
assert!(flags.is_enabled("skills"));
assert!(flags.is_enabled("memory"));
assert!(flags.is_enabled("knowledge"));
assert!(flags.is_enabled("plugins"));
assert!(flags.is_enabled("app_budgets"));
assert!(flags.is_enabled("agent_versions"));
assert!(flags.is_enabled("voice"));
assert!(flags.is_enabled("agent_delegation"));
assert!(flags.is_enabled("observers"));
assert!(flags.is_enabled("public_chat"));
assert!(
!flags.is_enabled("mcp_endpoint"),
"MCP is a product surface, not a feature flag"
);
assert!(flags.is_enabled("webmcp"));
assert!(flags.is_enabled("reports"));
assert!(flags.is_enabled("machine_payments"));
assert!(flags.is_enabled("openai_agents_api"));
assert!(!flags.is_enabled("nonexistent"));
}
#[test]
fn agent_delegation_capabilities_follow_effective_flag() {
let disabled = FeatureFlags::default();
assert!(!disabled.is_capability_enabled("a2a_agent_delegation"));
assert!(!disabled.is_capability_enabled("ag_ui_delegation"));
assert!(!disabled.is_capability_enabled("agent_handoff"));
assert!(!disabled.is_capability_enabled("skills"));
assert!(!disabled.is_capability_enabled("skill:019abc"));
assert!(!disabled.is_capability_enabled("memory"));
assert!(!disabled.is_capability_enabled("knowledge_index"));
assert!(!disabled.is_capability_enabled("knowledge_base"));
assert!(!disabled.is_capability_enabled("plugin:019abc"));
assert!(disabled.is_capability_enabled("current_time"));
let enabled = FeatureFlags {
agent_delegation: true,
skills: true,
memory: true,
knowledge: true,
plugins: true,
..FeatureFlags::default()
};
assert!(enabled.is_capability_enabled("a2a_agent_delegation"));
assert!(enabled.is_capability_enabled("ag_ui_delegation"));
assert!(enabled.is_capability_enabled("agent_handoff"));
assert!(enabled.is_capability_enabled("skills"));
assert!(enabled.is_capability_enabled("skill:019abc"));
assert!(enabled.is_capability_enabled("memory"));
assert!(enabled.is_capability_enabled("knowledge_index"));
assert!(enabled.is_capability_enabled("knowledge_base"));
assert!(enabled.is_capability_enabled("plugin:019abc"));
}
#[test]
fn test_serialization() {
let flags = FeatureFlags {
platform_chat_v2: false,
notifications: true,
evals: true,
skills: true,
memory: true,
knowledge: true,
plugins: true,
app_budgets: true,
agent_versions: true,
voice: true,
agent_delegation: true,
observers: true,
environments: true,
public_chat: true,
webmcp: true,
mcp_events: true,
reports: true,
machine_payments: true,
openai_agents_api: true,
};
let json = serde_json::to_string(&flags).unwrap();
assert!(json.contains("\"notifications\":true"));
assert!(json.contains("\"app_budgets\":true"));
assert!(json.contains("\"agent_versions\":true"));
assert!(json.contains("\"voice\":true"));
assert!(json.contains("\"agent_delegation\":true"));
assert!(json.contains("\"observers\":true"));
assert!(json.contains("\"webmcp\":true"));
assert!(json.contains("\"machine_payments\":true"));
assert!(json.contains("\"openai_agents_api\":true"));
let parsed: FeatureFlags = serde_json::from_str(&json).unwrap();
assert_eq!(flags, parsed);
}
#[test]
fn test_to_map_matches_serialized_flags() {
let flags = FeatureFlags::all_enabled();
let typed: serde_json::Value = serde_json::to_value(&flags).unwrap();
let map: serde_json::Value = serde_json::to_value(flags.to_map()).unwrap();
assert_eq!(typed, map);
let default_typed: serde_json::Value =
serde_json::to_value(FeatureFlags::default()).unwrap();
let default_map: serde_json::Value =
serde_json::to_value(FeatureFlags::default().to_map()).unwrap();
assert_eq!(default_typed, default_map);
}
#[test]
fn test_mcp_endpoint_is_not_in_api_feature_flag_catalog() {
assert!(
API_FEATURE_FLAG_DEFINITIONS
.iter()
.all(|definition| definition.name != "mcp_endpoint")
);
}
#[test]
fn test_agent_delegation_enabled_in_dev() {
let _lock = lock_env();
unsafe { std::env::remove_var("FEATURE_AGENT_DELEGATION") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Dev);
assert!(flags.agent_delegation);
}
#[test]
fn test_agent_delegation_disabled_in_prod() {
let _lock = lock_env();
unsafe { std::env::remove_var("FEATURE_AGENT_DELEGATION") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Prod);
assert!(!flags.agent_delegation);
}
#[test]
fn test_agent_delegation_env_override_in_prod() {
let _lock = lock_env();
unsafe { std::env::set_var("FEATURE_AGENT_DELEGATION", "true") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Prod);
assert!(flags.agent_delegation);
unsafe { std::env::remove_var("FEATURE_AGENT_DELEGATION") };
}
#[test]
fn test_notifications_enabled_in_dev() {
let _lock = lock_env();
unsafe { std::env::remove_var("FEATURE_NOTIFICATIONS") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Dev);
assert!(flags.notifications);
}
#[test]
fn test_notifications_disabled_in_prod() {
let _lock = lock_env();
unsafe { std::env::remove_var("FEATURE_NOTIFICATIONS") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Prod);
assert!(!flags.notifications);
}
#[test]
fn test_for_org_requires_system_and_opt_in() {
let system = FeatureFlags {
evals: true,
notifications: true,
machine_payments: true,
..FeatureFlags::default()
};
let mut org = std::collections::HashMap::new();
org.insert("evals".to_string(), true);
let effective = FeatureFlags::for_org(&system, &org);
assert!(effective.evals);
assert!(!effective.notifications);
assert!(effective.machine_payments);
let effective_none = FeatureFlags::for_org(&system, &std::collections::HashMap::new());
assert!(!effective_none.evals);
assert!(effective_none.machine_payments);
}
#[test]
fn test_optional_ui_modules_require_org_opt_in() {
let system = FeatureFlags {
evals: true,
skills: true,
memory: true,
knowledge: true,
plugins: true,
..FeatureFlags::default()
};
let disabled = FeatureFlags::for_org(&system, &std::collections::HashMap::new());
assert!(!disabled.evals);
assert!(!disabled.skills);
assert!(!disabled.memory);
assert!(!disabled.knowledge);
assert!(!disabled.plugins);
let org = std::collections::HashMap::from([
("evals".to_string(), true),
("skills".to_string(), true),
("memory".to_string(), true),
("knowledge".to_string(), true),
("plugins".to_string(), true),
]);
let enabled = FeatureFlags::for_org(&system, &org);
assert!(enabled.evals);
assert!(enabled.skills);
assert!(enabled.memory);
assert!(enabled.knowledge);
assert!(enabled.plugins);
}
#[test]
fn test_for_org_cannot_enable_when_system_off() {
let system = FeatureFlags::default();
let mut org = std::collections::HashMap::new();
org.insert("evals".to_string(), true);
let effective = FeatureFlags::for_org(&system, &org);
assert!(!effective.evals);
}
#[test]
fn test_notifications_respects_env_override() {
let _lock = lock_env();
unsafe { std::env::set_var("FEATURE_NOTIFICATIONS", "true") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Prod);
assert!(flags.notifications);
unsafe { std::env::remove_var("FEATURE_NOTIFICATIONS") };
}
#[test]
fn test_machine_payments_disabled_by_default() {
let _lock = lock_env();
let prev = std::env::var("FEATURE_MACHINE_PAYMENTS").ok();
unsafe { std::env::remove_var("FEATURE_MACHINE_PAYMENTS") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Dev);
assert!(
!flags.machine_payments,
"machine_payments should be disabled by default on all envs"
);
restore_env("FEATURE_MACHINE_PAYMENTS", prev);
}
#[test]
fn test_machine_payments_enabled_by_env_override() {
let _lock = lock_env();
let prev = std::env::var("FEATURE_MACHINE_PAYMENTS").ok();
unsafe { std::env::set_var("FEATURE_MACHINE_PAYMENTS", "true") };
let flags = FeatureFlags::from_env(&DeploymentGrade::Prod);
assert!(flags.machine_payments);
restore_env("FEATURE_MACHINE_PAYMENTS", prev);
}
#[test]
fn reports_is_off_until_an_org_opts_in() {
let _lock = lock_env();
let prev = std::env::var("FEATURE_REPORTS").ok();
unsafe { std::env::remove_var("FEATURE_REPORTS") };
assert!(!FeatureFlags::from_env(&DeploymentGrade::Prod).reports);
let system = FeatureFlags::from_env(&DeploymentGrade::Dev);
assert!(system.reports);
let no_opt_in = std::collections::HashMap::new();
assert!(!FeatureFlags::for_org(&system, &no_opt_in).reports);
let opted_in = std::collections::HashMap::from([("reports".to_string(), true)]);
assert!(FeatureFlags::for_org(&system, &opted_in).reports);
let definition = API_FEATURE_FLAG_DEFINITIONS
.iter()
.find(|definition| definition.name == "reports")
.expect("reports is in the org opt-in catalog");
assert!(definition.experimental);
assert!(!definition.platform_managed);
restore_env("FEATURE_REPORTS", prev);
}
#[test]
fn openai_agents_api_is_platform_managed_and_off_by_default() {
let _lock = lock_env();
let previous = std::env::var("FEATURE_OPENAI_AGENTS_API").ok();
unsafe { std::env::remove_var("FEATURE_OPENAI_AGENTS_API") };
assert!(!FeatureFlags::from_env(&DeploymentGrade::Dev).openai_agents_api);
assert!(is_platform_managed("openai_agents_api"));
unsafe { std::env::set_var("FEATURE_OPENAI_AGENTS_API", "true") };
let system = FeatureFlags::from_env(&DeploymentGrade::Prod);
assert!(system.openai_agents_api);
assert!(
!FeatureFlags::for_org(&system, &std::collections::HashMap::new()).openai_agents_api
);
let enrolled = std::collections::HashMap::from([("openai_agents_api".to_string(), true)]);
assert!(FeatureFlags::for_org(&system, &enrolled).openai_agents_api);
restore_env("FEATURE_OPENAI_AGENTS_API", previous);
}
#[test]
fn agents_api_runtime_capability_requires_the_org_flag() {
assert_eq!(
FeatureFlags::required_for_capability("openai_agents_api_runtime"),
Some("openai_agents_api")
);
let off = FeatureFlags::default();
assert!(!off.is_capability_enabled("openai_agents_api_runtime"));
let on = FeatureFlags {
openai_agents_api: true,
..FeatureFlags::default()
};
assert!(on.is_capability_enabled("openai_agents_api_runtime"));
}
}