kreuzberg 4.2.1 → 4.2.3

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

@@ -109,19 +109,41 @@ impl ApiSizeLimits {
     }
 }
 
+/// Plugin status information in health response.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
+pub struct PluginStatus {
+    /// Number of registered OCR backends
+    pub ocr_backends_count: usize,
+    /// Names of registered OCR backends
+    pub ocr_backends: Vec<String>,
+    /// Number of registered document extractors
+    pub extractors_count: usize,
+    /// Number of registered post-processors
+    pub post_processors_count: usize,
+}
+
 /// Health check response.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct HealthResponse {
     /// Health status
+    #[cfg_attr(feature = "api", schema(example = "healthy"))]
     pub status: String,
     /// API version
+    #[cfg_attr(feature = "api", schema(example = "0.8.0"))]
     pub version: String,
+    /// Plugin status (optional)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub plugins: Option<PluginStatus>,
 }
 
 /// Server information response.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct InfoResponse {
     /// API version
+    #[cfg_attr(feature = "api", schema(example = "0.8.0"))]
     pub version: String,
     /// Whether using Rust backend
     pub rust_backend: bool,
@@ -132,15 +154,19 @@ pub type ExtractResponse = Vec<ExtractionResult>;
 
 /// Error response.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct ErrorResponse {
     /// Error type name
+    #[cfg_attr(feature = "api", schema(example = "ValidationError"))]
     pub error_type: String,
     /// Error message
+    #[cfg_attr(feature = "api", schema(example = "Invalid input provided"))]
     pub message: String,
     /// Stack trace (if available)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub traceback: Option<String>,
     /// HTTP status code
+    #[cfg_attr(feature = "api", schema(example = 400))]
     pub status_code: u16,
 }
 
@@ -156,8 +182,10 @@ pub struct ApiState {
 
 /// Cache statistics response.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct CacheStatsResponse {
     /// Cache directory path
+    #[cfg_attr(feature = "api", schema(example = "/tmp/kreuzberg-cache"))]
     pub directory: String,
     /// Total number of cache files
     pub total_files: usize,
@@ -173,8 +201,10 @@ pub struct CacheStatsResponse {
 
 /// Cache clear response.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct CacheClearResponse {
     /// Cache directory path
+    #[cfg_attr(feature = "api", schema(example = "/tmp/kreuzberg-cache"))]
     pub directory: String,
     /// Number of files removed
     pub removed_files: usize,
@@ -184,20 +214,25 @@ pub struct CacheClearResponse {
 
 /// Embedding request for generating embeddings from text.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct EmbedRequest {
-    /// Text strings to generate embeddings for
+    /// Text strings to generate embeddings for (at least one non-empty string required)
+    #[cfg_attr(feature = "api", schema(min_items = 1))]
     pub texts: Vec<String>,
     /// Optional embedding configuration (model, batch size, etc.)
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[cfg_attr(feature = "api", schema(value_type = Option<Object>))]
     pub config: Option<crate::core::config::EmbeddingConfig>,
 }
 
 /// Embedding response containing generated embeddings.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct EmbedResponse {
     /// Generated embeddings (one per input text)
     pub embeddings: Vec<Vec<f32>>,
     /// Model used for embedding generation
+    #[cfg_attr(feature = "api", schema(example = "all-MiniLM-L6-v2"))]
     pub model: String,
     /// Dimensionality of the embeddings
     pub dimensions: usize,
@@ -212,23 +247,29 @@ fn default_chunker_type() -> String {
 
 /// Chunk request with text and configuration.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct ChunkRequest {
-    /// Text to chunk
+    /// Text to chunk (must not be empty)
+    #[cfg_attr(feature = "api", schema(example = "This is sample text to chunk.", min_length = 1))]
     pub text: String,
     /// Optional chunking configuration
     #[serde(skip_serializing_if = "Option::is_none")]
     pub config: Option<ChunkingConfigRequest>,
     /// Chunker type (text or markdown)
     #[serde(default = "default_chunker_type")]
+    #[cfg_attr(feature = "api", schema(example = "text", pattern = "^(text|markdown)$"))]
     pub chunker_type: String,
 }
 
 /// Chunking configuration request.
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct ChunkingConfigRequest {
-    /// Maximum characters per chunk
+    /// Maximum characters per chunk (must be greater than overlap, default: 2000)
+    #[cfg_attr(feature = "api", schema(minimum = 101, example = 2000))]
     pub max_characters: Option<usize>,
-    /// Overlap between chunks in characters
+    /// Overlap between chunks in characters (must be less than max_characters, default: 100)
+    #[cfg_attr(feature = "api", schema(minimum = 0, maximum = 1999, example = 100))]
     pub overlap: Option<usize>,
     /// Whether to trim whitespace
     pub trim: Option<bool>,
@@ -236,6 +277,7 @@ pub struct ChunkingConfigRequest {
 
 /// Chunk response with chunks and metadata.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct ChunkResponse {
     /// List of chunks
     pub chunks: Vec<ChunkItem>,
@@ -246,11 +288,13 @@ pub struct ChunkResponse {
     /// Input text size in bytes
     pub input_size_bytes: usize,
     /// Chunker type used for chunking
+    #[cfg_attr(feature = "api", schema(example = "text"))]
     pub chunker_type: String,
 }
 
 /// Individual chunk item with metadata.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct ChunkItem {
     /// Chunk content
     pub content: String,
@@ -272,6 +316,7 @@ pub struct ChunkItem {
 
 /// Chunking configuration response.
 #[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(feature = "api", derive(utoipa::ToSchema))]
 pub struct ChunkingConfigResponse {
     /// Maximum characters per chunk
     pub max_characters: usize,
@@ -280,5 +325,6 @@ pub struct ChunkingConfigResponse {
     /// Whether whitespace was trimmed
     pub trim: bool,
     /// Type of chunker used
+    #[cfg_attr(feature = "api", schema(example = "text"))]
     pub chunker_type: String,
 }

data/vendor/kreuzberg/src/core/config/processing.rs

@@ -84,7 +84,8 @@ pub struct ChunkingConfig {
 /// Requires the `embeddings` feature to be enabled.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct EmbeddingConfig {
-    /// The embedding model to use
+    /// The embedding model to use (defaults to "balanced" preset if not specified)
+    #[serde(default = "default_model")]
     pub model: EmbeddingModelType,
 
     /// Whether to normalize embedding vectors (recommended for cosine similarity)
@@ -156,6 +157,12 @@ fn default_batch_size() -> usize {
     32
 }
 
+fn default_model() -> EmbeddingModelType {
+    EmbeddingModelType::Preset {
+        name: "balanced".to_string(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

data/vendor/kreuzberg/src/extraction/excel.rs

@@ -27,16 +27,23 @@
 //! # Ok(())
 //! # }
 //! ```
-use calamine::{Data, Range, Reader, open_workbook_auto};
+use calamine::{Data, DataRef, Range, Reader, open_workbook_auto};
 use std::collections::HashMap;
 use std::fmt::Write as FmtWrite;
-use std::io::Cursor;
+use std::io::{Cursor, Read, Seek};
 use std::path::Path;
 
 use crate::error::{KreuzbergError, Result};
 use crate::extraction::capacity;
 use crate::types::{ExcelSheet, ExcelWorkbook};
 
+/// Maximum number of cells in a Range's bounding box before we consider it pathological.
+/// This threshold is set to prevent OOM when processing files with sparse data at extreme
+/// positions (e.g., Excel Solver files that have cells at A1 and XFD1048575).
+///
+/// 100 million cells at ~64 bytes each = ~6.4 GB, which is a reasonable upper limit.
+const MAX_BOUNDING_BOX_CELLS: u64 = 100_000_000;
+
 #[cfg(feature = "office")]
 use crate::extraction::office_metadata::{
     extract_core_properties, extract_custom_properties, extract_xlsx_app_properties,
@@ -45,11 +52,13 @@ use crate::extraction::office_metadata::{
 use serde_json::Value;
 
 pub fn read_excel_file(file_path: &str) -> Result<ExcelWorkbook> {
+    let lower_path = file_path.to_lowercase();
+
     #[cfg(feature = "office")]
-    let office_metadata = if file_path.to_lowercase().ends_with(".xlsx")
-        || file_path.to_lowercase().ends_with(".xlsm")
-        || file_path.to_lowercase().ends_with(".xlam")
-        || file_path.to_lowercase().ends_with(".xltm")
+    let office_metadata = if lower_path.ends_with(".xlsx")
+        || lower_path.ends_with(".xlsm")
+        || lower_path.ends_with(".xlam")
+        || lower_path.ends_with(".xltm")
     {
         extract_xlsx_office_metadata_from_file(file_path).ok()
     } else {
@@ -59,7 +68,19 @@ pub fn read_excel_file(file_path: &str) -> Result<ExcelWorkbook> {
     #[cfg(not(feature = "office"))]
     let office_metadata: Option<HashMap<String, String>> = None;
 
-    // We analyze the error and only wrap format errors, letting real IO errors bubble up ~keep
+    // For XLSX files, use specialized handler with OOM protection
+    if lower_path.ends_with(".xlsx")
+        || lower_path.ends_with(".xlsm")
+        || lower_path.ends_with(".xlam")
+        || lower_path.ends_with(".xltm")
+    {
+        let file = std::fs::File::open(file_path)?;
+        let workbook = calamine::Xlsx::new(std::io::BufReader::new(file))
+            .map_err(|e| KreuzbergError::parsing(format!("Failed to parse XLSX: {}", e)))?;
+        return process_xlsx_workbook(workbook, office_metadata);
+    }
+
+    // For other formats, use open_workbook_auto
     let workbook = match open_workbook_auto(Path::new(file_path)) {
         Ok(wb) => wb,
         Err(calamine::Error::Io(io_err)) => {
@@ -94,7 +115,7 @@ pub fn read_excel_bytes(data: &[u8], file_extension: &str) -> Result<ExcelWorkbo
         ".xlsx" | ".xlsm" | ".xlam" | ".xltm" => {
             let workbook = calamine::Xlsx::new(cursor)
                 .map_err(|e| KreuzbergError::parsing(format!("Failed to parse XLSX: {}", e)))?;
-            process_workbook(workbook, office_metadata)
+            process_xlsx_workbook(workbook, office_metadata)
         }
         ".xls" | ".xla" => {
             let workbook = calamine::Xls::new(cursor)
@@ -118,6 +139,194 @@ pub fn read_excel_bytes(data: &[u8], file_extension: &str) -> Result<ExcelWorkbo
     }
 }
 
+/// Process XLSX workbooks with special handling for pathological sparse files.
+///
+/// This function uses calamine's `worksheet_cells_reader()` API to detect sheets with
+/// extreme bounding boxes BEFORE allocating memory for the full Range. This prevents
+/// OOM when processing files like Excel Solver files that have cells at both A1 and
+/// XFD1048575, creating a bounding box of ~17 billion cells.
+fn process_xlsx_workbook<RS: Read + Seek>(
+    mut workbook: calamine::Xlsx<RS>,
+    office_metadata: Option<HashMap<String, String>>,
+) -> Result<ExcelWorkbook> {
+    let sheet_names = workbook.sheet_names();
+    let mut sheets = Vec::with_capacity(sheet_names.len());
+
+    for name in &sheet_names {
+        // Use worksheet_cells_reader to stream cells and detect pathological bounding boxes
+        match process_xlsx_sheet_safe(&mut workbook, name) {
+            Ok(sheet) => sheets.push(sheet),
+            Err(e) => {
+                // Log but don't fail - continue with other sheets
+                tracing::warn!("Failed to process sheet '{}': {}", name, e);
+            }
+        }
+    }
+
+    let metadata = extract_metadata(&workbook, &sheet_names, office_metadata);
+    Ok(ExcelWorkbook { sheets, metadata })
+}
+
+/// Process a single XLSX sheet safely by pre-checking the bounding box.
+///
+/// This function streams cells to compute the actual bounding box without allocating
+/// a full Range, then only creates the Range if the bounding box is within safe limits.
+fn process_xlsx_sheet_safe<RS: Read + Seek>(workbook: &mut calamine::Xlsx<RS>, sheet_name: &str) -> Result<ExcelSheet> {
+    // First pass: stream cells to compute actual bounding box and collect cell data
+    let (cells, row_min, row_max, col_min, col_max) = {
+        let mut cell_reader = workbook
+            .worksheet_cells_reader(sheet_name)
+            .map_err(|e| KreuzbergError::parsing(format!("Failed to read sheet '{}': {}", sheet_name, e)))?;
+
+        let mut cells: Vec<((u32, u32), Data)> = Vec::new();
+        let mut row_min = u32::MAX;
+        let mut row_max = 0u32;
+        let mut col_min = u32::MAX;
+        let mut col_max = 0u32;
+
+        // Stream through all cells, tracking bounds
+        while let Ok(Some(cell)) = cell_reader.next_cell() {
+            let (row, col) = cell.get_position();
+            row_min = row_min.min(row);
+            row_max = row_max.max(row);
+            col_min = col_min.min(col);
+            col_max = col_max.max(col);
+
+            // Convert DataRef to owned Data
+            let data: Data = match cell.get_value() {
+                DataRef::Empty => Data::Empty,
+                DataRef::String(s) => Data::String(s.clone()),
+                DataRef::SharedString(s) => Data::String(s.to_string()),
+                DataRef::Float(f) => Data::Float(*f),
+                DataRef::Int(i) => Data::Int(*i),
+                DataRef::Bool(b) => Data::Bool(*b),
+                DataRef::DateTime(dt) => Data::DateTime(*dt),
+                DataRef::DateTimeIso(s) => Data::DateTimeIso(s.clone()),
+                DataRef::DurationIso(s) => Data::DurationIso(s.clone()),
+                DataRef::Error(e) => Data::Error(e.clone()),
+            };
+            cells.push(((row, col), data));
+        }
+        (cells, row_min, row_max, col_min, col_max)
+    }; // cell_reader is dropped here, releasing the borrow
+
+    // Check if sheet is empty
+    if cells.is_empty() {
+        return Ok(ExcelSheet {
+            name: sheet_name.to_owned(),
+            markdown: format!("## {}\n\n*Empty sheet*", sheet_name),
+            row_count: 0,
+            col_count: 0,
+            cell_count: 0,
+            table_cells: None,
+        });
+    }
+
+    // Calculate bounding box size
+    let bb_rows = (row_max - row_min + 1) as u64;
+    let bb_cols = (col_max - col_min + 1) as u64;
+    let bb_cells = bb_rows.saturating_mul(bb_cols);
+
+    // Check for pathological bounding box
+    if bb_cells > MAX_BOUNDING_BOX_CELLS {
+        // Sheet has sparse data at extreme positions - process directly from cells
+        return process_sparse_sheet_from_cells(sheet_name, cells, row_min, row_max, col_min, col_max);
+    }
+
+    // Safe to create a Range - bounding box is within limits
+    // Use calamine's normal worksheet_range which will create the Range
+    let range = workbook
+        .worksheet_range(sheet_name)
+        .map_err(|e| KreuzbergError::parsing(format!("Failed to parse sheet '{}': {}", sheet_name, e)))?;
+
+    Ok(process_sheet(sheet_name, &range))
+}
+
+/// Process a sparse sheet directly from collected cells without creating a full Range.
+///
+/// This is used when the bounding box would exceed MAX_BOUNDING_BOX_CELLS.
+/// Instead of creating a dense Range, we generate markdown directly from the sparse cells.
+fn process_sparse_sheet_from_cells(
+    sheet_name: &str,
+    cells: Vec<((u32, u32), Data)>,
+    row_min: u32,
+    row_max: u32,
+    col_min: u32,
+    col_max: u32,
+) -> Result<ExcelSheet> {
+    let cell_count = cells.len();
+    let bb_rows = (row_max - row_min + 1) as usize;
+    let bb_cols = (col_max - col_min + 1) as usize;
+
+    // Create a warning message about the sparse data
+    let mut markdown = String::with_capacity(500 + cell_count * 50);
+    write!(
+        markdown,
+        "## {}\n\n*Note: Sheet contains sparse data spanning {} rows x {} columns ({} actual cells). \
+         Bounding box too large for dense extraction. Showing actual cell data below.*\n\n",
+        sheet_name, bb_rows, bb_cols, cell_count
+    )
+    .expect("write to String cannot fail");
+
+    // Group cells by row for tabular display
+    let mut cells_by_row: HashMap<u32, Vec<(u32, &Data)>> = HashMap::new();
+    for ((row, col), data) in &cells {
+        cells_by_row.entry(*row).or_default().push((*col, data));
+    }
+
+    // Sort rows and output as simple key-value pairs
+    let mut rows: Vec<_> = cells_by_row.keys().copied().collect();
+    rows.sort_unstable();
+
+    // Limit output to first 1000 cells to avoid huge output
+    let mut output_count = 0;
+    const MAX_OUTPUT_CELLS: usize = 1000;
+
+    for row in rows {
+        if output_count >= MAX_OUTPUT_CELLS {
+            write!(markdown, "\n... ({} more cells not shown)\n", cell_count - output_count)
+                .expect("write to String cannot fail");
+            break;
+        }
+
+        let mut row_cells = cells_by_row.remove(&row).unwrap_or_default();
+        row_cells.sort_by_key(|(col, _)| *col);
+
+        for (col, data) in row_cells {
+            if output_count >= MAX_OUTPUT_CELLS {
+                break;
+            }
+            let cell_ref = col_to_excel_letter(col);
+            let cell_str = format_cell_to_string(data);
+            if !cell_str.is_empty() {
+                writeln!(markdown, "- **{}{}**: {}", cell_ref, row + 1, cell_str).expect("write to String cannot fail");
+                output_count += 1;
+            }
+        }
+    }
+
+    Ok(ExcelSheet {
+        name: sheet_name.to_owned(),
+        markdown,
+        row_count: bb_rows,
+        col_count: bb_cols,
+        cell_count,
+        table_cells: None, // No structured table for sparse sheets
+    })
+}
+
+/// Convert a 0-indexed column number to Excel-style letter(s) (A, B, ..., Z, AA, AB, ...).
+fn col_to_excel_letter(col: u32) -> String {
+    let mut result = String::new();
+    let mut n = col + 1; // 1-indexed for calculation
+    while n > 0 {
+        n -= 1;
+        result.insert(0, (b'A' + (n % 26) as u8) as char);
+        n /= 26;
+    }
+    result
+}
+
 fn process_workbook<RS, R>(mut workbook: R, office_metadata: Option<HashMap<String, String>>) -> Result<ExcelWorkbook>
 where
     RS: std::io::Read + std::io::Seek,
@@ -143,7 +352,10 @@ fn process_sheet(name: &str, range: &Range<Data>) -> ExcelSheet {
     let (rows, cols) = range.get_size();
     let cell_count = range.used_cells().count();
 
-    let estimated_capacity = 50 + (cols * 20) + (rows * cols * 12);
+    // Fix for issue #331: Use actual cell count instead of declared dimensions
+    // to avoid OOM on sparse sheets with extreme dimensions (e.g., Excel Solver files).
+    // Declared dimensions can claim A1:XFD1048575 (~17T cells) while actual data is minimal.
+    let estimated_capacity = 50 + (cols * 20) + (cell_count * 12);
 
     if rows == 0 || cols == 0 {
         let markdown = format!("## {}\n\n*Empty sheet*", name);
@@ -176,6 +388,31 @@ fn process_sheet(name: &str, range: &Range<Data>) -> ExcelSheet {
 ///
 /// Returns (markdown, table_cells) where table_cells is a 2D vector of strings.
 fn generate_markdown_and_cells(sheet_name: &str, range: &Range<Data>, capacity: usize) -> (String, Vec<Vec<String>>) {
+    // Fix for issue #331: Protect against extreme declared dimensions.
+    // Excel Solver files can declare A1:XFD1048575 (1M+ rows) but only have ~26 actual cells.
+    // Calling range.rows().collect() would iterate ALL declared rows causing OOM.
+    const MAX_REASONABLE_ROWS: usize = 100_000; // Cap at 100K rows for safety
+
+    let (declared_rows, _declared_cols) = range.get_size();
+
+    // If declared rows exceed reasonable limit, skip processing to avoid OOM
+    if declared_rows > MAX_REASONABLE_ROWS {
+        let actual_cell_count = range.used_cells().count();
+
+        // If actual data is minimal compared to declared size, it's a sparse/pathological file
+        if actual_cell_count < 10_000 {
+            // Return minimal output instead of OOM
+            let result_capacity = 100 + sheet_name.len();
+            let mut result = String::with_capacity(result_capacity);
+            write!(
+                result,
+                "## {}\n\n*Sheet has extreme declared dimensions ({} rows) with minimal actual data ({} cells). Skipping to prevent OOM.*",
+                sheet_name, declared_rows, actual_cell_count
+            ).unwrap();
+            return (result, Vec::new());
+        }
+    }
+
     let rows: Vec<_> = range.rows().collect();
     if rows.is_empty() {
         let result_capacity = 50 + sheet_name.len();

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

@@ -72,28 +72,12 @@ pub(super) fn build_config(
     }
 }
 
-/// Format extraction result as human-readable text.
+/// Format extraction result as JSON string.
+///
+/// Serializes the full `ExtractionResult` to JSON, ensuring 1:1 parity
+/// with the API and CLI JSON output.
 pub(super) 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
+    serde_json::to_string_pretty(result).unwrap_or_default()
 }
 
 #[cfg(test)]
@@ -303,7 +287,7 @@ mod tests {
     }
 
     #[test]
-    fn test_format_extraction_result_with_content() {
+    fn test_format_extraction_result_is_valid_json() {
         let result = KreuzbergResult {
             content: "Sample extracted text".to_string(),
             mime_type: "text/plain".to_string(),
@@ -318,36 +302,27 @@ mod tests {
         };
 
         let formatted = format_extraction_result(&result);
+        let parsed: serde_json::Value = serde_json::from_str(&formatted).expect("Should be valid JSON");
 
-        assert!(formatted.contains("Content (21 characters)"));
-        assert!(formatted.contains("Sample extracted text"));
-        assert!(formatted.contains("Metadata:"));
+        assert_eq!(parsed["content"], "Sample extracted text");
+        assert_eq!(parsed["mime_type"], "text/plain");
+        assert!(parsed["metadata"].is_object());
     }
 
     #[test]
-    fn test_format_extraction_result_with_tables() {
+    fn test_format_extraction_result_includes_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(),
-                },
-            ],
+            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(),
+            }],
             detected_languages: None,
             chunks: None,
             images: None,
@@ -357,23 +332,33 @@ mod tests {
         };
 
         let formatted = format_extraction_result(&result);
+        let parsed: serde_json::Value = serde_json::from_str(&formatted).expect("Should be valid JSON");
 
-        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 |"));
+        assert_eq!(parsed["tables"].as_array().unwrap().len(), 1);
+        assert_eq!(parsed["tables"][0]["page_number"], 1);
     }
 
     #[test]
-    fn test_format_extraction_result_empty_content() {
+    fn test_format_extraction_result_includes_chunks_when_present() {
         let result = KreuzbergResult {
-            content: String::new(),
+            content: "Chunked text".to_string(),
             mime_type: "text/plain".to_string(),
             metadata: crate::Metadata::default(),
             tables: vec![],
             detected_languages: None,
-            chunks: None,
+            chunks: Some(vec![crate::Chunk {
+                content: "Chunk 1".to_string(),
+                embedding: None,
+                metadata: crate::ChunkMetadata {
+                    byte_start: 0,
+                    byte_end: 7,
+                    token_count: None,
+                    chunk_index: 0,
+                    total_chunks: 1,
+                    first_page: None,
+                    last_page: None,
+                },
+            }]),
             images: None,
             pages: None,
             elements: None,
@@ -381,13 +366,14 @@ mod tests {
         };
 
         let formatted = format_extraction_result(&result);
+        let parsed: serde_json::Value = serde_json::from_str(&formatted).expect("Should be valid JSON");
 
-        assert!(formatted.contains("Content (0 characters)"));
-        assert!(formatted.contains("Metadata:"));
+        assert_eq!(parsed["chunks"].as_array().unwrap().len(), 1);
+        assert_eq!(parsed["chunks"][0]["content"], "Chunk 1");
     }
 
     #[test]
-    fn test_format_extraction_result_no_tables() {
+    fn test_format_extraction_result_omits_none_fields() {
         let result = KreuzbergResult {
             content: "Simple text".to_string(),
             mime_type: "text/plain".to_string(),
@@ -402,8 +388,11 @@ mod tests {
         };
 
         let formatted = format_extraction_result(&result);
+        let parsed: serde_json::Value = serde_json::from_str(&formatted).expect("Should be valid JSON");
 
-        assert!(formatted.contains("Simple text"));
-        assert!(!formatted.contains("Tables"));
+        // None fields should be omitted via skip_serializing_if
+        assert!(parsed.get("chunks").is_none());
+        assert!(parsed.get("images").is_none());
+        assert!(parsed.get("detected_languages").is_none());
     }
 }