feat(llm): add overall timeout to ArticleFactChecker & add arXiv package

[seancoding-day]

No description provided.

[gemini-code-assist]

Code Review

This pull request introduces a wall-clock timeout mechanism for the ArticleFactChecker agent, including new configuration parameters, clamping logic, and a structured error response for timeout events. It also adds the arxiv dependency to the agent requirements. Feedback was provided to refactor duplicated timeout handling logic and to replace a magic number with a named constant to improve maintainability.

[gemini-code-assist]

There's some code duplication in the timeout handling logic within the except blocks. This can be refactored into a local helper function to improve maintainability.

Additionally, the 30 second margin added to the fallback timeout is a magic number. It would be better to define this as a local constant for clarity.

Here's a suggested refactoring that addresses both points:

        async def _run_with_timeout() -> EvalDetail:
            return await asyncio.wait_for(
                cls._async_eval(input_data, start_time, output_dir),
                timeout=timeout,
            )

        FALLBACK_TIMEOUT_MARGIN = 30  # seconds
        def _handle_timeout_error(is_fallback: bool = False):
            elapsed = time.time() - start_time
            path_str = " (fallback path)" if is_fallback else ""
            log.warning(
                f"ArticleFactChecker: overall timeout exceeded "
                f"({elapsed:.1f}s / {timeout:.0f}s limit{path_str})"
            )
            return cls._create_overall_timeout_result(elapsed, timeout)

        try:
            return asyncio.run(_run_with_timeout())
        except asyncio.TimeoutError:
            return _handle_timeout_error()
        except RuntimeError as e:
            # Fallback when called inside an already-running event loop (e.g. Jupyter, tests)
            if "cannot run" in str(e).lower() or "already running" in str(e).lower():
                import concurrent.futures
                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
                    future = pool.submit(lambda: asyncio.run(_run_with_timeout()))
                    try:
                        # Extra margin so asyncio.wait_for fires before this outer timeout
                        return future.result(timeout=timeout + FALLBACK_TIMEOUT_MARGIN)
                    except (asyncio.TimeoutError, concurrent.futures.TimeoutError):
                        return _handle_timeout_error(is_fallback=True)
            raise