Recover missing sections and bound search failures

app.py

@@ -182,7 +182,7 @@ def arxiv_search(topic: str, limit: int) -> list[dict[str, Any]]:
         "&sortBy=submittedDate&sortOrder=descending"
     )
     headers = {"User-Agent": f"algorithm-research-deck/1.0 ({os.getenv('CONTACT_EMAIL', 'contact-not-set')})"}
-    response = http_get_with_retries(url, headers=headers, read_timeout=90, attempts=3)
+    response = http_get_with_retries(url, headers=headers, read_timeout=35, attempts=2)
     ns = {"a": "http://www.w3.org/2005/Atom"}
     root = ElementTree.fromstring(response.text)
     papers = []
@@ -207,7 +207,7 @@ def openalex_search(query: str, limit: int) -> list[dict[str, Any]]:
     url = f"https://api.openalex.org/works?search={quote_plus(query)}&per-page={min(limit, 100)}"
     if email:
         url += f"&mailto={quote_plus(email)}"
-    response = http_get_with_retries(url, read_timeout=60, attempts=3)
+    response = http_get_with_retries(url, read_timeout=35, attempts=2)
     results = response.json().get("results", [])
     papers = []
     for work in results:
@@ -305,26 +305,46 @@ def plan_search_queries(request: ResearchRequest) -> tuple[list[str], dict[str,
     return queries[:6], english_understanding
 
 
+def search_error_summary(exc: Exception) -> str:
+    if exc.__cause__ is not None and isinstance(exc.__cause__, Exception):
+        return search_error_summary(exc.__cause__)
+    if isinstance(exc, httpx.HTTPStatusError):
+        return f"HTTP {exc.response.status_code}"
+    if isinstance(exc, httpx.TimeoutException) or "timed out" in str(exc).lower():
+        return "请求超时"
+    return type(exc).__name__
+
+
 def search_literature(queries: list[str], total_limit: int) -> tuple[list[dict[str, Any]], list[str]]:
     per_query = max(5, min(20, total_limit // max(1, len(queries))))
     buckets: list[list[dict[str, Any]]] = []
     warnings: list[str] = []
+    failures = {"arXiv": 0, "OpenAlex": 0}
     for query in queries:
         query_papers: list[dict[str, Any]] = []
-        try:
-            found = arxiv_search(query, per_query)
-            for paper in found:
-                paper["source"] = "arXiv"
-            query_papers.extend(found)
-        except Exception:
-            warnings.append(f"arXiv timeout: {query}")
-        if len(query_papers) < max(2, per_query // 4):
+        if failures["arXiv"] < 2:
+            try:
+                found = arxiv_search(query, per_query)
+                for paper in found:
+                    paper["source"] = "arXiv"
+                query_papers.extend(found)
+                failures["arXiv"] = 0
+            except Exception as exc:
+                failures["arXiv"] += 1
+                warnings.append(f"arXiv {search_error_summary(exc)}：{query}")
+        if len(query_papers) < max(2, per_query // 4) and failures["OpenAlex"] < 2:
             try:
                 query_papers.extend(openalex_search(query, per_query))
-            except Exception:
-                warnings.append(f"OpenAlex timeout: {query}")
+                failures["OpenAlex"] = 0
+            except Exception as exc:
+                failures["OpenAlex"] += 1
+                warnings.append(f"OpenAlex {search_error_summary(exc)}：{query}")
         buckets.append(deduplicate(query_papers))
 
+    for provider, count in failures.items():
+        if count >= 2:
+            warnings.append(f"{provider} 连续失败，已停止剩余重复请求")
+
     balanced: list[dict[str, Any]] = []
     max_bucket = max((len(bucket) for bucket in buckets), default=0)
     for index in range(max_bucket):
@@ -484,6 +504,31 @@ def validate_stage_with_repairs(
     raise RuntimeError(f"{stage_name} validation failed")
 
 
+def align_sections_to_plan(result: dict[str, Any], plans: list[SectionPlan]) -> dict[str, Any]:
+    """Order model sections by approved IDs and expose omissions to schema repair."""
+    candidates = [item for item in result.get("sections", []) if isinstance(item, dict)]
+    by_id = {str(item.get("id")): item for item in candidates if item.get("id")}
+    plan_ids = {plan.id for plan in plans}
+    unused = [item for item in candidates if str(item.get("id", "")) not in plan_ids]
+    aligned = []
+    for plan in plans:
+        candidate = by_id.get(plan.id)
+        if candidate is None and unused:
+            candidate = unused.pop(0)
+        candidate = dict(candidate or {})
+        candidate.update({
+            "id": plan.id,
+            "title": plan.title,
+            "purpose": plan.purpose,
+            "layout": plan.layout,
+        })
+        candidate.setdefault("takeaway", "")
+        candidate.setdefault("content", {})
+        candidate.setdefault("source_ids", [])
+        aligned.append(candidate)
+    return {"sections": aligned}
+
+
 def prepare_evidence_inputs(
     papers: list[dict[str, Any]], deep_texts: dict[str, str], limit: int
 ) -> list[dict[str, Any]]:
@@ -648,12 +693,7 @@ def build_report(
             }, ensure_ascii=False),
             4200,
         )
-        candidates = sections_result.get("sections", [])
-        for plan, candidate in zip(batch, candidates):
-            if isinstance(candidate, dict):
-                candidate.update({
-                    "id": plan.id, "title": plan.title, "purpose": plan.purpose, "layout": plan.layout,
-                })
+        sections_result = align_sections_to_plan(sections_result, batch)
         validated_batch = validate_stage_with_repairs(
             sections_result,
             SectionsEnvelope,
@@ -662,7 +702,37 @@ def build_report(
             4200,
         )
         if len(validated_batch.sections) != len(batch):
-            raise RuntimeError("The model omitted one or more approved report sections")
+            recovered_sections: list[ReportSection] = []
+            for plan in batch:
+                one_result = chat_json(
+                    section_system,
+                    json.dumps({
+                        **shared_context,
+                        "report_identity": {
+                            "title": outline.title,
+                            "research_type": outline.research_type,
+                            "executive_summary": outline.executive_summary,
+                        },
+                        "approved_section_plan": [plan.model_dump()],
+                        "requirements": {
+                            "return_exactly_one_section": True,
+                            "preserve_plan_identity_and_layout": True,
+                            "source_ids": "Only IDs present in evidence_cards; otherwise []",
+                            "schema": SectionsEnvelope.model_json_schema(),
+                        },
+                    }, ensure_ascii=False),
+                    2600,
+                )
+                one_result = align_sections_to_plan(one_result, [plan])
+                recovered = validate_stage_with_repairs(
+                    one_result,
+                    SectionsEnvelope,
+                    f"missing report section {plan.id}",
+                    {**shared_context, "approved_section_plan": [plan.model_dump()]},
+                    2800,
+                )
+                recovered_sections.append(recovered.sections[0])
+            validated_batch = SectionsEnvelope(sections=recovered_sections)
         for plan, section in zip(batch, validated_batch.sections):
             normalized = section.model_dump()
             normalized.update({

tests/test_app.py

@@ -4,7 +4,7 @@ from unittest.mock import patch
 
 from pydantic import ValidationError
 
-from app import ResearchReport, chat_json, deduplicate, infer_section_source_ids, normalize_comparison, normalize_process, parse_json_object, prepare_evidence_inputs, preview_frame, render_presentation, render_section_content, render_value, safe_slug, search_literature, serializable_validation_errors
+from app import ResearchReport, SectionPlan, align_sections_to_plan, chat_json, deduplicate, infer_section_source_ids, normalize_comparison, normalize_process, parse_json_object, prepare_evidence_inputs, preview_frame, render_presentation, render_section_content, render_value, safe_slug, search_literature, serializable_validation_errors
 
 
 def base_report(section):
@@ -50,6 +50,26 @@ class AppTests(unittest.TestCase):
         self.assertEqual(papers[0]["id"], "oa-1")
         mocked_openalex.assert_called_once()
 
+    @patch("app.openalex_search", side_effect=TimeoutError("offline"))
+    @patch("app.arxiv_search", side_effect=TimeoutError("offline"))
+    def test_search_stops_repeating_failed_providers(self, mocked_arxiv, mocked_openalex):
+        papers, warnings = search_literature([f"query-{i}" for i in range(5)], 20)
+        self.assertEqual(papers, [])
+        self.assertEqual(mocked_arxiv.call_count, 2)
+        self.assertEqual(mocked_openalex.call_count, 2)
+        self.assertTrue(any("已停止剩余重复请求" in warning for warning in warnings))
+
+    def test_missing_standard_and_deep_sections_are_exposed_for_repair(self):
+        plans = [
+            SectionPlan(id=f"section-{i}", title=f"Section {i}", purpose="Explain one distinct technical decision.", layout="text")
+            for i in range(4)
+        ]
+        partial = {"sections": [{"id": "section-0", "takeaway": "Only the first section was returned.", "content": {"points": ["A substantive point"]}}]}
+        aligned = align_sections_to_plan(partial, plans)
+        self.assertEqual(len(aligned["sections"]), 4)
+        self.assertEqual([item["id"] for item in aligned["sections"]], [plan.id for plan in plans])
+        self.assertEqual(aligned["sections"][1]["content"], {})
+
     def test_parser_removes_invalid_string_line_continuation(self):
         self.assertEqual(parse_json_object('{"title":"A\\\nB","value":1}'), {"title": "AB", "value": 1})