@@ -0,0 +1,8 @@
+# CODEOWNERS
+#
+# The vision-LLM image limits table is runtime data: when a deployment sets
+# VLM_IMAGE_LIMITS_URL (SaaS does), a merge to main changes which image-mode
+# documents every such deployment accepts within the refresh window, without a
+# release. Changes to it need an owner's review. See
+# unstract/sdk1/src/unstract/sdk1/utils/image_limits/README.md.
+/unstract/sdk1/src/unstract/sdk1/utils/image_limits/limits.json @Zipstack/unstract-maintainers @praveen-formido
@@ -14,11 +14,15 @@
 testenv); this file only takes effect in local/IDE runs.
 """
 
+import os
 from pathlib import Path
 
 import pytest
 from dotenv import load_dotenv
 
+# Keep image-limits lookups on the bundled table (no fetch from GitHub).
+os.environ.setdefault("VLM_IMAGE_LIMITS_URL", "")
+
 # `-s` is set in pyproject so prints surface — log when test.env is absent
 # to make a mis-located file debuggable instead of silently empty.
 if not load_dotenv(Path(__file__).parent / "test.env", override=False):
 
@@ -169,6 +169,9 @@ class IndexingConstants:
     EMBEDDING_INSTANCE_ID = "embedding_instance_id"
     VECTOR_DB_INSTANCE_ID = "vector_db_instance_id"
     X2TEXT_INSTANCE_ID = "x2text_instance_id"
+    # LLM adapter instance ids that will read an image-mode extraction; the
+    # executor checks their image-request limits before the billed conversion.
+    LLM_INSTANCE_IDS = "llm_instance_ids"
     FILE_PATH = "file_path"
     CHUNK_SIZE = "chunk_size"
     CHUNK_OVERLAP = "chunk_overlap"
 
@@ -91,6 +91,17 @@
 from unstract.sdk1.execution.context import ExecutionContext
 from unstract.sdk1.file_storage.constants import StorageType
 from unstract.sdk1.file_storage.env_helper import EnvHelper
+from unstract.sdk1.llm import LLM
+from unstract.sdk1.utils.image_limits import (
+    codes as image_limit_codes,
+)
+from unstract.sdk1.utils.image_limits import (
+    compute_page_budget,
+    extraction_bound_kwargs,
+    fixed_cap_message,
+    model_aware_limits_enabled,
+    page_cap_message,
+)
 from unstract.sdk1.utils.indexing import IndexingUtils
 from unstract.sdk1.utils.tool import ToolUtils
 
@@ -636,6 +647,13 @@ def build_index_payload(
                 "check_extraction_status raised; falling back to full extraction",
                 exc_info=True,
             )
+        if reused_extracted_text:
+            # The cache key ignores the LLM, so a cached image-mode extraction
+            # made for another LLM must still fit this profile's (outside the
+            # fallback above: a rejection must reach the user).
+            PromptStudioHelper._check_cached_image_extraction(
+                default_profile, reused_extracted_text, filename
+            )
 
         util = PromptIdeBaseTool(log_level=LogLevel.INFO, org_id=org_id)
         doc_id_key = IndexingUtils.generate_index_key(
@@ -654,6 +672,9 @@ def build_index_payload(
 
         extract_params = {
             IKeys.X2TEXT_INSTANCE_ID: str(default_profile.x2text.id),
+            IKeys.LLM_INSTANCE_IDS: PromptStudioHelper._image_limit_llm_ids(
+                default_profile
+            ),
             IKeys.FILE_PATH: file_path,
             IKeys.ENABLE_HIGHLIGHT: tool.enable_highlight,
             IKeys.OUTPUT_FILE_PATH: extract_file_path,
@@ -1480,34 +1501,139 @@ def uploads_use_image_output_mode(profile_manager: ProfileManager | None) -> boo
             return False
 
     @staticmethod
-    def validate_upload_page_count_for_image_mode(file_data: Any, file_type: str) -> None:
+    def _image_limit_llm_ids(profile_manager: ProfileManager | None) -> list[str]:
+        """The LLM ids whose image limits apply to this profile's extraction."""
+        llm = getattr(profile_manager, "llm", None)
+        llm_id = getattr(llm, "id", None)
+        return [str(llm_id)] if llm_id else []
+
+    @staticmethod
+    def _upload_page_budget(profile_manager: ProfileManager | None) -> Any:
+        """The profile LLM's page budget, or None to use the fixed cap.
+
+        Resolution is local (the adapter's own validation) and never waits on
+        the network: the limits table is served from memory, and a due
+        refresh runs in the background. Any failure, or
+        ``VLM_IMAGE_LIMITS_ENFORCE=false``, falls back to the fixed cap rather
+        than blocking the upload: extraction re-checks against the LLM before
+        anything is converted.
+        """
+        llm = getattr(profile_manager, "llm", None)
+        if llm is None or not model_aware_limits_enabled():
+            return None
+        try:
+            limits, tokens = LLM.image_input_limits_for(
+                str(llm.adapter_id), llm.metadata or {}
+            )
+        except Exception as e:
+            # The error type only, no traceback: the adapter's validation
+            # error quotes the stored metadata, credentials included.
+            logger.warning(
+                "Could not resolve image limits for the default profile's LLM "
+                "(%s); using the fixed page cap for the upload check",
+                type(e).__name__,
+            )
+            return None
+        bounds = extraction_bound_kwargs()
+        return compute_page_budget(
+            limits,
+            context_tokens=tokens,
+            page_ceiling=bounds["page_ceiling"],
+            legacy_cap=bounds["legacy_cap"],
+        )
+
+    @staticmethod
+    def _check_cached_image_extraction(
+        profile_manager: ProfileManager, extracted_text: str, filename: str
+    ) -> None:
+        """Re-check a cached image-mode extraction against the profile's LLM.
+
+        The extraction cache is keyed on the document, profile and x2text
+        config, not the LLM. After a profile switches LLM (e.g. Gemini to
+        Bedrock Claude, 20 images) a cache hit would skip the page-budget
+        check and the prompt would fail at the provider. Uses the page count
+        recorded in the image-mode summary; no-op outside image mode or when
+        the count or the LLM's limits are unknown (answer time re-checks).
+        With ``VLM_IMAGE_LIMITS_ENFORCE=false`` the fixed page cap applies,
+        as at upload.
+        """
+        if not PromptStudioHelper.uploads_use_image_output_mode(profile_manager):
+            return
+        page_count = LLMWhispererHelper.page_count_from_image_output_summary(
+            extracted_text
+        )
+        if page_count is None:
+            return
+        if not model_aware_limits_enabled():
+            page_cap = configured_page_cap()
+            if page_count <= page_cap:
+                return
+            raise ExtractionAPIError(
+                f"Failed to extract '{filename}'. "
+                f"{image_limit_codes.IMAGE_PAGE_CAP_EXCEEDED}: "
+                + fixed_cap_message(
+                    page_count,
+                    page_cap,
+                    switch_to="switch this profile to a text output mode",
+                )
+            )
+        budget = PromptStudioHelper._upload_page_budget(profile_manager)
+        if budget is None or page_count <= budget.max_pages:
+            return
+        raise ExtractionAPIError(
+            f"Failed to extract '{filename}'. "
+            f"{image_limit_codes.IMAGE_PAGE_CAP_EXCEEDED}: "
+            + page_cap_message(page_count, budget, charged=None)
+            + " The document was extracted earlier for a different LLM; "
+            "switch this profile back, or use one whose LLM accepts more pages."
+        )
+
+    @staticmethod
+    def validate_upload_page_count_for_image_mode(
+        file_data: Any, file_type: str, profile_manager: ProfileManager | None = None
+    ) -> None:
         """Reject, at upload, a PDF with more pages than image mode can answer.
 
         Call only when ``uploads_use_image_output_mode`` is True. Image mode
         sends every page to the LLM in one request, so a document over the
-        page cap can never be answered — and converting it would be billed.
-        Catching it at upload means the user never builds prompts around a
-        document that will fail at indexing.
-
-        Uses the SDK's own page counter and cap, so a document accepted here
-        also passes the extraction-time pre-check. The file is read in place,
-        not copied into memory. A PDF whose page count can't be read is let
-        through; extraction re-checks it.
+        LLM's page budget can never be answered — and converting it would be
+        billed. Catching it at upload means the user never builds prompts
+        around a document that will fail at indexing.
+
+        ``profile_manager`` is the project's default profile: its LLM's
+        image-request limits set the budget (the same computation the
+        extraction-time pre-check runs). Without a resolvable LLM the fixed
+        cap applies. The file is read in place, not copied into memory. A
+        PDF whose page count can't be read is let through; extraction
+        re-checks it.
         """
         if file_type != "application/pdf":
             return
-        page_cap = configured_page_cap()
         page_count = LLMWhispererHelper.pdf_page_count(file_data)
         file_data.seek(0)
-        if page_count is None or page_count <= page_cap:
+        if page_count is None:
+            return
+        budget = PromptStudioHelper._upload_page_budget(profile_manager)
+        if budget is not None:
+            if page_count <= budget.max_pages:
+                return
+            profile_name = getattr(profile_manager, "profile_name", "") or "default"
+            raise ImageModePageLimitExceeded(
+                detail=(
+                    page_cap_message(page_count, budget, charged=None)
+                    + " This check uses the project's default profile "
+                    f"('{profile_name}'); other profiles may allow a different "
+                    "number of pages."
+                )
+            )
+        page_cap = configured_page_cap()
+        if page_count <= page_cap:
             return
         raise ImageModePageLimitExceeded(
-            detail=(
-                "This document has too many pages for image output mode. It "
-                f"has {page_count} pages, and the limit is {page_cap} because "
-                "every page is sent to the LLM in one request. Split the "
-                "document into smaller files, or switch the project's default "
-                "profile to a text output mode."
+            detail=fixed_cap_message(
+                page_count,
+                page_cap,
+                switch_to="switch the project's default profile to a text output mode",
             )
         )
 
@@ -2703,6 +2829,11 @@ def dynamic_extractor(
             try:
                 extracted_text = fs_instance.read(path=extract_file_path, mode="r")
                 logger.info("Extracted text found. Reading from file..")
+                # The cache key ignores the LLM, so a cached image-mode
+                # extraction made for another LLM must still fit this one.
+                PromptStudioHelper._check_cached_image_extraction(
+                    profile_manager, extracted_text, filename
+                )
                 return extracted_text
             except FileNotFoundError as e:
                 logger.warning(
@@ -2712,6 +2843,9 @@ def dynamic_extractor(
                 extracted_text = None
         payload = {
             IKeys.X2TEXT_INSTANCE_ID: x2text,
+            IKeys.LLM_INSTANCE_IDS: PromptStudioHelper._image_limit_llm_ids(
+                profile_manager
+            ),
             IKeys.FILE_PATH: file_path,
             IKeys.ENABLE_HIGHLIGHT: enable_highlight,
             IKeys.USAGE_KWARGS: usage_kwargs.copy(),
 
@@ -24,6 +24,8 @@
 from typing import Any
 from unittest.mock import MagicMock, patch
 
+import pytest
+
 from prompt_studio.prompt_studio_core_v2 import prompt_studio_helper as _psh_mod
 
 PromptStudioHelper = _psh_mod.PromptStudioHelper
@@ -194,6 +196,60 @@ def test_check_extraction_status_raises_is_swallowed(self, caplog) -> None:
         )
 
 
+_LLMW_ADAPTER_ID = "llmwhisperer|a5e6b8af-3e1f-4a80-b006-d017e8e67f93"
+_BEDROCK_ID = "bedrock|8d18571f-5e96-4505-bd28-ad0379c64064"
+_BEDROCK_META = {
+    "model": "anthropic.claude-sonnet-4-5-20250929-v1:0",
+    "aws_region_name": "us-east-1",
+}
+
+
+def _image_mode_bedrock_profile() -> MagicMock:
+    profile = _make_profile()
+    profile.x2text.adapter_id = _LLMW_ADAPTER_ID
+    profile.x2text.metadata = {"output_mode": "image"}
+    profile.llm.adapter_id = _BEDROCK_ID
+    profile.llm.metadata = _BEDROCK_META
+    return profile
+
+
+def _cached_summary(pages: int) -> str:
+    return _psh_mod.LLMWhispererHelper.build_image_output_summary([None] * pages)
+
+
+class TestCacheHitImageLimits:
+    """Index reuses a cached extract only if it fits the profile's LLM (M5).
+
+    The extraction cache ignores the LLM: a document extracted for a
+    generous LLM must not be indexed for one that cannot answer it.
+    """
+
+    @pytest.fixture(autouse=True)
+    def _no_env_cap(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("VLM_IMAGE_ANSWER_PAGE_CAP", raising=False)
+        monkeypatch.delenv("VLM_IMAGE_LIMITS_ENFORCE", raising=False)
+
+    def test_cached_extract_over_the_llm_budget_is_rejected(self) -> None:
+        with pytest.raises(_psh_mod.ExtractionAPIError) as excinfo:
+            _dispatch_build(
+                check_return=True,
+                read_return=_cached_summary(21),
+                profile=_image_mode_bedrock_profile(),
+            )
+        detail = str(excinfo.value.detail)
+        assert "IMAGE_PAGE_CAP_EXCEEDED" in detail
+        assert "doc.pdf" in detail and "20 page images" in detail
+
+    def test_cached_extract_within_the_budget_is_reused(self) -> None:
+        context, _cb, _fs, _check = _dispatch_build(
+            check_return=True,
+            read_return=_cached_summary(20),
+            profile=_image_mode_bedrock_profile(),
+        )
+        index_params = context.executor_params["index_params"]
+        assert index_params[IKeys.EXTRACTED_TEXT] == _cached_summary(20)
+
+
 class TestOwnerAccessPlumbing:
     """UN-3739: the REQUESTER must reach the owner-access check.