kreuzberg 4.0.8 → 4.1.0

data/vendor/kreuzberg/src/mcp/server.rs

@@ -1,179 +1,19 @@
-//! MCP server implementation for Kreuzberg.
+//! Kreuzberg MCP server implementation.
 //!
-//! This module provides the core MCP server that exposes document extraction
-//! as tools for AI assistants via the Model Context Protocol.
+//! This module provides the main MCP server struct and startup functions.
 
-use base64::prelude::*;
+use crate::ExtractionConfig;
 use rmcp::{
-    ErrorData as McpError, ServerHandler, ServiceExt,
+    ServerHandler, ServiceExt,
     handler::server::{router::tool::ToolRouter, wrapper::Parameters},
     model::*,
-    schemars, tool, tool_handler, tool_router,
+    tool, tool_handler, tool_router,
     transport::stdio,
 };
 
 #[cfg(feature = "mcp-http")]
 use rmcp::transport::streamable_http_server::{StreamableHttpService, session::local::LocalSessionManager};
 
-use crate::{
-    ExtractionConfig, ExtractionResult as KreuzbergResult, KreuzbergError, batch_extract_file, batch_extract_file_sync,
-    cache, detect_mime_type, extract_bytes, extract_bytes_sync, extract_file, extract_file_sync,
-};
-
-/// Request parameters for file extraction.
-#[derive(Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
-pub struct ExtractFileParams {
-    /// Path to the file to extract
-    pub path: String,
-    /// Optional MIME type hint (auto-detected if not provided)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mime_type: Option<String>,
-    /// Enable OCR for scanned documents
-    #[serde(default)]
-    pub enable_ocr: bool,
-    /// Force OCR even if text extraction succeeds
-    #[serde(default)]
-    pub force_ocr: bool,
-    /// Use async extraction (default: false for sync)
-    #[serde(default)]
-    pub r#async: bool,
-}
-
-/// Request parameters for bytes extraction.
-#[derive(Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
-pub struct ExtractBytesParams {
-    /// Base64-encoded file content
-    pub data: String,
-    /// Optional MIME type hint (auto-detected if not provided)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mime_type: Option<String>,
-    /// Enable OCR for scanned documents
-    #[serde(default)]
-    pub enable_ocr: bool,
-    /// Force OCR even if text extraction succeeds
-    #[serde(default)]
-    pub force_ocr: bool,
-    /// Use async extraction (default: false for sync)
-    #[serde(default)]
-    pub r#async: bool,
-}
-
-/// Request parameters for batch file extraction.
-#[derive(Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
-pub struct BatchExtractFilesParams {
-    /// Paths to files to extract
-    pub paths: Vec<String>,
-    /// Enable OCR for scanned documents
-    #[serde(default)]
-    pub enable_ocr: bool,
-    /// Force OCR even if text extraction succeeds
-    #[serde(default)]
-    pub force_ocr: bool,
-    /// Use async extraction (default: false for sync)
-    #[serde(default)]
-    pub r#async: bool,
-}
-
-/// Request parameters for MIME type detection.
-#[derive(Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
-pub struct DetectMimeTypeParams {
-    /// Path to the file
-    pub path: String,
-    /// Use content-based detection (default: true)
-    #[serde(default = "default_use_content")]
-    pub use_content: bool,
-}
-
-fn default_use_content() -> bool {
-    true
-}
-
-/// Map Kreuzberg errors to MCP error responses with appropriate error codes.
-///
-/// This function ensures different error types are properly differentiated in MCP responses:
-/// - `Validation` errors → `INVALID_PARAMS` (-32602)
-/// - `UnsupportedFormat` errors → `INVALID_PARAMS` (-32602)
-/// - `Parsing` errors → `PARSE_ERROR` (-32700)
-/// - `Io` errors → `INTERNAL_ERROR` (-32603) with context preserved
-/// - All other errors → `INTERNAL_ERROR` (-32603)
-///
-/// The error message and source chain are preserved to aid debugging.
-#[doc(hidden)]
-pub fn map_kreuzberg_error_to_mcp(error: KreuzbergError) -> McpError {
-    match error {
-        KreuzbergError::Validation { message, source } => {
-            let mut error_message = format!("Validation error: {}", message);
-            if let Some(src) = source {
-                error_message.push_str(&format!(" (caused by: {})", src));
-            }
-            McpError::invalid_params(error_message, None)
-        }
-
-        KreuzbergError::UnsupportedFormat(mime_type) => {
-            McpError::invalid_params(format!("Unsupported format: {}", mime_type), None)
-        }
-
-        KreuzbergError::MissingDependency(dep) => McpError::invalid_params(
-            format!(
-                "Missing required dependency: {}. Please install it to use this feature.",
-                dep
-            ),
-            None,
-        ),
-
-        KreuzbergError::Parsing { message, source } => {
-            let mut error_message = format!("Parsing error: {}", message);
-            if let Some(src) = source {
-                error_message.push_str(&format!(" (caused by: {})", src));
-            }
-            McpError::parse_error(error_message, None)
-        }
-
-        // OSError/RuntimeError must bubble up - system errors need user reports ~keep
-        KreuzbergError::Io(io_err) => McpError::internal_error(format!("System I/O error: {}", io_err), None),
-
-        KreuzbergError::Ocr { message, source } => {
-            let mut error_message = format!("OCR processing error: {}", message);
-            if let Some(src) = source {
-                error_message.push_str(&format!(" (caused by: {})", src));
-            }
-            McpError::internal_error(error_message, None)
-        }
-
-        KreuzbergError::Cache { message, source } => {
-            let mut error_message = format!("Cache error: {}", message);
-            if let Some(src) = source {
-                error_message.push_str(&format!(" (caused by: {})", src));
-            }
-            McpError::internal_error(error_message, None)
-        }
-
-        KreuzbergError::ImageProcessing { message, source } => {
-            let mut error_message = format!("Image processing error: {}", message);
-            if let Some(src) = source {
-                error_message.push_str(&format!(" (caused by: {})", src));
-            }
-            McpError::internal_error(error_message, None)
-        }
-
-        KreuzbergError::Serialization { message, source } => {
-            let mut error_message = format!("Serialization error: {}", message);
-            if let Some(src) = source {
-                error_message.push_str(&format!(" (caused by: {})", src));
-            }
-            McpError::internal_error(error_message, None)
-        }
-
-        KreuzbergError::Plugin { message, plugin_name } => {
-            McpError::internal_error(format!("Plugin '{}' error: {}", plugin_name, message), None)
-        }
-
-        KreuzbergError::LockPoisoned(msg) => McpError::internal_error(format!("Internal lock poisoned: {}", msg), None),
-
-        KreuzbergError::Other(msg) => McpError::internal_error(msg, None),
-    }
-}
-
 /// Kreuzberg MCP server.
 ///
 /// Provides document extraction capabilities via MCP tools.
@@ -234,8 +74,12 @@ impl KreuzbergMcp {
     )]
     async fn extract_file(
         &self,
-        Parameters(params): Parameters<ExtractFileParams>,
-    ) -> Result<CallToolResult, McpError> {
+        Parameters(params): Parameters<super::params::ExtractFileParams>,
+    ) -> Result<CallToolResult, rmcp::ErrorData> {
+        use super::errors::map_kreuzberg_error_to_mcp;
+        use super::format::{build_config, format_extraction_result};
+        use crate::{extract_file, extract_file_sync};
+
         let config = build_config(&self.default_config, params.enable_ocr, params.force_ocr);
 
         let result = if params.r#async {
@@ -259,11 +103,16 @@ impl KreuzbergMcp {
     )]
     async fn extract_bytes(
         &self,
-        Parameters(params): Parameters<ExtractBytesParams>,
-    ) -> Result<CallToolResult, McpError> {
+        Parameters(params): Parameters<super::params::ExtractBytesParams>,
+    ) -> Result<CallToolResult, rmcp::ErrorData> {
+        use super::errors::map_kreuzberg_error_to_mcp;
+        use super::format::{build_config, format_extraction_result};
+        use crate::{extract_bytes, extract_bytes_sync};
+        use base64::prelude::*;
+
         let bytes = BASE64_STANDARD
             .decode(&params.data)
-            .map_err(|e| McpError::invalid_params(format!("Invalid base64: {}", e), None))?;
+            .map_err(|e| rmcp::ErrorData::invalid_params(format!("Invalid base64: {}", e), None))?;
 
         let config = build_config(&self.default_config, params.enable_ocr, params.force_ocr);
 
@@ -290,8 +139,12 @@ impl KreuzbergMcp {
     )]
     async fn batch_extract_files(
         &self,
-        Parameters(params): Parameters<BatchExtractFilesParams>,
-    ) -> Result<CallToolResult, McpError> {
+        Parameters(params): Parameters<super::params::BatchExtractFilesParams>,
+    ) -> Result<CallToolResult, rmcp::ErrorData> {
+        use super::errors::map_kreuzberg_error_to_mcp;
+        use super::format::{build_config, format_extraction_result};
+        use crate::{batch_extract_file, batch_extract_file_sync};
+
         let config = build_config(&self.default_config, params.enable_ocr, params.force_ocr);
 
         let results = if params.r#async {
@@ -321,8 +174,11 @@ impl KreuzbergMcp {
     )]
     fn detect_mime_type(
         &self,
-        Parameters(params): Parameters<DetectMimeTypeParams>,
-    ) -> Result<CallToolResult, McpError> {
+        Parameters(params): Parameters<super::params::DetectMimeTypeParams>,
+    ) -> Result<CallToolResult, rmcp::ErrorData> {
+        use super::errors::map_kreuzberg_error_to_mcp;
+        use crate::detect_mime_type;
+
         let mime_type = detect_mime_type(&params.path, params.use_content).map_err(map_kreuzberg_error_to_mcp)?;
 
         Ok(CallToolResult::success(vec![Content::text(mime_type)]))
@@ -335,7 +191,10 @@ impl KreuzbergMcp {
         description = "Get cache statistics including total files, size, and available disk space.",
         annotations(title = "Cache Stats", read_only_hint = true, idempotent_hint = true)
     )]
-    fn cache_stats(&self, Parameters(_): Parameters<()>) -> Result<CallToolResult, McpError> {
+    fn cache_stats(&self, Parameters(_): Parameters<()>) -> Result<CallToolResult, rmcp::ErrorData> {
+        use super::errors::map_kreuzberg_error_to_mcp;
+        use crate::cache;
+
         let cache_dir = std::env::current_dir()
             .unwrap_or_else(|_| std::path::PathBuf::from("."))
             .join(".kreuzberg");
@@ -369,7 +228,10 @@ impl KreuzbergMcp {
         description = "Clear all cached files. Returns the number of files removed and space freed in MB.",
         annotations(title = "Clear Cache", destructive_hint = true)
     )]
-    fn cache_clear(&self, Parameters(_): Parameters<()>) -> Result<CallToolResult, McpError> {
+    fn cache_clear(&self, Parameters(_): Parameters<()>) -> Result<CallToolResult, rmcp::ErrorData> {
+        use super::errors::map_kreuzberg_error_to_mcp;
+        use crate::cache;
+
         let cache_dir = std::env::current_dir()
             .unwrap_or_else(|_| std::path::PathBuf::from("."))
             .join(".kreuzberg");
@@ -573,70 +435,9 @@ pub async fn start_mcp_server_http_with_config(
     Ok(())
 }
 
-/// Build extraction config from MCP parameters.
-///
-/// Starts with the default config and overlays OCR settings from request parameters.
-fn build_config(default_config: &ExtractionConfig, enable_ocr: bool, force_ocr: bool) -> ExtractionConfig {
-    let mut config = default_config.clone();
-
-    config.ocr = if enable_ocr {
-        Some(crate::OcrConfig {
-            backend: "tesseract".to_string(),
-            language: "eng".to_string(),
-            tesseract_config: None,
-        })
-    } else {
-        None
-    };
-    config.force_ocr = force_ocr;
-
-    config
-}
-
-/// Format extraction result as human-readable text.
-fn format_extraction_result(result: &KreuzbergResult) -> String {
-    let mut response = String::new();
-
-    response.push_str(&format!("Content ({} characters):\n", result.content.len()));
-    response.push_str(&result.content);
-    response.push_str("\n\n");
-
-    response.push_str("Metadata:\n");
-    response.push_str(&serde_json::to_string_pretty(&result.metadata).unwrap_or_default());
-    response.push_str("\n\n");
-
-    if !result.tables.is_empty() {
-        response.push_str(&format!("Tables ({}):\n", result.tables.len()));
-        for (i, table) in result.tables.iter().enumerate() {
-            response.push_str(&format!("\nTable {} (page {}):\n", i + 1, table.page_number));
-            response.push_str(&table.markdown);
-            response.push('\n');
-        }
-    }
-
-    response
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::path::PathBuf;
-
-    /// Get the path to a test document relative to workspace root.
-    fn get_test_path(relative_path: &str) -> String {
-        let workspace_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .parent()
-            .unwrap()
-            .parent()
-            .unwrap()
-            .to_path_buf();
-
-        workspace_root
-            .join("test_documents")
-            .join(relative_path)
-            .to_string_lossy()
-            .to_string()
-    }
 
     #[tokio::test]
     async fn test_tool_router_has_routes() {
@@ -662,23 +463,6 @@ mod tests {
         assert!(info.capabilities.tools.is_some());
     }
 
-    #[test]
-    fn test_build_config() {
-        let default_config = ExtractionConfig::default();
-
-        let config = build_config(&default_config, false, false);
-        assert!(config.ocr.is_none());
-        assert!(!config.force_ocr);
-
-        let config = build_config(&default_config, true, false);
-        assert!(config.ocr.is_some());
-        assert!(!config.force_ocr);
-
-        let config = build_config(&default_config, true, true);
-        assert!(config.ocr.is_some());
-        assert!(config.force_ocr);
-    }
-
     #[test]
     fn test_with_config_stores_provided_config() {
         let custom_config = ExtractionConfig {
@@ -693,699 +477,6 @@ mod tests {
         assert!(!server.default_config.use_cache);
     }
 
-    #[test]
-    fn test_map_validation_error_to_invalid_params() {
-        let error = KreuzbergError::validation("invalid file path");
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32602);
-        assert!(mcp_error.message.contains("Validation error"));
-        assert!(mcp_error.message.contains("invalid file path"));
-    }
-
-    #[test]
-    fn test_map_validation_error_with_source_preserves_chain() {
-        let source = std::io::Error::new(std::io::ErrorKind::InvalidInput, "bad param");
-        let error = KreuzbergError::validation_with_source("invalid configuration", source);
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32602);
-        assert!(mcp_error.message.contains("Validation error"));
-        assert!(mcp_error.message.contains("invalid configuration"));
-        assert!(mcp_error.message.contains("caused by"));
-    }
-
-    #[test]
-    fn test_map_unsupported_format_to_invalid_params() {
-        let error = KreuzbergError::UnsupportedFormat("application/unknown".to_string());
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32602);
-        assert!(mcp_error.message.contains("Unsupported format"));
-        assert!(mcp_error.message.contains("application/unknown"));
-    }
-
-    #[test]
-    fn test_map_missing_dependency_to_invalid_params() {
-        let error = KreuzbergError::MissingDependency("tesseract".to_string());
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32602);
-        assert!(mcp_error.message.contains("Missing required dependency"));
-        assert!(mcp_error.message.contains("tesseract"));
-        assert!(mcp_error.message.contains("Please install"));
-    }
-
-    #[test]
-    fn test_map_parsing_error_to_parse_error() {
-        let error = KreuzbergError::parsing("corrupt PDF file");
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32700);
-        assert!(mcp_error.message.contains("Parsing error"));
-        assert!(mcp_error.message.contains("corrupt PDF file"));
-    }
-
-    #[test]
-    fn test_map_parsing_error_with_source_preserves_chain() {
-        let source = std::io::Error::new(std::io::ErrorKind::InvalidData, "malformed data");
-        let error = KreuzbergError::parsing_with_source("failed to parse document", source);
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32700);
-        assert!(mcp_error.message.contains("Parsing error"));
-        assert!(mcp_error.message.contains("failed to parse document"));
-        assert!(mcp_error.message.contains("caused by"));
-    }
-
-    #[test]
-    fn test_map_io_error_to_internal_error() {
-        let io_error = std::io::Error::new(std::io::ErrorKind::NotFound, "file not found");
-        let error = KreuzbergError::Io(io_error);
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32603);
-        assert!(mcp_error.message.contains("System I/O error"));
-        assert!(mcp_error.message.contains("file not found"));
-    }
-
-    #[test]
-    fn test_map_ocr_error_to_internal_error() {
-        let error = KreuzbergError::ocr("tesseract failed");
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32603);
-        assert!(mcp_error.message.contains("OCR processing error"));
-        assert!(mcp_error.message.contains("tesseract failed"));
-    }
-
-    #[test]
-    fn test_map_cache_error_to_internal_error() {
-        let error = KreuzbergError::cache("cache write failed");
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32603);
-        assert!(mcp_error.message.contains("Cache error"));
-        assert!(mcp_error.message.contains("cache write failed"));
-    }
-
-    #[test]
-    fn test_map_image_processing_error_to_internal_error() {
-        let error = KreuzbergError::image_processing("resize failed");
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32603);
-        assert!(mcp_error.message.contains("Image processing error"));
-        assert!(mcp_error.message.contains("resize failed"));
-    }
-
-    #[test]
-    fn test_map_serialization_error_to_internal_error() {
-        let error = KreuzbergError::serialization("JSON encode failed");
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32603);
-        assert!(mcp_error.message.contains("Serialization error"));
-        assert!(mcp_error.message.contains("JSON encode failed"));
-    }
-
-    #[test]
-    fn test_map_plugin_error_to_internal_error() {
-        let error = KreuzbergError::Plugin {
-            message: "extraction failed".to_string(),
-            plugin_name: "pdf-extractor".to_string(),
-        };
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32603);
-        assert!(mcp_error.message.contains("Plugin 'pdf-extractor' error"));
-        assert!(mcp_error.message.contains("extraction failed"));
-    }
-
-    #[test]
-    fn test_map_lock_poisoned_error_to_internal_error() {
-        let error = KreuzbergError::LockPoisoned("registry lock poisoned".to_string());
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32603);
-        assert!(mcp_error.message.contains("Internal lock poisoned"));
-        assert!(mcp_error.message.contains("registry lock poisoned"));
-    }
-
-    #[test]
-    fn test_map_other_error_to_internal_error() {
-        let error = KreuzbergError::Other("unexpected error".to_string());
-        let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-        assert_eq!(mcp_error.code.0, -32603);
-        assert!(mcp_error.message.contains("unexpected error"));
-    }
-
-    #[test]
-    fn test_error_type_differentiation() {
-        let validation = KreuzbergError::validation("test");
-        let parsing = KreuzbergError::parsing("test");
-        let io = KreuzbergError::Io(std::io::Error::other("test"));
-
-        let val_mcp = map_kreuzberg_error_to_mcp(validation);
-        let parse_mcp = map_kreuzberg_error_to_mcp(parsing);
-        let io_mcp = map_kreuzberg_error_to_mcp(io);
-
-        assert_eq!(val_mcp.code.0, -32602);
-        assert_eq!(parse_mcp.code.0, -32700);
-        assert_eq!(io_mcp.code.0, -32603);
-
-        assert_ne!(val_mcp.code.0, parse_mcp.code.0);
-        assert_ne!(val_mcp.code.0, io_mcp.code.0);
-        assert_ne!(parse_mcp.code.0, io_mcp.code.0);
-    }
-
-    #[test]
-    fn test_format_extraction_result_with_content() {
-        let result = KreuzbergResult {
-            content: "Sample extracted text".to_string(),
-            mime_type: "text/plain".to_string(),
-            metadata: crate::Metadata::default(),
-            tables: vec![],
-            detected_languages: None,
-            chunks: None,
-            images: None,
-            pages: None,
-        };
-
-        let formatted = format_extraction_result(&result);
-
-        assert!(formatted.contains("Content (21 characters)"));
-        assert!(formatted.contains("Sample extracted text"));
-        assert!(formatted.contains("Metadata:"));
-    }
-
-    #[test]
-    fn test_format_extraction_result_with_tables() {
-        let result = KreuzbergResult {
-            content: "Document with tables".to_string(),
-            mime_type: "application/pdf".to_string(),
-            metadata: crate::Metadata::default(),
-            tables: vec![
-                crate::Table {
-                    cells: vec![
-                        vec!["Col1".to_string(), "Col2".to_string()],
-                        vec!["A".to_string(), "B".to_string()],
-                    ],
-                    page_number: 1,
-                    markdown: "| Col1 | Col2 |\n|------|------|\n| A    | B    |".to_string(),
-                },
-                crate::Table {
-                    cells: vec![
-                        vec!["X".to_string(), "Y".to_string()],
-                        vec!["1".to_string(), "2".to_string()],
-                    ],
-                    page_number: 2,
-                    markdown: "| X | Y |\n|---|---|\n| 1 | 2 |".to_string(),
-                },
-            ],
-            detected_languages: None,
-            chunks: None,
-            images: None,
-            pages: None,
-        };
-
-        let formatted = format_extraction_result(&result);
-
-        assert!(formatted.contains("Tables (2)"));
-        assert!(formatted.contains("Table 1 (page 1)"));
-        assert!(formatted.contains("Table 2 (page 2)"));
-        assert!(formatted.contains("| Col1 | Col2 |"));
-        assert!(formatted.contains("| X | Y |"));
-    }
-
-    #[test]
-    fn test_format_extraction_result_empty_content() {
-        let result = KreuzbergResult {
-            content: String::new(),
-            mime_type: "text/plain".to_string(),
-            metadata: crate::Metadata::default(),
-            tables: vec![],
-            detected_languages: None,
-            chunks: None,
-            images: None,
-            pages: None,
-        };
-
-        let formatted = format_extraction_result(&result);
-
-        assert!(formatted.contains("Content (0 characters)"));
-        assert!(formatted.contains("Metadata:"));
-    }
-
-    #[test]
-    fn test_format_extraction_result_no_tables() {
-        let result = KreuzbergResult {
-            content: "Simple text".to_string(),
-            mime_type: "text/plain".to_string(),
-            metadata: crate::Metadata::default(),
-            tables: vec![],
-            detected_languages: None,
-            chunks: None,
-            images: None,
-            pages: None,
-        };
-
-        let formatted = format_extraction_result(&result);
-
-        assert!(formatted.contains("Simple text"));
-        assert!(!formatted.contains("Tables"));
-    }
-
-    #[tokio::test]
-    async fn test_extract_file_sync_with_valid_pdf() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = ExtractFileParams {
-            path: get_test_path("pdfs_with_tables/tiny.pdf").to_string(),
-            mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_file(Parameters(params)).await;
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first() {
-            match &content.raw {
-                RawContent::Text(text) => {
-                    assert!(!text.text.is_empty());
-                    assert!(text.text.contains("Content"));
-                }
-                _ => panic!("Expected text content"),
-            }
-        } else {
-            panic!("Expected content in result");
-        }
-    }
-
-    #[tokio::test]
-    async fn test_extract_file_async_with_valid_pdf() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = ExtractFileParams {
-            path: get_test_path("pdfs_with_tables/tiny.pdf").to_string(),
-            mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_file(Parameters(params)).await;
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first() {
-            match &content.raw {
-                RawContent::Text(text) => {
-                    assert!(!text.text.is_empty());
-                }
-                _ => panic!("Expected text content"),
-            }
-        } else {
-            panic!("Expected content in result");
-        }
-    }
-
-    #[tokio::test]
-    async fn test_extract_file_with_invalid_path() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = ExtractFileParams {
-            path: "/nonexistent/file.pdf".to_string(),
-            mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_file(Parameters(params)).await;
-
-        assert!(result.is_err());
-        let error = result.unwrap_err();
-        assert!(error.code.0 == -32602 || error.code.0 == -32603);
-    }
-
-    #[tokio::test]
-    async fn test_extract_file_with_mime_type_hint() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = ExtractFileParams {
-            path: get_test_path("pdfs_with_tables/tiny.pdf").to_string(),
-            mime_type: Some("application/pdf".to_string()),
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_file(Parameters(params)).await;
-
-        assert!(result.is_ok());
-    }
-
-    #[tokio::test]
-    async fn test_extract_file_with_ocr_enabled() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = ExtractFileParams {
-            path: get_test_path("pdfs_with_tables/tiny.pdf").to_string(),
-            mime_type: None,
-            enable_ocr: true,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_file(Parameters(params)).await;
-
-        assert!(result.is_ok() || result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_extract_file_with_force_ocr() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = ExtractFileParams {
-            path: get_test_path("pdfs_with_tables/tiny.pdf").to_string(),
-            mime_type: None,
-            enable_ocr: true,
-            force_ocr: true,
-            r#async: true,
-        };
-
-        let result = server.extract_file(Parameters(params)).await;
-
-        assert!(result.is_ok() || result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_extract_bytes_sync_with_valid_data() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let text_content = b"Hello, world!";
-        let encoded = BASE64_STANDARD.encode(text_content);
-
-        let params = ExtractBytesParams {
-            data: encoded,
-            mime_type: Some("text/plain".to_string()),
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_bytes(Parameters(params)).await;
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first() {
-            match &content.raw {
-                RawContent::Text(text) => {
-                    assert!(text.text.contains("Hello, world!"));
-                }
-                _ => panic!("Expected text content"),
-            }
-        } else {
-            panic!("Expected content in result");
-        }
-    }
-
-    #[tokio::test]
-    async fn test_extract_bytes_async_with_valid_data() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let text_content = b"Async extraction test";
-        let encoded = BASE64_STANDARD.encode(text_content);
-
-        let params = ExtractBytesParams {
-            data: encoded,
-            mime_type: Some("text/plain".to_string()),
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_bytes(Parameters(params)).await;
-
-        assert!(result.is_ok());
-    }
-
-    #[tokio::test]
-    async fn test_extract_bytes_with_invalid_base64() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let params = ExtractBytesParams {
-            data: "not-valid-base64!!!".to_string(),
-            mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_bytes(Parameters(params)).await;
-
-        assert!(result.is_err());
-        let error = result.unwrap_err();
-        assert_eq!(error.code.0, -32602);
-        assert!(error.message.contains("Invalid base64"));
-    }
-
-    #[tokio::test]
-    async fn test_extract_bytes_without_mime_type() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let text_content = b"Test content";
-        let encoded = BASE64_STANDARD.encode(text_content);
-
-        let params = ExtractBytesParams {
-            data: encoded,
-            mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_bytes(Parameters(params)).await;
-
-        assert!(result.is_ok() || result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_extract_bytes_with_ocr_enabled() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let text_content = b"OCR test content";
-        let encoded = BASE64_STANDARD.encode(text_content);
-
-        let params = ExtractBytesParams {
-            data: encoded,
-            mime_type: Some("text/plain".to_string()),
-            enable_ocr: true,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_bytes(Parameters(params)).await;
-
-        assert!(result.is_ok() || result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_batch_extract_files_sync_with_valid_files() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = BatchExtractFilesParams {
-            paths: vec![get_test_path("pdfs_with_tables/tiny.pdf").to_string()],
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.batch_extract_files(Parameters(params)).await;
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first() {
-            match &content.raw {
-                RawContent::Text(text) => {
-                    assert!(text.text.contains("Document 1"));
-                    assert!(text.text.contains("tiny.pdf"));
-                }
-                _ => panic!("Expected text content"),
-            }
-        } else {
-            panic!("Expected content in result");
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_extract_files_async_with_multiple_files() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = BatchExtractFilesParams {
-            paths: vec![
-                get_test_path("pdfs_with_tables/tiny.pdf").to_string(),
-                get_test_path("pdfs_with_tables/medium.pdf").to_string(),
-            ],
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.batch_extract_files(Parameters(params)).await;
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first() {
-            match &content.raw {
-                RawContent::Text(text) => {
-                    assert!(text.text.contains("Document 1"));
-                    assert!(text.text.contains("Document 2"));
-                }
-                _ => panic!("Expected text content"),
-            }
-        } else {
-            panic!("Expected content in result");
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_extract_files_with_empty_list() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = BatchExtractFilesParams {
-            paths: vec![],
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.batch_extract_files(Parameters(params)).await;
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first() {
-            match &content.raw {
-                RawContent::Text(text) => {
-                    assert!(text.text.is_empty() || text.text.trim().is_empty());
-                }
-                _ => panic!("Expected text content"),
-            }
-        } else {
-            panic!("Expected content in result");
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_extract_files_with_invalid_file() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = BatchExtractFilesParams {
-            paths: vec!["/nonexistent/file.pdf".to_string()],
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.batch_extract_files(Parameters(params)).await;
-
-        assert!(result.is_ok() || result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_detect_mime_type_with_valid_file() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = DetectMimeTypeParams {
-            path: get_test_path("pdfs_with_tables/tiny.pdf").to_string(),
-            use_content: true,
-        };
-
-        let result = server.detect_mime_type(Parameters(params));
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first() {
-            match &content.raw {
-                RawContent::Text(text) => {
-                    assert!(text.text.contains("application/pdf") || text.text.contains("pdf"));
-                }
-                _ => panic!("Expected text content"),
-            }
-        } else {
-            panic!("Expected content in result");
-        }
-    }
-
-    #[tokio::test]
-    async fn test_detect_mime_type_without_content_detection() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = DetectMimeTypeParams {
-            path: get_test_path("pdfs_with_tables/tiny.pdf").to_string(),
-            use_content: false,
-        };
-
-        let result = server.detect_mime_type(Parameters(params));
-
-        assert!(result.is_ok());
-    }
-
-    #[tokio::test]
-    async fn test_detect_mime_type_with_invalid_file() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-        let params = DetectMimeTypeParams {
-            path: "/nonexistent/file.pdf".to_string(),
-            use_content: true,
-        };
-
-        let result = server.detect_mime_type(Parameters(params));
-
-        assert!(result.is_err());
-        let error = result.unwrap_err();
-        assert!(error.code.0 == -32602 || error.code.0 == -32603);
-    }
-
-    #[tokio::test]
-    async fn test_cache_stats_returns_statistics() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let result = server.cache_stats(Parameters(()));
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first() {
-            match &content.raw {
-                RawContent::Text(text) => {
-                    assert!(text.text.contains("Cache Statistics"));
-                    assert!(text.text.contains("Directory:"));
-                    assert!(text.text.contains("Total files:"));
-                    assert!(text.text.contains("Total size:"));
-                    assert!(text.text.contains("Available space:"));
-                }
-                _ => panic!("Expected text content"),
-            }
-        } else {
-            panic!("Expected content in result");
-        }
-    }
-
-    #[tokio::test]
-    async fn test_cache_clear_returns_result() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let result = server.cache_clear(Parameters(()));
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first() {
-            match &content.raw {
-                RawContent::Text(text) => {
-                    assert!(text.text.contains("Cache cleared"));
-                    assert!(text.text.contains("Directory:"));
-                    assert!(text.text.contains("Removed files:"));
-                    assert!(text.text.contains("Freed space:"));
-                }
-                _ => panic!("Expected text content"),
-            }
-        } else {
-            panic!("Expected content in result");
-        }
-    }
-
     #[test]
     fn test_new_creates_server_with_default_config() {
         let server = KreuzbergMcp::new();
@@ -1418,92 +509,6 @@ mod tests {
         assert!(info.capabilities.tools.is_some());
     }
 
-    #[test]
-    fn test_build_config_preserves_default_config_settings() {
-        let default_config = ExtractionConfig {
-            use_cache: false,
-            ..Default::default()
-        };
-
-        let config = build_config(&default_config, false, false);
-
-        assert!(!config.use_cache);
-    }
-
-    #[test]
-    fn test_build_config_ocr_disabled_by_default() {
-        let default_config = ExtractionConfig::default();
-
-        let config = build_config(&default_config, false, false);
-
-        assert!(config.ocr.is_none());
-        assert!(!config.force_ocr);
-    }
-
-    #[test]
-    fn test_build_config_ocr_enabled_creates_tesseract_config() {
-        let default_config = ExtractionConfig::default();
-
-        let config = build_config(&default_config, true, false);
-
-        assert!(config.ocr.is_some());
-        let ocr_config = config.ocr.unwrap();
-        assert_eq!(ocr_config.backend, "tesseract");
-        assert_eq!(ocr_config.language, "eng");
-    }
-
-    #[test]
-    fn test_extract_file_params_defaults() {
-        let json = r#"{"path": "/test.pdf"}"#;
-        let params: ExtractFileParams = serde_json::from_str(json).unwrap();
-
-        assert_eq!(params.path, "/test.pdf");
-        assert_eq!(params.mime_type, None);
-        assert!(!params.enable_ocr);
-        assert!(!params.force_ocr);
-        assert!(!params.r#async);
-    }
-
-    #[test]
-    fn test_extract_bytes_params_defaults() {
-        let json = r#"{"data": "SGVsbG8="}"#;
-        let params: ExtractBytesParams = serde_json::from_str(json).unwrap();
-
-        assert_eq!(params.data, "SGVsbG8=");
-        assert_eq!(params.mime_type, None);
-        assert!(!params.enable_ocr);
-        assert!(!params.force_ocr);
-        assert!(!params.r#async);
-    }
-
-    #[test]
-    fn test_batch_extract_files_params_defaults() {
-        let json = r#"{"paths": ["/a.pdf", "/b.pdf"]}"#;
-        let params: BatchExtractFilesParams = serde_json::from_str(json).unwrap();
-
-        assert_eq!(params.paths.len(), 2);
-        assert!(!params.enable_ocr);
-        assert!(!params.force_ocr);
-        assert!(!params.r#async);
-    }
-
-    #[test]
-    fn test_detect_mime_type_params_defaults() {
-        let json = r#"{"path": "/test.pdf"}"#;
-        let params: DetectMimeTypeParams = serde_json::from_str(json).unwrap();
-
-        assert_eq!(params.path, "/test.pdf");
-        assert!(params.use_content);
-    }
-
-    #[test]
-    fn test_detect_mime_type_params_use_content_false() {
-        let json = r#"{"path": "/test.pdf", "use_content": false}"#;
-        let params: DetectMimeTypeParams = serde_json::from_str(json).unwrap();
-
-        assert!(!params.use_content);
-    }
-
     #[test]
     fn test_mcp_server_info_protocol_version() {
         let server = KreuzbergMcp::with_config(ExtractionConfig::default());
@@ -1643,6 +648,7 @@ mod tests {
                 backend: "tesseract".to_string(),
                 language: "spa".to_string(),
                 tesseract_config: None,
+                output_format: None,
             }),
             ..Default::default()
         };
@@ -1666,234 +672,6 @@ mod tests {
         assert_eq!(server1.default_config.force_ocr, server2.default_config.force_ocr);
     }
 
-    #[tokio::test]
-    async fn test_extract_bytes_with_empty_data() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let params = ExtractBytesParams {
-            data: String::new(),
-            mime_type: Some("text/plain".to_string()),
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_bytes(Parameters(params)).await;
-
-        assert!(result.is_ok() || result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_extract_bytes_with_valid_pdf_bytes() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let pdf_path = get_test_path("pdfs_with_tables/tiny.pdf");
-
-        if std::path::Path::new(&pdf_path).exists() {
-            let pdf_bytes = std::fs::read(&pdf_path).unwrap();
-            let encoded = BASE64_STANDARD.encode(&pdf_bytes);
-
-            let params = ExtractBytesParams {
-                data: encoded,
-                mime_type: Some("application/pdf".to_string()),
-                enable_ocr: false,
-                force_ocr: false,
-                r#async: true,
-            };
-
-            let result = server.extract_bytes(Parameters(params)).await;
-
-            assert!(result.is_ok(), "PDF bytes extraction should succeed");
-            let call_result = result.unwrap();
-            assert!(!call_result.content.is_empty());
-        }
-    }
-
-    #[tokio::test]
-    async fn test_extract_bytes_mime_type_auto_detection() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let text_content = b"Plain text content for testing";
-        let encoded = BASE64_STANDARD.encode(text_content);
-
-        let params = ExtractBytesParams {
-            data: encoded,
-            mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let result = server.extract_bytes(Parameters(params)).await;
-
-        assert!(result.is_ok() || result.is_err());
-    }
-
-    #[tokio::test]
-    async fn test_batch_extract_preserves_file_order() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let file1 = get_test_path("pdfs_with_tables/tiny.pdf");
-        let file2 = get_test_path("pdfs_with_tables/medium.pdf");
-
-        if std::path::Path::new(&file1).exists() && std::path::Path::new(&file2).exists() {
-            let params = BatchExtractFilesParams {
-                paths: vec![file1.to_string(), file2.to_string()],
-                enable_ocr: false,
-                force_ocr: false,
-                r#async: true,
-            };
-
-            let result = server.batch_extract_files(Parameters(params)).await;
-
-            if let Ok(call_result) = result
-                && let Some(content) = call_result.content.first()
-                && let RawContent::Text(text) = &content.raw
-            {
-                assert!(text.text.contains("Document 1"));
-                assert!(text.text.contains("Document 2"));
-
-                let doc1_pos = text.text.find("Document 1");
-                let doc2_pos = text.text.find("Document 2");
-                if let (Some(pos1), Some(pos2)) = (doc1_pos, doc2_pos) {
-                    assert!(pos1 < pos2, "Documents should be in order");
-                }
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_cache_clear_is_idempotent() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let result1 = server.cache_clear(Parameters(()));
-        assert!(result1.is_ok());
-
-        let result2 = server.cache_clear(Parameters(()));
-        assert!(result2.is_ok());
-    }
-
-    #[tokio::test]
-    async fn test_cache_clear_returns_metrics() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let result = server.cache_clear(Parameters(()));
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first()
-            && let RawContent::Text(text) = &content.raw
-        {
-            assert!(text.text.contains("Removed files:"));
-            assert!(text.text.contains("Freed space:"));
-        }
-    }
-
-    #[test]
-    fn test_error_mapping_preserves_error_context() {
-        let validation_error = KreuzbergError::validation("invalid file path");
-        let mcp_error = map_kreuzberg_error_to_mcp(validation_error);
-
-        assert!(mcp_error.message.contains("invalid file path"));
-    }
-
-    #[test]
-    fn test_io_errors_bubble_up_as_internal() {
-        // OSError/RuntimeError must bubble up - system errors need user reports ~keep
-        let io_error = std::io::Error::new(std::io::ErrorKind::PermissionDenied, "access denied");
-        let kreuzberg_error = KreuzbergError::Io(io_error);
-        let mcp_error = map_kreuzberg_error_to_mcp(kreuzberg_error);
-
-        assert_eq!(mcp_error.code.0, -32603);
-        assert!(mcp_error.message.contains("System I/O error"));
-    }
-
-    #[test]
-    fn test_all_error_variants_have_mappings() {
-        let errors = vec![
-            KreuzbergError::validation("test"),
-            KreuzbergError::UnsupportedFormat("test/unknown".to_string()),
-            KreuzbergError::MissingDependency("test-dep".to_string()),
-            KreuzbergError::parsing("test"),
-            KreuzbergError::Io(std::io::Error::other("test")),
-            KreuzbergError::ocr("test"),
-            KreuzbergError::cache("test"),
-            KreuzbergError::image_processing("test"),
-            KreuzbergError::serialization("test"),
-            KreuzbergError::Plugin {
-                message: "test".to_string(),
-                plugin_name: "test-plugin".to_string(),
-            },
-            KreuzbergError::LockPoisoned("test".to_string()),
-            KreuzbergError::Other("test".to_string()),
-        ];
-
-        for error in errors {
-            let mcp_error = map_kreuzberg_error_to_mcp(error);
-
-            assert!(mcp_error.code.0 < 0, "Error code should be negative");
-
-            assert!(!mcp_error.message.is_empty());
-        }
-    }
-
-    #[tokio::test]
-    async fn test_response_includes_metadata() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let test_file = get_test_path("pdfs_with_tables/tiny.pdf");
-
-        if std::path::Path::new(&test_file).exists() {
-            let params = ExtractFileParams {
-                path: test_file.to_string(),
-                mime_type: None,
-                enable_ocr: false,
-                force_ocr: false,
-                r#async: true,
-            };
-
-            let result = server.extract_file(Parameters(params)).await;
-
-            assert!(result.is_ok());
-            let call_result = result.unwrap();
-
-            if let Some(content) = call_result.content.first()
-                && let RawContent::Text(text) = &content.raw
-            {
-                assert!(text.text.contains("Metadata:"));
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_response_includes_content_length() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let test_file = get_test_path("pdfs_with_tables/tiny.pdf");
-
-        if std::path::Path::new(&test_file).exists() {
-            let params = ExtractFileParams {
-                path: test_file.to_string(),
-                mime_type: None,
-                enable_ocr: false,
-                force_ocr: false,
-                r#async: true,
-            };
-
-            let result = server.extract_file(Parameters(params)).await;
-
-            assert!(result.is_ok());
-            let call_result = result.unwrap();
-
-            if let Some(content) = call_result.content.first()
-                && let RawContent::Text(text) = &content.raw
-            {
-                assert!(text.text.contains("characters"));
-                assert!(text.text.contains("Content"));
-            }
-        }
-    }
-
     #[tokio::test]
     async fn test_server_is_thread_safe() {
         let server = KreuzbergMcp::with_config(ExtractionConfig::default());
@@ -1910,181 +688,4 @@ mod tests {
 
         assert_eq!(info1.server_info.name, info2.server_info.name);
     }
-
-    #[test]
-    fn test_extract_file_params_serialization() {
-        let params = ExtractFileParams {
-            path: "/test.pdf".to_string(),
-            mime_type: Some("application/pdf".to_string()),
-            enable_ocr: true,
-            force_ocr: false,
-            r#async: true,
-        };
-
-        let json = serde_json::to_string(&params).unwrap();
-        let deserialized: ExtractFileParams = serde_json::from_str(&json).unwrap();
-
-        assert_eq!(params.path, deserialized.path);
-        assert_eq!(params.mime_type, deserialized.mime_type);
-        assert_eq!(params.enable_ocr, deserialized.enable_ocr);
-        assert_eq!(params.force_ocr, deserialized.force_ocr);
-        assert_eq!(params.r#async, deserialized.r#async);
-    }
-
-    #[test]
-    fn test_extract_bytes_params_serialization() {
-        let params = ExtractBytesParams {
-            data: "SGVsbG8=".to_string(),
-            mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
-            r#async: false,
-        };
-
-        let json = serde_json::to_string(&params).unwrap();
-        let deserialized: ExtractBytesParams = serde_json::from_str(&json).unwrap();
-
-        assert_eq!(params.data, deserialized.data);
-    }
-
-    #[test]
-    fn test_batch_extract_params_serialization() {
-        let params = BatchExtractFilesParams {
-            paths: vec!["/a.pdf".to_string(), "/b.pdf".to_string()],
-            enable_ocr: true,
-            force_ocr: true,
-            r#async: true,
-        };
-
-        let json = serde_json::to_string(&params).unwrap();
-        let deserialized: BatchExtractFilesParams = serde_json::from_str(&json).unwrap();
-
-        assert_eq!(params.paths, deserialized.paths);
-        assert_eq!(params.enable_ocr, deserialized.enable_ocr);
-    }
-
-    #[test]
-    fn test_detect_mime_type_params_serialization() {
-        let params = DetectMimeTypeParams {
-            path: "/test.pdf".to_string(),
-            use_content: false,
-        };
-
-        let json = serde_json::to_string(&params).unwrap();
-        let deserialized: DetectMimeTypeParams = serde_json::from_str(&json).unwrap();
-
-        assert_eq!(params.path, deserialized.path);
-        assert_eq!(params.use_content, deserialized.use_content);
-    }
-
-    #[tokio::test]
-    async fn test_extract_file_respects_custom_default_config() {
-        let custom_config = ExtractionConfig {
-            use_cache: false,
-            ..Default::default()
-        };
-
-        let server = KreuzbergMcp::with_config(custom_config);
-
-        let test_file = get_test_path("pdfs_with_tables/tiny.pdf");
-
-        if std::path::Path::new(&test_file).exists() {
-            let params = ExtractFileParams {
-                path: test_file.to_string(),
-                mime_type: None,
-                enable_ocr: false,
-                force_ocr: false,
-                r#async: true,
-            };
-
-            let result = server.extract_file(Parameters(params)).await;
-
-            assert!(result.is_ok() || result.is_err());
-        }
-    }
-
-    #[tokio::test]
-    async fn test_batch_extract_with_single_file() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let test_file = get_test_path("pdfs_with_tables/tiny.pdf");
-
-        if std::path::Path::new(&test_file).exists() {
-            let params = BatchExtractFilesParams {
-                paths: vec![test_file.to_string()],
-                enable_ocr: false,
-                force_ocr: false,
-                r#async: true,
-            };
-
-            let result = server.batch_extract_files(Parameters(params)).await;
-
-            assert!(result.is_ok());
-            let call_result = result.unwrap();
-            assert!(!call_result.content.is_empty());
-        }
-    }
-
-    #[tokio::test]
-    async fn test_detect_mime_type_with_extension_only() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let test_file = get_test_path("pdfs_with_tables/tiny.pdf");
-
-        if std::path::Path::new(&test_file).exists() {
-            let params = DetectMimeTypeParams {
-                path: test_file.to_string(),
-                use_content: false,
-            };
-
-            let result = server.detect_mime_type(Parameters(params));
-
-            assert!(result.is_ok());
-            let call_result = result.unwrap();
-            if let Some(content) = call_result.content.first()
-                && let RawContent::Text(text) = &content.raw
-            {
-                assert!(text.text.contains("pdf") || text.text.contains("PDF"));
-            }
-        }
-    }
-
-    #[tokio::test]
-    async fn test_detect_mime_type_with_content_analysis() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let test_file = get_test_path("pdfs_with_tables/tiny.pdf");
-
-        if std::path::Path::new(&test_file).exists() {
-            let params = DetectMimeTypeParams {
-                path: test_file.to_string(),
-                use_content: true,
-            };
-
-            let result = server.detect_mime_type(Parameters(params));
-
-            assert!(result.is_ok());
-        }
-    }
-
-    #[tokio::test]
-    async fn test_cache_stats_returns_valid_data() {
-        let server = KreuzbergMcp::with_config(ExtractionConfig::default());
-
-        let result = server.cache_stats(Parameters(()));
-
-        assert!(result.is_ok());
-        let call_result = result.unwrap();
-        if let Some(content) = call_result.content.first()
-            && let RawContent::Text(text) = &content.raw
-        {
-            assert!(text.text.contains("Cache Statistics"));
-            assert!(text.text.contains("Directory:"));
-            assert!(text.text.contains("Total files:"));
-            assert!(text.text.contains("Total size:"));
-            assert!(text.text.contains("Available space:"));
-            assert!(text.text.contains("Oldest file age:"));
-            assert!(text.text.contains("Newest file age:"));
-        }
-    }
 }