fix empty research findings

tests/test_research_findings.py

@@ -0,0 +1,151 @@
+# tests/test_research_findings.py
+from __future__ import annotations
+
+import json
+import unittest
+from unittest.mock import patch
+
+from langchain_core.messages import AIMessage, ToolMessage
+
+from ui.agent.graph.nodes.helpers import extract_assistant_text, research_tool_calls
+from ui.agent.synthesis import synthesize_finding_from_tool_messages
+
+
+class ExtractAssistantTextTests(unittest.TestCase):
+    def test_plain_string_content(self) -> None:
+        message = AIMessage(content="## Eligibility\nYou may qualify.")
+        self.assertEqual(extract_assistant_text(message), "## Eligibility\nYou may qualify.")
+
+    def test_list_content_blocks(self) -> None:
+        message = AIMessage(
+            content=[
+                {"type": "text", "text": "Line one"},
+                {"type": "text", "text": "Line two"},
+            ]
+        )
+        self.assertEqual(extract_assistant_text(message), "Line one\nLine two")
+
+    def test_reasoning_only_message(self) -> None:
+        message = AIMessage(content="", additional_kwargs={"reasoning_content": "Final report"})
+        self.assertEqual(extract_assistant_text(message), "Final report")
+
+    def test_strips_think_wrappers(self) -> None:
+        open_tag = "<" + "think" + ">"
+        close_tag = "</" + "think" + ">"
+        message = AIMessage(
+            content=(
+                f"{open_tag}internal reasoning{close_tag}\n\n"
+                "## Findings\nCanada Express Entry."
+            )
+        )
+        extracted = extract_assistant_text(message)
+        self.assertIn("## Findings", extracted)
+        self.assertNotIn("internal reasoning", extracted)
+
+    def test_prefers_content_over_reasoning(self) -> None:
+        message = AIMessage(
+            content="Visible answer",
+            additional_kwargs={"reasoning_content": "Hidden reasoning"},
+        )
+        self.assertEqual(extract_assistant_text(message), "Visible answer")
+
+
+class ResearchToolCallsTests(unittest.TestCase):
+    def test_parses_tool_calls_from_reasoning(self) -> None:
+        reasoning = 'search_immigration_info{"query": "Canada Express Entry"}'
+        message = AIMessage(content="", additional_kwargs={"reasoning_content": reasoning})
+        calls = research_tool_calls(message)
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(calls[0][0], "search_immigration_info")
+        self.assertEqual(calls[0][1]["query"], "Canada Express Entry")
+
+
+class SynthesizeFindingTests(unittest.TestCase):
+    def test_builds_fallback_from_search_results(self) -> None:
+        todo = {"id": 1, "country": "Canada", "methods": "Express Entry"}
+        payload = {
+            "query": "Canada Express Entry",
+            "num_results": 1,
+            "results": [
+                {
+                    "title": "Express Entry",
+                    "url": "https://www.canada.ca/en/immigration/express-entry.html",
+                    "highlights": ["Skilled workers may apply through Express Entry."],
+                }
+            ],
+        }
+        tool_messages = [ToolMessage(content=json.dumps(payload), tool_call_id="abc")]
+        summary = synthesize_finding_from_tool_messages(todo, tool_messages)
+        self.assertIn("Canada", summary)
+        self.assertIn("Express Entry", summary)
+        self.assertIn("canada.ca", summary)
+        self.assertNotEqual(summary, "")
+
+    def test_returns_empty_without_tool_evidence(self) -> None:
+        todo = {"id": 1, "country": "Canada", "methods": "Express Entry"}
+        self.assertEqual(
+            synthesize_finding_from_tool_messages(todo, []),
+            "",
+        )
+
+
+class ResearcherFallbackTests(unittest.TestCase):
+    @patch("ui.agent.graph.nodes.researcher.build_llm")
+    @patch("ui.agent.graph.nodes.researcher.get_stream_writer")
+    @patch("ui.agent.graph.nodes.researcher.execute_tool_call")
+    def test_uses_tool_fallback_when_llm_summary_empty(
+        self,
+        mock_execute_tool_call: unittest.mock.Mock,
+        mock_get_stream_writer: unittest.mock.Mock,
+        mock_build_llm: unittest.mock.Mock,
+    ) -> None:
+        from ui.agent.graph.nodes.researcher import researcher_node
+
+        mock_get_stream_writer.return_value = lambda _event: None
+        mock_execute_tool_call.return_value = json.dumps(
+            {
+                "query": "Germany Blue Card",
+                "num_results": 1,
+                "results": [
+                    {
+                        "title": "EU Blue Card",
+                        "url": "https://www.make-it-in-germany.com/en/visa-residence/eu-blue-card",
+                        "highlights": ["The EU Blue Card is for qualified professionals."],
+                    }
+                ],
+            }
+        )
+
+        search_response = AIMessage(
+            content="",
+            tool_calls=[
+                {
+                    "name": "search_immigration_info",
+                    "args": {"query": "Germany Blue Card"},
+                    "id": "call-1",
+                }
+            ],
+        )
+        empty_summary = AIMessage(content="")
+
+        mock_llm = unittest.mock.Mock()
+        mock_bound = unittest.mock.Mock()
+        mock_bound.invoke.side_effect = [search_response, empty_summary]
+        mock_llm.bind_tools.return_value = mock_bound
+        mock_build_llm.return_value = mock_llm
+
+        task = {
+            "todo": {"id": 2, "country": "Germany", "methods": "EU Blue Card"},
+            "profile_summary": "Software engineer from India.",
+        }
+        config = {"configurable": {"hf_token": "test-token"}}
+
+        result = researcher_node(task, config)
+
+        summary = result["findings"][0]["summary"]
+        self.assertNotEqual(summary, "No findings could be produced for this to-do.")
+        self.assertIn("Germany", summary)
+
+
+if __name__ == "__main__":
+    unittest.main()

ui/agent/graph/nodes/config.py

@@ -19,6 +19,7 @@ MAX_TODOS = 4
 MAX_RESEARCH_ROUNDS = 4
 TOOL_RESULT_LIMIT = 4000
 FINDING_SUMMARY_LIMIT = 2500
+RESEARCHER_FINAL_MAX_TOKENS = FINDING_SUMMARY_LIMIT
 PLANNER_MAX_TOKENS = 900
 PLANNER_TEMPERATURE = 0.2
 CONSOLIDATOR_MAX_TOKENS = 3000

ui/agent/graph/nodes/helpers.py

@@ -365,6 +365,88 @@ def normalize_plan(
     }
 
 
+def _think_tags() -> tuple[str, str]:
+    return "<" + "think" + ">", "</" + "think" + ">"
+
+
+_THINK_OPEN, _THINK_CLOSE = _think_tags()
+_THINK_BLOCK_PATTERN = re.compile(
+    re.escape(_THINK_OPEN) + r".*?" + re.escape(_THINK_CLOSE),
+    re.I | re.DOTALL,
+)
+_THINK_INNER_PATTERN = re.compile(
+    re.escape(_THINK_OPEN) + r"(.*?)" + re.escape(_THINK_CLOSE),
+    re.I | re.DOTALL,
+)
+
+
+def _flatten_content_blocks(content: Any) -> str:
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for block in content:
+            if isinstance(block, str):
+                parts.append(block)
+                continue
+            if isinstance(block, dict):
+                if block.get("type") == "text":
+                    parts.append(str(block.get("text") or ""))
+                elif "text" in block:
+                    parts.append(str(block["text"]))
+        return "\n".join(part for part in parts if part)
+    return str(content)
+
+
+def _extract_reasoning(message: AIMessage) -> str:
+    reasoning = getattr(message, "reasoning", None)
+    if reasoning:
+        return str(reasoning).strip()
+
+    additional = getattr(message, "additional_kwargs", None) or {}
+    for key in ("reasoning_content", "reasoning", "reasoning_text"):
+        value = additional.get(key)
+        if value:
+            return str(value).strip()
+
+    metadata = getattr(message, "response_metadata", None) or {}
+    for key in ("reasoning_content", "reasoning"):
+        value = metadata.get(key)
+        if value:
+            return str(value).strip()
+    return ""
+
+
+def _strip_think_blocks(text: str) -> str:
+    if not text.strip():
+        return ""
+    outside = _THINK_BLOCK_PATTERN.sub("", text).strip()
+    if outside:
+        return outside
+    inner_parts = _THINK_INNER_PATTERN.findall(text)
+    if inner_parts:
+        return "\n".join(part.strip() for part in inner_parts if part.strip())
+    return text.strip()
+
+
+def assistant_text_sources(message: AIMessage) -> tuple[str, str]:
+    content_text = _flatten_content_blocks(message.content).strip()
+    reasoning_text = _extract_reasoning(message)
+    return content_text, reasoning_text
+
+
+def extract_assistant_text(message: AIMessage) -> str:
+    """Extract user-visible assistant text from content, blocks, or reasoning."""
+    content_text, reasoning_text = assistant_text_sources(message)
+    for candidate in (content_text, reasoning_text):
+        stripped = _strip_think_blocks(candidate)
+        if stripped:
+            return stripped
+    return ""
+
+
 def research_tool_calls(
     response: AIMessage,
 ) -> list[tuple[str, dict[str, Any], str]]:
@@ -375,7 +457,10 @@ def research_tool_calls(
             for tool_call in response.tool_calls
         ]
 
-    parsed_calls = parse_text_tool_calls(str(response.content or ""))
+    content_text, reasoning_text = assistant_text_sources(response)
+    parsed_calls = parse_text_tool_calls(content_text) or parse_text_tool_calls(
+        reasoning_text
+    )
     if not parsed_calls:
         return []
 

ui/agent/graph/nodes/researcher.py

@@ -2,6 +2,8 @@
 from __future__ import annotations
 
 import json
+import logging
+import os
 import time
 import uuid
 from typing import Any
@@ -10,6 +12,7 @@ from langchain_core.messages import AIMessage, ToolMessage
 from langchain_core.runnables import RunnableConfig
 from langgraph.config import get_stream_writer
 
+from ...synthesis import synthesize_finding_from_tool_messages
 from ...tools import (
     _done_tool_message,
     _pending_tool_message,
@@ -23,12 +26,27 @@ from ..state import Finding, ResearchTask, TodoItem
 from .config import (
     FINDING_SUMMARY_LIMIT,
     MAX_RESEARCH_ROUNDS,
+    RESEARCHER_FINAL_MAX_TOKENS,
     RESEARCH_TOOL_SCHEMAS,
     TOOL_RESULT_LIMIT,
 )
-from .helpers import format_todo_label, research_tool_calls, todo_research_brief
+from .helpers import (
+    assistant_text_sources,
+    extract_assistant_text,
+    format_todo_label,
+    research_tool_calls,
+    todo_research_brief,
+)
 from .prompts import RESEARCHER_SYSTEM_PROMPT
 
+logger = logging.getLogger(__name__)
+DEBUG_RESEARCHER = os.environ.get("BORDERLESS_DEBUG_RESEARCHER") == "1"
+
+
+def _debug_researcher(**fields: Any) -> None:
+    if DEBUG_RESEARCHER:
+        logger.info("researcher debug: %s", fields)
+
 
 def _research_task_metadata(todo: TodoItem) -> dict[str, Any]:
     return {
@@ -82,6 +100,18 @@ def execute_tool_call(
     return result
 
 
+def _append_assistant_message(messages: list[Any], response: AIMessage) -> None:
+    if response.tool_calls:
+        messages.append(response)
+        return
+
+    assistant_text = extract_assistant_text(response)
+    if assistant_text:
+        messages.append(AIMessage(content=assistant_text))
+    else:
+        messages.append(response)
+
+
 def researcher_node(task: ResearchTask, config: RunnableConfig) -> dict[str, Any]:
     writer = get_stream_writer()
     todo = task["todo"]
@@ -102,15 +132,23 @@ def researcher_node(task: ResearchTask, config: RunnableConfig) -> dict[str, Any
     summary = ""
     for round_index in range(MAX_RESEARCH_ROUNDS):
         response: AIMessage = llm.invoke(messages)
+        content_text, reasoning_text = assistant_text_sources(response)
         tool_calls = research_tool_calls(response)
+
+        _debug_researcher(
+            round_index=round_index,
+            has_native_tool_calls=bool(response.tool_calls),
+            parsed_text_tool_calls=len(tool_calls) if not response.tool_calls else 0,
+            content_len=len(content_text),
+            reasoning_len=len(reasoning_text),
+            content_preview=content_text[:120],
+        )
+
         if not tool_calls:
-            summary = str(response.content or "").strip()
+            summary = extract_assistant_text(response)
             break
 
-        if response.tool_calls:
-            messages.append(response)
-        else:
-            messages.append(AIMessage(content=""))
+        _append_assistant_message(messages, response)
 
         for tool_name, tool_args, tool_call_id in tool_calls:
             result = execute_tool_call(writer, todo, tool_name, tool_args)
@@ -126,17 +164,39 @@ def researcher_node(task: ResearchTask, config: RunnableConfig) -> dict[str, Any
                 {
                     "role": "user",
                     "content": (
-                        "Stop researching now. Write your findings report based "
-                        "on the information gathered so far, labeling anything "
-                        "unverified."
+                        "Respond with the markdown findings report in your main "
+                        "answer text. Do not call tools. Label anything unverified."
                     ),
                 }
             )
-            final = build_llm(config).invoke(messages)
-            summary = str(final.content or "").strip()
+            final = build_llm(
+                config,
+                max_tokens=RESEARCHER_FINAL_MAX_TOKENS,
+            ).invoke(messages)
+            summary = extract_assistant_text(final)
+            final_content, final_reasoning = assistant_text_sources(final)
+            _debug_researcher(
+                round_index="final",
+                content_len=len(final_content),
+                reasoning_len=len(final_reasoning),
+                final_summary_len=len(summary),
+            )
+
+    tool_messages = [message for message in messages if isinstance(message, ToolMessage)]
+    fallback_used = False
+    if not summary and tool_messages:
+        summary = synthesize_finding_from_tool_messages(todo, tool_messages)
+        fallback_used = bool(summary)
 
     if not summary:
         summary = "No findings could be produced for this to-do."
+
+    _debug_researcher(
+        fallback_used=fallback_used,
+        final_summary_len=len(summary),
+        tool_message_count=len(tool_messages),
+    )
+
     summary = truncate(summary, FINDING_SUMMARY_LIMIT)
 
     todo_label = format_todo_label(todo)

ui/agent/synthesis.py

@@ -1,6 +1,7 @@
 # ui/agent/synthesis.py
 from __future__ import annotations
 
+import json
 import re
 from typing import Any, TypedDict
 
@@ -349,3 +350,122 @@ def findings_from_ui_messages(ui_messages: list[Any]) -> list[Finding]:
         )
         todo_id += 1
     return findings
+
+
+def _parse_tool_payload(content: str) -> dict[str, Any]:
+    try:
+        parsed = json.loads(content)
+    except json.JSONDecodeError:
+        return {"text": content}
+    return parsed if isinstance(parsed, dict) else {"text": content}
+
+
+def synthesize_finding_from_tool_messages(
+    todo: TodoItem,
+    tool_messages: list[Any],
+) -> str:
+    """Build a markdown finding from tool results when the LLM summary is empty."""
+    country = todo["country"]
+    methods = todo["methods"]
+
+    search_snippets: list[str] = []
+    scraped_snippets: list[str] = []
+    profile_notes: list[str] = []
+    urls: list[str] = []
+
+    for message in tool_messages:
+        content = getattr(message, "content", message)
+        payload = _parse_tool_payload(str(content or ""))
+        if payload.get("error") and len(payload) <= 3:
+            continue
+
+        for result in payload.get("results") or []:
+            if not isinstance(result, dict):
+                continue
+            url = str(result.get("url") or "")
+            if url:
+                urls.append(url)
+            title = str(result.get("title") or url or "Search result")
+            highlights = result.get("highlights") or []
+            summary = str(result.get("summary") or "")
+            snippet = "\n".join(str(item) for item in highlights[:2])
+            if not snippet:
+                snippet = summary
+            if snippet:
+                search_snippets.append(f"- **{title}**: {snippet[:500]}")
+
+        markdown = str(payload.get("markdown") or "")
+        if markdown:
+            title = str(payload.get("title") or payload.get("url") or "Official page")
+            url = str(payload.get("source_url") or payload.get("url") or "")
+            if url:
+                urls.append(url)
+            scraped_snippets.append(f"### {title}\n{markdown[:1500]}")
+
+        for page in payload.get("pages") or []:
+            if not isinstance(page, dict):
+                continue
+            page_markdown = str(page.get("markdown") or "")
+            if not page_markdown:
+                continue
+            title = str(page.get("title") or page.get("url") or "Page")
+            url = str(page.get("source_url") or page.get("url") or "")
+            if url:
+                urls.append(url)
+            scraped_snippets.append(f"### {title}\n{page_markdown[:800]}")
+
+        for profile in payload.get("countries") or []:
+            if not isinstance(profile, dict):
+                continue
+            name = str(profile.get("name") or country)
+            domains = profile.get("official_immigration_domains") or []
+            domain_text = ", ".join(str(domain) for domain in domains[:5])
+            if domain_text:
+                profile_notes.append(f"{name}: official domains include {domain_text}")
+
+    if not search_snippets and not scraped_snippets and not profile_notes:
+        return ""
+
+    raw_parts = [
+        f"# Research Findings: {country} — {methods}",
+        "",
+        "*Compiled from tool results. Verify all details on official sources.*",
+        "",
+        "## Visa Pathway",
+        methods,
+        "",
+    ]
+    if search_snippets:
+        raw_parts.extend(["## Search Results", "\n".join(search_snippets[:8]), ""])
+    if scraped_snippets:
+        raw_parts.extend(
+            ["## Official Page Excerpts", "\n\n".join(scraped_snippets[:3]), ""]
+        )
+    if profile_notes:
+        raw_parts.extend(["## Country Context", "\n".join(profile_notes), ""])
+
+    unique_urls = list(dict.fromkeys(url for url in urls if url))
+    if unique_urls:
+        raw_parts.extend(
+            ["## Official Sources", "\n".join(f"- {url}" for url in unique_urls[:10])]
+        )
+
+    raw_text = "\n".join(raw_parts)
+    sections = build_country_report_sections(
+        raw_text,
+        country=country,
+        pathway=methods,
+    )
+
+    return (
+        f"# {country} — {methods}\n\n"
+        "*Automated fallback report from research tool outputs. "
+        "Verify all details on official immigration websites.*\n\n"
+        f"## Eligibility\n{sections['why_recommended']}\n\n"
+        f"## Visa Pathway\n{sections['feasible_methods']}\n\n"
+        f"## Required Documents\n{sections['requirements']}\n\n"
+        f"## Steps\n{sections['procedure']}\n\n"
+        f"## Timeline, Costs, and Risks\n{sections['duration_costs_risks']}\n\n"
+        f"## Official Sources\n{sections['official_sources']}\n\n"
+        f"## Raw Research Notes\n{raw_text[:2000]}"
+    )