kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

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

@@ -16,7 +16,7 @@
 //! use kreuzberg::mcp::start_mcp_server;
 //!
 //! #[tokio::main]
-//! async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+//! async fn main() -> anyhow::Result<()> {
 //!     start_mcp_server().await?;
 //!     Ok(())
 //! }
@@ -26,9 +26,6 @@ mod server;
 
 pub use server::{start_mcp_server, start_mcp_server_with_config};
 
-#[cfg(feature = "mcp-http")]
-pub use server::{start_mcp_server_http, start_mcp_server_http_with_config};
-
 pub use server::{BatchExtractFilesParams, DetectMimeTypeParams, ExtractBytesParams, ExtractFileParams, KreuzbergMcp};
 
 #[doc(hidden)]

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

@@ -12,9 +12,6 @@ use rmcp::{
     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,
@@ -229,8 +226,7 @@ impl KreuzbergMcp {
     /// This tool extracts text, metadata, and tables from documents in various formats
     /// including PDFs, Word documents, Excel spreadsheets, images (with OCR), and more.
     #[tool(
-        description = "Extract content from a file by path. Supports PDFs, Word, Excel, images (with OCR), HTML, and more.",
-        annotations(title = "Extract File", read_only_hint = true, idempotent_hint = true)
+        description = "Extract content from a file by path. Supports PDFs, Word, Excel, images (with OCR), HTML, and more."
     )]
     async fn extract_file(
         &self,
@@ -254,8 +250,7 @@ impl KreuzbergMcp {
     ///
     /// This tool extracts text, metadata, and tables from base64-encoded document data.
     #[tool(
-        description = "Extract content from base64-encoded file data. Returns extracted text, metadata, and tables.",
-        annotations(title = "Extract Bytes", read_only_hint = true, idempotent_hint = true)
+        description = "Extract content from base64-encoded file data. Returns extracted text, metadata, and tables."
     )]
     async fn extract_bytes(
         &self,
@@ -284,10 +279,7 @@ impl KreuzbergMcp {
     /// Extract content from multiple files in parallel.
     ///
     /// This tool efficiently processes multiple documents simultaneously, useful for batch operations.
-    #[tool(
-        description = "Extract content from multiple files in parallel. Returns results for all files.",
-        annotations(title = "Batch Extract Files", read_only_hint = true, idempotent_hint = true)
-    )]
+    #[tool(description = "Extract content from multiple files in parallel. Returns results for all files.")]
     async fn batch_extract_files(
         &self,
         Parameters(params): Parameters<BatchExtractFilesParams>,
@@ -315,10 +307,7 @@ impl KreuzbergMcp {
     /// Detect the MIME type of a file.
     ///
     /// This tool identifies the file format, useful for determining which extractor to use.
-    #[tool(
-        description = "Detect the MIME type of a file. Returns the detected MIME type string.",
-        annotations(title = "Detect MIME Type", read_only_hint = true, idempotent_hint = true)
-    )]
+    #[tool(description = "Detect the MIME type of a file. Returns the detected MIME type string.")]
     fn detect_mime_type(
         &self,
         Parameters(params): Parameters<DetectMimeTypeParams>,
@@ -331,10 +320,7 @@ impl KreuzbergMcp {
     /// Get cache statistics.
     ///
     /// This tool returns statistics about the cache including total files, size, and disk space.
-    #[tool(
-        description = "Get cache statistics including total files, size, and available disk space.",
-        annotations(title = "Cache Stats", read_only_hint = true, idempotent_hint = true)
-    )]
+    #[tool(description = "Get cache statistics including total files, size, and available disk space.")]
     fn cache_stats(&self, Parameters(_): Parameters<()>) -> Result<CallToolResult, McpError> {
         let cache_dir = std::env::current_dir()
             .unwrap_or_else(|_| std::path::PathBuf::from("."))
@@ -365,10 +351,7 @@ impl KreuzbergMcp {
     /// Clear the cache.
     ///
     /// This tool removes all cached files and returns the number of files removed and space freed.
-    #[tool(
-        description = "Clear all cached files. Returns the number of files removed and space freed in MB.",
-        annotations(title = "Clear Cache", destructive_hint = true)
-    )]
+    #[tool(description = "Clear all cached files. Returns the number of files removed and space freed in MB.")]
     fn cache_clear(&self, Parameters(_): Parameters<()>) -> Result<CallToolResult, McpError> {
         let cache_dir = std::env::current_dir()
             .unwrap_or_else(|_| std::path::PathBuf::from("."))
@@ -445,12 +428,12 @@ impl Default for KreuzbergMcp {
 /// use kreuzberg::mcp::start_mcp_server;
 ///
 /// #[tokio::main]
-/// async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+/// async fn main() -> anyhow::Result<()> {
 ///     start_mcp_server().await?;
 ///     Ok(())
 /// }
 /// ```
-pub async fn start_mcp_server() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+pub async fn start_mcp_server() -> Result<(), Box<dyn std::error::Error>> {
     let service = KreuzbergMcp::new()?.serve(stdio()).await?;
 
     service.waiting().await?;
@@ -461,118 +444,13 @@ pub async fn start_mcp_server() -> Result<(), Box<dyn std::error::Error + Send +
 ///
 /// This variant allows specifying a custom extraction configuration
 /// (e.g., loaded from a file) instead of using defaults.
-pub async fn start_mcp_server_with_config(
-    config: ExtractionConfig,
-) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+pub async fn start_mcp_server_with_config(config: ExtractionConfig) -> Result<(), Box<dyn std::error::Error>> {
     let service = KreuzbergMcp::with_config(config).serve(stdio()).await?;
 
     service.waiting().await?;
     Ok(())
 }
 
-/// Start MCP server with HTTP Stream transport.
-///
-/// Uses rmcp's built-in StreamableHttpService for HTTP/SSE support per MCP spec.
-///
-/// # Arguments
-///
-/// * `host` - Host to bind to (e.g., "127.0.0.1" or "0.0.0.0")
-/// * `port` - Port number (e.g., 8001)
-///
-/// # Example
-///
-/// ```no_run
-/// use kreuzberg::mcp::start_mcp_server_http;
-///
-/// #[tokio::main]
-/// async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-///     start_mcp_server_http("127.0.0.1", 8001).await?;
-///     Ok(())
-/// }
-/// ```
-#[cfg(feature = "mcp-http")]
-pub async fn start_mcp_server_http(
-    host: impl AsRef<str>,
-    port: u16,
-) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    use axum::Router;
-    use std::net::SocketAddr;
-
-    let http_service = StreamableHttpService::new(
-        || KreuzbergMcp::new().map_err(|e| std::io::Error::other(e.to_string())),
-        LocalSessionManager::default().into(),
-        Default::default(),
-    );
-
-    let router = Router::new().nest_service("/mcp", http_service);
-
-    let addr: SocketAddr = format!("{}:{}", host.as_ref(), port)
-        .parse()
-        .map_err(|e| format!("Invalid address: {}", e))?;
-
-    #[cfg(feature = "api")]
-    tracing::info!("Starting MCP HTTP server on http://{}", addr);
-
-    let listener = tokio::net::TcpListener::bind(addr).await?;
-    axum::serve(listener, router).await?;
-
-    Ok(())
-}
-
-/// Start MCP HTTP server with custom extraction config.
-///
-/// This variant allows specifying a custom extraction configuration
-/// while using HTTP Stream transport.
-///
-/// # Arguments
-///
-/// * `host` - Host to bind to (e.g., "127.0.0.1" or "0.0.0.0")
-/// * `port` - Port number (e.g., 8001)
-/// * `config` - Custom extraction configuration
-///
-/// # Example
-///
-/// ```no_run
-/// use kreuzberg::mcp::start_mcp_server_http_with_config;
-/// use kreuzberg::ExtractionConfig;
-///
-/// #[tokio::main]
-/// async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-///     let config = ExtractionConfig::default();
-///     start_mcp_server_http_with_config("127.0.0.1", 8001, config).await?;
-///     Ok(())
-/// }
-/// ```
-#[cfg(feature = "mcp-http")]
-pub async fn start_mcp_server_http_with_config(
-    host: impl AsRef<str>,
-    port: u16,
-    config: ExtractionConfig,
-) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    use axum::Router;
-    use std::net::SocketAddr;
-
-    let http_service = StreamableHttpService::new(
-        move || Ok(KreuzbergMcp::with_config(config.clone())),
-        LocalSessionManager::default().into(),
-        Default::default(),
-    );
-
-    let router = Router::new().nest_service("/mcp", http_service);
-
-    let addr: SocketAddr = format!("{}:{}", host.as_ref(), port)
-        .parse()
-        .map_err(|e| format!("Invalid address: {}", e))?;
-
-    #[cfg(feature = "api")]
-    tracing::info!("Starting MCP HTTP server on http://{}", addr);
-
-    let listener = tokio::net::TcpListener::bind(addr).await?;
-    axum::serve(listener, router).await?;
-
-    Ok(())
-}
-
 /// Build extraction config from MCP parameters.
 ///
 /// Starts with the default config and overlays OCR settings from request parameters.
@@ -870,7 +748,6 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         let formatted = format_extraction_result(&result);
@@ -907,7 +784,6 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         let formatted = format_extraction_result(&result);
@@ -929,7 +805,6 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         let formatted = format_extraction_result(&result);
@@ -948,7 +823,6 @@ mod tests {
             detected_languages: None,
             chunks: None,
             images: None,
-            pages: None,
         };
 
         let formatted = format_extraction_result(&result);
@@ -1746,17 +1620,19 @@ mod tests {
 
             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"));
+            if 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("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");
+                    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");
+                    }
                 }
             }
         }

data/vendor/kreuzberg/src/ocr/mod.rs

@@ -40,7 +40,6 @@
 pub mod cache;
 pub mod error;
 pub mod hocr;
-pub mod language_registry;
 pub mod processor;
 pub mod table;
 pub mod tesseract_backend;
@@ -51,7 +50,6 @@ pub mod validation;
 pub use cache::{OcrCache, OcrCacheStats};
 pub use error::OcrError;
 pub use hocr::convert_hocr_to_markdown;
-pub use language_registry::LanguageRegistry;
 pub use processor::OcrProcessor;
 pub use table::{HocrWord, extract_words_from_tsv, reconstruct_table, table_to_markdown};
 pub use tesseract_backend::TesseractBackend;

data/vendor/kreuzberg/src/ocr/processor.rs

@@ -51,14 +51,6 @@ impl OcrProcessor {
         Ok(Self { cache })
     }
 
-    #[cfg_attr(feature = "otel", tracing::instrument(
-        skip(self, image_bytes),
-        fields(
-            ocr.backend = "tesseract",
-            ocr.language = %config.language,
-            image.size_bytes = image_bytes.len(),
-        )
-    ))]
     pub fn process_image(&self, image_bytes: &[u8], config: &TesseractConfig) -> Result<OcrExtractionResult, OcrError> {
         config.validate().map_err(OcrError::InvalidConfiguration)?;
 
@@ -72,14 +64,9 @@ impl OcrProcessor {
         if config.use_cache
             && let Some(cached_result) = self.cache.get_cached_result(&image_hash, "tesseract", &config_str)?
         {
-            #[cfg(feature = "otel")]
-            tracing::Span::current().record("cache.hit", true);
             return Ok(cached_result);
         }
 
-        #[cfg(feature = "otel")]
-        tracing::Span::current().record("cache.hit", false);
-
         let result = self.perform_ocr(image_bytes, config)?;
 
         if config.use_cache {
@@ -241,6 +228,7 @@ impl OcrProcessor {
         });
 
         // Validate language before initializing to prevent segfault ~keep
+        // tesseract-rs can crash on empty language or missing language files
         if config.language.trim().is_empty() {
             return Err(OcrError::TesseractInitializationFailed(
                 "Language cannot be empty. Please specify a valid language code (e.g., 'eng')".to_string(),
@@ -248,6 +236,7 @@ impl OcrProcessor {
         }
 
         // Validate language file exists before initializing to prevent segfault ~keep
+        // tesseract-rs can crash if language file is missing instead of returning error
         if !tessdata_path.is_empty() {
             let languages: Vec<&str> = config.language.split('+').collect();
             for lang in languages {
@@ -373,11 +362,6 @@ impl OcrProcessor {
             )
         });
 
-        api.recognize()
-            .map_err(|e| OcrError::ProcessingFailed(format!("Failed to recognize text: {}", e)))?;
-
-        log_ci_debug(ci_debug_enabled, "recognize", || "completed".to_string());
-
         let tsv_data_for_tables = if config.enable_table_detection || config.output_format == "tsv" {
             Some(
                 api.get_tsv_text(0)
@@ -453,7 +437,12 @@ impl OcrProcessor {
             let words = extract_words_from_tsv(&tsv_data, config.table_min_confidence)?;
 
             if !words.is_empty() {
-                let table = reconstruct_table(&words, config.table_column_threshold, config.table_row_threshold_ratio);
+                let table = reconstruct_table(
+                    &words,
+                    config.table_column_threshold,
+                    config.table_row_threshold_ratio,
+                    true,
+                );
                 if !table.is_empty() {
                     metadata.insert("table_count".to_string(), serde_json::Value::String("1".to_string()));
                     metadata.insert(

data/vendor/kreuzberg/src/ocr/tesseract_backend.rs

@@ -161,7 +161,6 @@ impl OcrBackend for TesseractBackend {
             content: ocr_result.content,
             mime_type: ocr_result.mime_type,
             metadata,
-            pages: None,
             tables: ocr_result
                 .tables
                 .into_iter()
@@ -215,7 +214,6 @@ impl OcrBackend for TesseractBackend {
             content: ocr_result.content,
             mime_type: ocr_result.mime_type,
             metadata,
-            pages: None,
             tables: ocr_result
                 .tables
                 .into_iter()

data/vendor/kreuzberg/src/pdf/error.rs

@@ -10,8 +10,6 @@ pub enum PdfError {
     TextExtractionFailed(String),
     RenderingFailed(String),
     MetadataExtractionFailed(String),
-    ExtractionFailed(String),
-    FontLoadingFailed(String),
     IOError(String),
 }
 
@@ -30,8 +28,6 @@ impl fmt::Display for PdfError {
             PdfError::MetadataExtractionFailed(msg) => {
                 write!(f, "Metadata extraction failed: {}", msg)
             }
-            PdfError::ExtractionFailed(msg) => write!(f, "Extraction failed: {}", msg),
-            PdfError::FontLoadingFailed(msg) => write!(f, "Font loading failed: {}", msg),
             PdfError::IOError(msg) => write!(f, "I/O error: {}", msg),
         }
     }
@@ -44,7 +40,7 @@ impl std::error::Error for PdfError {}
 impl From<lopdf::Error> for PdfError {
     fn from(err: lopdf::Error) -> Self {
         match err {
-            lopdf::Error::IO(io_err) => PdfError::IOError(io_err.to_string()),
+            lopdf::Error::IO(_) => panic!("lopdf IO errors should not be converted to PdfError - let them bubble up"),
             _ => PdfError::InvalidPdf(err.to_string()),
         }
     }
@@ -52,30 +48,6 @@ impl From<lopdf::Error> for PdfError {
 
 pub type Result<T> = std::result::Result<T, PdfError>;
 
-/// Format a pdfium error for display.
-///
-/// The kreuzberg-pdfium-render fork's error type doesn't implement Display,
-/// so Debug formatting produces messages like "PdfiumLibraryInternalError(FormatError,)"
-/// with trailing commas and parentheses. This function cleans up the formatting.
-pub(crate) fn format_pdfium_error<E: std::fmt::Debug>(error: E) -> String {
-    let debug_msg = format!("{:?}", error);
-
-    if let Some(paren_idx) = debug_msg.find('(') {
-        let variant = &debug_msg[..paren_idx];
-        let inner = &debug_msg[paren_idx + 1..];
-
-        let inner_clean = inner.trim_end_matches(')').trim_end_matches(',');
-
-        if inner_clean.is_empty() {
-            variant.to_string()
-        } else {
-            format!("{}: {}", variant, inner_clean)
-        }
-    } else {
-        debug_msg
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -147,68 +119,4 @@ mod tests {
         let err2 = err1.clone();
         assert_eq!(err1.to_string(), err2.to_string());
     }
-
-    #[test]
-    fn test_extraction_failed_error() {
-        let err = PdfError::ExtractionFailed("page data mismatch".to_string());
-        assert_eq!(err.to_string(), "Extraction failed: page data mismatch");
-    }
-
-    #[test]
-    fn test_font_loading_failed_error() {
-        let err = PdfError::FontLoadingFailed("missing font file".to_string());
-        assert_eq!(err.to_string(), "Font loading failed: missing font file");
-    }
-
-    #[test]
-    fn test_format_pdfium_error_with_inner_value() {
-        #[derive(Debug)]
-        #[allow(dead_code)]
-        struct MockError(String);
-
-        let error = MockError("FormatError,".to_string());
-        let formatted = format_pdfium_error(error);
-        assert!(formatted.contains("MockError"));
-        assert!(formatted.contains("FormatError"));
-    }
-
-    #[test]
-    fn test_format_pdfium_error_simple() {
-        #[derive(Debug)]
-        struct SimpleError;
-
-        let formatted = format_pdfium_error(SimpleError);
-        assert_eq!(formatted, "SimpleError");
-    }
-
-    #[test]
-    fn test_format_pdfium_error_empty_inner() {
-        #[derive(Debug)]
-        struct EmptyInner;
-
-        let formatted = format_pdfium_error(EmptyInner);
-        assert_eq!(formatted, "EmptyInner");
-    }
-
-    #[test]
-    fn test_format_pdfium_error_cleans_trailing_comma() {
-        #[derive(Debug)]
-        #[allow(dead_code)]
-        enum PdfiumError {
-            PdfiumLibraryInternalError(InternalError),
-        }
-
-        #[derive(Debug)]
-        #[allow(dead_code)]
-        enum InternalError {
-            FormatError,
-        }
-
-        let error = PdfiumError::PdfiumLibraryInternalError(InternalError::FormatError);
-        let formatted = format_pdfium_error(error);
-
-        assert!(!formatted.contains(",)"));
-        assert!(formatted.contains("PdfiumLibraryInternalError"));
-        assert!(formatted.contains("FormatError"));
-    }
 }