claude-smart 0.2.47 → 0.2.48

package/plugin/vendor/reflexio/reflexio/server/services/base_generation/_batch_progress.py

@@ -0,0 +1,298 @@
+"""Batch-progress + rerun orchestration for ``BaseGenerationService`` (Tier-1b decomposition).
+
+``BatchProgressMixin`` holds the shared batch-with-progress driver
+(``_run_batch_with_progress``) plus the ``run_rerun`` public template method and the
+overridable rerun hooks subclasses implement (``_get_rerun_user_ids``,
+``_build_rerun_request_params``, ``_create_run_request_for_item``,
+``_create_rerun_response``, ``_get_generated_count``, ``_pre_process_rerun``).
+
+``_run_batch_with_progress`` is both subclass-called (``self._run_batch_with_progress``
+in the profile/playbook manual-run paths, resolved via MRO) and instance-patched in
+tests (``patch.object(svc, "_run_batch_with_progress")``, which is location-agnostic).
+It is the sole WRITER of ``self._is_batch_mode`` (read by the base ``run``); that field
+is initialised on the base ``__init__`` and stubbed annotation-only below. ``run_rerun``
+is PUBLIC (dispatched via ``run_method="run_rerun"`` from ``lib/_generation.py``) so its
+signature is byte-identical. Method bodies are moved VERBATIM from the former monolithic
+``base_generation_service.py``.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from reflexio.server.services.operation_state_utils import OperationStateManager
+
+logger = logging.getLogger(__name__)
+
+TRequest = TypeVar("TRequest")
+
+
+class BatchProgressMixin(Generic[TRequest]):  # noqa: UP046
+    """Batch-with-progress driver + rerun template method and hooks.
+
+    Mixed into ``BaseGenerationService`` ahead of the other mixins and ``ABC``. Every
+    ``self.`` call resolves either to a sibling hook on this mixin or, via MRO, to a
+    base-owned method (``run``, ``_create_state_manager``, ``_get_base_service_name``)
+    or the base-initialised ``_is_batch_mode`` field — the annotation-only / type-only
+    stubs below give pyright the types without introducing shared class-level state.
+    """
+
+    # Annotation-only stub for the base-owned field this driver WRITES (init'd in the
+    # base ``__init__``). NEVER assign here — a class-level default would be a
+    # shared-state footgun on a mixin.
+    _is_batch_mode: bool
+
+    if TYPE_CHECKING:
+        # Abstract on the base ABC (stays there per SINK-2); declared type-only so
+        # pyright can resolve the ``self._get_base_service_name()`` call. No runtime
+        # attribute is added, so ``__abstractmethods__`` is unaffected.
+        def _get_base_service_name(self) -> str: ...
+        # Concrete on the base (the FIFO-drain orchestrator + lock/queue helper);
+        # resolved via MRO. Declared type-only so pyright can resolve the calls.
+        def run(self, request: TRequest) -> None: ...
+        def _create_state_manager(self) -> OperationStateManager: ...
+
+    # ===============================
+    # Batch with progress (shared by rerun + manual)
+    # ===============================
+
+    def _run_batch_with_progress(
+        self,
+        user_ids: list[str],
+        request: TRequest,
+        request_params: dict,
+        state_manager: OperationStateManager,
+    ) -> tuple[int, int]:
+        """Run a batch of users with progress tracking.
+
+        Shared logic for both run_rerun() and run_manual_regular().
+        Initializes progress, processes each user, and finalizes.
+        Checks for cancellation before each user.
+
+        Args:
+            user_ids: List of user IDs to process
+            request: The original request object
+            request_params: Parameters dict for progress state
+            state_manager: OperationStateManager instance
+
+        Returns:
+            Tuple of (users_processed, total_generated)
+        """
+        total_users = len(user_ids)
+        self._is_batch_mode = True
+
+        try:
+            # Initialize progress. Kept inside the try so a raise here still
+            # resets _is_batch_mode via the finally (no leak into the next op).
+            state_manager.initialize_progress(
+                total_users=total_users,
+                request_params=request_params,
+            )
+
+            # Process each user
+            users_processed = 0
+            processed_user_ids: list[str] = []
+            for user_id in user_ids:
+                # Check for cancellation before starting next user
+                if state_manager.is_cancellation_requested():
+                    logger.info(
+                        "Cancellation requested for %s, stopping after %d/%d users",
+                        self._get_base_service_name(),
+                        users_processed,
+                        total_users,
+                    )
+                    state_manager.mark_cancelled()
+                    return users_processed, self._get_generated_count(
+                        request, processed_user_ids=processed_user_ids
+                    )
+
+                state_manager.set_current_item(user_id)
+
+                try:
+                    run_request = self._create_run_request_for_item(user_id, request)
+                    self.run(run_request)
+                    users_processed += 1
+                    processed_user_ids.append(user_id)
+
+                    state_manager.update_progress(
+                        item_id=user_id,
+                        count=0,  # Extractors collect their own data
+                        success=True,
+                        total_users=total_users,
+                    )
+
+                except Exception as e:
+                    logger.error(
+                        "Failed to process user %s for %s: %s",
+                        user_id,
+                        self._get_base_service_name(),
+                        str(e),
+                    )
+                    state_manager.update_progress(
+                        item_id=user_id,
+                        count=0,
+                        success=False,
+                        total_users=total_users,
+                        error=str(e),
+                    )
+                    continue
+
+            # Get generated count and finalize
+            total_generated = self._get_generated_count(
+                request, processed_user_ids=processed_user_ids
+            )
+            state_manager.finalize_progress(users_processed, total_generated)
+
+            return users_processed, total_generated
+        finally:
+            self._is_batch_mode = False
+
+    # ===============================
+    # Rerun methods (optional - override to enable rerun functionality)
+    # ===============================
+
+    def _get_rerun_user_ids(self, request: TRequest) -> list[str]:
+        """Get user IDs to process during rerun.
+
+        Override this method to enable rerun functionality for the service.
+        Returns a list of user IDs that have interactions matching the request filters.
+        Each extractor collects its own data using its configured window_size.
+
+        Args:
+            request: The rerun request object
+
+        Returns:
+            List of user IDs to process
+        """
+        raise NotImplementedError("Rerun not supported by this service")
+
+    def _build_rerun_request_params(self, request: TRequest) -> dict:
+        """Build request params dict for operation state tracking.
+
+        Override this method to enable rerun functionality for the service.
+
+        Args:
+            request: The rerun request object
+
+        Returns:
+            Dictionary of request parameters for state tracking
+        """
+        raise NotImplementedError("Rerun not supported by this service")
+
+    def _create_run_request_for_item(self, user_id: str, request: TRequest) -> TRequest:
+        """Create the request object to pass to self.run() for a single user.
+
+        Override this method to enable rerun functionality for the service.
+        Each extractor collects its own data using its configured window_size.
+
+        Args:
+            user_id: The user ID to process
+            request: The original rerun request object
+
+        Returns:
+            A request object suitable for self.run()
+        """
+        raise NotImplementedError("Rerun not supported by this service")
+
+    def _create_rerun_response(self, success: bool, msg: str, count: int) -> Any:
+        """Create the rerun response object.
+
+        Override this method to enable rerun functionality for the service.
+
+        Args:
+            success: Whether the operation succeeded
+            msg: Status message
+            count: Number of items generated
+
+        Returns:
+            A response object (e.g., RerunProfileGenerationResponse)
+        """
+        raise NotImplementedError("Rerun not supported by this service")
+
+    def _get_generated_count(
+        self,
+        request: TRequest,
+        processed_user_ids: list[str] | None = None,
+    ) -> int:
+        """Get the count of generated items (profiles or playbooks) after rerun.
+
+        Override this method to enable rerun functionality for the service.
+
+        Args:
+            request: The rerun request object (for filtering)
+            processed_user_ids: List of user IDs that were successfully processed
+                in the batch. Provided by _run_batch_with_progress so overrides
+                don't need to handle user_id=None from batch requests.
+
+        Returns:
+            Number of items generated during rerun
+        """
+        raise NotImplementedError("Rerun not supported by this service")
+
+    def _pre_process_rerun(self, request: TRequest) -> None:  # noqa: B027
+        """Hook called before processing rerun items.
+
+        Override in subclasses to perform cleanup or preparation before rerun.
+        Default implementation does nothing.
+
+        Args:
+            request: The rerun request object
+        """
+
+    def run_rerun(self, request: TRequest) -> Any:
+        """Run the rerun workflow for the service.
+
+        This template method orchestrates the rerun process:
+        1. Check for existing in-progress operations
+        2. Get user IDs to process
+        3. Pre-process hook
+        4. Run batch with progress tracking
+        5. Return response
+
+        Child classes must implement the hook methods to enable rerun functionality:
+        - _get_rerun_user_ids()
+        - _build_rerun_request_params()
+        - _create_run_request_for_item()
+        - _create_rerun_response()
+
+        Args:
+            request: The rerun request object
+
+        Returns:
+            A response object with success status, message, and count
+        """
+        state_manager = self._create_state_manager()
+
+        try:
+            # 1. Check for existing in-progress operation
+            error = state_manager.check_in_progress()
+            if error:
+                return self._create_rerun_response(False, error, 0)
+
+            # 2. Get user IDs to process
+            user_ids = self._get_rerun_user_ids(request)
+            if not user_ids:
+                return self._create_rerun_response(
+                    False, "No interactions found matching the specified filters", 0
+                )
+
+            # 3. Pre-process hook (e.g., delete existing pending items)
+            self._pre_process_rerun(request)
+
+            # 4. Run batch with progress tracking
+            users_processed, total_generated = self._run_batch_with_progress(
+                user_ids=user_ids,
+                request=request,
+                request_params=self._build_rerun_request_params(request),
+                state_manager=state_manager,
+            )
+
+            msg = f"Completed for {users_processed} user(s)"
+            return self._create_rerun_response(True, msg, total_generated)
+
+        except Exception as e:
+            state_manager.mark_progress_failed(str(e))
+            return self._create_rerun_response(
+                False,
+                f"Failed to run {self._get_base_service_name()}: {str(e)}",
+                0,
+            )

package/plugin/vendor/reflexio/reflexio/server/services/base_generation/_config_filter.py

@@ -0,0 +1,152 @@
+"""Config-filtering helpers for ``BaseGenerationService`` (Tier-1b decomposition).
+
+``ConfigFilterMixin`` holds the concrete, non-abstract config-filter helpers:
+``_filter_extractor_config_by_service_config`` (source/manual-trigger filtering),
+``_get_extractor_state_service_name`` (stride bookmark service name, overridable),
+and ``_filter_config_by_stride`` (pre-LLM stride_size gate). The abstract config
+LOADERS (``_load_extractor_config``, ``_load_generation_service_config``,
+``_create_extractor``) stay physically on the base ABC — an ``@abstractmethod`` on a
+plain mixin is dropped from ``__abstractmethods__``, so this mixin carries only the
+concrete helpers. Method bodies are moved verbatim from the former monolithic
+``base_generation_service.py``.
+"""
+
+import logging
+from typing import Generic, TypeVar
+
+from reflexio.server.api_endpoints.request_context import RequestContext
+from reflexio.server.services.extractor_config_utils import (
+    filter_extractor_configs,
+    get_extractor_name,
+)
+from reflexio.server.services.extractor_interaction_utils import (
+    get_effective_source_filter,
+    get_extractor_window_params,
+    should_extractor_run_by_stride,
+)
+from reflexio.server.services.operation_state_utils import OperationStateManager
+from reflexio.server.services.storage.storage_base import BaseStorage
+
+logger = logging.getLogger(__name__)
+
+TExtractorConfig = TypeVar("TExtractorConfig")
+TGenerationServiceConfig = TypeVar("TGenerationServiceConfig")
+
+
+class ConfigFilterMixin(Generic[TExtractorConfig, TGenerationServiceConfig]):  # noqa: UP046
+    """Concrete config-filter helpers mixed into ``BaseGenerationService``.
+
+    Mixed into the base ahead of ``ABC``; the per-run ``self`` attributes these
+    helpers read (``service_config``, ``storage``, ``org_id``, ``request_context``)
+    are initialised on the base ``__init__`` — the annotation-only stubs below give
+    pyright the types without introducing shared class-level mutable state.
+    """
+
+    # Annotation-only stubs for base-owned attributes these helpers read (init'd in
+    # the base ``__init__``). NEVER assign here — a class-level default would be a
+    # shared-state footgun on a mixin.
+    service_config: TGenerationServiceConfig | None
+    storage: BaseStorage | None
+    org_id: str
+    request_context: RequestContext
+
+    def _filter_extractor_config_by_service_config(
+        self,
+        extractor_config: TExtractorConfig,
+        service_config: TGenerationServiceConfig,
+    ) -> TExtractorConfig | None:
+        """
+        Filter the extractor config based on request_sources_enabled and manual_trigger.
+        """
+        filtered = filter_extractor_configs(
+            extractor_configs=[extractor_config],
+            source=getattr(service_config, "source", None),
+            allow_manual_trigger=getattr(service_config, "allow_manual_trigger", False),
+        )
+        return filtered[0] if filtered else None
+
+    def _get_extractor_state_service_name(self) -> str | None:
+        """
+        Get the service name used for extractor state (stride_size bookmark) lookups.
+
+        Override in subclasses that support stride_size-based pre-filtering to return
+        the OperationStateManager service name (e.g., "profile_extractor", "playbook_extractor").
+        Returns None by default, meaning stride_size pre-filtering is skipped.
+
+        Returns:
+            Optional[str]: Service name for OperationStateManager, or None to skip stride_size pre-filtering
+        """
+        return None
+
+    def _filter_config_by_stride(
+        self, extractor_config: TExtractorConfig
+    ) -> TExtractorConfig | None:
+        """
+        Filter extractor config by stride_size check before the should_run LLM call.
+
+        Skips filtering when:
+        - _get_extractor_state_service_name() returns None (service doesn't support stride_size)
+        - auto_run is False (rerun/manual flows skip stride_size)
+
+        Args:
+            extractor_config: Extractor config after source/manual_trigger filtering
+
+        Returns:
+            Extractor config when it passes the stride_size check, otherwise None.
+        """
+        state_service_name = self._get_extractor_state_service_name()
+        if state_service_name is None:
+            return extractor_config
+
+        if not getattr(self.service_config, "auto_run", True):
+            return extractor_config
+
+        if getattr(self.service_config, "force_extraction", False):
+            return extractor_config
+
+        root_config = self.request_context.configurator.get_config()
+        global_window_size = (
+            getattr(root_config, "window_size", None) if root_config else None
+        )
+        global_stride_size = (
+            getattr(root_config, "stride_size", None) if root_config else None
+        )
+
+        state_manager = OperationStateManager(
+            self.storage,  # type: ignore[reportArgumentType]
+            self.org_id,
+            state_service_name,  # type: ignore[reportArgumentType]
+        )
+
+        name = get_extractor_name(extractor_config)
+        _, stride_size = get_extractor_window_params(
+            extractor_config, global_window_size, global_stride_size
+        )
+
+        # Resolve effective source filter for this extractor
+        should_skip, effective_source = get_effective_source_filter(
+            extractor_config, getattr(self.service_config, "source", None)
+        )
+        if should_skip:
+            return None
+
+        (
+            _,
+            new_interactions,
+        ) = state_manager.get_extractor_state_with_new_interactions(
+            extractor_name=name,
+            user_id=getattr(self.service_config, "user_id", None),
+            sources=effective_source,
+        )
+        new_count = sum(len(ri.interactions) for ri in new_interactions)
+
+        if should_extractor_run_by_stride(new_count, stride_size):
+            return extractor_config
+
+        logger.info(
+            "Stride pre-filter: skipping extractor '%s' (new=%d, stride_size=%s)",
+            name,
+            new_count,
+            stride_size,
+        )
+        return None

package/plugin/vendor/reflexio/reflexio/server/services/base_generation/_extraction_lifecycle.py

@@ -0,0 +1,243 @@
+"""Extraction-run lifecycle helpers for ``BaseGenerationService`` (Tier-1b decomposition).
+
+``ExtractionRunLifecycleMixin`` holds the four concrete methods that run the
+configured extractor and drive the agent-run rows through their terminal states:
+``_execute_extractor`` (thread-pool run + timeout guard), ``_fail_active_extraction_runs``
+(timeout cleanup), ``_finalize_extraction_runs`` (success finalization), and
+``_mark_extraction_runs_finalization_failed`` (failure/backoff).
+
+``_execute_extractor`` writes the per-run billing accumulators — ``_last_extractor_run_stats``,
+``_last_extraction_run_ids`` (appended on an ``ExtractionOutcome`` run id), and
+``_last_token_totals`` (set ONLY under ``isinstance(result, ExtractionOutcome)``). Those
+writes and their guards are moved VERBATIM: the ``isinstance`` write-guard is the double-bill
+idempotency backstop (a non-``ExtractionOutcome`` result must NOT overwrite the accumulator),
+and ``_finalize_extraction_runs`` / ``_mark_extraction_runs_finalization_failed`` are invoked
+from ``_run_generation`` (still on the base) via ``self.`` MRO — the atomicity invariant
+(``_mark_..._failed`` on a ``_process_results`` failure, not finalize) depends on both bodies
+being unchanged.
+
+``ExtractorExecutionError`` and ``EXTRACTOR_TIMEOUT_SECONDS`` live in
+``base_generation_service`` and are imported function-locally to avoid a circular import
+(the base module imports this package at load time). Method bodies are otherwise moved
+verbatim from the former monolithic ``base_generation_service.py``.
+"""
+
+import contextvars
+import logging
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import TimeoutError as FuturesTimeoutError
+from datetime import UTC, datetime, timedelta
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from reflexio.server.api_endpoints.request_context import RequestContext
+from reflexio.server.llm.token_accounting import RunTokenTotals
+from reflexio.server.services.extraction.outcome import ExtractionOutcome
+from reflexio.server.services.extractor_config_utils import get_extractor_name
+from reflexio.server.services.storage.storage_base import AgentRunStatus, BaseStorage
+
+logger = logging.getLogger(__name__)
+
+TExtractorConfig = TypeVar("TExtractorConfig")
+TGenerationServiceConfig = TypeVar("TGenerationServiceConfig")
+
+
+class ExtractionRunLifecycleMixin(Generic[TExtractorConfig, TGenerationServiceConfig]):  # noqa: UP046
+    """Extractor execution + agent-run terminal-state transitions.
+
+    Mixed into ``BaseGenerationService`` ahead of the other mixins and ``ABC``; the
+    per-run ``self`` attributes these methods read/write (``service_config``,
+    ``storage``, ``request_context`` and the billing accumulators
+    ``_last_extractor_run_stats`` / ``_last_extraction_run_ids`` / ``_last_token_totals``)
+    are initialised on the base ``__init__`` — the annotation-only stubs below give
+    pyright the types without introducing shared class-level mutable state.
+    """
+
+    # Annotation-only stubs for base-owned attributes these helpers read/write (init'd
+    # in the base ``__init__``). NEVER assign here — a class-level default would be a
+    # shared-state footgun on a mixin.
+    service_config: TGenerationServiceConfig | None
+    storage: BaseStorage | None
+    request_context: RequestContext
+    _last_extractor_run_stats: dict[str, int]
+    _last_extraction_run_ids: list[str]
+    _last_token_totals: RunTokenTotals | None
+
+    if TYPE_CHECKING:
+        # Abstract on the base ABC (stays there per SINK-2); declared here type-only so
+        # pyright can resolve the ``self._create_extractor()`` / ``self._get_service_name()``
+        # calls. No runtime attribute is added, so ``__abstractmethods__`` is unaffected.
+        def _create_extractor(
+            self,
+            extractor_config: TExtractorConfig,
+            service_config: TGenerationServiceConfig,
+        ) -> Any: ...
+        def _get_service_name(self) -> str: ...
+
+    def _execute_extractor(
+        self,
+        extractor_config: TExtractorConfig,
+        identifier: str,
+    ) -> Any | None:
+        """
+        Run the configured extractor with timeout and error handling.
+
+        The extractor runs in a thread pool with a timeout guard so providers that
+        ignore their own timeout cannot block generation forever.
+
+        Args:
+            extractor_config: Filtered extractor config to execute
+            identifier: Logging context identifier (user_id or request_id)
+
+        Returns:
+            Extractor result, or None if the extractor succeeded with no output.
+
+        Raises:
+            ExtractorExecutionError: If the extractor fails with an exception or timeout.
+        """
+        from reflexio.server.services.base_generation_service import (
+            EXTRACTOR_TIMEOUT_SECONDS,
+            ExtractorExecutionError,
+        )
+
+        if (
+            self.service_config is None
+        ):  # pragma: no cover — set by _prepare_generation_run
+            raise RuntimeError("service_config must be set before executing extractor")
+
+        self._last_extractor_run_stats = {"total": 1, "failed": 0, "timed_out": 0}
+        extractor = self._create_extractor(extractor_config, self.service_config)
+        executor: ThreadPoolExecutor | None = None
+        try:
+            executor = ThreadPoolExecutor(max_workers=1)
+            # Copy context so correlation ID propagates to worker thread
+            ctx = contextvars.copy_context()
+            future = executor.submit(ctx.run, extractor.run)  # type: ignore[reportAttributeAccessIssue]
+            result = future.result(timeout=EXTRACTOR_TIMEOUT_SECONDS)
+            if isinstance(result, ExtractionOutcome):
+                if result.run_id:
+                    self._last_extraction_run_ids.append(result.run_id)
+                self._last_token_totals = result.token_totals
+                if result.status == "completed" and result.items:
+                    return result.items
+                logger.info(
+                    "No results generated for %s identifier: %s",
+                    self._get_service_name(),
+                    identifier,
+                )
+                return None
+            if result:
+                return result
+            logger.info(
+                "No results generated for %s identifier: %s",
+                self._get_service_name(),
+                identifier,
+            )
+            return None
+        except FuturesTimeoutError as exc:
+            self._last_extractor_run_stats = {"total": 1, "failed": 1, "timed_out": 1}
+            error_msg = (
+                f"Extractor timed out after {EXTRACTOR_TIMEOUT_SECONDS} seconds "
+                f"for {self._get_service_name()} identifier={identifier}"
+            )
+            logger.error(error_msg)
+            self._fail_active_extraction_runs(
+                extractor_kind=get_extractor_name(extractor_config),
+                last_error=error_msg,
+            )
+            raise ExtractorExecutionError(error_msg) from exc
+        except Exception as exc:
+            self._last_extractor_run_stats = {"total": 1, "failed": 1, "timed_out": 0}
+            error_msg = (
+                f"Extractor failed for {self._get_service_name()} "
+                f"identifier={identifier}: {exc} (type={type(exc).__name__})"
+            )
+            logger.error(error_msg)
+            raise ExtractorExecutionError(error_msg) from exc
+        finally:
+            if executor is not None:
+                executor.shutdown(wait=False, cancel_futures=True)
+
+    def _fail_active_extraction_runs(
+        self,
+        *,
+        extractor_kind: str,
+        last_error: str,
+    ) -> None:
+        """Mark active agent-run rows failed when the service timeout fires."""
+        if self.storage is None or self.service_config is None:
+            return
+        request_id = getattr(self.service_config, "request_id", None)
+        if not request_id:
+            return
+        user_id = getattr(self.service_config, "user_id", None)
+        try:
+            failed_count = self.storage.fail_running_agent_runs_for_request(
+                org_id=self.request_context.org_id,
+                extractor_kind=extractor_kind,
+                user_id=user_id,
+                request_id=request_id,
+                last_error=last_error,
+            )
+        except NotImplementedError:
+            return
+        except Exception as exc:  # noqa: BLE001 - keep timeout error primary
+            logger.warning(
+                "Failed to mark timed-out %s agent runs failed: %s",
+                extractor_kind,
+                exc,
+            )
+            return
+        if failed_count:
+            logger.warning(
+                "Marked %d timed-out %s agent run(s) failed for request_id=%s",
+                failed_count,
+                extractor_kind,
+                request_id,
+            )
+
+    def _finalize_extraction_runs(self) -> None:
+        if self.storage is None:
+            return
+        for run_id in self._last_extraction_run_ids:
+            run = self.storage.get_agent_run(run_id)
+            if run is None:
+                continue
+            status = (
+                AgentRunStatus.FINALIZED_PENDING_TOOL
+                if run.pending_tool_call_ids
+                else AgentRunStatus.FINALIZED
+            )
+            self.storage.update_agent_run_status(
+                run_id,
+                status,
+                pending_tool_call_ids=run.pending_tool_call_ids,
+            )
+
+    def _mark_extraction_runs_finalization_failed(self, exc: Exception) -> None:
+        if self.storage is None:
+            return
+        root_config = self.request_context.configurator.get_config()
+        pending_config = getattr(root_config, "pending_tool_call_config", None)
+        for run_id in self._last_extraction_run_ids:
+            run = self.storage.get_agent_run(run_id)
+            if run is None or run.committed_output is None:
+                continue
+            next_attempt_count = run.finalization_attempts + 1
+            max_attempts = (
+                pending_config.max_finalization_attempts
+                if pending_config is not None
+                else 3
+            )
+            status = (
+                AgentRunStatus.FAILED
+                if next_attempt_count >= max_attempts
+                else AgentRunStatus.FINALIZATION_FAILED
+            )
+            delay_seconds = min(300, max(1, 2 ** max(0, next_attempt_count - 1)))
+            self.storage.update_agent_run_status(
+                run_id,
+                status,
+                next_resume_at=datetime.now(UTC) + timedelta(seconds=delay_seconds),
+                last_error=str(exc),
+                increment_finalization_attempts=True,
+            )