kreuzberg 4.1.1 → 4.2.0

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

@@ -4,25 +4,72 @@
 
 use crate::{ExtractionConfig, ExtractionResult as KreuzbergResult};
 
+/// Merge extraction configuration using JSON-level merge.
+///
+/// This function performs a JSON-level merge where fields present in the override
+/// JSON take precedence over the base config. This approach correctly handles
+/// boolean fields that are explicitly set to their default values.
+///
+/// # Strategy
+///
+/// 1. Serialize base config to JSON
+/// 2. For each field in the override JSON, merge into base JSON (field-by-field override)
+/// 3. Deserialize merged JSON back to ExtractionConfig
+///
+/// This ensures that explicitly provided values always take precedence, even if
+/// they match the default value. Unspecified fields are preserved from base config.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use kreuzberg::{ExtractionConfig, OutputFormat};
+/// use serde_json::json;
+///
+/// let mut base = ExtractionConfig::default();
+/// base.use_cache = true;
+///
+/// let override_json = json!({
+///     "force_ocr": true,
+/// });
+///
+/// let merged = merge_configs(&base, &override_json).unwrap();
+/// assert_eq!(merged.use_cache, true);  // from base
+/// assert_eq!(merged.force_ocr, true);  // from override
+/// ```
+fn merge_configs(base: &ExtractionConfig, override_json: serde_json::Value) -> Result<ExtractionConfig, String> {
+    // Serialize base config to JSON
+    let mut config_json =
+        serde_json::to_value(base).map_err(|e| format!("Failed to serialize base config to JSON: {}", e))?;
+
+    // Merge JSON value into config JSON (simple field-by-field merge)
+    // For each key in the provided JSON, override the corresponding key in config JSON
+    if let serde_json::Value::Object(json_obj) = override_json
+        && let Some(config_obj) = config_json.as_object_mut()
+    {
+        for (key, value) in json_obj {
+            config_obj.insert(key, value);
+        }
+    }
+
+    // Deserialize merged JSON back to ExtractionConfig
+    serde_json::from_value(config_json).map_err(|e| format!("Failed to deserialize merged config: {}", e))
+}
+
 /// Build extraction config from MCP parameters.
 ///
-/// Starts with the default config and overlays OCR settings from request parameters.
-pub(super) 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,
-            output_format: None,
-        })
+/// Merges the provided config JSON (if any) with the default config using JSON-level
+/// merge semantics. Unspecified fields in the JSON preserve their values from the default config.
+pub(super) fn build_config(
+    default_config: &ExtractionConfig,
+    config_json: Option<serde_json::Value>,
+) -> Result<ExtractionConfig, String> {
+    if let Some(json) = config_json {
+        // Merge using JSON-level merge: provided JSON fields override default config
+        merge_configs(default_config, json)
     } else {
-        None
-    };
-    config.force_ocr = force_ocr;
-
-    config
+        // No config provided, use default
+        Ok(default_config.clone())
+    }
 }
 
 /// Format extraction result as human-readable text.
@@ -54,20 +101,35 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_build_config() {
+    fn test_build_config_with_no_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, None).unwrap();
+        assert_eq!(config.use_cache, default_config.use_cache);
+    }
+
+    #[test]
+    fn test_build_config_with_config_json() {
+        let default_config = ExtractionConfig::default();
+        let config_json = serde_json::json!({
+            "use_cache": false
+        });
 
-        let config = build_config(&default_config, true, false);
-        assert!(config.ocr.is_some());
-        assert!(!config.force_ocr);
+        let config = build_config(&default_config, Some(config_json)).unwrap();
+        assert!(!config.use_cache);
+    }
 
-        let config = build_config(&default_config, true, true);
-        assert!(config.ocr.is_some());
-        assert!(config.force_ocr);
+    #[test]
+    fn test_build_config_with_invalid_config_json() {
+        let default_config = ExtractionConfig::default();
+        // Provide invalid type for a field (string instead of boolean)
+        let config_json = serde_json::json!({
+            "use_cache": "not_a_boolean"
+        });
+
+        let result = build_config(&default_config, Some(config_json));
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("Failed to deserialize"));
     }
 
     #[test]
@@ -77,31 +139,167 @@ mod tests {
             ..Default::default()
         };
 
-        let config = build_config(&default_config, false, false);
+        let config = build_config(&default_config, None).unwrap();
 
         assert!(!config.use_cache);
     }
 
     #[test]
-    fn test_build_config_ocr_disabled_by_default() {
-        let default_config = ExtractionConfig::default();
+    fn test_build_config_overrides_default_settings() {
+        let default_config = ExtractionConfig {
+            use_cache: true,
+            ..Default::default()
+        };
 
-        let config = build_config(&default_config, false, false);
+        let config_json = serde_json::json!({
+            "use_cache": false
+        });
 
-        assert!(config.ocr.is_none());
-        assert!(!config.force_ocr);
+        let config = build_config(&default_config, Some(config_json)).unwrap();
+        assert!(!config.use_cache);
     }
 
     #[test]
-    fn test_build_config_ocr_enabled_creates_tesseract_config() {
-        let default_config = ExtractionConfig::default();
+    fn test_build_config_merges_partial_config() {
+        // Base config with custom use_cache setting
+        let default_config = ExtractionConfig {
+            use_cache: false,
+            enable_quality_processing: true,
+            force_ocr: false,
+            ..Default::default()
+        };
+
+        // Override only force_ocr
+        let config_json = serde_json::json!({
+            "force_ocr": true
+        });
+
+        let config = build_config(&default_config, Some(config_json)).unwrap();
+
+        // use_cache should be preserved from default_config
+        assert!(!config.use_cache, "use_cache should be preserved from default config");
+        // enable_quality_processing should be preserved
+        assert!(
+            config.enable_quality_processing,
+            "enable_quality_processing should be preserved"
+        );
+        // force_ocr should be overridden
+        assert!(config.force_ocr, "force_ocr should be overridden to true");
+    }
+
+    #[test]
+    fn test_build_config_merges_nested_config() {
+        let default_config = ExtractionConfig {
+            use_cache: true,
+            ..Default::default()
+        };
+
+        // Override output format only
+        let config_json = serde_json::json!({
+            "output_format": "markdown"
+        });
+
+        let config = build_config(&default_config, Some(config_json)).unwrap();
+
+        // use_cache should be preserved
+        assert!(config.use_cache, "use_cache should be preserved from default config");
+        // output_format should be overridden
+        assert_eq!(
+            config.output_format,
+            crate::core::config::formats::OutputFormat::Markdown,
+            "output_format should be overridden to markdown"
+        );
+    }
+
+    #[test]
+    fn test_build_config_merges_with_custom_defaults() {
+        // Create a default config with custom values
+        let default_config = ExtractionConfig {
+            use_cache: false,
+            enable_quality_processing: true,
+            force_ocr: false,
+            ..Default::default()
+        };
+
+        // Provide partial override (only force_ocr)
+        let config_json = serde_json::json!({
+            "force_ocr": true,
+        });
+
+        let config = build_config(&default_config, Some(config_json)).unwrap();
+
+        // force_ocr should be overridden
+        assert!(config.force_ocr, "force_ocr should be overridden to true");
+        // use_cache should be preserved from default_config
+        assert!(
+            !config.use_cache,
+            "use_cache should be preserved from default config (false)"
+        );
+        // enable_quality_processing should be preserved
+        assert!(
+            config.enable_quality_processing,
+            "enable_quality_processing should be preserved (true)"
+        );
+    }
+
+    #[test]
+    fn test_build_config_merges_multiple_fields() {
+        let default_config = ExtractionConfig {
+            use_cache: true,
+            enable_quality_processing: false,
+            force_ocr: true,
+            ..Default::default()
+        };
+
+        // Override multiple fields
+        let config_json = serde_json::json!({
+            "use_cache": false,
+            "output_format": "markdown",
+        });
+
+        let config = build_config(&default_config, Some(config_json)).unwrap();
+
+        // use_cache should be overridden
+        assert!(!config.use_cache, "use_cache should be overridden to false");
+        // output_format should be overridden
+        assert_eq!(
+            config.output_format,
+            crate::core::config::formats::OutputFormat::Markdown,
+            "output_format should be overridden to markdown"
+        );
+        // force_ocr should be preserved (not in override)
+        assert!(
+            config.force_ocr,
+            "force_ocr should be preserved from default config (true)"
+        );
+        // enable_quality_processing should be preserved
+        assert!(
+            !config.enable_quality_processing,
+            "enable_quality_processing should be preserved (false)"
+        );
+    }
+
+    #[test]
+    fn test_build_config_boolean_override_to_default_value() {
+        // This test validates the critical bug fix: when user explicitly sets a boolean
+        // to its default value, the merge logic should correctly use the override value,
+        // not fall back to the base config.
+        let base = ExtractionConfig {
+            use_cache: false,
+            ..Default::default()
+        };
+
+        // User explicitly provides use_cache: true (which IS the default)
+        let override_json = serde_json::json!({"use_cache": true});
 
-        let config = build_config(&default_config, true, false);
+        let merged = build_config(&base, Some(override_json)).unwrap();
 
-        assert!(config.ocr.is_some());
-        let ocr_config = config.ocr.unwrap();
-        assert_eq!(ocr_config.backend, "tesseract");
-        assert_eq!(ocr_config.language, "eng");
+        // Before the fix: merged.use_cache would be false (WRONG - fell back to base)
+        // After the fix: merged.use_cache should be true (CORRECT - override applied)
+        assert!(
+            merged.use_cache,
+            "Should use explicit override even if it matches default"
+        );
     }
 
     #[test]

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

@@ -12,12 +12,9 @@ pub struct ExtractFileParams {
     /// 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,
+    /// Extraction configuration (JSON object)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub config: Option<serde_json::Value>,
     /// Use async extraction (default: false for sync)
     #[serde(default)]
     pub r#async: bool,
@@ -31,12 +28,9 @@ pub struct ExtractBytesParams {
     /// 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,
+    /// Extraction configuration (JSON object)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub config: Option<serde_json::Value>,
     /// Use async extraction (default: false for sync)
     #[serde(default)]
     pub r#async: bool,
@@ -47,12 +41,9 @@ pub struct ExtractBytesParams {
 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,
+    /// Extraction configuration (JSON object)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub config: Option<serde_json::Value>,
     /// Use async extraction (default: false for sync)
     #[serde(default)]
     pub r#async: bool,
@@ -83,8 +74,7 @@ mod tests {
 
         assert_eq!(params.path, "/test.pdf");
         assert_eq!(params.mime_type, None);
-        assert!(!params.enable_ocr);
-        assert!(!params.force_ocr);
+        assert_eq!(params.config, None);
         assert!(!params.r#async);
     }
 
@@ -95,8 +85,7 @@ mod tests {
 
         assert_eq!(params.data, "SGVsbG8=");
         assert_eq!(params.mime_type, None);
-        assert!(!params.enable_ocr);
-        assert!(!params.force_ocr);
+        assert_eq!(params.config, None);
         assert!(!params.r#async);
     }
 
@@ -106,8 +95,7 @@ mod tests {
         let params: BatchExtractFilesParams = serde_json::from_str(json).unwrap();
 
         assert_eq!(params.paths.len(), 2);
-        assert!(!params.enable_ocr);
-        assert!(!params.force_ocr);
+        assert_eq!(params.config, None);
         assert!(!params.r#async);
     }
 
@@ -128,13 +116,21 @@ mod tests {
         assert!(!params.use_content);
     }
 
+    #[test]
+    fn test_extract_file_params_with_config() {
+        let json = r#"{"path": "/test.pdf", "config": {"use_cache": false}}"#;
+        let params: ExtractFileParams = serde_json::from_str(json).unwrap();
+
+        assert_eq!(params.path, "/test.pdf");
+        assert!(params.config.is_some());
+    }
+
     #[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,
+            config: Some(serde_json::json!({"use_cache": false})),
             r#async: true,
         };
 
@@ -143,8 +139,7 @@ mod tests {
 
         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.config, deserialized.config);
         assert_eq!(params.r#async, deserialized.r#async);
     }
 
@@ -153,8 +148,7 @@ mod tests {
         let params = ExtractBytesParams {
             data: "SGVsbG8=".to_string(),
             mime_type: None,
-            enable_ocr: false,
-            force_ocr: false,
+            config: None,
             r#async: false,
         };
 
@@ -168,8 +162,7 @@ mod tests {
     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,
+            config: Some(serde_json::json!({"use_cache": true})),
             r#async: true,
         };
 
@@ -177,7 +170,7 @@ mod tests {
         let deserialized: BatchExtractFilesParams = serde_json::from_str(&json).unwrap();
 
         assert_eq!(params.paths, deserialized.paths);
-        assert_eq!(params.enable_ocr, deserialized.enable_ocr);
+        assert_eq!(params.config, deserialized.config);
     }
 
     #[test]

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,
             };