Fix/ai summary async timeout

backend/secuscan/ai_summary.py

@@ -11,7 +11,7 @@
 """
 
 from __future__ import annotations
-
+import asyncio
 import logging
 import re
 from collections import Counter
@@ -95,7 +95,7 @@ def _build_prompt(findings: list[dict]) -> str:
     )
 
 
-def generate_summary(
+async def generate_summary(
     findings: list[dict],
     model: str,
     api_key: str,
@@ -109,16 +109,16 @@ def generate_summary(
         model:    Model name e.g. ``"gpt-4o-mini"`` or ``"llama3"``.
         api_key:  API key for the OpenAI-compatible endpoint.
         base_url: Optional base URL override for non-OpenAI providers.
-        timeout:  HTTP timeout in seconds (default 15). Prevents LLM calls
-                  from stalling report generation.
+        timeout:  Hard timeout in seconds (default 15). If the LLM exceeds
+                  this, the call is cancelled and ``""`` is returned so that
+                  report export is never blocked.
 
     Returns:
         A plain-text executive summary string, or ``""`` on any failure so
         that callers always get a safe value to embed in reports.
     """
     if not findings:
         return ""
-
     if OpenAI is None:
         logger.warning(
             "ai_summary: 'openai' package not installed. "
@@ -131,16 +131,25 @@ def generate_summary(
     if base_url:
         client_kwargs["base_url"] = base_url
 
-    try:
+    async def _call() -> str:
+        loop = asyncio.get_running_loop()
         client = OpenAI(**client_kwargs)
-        response = client.chat.completions.create(
-            model=model,
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=300,
-            temperature=0.4,
+        response = await loop.run_in_executor(
+            None,
+            lambda: client.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=300,
+                temperature=0.4,
+            ),
         )
-        summary = response.choices[0].message.content or ""
-        return summary.strip()
+        return (response.choices[0].message.content or "").strip()
+
+    try:
+        return await asyncio.wait_for(_call(), timeout=timeout)
+    except asyncio.TimeoutError:
+        logger.warning("ai_summary: LLM call timed out after %.1fs — skipping summary", timeout)
+        return ""
     except Exception as exc:  # noqa: BLE001
         logger.warning("ai_summary: LLM call failed — %s", exc)
         return ""

backend/secuscan/reporting.py

@@ -1,3 +1,4 @@
+import asyncio
 import base64
 import csv
 import html
@@ -102,14 +103,14 @@ def _generate_severity_chart(cls, severity_counts: Dict[str, int]) -> str:
             output.close()
 
     @classmethod
-    def _get_ai_summary(cls, findings):
+    async def _get_ai_summary(cls, findings):
         """Return an AI executive summary, or '' when the feature is disabled."""
         from .config import settings as _settings
         if not _settings.ai_summary_enabled:
             return ""
         if not _settings.ai_summary_api_key:
             return ""
-        return generate_summary(
+        return await generate_summary(
             findings=findings,
             model=_settings.ai_summary_model,
             api_key=_settings.ai_summary_api_key,
@@ -402,7 +403,10 @@ def _generate_pdf_html_report(cls, task: Dict[str, Any], result: Dict[str, Any])
         payload = cls._build_report_payload(task, result)
         findings = payload["findings"]
         severity_counts = payload["severity_counts"]
-        ai_summary = cls._get_ai_summary(findings)
+        try:
+          ai_summary = asyncio.run(cls._get_ai_summary(findings))
+        except Exception:
+          ai_summary = ""
         shield_icon = cls._icon_data_uri("shield", "1e3a5f")
         target_icon = cls._icon_data_uri("target", "2563eb")
         findings_icon = cls._icon_data_uri("findings", "0f172a")
@@ -731,7 +735,10 @@ def generate_html_report(cls, task: Dict[str, Any], result: Dict[str, Any]) -> s
         payload = cls._build_report_payload(task, result)
         findings = payload["findings"]
         severity_counts = payload["severity_counts"]
-        ai_summary = cls._get_ai_summary(findings)
+        try:
+          ai_summary = asyncio.run(cls._get_ai_summary(findings))
+        except Exception:
+          ai_summary = ""
         shield_icon = cls._icon_data_uri("shield", "1e3a5f")
         target_icon = cls._icon_data_uri("target", "2563eb")
         findings_icon = cls._icon_data_uri("findings", "0f172a")

frontend/src/pages/Findings.tsx

@@ -824,7 +824,7 @@ export default function Findings() {
             </div>
 
             <div className="flex flex-col gap-6">
-              <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4">
+              <div className="grid gap-x-4 gap-y-5 grid-cols-[repeat(auto-fit,minmax(180px,1fr))]">
                 <div className="space-y-2 min-w-0">
                   <label className={filterLabelClass}>Target</label>
                   <select

frontend/testing/unit/pages/Findings.test.tsx

@@ -328,7 +328,7 @@ describe('Findings — virtualized list', () => {
     expect(fieldContainer).toHaveClass('space-y-2', 'min-w-0')
 
     const gridContainer = fieldContainer?.parentElement
-    expect(gridContainer).toHaveClass('grid', 'gap-4', 'sm:grid-cols-2', 'lg:grid-cols-3', 'xl:grid-cols-4')
+    expect(gridContainer).toHaveClass('grid', 'gap-x-4', 'gap-y-5')
 
     const filterContainer = gridContainer?.parentElement
     expect(filterContainer).toHaveClass('flex', 'flex-col', 'gap-6')

testing/backend/unit/test_ai_summary.py

@@ -8,7 +8,7 @@
 """
 
 from __future__ import annotations
-
+import asyncio
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -76,40 +76,40 @@ def test_returns_summary_string(self):
         expected = "The scan found 5 findings including a critical SQL injection."
         with patch("backend.secuscan.ai_summary.OpenAI") as mock_cls:
             mock_cls.return_value.chat.completions.create.return_value = _mock_response(expected)
-            result = generate_summary(SAMPLE_FINDINGS, "gpt-4o-mini", "test-key")
+            result = asyncio.run(generate_summary(SAMPLE_FINDINGS, "gpt-4o-mini", "test-key"))
         assert result == expected
 
     def test_strips_whitespace(self):
         with patch("backend.secuscan.ai_summary.OpenAI") as mock_cls:
             mock_cls.return_value.chat.completions.create.return_value = _mock_response("  Summary.  ")
-            result = generate_summary(SAMPLE_FINDINGS, "gpt-4o-mini", "key")
+            result = asyncio.run(generate_summary(SAMPLE_FINDINGS, "gpt-4o-mini", "key"))
         assert result == "Summary."
 
     def test_passes_base_url_to_client(self):
         with patch("backend.secuscan.ai_summary.OpenAI") as mock_cls:
             mock_cls.return_value.chat.completions.create.return_value = _mock_response("ok")
-            generate_summary(
+            asyncio.run(generate_summary(
                 SAMPLE_FINDINGS, model="llama3", api_key="ollama",
                 base_url="http://localhost:11434/v1",
-            )
+            ))
             mock_cls.assert_called_once_with(
                 api_key="ollama", base_url="http://localhost:11434/v1", timeout=15.0
             )
 
     def test_returns_empty_string_on_llm_exception(self):
         with patch("backend.secuscan.ai_summary.OpenAI") as mock_cls:
             mock_cls.return_value.chat.completions.create.side_effect = RuntimeError("conn refused")
-            assert generate_summary(SAMPLE_FINDINGS, "gpt-4o-mini", "key") == ""
+            assert asyncio.run(generate_summary(SAMPLE_FINDINGS, "gpt-4o-mini", "key")) == ""
 
     def test_returns_empty_string_for_empty_findings(self):
         with patch("backend.secuscan.ai_summary.OpenAI") as mock_cls:
-            result = generate_summary([], "gpt-4o-mini", "key")
+            result = asyncio.run(generate_summary([], "gpt-4o-mini", "key"))
         assert result == ""
         mock_cls.assert_not_called()
 
     def test_returns_empty_string_when_openai_none(self):
         with patch("backend.secuscan.ai_summary.OpenAI", None):
-            result = generate_summary(SAMPLE_FINDINGS, "gpt-4o-mini", "key")
+            result = asyncio.run(generate_summary(SAMPLE_FINDINGS, "gpt-4o-mini", "key"))
         assert result == ""
 
 
@@ -178,7 +178,7 @@ def test_get_ai_summary_returns_empty_when_no_api_key(self):
         with patch("backend.secuscan.config.settings") as ms:
             ms.ai_summary_enabled = True
             ms.ai_summary_api_key = ""
-            result = ReportGenerator._get_ai_summary([{"title": "x", "severity": "high"}])
+            result = asyncio.run(ReportGenerator._get_ai_summary([{"title": "x", "severity": "high"}]))
         assert result == ""
 
     def test_sarif_report_unchanged(self):