systemprompt_runtime/builder/
mod.rs1mod assembly;
12mod core_layer;
13
14use std::sync::{Arc, OnceLock};
15
16use systemprompt_database::MigrationConfig;
17use systemprompt_extension::ExtensionRegistry;
18use systemprompt_marketplace::MarketplaceFilter;
19use systemprompt_mcp::services::registry::RegistryService;
20use systemprompt_security::authz::{AuthzDecisionHook, SharedAuthzHook};
21use systemprompt_users::UserService;
22
23use crate::context::{AppContext, ConfigPlane, DataPlane, Plugins, Subsystems};
24use crate::error::RuntimeResult;
25use crate::registry::ModuleApiRegistry;
26use core_layer::{CoreLayer, init_core, init_extensions};
27
28#[derive(Default)]
37pub struct AppContextBuilder {
38 extension_registry: Option<ExtensionRegistry>,
39 show_startup_warnings: bool,
40 marketplace_filter: Option<Arc<dyn MarketplaceFilter>>,
41 authz_hook: Option<SharedAuthzHook>,
42 install_schemas: bool,
43 migration_config: MigrationConfig,
44}
45
46impl std::fmt::Debug for AppContextBuilder {
47 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
48 f.debug_struct("AppContextBuilder")
49 .field("extension_registry", &self.extension_registry.is_some())
50 .field("show_startup_warnings", &self.show_startup_warnings)
51 .field("marketplace_filter", &self.marketplace_filter.is_some())
52 .field("authz_hook", &self.authz_hook.is_some())
53 .field("install_schemas", &self.install_schemas)
54 .field("migration_config", &self.migration_config)
55 .finish()
56 }
57}
58
59impl AppContextBuilder {
60 #[must_use]
61 pub fn new() -> Self {
62 Self::default()
63 }
64
65 #[must_use]
68 pub fn with_extensions(mut self, registry: ExtensionRegistry) -> Self {
69 self.extension_registry = Some(registry);
70 self
71 }
72
73 #[must_use]
74 pub const fn with_startup_warnings(mut self, show: bool) -> Self {
75 self.show_startup_warnings = show;
76 self
77 }
78
79 #[must_use]
83 pub fn with_marketplace_filter(mut self, filter: Arc<dyn MarketplaceFilter>) -> Self {
84 self.marketplace_filter = Some(filter);
85 self
86 }
87
88 #[must_use]
92 pub const fn with_migrations(mut self, install: bool) -> Self {
93 self.install_schemas = install;
94 self
95 }
96
97 #[must_use]
101 pub fn with_authz_hook<H>(mut self, hook: H) -> Self
102 where
103 H: AuthzDecisionHook + 'static,
104 {
105 self.authz_hook = Some(Arc::new(hook));
106 self
107 }
108
109 #[must_use]
110 pub fn with_shared_authz_hook(mut self, hook: SharedAuthzHook) -> Self {
111 self.authz_hook = Some(hook);
112 self
113 }
114
115 #[must_use]
116 pub const fn with_migration_config(mut self, config: MigrationConfig) -> Self {
117 self.migration_config = config;
118 self
119 }
120
121 pub async fn build(self) -> RuntimeResult<AppContext> {
122 let CoreLayer {
123 config,
124 app_paths,
125 database,
126 authz_hook,
127 } = init_core(self.authz_hook).await?;
128
129 let api_registry = Arc::new(ModuleApiRegistry::new());
130 let extension_registry = init_extensions(
131 self.extension_registry,
132 self.install_schemas,
133 self.migration_config,
134 &database,
135 )
136 .await?;
137
138 let assembly::ContentAnalytics {
139 geoip_reader,
140 content_config,
141 route_classifier,
142 analytics_service,
143 analytics_repositories,
144 fingerprint_repo,
145 } = assembly::assemble_content_analytics(
146 &config,
147 &app_paths,
148 &database,
149 self.show_startup_warnings,
150 )?;
151
152 let repositories = build_repositories(&database, analytics_repositories)?;
153
154 let user_service = Arc::new(UserService::new(Arc::clone(&repositories.users)));
155
156 let system_admin =
157 assembly::resolve_and_install_system_admin(&config, &user_service).await?;
158 let mcp_registry = RegistryService::new(system_admin.id().clone());
159
160 ensure_legacy_context(&repositories, &system_admin).await?;
161
162 let marketplace_filter = self
163 .marketplace_filter
164 .unwrap_or_else(|| assembly::build_marketplace_filter(&database));
165
166 let event_bridge = Arc::new(OnceLock::new());
167
168 Ok(AppContext::from_parts(
169 DataPlane {
170 database,
171 analytics_service,
172 fingerprint_repo,
173 user_service: Some(user_service),
174 a2a_repositories: repositories.a2a,
175 content_repositories: repositories.content,
176 oauth_repositories: repositories.oauth,
177 user_repository: repositories.users,
178 service_repository: repositories.services,
179 ai_repositories: repositories.ai,
180 analytics_repositories: repositories.analytics,
181 file_repository: repositories.files,
182 mcp_session_repository: repositories.mcp_sessions,
183 },
184 ConfigPlane {
185 config,
186 app_paths,
187 content_config,
188 route_classifier,
189 },
190 Plugins {
191 extension_registry,
192 api_registry,
193 mcp_registry,
194 marketplace_filter,
195 },
196 Subsystems {
197 system_admin,
198 authz_hook,
199 event_bridge,
200 geoip_reader,
201 },
202 ))
203 }
204}
205
206async fn ensure_legacy_context(
207 repositories: &RepositoryBundles,
208 system_admin: &systemprompt_models::services::SystemAdmin,
209) -> RuntimeResult<()> {
210 repositories
211 .a2a
212 .contexts
213 .ensure_context(
214 &systemprompt_traits::EnsureContextParams {
215 context_id: &systemprompt_identifiers::ContextId::legacy(),
216 user_id: system_admin.id(),
217 session_id: None,
218 name: "Legacy (pre-context)",
219 kind: systemprompt_models::ContextKind::Legacy.as_str(),
220 },
221 systemprompt_models::ContextKind::Legacy,
222 )
223 .await
224 .map_err(|e| crate::error::RuntimeError::Internal(e.to_string()))
225}
226
227struct RepositoryBundles {
228 a2a: Arc<systemprompt_agent::repository::A2ARepositories>,
229 content: Arc<systemprompt_content::repository::ContentRepositories>,
230 oauth: Arc<systemprompt_oauth::repository::OAuthRepositories>,
231 users: Arc<systemprompt_users::UserRepository>,
232 services: Arc<systemprompt_database::ServiceRepository>,
233 ai: Arc<systemprompt_ai::repository::AiRepositories>,
234 analytics: Arc<systemprompt_analytics::repository::AnalyticsRepositories>,
235 files: Arc<systemprompt_files::FileRepository>,
236 mcp_sessions: Arc<systemprompt_mcp::repository::McpSessionRepository>,
237}
238
239fn build_repositories(
240 database: &systemprompt_database::DbPool,
241 analytics: Arc<systemprompt_analytics::repository::AnalyticsRepositories>,
242) -> RuntimeResult<RepositoryBundles> {
243 let session_usage: systemprompt_traits::DynSessionUsageCounters =
244 Arc::new(analytics.sessions.clone());
245 Ok(RepositoryBundles {
246 a2a: Arc::new(systemprompt_agent::repository::A2ARepositories::new(
247 database,
248 session_usage,
249 )?),
250 content: Arc::new(systemprompt_content::repository::ContentRepositories::new(
251 database,
252 )?),
253 oauth: Arc::new(systemprompt_oauth::repository::OAuthRepositories::new(
254 database,
255 )?),
256 users: Arc::new(systemprompt_users::UserRepository::new(database)?),
257 services: Arc::new(systemprompt_database::ServiceRepository::new(database)?),
258 ai: Arc::new(systemprompt_ai::repository::AiRepositories::new(database)?),
259 analytics,
260 files: Arc::new(systemprompt_files::FileRepository::new(database)?),
261 mcp_sessions: Arc::new(systemprompt_mcp::repository::McpSessionRepository::new(
262 database,
263 )?),
264 })
265}