Development Guide

// src/tools/my_new_tool.rs
use crate::client::LoxoneClient;
use rmcp::tools::{Tool, ToolBuilder, ToolError};
use serde_json::{json, Value};

pub fn create_my_tool() -> Tool {
    ToolBuilder::new("my_tool_name")
        .description("Description of what this tool does")
        .param("param1", "string", "Description of param1")
        .param("param2", "number", "Optional param2")
        .optional()
        .handler(|context, params| Box::pin(async move {
            let param1 = params["param1"].as_str()
                .ok_or_else(|| ToolError::InvalidParams("param1 required".into()))?;
            
            // Implementation here
            let client = context.get::<LoxoneClient>()?;
            let result = client.some_operation(param1).await?;
            
            Ok(json!({
                "success": true,
                "result": result
            }))
        }))
        .build()
}

pub fn register_all_tools(server: &mut McpServer) {
    // ... existing tools ...
    server.add_tool(my_new_tool::create_my_tool());
}

#[tokio::test]
async fn test_my_new_tool() {
    let server = create_test_server().await;
    let result = server.call_tool("my_tool_name", json!({
        "param1": "test_value"
    })).await;
    
    assert!(result.is_ok());
    assert_eq!(result["success"], true);
}

pub fn create_my_resource() -> Resource {
    ResourceBuilder::new("loxone://my-resource/{id}")
        .description("My resource description")
        .mime_type("application/json")
        .handler(|context, uri| Box::pin(async move {
            let id = extract_id_from_uri(&uri)?;
            let client = context.get::<LoxoneClient>()?;
            
            let data = client.get_my_data(id).await?;
            
            Ok(ResourceContent {
                uri: uri.clone(),
                mime_type: "application/json".into(),
                text: Some(serde_json::to_string(&data)?),
                ..Default::default()
            })
        }))
        .build()
}

// Use the custom error type
use crate::error::{LoxoneError, Result};

// Return errors appropriately
pub async fn some_function() -> Result<String> {
    let data = fetch_data().await
        .map_err(|e| LoxoneError::connection(format!("Failed to fetch: {}", e)))?;
    
    Ok(data)
}

// Use error context
let result = operation()
    .context("Failed to perform operation")?;

// Use tokio for async runtime
#[tokio::main]
async fn main() -> Result<()> {
    // ...
}

// Prefer concurrent operations
let (result1, result2) = tokio::join!(
    async_operation1(),
    async_operation2()
);

// Use timeouts for external calls
let result = tokio::time::timeout(
    Duration::from_secs(30),
    client.request()
).await??;