kreuzberg 4.1.2 → 4.2.1

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

@@ -80,7 +80,8 @@ impl KreuzbergMcp {
         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 config =
+            build_config(&self.default_config, params.config).map_err(|e| rmcp::ErrorData::invalid_params(e, None))?;
 
         let result = if params.r#async {
             extract_file(&params.path, params.mime_type.as_deref(), &config)
@@ -114,7 +115,8 @@ impl KreuzbergMcp {
             .decode(&params.data)
             .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);
+        let config =
+            build_config(&self.default_config, params.config).map_err(|e| rmcp::ErrorData::invalid_params(e, None))?;
 
         let mime_type = params.mime_type.as_deref().unwrap_or("");
 
@@ -145,7 +147,8 @@ impl KreuzbergMcp {
         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 config =
+            build_config(&self.default_config, params.config).map_err(|e| rmcp::ErrorData::invalid_params(e, None))?;
 
         let results = if params.r#async {
             batch_extract_file(params.paths.clone(), &config)

data/vendor/kreuzberg/src/mcp/tools/extraction.rs

@@ -30,7 +30,8 @@ pub(in crate::mcp) trait ExtractionTool {
         &self,
         Parameters(params): Parameters<ExtractFileParams>,
     ) -> Result<CallToolResult, McpError> {
-        let config = build_config(self.default_config(), params.enable_ocr, params.force_ocr);
+        let config = build_config(self.default_config(), params.config)
+            .map_err(|e| McpError::invalid_params(e, None))?;
 
         let result = if params.r#async {
             extract_file(&params.path, params.mime_type.as_deref(), &config)
@@ -59,7 +60,8 @@ pub(in crate::mcp) trait ExtractionTool {
             .decode(&params.data)
             .map_err(|e| McpError::invalid_params(format!("Invalid base64: {}", e), None))?;
 
-        let config = build_config(self.default_config(), params.enable_ocr, params.force_ocr);
+        let config = build_config(self.default_config(), params.config)
+            .map_err(|e| McpError::invalid_params(e, None))?;
 
         let mime_type = params.mime_type.as_deref().unwrap_or("");
 
@@ -86,7 +88,8 @@ pub(in crate::mcp) trait ExtractionTool {
         &self,
         Parameters(params): Parameters<BatchExtractFilesParams>,
     ) -> Result<CallToolResult, McpError> {
-        let config = build_config(self.default_config(), params.enable_ocr, params.force_ocr);
+        let config = build_config(self.default_config(), params.config)
+            .map_err(|e| McpError::invalid_params(e, None))?;
 
         let results = if params.r#async {
             batch_extract_file(params.paths.clone(), &config)
@@ -153,8 +156,7 @@ mod tests {
         let params = ExtractFileParams {
             path: get_test_path("pdfs_with_tables/tiny.pdf").to_string(),
             mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
+            config: None,
             r#async: true,
         };
 
@@ -181,8 +183,7 @@ mod tests {
         let params = ExtractFileParams {
             path: get_test_path("pdfs_with_tables/tiny.pdf").to_string(),
             mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
+            config: None,
             r#async: true,
         };
 
@@ -208,8 +209,7 @@ mod tests {
         let params = ExtractFileParams {
             path: "/nonexistent/file.pdf".to_string(),
             mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
+            config: None,
             r#async: true,
         };
 
@@ -226,8 +226,7 @@ mod tests {
         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,
+            config: None,
             r#async: true,
         };
 
@@ -246,8 +245,7 @@ mod tests {
         let params = ExtractBytesParams {
             data: encoded,
             mime_type: Some("text/plain".to_string()),
-            enable_ocr: false,
-            force_ocr: false,
+            config: None,
             r#async: true,
         };
 
@@ -274,8 +272,7 @@ mod tests {
         let params = ExtractBytesParams {
             data: "not-valid-base64!!!".to_string(),
             mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
+            config: None,
             r#async: true,
         };
 
@@ -292,8 +289,7 @@ mod tests {
         let server = TestMcpServer::new();
         let params = BatchExtractFilesParams {
             paths: vec![get_test_path("pdfs_with_tables/tiny.pdf").to_string()],
-            enable_ocr: false,
-            force_ocr: false,
+            config: None,
             r#async: true,
         };
 
@@ -319,8 +315,7 @@ mod tests {
         let server = TestMcpServer::new();
         let params = BatchExtractFilesParams {
             paths: vec![],
-            enable_ocr: false,
-            force_ocr: false,
+            config: None,
             r#async: true,
         };
 
@@ -350,8 +345,7 @@ mod tests {
             let params = ExtractFileParams {
                 path: test_file.to_string(),
                 mime_type: None,
-                enable_ocr: false,
-                force_ocr: false,
+                config: None,
                 r#async: true,
             };
 
@@ -378,8 +372,7 @@ mod tests {
         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,
+                config: None,
                 r#async: true,
             };
 

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

@@ -206,6 +206,7 @@ mod extractor;
 mod ocr;
 mod processor;
 pub mod registry;
+pub mod startup_validation;
 mod traits;
 mod validator;
 

data/vendor/kreuzberg/src/plugins/registry/extractor.rs

@@ -43,9 +43,26 @@ impl DocumentExtractorRegistry {
         let priority = extractor.priority();
         let mime_types: Vec<String> = extractor.supported_mime_types().iter().map(|s| s.to_string()).collect();
 
-        super::validate_plugin_name(&name)?;
+        if let Err(e) = super::validate_plugin_name(&name) {
+            tracing::warn!(
+                "Failed to validate document extractor name '{}': {}. \
+                 Registration aborted. Plugin names must be non-empty and contain only alphanumeric characters, hyphens, and underscores.",
+                name,
+                e
+            );
+            return Err(e);
+        }
 
-        extractor.initialize()?;
+        if let Err(e) = extractor.initialize() {
+            tracing::error!(
+                "Failed to initialize document extractor '{}': {}. \
+                 Extraction for MIME types {:?} will be unavailable.",
+                name,
+                e,
+                mime_types
+            );
+            return Err(e);
+        }
 
         let mut index_entries = Vec::new();
 
@@ -57,7 +74,13 @@ impl DocumentExtractorRegistry {
             index_entries.push((mime_type.clone(), priority));
         }
 
-        self.name_index.insert(name, index_entries);
+        self.name_index.insert(name.clone(), index_entries);
+        tracing::debug!(
+            "Registered document extractor '{}' with priority {} for MIME types: {:?}",
+            name,
+            priority,
+            mime_types
+        );
 
         Ok(())
     }
@@ -128,7 +151,13 @@ impl DocumentExtractorRegistry {
     pub fn remove(&mut self, name: &str) -> Result<()> {
         let index_entries = match self.name_index.remove(name) {
             Some(entries) => entries,
-            None => return Ok(()),
+            None => {
+                tracing::debug!(
+                    "Document extractor '{}' not found in registry (already removed or never registered)",
+                    name
+                );
+                return Ok(());
+            }
         };
 
         let mut extractor_to_shutdown: Option<Arc<dyn DocumentExtractor>> = None;
@@ -148,7 +177,16 @@ impl DocumentExtractorRegistry {
         }
 
         if let Some(extractor) = extractor_to_shutdown {
-            extractor.shutdown()?;
+            if let Err(e) = extractor.shutdown() {
+                tracing::warn!(
+                    "Failed to shutdown document extractor '{}': {}. \
+                     Resources may not have been properly released.",
+                    name,
+                    e
+                );
+                return Err(e);
+            }
+            tracing::debug!("Successfully removed and shut down document extractor '{}'", name);
         }
 
         Ok(())
@@ -157,9 +195,19 @@ impl DocumentExtractorRegistry {
     /// Shutdown all extractors and clear the registry.
     pub fn shutdown_all(&mut self) -> Result<()> {
         let names = self.list();
+        let count = names.len();
+
+        if count > 0 {
+            tracing::debug!("Shutting down {} document extractors", count);
+        }
+
         for name in names {
             self.remove(&name)?;
         }
+
+        if count > 0 {
+            tracing::debug!("Successfully shut down all {} document extractors", count);
+        }
         Ok(())
     }
 }
@@ -413,4 +461,202 @@ mod tests {
         assert_eq!(registry.get("text/markdown").unwrap().name(), "multi-extractor");
         assert_eq!(registry.get("text/html").unwrap().name(), "multi-extractor");
     }
+
+    struct FailingExtractor {
+        name: String,
+        fail_on_init: bool,
+    }
+
+    impl Plugin for FailingExtractor {
+        fn name(&self) -> &str {
+            &self.name
+        }
+        fn version(&self) -> String {
+            "1.0.0".to_string()
+        }
+        fn initialize(&self) -> Result<()> {
+            if self.fail_on_init {
+                Err(KreuzbergError::Plugin {
+                    message: "Extractor initialization failed".to_string(),
+                    plugin_name: self.name.clone(),
+                })
+            } else {
+                Ok(())
+            }
+        }
+        fn shutdown(&self) -> Result<()> {
+            Ok(())
+        }
+    }
+
+    #[async_trait]
+    impl DocumentExtractor for FailingExtractor {
+        async fn extract_bytes(&self, _: &[u8], _: &str, _: &ExtractionConfig) -> Result<ExtractionResult> {
+            Ok(ExtractionResult {
+                content: "test".to_string(),
+                mime_type: "text/plain".to_string(),
+                metadata: crate::types::Metadata::default(),
+                tables: vec![],
+                detected_languages: None,
+                chunks: None,
+                images: None,
+                djot_content: None,
+                pages: None,
+                elements: None,
+            })
+        }
+
+        fn supported_mime_types(&self) -> &[&str] {
+            &["text/plain"]
+        }
+
+        fn priority(&self) -> i32 {
+            50
+        }
+    }
+
+    #[test]
+    fn test_document_extractor_initialization_failure_logs_error() {
+        let mut registry = DocumentExtractorRegistry::new();
+
+        let extractor = Arc::new(FailingExtractor {
+            name: "failing-extractor".to_string(),
+            fail_on_init: true,
+        });
+
+        let result = registry.register(extractor);
+        assert!(result.is_err());
+        assert_eq!(registry.list().len(), 0);
+    }
+
+    #[test]
+    fn test_document_extractor_invalid_name_empty_logs_warning() {
+        let mut registry = DocumentExtractorRegistry::new();
+
+        let extractor = Arc::new(MockExtractor {
+            name: "".to_string(),
+            mime_types: &["text/plain"],
+            priority: 50,
+        });
+
+        let result = registry.register(extractor);
+        assert!(matches!(result, Err(KreuzbergError::Validation { .. })));
+    }
+
+    #[test]
+    fn test_document_extractor_invalid_name_with_spaces_logs_warning() {
+        let mut registry = DocumentExtractorRegistry::new();
+
+        let extractor = Arc::new(MockExtractor {
+            name: "invalid extractor".to_string(),
+            mime_types: &["text/plain"],
+            priority: 50,
+        });
+
+        let result = registry.register(extractor);
+        assert!(matches!(result, Err(KreuzbergError::Validation { .. })));
+    }
+
+    #[test]
+    fn test_document_extractor_successful_registration_logs_debug() {
+        let mut registry = DocumentExtractorRegistry::new();
+
+        let extractor = Arc::new(MockExtractor {
+            name: "valid-pdf-extractor".to_string(),
+            mime_types: &["application/pdf"],
+            priority: 100,
+        });
+
+        let result = registry.register(extractor);
+        assert!(result.is_ok());
+        assert_eq!(registry.list().len(), 1);
+    }
+
+    #[test]
+    fn test_document_extractor_remove_nonexistent_logs_debug() {
+        let mut registry = DocumentExtractorRegistry::new();
+
+        let result = registry.remove("nonexistent-extractor");
+        assert!(result.is_ok());
+        assert_eq!(registry.list().len(), 0);
+    }
+
+    #[test]
+    fn test_document_extractor_shutdown_empty_registry() {
+        let mut registry = DocumentExtractorRegistry::new();
+        let result = registry.shutdown_all();
+        assert!(result.is_ok());
+        assert_eq!(registry.list().len(), 0);
+    }
+
+    #[test]
+    fn test_document_extractor_shutdown_with_multiple_extractors() {
+        let mut registry = DocumentExtractorRegistry::new();
+
+        let extractor1 = Arc::new(MockExtractor {
+            name: "extractor1".to_string(),
+            mime_types: &["text/plain"],
+            priority: 50,
+        });
+
+        let extractor2 = Arc::new(MockExtractor {
+            name: "extractor2".to_string(),
+            mime_types: &["application/pdf"],
+            priority: 100,
+        });
+
+        let extractor3 = Arc::new(MockExtractor {
+            name: "extractor3".to_string(),
+            mime_types: &["image/png"],
+            priority: 75,
+        });
+
+        registry.register(extractor1).unwrap();
+        registry.register(extractor2).unwrap();
+        registry.register(extractor3).unwrap();
+
+        assert_eq!(registry.list().len(), 3);
+
+        registry.shutdown_all().unwrap();
+        assert_eq!(registry.list().len(), 0);
+    }
+
+    #[test]
+    fn test_document_extractor_priority_ordering_complex() {
+        let mut registry = DocumentExtractorRegistry::new();
+
+        let extractors = vec![
+            (
+                Arc::new(MockExtractor {
+                    name: "priority-1".to_string(),
+                    mime_types: &["application/pdf"],
+                    priority: 1,
+                }),
+                1,
+            ),
+            (
+                Arc::new(MockExtractor {
+                    name: "priority-100".to_string(),
+                    mime_types: &["application/pdf"],
+                    priority: 100,
+                }),
+                100,
+            ),
+            (
+                Arc::new(MockExtractor {
+                    name: "priority-50".to_string(),
+                    mime_types: &["application/pdf"],
+                    priority: 50,
+                }),
+                50,
+            ),
+        ];
+
+        for (extractor, _priority) in &extractors {
+            registry.register(extractor.clone()).unwrap();
+        }
+
+        let retrieved = registry.get("application/pdf").unwrap();
+        assert_eq!(retrieved.name(), "priority-100");
+    }
 }

data/vendor/kreuzberg/src/plugins/registry/ocr.rs

@@ -31,6 +31,8 @@ impl OcrBackendRegistry {
     /// Create a new OCR backend registry with default backends.
     ///
     /// Registers the Tesseract backend by default if the "ocr" feature is enabled.
+    /// Logs warnings if backend initialization fails (common in containerized environments
+    /// with missing dependencies or permission issues).
     pub fn new() -> Self {
         #[cfg(feature = "ocr")]
         let mut registry = Self {
@@ -45,8 +47,27 @@ impl OcrBackendRegistry {
         #[cfg(feature = "ocr")]
         {
             use crate::ocr::tesseract_backend::TesseractBackend;
-            if let Ok(backend) = TesseractBackend::new() {
-                let _ = registry.register(Arc::new(backend));
+            match TesseractBackend::new() {
+                Ok(backend) => {
+                    if let Err(e) = registry.register(Arc::new(backend)) {
+                        tracing::error!(
+                            "Failed to register Tesseract OCR backend: {}. \
+                             OCR functionality will be unavailable. \
+                             Check TESSDATA_PREFIX environment variable and tessdata file permissions.",
+                            e
+                        );
+                    }
+                }
+                Err(e) => {
+                    tracing::warn!(
+                        "Tesseract OCR backend initialization failed: {}. \
+                         OCR functionality will be unavailable. \
+                         Common causes: missing TESSDATA_PREFIX env var, \
+                         tessdata files not found, or permission issues in containerized environments. \
+                         See https://docs.kreuzberg.dev/guides/docker/ for Kubernetes troubleshooting.",
+                        e
+                    );
+                }
             }
         }
 
@@ -290,4 +311,131 @@ mod tests {
         registry.shutdown_all().unwrap();
         assert_eq!(registry.list().len(), 0);
     }
+
+    struct FailingOcrBackend {
+        name: String,
+        fail_on_init: bool,
+    }
+
+    impl Plugin for FailingOcrBackend {
+        fn name(&self) -> &str {
+            &self.name
+        }
+        fn version(&self) -> String {
+            "1.0.0".to_string()
+        }
+        fn initialize(&self) -> Result<()> {
+            if self.fail_on_init {
+                Err(KreuzbergError::Plugin {
+                    message: "Backend initialization failed".to_string(),
+                    plugin_name: self.name.clone(),
+                })
+            } else {
+                Ok(())
+            }
+        }
+        fn shutdown(&self) -> Result<()> {
+            Ok(())
+        }
+    }
+
+    #[async_trait]
+    impl OcrBackend for FailingOcrBackend {
+        async fn process_image(&self, _: &[u8], _: &OcrConfig) -> Result<ExtractionResult> {
+            Ok(ExtractionResult {
+                content: "test".to_string(),
+                mime_type: "text/plain".to_string(),
+                metadata: crate::types::Metadata::default(),
+                tables: vec![],
+                detected_languages: None,
+                chunks: None,
+                images: None,
+                djot_content: None,
+                pages: None,
+                elements: None,
+            })
+        }
+
+        fn supports_language(&self, _lang: &str) -> bool {
+            false
+        }
+
+        fn backend_type(&self) -> crate::plugins::ocr::OcrBackendType {
+            crate::plugins::ocr::OcrBackendType::Custom
+        }
+    }
+
+    #[test]
+    fn test_ocr_backend_initialization_failure_logs_error() {
+        let mut registry = OcrBackendRegistry::new_empty();
+
+        let backend = Arc::new(FailingOcrBackend {
+            name: "failing-ocr".to_string(),
+            fail_on_init: true,
+        });
+
+        let result = registry.register(backend);
+        assert!(result.is_err());
+        assert_eq!(registry.list().len(), 0);
+    }
+
+    #[test]
+    fn test_ocr_backend_invalid_name_empty_logs_warning() {
+        let mut registry = OcrBackendRegistry::new_empty();
+
+        let backend = Arc::new(MockOcrBackend {
+            name: "".to_string(),
+            languages: vec!["eng".to_string()],
+        });
+
+        let result = registry.register(backend);
+        assert!(matches!(result, Err(KreuzbergError::Validation { .. })));
+    }
+
+    #[test]
+    fn test_ocr_backend_invalid_name_with_spaces_logs_warning() {
+        let mut registry = OcrBackendRegistry::new_empty();
+
+        let backend = Arc::new(MockOcrBackend {
+            name: "invalid ocr backend".to_string(),
+            languages: vec!["eng".to_string()],
+        });
+
+        let result = registry.register(backend);
+        assert!(matches!(result, Err(KreuzbergError::Validation { .. })));
+    }
+
+    #[test]
+    fn test_ocr_backend_successful_registration_logs_debug() {
+        let mut registry = OcrBackendRegistry::new_empty();
+
+        let backend = Arc::new(MockOcrBackend {
+            name: "valid-ocr".to_string(),
+            languages: vec!["eng".to_string()],
+        });
+
+        let result = registry.register(backend);
+        assert!(result.is_ok());
+        assert_eq!(registry.list().len(), 1);
+    }
+
+    #[test]
+    fn test_ocr_backend_multiple_registrations() {
+        let mut registry = OcrBackendRegistry::new_empty();
+
+        let backend1 = Arc::new(MockOcrBackend {
+            name: "ocr-backend-1".to_string(),
+            languages: vec!["eng".to_string()],
+        });
+
+        let backend2 = Arc::new(MockOcrBackend {
+            name: "ocr-backend-2".to_string(),
+            languages: vec!["deu".to_string()],
+        });
+
+        registry.register(backend1).unwrap();
+        registry.register(backend2).unwrap();
+
+        assert_eq!(registry.list().len(), 2);
+    }
 }