aiagents4pharma 1.37.0__py3-none-any.whl → 1.39.0__py3-none-any.whl

aiagents4pharma/talk2scholars/agents/paper_download_agent.py

@@ -14,6 +14,8 @@ from langgraph.prebuilt.tool_node import ToolNode
 from langgraph.checkpoint.memory import MemorySaver
 from ..state.state_talk2scholars import Talk2Scholars
 from ..tools.paper_download.download_arxiv_input import download_arxiv_paper
+from ..tools.paper_download.download_medrxiv_input import download_medrxiv_paper
+from ..tools.paper_download.download_biorxiv_input import download_biorxiv_paper
 
 # Initialize logger
 logging.basicConfig(level=logging.INFO)
@@ -24,14 +26,20 @@ def get_app(uniq_id, llm_model: BaseChatModel):
     """
     Initializes and returns the LangGraph application for the Talk2Scholars paper download agent.
 
+    This agent supports downloading scientific papers from multiple preprint servers, including
+    arXiv, BioRxiv, and MedRxiv. It can intelligently handle user queries by extracting or resolving
+    necessary identifiers (e.g., arXiv ID or DOI) from the paper title and routing the request to
+    the appropriate download tool.
+
     Args:
         uniq_id (str): A unique identifier for tracking the current session.
         llm_model (BaseChatModel, optional): The language model to be used by the agent.
-            Defaults to ChatOpenAI(model="gpt-4o-mini", temperature=0.5).
+        Defaults to ChatOpenAI(model="gpt-4o-mini", temperature=0.5).
 
     Returns:
         StateGraph: A compiled LangGraph application that enables the paper download agent to
-            process user queries and retrieve arXiv papers.
+        process user queries and retrieve research papers from arXiv (using arXiv ID),
+        BioRxiv and MedRxiv (using DOI resolved from the paper title or provided directly).
     """
 
     # Load Hydra configuration
@@ -44,7 +52,7 @@ def get_app(uniq_id, llm_model: BaseChatModel):
         cfg = cfg.agents.talk2scholars.paper_download_agent
 
     # Define tools properly
-    tools = ToolNode([download_arxiv_paper])
+    tools = ToolNode([download_arxiv_paper, download_medrxiv_paper, download_biorxiv_paper])
 
     # Define the model
     logger.info("Using OpenAI model %s", llm_model)
@@ -58,7 +66,7 @@ def get_app(uniq_id, llm_model: BaseChatModel):
 
     def paper_download_agent_node(state: Talk2Scholars) -> Dict[str, Any]:
         """
-        Processes the current state to fetch the arXiv paper.
+        Processes the current state to fetch the research paper from arXiv, BioRxiv, or MedRxiv.
         """
         logger.info("Creating paper download agent node with thread_id: %s", uniq_id)
         result = model.invoke(state, {"configurable": {"thread_id": uniq_id}})

aiagents4pharma/talk2scholars/configs/config.yaml

@@ -8,6 +8,8 @@ defaults:
   - agents/talk2scholars/pdf_agent: default
   - tools/search: default
   - tools/download_arxiv_paper: default
+  - tools/download_biorxiv_paper: default
+  - tools/download_medrxiv_paper: default
   - tools/single_paper_recommendation: default
   - tools/multi_paper_recommendation: default
   - tools/retrieve_semantic_scholar_paper_id: default

aiagents4pharma/talk2scholars/configs/tools/download_biorxiv_paper/__init__.py

@@ -0,0 +1,3 @@
+"""
+Import all the modules in the package
+"""

aiagents4pharma/talk2scholars/configs/tools/download_medrxiv_paper/__init__.py

@@ -0,0 +1,3 @@
+"""
+Import all the modules in the package
+"""

aiagents4pharma/talk2scholars/configs/tools/zotero_read/default.yaml

@@ -2,6 +2,7 @@
 library_type: "user" # Type of library ('user' or 'group')
 default_limit: 2
 request_timeout: 10
+chunk_size: 16384  # Size (in bytes) for streaming PDF download chunks
 user_id: ${oc.env:ZOTERO_USER_ID} # Load from environment variable
 api_key: ${oc.env:ZOTERO_API_KEY} # Load from environment variable
 

aiagents4pharma/talk2scholars/state/state_talk2scholars.py

@@ -7,6 +7,7 @@ across agent interactions.
 """
 
 import logging
+from collections.abc import Mapping
 from typing import Annotated, Any, Dict
 
 from langchain_core.embeddings import Embeddings
@@ -18,7 +19,24 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-def replace_dict(existing: Dict[str, Any], new: Dict[str, Any]) -> Dict[str, Any]:
+def merge_dict(existing: Dict[str, Any], new: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Merges the existing dictionary with a new dictionary.
+
+    This function logs the state merge and ensures that the new values
+    are appended to the existing state without overwriting other entries.
+    Args:
+        existing (Dict[str, Any]): The current dictionary state.
+        new (Dict[str, Any]): The new dictionary state to merge.
+    Returns:
+        Dict[str, Any]: The merged dictionary state.
+    """
+    merged = dict(existing) if existing else {}
+    merged.update(new or {})
+    return merged
+
+
+def replace_dict(existing: Dict[str, Any], new: Any) -> Any:
     """
     Replaces the existing dictionary with a new dictionary.
 
@@ -39,9 +57,13 @@ def replace_dict(existing: Dict[str, Any], new: Dict[str, Any]) -> Dict[str, Any
         >>> print(updated_state)
         {"papers": {"id2": "Paper 2"}}
     """
-    # No-op operation to use the 'existing' variable
-    _ = len(existing)
-    return new
+    # If new is not a mapping, just replace existing value outright
+    if not isinstance(new, Mapping):
+        return new
+    # In-place replace: clear existing mapping and update with new entries
+    existing.clear()
+    existing.update(new)
+    return existing
 
 
 class Talk2Scholars(AgentState):
@@ -63,10 +85,14 @@ class Talk2Scholars(AgentState):
     """
 
     # Agent state fields
+    # Key controlling UI display: always replace to reference latest output
+    # Stores the most recently displayed papers metadata
     last_displayed_papers: Annotated[Dict[str, Any], replace_dict]
-    papers: Annotated[Dict[str, Any], replace_dict]
-    multi_papers: Annotated[Dict[str, Any], replace_dict]
-    article_data: Annotated[Dict[str, Any], replace_dict]
+    # Accumulative keys: merge new entries into existing state
+    papers: Annotated[Dict[str, Any], merge_dict]
+    multi_papers: Annotated[Dict[str, Any], merge_dict]
+    article_data: Annotated[Dict[str, Any], merge_dict]
+    # Approval status: always replace to reflect latest operation
     zotero_write_approval_status: Annotated[Dict[str, Any], replace_dict]
     llm_model: BaseChatModel
     text_embedding_model: Embeddings

aiagents4pharma/talk2scholars/tests/test_paper_download_biorxiv.py

@@ -0,0 +1,151 @@
+"""
+Unit tests for bioRxiv paper downloading functionality, including:
+- download_bioRxiv_paper tool function.
+"""
+
+import unittest
+from unittest.mock import MagicMock, patch
+from langchain_core.messages import ToolMessage
+
+from aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input import (
+    download_biorxiv_paper,
+)
+
+
+class TestDownloadBiorxivPaper(unittest.TestCase):
+    """Tests for the download_bioRxiv_paper tool."""
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.requests.get"
+    )
+    def test_download_biorxiv_paper_success(self, mock_get, mock_compose, mock_initialize):
+        """Test successful metadata and PDF URL retrieval."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_biorxiv_paper.api_url = "http://dummy.biorxiv.org/api"
+        dummy_cfg.tools.download_biorxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        doi = "10.1101/2025.05.13.653102"
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {
+            "collection": [
+                {
+                    "title": "Sample BioRxiv Paper",
+                    "authors": "Author One; Author Two",
+                    "abstract": "This is a bioRxiv abstract.",
+                    "date": "2025-04-25",
+                    "doi": doi,
+                    "link": f"https://www.biorxiv.org/content/{doi}.full.pdf"
+                }
+            ]
+        }
+        mock_get.return_value = dummy_response
+
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+        result = download_biorxiv_paper.run(tool_input)
+        update = result.update
+
+        self.assertIn("article_data", update)
+        self.assertIn(doi, update["article_data"])
+        metadata = update["article_data"][doi]
+        self.assertEqual(metadata["Title"], "Sample BioRxiv Paper")
+        self.assertEqual(metadata["Authors"], "Author One; Author Two")
+        self.assertEqual(metadata["Abstract"], "This is a bioRxiv abstract.")
+        self.assertEqual(metadata["Publication Date"], "2025-04-25")
+        self.assertEqual(metadata["URL"], f"https://www.biorxiv.org/content/{doi}.full.pdf")
+        self.assertEqual(metadata["pdf_url"], f"https://www.biorxiv.org/content/{doi}.full.pdf")
+        self.assertEqual(metadata["filename"], f"{doi.rsplit('/', maxsplit=1)[-1]}.pdf")
+        self.assertEqual(metadata["source"], "biorxiv")
+        self.assertEqual(metadata["biorxiv_id"], doi)
+
+        self.assertTrue(len(update["messages"]) >= 1)
+        self.assertIsInstance(update["messages"][0], ToolMessage)
+        self.assertIn("Successfully retrieved metadata and PDF URL", update["messages"][0].content)
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.requests.get"
+    )
+    def test_no_entry_found(self, mock_get, mock_compose, mock_initialize):
+        """Test behavior when no 'entry' is in response."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_biorxiv_paper.api_url = "http://dummy.biorxiv.org/api"
+        dummy_cfg.tools.download_biorxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {}  # No entry
+        mock_get.return_value = dummy_response
+
+        doi = "10.1101/2025.05.13.653102"
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+
+        with self.assertRaises(ValueError) as context:
+            download_biorxiv_paper.run(tool_input)
+
+        self.assertEqual(str(context.exception), f"No metadata found for DOI: {doi}")
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_biorxiv_input.requests.get"
+    )
+    def test_no_pdf_url_found(self, mock_get, mock_compose, mock_initialize):
+        """Test fallback to DOI-based PDF URL construction when 'link' is missing."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_biorxiv_paper.api_url = "http://dummy.biorxiv.org/api"
+        dummy_cfg.tools.download_biorxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        doi = "10.1101/2025.05.13.653102"
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {
+            "collection": [
+                {
+                    "title": "Sample Biorxiv Paper",
+                    "authors": "Author One; Author Two",
+                    "abstract": "This is a BioRxiv abstract.",
+                    "date": "2025-04-25",
+                    "doi": doi
+                    # 'link' is intentionally omitted
+                }
+            ]
+        }
+        mock_get.return_value = dummy_response
+
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+        result = download_biorxiv_paper.run(tool_input)
+        update = result.update
+        metadata = update["article_data"][doi]
+
+        # Assert that the PDF URL was constructed from DOI
+        expected_suffix = doi.rsplit('/', maxsplit=1)[-1]
+        expected_url = f"https://www.biorxiv.org/content/10.1101/{expected_suffix}.full.pdf"
+
+        self.assertEqual(metadata["pdf_url"], expected_url)

aiagents4pharma/talk2scholars/tests/test_paper_download_medrxiv.py

@@ -0,0 +1,151 @@
+"""
+Unit tests for medrXiv paper downloading functionality, including:
+- download_medrxiv_paper tool function.
+"""
+
+import unittest
+from unittest.mock import MagicMock, patch
+from langchain_core.messages import ToolMessage
+
+from aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input import (
+    download_medrxiv_paper,
+)
+
+
+class TestDownloadMedrxivPaper(unittest.TestCase):
+    """Tests for the download_medrxiv_paper tool."""
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.requests.get"
+    )
+    def test_download_medrxiv_paper_success(self, mock_get, mock_compose, mock_initialize):
+        """Test successful metadata and PDF URL retrieval."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_medrxiv_paper.api_url = "http://dummy.medrxiv.org/api"
+        dummy_cfg.tools.download_medrxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        doi = "10.1101/2025.04.25.25326432"
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {
+            "collection": [
+                {
+                    "title": "Sample Medrxiv Paper",
+                    "authors": "Author One; Author Two",
+                    "abstract": "This is a medRxiv abstract.",
+                    "date": "2025-04-25",
+                    "doi": doi,
+                    "link": f"https://www.medrxiv.org/content/{doi}.full.pdf"
+                }
+            ]
+        }
+        mock_get.return_value = dummy_response
+
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+        result = download_medrxiv_paper.run(tool_input)
+        update = result.update
+
+        self.assertIn("article_data", update)
+        self.assertIn(doi, update["article_data"])
+        metadata = update["article_data"][doi]
+        self.assertEqual(metadata["Title"], "Sample Medrxiv Paper")
+        self.assertEqual(metadata["Authors"], "Author One; Author Two")
+        self.assertEqual(metadata["Abstract"], "This is a medRxiv abstract.")
+        self.assertEqual(metadata["Publication Date"], "2025-04-25")
+        self.assertEqual(metadata["URL"], f"https://www.medrxiv.org/content/{doi}.full.pdf")
+        self.assertEqual(metadata["pdf_url"], f"https://www.medrxiv.org/content/{doi}.full.pdf")
+        self.assertEqual(metadata["filename"], f"{doi.rsplit('/', maxsplit=1)[-1]}.pdf")
+        self.assertEqual(metadata["source"], "medrxiv")
+        self.assertEqual(metadata["medrxiv_id"], doi)
+
+        self.assertTrue(len(update["messages"]) >= 1)
+        self.assertIsInstance(update["messages"][0], ToolMessage)
+        self.assertIn("Successfully retrieved metadata and PDF URL", update["messages"][0].content)
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.requests.get"
+    )
+    def test_no_entry_found(self, mock_get, mock_compose, mock_initialize):
+        """Test behavior when no 'entry' is in response."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_medrxiv_paper.api_url = "http://dummy.medrxiv.org/api"
+        dummy_cfg.tools.download_medrxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {}  # No entry
+        mock_get.return_value = dummy_response
+
+        doi = "10.1101/2025.04.25.25326432"
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+
+        with self.assertRaises(ValueError) as context:
+            download_medrxiv_paper.run(tool_input)
+
+        self.assertEqual(str(context.exception), f"No entry found for medRxiv ID {doi}")
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.initialize"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.hydra.compose"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.paper_download.download_medrxiv_input.requests.get"
+    )
+    def test_no_pdf_url_found(self, mock_get, mock_compose, mock_initialize):
+        """Test fallback to DOI-based PDF URL construction when 'link' is missing."""
+        dummy_cfg = MagicMock()
+        dummy_cfg.tools.download_medrxiv_paper.api_url = "http://dummy.medrxiv.org/api"
+        dummy_cfg.tools.download_medrxiv_paper.request_timeout = 10
+        mock_compose.return_value = dummy_cfg
+        mock_initialize.return_value.__enter__.return_value = None
+
+        doi = "10.1101/2025.04.25.25326432"
+
+        dummy_response = MagicMock()
+        dummy_response.status_code = 200
+        dummy_response.raise_for_status = MagicMock()
+        dummy_response.json.return_value = {
+            "collection": [
+                {
+                    "title": "Sample Medrxiv Paper",
+                    "authors": "Author One; Author Two",
+                    "abstract": "This is a medRxiv abstract.",
+                    "date": "2025-04-25",
+                    "doi": doi
+                    # 'link' is intentionally omitted
+                }
+            ]
+        }
+        mock_get.return_value = dummy_response
+
+        tool_input = {"doi": doi, "tool_call_id": "test_tool_id"}
+        result = download_medrxiv_paper.run(tool_input)
+        update = result.update
+        metadata = update["article_data"][doi]
+
+        # Assert that the PDF URL was constructed from DOI
+        expected_suffix = doi.rsplit('/', maxsplit=1)[-1]
+        expected_url = f"https://www.medrxiv.org/content/10.1101/{expected_suffix}.full.pdf"
+
+        self.assertEqual(metadata["pdf_url"], expected_url)

aiagents4pharma/talk2scholars/tests/test_question_and_answer_tool.py

@@ -3,11 +3,14 @@ Unit tests for question_and_answer tool functionality.
 """
 
 import unittest
+from types import SimpleNamespace
 from unittest.mock import MagicMock, patch
 
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings
+from langchain_core.messages import ToolMessage
 
+import aiagents4pharma.talk2scholars.tools.pdf.question_and_answer as qa_module
 from aiagents4pharma.talk2scholars.tools.pdf.question_and_answer import (
     Vectorstore,
     generate_answer,
@@ -145,8 +148,9 @@ class TestQuestionAndAnswerTool(unittest.TestCase):
 
         vector_store = Vectorstore(embedding_model=mock_embedding_model)
         vector_store.vector_store = True
+        # Add a document chunk with required metadata including chunk_id
         vector_store.documents["test_doc"] = Document(
-            page_content="Test content", metadata={"paper_id": "test_paper"}
+            page_content="Test content", metadata={"paper_id": "test_paper", "chunk_id": 0}
         )
 
         results = vector_store.retrieve_relevant_chunks(query="test query")
@@ -793,8 +797,9 @@ class TestMissingState(unittest.TestCase):
 
         vector_store = Vectorstore(embedding_model=mock_embedding_model)
         vector_store.vector_store = True
-        doc1 = Document(page_content="Doc 1", metadata={"paper_id": "paper1"})
-        doc2 = Document(page_content="Doc 2", metadata={"paper_id": "paper2"})
+        # Add document chunks with necessary metadata including chunk_ids
+        doc1 = Document(page_content="Doc 1", metadata={"paper_id": "paper1", "chunk_id": 0})
+        doc2 = Document(page_content="Doc 2", metadata={"paper_id": "paper2", "chunk_id": 1})
         vector_store.documents = {"doc1": doc1, "doc2": doc2}
 
         results = vector_store.retrieve_relevant_chunks(
@@ -820,3 +825,54 @@ class TestMissingState(unittest.TestCase):
             query="test", paper_ids=["nonexistent_id"]
         )
         assert results == []
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.pdf.question_and_answer.load_hydra_config"
+    )
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.pdf.question_and_answer.generate_answer"
+    )
+    def test_prebuilt_vector_store_branch(self, mock_generate, mock_load_config):
+        """Test question_and_answer tool with a shared pre-built vector store branch."""
+        # Mock configuration for tool-level thresholds
+        config = SimpleNamespace(top_k_papers=1, top_k_chunks=1)
+        mock_load_config.return_value = config
+        # Mock generate_answer to return a simple response
+        mock_generate.return_value = {"output_text": "Answer", "papers_used": ["p1"]}
+
+        # Prepare a dummy pre-built vector store
+        dummy_vs = SimpleNamespace(
+            loaded_papers=set(),
+            vector_store=True,
+            retrieve_relevant_chunks=lambda *_args, **_kwargs: [
+                Document(page_content="chunk", metadata={"paper_id": "p1"})
+            ],
+        )
+        # Override the module-level prebuilt_vector_store
+        qa_module.prebuilt_vector_store = dummy_vs
+
+        # Prepare state with required models and article_data
+        state = {
+            "text_embedding_model": MagicMock(),
+            "llm_model": MagicMock(),
+            "article_data": {"p1": {"source": "upload"}},
+        }
+
+        # Invoke the tool-level function via .run with appropriate input schema
+        input_data = {
+            "question": "What?",
+            "paper_ids": None,
+            "use_all_papers": False,
+            "tool_call_id": "testid",
+            "state": state,
+        }
+        result = qa_module.question_and_answer.run(input_data)
+
+        # Ensure the prebuilt branch was used and a Command is returned
+        self.assertTrue(hasattr(result, "update"))
+        messages = result.update.get("messages", [])
+        self.assertEqual(len(messages), 1)
+        self.assertIsInstance(messages[0], ToolMessage)
+
+        # Clean up global override
+        qa_module.prebuilt_vector_store = None

aiagents4pharma/talk2scholars/tests/test_read_helper_utils.py

@@ -0,0 +1,110 @@
+"""
+Unit tests for Zotero read helper download branches.
+"""
+
+import unittest
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+from aiagents4pharma.talk2scholars.tools.zotero.utils.read_helper import (
+    ZoteroSearchData,
+)
+
+# Dummy Hydra configuration for tests
+dummy_zotero_read_config = SimpleNamespace(
+    user_id="dummy_user",
+    library_type="user",
+    api_key="dummy_api_key",
+    zotero=SimpleNamespace(
+        max_limit=5,
+        filter_item_types=["journalArticle", "conferencePaper"],
+        filter_excluded_types=["attachment", "note"],
+    ),
+)
+dummy_cfg = SimpleNamespace(tools=SimpleNamespace(zotero_read=dummy_zotero_read_config))
+
+
+class TestReadHelperDownloadsFalse(unittest.TestCase):
+    """Tests for read_helper download_pdfs=False branches."""
+
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.zotero.utils.zotero_path.get_item_collections"
+    )
+    @patch("aiagents4pharma.talk2scholars.tools.zotero.utils.read_helper.zotero.Zotero")
+    @patch("aiagents4pharma.talk2scholars.tools.zotero.utils.read_helper.hydra.compose")
+    @patch(
+        "aiagents4pharma.talk2scholars.tools.zotero.utils.read_helper.hydra.initialize"
+    )
+    def test_download_pdfs_false_branches(
+        self,
+        mock_hydra_init,
+        mock_hydra_compose,
+        mock_zotero_class,
+        mock_get_item_collections,
+    ):
+        """Ensure attachment_key and filename are set when download_pdfs=False."""
+        # Setup Hydra mocks
+        mock_hydra_compose.return_value = dummy_cfg
+        mock_hydra_init.return_value.__enter__.return_value = None
+
+        # Fake Zotero items: one paper with child PDF, one orphaned PDF
+        fake_zot = MagicMock()
+        fake_items = [
+            {
+                "data": {
+                    "key": "paper1",
+                    "title": "P1",
+                    "abstractNote": "A1",
+                    "date": "2021",
+                    "url": "u1",
+                    "itemType": "journalArticle",
+                }
+            },
+            {
+                "data": {
+                    "key": "attach2",
+                    "itemType": "attachment",
+                    "contentType": "application/pdf",
+                    "filename": "file2.pdf",
+                }
+            },
+        ]
+        fake_zot.items.return_value = fake_items
+        # children for paper1
+        fake_child = {
+            "data": {
+                "key": "attach1",
+                "filename": "file1.pdf",
+                "contentType": "application/pdf",
+            }
+        }
+
+        def children_side_effect(key):
+            return [fake_child] if key == "paper1" else []
+
+        fake_zot.children.side_effect = children_side_effect
+        mock_zotero_class.return_value = fake_zot
+        mock_get_item_collections.return_value = {"paper1": ["/C1"], "attach2": ["/C2"]}
+
+        # Instantiate with download_pdfs=False
+        search = ZoteroSearchData(
+            query="test",
+            only_articles=False,
+            limit=2,
+            tool_call_id="id",
+            download_pdfs=False,
+        )
+        search.process_search()
+        data = search.get_search_results()["article_data"]
+
+        # Regular paper1 should have attachment_key and filename, no pdf_url
+        self.assertIn("paper1", data)
+        self.assertEqual(data["paper1"]["attachment_key"], "attach1")
+        self.assertEqual(data["paper1"]["filename"], "file1.pdf")
+        self.assertNotIn("pdf_url", data["paper1"])
+
+        # Orphan attach2 should have attachment_key and filename, no pdf_url
+        self.assertIn("attach2", data)
+        self.assertEqual(data["attach2"]["attachment_key"], "attach2")
+        self.assertEqual(data["attach2"]["filename"], "file2.pdf")
+        self.assertNotIn("pdf_url", data["attach2"])