kreuzberg 4.1.2 → 4.2.1

data/vendor/kreuzberg/README.md

@@ -17,7 +17,7 @@ High-performance document intelligence library for Rust. Extract text, metadata,
 
 This is the core Rust library that powers the Python, TypeScript, and Ruby bindings.
 
-> **🚀 Version 4.1.2 Release**
+> **🚀 Version 4.2.1 Release**
 > This is a pre-release version. We invite you to test the library and [report any issues](https://github.com/kreuzberg-dev/kreuzberg/issues) you encounter.
 >
 > **Note**: The Rust crate is not currently published to crates.io for this RC. Use git dependencies or language bindings (Python, TypeScript, Ruby) instead.

data/vendor/kreuzberg/src/api/startup.rs

@@ -2,7 +2,7 @@
 
 use std::net::{IpAddr, SocketAddr};
 
-use crate::{ExtractionConfig, Result, core::ServerConfig};
+use crate::{ExtractionConfig, Result, core::ServerConfig, plugins::startup_validation::validate_plugins_at_startup};
 
 use super::{config::load_server_config, router::create_router_with_limits_and_server_config, types::ApiSizeLimits};
 
@@ -80,6 +80,9 @@ pub async fn serve(host: impl AsRef<str>, port: u16) -> Result<()> {
         server_config.max_multipart_field_bytes,
     );
 
+    // Validate plugins at startup
+    validate_plugins_at_startup()?;
+
     serve_with_config_and_limits(host, port, extraction_config, limits).await
 }
 
@@ -111,6 +114,10 @@ pub async fn serve_with_config(host: impl AsRef<str>, port: u16, config: Extract
         "Upload size limit: 100 MB (default, {} bytes)",
         limits.max_request_body_bytes
     );
+
+    // Validate plugins at startup
+    validate_plugins_at_startup()?;
+
     serve_with_config_and_limits(host, port, config, limits).await
 }
 
@@ -158,6 +165,9 @@ pub async fn serve_with_config_and_limits(
     let addr = SocketAddr::new(ip, port);
     let app = create_router_with_limits_and_server_config(config, limits, server_config);
 
+    // Validate plugins at startup
+    validate_plugins_at_startup()?;
+
     tracing::info!("Starting Kreuzberg API server on http://{}:{}", ip, port);
 
     let listener = tokio::net::TcpListener::bind(addr)
@@ -214,6 +224,9 @@ pub async fn serve_with_server_config(extraction_config: ExtractionConfig, serve
     let addr = SocketAddr::new(ip, server_config.port);
     let app = create_router_with_limits_and_server_config(extraction_config, limits, server_config.clone());
 
+    // Validate plugins at startup
+    validate_plugins_at_startup()?;
+
     tracing::info!(
         "Starting Kreuzberg API server on http://{}:{} (request_body_limit={} MB, multipart_field_limit={} MB)",
         ip,
@@ -238,6 +251,7 @@ pub async fn serve_with_server_config(extraction_config: ExtractionConfig, serve
 /// Defaults: host = "127.0.0.1", port = 8000
 ///
 /// Uses config file discovery (searches current/parent directories for kreuzberg.toml/yaml/json).
+/// Validates plugins at startup to help diagnose configuration issues.
 pub async fn serve_default() -> Result<()> {
     serve("127.0.0.1", 8000).await
 }

data/vendor/kreuzberg/src/core/config_validation/sections.rs

@@ -30,8 +30,10 @@ const VALID_TESSERACT_PSM: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
 /// Valid tesseract OEM (OCR Engine Mode) values.
 const VALID_TESSERACT_OEM: &[i32] = &[0, 1, 2, 3];
 
-/// Valid output formats for tesseract.
-const VALID_OUTPUT_FORMATS: &[&str] = &["text", "markdown"];
+/// Valid output formats for document extraction.
+/// Supports plain text, markdown, djot, and HTML output formats.
+/// Also accepts aliases: "text" for "plain", "md" for "markdown".
+const VALID_OUTPUT_FORMATS: &[&str] = &["plain", "text", "markdown", "md", "djot", "html"];
 
 /// Validate a binarization method string.
 ///
@@ -248,11 +250,17 @@ pub fn validate_tesseract_oem(oem: i32) -> Result<()> {
     }
 }
 
-/// Validate a tesseract output format.
+/// Validate a document extraction output format.
+///
+/// Accepts the following formats and aliases:
+/// - "plain" or "text" for plain text output
+/// - "markdown" or "md" for Markdown output
+/// - "djot" for Djot markup format
+/// - "html" for HTML output
 ///
 /// # Arguments
 ///
-/// * `format` - The output format to validate (e.g., "text", "markdown")
+/// * `format` - The output format to validate
 ///
 /// # Returns
 ///
@@ -264,7 +272,11 @@ pub fn validate_tesseract_oem(oem: i32) -> Result<()> {
 /// use kreuzberg::core::config_validation::validate_output_format;
 ///
 /// assert!(validate_output_format("text").is_ok());
+/// assert!(validate_output_format("plain").is_ok());
 /// assert!(validate_output_format("markdown").is_ok());
+/// assert!(validate_output_format("md").is_ok());
+/// assert!(validate_output_format("djot").is_ok());
+/// assert!(validate_output_format("html").is_ok());
 /// assert!(validate_output_format("json").is_err());
 /// ```
 pub fn validate_output_format(format: &str) -> Result<()> {

data/vendor/kreuzberg/src/core/extractor/file.rs

@@ -106,9 +106,8 @@ pub(in crate::core::extractor) fn record_error(error: &KreuzbergError) {
 ///
 /// # Errors
 ///
-/// Returns `KreuzbergError::Validation` if the file doesn't exist or path is invalid.
+/// Returns `KreuzbergError::Io` if the file doesn't exist (NotFound) or for other file I/O errors.
 /// Returns `KreuzbergError::UnsupportedFormat` if MIME type is not supported.
-/// Returns `KreuzbergError::Io` for file I/O errors (these always bubble up).
 ///
 /// # Example
 ///

data/vendor/kreuzberg/src/core/extractor/mod.rs

@@ -411,7 +411,8 @@ mod tests {
 
         assert!(result.is_err());
         use crate::KreuzbergError;
-        assert!(matches!(result.unwrap_err(), KreuzbergError::Validation { .. }));
+        // File validation returns Io error, not Validation error
+        assert!(matches!(result.unwrap_err(), KreuzbergError::Io { .. }));
     }
 
     #[test]

data/vendor/kreuzberg/src/core/io.rs

@@ -61,12 +61,12 @@ pub fn file_exists(path: impl AsRef<Path>) -> bool {
 ///
 /// # Errors
 ///
-/// Returns `KreuzbergError::Validation` if file doesn't exist.
+/// Returns `KreuzbergError::Io` if file doesn't exist.
 pub fn validate_file_exists(path: impl AsRef<Path>) -> Result<()> {
     if !file_exists(&path) {
-        return Err(KreuzbergError::validation(format!(
-            "File does not exist: {}",
-            path.as_ref().display()
+        return Err(KreuzbergError::from(std::io::Error::new(
+            std::io::ErrorKind::NotFound,
+            format!("File does not exist: {}", path.as_ref().display()),
         )));
     }
     Ok(())
@@ -99,9 +99,9 @@ where
     let mut files = Vec::new();
 
     if !dir.is_dir() {
-        return Err(KreuzbergError::validation(format!(
-            "Path is not a directory: {}",
-            dir.display()
+        return Err(KreuzbergError::from(std::io::Error::new(
+            std::io::ErrorKind::NotADirectory,
+            format!("Path is not a directory: {}", dir.display()),
         )));
     }
 

data/vendor/kreuzberg/src/core/mime.rs

@@ -231,15 +231,15 @@ static SUPPORTED_MIME_TYPES: Lazy<HashSet<&'static str>> = Lazy::new(|| {
 ///
 /// # Errors
 ///
-/// Returns `KreuzbergError::Validation` if file doesn't exist (when `check_exists` is true).
+/// Returns `KreuzbergError::Io` if file doesn't exist (when `check_exists` is true).
 /// Returns `KreuzbergError::UnsupportedFormat` if MIME type cannot be determined.
 pub fn detect_mime_type(path: impl AsRef<Path>, check_exists: bool) -> Result<String> {
     let path = path.as_ref();
 
     if check_exists && !path.exists() {
-        return Err(KreuzbergError::validation(format!(
-            "File does not exist: {}",
-            path.display()
+        return Err(KreuzbergError::from(std::io::Error::new(
+            std::io::ErrorKind::NotFound,
+            format!("File does not exist: {}", path.display()),
         )));
     }
 

data/vendor/kreuzberg/src/embeddings.rs

@@ -219,10 +219,10 @@ pub fn get_or_init_model(
         // This prevents panics that cannot unwind through FFI boundaries
         fn ensure_onnx_available() -> Result<(), String> {
             // Check if ORT_DYLIB_PATH is already set and valid
-            if let Ok(path) = std::env::var("ORT_DYLIB_PATH") {
-                if std::path::Path::new(&path).exists() {
-                    return Ok(());
-                }
+            if let Ok(path) = std::env::var("ORT_DYLIB_PATH")
+                && std::path::Path::new(&path).exists()
+            {
+                return Ok(());
             }
 
             // Check common installation paths and set ORT_DYLIB_PATH if found

data/vendor/kreuzberg/src/extraction/pptx/parser.rs

@@ -384,5 +384,11 @@ pub(super) fn parse_presentation_rels(rels_data: &[u8]) -> Result<Vec<String>> {
         }
     }
 
+    // Sort slide paths to ensure correct ordering regardless of XML order.
+    // PowerPoint doesn't guarantee relationship order in the rels file.
+    // GitHub Issue #329: Without sorting, slides can be processed in wrong order,
+    // causing images to have incorrect page numbers.
+    slide_paths.sort();
+
     Ok(slide_paths)
 }

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]