TurboMCP v1.0.5: Enterprise-Grade MCP with Elicitation & Sampling

use turbomcp::prelude::*;
use turbomcp::elicitation_api::{elicit, text, checkbox, integer_field};

#[tool("Configure deployment")]
async fn deploy(&self, ctx: Context, project: String) -> McpResult<String> {
    // Simple elicit macro for quick prompts
    let confirmation = elicit!(ctx, "Deploy to production?")?;
    
    // Advanced form with beautiful ergonomic builders
    let config = elicit("Configure deployment")
        .field("environment", text("Environment")
            .options(&["dev", "staging", "production"]))
        .field("auto_scale", checkbox("Enable Auto-scaling")
            .default(true))
        .field("replicas", integer_field("Replica Count")
            .range(1.0, 10.0))
        .require(vec!["environment"])
        .send(&ctx.request)
        .await?;
    
    match config {
        ElicitationResult::Accept(data) => {
            let env = data.get::<String>("environment")?;
            let replicas = data.get::<i64>("replicas").unwrap_or(1);
            Ok(format!("Deployed {} to {} with {} replicas", 
                project, env, replicas))
        }
        _ => Err(mcp_error!("Deployment cancelled"))
    }
}

use turbomcp::prelude::*;

#[tool("Get AI code review")]
async fn code_review(&self, ctx: Context, code: String) -> McpResult<String> {
    // Build sampling request with ergonomic JSON
    let request = serde_json::json!({
        "messages": [{
            "role": "user",
            "content": {
                "type": "text",
                "text": format!("Please review this code:\n\n{}", code)
            }
        }],
        "maxTokens": 500,
        "systemPrompt": "You are a senior code reviewer."
    });
    
    // Request LLM assistance through the client
    match ctx.create_message(request).await {
        Ok(response) => {
            ctx.info("AI review completed successfully").await?;
            Ok(format!("AI Review: {:?}", response))
        }
        Err(_) => {
            // Graceful fallback if sampling unavailable
            let issues = code.matches("TODO").count();
            Ok(format!("Static analysis: {} issues found", issues))
        }
    }
}

use turbomcp_transport::{AxumMcpExt, McpServerConfig};
use axum::Router;

// Production security configuration  
let config = McpServerConfig::production()
    .with_cors_origins(vec!["https://app.example.com"])
    .with_custom_csp("default-src 'self'; connect-src 'self' wss:")
    .with_rate_limit(120, 20)  // 120 requests/minute, 20 burst
    .with_jwt_auth("your-secret-key");

let app = Router::new()
    .route("/api/status", get(status_handler))
    .merge(Router::<()>::turbo_mcp_routes_for_merge(
        mcp_service, 
        config
    ));

#[server(
    name = "filesystem-server",
    version = "1.0.0",
    root = "file:///workspace:Project Workspace",
    root = "file:///tmp:Temporary Files",
    root = "file:///Users/shared:Shared Documents"
)]
impl FileSystemServer {
    #[tool("List files in directory")]
    async fn list_files(&self, ctx: Context, path: String) 
        -> McpResult<Vec<String>> {
        // File operations are bounded by configured roots
        ctx.info(&format!("Listing files in: {}", path)).await?;
        Ok(list_directory(&path)?)
    }
}