remote_mcp_kernel/microkernel/
factory.rs1use crate::handlers::{McpServer, SseHandler, SseHandlerConfig, StreamableHttpHandler};
7use oauth_provider_rs::storage::create_dynamodb_storage;
8use oauth_provider_rs::{
9 CognitoOAuthProvider, DefaultClientManager, GitHubOAuthProvider, OAuthProvider,
10 OAuthProviderTrait, OAuthStorage, storage::DynamoDBStorage,
11};
12
13use super::{
14 core::MicrokernelServer,
15 types::{CognitoMicrokernelServer, CognitoMicrokernelServerDynamoDB, GitHubMicrokernelServer},
16};
17
18pub fn create_full_microkernel<
20 P: OAuthProviderTrait<S, DefaultClientManager<S>> + 'static,
21 S: OAuthStorage + Clone + 'static,
22>(
23 oauth_provider: OAuthProvider<P, S>,
24) -> MicrokernelServer<P, S> {
25 let mcp_server = McpServer::new();
26 let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
27 let sse_handler = SseHandler::new(mcp_server.clone());
28 let sse_config = SseHandlerConfig::default();
29
30 MicrokernelServer::new()
31 .with_oauth_provider(oauth_provider)
32 .with_streamable_handler(streamable_handler)
33 .with_sse_handler(sse_handler, sse_config)
34}
35
36pub fn create_full_github_microkernel(
38 oauth_provider: GitHubOAuthProvider,
39) -> GitHubMicrokernelServer {
40 let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
41 let mcp_server = McpServer::new();
42 let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
43 let sse_handler = SseHandler::new(mcp_server.clone());
44 let sse_config = SseHandlerConfig::default();
45
46 MicrokernelServer::new()
47 .with_oauth_provider(wrapped_oauth_provider)
48 .with_streamable_handler(streamable_handler)
49 .with_sse_handler(sse_handler, sse_config)
50}
51
52pub fn create_full_cognito_microkernel(
54 oauth_provider: CognitoOAuthProvider,
55) -> CognitoMicrokernelServer {
56 let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
57 let mcp_server = McpServer::new();
58 let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
59 let sse_handler = SseHandler::new(mcp_server.clone());
60 let sse_config = SseHandlerConfig::default();
61
62 MicrokernelServer::new()
63 .with_oauth_provider(wrapped_oauth_provider)
64 .with_streamable_handler(streamable_handler)
65 .with_sse_handler(sse_handler, sse_config)
66}
67
68pub fn create_github_oauth_only_microkernel(
70 oauth_provider: GitHubOAuthProvider,
71) -> GitHubMicrokernelServer {
72 let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
73 MicrokernelServer::new().with_oauth_provider(wrapped_oauth_provider)
74}
75
76pub fn create_cognito_oauth_only_microkernel(
78 oauth_provider: CognitoOAuthProvider,
79) -> CognitoMicrokernelServer {
80 let wrapped_oauth_provider = OAuthProvider::new(oauth_provider);
81 MicrokernelServer::new().with_oauth_provider(wrapped_oauth_provider)
82}
83
84pub async fn create_full_cognito_microkernel_dynamodb(
86 cognito_config: oauth_provider_rs::CognitoOAuthConfig,
87 cognito_domain: String,
88 region: String,
89 user_pool_id: String,
90 table_name: String,
91 create_table: bool,
92) -> Result<CognitoMicrokernelServerDynamoDB<DynamoDBStorage>, Box<dyn std::error::Error>> {
93 let (storage, client_manager) =
95 create_dynamodb_storage(table_name, create_table, Some("expires_at".to_string())).await?;
96
97 let oauth_handler = oauth_provider_rs::CognitoOAuthHandler::new_simple(
99 storage,
100 client_manager,
101 cognito_config,
102 cognito_domain,
103 region,
104 user_pool_id,
105 );
106
107 let oauth_provider = OAuthProvider::new(oauth_handler);
108
109 let mcp_server = McpServer::new();
111 let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
112 let sse_handler = SseHandler::new(mcp_server.clone());
113 let sse_config = SseHandlerConfig::default();
114
115 let microkernel = MicrokernelServer::new()
117 .with_oauth_provider(oauth_provider)
118 .with_streamable_handler(streamable_handler)
119 .with_sse_handler(sse_handler, sse_config);
120
121 Ok(microkernel)
122}
123
124pub fn create_oauth_only_microkernel<
126 P: OAuthProviderTrait<S, DefaultClientManager<S>> + 'static,
127 S: OAuthStorage + Clone + 'static,
128>(
129 oauth_provider: OAuthProvider<P, S>,
130) -> MicrokernelServer<P, S> {
131 MicrokernelServer::new().with_oauth_provider(oauth_provider)
132}
133
134pub fn create_unauthenticated_microkernel<
136 P: OAuthProviderTrait<S, DefaultClientManager<S>> + 'static,
137 S: OAuthStorage + Clone + 'static,
138>(
139 oauth_provider: OAuthProvider<P, S>,
140) -> MicrokernelServer<P, S> {
141 let mcp_server = McpServer::new();
142 let streamable_handler = StreamableHttpHandler::new(mcp_server.clone());
143 let sse_handler = SseHandler::new(mcp_server.clone());
144 let sse_config = SseHandlerConfig {
145 require_auth: false,
146 ..Default::default()
147 };
148
149 MicrokernelServer::new()
150 .with_oauth_provider(oauth_provider)
151 .with_streamable_handler(streamable_handler)
152 .with_sse_handler(sse_handler, sse_config)
153}