@exulu/backend 3.7.4 → 4.0.0

package/ee/python/documents/processing/README.md

@@ -126,14 +126,13 @@ IMAGE_RESOLUTION_SCALE = 2.0  # Image resolution multiplier
 
 This script requires the following Python packages (installed via `npm run python:setup`):
 
-- `docling` - Document conversion
-- `docling-hierarchical-pdf` - Hierarchical heading processing
+- `pypdf` - PDF page-range splitting for the `mistral` OCR processor
 - `transformers` - ML-based text processing
 - `PIL` - Image handling
 
 ### Troubleshooting
 
-**Issue: ImportError for docling**
+**Issue: ImportError for pypdf**
 ```bash
 npm run python:install
 ```

package/ee/python/documents/processing/doc_processor.ts

@@ -12,7 +12,6 @@ import WordExtractor from 'word-extractor';
 import { parseOfficeAsync } from "officeparser";
 import { checkLicense } from '@EE/entitlements';
 import { executePythonScript } from '@SRC/utils/python-executor';
-import { setupPythonEnvironment, validatePythonEnvironment } from '@SRC/utils/python-setup';
 import { LiteParse } from '@llamaindex/liteparse';
 import { resolveOcr } from '@SRC/exulu/resolve-ocr';
 import type { ResolveOcrInput } from '@SRC/exulu/resolve-ocr';
@@ -31,7 +30,7 @@ type DocumentProcessorConfig = {
     concurrency: number;
   },
   processor: {
-    name: "docling" | "liteparse" | "mistral" | "officeparser"
+    name: "liteparse" | "mistral" | "officeparser"
     /**
      * LiteLLM model_name for the "mistral" OCR processor (declared in
      * config.litellm.yaml). Defaults to "mistral-ocr". OCR is routed through
@@ -534,7 +533,7 @@ async function validateWithVLM(
   verbose: boolean = false,
   concurrency: number = 10
 ): Promise<ProcessedDocument> {
-  console.log(`[EXULU] Starting VLM validation for docling output, ${document.length} pages...`);
+  console.log(`[EXULU] Starting VLM validation for processor output, ${document.length} pages...`);
   console.log(`[EXULU] Concurrency limit: ${concurrency}`);
 
   // Create a concurrency limiter
@@ -683,7 +682,7 @@ async function processDocument(
   /* 
   tempDir/
     uuid/
-      docling.json
+      processed.json
       images/
   */
   const paths: ProcessingPaths = {
@@ -751,56 +750,7 @@ async function processPdf(
   try {
     let json: ProcessedDocument = [];
     // Call the PDF processor script
-    if (config?.processor.name === "docling") {
-
-      // Validate Python environment and setup if needed
-      console.log(`[EXULU] Validating Python environment...`);
-      const validation = await validatePythonEnvironment(undefined, true);
-
-      if (!validation.valid) {
-        console.log(`[EXULU] Python environment not ready, setting up automatically...`);
-        console.log(`[EXULU] Reason: ${validation.message}`);
-
-        const setupResult = await setupPythonEnvironment({
-          verbose: true,
-          force: false, // Only setup if not already done
-        });
-
-        if (!setupResult.success) {
-          throw new Error(`Failed to setup Python environment: ${setupResult.message}\n\n${setupResult.output || ''}`);
-        }
-
-        console.log(`[EXULU] Python environment setup completed successfully`);
-      } else {
-        console.log(`[EXULU] Python environment is valid`);
-      }
-
-      console.log(`[EXULU] Processing document with document_to_markdown.py`);
-
-      const result = await executePythonScript({
-        scriptPath: 'ee/python/documents/processing/document_to_markdown.py',
-        args: [
-          paths.source,
-          '-o', paths.json,
-          '--images-dir', paths.images
-        ],
-        timeout: 30 * 60 * 1000, // 30 minutes for large documents
-      });
-
-      // Log processing info from stderr
-      if (result.stderr) {
-        console.log('Processing info:', result.stderr.trim());
-      }
-
-      if (!result.success) {
-        throw new Error(`Document processing failed: ${result.stderr}`);
-      }
-
-      // Read the generated JSON file
-      const jsonContent = await fs.promises.readFile(paths.json, 'utf-8');
-      json = JSON.parse(jsonContent);
-
-    } else if (config?.processor.name === "officeparser") {
+    if (config?.processor.name === "officeparser") {
       const text = await parseOfficeAsync(buffer, {
         outputErrorToConsole: false,
         newlineDelimiter: "\n",
@@ -934,16 +884,29 @@ async function processPdf(
       }));
 
       fs.writeFileSync(paths.json, JSON.stringify(json, null, 2));
+    } else {
+      // Without this the if/else chain fell through leaving `json` empty, and
+      // the document was stored as zero pages with no error anywhere — a silent
+      // data-loss path. "docling" in particular used to be a valid value here.
+      // Every member of the union is handled above, so TypeScript narrows
+      // `processor.name` to `never` here. At runtime a caller can still pass
+      // anything, because these configs are routinely built from plain JS or
+      // from database rows. String() widens it back for the message.
+      const configured = String(config?.processor?.name ?? '');
+      throw new Error(
+        configured === ''
+          ? '[EXULU] No document processor configured. Set processor.name to one of: mistral, liteparse, officeparser.'
+          : `[EXULU] Unknown document processor "${configured}". Supported processors are: mistral, liteparse, officeparser.` +
+            (configured === 'docling'
+              ? ' The "docling" processor was removed: it depended on PyMuPDF, which is AGPL-licensed. Use "mistral" for PDF OCR.'
+              : '')
+      );
     }
 
     console.log(`[EXULU] \n✓ Document processing completed successfully`);
     console.log(`[EXULU] Total pages: ${json.length}`);
     console.log(`[EXULU] Output file: ${paths.json}`);
 
-    if (config?.vlm?.model) {
-      console.error('[EXULU] VLM validation is only supported when docling is enabled, skipping validation.');
-    }
-
     // Apply VLM validation if enabled
     const vlmModel = config?.vlm?.model ? await resolveVlmModel(config) : undefined;
     if (vlmModel && json.length > 0) {
@@ -1121,9 +1084,6 @@ export async function documentProcessor({
 
     let supportedTypes: string[] = [];
     switch (config?.processor.name) {
-      case "docling":
-        supportedTypes = ['pdf', 'docx', 'doc', 'txt', 'md', 'jpg', 'jpeg', 'png', 'gif', 'webp'];
-        break;
       case "officeparser":
         supportedTypes = ['docx', 'pptx', 'xlsx', 'odt', 'odp', 'ods', 'pdf', 'rtf', 'csv', 'md', 'html'];
         break;

package/ee/python/documents/processing/split_pdf.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-PDF Splitter — splits a PDF into fixed-size page chunks using PyMuPDF.
+PDF Splitter — splits a PDF into fixed-size page chunks using pypdf.
 
 Outputs a JSON array to stdout, each element:
   { "path": "<absolute-path>", "start_page": <int>, "end_page": <int> }
@@ -22,26 +22,20 @@ import argparse
 
 # stdout is this script's result channel and the caller does JSON.parse() on it,
 # so nothing else may write there. Our own prints all pass file=sys.stderr, but
-# dependencies do not honour that: PyMuPDF sends its messages to sys.stdout by
-# default, and importing the legacy `fitz` alias emits
-# "warning: The `fitz` API is deprecated ..." — which lands ahead of the payload
-# and fails the caller with "Unexpected token 'w'". PyMuPDF arrives unpinned as
-# a docling transitive dependency, so a routine rebuild is enough to introduce a
-# banner like that. Point sys.stdout at stderr before importing anything and
-# keep a private handle for the result, so any library that prints — now or
-# after a future dependency bump — is shunted to the log channel instead of
-# corrupting the payload.
+# a dependency need not: any library is free to emit a deprecation banner or a
+# progress line on stdout, and it would land ahead of the payload and fail the
+# caller with "Unexpected token 'w'". Point sys.stdout at stderr before
+# importing anything and keep a private handle for the result, so a library
+# that prints — now or after a future dependency bump — is shunted to the log
+# channel instead of corrupting the payload.
 _stdout = sys.stdout
 sys.stdout = sys.stderr
 
-try:
-    import pymupdf as fitz  # PyMuPDF >= 1.24.3, where the module was renamed
-except ImportError:  # older releases only ship the legacy `fitz` module
-    import fitz
+from pypdf import PdfReader, PdfWriter
 
 
 def _write_chunk(
-    doc: fitz.Document,
+    reader: PdfReader,
     output_dir: str,
     chunk_start: int,
     chunk_end: int,
@@ -56,10 +50,11 @@ def _write_chunk(
     """
     chunk_path = os.path.join(output_dir, f"chunk_{chunk_start}_{chunk_end - 1}.pdf")
 
-    sub = fitz.open()
-    sub.insert_pdf(doc, from_page=chunk_start, to_page=chunk_end - 1)
-    sub.save(chunk_path)
-    sub.close()
+    writer = PdfWriter()
+    writer.append(reader, pages=(chunk_start, chunk_end))
+    with open(chunk_path, "wb") as fh:
+        writer.write(fh)
+    writer.close()
 
     chunk_bytes = os.path.getsize(chunk_path)
     n_pages = chunk_end - chunk_start
@@ -68,8 +63,8 @@ def _write_chunk(
         os.remove(chunk_path)
         mid = chunk_start + n_pages // 2
         return (
-            _write_chunk(doc, output_dir, chunk_start, mid, max_size_bytes)
-            + _write_chunk(doc, output_dir, mid, chunk_end, max_size_bytes)
+            _write_chunk(reader, output_dir, chunk_start, mid, max_size_bytes)
+            + _write_chunk(reader, output_dir, mid, chunk_end, max_size_bytes)
         )
 
     if max_size_bytes and chunk_bytes > max_size_bytes:
@@ -88,21 +83,21 @@ def split_pdf(
     chunk_size: int,
     max_size_bytes: int | None = None,
 ) -> list[dict]:
-    doc = fitz.open(input_path)
+    reader = PdfReader(input_path)
 
     # Some PDFs are saved with an empty owner/user password by certain writers
     # (e.g. older Adobe Acrobat exports). The OS opens them transparently by
     # trying "" first, but most libraries raise immediately. We replicate that
-    # OS-level behaviour here.
-    if doc.needs_pass:
-        authenticated = doc.authenticate("")
-        if not authenticated:
+    # OS-level behaviour here. pypdf's decrypt() returns a PasswordType enum
+    # whose NOT_DECRYPTED member is falsy, so a plain truth test is enough.
+    if reader.is_encrypted:
+        if not reader.decrypt(""):
             raise ValueError(
                 "PDF requires a non-empty password and cannot be opened automatically."
             )
         print("[split_pdf] Authenticated with empty password (phantom-password PDF)", file=sys.stderr)
 
-    total_pages = len(doc)
+    total_pages = len(reader.pages)
     file_size = os.path.getsize(input_path)
     print(
         f"[split_pdf] Total pages: {total_pages}, chunk size: {chunk_size}, "
@@ -115,7 +110,7 @@ def split_pdf(
 
     if not needs_split:
         print("[split_pdf] No split needed — returning original path", file=sys.stderr)
-        doc.close()
+        reader.close()
         return [{
             "path": os.path.abspath(input_path),
             "start_page": 0,
@@ -127,7 +122,7 @@ def split_pdf(
     chunks = []
     for start_page in range(0, total_pages, chunk_size):
         end_page = min(start_page + chunk_size, total_pages)
-        sub_chunks = _write_chunk(doc, output_dir, start_page, end_page, max_size_bytes)
+        sub_chunks = _write_chunk(reader, output_dir, start_page, end_page, max_size_bytes)
         for c in sub_chunks:
             print(
                 f"[split_pdf] Chunk {len(chunks) + 1}: pages {c['start_page']}–{c['end_page'] - 1} "
@@ -136,7 +131,7 @@ def split_pdf(
             )
         chunks.extend(sub_chunks)
 
-    doc.close()
+    reader.close()
     return chunks
 
 

package/ee/python/documents/processing/tests/test_split_pdf.py

@@ -0,0 +1,230 @@
+"""Tests for split_pdf.py.
+
+Builds real PDFs with pypdf rather than using fixtures, so the suite is
+self-contained and the page counts/byte sizes are known exactly.
+
+Run from the repo root with the venv active:
+    cd ee/python/documents/processing && ../../.venv/bin/python -m pytest tests
+"""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+from pypdf import PdfReader, PdfWriter
+from pypdf.generic import DecodedStreamObject, NameObject
+
+# Make ee/python/documents/processing importable.
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import split_pdf as sp  # noqa: E402
+
+SCRIPT = Path(__file__).resolve().parent.parent / "split_pdf.py"
+
+
+def _make_pdf(path: Path, pages: int, page_bytes: int = 0) -> Path:
+    """Write a PDF whose pages carry a real content stream.
+
+    Each page's stream holds a `% exulu-page-N` marker so tests can assert the
+    page order survived, plus `page_bytes` of incompressible padding so the
+    byte-size bisection tests get a file whose size scales with page count.
+    Page content is used rather than custom dictionary keys because a PDF
+    library is free to drop unknown keys when it rebuilds pages, and PyMuPDF
+    does exactly that.
+    """
+    writer = PdfWriter()
+    for i in range(pages):
+        writer.add_blank_page(width=200, height=200)
+        body = f"% exulu-page-{i}\n".encode()
+        if page_bytes:
+            body += b"% " + os.urandom(page_bytes).hex().encode() + b"\n"
+        stream = DecodedStreamObject()
+        stream.set_data(body)
+        writer.pages[i][NameObject("/Contents")] = writer._add_object(stream)
+    with open(path, "wb") as fh:
+        writer.write(fh)
+    return path
+
+
+def _page_markers(pdf_path: str) -> list[str]:
+    """Read back the `% exulu-page-N` marker from every page of a chunk."""
+    markers = []
+    for page in PdfReader(pdf_path).pages:
+        data = page["/Contents"].get_data().decode("latin-1")
+        markers.append(data.splitlines()[0].removeprefix("% "))
+    return markers
+
+
+def _run_script(*args: str) -> tuple[int, str, str]:
+    proc = subprocess.run(
+        [sys.executable, str(SCRIPT), *args],
+        capture_output=True,
+        text=True,
+    )
+    return proc.returncode, proc.stdout, proc.stderr
+
+
+# --- no-split path -----------------------------------------------------------
+
+
+def test_returns_original_when_within_limits(tmp_path):
+    src = _make_pdf(tmp_path / "small.pdf", pages=3)
+    chunks = sp.split_pdf(str(src), str(tmp_path / "out"), chunk_size=25)
+
+    assert len(chunks) == 1
+    assert chunks[0]["path"] == str(src.resolve())
+    assert chunks[0]["start_page"] == 0
+    assert chunks[0]["end_page"] == 3
+    # No copy is made, so the output dir is never created.
+    assert not (tmp_path / "out").exists()
+
+
+# --- page-count splitting ----------------------------------------------------
+
+
+def test_splits_on_page_count(tmp_path):
+    src = _make_pdf(tmp_path / "big.pdf", pages=10)
+    out = tmp_path / "out"
+    chunks = sp.split_pdf(str(src), str(out), chunk_size=4)
+
+    assert [(c["start_page"], c["end_page"]) for c in chunks] == [(0, 4), (4, 8), (8, 10)]
+    for c in chunks:
+        assert Path(c["path"]).exists()
+    assert [len(PdfReader(c["path"]).pages) for c in chunks] == [4, 4, 2]
+
+
+def test_chunk_ranges_are_contiguous_and_cover_every_page(tmp_path):
+    src = _make_pdf(tmp_path / "doc.pdf", pages=17)
+    chunks = sp.split_pdf(str(src), str(tmp_path / "out"), chunk_size=5)
+
+    assert chunks[0]["start_page"] == 0
+    assert chunks[-1]["end_page"] == 17
+    for prev, nxt in zip(chunks, chunks[1:]):
+        assert prev["end_page"] == nxt["start_page"]
+    assert sum(len(PdfReader(c["path"]).pages) for c in chunks) == 17
+
+
+def test_exact_multiple_of_chunk_size_produces_no_empty_trailing_chunk(tmp_path):
+    src = _make_pdf(tmp_path / "doc.pdf", pages=8)
+    chunks = sp.split_pdf(str(src), str(tmp_path / "out"), chunk_size=4)
+
+    assert [(c["start_page"], c["end_page"]) for c in chunks] == [(0, 4), (4, 8)]
+
+
+def test_page_content_is_preserved_in_order(tmp_path):
+    """The Nth page of the source must land at the right offset in its chunk."""
+    src = _make_pdf(tmp_path / "marked.pdf", pages=6)
+
+    chunks = sp.split_pdf(str(src), str(tmp_path / "out"), chunk_size=2)
+
+    seen = []
+    for c in chunks:
+        seen.extend(_page_markers(c["path"]))
+    assert seen == [f"exulu-page-{i}" for i in range(6)]
+
+
+# --- byte-size bisection -----------------------------------------------------
+
+
+def test_oversized_chunk_is_bisected_by_page_count(tmp_path):
+    # 4 pages, ~40 KB each. A 4-page chunk exceeds 100 KB and must bisect.
+    src = _make_pdf(tmp_path / "heavy.pdf", pages=4, page_bytes=20_000)
+    chunks = sp.split_pdf(
+        str(src), str(tmp_path / "out"), chunk_size=4, max_size_bytes=100_000
+    )
+
+    assert len(chunks) > 1
+    assert [(c["start_page"], c["end_page"]) for c in chunks][0][0] == 0
+    assert chunks[-1]["end_page"] == 4
+    for prev, nxt in zip(chunks, chunks[1:]):
+        assert prev["end_page"] == nxt["start_page"]
+
+
+def test_single_page_over_limit_is_kept_with_a_warning(tmp_path, capsys):
+    src = _make_pdf(tmp_path / "huge-page.pdf", pages=1, page_bytes=60_000)
+    # Force the split path: max_size_bytes below the file size.
+    chunks = sp.split_pdf(
+        str(src), str(tmp_path / "out"), chunk_size=1, max_size_bytes=1_000
+    )
+
+    assert len(chunks) == 1
+    assert Path(chunks[0]["path"]).exists()
+    assert "cannot be split further" in capsys.readouterr().err
+
+
+def test_file_over_size_limit_splits_even_when_page_count_fits(tmp_path):
+    src = _make_pdf(tmp_path / "wide.pdf", pages=4, page_bytes=20_000)
+    chunks = sp.split_pdf(
+        str(src), str(tmp_path / "out"), chunk_size=25, max_size_bytes=50_000
+    )
+
+    # chunk_size alone would have returned the original untouched.
+    assert len(chunks) > 1
+
+
+# --- encryption --------------------------------------------------------------
+
+
+def test_opens_phantom_password_pdf(tmp_path):
+    """A PDF encrypted with an empty password must open, as the OS does."""
+    writer = PdfWriter()
+    for _ in range(6):
+        writer.add_blank_page(width=200, height=200)
+    writer.encrypt("")
+    src = tmp_path / "phantom.pdf"
+    with open(src, "wb") as fh:
+        writer.write(fh)
+
+    assert PdfReader(src).is_encrypted
+
+    chunks = sp.split_pdf(str(src), str(tmp_path / "out"), chunk_size=2)
+    assert len(chunks) == 3
+    assert sum(len(PdfReader(c["path"]).pages) for c in chunks) == 6
+
+
+def test_rejects_pdf_with_a_real_password(tmp_path):
+    writer = PdfWriter()
+    writer.add_blank_page(width=200, height=200)
+    writer.encrypt("hunter2")
+    src = tmp_path / "locked.pdf"
+    with open(src, "wb") as fh:
+        writer.write(fh)
+
+    with pytest.raises(ValueError, match="non-empty password"):
+        sp.split_pdf(str(src), str(tmp_path / "out"), chunk_size=1)
+
+
+# --- CLI contract ------------------------------------------------------------
+
+
+def test_stdout_is_pure_json(tmp_path):
+    src = _make_pdf(tmp_path / "doc.pdf", pages=6)
+    code, out, err = _run_script(str(src), str(tmp_path / "out"), "--chunk-size", "2")
+
+    assert code == 0
+    parsed = json.loads(out)  # must not raise: nothing but JSON on stdout
+    assert len(parsed) == 3
+    # Diagnostics go to stderr, not stdout.
+    assert "[split_pdf]" in err
+    assert "[split_pdf]" not in out
+
+
+def test_cli_max_size_mb_is_converted_to_bytes(tmp_path):
+    src = _make_pdf(tmp_path / "heavy.pdf", pages=4, page_bytes=20_000)
+    code, out, _ = _run_script(
+        str(src), str(tmp_path / "out"), "--chunk-size", "4", "--max-size-mb", "0.05"
+    )
+
+    assert code == 0
+    assert len(json.loads(out)) > 1
+
+
+def test_exits_nonzero_on_failure(tmp_path):
+    code, out, err = _run_script(str(tmp_path / "missing.pdf"), str(tmp_path / "out"))
+
+    assert code == 1
+    assert "[split_pdf] ERROR" in err
+    assert out.strip() == ""

package/ee/python/requirements.txt

@@ -1,12 +1,15 @@
-docling
 # transformers <5: the 5.x line requires huggingface_hub>=1.0, which removed the
 # `use_auth_token` kwarg that pyannote.audio 3.x still passes to hf_hub_download()
 # (→ "unexpected keyword argument 'use_auth_token'", diarization silently
 # disabled). whisperx only needs transformers>=4.48, so the 4.x line is fine.
 transformers>=4.48,<5
 pyinstaller
-docling-hierarchical-pdf
 defusedxml
+# PDF page-range splitting for the "mistral" OCR processor (split_pdf.py).
+# BSD-3-Clause, no dependencies. Replaced PyMuPDF, which is AGPL-3.0 or a paid
+# Artifex commercial licence; see split_pdf.py. Do not reintroduce a PDF library
+# without checking its licence.
+pypdf>=6.1
 # Whisper transcription server. Used by `npx @exulu/backend exulu-start-whisper`.
 #
 # Notes on the pins:
@@ -30,6 +33,11 @@ requests
 # LiteLLM proxy — only used when EXULU_USE_LITELLM=true. Always installed so
 # the dep is ready when the env var is flipped. Pinned to a tested version;
 # upgrade deliberately.
+# NOTE: the [proxy] extra hard-requires litellm-enterprise, which is NOT MIT —
+# it carries the proprietary BerriAI Enterprise License. setup.sh step 6.4
+# uninstalls it right after this file is installed; see the comment there. Keep
+# the extra (we need its other 29 packages) and keep that uninstall step
+# together.
 litellm[proxy]==1.97.0
 # FastAPI ceiling — NOT cosmetic. litellm 1.97.0 declares fastapi>=0.136.3,<1.0
 # but imports the private `get_flat_dependant` from fastapi.dependencies.utils
@@ -57,3 +65,5 @@ google-cloud-aiplatform>=1.38
 # skill scripts (e.g. the built-in docx-manipulation skill) find their libraries without
 # creating a venv per session (which mirrored thousands of files into the tool result).
 python-docx>=1.1
+python-pptx>=1.0
+openpyxl>=3.1

package/ee/python/setup.sh

@@ -240,6 +240,39 @@ pip install -r "$REQUIREMENTS_FILE"
 
 print_success "All dependencies installed successfully"
 
+# Step 6.4: Remove the proprietary litellm-enterprise package.
+#
+# requirements.txt pins `litellm[proxy]`, and that extra hard-requires
+# litellm-enterprise. We need the other 29 packages the extra brings in
+# (gunicorn, fastapi, apscheduler, boto3, mcp, litellm-proxy-extras, …) but not
+# this one: it is NOT MIT like litellm itself. It carries the BerriAI Enterprise
+# License, which permits production use only with a paid per-seat subscription
+# and forbids redistributing the package. Exulu ships ee/ (including this script
+# and requirements.txt) inside the public npm package, so leaving it installed
+# would put a proprietary dependency on every customer's machine.
+#
+# Removing it is safe. Every one of litellm's 36 `litellm_enterprise` import
+# sites is wrapped in `try/except ImportError`; with the package absent the
+# proxy imports cleanly, `enterprise_proxy_config` falls back to None and the
+# route table is unchanged. Exulu never sets LITELLM_LICENSE, so `premium_user`
+# is False and no enterprise feature was reachable in the first place.
+#
+# If you DO hold a BerriAI Enterprise subscription and want the enterprise
+# callbacks, set EXULU_KEEP_LITELLM_ENTERPRISE=true to skip this step.
+echo ""
+if [ "${EXULU_KEEP_LITELLM_ENTERPRISE:-false}" = "true" ]; then
+    print_warning "EXULU_KEEP_LITELLM_ENTERPRISE=true — keeping litellm-enterprise (proprietary; requires a BerriAI subscription for production use)."
+elif pip show litellm-enterprise > /dev/null 2>&1; then
+    print_info "Removing litellm-enterprise (proprietary BerriAI package pulled in by litellm[proxy])..."
+    if pip uninstall -y litellm-enterprise > /dev/null 2>&1; then
+        print_success "litellm-enterprise removed; LiteLLM proxy runs on the MIT-licensed core"
+    else
+        print_warning "Could not remove litellm-enterprise. It is proprietary (BerriAI Enterprise License) and production use requires a paid subscription — remove it manually with 'pip uninstall -y litellm-enterprise' or set EXULU_KEEP_LITELLM_ENTERPRISE=true if you hold one."
+    fi
+else
+    print_info "litellm-enterprise not present — nothing to remove"
+fi
+
 # Step 6.5: Generate Prisma client for LiteLLM database mode.
 # LiteLLM's PrismaClient does `from prisma import Prisma`, which only works
 # after `prisma generate` has materialized the Python client against
@@ -259,7 +292,7 @@ echo "Step 7: Validating installation..."
 
 # Test critical imports
 print_info "Testing critical imports..."
-$PYTHON_CMD -c "import docling" 2>/dev/null && print_success "docling imported successfully" || print_error "Failed to import docling"
+$PYTHON_CMD -c "import pypdf" 2>/dev/null && print_success "pypdf imported successfully" || print_error "Failed to import pypdf"
 $PYTHON_CMD -c "import transformers" 2>/dev/null && print_success "transformers imported successfully" || print_error "Failed to import transformers"
 
 # Whisper transcription server imports — non-fatal: only needed for
@@ -269,6 +302,12 @@ $PYTHON_CMD -c "import whisperx" 2>/dev/null && print_success "whisperx imported
 $PYTHON_CMD -c "import pyannote.audio" 2>/dev/null && print_success "pyannote.audio imported successfully" || print_warning "pyannote.audio not importable (diarization will be disabled even with HF_AUTH_TOKEN)"
 $PYTHON_CMD -c "import fastapi, uvicorn" 2>/dev/null && print_success "fastapi/uvicorn imported successfully" || print_warning "fastapi/uvicorn not importable (transcription server will not start)"
 
+# litellm must still import after litellm-enterprise was removed in step 6.4.
+# Cheap check on purpose: `import litellm` takes ~2s, while importing
+# litellm.proxy.proxy_server takes ~15s and would eat into the npm postinstall
+# timeout that the CUDA torch download already strains.
+$PYTHON_CMD -c "import litellm" 2>/dev/null && print_success "litellm imported successfully" || print_warning "litellm not importable (LiteLLM proxy will not start; only needed when EXULU_USE_LITELLM=true)"
+
 # Step 8: Display summary
 echo ""
 echo -e "${GREEN}========================================${NC}"