Add local CUDA deployment and reject non-notice images

Add a Docker Compose Transformers runtime for local NVIDIA GPUs and use Nemotron semantic classes to reject picture-only uploads before MiniCPM generation.

Co-authored-by: Codex <codex@openai.com>

.dockerignore

@@ -0,0 +1,13 @@
+.git
+.codex
+.env
+.venv
+__pycache__
+*.py[cod]
+*.log
+.pytest_cache
+.mypy_cache
+.ruff_cache
+traces/pending
+traces/export
+experiments

Dockerfile

@@ -0,0 +1,26 @@
+FROM pytorch/pytorch:2.9.1-cuda12.8-cudnn9-runtime
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    HF_HOME=/root/.cache/huggingface
+
+RUN apt-get update \
+    && apt-get install --yes --no-install-recommends \
+        git \
+        libgl1 \
+        libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN python -m pip install --upgrade pip \
+    && python -m pip install -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -77,10 +77,63 @@ fallback. Model and OCR failures are returned explicitly.
 
 Both models run through Transformers on the Hugging Face ZeroGPU deployment.
 
+## Run Locally With Docker and CUDA
+
+The included Compose setup runs the same Transformers pipeline entirely on a
+local NVIDIA GPU. It does not use ZeroGPU or a remote inference API.
+
+Prerequisites:
+
+- Docker Engine with Docker Compose 2.30 or newer, or Docker Desktop with the
+  WSL 2 backend
+- a supported NVIDIA GPU and current NVIDIA driver
+- NVIDIA Container Toolkit when using Docker Engine on Linux
+- enough GPU memory for MiniCPM5-1B and Nemotron-Parse v1.2
+
+Start the application:
+
+```bash
+docker compose up --build
+```
+
+Open <http://localhost:7860>. The first startup takes longer because both model
+repositories are downloaded. Downloads are retained in the
+`huggingface-cache` Docker volume.
+
+Verify that PyTorch can access the local GPU:
+
+```bash
+docker compose run --rm noticecheck python -c \
+  "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"
+```
+
+Optional environment overrides can be placed in a local `.env` file:
+
+```dotenv
+NOTICECHECK_PORT=7860
+TRANSFORMERS_MODEL_REPO=openbmb/MiniCPM5-1B
+MODEL_ENABLE_THINKING=0
+HF_TOKEN=
+```
+
+Stop the application without deleting downloaded models:
+
+```bash
+docker compose down
+```
+
+To also remove the model cache and trace volumes:
+
+```bash
+docker compose down --volumes
+```
+
 ## Repository Layout
 
 ```text
 app.py                 Thin Space launcher
+Dockerfile             Local CUDA image
+compose.yaml           Local NVIDIA GPU deployment
 app/
   cli.py               CLI and startup
   config.py            Environment configuration

app/cli.py

@@ -54,7 +54,7 @@ def run_self_tests() -> None:
 
 def test_endpoint() -> None:
     if not model_status()["connected"]:
-        raise ModelRuntimeError("The local llama.cpp runtime is not ready.")
+        raise ModelRuntimeError("The configured local model runtime is not ready.")
     sample = (
         "PAKISTAN POST: Pay Rs. 85 now at http://pakpost-delivery.example/verify "
         "or your parcel will be destroyed today."

app/config.py

@@ -18,6 +18,23 @@ def _env_bool(name: str, default: bool) -> bool:
     return value.strip().lower() in {"1", "true", "yes", "on"}
 
 
+def model_runtime() -> str:
+    """Select Transformers on Spaces or when explicitly requested locally."""
+    configured = os.getenv("MODEL_RUNTIME", "").strip().lower()
+    if configured:
+        if configured not in {"transformers", "llama_cpp"}:
+            raise ValueError(
+                "MODEL_RUNTIME must be 'transformers' or 'llama_cpp'."
+            )
+        return configured
+    return "transformers" if os.getenv("SPACE_ID") else "llama_cpp"
+
+
+def cuda_required() -> bool:
+    """Return whether startup should fail instead of falling back to CPU."""
+    return _env_bool("REQUIRE_CUDA", False)
+
+
 @dataclass(frozen=True)
 class ModelConfig:
     repo_id: str
@@ -39,8 +56,8 @@ class ModelConfig:
 
 
 def model_config() -> ModelConfig:
-    """Return llama.cpp settings for local GGUF inference."""
-    on_space = bool(os.getenv("SPACE_ID"))
+    """Return shared generation settings and llama.cpp fallback settings."""
+    using_transformers = model_runtime() == "transformers"
     return ModelConfig(
         repo_id=os.getenv(
             "MODEL_REPO_ID",
@@ -61,6 +78,6 @@ def model_config() -> ModelConfig:
             float(os.getenv("MODEL_RETRY_DELAY_SECONDS", "1")),
         ),
         verbose=_env_bool("MODEL_VERBOSE", False),
-        keep_loaded=_env_bool("MODEL_KEEP_LOADED", not on_space),
+        keep_loaded=_env_bool("MODEL_KEEP_LOADED", not using_transformers),
         enable_thinking=_env_bool("MODEL_ENABLE_THINKING", False),
     )

app/model_endpoint.py

@@ -15,7 +15,7 @@ from typing import Any
 import spaces
 from huggingface_hub import hf_hub_download
 
-from app.config import ModelConfig, model_config
+from app.config import ModelConfig, cuda_required, model_config, model_runtime
 from app.ocr import NoReadableTextError, OCRRuntimeError, extract_text, ocr_installed
 from app.prompts import SYSTEM_PROMPT
 from app.schema import OUTPUT_SCHEMA, normalize_assessment
@@ -26,7 +26,10 @@ _MODEL_LOCK = threading.RLock()
 _TF_MODEL: Any | None = None
 _TF_TOKENIZER: Any | None = None
 _TF_LOCK = threading.RLock()
-SPACE_MODEL_REPO = os.getenv("SPACE_MODEL_REPO", "openbmb/MiniCPM5-1B").strip()
+TRANSFORMERS_MODEL_REPO = os.getenv(
+    "TRANSFORMERS_MODEL_REPO",
+    os.getenv("SPACE_MODEL_REPO", "openbmb/MiniCPM5-1B"),
+).strip()
 URDU_SCRIPT_PATTERN = re.compile(r"[\u0600-\u06ff]")
 
 
@@ -40,24 +43,42 @@ class NoticeImageInputError(ModelRuntimeError):
 
 def model_status() -> dict[str, Any]:
     config = model_config()
-    on_space = bool(os.getenv("SPACE_ID"))
+    runtime = model_runtime()
+    using_transformers = runtime == "transformers"
     installed = importlib.util.find_spec(
-        "transformers" if on_space else "llama_cpp"
+        "transformers" if using_transformers else "llama_cpp"
     ) is not None
-    configured = bool(SPACE_MODEL_REPO) if on_space else bool(
+    configured = bool(TRANSFORMERS_MODEL_REPO) if using_transformers else bool(
         config.model_path or (config.repo_id and config.filename)
     )
-    ready = installed and configured
+    cuda_ready = True
+    if using_transformers and cuda_required():
+        try:
+            import torch
+
+            cuda_ready = torch.cuda.is_available()
+        except ImportError:
+            cuda_ready = False
+    ready = installed and configured and cuda_ready
+    on_space = bool(os.getenv("SPACE_ID"))
     return {
         "connected": ready,
-            "label": (
-                "Local models ready"
-                if ready
-                else "Local model setup required"
-            ),
-        "mode": "minicpm5_transformers" if on_space else "minicpm5_llama_cpp",
-        "model": SPACE_MODEL_REPO if on_space else config.source,
-        "compute": "zerogpu_cuda" if on_space else "local",
+        "label": (
+            "Local models ready"
+            if ready
+            else "CUDA is unavailable"
+            if using_transformers and not cuda_ready
+            else "Local model setup required"
+        ),
+        "mode": f"minicpm5_{runtime}",
+        "model": TRANSFORMERS_MODEL_REPO if using_transformers else config.source,
+        "compute": (
+            "zerogpu_cuda"
+            if on_space
+            else "local_cuda"
+            if using_transformers and cuda_ready
+            else "local"
+        ),
         "reasoning": config.enable_thinking,
         "ocr": {
             "model": "nvidia/NVIDIA-Nemotron-Parse-v1.2",
@@ -218,10 +239,16 @@ def _get_transformers_model() -> tuple[Any, Any]:
                 raise ModelRuntimeError(
                     "Transformers MiniCPM runtime is not installed."
                 ) from exc
+            if cuda_required() and not torch.cuda.is_available():
+                raise ModelRuntimeError(
+                    "CUDA is required but is not available to PyTorch."
+                )
             try:
-                _TF_TOKENIZER = AutoTokenizer.from_pretrained(SPACE_MODEL_REPO)
+                _TF_TOKENIZER = AutoTokenizer.from_pretrained(
+                    TRANSFORMERS_MODEL_REPO
+                )
                 _TF_MODEL = AutoModelForCausalLM.from_pretrained(
-                    SPACE_MODEL_REPO,
+                    TRANSFORMERS_MODEL_REPO,
                     torch_dtype="auto",
                     device_map="auto",
                 ).eval()
@@ -297,6 +324,7 @@ def call_model(
 ) -> dict[str, Any]:
     """Run Transformers on Spaces and llama.cpp for local installations."""
     config = model_config()
+    runtime = model_runtime()
     input_text = text.strip()
     if image_data_url:
         try:
@@ -317,7 +345,7 @@ def call_model(
     for attempt in range(attempts):
         ephemeral_model: Any | None = None
         try:
-            if os.getenv("SPACE_ID"):
+            if runtime == "transformers":
                 return _run_transformers_completion(input_text, output_language)
             model = (
                 _get_persistent_model(config)

app/ocr.py

@@ -13,6 +13,8 @@ from typing import Any
 
 from PIL import Image
 
+from app.config import cuda_required
+
 MODEL_ID = "nvidia/NVIDIA-Nemotron-Parse-v1.2"
 TASK_PROMPT = "</s><s><predict_bbox><predict_classes><output_markdown><predict_no_text_in_pic>"
 
@@ -26,6 +28,7 @@ _PROCESSOR: Any | None = None
 _GEN_CONFIG: Any | None = None
 _POSTPROCESSING: Any | None = None
 _LOCK = threading.RLock()
+NON_TEXT_CLASSES = {"figure", "image", "picture"}
 
 
 class OCRRuntimeError(RuntimeError):
@@ -43,6 +46,15 @@ def _has_readable_text(text: str) -> bool:
     return len(alphanumeric) >= 4 and any(char.isalpha() for char in alphanumeric)
 
 
+def _is_text_class(value: Any) -> bool:
+    """Return whether a Nemotron region represents document text."""
+    normalized = re.sub(r"[^a-z]+", " ", str(value).lower()).strip()
+    return not any(
+        token in NON_TEXT_CLASSES
+        for token in normalized.split()
+    )
+
+
 def ocr_installed() -> bool:
     try:
         from transformers import AutoModel, AutoProcessor  # noqa: F401
@@ -96,6 +108,10 @@ def _get_model() -> tuple[Any, Any, Any]:
             raise OCRRuntimeError(
                 "Transformers is not installed."
             ) from exc
+        if cuda_required() and not torch.cuda.is_available():
+            raise OCRRuntimeError(
+                "CUDA is required but is not available to PyTorch."
+            )
         try:
             _MODEL = (
                 AutoModel.from_pretrained(MODEL_ID, trust_remote_code=True, dtype="auto")
@@ -145,11 +161,22 @@ def extract_text(image_data_url: str) -> str:
         if pp is not None:
             try:
                 classes, bboxes, texts = pp.extract_classes_bboxes(generated_text)
-                texts = [
-                    pp.postprocess_text(t, cls=c, text_format="markdown")
-                    for t, c in zip(texts, classes)
+                text_regions = [
+                    pp.postprocess_text(region_text, cls=region_class, text_format="markdown")
+                    for region_text, region_class in zip(texts, classes)
+                    if _is_text_class(region_class)
                 ]
-                text = "\n\n".join(t.strip() for t in texts if t.strip())
+                text = "\n\n".join(
+                    region.strip()
+                    for region in text_regions
+                    if _has_readable_text(region)
+                )
+                if not text and classes:
+                    raise NoReadableTextError(
+                        "No readable notice text was found in the screenshot."
+                    )
+            except NoReadableTextError:
+                raise
             except Exception:
                 text = generated_text.strip()
         else:

compose.yaml

@@ -0,0 +1,40 @@
+services:
+  noticecheck:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "${NOTICECHECK_PORT:-7860}:7860"
+    environment:
+      MODEL_RUNTIME: transformers
+      REQUIRE_CUDA: "1"
+      TRANSFORMERS_MODEL_REPO: "${TRANSFORMERS_MODEL_REPO:-openbmb/MiniCPM5-1B}"
+      MODEL_ENABLE_THINKING: "${MODEL_ENABLE_THINKING:-0}"
+      HF_HOME: /root/.cache/huggingface
+      HF_TOKEN: "${HF_TOKEN:-}"
+      GRADIO_ANALYTICS_ENABLED: "False"
+    volumes:
+      - huggingface-cache:/root/.cache/huggingface
+      - noticecheck-traces:/app/traces/pending
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+    healthcheck:
+      test:
+        - CMD
+        - python
+        - -c
+        - "import urllib.request; urllib.request.urlopen('http://127.0.0.1:7860/health', timeout=5)"
+      interval: 30s
+      timeout: 10s
+      retries: 5
+      start_period: 10m
+    restart: unless-stopped
+
+volumes:
+  huggingface-cache:
+  noticecheck-traces:

docs/local_model_setup.md

@@ -1,76 +1,93 @@
-# Local model setup
+# Local CUDA model setup
 
-The application has separate Space and local runtimes:
+The Docker Compose deployment runs the application completely locally:
 
-- **Space:** `openbmb/MiniCPM5-1B` through Transformers, plus
-  `nvidia/nemotron-ocr-v2` for screenshots
-- **Local:** `openbmb/MiniCPM5-1B-GGUF` through `llama-cpp-python`
+- `openbmb/MiniCPM5-1B` through Transformers
+- `nvidia/NVIDIA-Nemotron-Parse-v1.2` through Transformers
+- PyTorch CUDA on one local NVIDIA GPU
 
-No remote model API is required.
+It does not set `SPACE_ID`, request ZeroGPU, or call a remote inference API.
+Internet access is required on the first run to download model files from
+Hugging Face.
 
-## Supported environment
+## Prerequisites
 
-Nemotron OCR v2 requires Linux amd64, an NVIDIA GPU, CUDA build/runtime
-compatibility, and Python 3.12. The Space metadata pins Python 3.12.
+Use a Linux amd64 Docker host with:
 
-Install the Space dependencies:
+- Docker Engine and Docker Compose 2.30 or newer
+- an NVIDIA GPU supported by CUDA 12.8
+- a current NVIDIA driver
+- NVIDIA Container Toolkit configured for Docker
+
+On Windows, use Docker Desktop with its WSL 2 backend and an NVIDIA driver that
+supports CUDA in WSL.
+
+Confirm GPU access before building the application:
+
+```bash
+docker run --rm --gpus all \
+  pytorch/pytorch:2.9.1-cuda12.8-cudnn9-runtime \
+  python -c "import torch; print(torch.cuda.is_available())"
+```
+
+## Start
 
 ```bash
-python -m pip install -r requirements.txt
+docker compose up --build
 ```
 
-The OCR dependency is NVIDIA's prebuilt `cp312` wheel from its official
-ZeroGPU Space. The Space uses the matching CUDA 12.8 pair `torch==2.9.1` and
-`torchvision==0.24.1` for NVIDIA's native OCR extension. MiniCPM uses
-Transformers on the same ZeroGPU allocation. The Space does not install
-`llama-cpp-python`.
+The startup process preloads Nemotron-Parse before opening port `7860`, so the
+first health check may take several minutes. MiniCPM5-1B loads on the first
+non-cached assessment. Model files persist in the `huggingface-cache` volume.
 
-## MiniCPM configuration
+Open <http://localhost:7860>.
 
-Defaults:
+## Configuration
+
+Compose sets these required values:
 
 ```text
-openbmb/MiniCPM5-1B-GGUF
-MiniCPM5-1B-Q8_0.gguf
+MODEL_RUNTIME=transformers
+REQUIRE_CUDA=1
+HF_HOME=/root/.cache/huggingface
 ```
 
-Overrides:
+Optional `.env` values:
 
-```powershell
-$env:MODEL_REPO_ID = "openbmb/MiniCPM5-1B-GGUF"
-$env:MODEL_FILENAME = "MiniCPM5-1B-Q8_0.gguf"
-$env:MODEL_CONTEXT_SIZE = "8192"
-$env:MODEL_GPU_LAYERS = "0"
-$env:MODEL_ENABLE_THINKING = "0"
+```dotenv
+NOTICECHECK_PORT=7860
+TRANSFORMERS_MODEL_REPO=openbmb/MiniCPM5-1B
+MODEL_ENABLE_THINKING=0
+HF_TOKEN=
 ```
 
-Use `MODEL_PATH` for an existing GGUF. Schema-constrained generation is the
-default because it is more reliable for the application response contract.
-Set `MODEL_ENABLE_THINKING=1` only for experiments; it uses a larger token
-budget but still must produce schema-valid JSON.
+`REQUIRE_CUDA=1` prevents accidental CPU fallback. If Docker cannot expose the
+GPU, model status reports that CUDA is unavailable and startup fails while
+preloading OCR.
+
+## Operations
 
-Set `MODEL_GPU_LAYERS=-1` when using a locally built CUDA-enabled
-`llama-cpp-python` installation outside ZeroGPU.
+View logs:
 
-```powershell
-python -m pip install -r requirements-local.txt
-python app.py --download-model
-python app.py --test-endpoint
-python app.py
+```bash
+docker compose logs --follow noticecheck
 ```
 
-## ZeroGPU lifecycle
+Check the GPU from the application image:
+
+```bash
+docker compose run --rm noticecheck python -c \
+  "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))"
+```
 
-Inference runs inside `@spaces.GPU(duration=60)`. Nemotron OCR first extracts
-paragraph text from a screenshot, then the Transformers MiniCPM5-1B model
-assesses that text. Both Space models are cached in the ZeroGPU worker. Local
-runs use only the separate GGUF/llama.cpp path.
+Stop containers while retaining downloaded models:
 
-## Language limits
+```bash
+docker compose down
+```
 
-Nemotron OCR v2 officially supports English, Chinese, Japanese, Korean, and
-Russian. It does not officially support Urdu script. Roman Urdu uses Latin
-characters and may be readable, but accuracy is not guaranteed.
+Delete containers and persistent model/trace data:
 
-MiniCPM5-1B is officially evaluated in English and Chinese. Urdu and Roman Urdu
-reasoning/output are best effort and must be validated on this app's data.
+```bash
+docker compose down --volumes
+```

tests/test_tracing.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from unittest.mock import patch
 
 import app
-from app import model_endpoint, service
+from app import config, model_endpoint, service
 from app import ocr
 from traces import runtime as trace_runtime
 from traces.scripts.validate_traces import validate_file
@@ -471,21 +471,41 @@ class TraceTests(unittest.TestCase):
         )
 
     def test_ocr_extracts_paragraph_text(self) -> None:
+        import torch
+
         image_data = (
             "data:image/png;base64,"
             "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR4nGNg"
             "YAAAAAMAASsJTYQAAAAASUVORK5CYII="
         )
-        fake_pipeline = unittest.mock.Mock(
-            return_value=[
-                {"text": "PAKISTAN POST", "confidence": 0.99},
-                {"text": "Pay Rs. 85 now", "confidence": 0.98},
-            ]
+        parameter = unittest.mock.Mock(device=torch.device("cpu"), dtype=torch.float32)
+        model = unittest.mock.Mock()
+        model.parameters.side_effect = lambda: iter([parameter])
+        model.generate.return_value = torch.tensor([[1, 2, 3]])
+        processor = unittest.mock.Mock()
+        processor.return_value = {"pixel_values": torch.ones(1)}
+        processor.batch_decode.return_value = ["model output"]
+        postprocessing = unittest.mock.Mock()
+        postprocessing.extract_classes_bboxes.return_value = (
+            ["paragraph", "paragraph"],
+            [None, None],
+            ["PAKISTAN POST", "Pay Rs. 85 now"],
         )
-        with patch("app.ocr._get_pipeline", return_value=fake_pipeline):
+        postprocessing.postprocess_text.side_effect = (
+            lambda text, **_kwargs: text
+        )
+
+        with patch(
+            "app.ocr._get_model",
+            return_value=(model, processor, unittest.mock.Mock()),
+        ), patch(
+            "app.ocr._load_postprocessing",
+            return_value=postprocessing,
+        ):
             text = ocr.extract_text(image_data)
+
         self.assertEqual(text, "PAKISTAN POST\n\nPay Rs. 85 now")
-        fake_pipeline.assert_called_once()
+        model.generate.assert_called_once()
 
     def test_ocr_readability_rejects_parser_markup_without_notice_text(self) -> None:
         self.assertFalse(
@@ -496,6 +516,46 @@ class TraceTests(unittest.TestCase):
         self.assertTrue(ocr._has_readable_text("Pay Rs. 85 now"))
         self.assertTrue(ocr._has_readable_text("آپ کا بل 500 روپے ہے"))
 
+    def test_ocr_rejects_picture_region_with_generated_description(self) -> None:
+        import torch
+
+        image_data = (
+            "data:image/png;base64,"
+            "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR4nGNg"
+            "YAAAAAMAASsJTYQAAAAASUVORK5CYII="
+        )
+        parameter = unittest.mock.Mock(device=torch.device("cpu"), dtype=torch.float32)
+        model = unittest.mock.Mock()
+        model.parameters.side_effect = lambda: iter([parameter])
+        model.generate.return_value = torch.tensor([[1, 2, 3]])
+        processor = unittest.mock.Mock()
+        processor.return_value = {"pixel_values": torch.ones(1)}
+        processor.batch_decode.return_value = ["generated picture output"]
+        postprocessing = unittest.mock.Mock()
+        postprocessing.extract_classes_bboxes.return_value = (
+            ["Picture"],
+            [None],
+            ["A portrait of a woman"],
+        )
+
+        with patch(
+            "app.ocr._get_model",
+            return_value=(model, processor, unittest.mock.Mock()),
+        ), patch(
+            "app.ocr._load_postprocessing",
+            return_value=postprocessing,
+        ):
+            with self.assertRaises(ocr.NoReadableTextError):
+                ocr.extract_text(image_data)
+
+        postprocessing.postprocess_text.assert_not_called()
+
+    def test_ocr_keeps_text_regions_next_to_a_picture(self) -> None:
+        self.assertFalse(ocr._is_text_class("Picture"))
+        self.assertFalse(ocr._is_text_class("page-image"))
+        self.assertTrue(ocr._is_text_class("Paragraph"))
+        self.assertTrue(ocr._is_text_class("Table"))
+
     def test_no_text_ocr_error_becomes_notice_image_input_error(self) -> None:
         with patch(
             "app.model_endpoint.extract_text",
@@ -573,6 +633,42 @@ class TraceTests(unittest.TestCase):
         )
         llama_mock.assert_not_called()
 
+    def test_explicit_local_transformers_runtime_avoids_llama_cpp(self) -> None:
+        assessment = {
+            "risk_label": "Verify first",
+            "simple_explanation": "Confirm the sender independently.",
+            "red_flags": ["Unverified sender"],
+            "safe_next_steps": ["Use an official contact channel."],
+            "reply_draft": "I will verify this independently.",
+        }
+        with patch.dict(
+            "os.environ",
+            {"MODEL_RUNTIME": "transformers"},
+            clear=False,
+        ), patch(
+            "app.model_endpoint._run_transformers_completion",
+            return_value=assessment,
+        ) as transformers_mock, patch(
+            "app.model_endpoint._build_model",
+        ) as llama_mock:
+            result = model_endpoint.call_model("Please pay this fee now.")
+
+        self.assertEqual(result, assessment)
+        transformers_mock.assert_called_once_with(
+            "Please pay this fee now.",
+            "en",
+        )
+        llama_mock.assert_not_called()
+
+    def test_invalid_model_runtime_is_rejected(self) -> None:
+        with patch.dict(
+            "os.environ",
+            {"MODEL_RUNTIME": "invalid"},
+            clear=False,
+        ):
+            with self.assertRaisesRegex(ValueError, "MODEL_RUNTIME"):
+                config.model_runtime()
+
     def test_transformers_completion_uses_model_card_generation_flow(self) -> None:
         assessment = {
             "risk_label": "Likely scam",
@@ -654,23 +750,39 @@ class TraceTests(unittest.TestCase):
         self.assertEqual(result, assessment)
         self.assertEqual(model.generate.call_count, 2)
 
-    def test_urdu_script_ocr_returns_language_error(self) -> None:
-        with patch(
+    def test_urdu_script_ocr_is_assessed_with_english_output(self) -> None:
+        assessment = {
+            "risk_label": "Verify first",
+            "simple_explanation": "Confirm the sender independently.",
+            "red_flags": ["Unverified sender"],
+            "safe_next_steps": ["Use an official contact channel."],
+            "reply_draft": "I will verify this independently.",
+        }
+        with patch.dict(
+            "os.environ",
+            {"MODEL_RUNTIME": "transformers"},
+            clear=False,
+        ), patch(
             "app.model_endpoint.extract_text",
             return_value="آپ کا اکاؤنٹ بند ہو جائے گا",
-        ):
-            with self.assertRaisesRegex(
-                model_endpoint.ModelRuntimeError,
-                "Urdu-script screenshots",
-            ):
-                model_endpoint.call_model(
-                    "",
-                    (
-                        "data:image/png;base64,"
-                        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lE"
-                        "QVR4nGNgYAAAAAMAASsJTYQAAAAASUVORK5CYII="
-                    ),
-                )
+        ), patch(
+            "app.model_endpoint._run_transformers_completion",
+            return_value=assessment,
+        ) as completion_mock:
+            result = model_endpoint.call_model(
+                "",
+                (
+                    "data:image/png;base64,"
+                    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lE"
+                    "QVR4nGNgYAAAAAMAASsJTYQAAAAASUVORK5CYII="
+                ),
+            )
+
+        self.assertEqual(result, assessment)
+        completion_mock.assert_called_once_with(
+            "آپ کا اکاؤنٹ بند ہو جائے گا",
+            "en",
+        )
 
     def test_publisher_persists_batch(self) -> None:
         publisher = trace_runtime.TracePublisher()