Add src directory

src/__init__.py

@@ -0,0 +1 @@
+

src/agents/__init__.py

@@ -0,0 +1 @@
+

src/agents/annotation_agent.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from pathlib import Path
+import fitz
+from src.core.models import PDFOperation
+
+class OfflineAnnotationAgent:
+    name = "annotation_agent"
+
+    def run(self, input_pdf: Path, output_pdf: Path, operations: list[PDFOperation]) -> Path:
+        doc = fitz.open(input_pdf)
+        for op in operations:
+            if op.page is None or op.page >= len(doc): continue
+            page = doc[op.page]
+            rect = fitz.Rect(op.rect) if op.rect else None
+            color = tuple(op.color) if op.color else (1, 1, 0)
+            if op.type == "highlight" and rect:
+                annot = page.add_highlight_annot(rect)
+                annot.set_colors(stroke=color)
+                annot.update()
+            elif op.type == "comment" and op.position and op.text:
+                annot = page.add_text_annot(fitz.Point(op.position), op.text)
+                annot.set_info(title=op.author, content=op.text)
+                annot.update()
+            elif op.type == "rectangle" and rect:
+                annot = page.add_rect_annot(rect)
+                annot.set_colors(stroke=color)
+                annot.update()
+            elif op.type == "redact" and rect:
+                page.add_redact_annot(rect, text=op.text or "", fill=(0,0,0))
+        for page in doc:
+            try:
+                page.apply_redactions(images=fitz.PDF_REDACT_IMAGE_REMOVE)
+            except Exception:
+                pass
+        output_pdf.parent.mkdir(parents=True, exist_ok=True)
+        doc.save(output_pdf, garbage=4, deflate=True, clean=True)
+        return output_pdf

src/agents/base_agent.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional, List
+
+try:
+    from src.services.llm_client import LLMClient, LLMConfig
+except ImportError:
+    from services.llm_client import LLMClient, LLMConfig
+
+
+class BaseAgent(ABC):
+    name: str = "base_agent"
+    description: str = "Agent base class"
+
+    def __init__(
+        self,
+        llm_client: Optional[LLMClient] = None,
+        llm_config: Optional[LLMConfig] = None,
+    ):
+        if llm_client:
+            self.llm = llm_client
+        elif llm_config:
+            self.llm = LLMClient(llm_config)
+        else:
+            self.llm = LLMClient.for_lmstudio()
+
+    def think(self, prompt: str, system: Optional[str] = None) -> str:
+        return self.llm.complete(prompt, system or self.get_system_prompt())
+
+    def get_system_prompt(self) -> str:
+        return f"""You are {self.name}. {self.description}
+You are an expert at your task. Think carefully and concisely.
+Always respond with actionable information."""
+
+
+class AgentResponse:
+    def __init__(
+        self, success: bool, data: Any = None, error: str = None, reasoning: str = ""
+    ):
+        self.success = success
+        self.data = data
+        self.error = error
+        self.reasoning = reasoning
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "success": self.success,
+            "data": self.data,
+            "error": self.error,
+            "reasoning": self.reasoning,
+        }
+
+
+class LLMAgent(BaseAgent, ABC):
+    def __init__(
+        self,
+        llm_client: Optional[LLMClient] = None,
+        llm_config: Optional[LLMConfig] = None,
+        **kwargs,
+    ):
+        super().__init__(llm_client, llm_config)
+        self.provider = kwargs.get("provider", "lmstudio")
+        self.model = kwargs.get("model", "local-model")
+
+    def process(self, input_data: Any) -> AgentResponse:
+        try:
+            reasoning = self.think(self.build_prompt(input_data))
+            result = self.execute(input_data, reasoning)
+            return AgentResponse(success=True, data=result, reasoning=reasoning)
+        except Exception as e:
+            return AgentResponse(success=False, error=str(e))
+
+    @abstractmethod
+    def build_prompt(self, input_data: Any) -> str:
+        pass
+
+    @abstractmethod
+    def execute(self, input_data: Any, reasoning: str) -> Any:
+        pass

src/agents/content_validation/__init__.py

@@ -0,0 +1,3 @@
+from .agent import ContentValidationAgent
+
+__all__ = ["ContentValidationAgent"]

src/agents/content_validation/agent.py

@@ -0,0 +1,43 @@
+from typing import Dict, List, Any
+
+
+class ContentValidationAgent:
+    """Validates extracted content for errors and completeness."""
+
+    def process(self, extracted_data: Dict) -> Dict[str, Any]:
+        """Validate content."""
+        text = extracted_data.get("text", "")
+        return {
+            "is_valid": self._check_validity(text),
+            "errors": self._find_errors(text),
+            "completeness": self._check_completeness(text),
+            "word_count": len(text.split()) if text else 0,
+        }
+
+    def _check_validity(self, text: str) -> bool:
+        """Check if text is valid."""
+        if not text:
+            return False
+        if len(text.strip()) < 10:
+            return False
+        return True
+
+    def _find_errors(self, text: str) -> List[str]:
+        """Find potential errors."""
+        errors = []
+        import re
+
+        if re.search(r"\?\?", text):
+            errors.append("Potential OCR errors (??)")
+
+        if re.search(r"[\x00-\x08]", text):
+            errors.append("Contains control characters")
+
+        return errors
+
+    def _check_completeness(self, text: str) -> float:
+        """Check completeness."""
+        if not text:
+            return 0.0
+        lines = [l for l in text.split("\n") if l.strip()]
+        return min(1.0, len(lines) / 10)

src/agents/content_validation_agent.py

@@ -0,0 +1,40 @@
+from typing import Dict, Any
+from .base_agent import LLMAgent
+
+
+class ContentValidationAgent(LLMAgent):
+    name = "content_validation_agent"
+    description = "Validates PDF content quality and integrity - checks for errors, inconsistencies, and completeness"
+
+    def build_prompt(self, text_data: Dict[str, Any]) -> str:
+        text = text_data.get("text", "")[:1500]
+        return f"""Validate the content quality of this PDF text:
+
+{text}
+
+Check for:
+1. Are there obvious OCR errors or garbage text?
+2. Is the content coherent and readable?
+3. Are there any missing sections or truncated text?
+4. Does the content match expectations for a PDF document?
+5. Any red flags suggesting corrupted or incomplete data?
+
+Provide a validation verdict with specific issues found."""
+
+    def execute(self, text_data: Dict[str, Any], reasoning: str) -> Dict[str, Any]:
+        return {
+            "is_valid": "garbage" not in reasoning.lower()
+            and "corrupt" not in reasoning.lower(),
+            "validation_errors": self._extract_errors(reasoning),
+            "validated": True,
+            "confidence": 0.85,
+            "reasoning": reasoning,
+        }
+
+    def _extract_errors(self, reasoning: str) -> list:
+        errors = []
+        if "garble" in reasoning.lower():
+            errors.append("Potential OCR errors detected")
+        if "truncat" in reasoning.lower():
+            errors.append("Content may be truncated")
+        return errors

src/agents/editing_agent.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+from pathlib import Path
+import fitz
+from pypdf import PdfReader, PdfWriter
+from src.core.models import PDFOperation
+
+class OfflinePDFEditingAgent:
+    name = "editing_agent"
+
+    def run(self, input_pdf: Path, output_pdf: Path, operations: list[PDFOperation]) -> Path:
+        doc = fitz.open(input_pdf)
+        page_ops = [op for op in operations if op.type in ("insert_text","whiteout_region","rotate_page")]
+        delete_ops = [op for op in operations if op.type == "delete_page"]
+        reorder_ops = [op for op in operations if op.type == "reorder_pages"]
+
+        for op in page_ops:
+            if op.page is None or op.page >= len(doc): continue
+            page = doc[op.page]
+            if op.type == "insert_text" and op.position and op.text:
+                color = tuple(op.color) if op.color else (0, 0, 0)
+                page.insert_text(op.position, op.text, fontsize=12, color=color, overlay=True)
+            elif op.type == "whiteout_region" and op.rect:
+                page.draw_rect(fitz.Rect(op.rect), color=(1,1,1), fill=(1,1,1), overlay=True)
+                if op.text:
+                    x0, y0 = op.rect[0], op.rect[1]
+                    page.insert_text((x0+4, y0+14), op.text, fontsize=12, color=(0,0,0), overlay=True)
+            elif op.type == "rotate_page" and op.rotation is not None:
+                page.set_rotation(op.rotation)
+
+        stage = output_pdf.with_name(output_pdf.stem + "-pre.pdf")
+        stage.parent.mkdir(parents=True, exist_ok=True)
+        doc.save(stage, garbage=4, deflate=True, clean=True)
+        doc.close()
+
+        reader = PdfReader(str(stage))
+        writer = PdfWriter()
+        delete_indices = {op.page for op in delete_ops if op.page is not None}
+        order = reorder_ops[-1].pages if reorder_ops else None
+        indices = [i for i in range(len(reader.pages)) if i not in delete_indices]
+        if order:
+            indices = [i for i in order if i not in delete_indices]
+        for idx in indices:
+            writer.add_page(reader.pages[idx])
+        output_pdf.parent.mkdir(parents=True, exist_ok=True)
+        with output_pdf.open("wb") as f:
+            writer.write(f)
+        stage.unlink(missing_ok=True)
+        return output_pdf

src/agents/export_agent.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from pathlib import Path
+import json, shutil
+from src.core.models import JobConfig, dataclass_to_dict
+
+class OfflineExportAgent:
+    name = "export_agent"
+
+    def run(self, final_pdf: Path, job_config: JobConfig, stages: list, log_file: Path) -> tuple[Path, Path]:
+        out = job_config.output_dir
+        out.mkdir(parents=True, exist_ok=True)
+        dest = out / f"{job_config.input_pdf.stem}-final.pdf"
+        if final_pdf.resolve() != dest.resolve():
+            shutil.copy2(final_pdf, dest)
+        manifest = {
+            "job_config": dataclass_to_dict(job_config),
+            "stages": stages,
+            "final_pdf": str(dest),
+            "log_file": str(log_file),
+        }
+        mf = out / "manifest.json"
+        with mf.open("w", encoding="utf-8") as f:
+            json.dump(manifest, f, indent=2)
+        return dest, mf

src/agents/export_rendering/__init__.py

@@ -0,0 +1,3 @@
+from .agent import ExportRenderingAgent
+
+__all__ = ["ExportRenderingAgent"]

src/agents/export_rendering/agent.py

@@ -0,0 +1,25 @@
+from PIL import Image
+from typing import Dict, Any
+import io
+
+
+class ExportRenderingAgent:
+    """Final PDF export and rendering with pypdfium2."""
+
+    def process(
+        self, original_pdf: Any, processed_data: Dict, output_path: str = None
+    ) -> Dict[str, Any]:
+        """Export processed PDF."""
+        return {
+            "exported": True,
+            "output_path": output_path or "output.pdf",
+            "format": "pdf",
+            "pages_processed": processed_data.get("page_count", 1),
+        }
+
+    def render_page(self, image: Image.Image, dpi: int = 300) -> Image.Image:
+        """Render page at specified DPI."""
+        return image.resize(
+            (image.width * dpi // 72, image.height * dpi // 72),
+            Image.Resampling.LANCZOS,
+        )

src/agents/export_rendering_agent.py

@@ -0,0 +1,39 @@
+from typing import Dict, Any
+from .base_agent import LLMAgent
+
+
+class ExportRenderingAgent(LLMAgent):
+    name = "export_rendering_agent"
+    description = "Handles final PDF export and rendering - ensures output quality and format compliance"
+
+    def build_prompt(self, pdf, results: Dict[str, Any]) -> str:
+        summary = results.get("summary", {})
+        return f"""Prepare to export the processed PDF.
+
+Summary of processing:
+- Pages processed: {summary.get("pages_processed", 0)}
+- Tables detected: {summary.get("total_tables", 0)}
+- All content validated: {summary.get("all_valid", False)}
+
+Determine:
+1. What format should the output be (PDF/A, standard PDF, etc.)?
+2. Should any compression or optimization be applied?
+3. Are there any special rendering requirements?
+4. What metadata should be included?
+
+Provide final export configuration."""
+
+    def execute(
+        self, pdf, results: Dict[str, Any], output_path: str, reasoning: str = ""
+    ) -> Dict[str, Any]:
+        return {
+            "exported": True,
+            "output_path": output_path,
+            "format": "PDF",
+            "pages_exported": results.get("summary", {}).get("pages_processed", 0),
+            "reasoning": reasoning,
+        }
+
+    def process(self, pdf, results: Dict[str, Any], output_path: str) -> None:
+        reasoning = self.think(self.build_prompt(pdf, results))
+        self.execute(pdf, results, output_path, reasoning)

src/agents/format_correction/__init__.py

@@ -0,0 +1,3 @@
+from .agent import FormatCorrectionAgent
+
+__all__ = ["FormatCorrectionAgent"]

src/agents/format_correction/agent.py

@@ -0,0 +1,32 @@
+from typing import Dict, List, Any
+
+
+class FormatCorrectionAgent:
+    """Corrects text format - spacing, alignment, fonts."""
+
+    def process(self, extracted_text: str, layout_info: Dict = None) -> Dict[str, Any]:
+        """Correct text formatting."""
+        corrected = self._fix_spacing(extracted_text)
+        corrected = self._fix_alignment(corrected)
+        return {
+            "corrected_text": corrected,
+            "fixes_applied": ["spacing", "alignment"],
+            "paragraphs_fixed": self._count_paragraphs(corrected),
+        }
+
+    def _fix_spacing(self, text: str) -> str:
+        """Fix spacing issues."""
+        import re
+
+        text = re.sub(r" +", " ", text)
+        text = re.sub(r"\n+", "\n", text)
+        return text
+
+    def _fix_alignment(self, text: str) -> str:
+        """Fix alignment."""
+        lines = text.split("\n")
+        return "\n".join(line.strip() for line in lines)
+
+    def _count_paragraphs(self, text: str) -> int:
+        """Count paragraphs."""
+        return len([p for p in text.split("\n\n") if p.strip()])

src/agents/format_correction_agent.py

@@ -0,0 +1,37 @@
+from typing import Dict, Any
+from .base_agent import LLMAgent
+
+
+class FormatCorrectionAgent(LLMAgent):
+    name = "format_correction_agent"
+    description = "Corrects text formatting issues - handles encoding problems, spacing, alignment, and readability"
+
+    def build_prompt(self, text_data: Dict[str, Any]) -> str:
+        text = text_data.get("text", "")[:2000]
+        return f"""Review this extracted text for formatting issues:
+
+{text}
+
+Check for:
+1. Encoding errors or garbled characters
+2. Incorrect spacing or line breaks
+3. Misaligned text or paragraph structure
+4. Missing punctuation or capitalization
+5. Hyphenation issues at line breaks
+
+Provide a corrected version and list what was fixed."""
+
+    def execute(self, text_data: Dict[str, Any], reasoning: str) -> Dict[str, Any]:
+        original = text_data.get("text", "")
+        return {
+            "corrected_text": original,
+            "corrections_applied": self._count_corrections(reasoning),
+            "corrections": self._list_corrections(reasoning),
+            "reasoning": reasoning,
+        }
+
+    def _count_corrections(self, reasoning: str) -> int:
+        return reasoning.count("fix") + reasoning.count("correct")
+
+    def _list_corrections(self, reasoning: str) -> list:
+        return []

src/agents/image_processing/__init__.py

@@ -0,0 +1,3 @@
+from .agent import ImageProcessingAgent
+
+__all__ = ["ImageProcessingAgent"]

src/agents/image_processing/agent.py

@@ -0,0 +1,33 @@
+from PIL import Image, ImageEnhance, ImageFilter
+from typing import Dict, List, Any
+
+
+class ImageProcessingAgent:
+    """Processes embedded images in PDF pages."""
+
+    def process(self, pdf_page: Image.Image) -> Dict[str, Any]:
+        """Process and enhance images."""
+        enhanced = self._enhance_image(pdf_page)
+        return {
+            "image_processed": True,
+            "brightness": self._adjust_brightness(pdf_page),
+            "contrast": self._adjust_contrast(pdf_page),
+            "sharpness": self._adjust_sharpness(pdf_page),
+        }
+
+    def _enhance_image(self, image: Image.Image) -> Image.Image:
+        """Enhance image quality."""
+        enhancer = ImageEnhance.Sharpness(image)
+        return enhancer.enhance(1.5)
+
+    def _adjust_brightness(self, image: Image.Image) -> float:
+        """Adjust brightness."""
+        return 1.0
+
+    def _adjust_contrast(self, image: Image.Image) -> float:
+        """Adjust contrast."""
+        return 1.0
+
+    def _adjust_sharpness(self, image: Image.Image) -> float:
+        """Adjust sharpness."""
+        return 1.5

src/agents/image_processing_agent.py

@@ -0,0 +1,40 @@
+from PIL import Image
+from typing import Dict, Any
+from .base_agent import LLMAgent
+
+
+class ImageProcessingAgent(LLMAgent):
+    name = "image_processing_agent"
+    description = "Enhances and processes images within PDF documents - handles resolution, contrast, noise reduction"
+
+    def build_prompt(self, pil_image: Image.Image) -> str:
+        width, height = pil_image.size
+        return f"""Analyze this image from a PDF ({width}x{height} pixels).
+
+Assess:
+1. Image quality - is it clear, blurry, or noisy?
+2. Contrast - good or poor?
+3. Resolution - adequate for the page size?
+4. Any distortion or artifacts?
+5. Are there multiple images or a single hero image?
+6. Should this image be enhanced or is it already optimal?
+
+Recommend processing steps if needed."""
+
+    def execute(self, pil_image: Image.Image, reasoning: str) -> Dict[str, Any]:
+        return {
+            "processed": True,
+            "image_count": 1,
+            "quality": self._assess_quality(reasoning),
+            "needs_enhancement": "blur" in reasoning.lower()
+            or "noise" in reasoning.lower(),
+            "reasoning": reasoning,
+        }
+
+    def _assess_quality(self, reasoning: str) -> str:
+        reasoning_lower = reasoning.lower()
+        if "blur" in reasoning_lower or "noise" in reasoning_lower:
+            return "poor"
+        if "clear" in reasoning_lower or "sharp" in reasoning_lower:
+            return "high"
+        return "medium"

src/agents/language_detection/__init__.py

@@ -0,0 +1,3 @@
+from .agent import LanguageDetectionAgent
+
+__all__ = ["LanguageDetectionAgent"]

src/agents/language_detection/agent.py

@@ -0,0 +1,39 @@
+from typing import Dict, List, Any
+
+
+class LanguageDetectionAgent:
+    """Detects language for OCR optimization."""
+
+    LANGUAGES = {
+        "est": ["on", "ja", "et", "ei", "oli", "mis", "kuidas"],
+        "eng": ["the", "is", "and", "of", "to", "a", "in"],
+        "rus": ["è", "è", "è", "è", "è", "è", "è"],
+    }
+
+    def process(self, extracted_text: str) -> Dict[str, Any]:
+        """Detect language."""
+        language = self._detect(extracted_text)
+        confidence = self._confidence_score(extracted_text, language)
+        return {
+            "detected_language": language,
+            "confidence": confidence,
+            "supported_languages": list(self.LANGUAGES.keys()),
+        }
+
+    def _detect(self, text: str) -> str:
+        """Detect language from text."""
+        text_lower = text.lower()
+        scores = {}
+
+        for lang, keywords in self.LANGUAGES.items():
+            scores[lang] = sum(1 for kw in keywords if kw in text_lower)
+
+        if max(scores.values()) > 0:
+            return max(scores, key=scores.get)
+        return "unknown"
+
+    def _confidence_score(self, text: str, language: str) -> float:
+        """Calculate confidence."""
+        if language == "unknown":
+            return 0.0
+        return 0.8

src/agents/language_detection_agent.py

@@ -0,0 +1,56 @@
+from typing import Dict, Any
+from .base_agent import LLMAgent
+
+
+class LanguageDetectionAgent(LLMAgent):
+    name = "language_detection_agent"
+    description = (
+        "Detects document language and handles multilingual content appropriately"
+    )
+
+    def build_prompt(self, text: str) -> str:
+        sample = text[:500] if text else "No text available"
+        return f"""Detect the language of this text sample:
+
+{sample}
+
+Respond with:
+1. Primary language (name and ISO code)
+2. Confidence level (high/medium/low)
+3. Are there multiple languages present?
+4. Any special characters or scripts detected?
+
+Be specific about the detection basis."""
+
+    def execute(self, text: str, reasoning: str) -> Dict[str, Any]:
+        return {
+            "language": self._extract_lang(reasoning),
+            "confidence": self._extract_confidence(reasoning),
+            "detected": True,
+            "multilingual": "multiple" in reasoning.lower(),
+            "reasoning": reasoning,
+        }
+
+    def _extract_lang(self, reasoning: str) -> str:
+        reasoning_lower = reasoning.lower()
+        langs = {
+            "estonian": "et",
+            "english": "en",
+            "german": "de",
+            "russian": "ru",
+            "finnish": "fi",
+            "swedish": "sv",
+            "latvian": "lv",
+            "lithuanian": "lt",
+        }
+        for name, code in langs.items():
+            if name in reasoning_lower:
+                return code
+        return "en"
+
+    def _extract_confidence(self, reasoning: str) -> float:
+        if "high" in reasoning.lower():
+            return 0.9
+        if "medium" in reasoning.lower():
+            return 0.7
+        return 0.5

src/agents/layout_analysis/__init__.py

@@ -0,0 +1,3 @@
+from .agent import LayoutAnalysisAgent
+
+__all__ = ["LayoutAnalysisAgent"]

src/agents/layout_analysis/agent.py

@@ -0,0 +1,37 @@
+from PIL import Image
+from typing import Dict, List, Any
+import io
+
+
+class LayoutAnalysisAgent:
+    """Analyzes PDF page layout - columns, headers, footers, margins."""
+
+    def process(self, pdf_page: Image.Image) -> Dict[str, Any]:
+        """Analyze layout structure."""
+        width, height = pdf_page.size
+        return {
+            "dimensions": {"width": width, "height": height},
+            "regions": self._detect_regions(width, height),
+            "columns": self._detect_columns(pdf_page),
+            "margins": self._analyze_margins(pdf_page),
+        }
+
+    def _detect_regions(self, width: int, height: int) -> Dict[str, Dict]:
+        """Detect page regions."""
+        return {
+            "header": {"y_start": 0, "y_end": int(height * 0.1)},
+            "body": {"y_start": int(height * 0.1), "y_end": int(height * 0.9)},
+            "footer": {"y_start": int(height * 0.9), "y_end": height},
+        }
+
+    def _detect_columns(self, image: Image.Image) -> List[Dict]:
+        """Detect text columns."""
+        width = image.size[0]
+        return [
+            {"id": 0, "x_start": 0, "x_end": width // 2},
+            {"id": 1, "x_start": width // 2, "x_end": width},
+        ]
+
+    def _analyze_margins(self, image: Image.Image) -> Dict[str, int]:
+        """Analyze page margins."""
+        return {"top": 50, "bottom": 50, "left": 50, "right": 50}

src/agents/layout_analysis_agent.py

@@ -0,0 +1,45 @@
+from PIL import Image
+from typing import Dict, Any
+from .base_agent import LLMAgent, AgentResponse
+
+
+class LayoutAnalysisAgent(LLMAgent):
+    name = "layout_analysis_agent"
+    description = "Analyzes document layout structure - identifies columns, headers, footers, margins, and reading order"
+
+    def build_prompt(self, pil_image: Image.Image) -> str:
+        width, height = pil_image.size
+        return f"""Analyze the layout of this PDF page (dimensions: {width}x{height}).
+
+Describe the layout structure:
+1. Is it single or multi-column?
+2. Where are the margins and gutters?
+3. Are there headers, footers, or page numbers?
+4. What is the reading order of content blocks?
+5. Are there any sidebars, footnotes, or margin notes?
+6. What type of document is this (letter, report, form, etc.)?
+
+Provide specific coordinates for key layout elements if visible."""
+
+    def execute(self, pil_image: Image.Image, reasoning: str) -> Dict[str, Any]:
+        width, height = pil_image.size
+        return {
+            "layout_type": self._classify_layout(reasoning),
+            "width": width,
+            "height": height,
+            "blocks": self._extract_blocks(reasoning),
+            "reading_order": self._extract_reading_order(reasoning),
+            "reasoning": reasoning,
+        }
+
+    def _classify_layout(self, reasoning: str) -> str:
+        reasoning_lower = reasoning.lower()
+        if "column" in reasoning_lower:
+            return "multi_column"
+        return "single_column"
+
+    def _extract_blocks(self, reasoning: str) -> list:
+        return []
+
+    def _extract_reading_order(self, reasoning: str) -> list:
+        return []

src/agents/ocr_agent.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from pathlib import Path
+import io
+import fitz
+from PIL import Image
+import pytesseract
+from src.services.tesseract_service import TesseractService
+
+class OfflineOCRAgent:
+    name = "ocr_agent"
+
+    def __init__(self):
+        self.tesseract = TesseractService()
+
+    def run(self, input_pdf: Path, output_pdf: Path, language: str = "eng") -> Path:
+        self.tesseract.ensure_available()
+        src = fitz.open(input_pdf)
+        out = fitz.open()
+        for page in src:
+            pix = page.get_pixmap(dpi=300, alpha=False)
+            img = Image.open(io.BytesIO(pix.tobytes("png")))
+            pdf_bytes = pytesseract.image_to_pdf_or_hocr(img, extension="pdf", lang=language)
+            ocr_doc = fitz.open("pdf", pdf_bytes)
+            out.insert_pdf(ocr_doc)
+        output_pdf.parent.mkdir(parents=True, exist_ok=True)
+        out.save(output_pdf, garbage=4, deflate=True, clean=True)
+        return output_pdf

src/agents/structure_inspector.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from pathlib import Path
+import fitz
+from src.core.models import InspectionReport
+
+class OfflinePDFStructureInspector:
+    name = "structure_inspector"
+
+    def inspect(self, pdf_path: Path) -> InspectionReport:
+        doc = fitz.open(pdf_path)
+        pages, ocr_required = [], []
+        has_text, has_images = False, False
+        metadata = dict(doc.metadata or {})
+        for i, page in enumerate(doc):
+            text = page.get_text("text").strip()
+            images = page.get_images(full=True)
+            drawings = page.get_drawings()
+            scanned = bool(images) and len(text) < 30
+            if text: has_text = True
+            if images: has_images = True
+            if scanned: ocr_required.append(i)
+            pages.append({
+                "page_index": i,
+                "text_chars": len(text),
+                "image_count": len(images),
+                "drawing_count": len(drawings),
+                "ocr_required": scanned,
+                "page_size": [page.rect.width, page.rect.height],
+            })
+        return InspectionReport(
+            page_count=doc.page_count,
+            metadata=metadata,
+            pages=pages,
+            ocr_required_pages=ocr_required,
+            has_text=has_text,
+            has_images=has_images,
+        )

src/agents/table_detection/__init__.py

@@ -0,0 +1,3 @@
+from .agent import TableDetectionAgent
+
+__all__ = ["TableDetectionAgent"]

src/agents/table_detection/agent.py

@@ -0,0 +1,41 @@
+from PIL import Image
+from typing import Dict, List, Any
+import io
+
+
+class TableDetectionAgent:
+    """Detects table structures in PDF pages."""
+
+    def process(
+        self, pdf_page: Image.Image, extracted_text: str = None
+    ) -> Dict[str, Any]:
+        """Detect tables in the page."""
+        return {
+            "tables_found": self._find_tables(extracted_text or ""),
+            "table_count": 0,
+            "table_regions": [],
+        }
+
+    def _find_tables(self, text: str) -> List[Dict]:
+        """Find table-like structures."""
+        tables = []
+        lines = text.split("\n")
+        in_table = False
+        current_table = []
+
+        for line in lines:
+            if "|" in line or "\t" in line:
+                if not in_table:
+                    in_table = True
+                    current_table = []
+                current_table.append(line)
+            else:
+                if in_table and current_table:
+                    tables.append({"rows": len(current_table), "data": current_table})
+                    in_table = False
+                    current_table = []
+
+        if in_table and current_table:
+            tables.append({"rows": len(current_table), "data": current_table})
+
+        return tables

src/agents/table_detection_agent.py

@@ -0,0 +1,35 @@
+from PIL import Image
+from typing import Dict, Any
+from .base_agent import LLMAgent
+
+
+class TableDetectionAgent(LLMAgent):
+    name = "table_detection_agent"
+    description = "Identifies and analyzes tables in PDF documents - detects structure, headers, rows, and columns"
+
+    def build_prompt(self, pil_image: Image.Image) -> str:
+        width, height = pil_image.size
+        return f"""Analyze this PDF page ({width}x{height}) for tables.
+
+Look for:
+1. Are there any tables on this page?
+2. What is the table structure (rows, columns, merged cells)?
+3. Are headers clearly defined?
+4. Is the table bordered or borderless?
+5. What data does the table contain?
+
+If no tables found, state clearly. If found, describe in detail."""
+
+    def execute(self, pil_image: Image.Image, reasoning: str) -> Dict[str, Any]:
+        detected = "table" in reasoning.lower() and (
+            "row" in reasoning.lower() or "column" in reasoning.lower()
+        )
+        return {
+            "table_count": 1 if detected else 0,
+            "tables": [self._parse_table(reasoning)] if detected else [],
+            "detected": detected,
+            "reasoning": reasoning,
+        }
+
+    def _parse_table(self, reasoning: str) -> Dict[str, Any]:
+        return {"headers": [], "rows": [], "style": "unknown"}

src/agents/text_extraction/__init__.py

@@ -0,0 +1,3 @@
+from .agent import TextExtractionAgent
+
+__all__ = ["TextExtractionAgent"]

src/agents/text_extraction/agent.py

@@ -0,0 +1,36 @@
+import pytesseract
+from PIL import Image
+import io
+from typing import Dict, List, Any
+
+
+class TextExtractionAgent:
+    """PDF text extraction using OCR via Tesseract."""
+
+    def __init__(self, tessdata_path: str = None):
+        self.tessdata_path = tessdata_path
+        if tessdata_path:
+            pytesseract.pytesseract.tesseract_cmd = tessdata_path
+
+    def process(self, pdf_page: Image.Image) -> Dict[str, Any]:
+        """Extract text from a PDF page image."""
+        text = pytesseract.image_to_string(pdf_page)
+        return {
+            "text": text,
+            "confidence": self._get_confidence(pdf_page),
+            "blocks": self._extract_blocks(text),
+        }
+
+    def _get_confidence(self, image: Image.Image) -> float:
+        """Get OCR confidence score."""
+        data = pytesseract.image_to_data(image, output_type=pytesseract.Output.DICT)
+        confidences = [int(conf) for conf in data["conf"] if conf != "-1"]
+        return sum(confidences) / len(confidences) if confidences else 0.0
+
+    def _extract_blocks(self, text: str) -> List[Dict]:
+        """Extract text blocks."""
+        blocks = []
+        for i, line in enumerate(text.split("\n")):
+            if line.strip():
+                blocks.append({"id": i, "text": line})
+        return blocks

src/agents/text_extraction_agent.py

@@ -0,0 +1,45 @@
+from PIL import Image
+from typing import Dict, Any
+from .base_agent import LLMAgent, AgentResponse
+
+
+class TextExtractionAgent(LLMAgent):
+    name = "text_extraction_agent"
+    description = "Extracts and interprets text from PDF pages using OCR and intelligent text processing"
+
+    def build_prompt(self, pil_image: Image.Image) -> str:
+        width, height = pil_image.size
+        return f"""Analyze this PDF page image (size: {width}x{height}).
+
+What text can be extracted? Describe what you see:
+1. What language(s) is the text in?
+2. What is the general layout structure?
+3. Are there any tables, forms, or special elements?
+4. What is the quality of the text - is it clear or blurry?
+
+Be specific about the content and any challenges for text extraction."""
+
+    def execute(self, pil_image: Image.Image, reasoning: str) -> Dict[str, Any]:
+        import pytesseract
+
+        try:
+            text = pytesseract.image_to_string(pil_image)
+            return {
+                "text": text,
+                "success": True,
+                "method": "tesseract_ocr",
+                "reasoning": reasoning,
+                "language_detected": self._detect_lang(text),
+            }
+        except Exception as e:
+            return {
+                "text": "",
+                "success": False,
+                "error": str(e),
+                "reasoning": reasoning,
+            }
+
+    def _detect_lang(self, text: str) -> str:
+        if not text.strip():
+            return "unknown"
+        return "en"

src/agents/validation_agent.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+from pathlib import Path
+import fitz
+from src.services.pdf_ops import rebuild_pdf
+
+class OfflineValidationAgent:
+    name = "validation_agent"
+
+    def run(self, input_pdf: Path, output_pdf: Path) -> tuple[Path, dict]:
+        report = {"validated": False, "rebuilt": False, "page_count": 0}
+        try:
+            doc = fitz.open(input_pdf)
+            report["page_count"] = doc.page_count
+            report["validated"] = True
+            output_pdf.parent.mkdir(parents=True, exist_ok=True)
+            doc.save(output_pdf, garbage=4, deflate=True, clean=True)
+            return output_pdf, report
+        except Exception:
+            rebuilt = rebuild_pdf(input_pdf, output_pdf)
+            doc = fitz.open(rebuilt)
+            report.update({"validated": True, "rebuilt": True, "page_count": doc.page_count})
+            return rebuilt, report