#[cfg(feature = "a2a")]
pub mod a2a_delegation;
pub mod agent_handoff;
pub mod background_execution;
pub mod citation_retrieval;
pub mod citation_verification;
pub mod data_knowledge;
pub mod delegation_result;
pub mod knowledge_base;
pub mod knowledge_index;
pub mod memory;
pub mod monitors;
pub mod platform;
pub mod platform_management;
pub mod research;
pub mod session_sandbox;
pub mod session_schedule;
pub mod session_sql_database;
pub mod session_tasks;
pub mod subagents;
pub mod user_hooks;
pub mod util;
pub use everruns_core::capabilities::{
A2A_AGENT_DELEGATION_CAPABILITY_ID, AGENT_RUN_KEY_PREFIX, DelegationTargetProvider,
SPAWN_AGENT_CONCURRENCY_CLASS,
};
pub(crate) use everruns_core::capabilities::{
Capability, CapabilityLocalization, CapabilityStatus, MountDirectoryBuilder, MountPoint,
RiskLevel, SpawnMode, SystemPromptContext,
};
#[cfg(feature = "a2a")]
pub use a2a_delegation::{A2aAgentDelegationCapability, SpawnAgentTool};
pub use agent_handoff::{
AGENT_HANDOFF_CAPABILITY_ID, AgentHandoffCapability, SpawnAgentHandoffTool,
};
pub use background_execution::{BACKGROUND_EXECUTION_CAPABILITY_ID, BackgroundExecutionCapability};
pub use citation_retrieval::{
CITATION_RETRIEVAL_CAPABILITY_ID, CitationRetrievalCapability, CitationRetrievalConfig,
};
pub use citation_verification::{
CITATION_VERIFICATION_CAPABILITY_ID, CitationVerificationCapability,
CitationVerificationConfig, VerificationMode,
};
pub use data_knowledge::{DATA_KNOWLEDGE_CAPABILITY_ID, DataKnowledgeCapability};
pub use delegation_result::{
ReportResultTool, ReportTaskProgressTool, report_result_tool_for_child_session,
report_task_progress_tool_for_child_session,
};
pub use everruns_host::session_services::capabilities::session::{
GetSessionInfoTool, SESSION_CAPABILITY_ID, SessionCapability, SessionCapabilityConfig,
SessionTitleMutation, WriteSessionTitleTool, session_title_updated_event,
update_session_title_with_event,
};
pub use everruns_host::session_services::capabilities::session_storage::{
KvStoreTool, SESSION_STORAGE_CAPABILITY_ID, SecretStoreTool, SessionStorageCapability,
is_internal_session_kv_key, is_internal_session_secret_name,
};
pub use knowledge_base::{
KNOWLEDGE_BASE_CAPABILITY_ID, KnowledgeBaseCapability, KnowledgeBaseConfig,
validate_knowledge_base_config,
};
pub use knowledge_index::{
KNOWLEDGE_INDEX_CAPABILITY_ID, KnowledgeIndexCapability, KnowledgeIndexConfig,
validate_knowledge_index_config,
};
pub use memory::{MEMORY_CAPABILITY_ID, MemoryCapability};
pub use platform::{
DISCOVER_DESCRIPTION as PLATFORM_DISCOVER_DESCRIPTION,
EXECUTE_DESCRIPTION as PLATFORM_EXECUTE_DESCRIPTION, PLATFORM_CAPABILITY_ID,
PlatformCapability, QUERY_DESCRIPTION as PLATFORM_QUERY_DESCRIPTION, discover_input_schema,
execute_input_schema, query_input_schema,
};
pub use platform_management::{
ManageAgentsTool, ManageHarnessesTool, ManageSessionsTool, PLATFORM_MANAGEMENT_CAPABILITY_ID,
PlatformManagementCapability, ReadAgentsTool, ReadCapabilitiesTool, ReadHarnessesTool,
ReadSessionsTool, SessionReadMessagesTool, SessionReadResponseTool, SessionSendMessageTool,
};
pub use research::{RESEARCH_CAPABILITY_ID, ResearchCapability};
pub use session_sandbox::{
SESSION_SANDBOX_CAPABILITY_ID, SandboxExecTool, SandboxManageTool, SandboxReadFileTool,
SandboxStatusTool, SandboxWriteFileTool, SessionSandboxCapability,
};
pub use session_schedule::{
CancelScheduleTool, CreateScheduleTool, ListSchedulesTool, SESSION_SCHEDULE_CAPABILITY_ID,
SessionScheduleCapability,
};
pub use session_sql_database::{
SESSION_SQL_DATABASE_CAPABILITY_ID, SessionSqlDatabaseCapability, SqlExecuteTool, SqlQueryTool,
SqlSchemaTool,
};
pub use session_tasks::{SESSION_TASKS_CAPABILITY_ID, SessionTasksCapability};
pub use subagents::{
SUBAGENTS_CAPABILITY_ID, SpawnLifetime, SpawnSubagentAsAgentTool, SubagentCapability,
};
pub use user_hooks::{USER_HOOKS_CAPABILITY_ID, UserHooksCapability};
pub fn register_platform_capabilities(
registry: &mut everruns_core::capabilities::CapabilityRegistry,
) {
registry.register(PlatformCapability);
registry.register(PlatformManagementCapability);
}
#[cfg(feature = "environment-capabilities")]
pub fn register_environment_capabilities(
registry: &mut everruns_core::capabilities::CapabilityRegistry,
) {
registry.register(everruns_integrations_filesystem::FileSystemCapability);
registry.register(everruns_integrations_bashkit::BashkitShellCapability);
registry.register(everruns_integrations_web_fetch::WebFetchCapability::from_env());
registry.register(everruns_integrations_openrouter_workspace::OpenRouterServerToolsCapability);
registry.register(everruns_integrations_openrouter_workspace::ModelScoutCapability);
registry.register(everruns_integrations_openrouter_workspace::OpenRouterWorkspaceCapability);
#[cfg(feature = "lua")]
if everruns_core::InternalFeatureFlags::from_env().lua {
registry.register(everruns_integrations_lua::LuaCapability);
registry.register(everruns_integrations_lua::LuaCodeModeCapability);
}
}
#[cfg(not(feature = "environment-capabilities"))]
fn register_environment_capabilities(
_registry: &mut everruns_core::capabilities::CapabilityRegistry,
) {
}
fn register_inventory_capabilities(
registry: &mut everruns_core::CapabilityRegistry,
grade: everruns_core::DeploymentGrade,
) {
let feature_decisions = everruns_core::ExecutionFeatureDecisions::from_env(grade);
registry.register_inventory_plugins(|plugin| {
(!plugin.experimental_only || grade.experimental_features_enabled())
&& plugin
.feature_flag
.is_none_or(|flag| feature_decisions.is_enabled(flag))
});
}
pub fn register_hosted_capabilities(
registry: &mut everruns_core::capabilities::CapabilityRegistry,
grade: everruns_core::DeploymentGrade,
) {
registry.register(SessionCapability);
registry.register(SessionStorageCapability);
registry.register(SessionSqlDatabaseCapability);
if everruns_core::InternalFeatureFlags::from_env().session_sandbox {
registry.register(SessionSandboxCapability);
}
registry.register(ResearchCapability);
registry.register(MemoryCapability);
registry.register(BackgroundExecutionCapability);
registry.register(SessionScheduleCapability);
registry.register(SubagentCapability);
registry.register(SessionTasksCapability);
if everruns_core::ExecutionFeatureDecisions::from_env(grade).agent_delegation {
registry.register(AgentHandoffCapability);
#[cfg(feature = "a2a")]
registry.register(A2aAgentDelegationCapability);
}
registry.register(UserHooksCapability);
registry.register(DataKnowledgeCapability);
registry.register(KnowledgeBaseCapability);
registry.register(KnowledgeIndexCapability);
registry.register(CitationRetrievalCapability);
registry.register(CitationVerificationCapability);
register_environment_capabilities(registry);
register_platform_capabilities(registry);
}
pub fn hosted_capability_registry_for_grade(
grade: everruns_core::DeploymentGrade,
) -> everruns_core::capabilities::CapabilityRegistry {
let mut registry = everruns_core::capabilities::CapabilityRegistry::new();
#[cfg(feature = "portable-builtins")]
everruns_builtins::register_portable_capabilities(&mut registry)
.expect("portable built-in catalog must have unique capability IDs");
register_inventory_capabilities(&mut registry, grade);
register_hosted_capabilities(&mut registry, grade);
registry
}
pub fn hosted_capability_registry() -> everruns_core::capabilities::CapabilityRegistry {
hosted_capability_registry_for_grade(everruns_core::DeploymentGrade::from_env())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hosted_registry_always_contains_platform_capabilities() {
let registry = hosted_capability_registry_for_grade(everruns_core::DeploymentGrade::Prod);
assert!(registry.has(PLATFORM_CAPABILITY_ID));
assert!(registry.has(PLATFORM_MANAGEMENT_CAPABILITY_ID));
}
#[test]
fn a2a_delegation_registration_follows_the_a2a_feature() {
if std::env::var("FEATURE_AGENT_DELEGATION").is_ok() {
return;
}
let registry = hosted_capability_registry_for_grade(everruns_core::DeploymentGrade::Dev);
assert!(
registry.has(AGENT_HANDOFF_CAPABILITY_ID),
"dev grade should register agent delegation, otherwise this test is vacuous"
);
assert_eq!(
registry.has(everruns_core::capabilities::A2A_AGENT_DELEGATION_CAPABILITY_ID),
cfg!(feature = "a2a"),
);
}
#[cfg(feature = "portable-builtins")]
#[test]
fn hosted_registry_contains_full_portable_policy_catalog() {
let registry = hosted_capability_registry_for_grade(everruns_core::DeploymentGrade::Prod);
for capability_id in [
"human_intent",
"infinity_context",
"skills",
"current_time",
"compaction",
"tool_call_repair",
"usage_limit_auto_continue",
"openui",
"a2ui",
] {
assert!(
registry.has(capability_id),
"hosted product registry is missing `{capability_id}`"
);
}
}
#[cfg(feature = "environment-capabilities")]
#[test]
fn hosted_registry_composes_product_environment_capabilities() {
let registry = hosted_capability_registry_for_grade(everruns_core::DeploymentGrade::Prod);
for capability_id in [
"session_file_system",
"bashkit_shell",
"web_fetch",
"model_scout",
"openrouter_workspace",
"openrouter_server_tools",
] {
assert!(
registry.has(capability_id),
"hosted product registry is missing `{capability_id}`"
);
}
assert_eq!(registry.canonical_id("virtual_bash"), Some("bashkit_shell"));
}
#[cfg(not(feature = "environment-capabilities"))]
#[test]
fn platform_default_does_not_link_environment_capabilities() {
let registry = hosted_capability_registry_for_grade(everruns_core::DeploymentGrade::Prod);
for capability_id in [
"session_file_system",
"bashkit_shell",
"web_fetch",
"model_scout",
"openrouter_workspace",
] {
assert!(!registry.has(capability_id));
}
}
}