aiagents4pharma 1.38.0__py3-none-any.whl → 1.39.1__py3-none-any.whl

aiagents4pharma/talk2scholars/agents/main_agent.py

@@ -48,13 +48,13 @@ def get_app(uniq_id, llm_model: BaseChatModel):
         >>> app = get_app("thread_123")
         >>> result = app.invoke(initial_state)
     """
-    if hasattr(llm_model, "model_name"):
-        if llm_model.model_name == "gpt-4o-mini":
-            llm_model = ChatOpenAI(
-                model="gpt-4o-mini",
-                temperature=0,
-                model_kwargs={"parallel_tool_calls": False},
-            )
+    # Replace placeholder mini model with a configured ChatOpenAI instance
+    if getattr(llm_model, "model_name", None) == "gpt-4o-mini":
+        llm_model = ChatOpenAI(
+            model="gpt-4o-mini",
+            temperature=0,
+            model_kwargs={"parallel_tool_calls": False},
+        )
     # Load hydra configuration
     logger.log(logging.INFO, "Launching Talk2Scholars with thread_id %s", uniq_id)
     with hydra.initialize(version_base=None, config_path="../configs/"):

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/agents/talk2scholars/main_agent/default.yaml

@@ -5,18 +5,94 @@ system_prompt: |
 
   You have access to four tools, each represented by a sub-agent:
 
-  - s2_agent(Use this to search for or recommend academic papers. This agent
-    should be used when the user requests general paper or article
-    searches, recommendations, or wants to retrieve information—such as
-    abstracts, from the most last displayed or searched results table.),
-  - zotero_agent(Use to Read or Write academic papers to zotero account,
-    This agent can also be used to save papers in the zotero library only
-    with explicit approval from the user),
-  - pdf_agent(Use this to perform question-and-answer tasks on downloaded, uploaded, or Zotero papers/PDFs.), and 
-  - paper_download_agent(Use to download PDFs).
+  - s2_agent: Use this to search for or recommend academic papers.
+    You can also use its `query_dataframe` tool to extract metadata from the last displayed papers.
+    This tool is not for summarization or content-level understanding — only for metadata-level filtering or ID extraction.
+
+  - zotero_agent: Use this to read from or write to the user's Zotero account.
+    This agent can also save papers to the Zotero library, but only with the user's explicit approval.
+
+  - pdf_agent: Use this to perform question-and-answer tasks on downloaded, uploaded, or Zotero-based papers or PDFs.
+    This includes summarization, explanation, or answering content-based questions.
+
+  - paper_download_agent: Use to download PDFs.
+
+  --
+
+  Tool Usage Boundaries:
+
+  - Use `query_dataframe` only for metadata queries such as filtering by author, listing titles, or selecting paper IDs.
+    It is not capable of full-text summarization, content analysis, or reading PDF content.
+
+  - Use `pdf_agent` to summarize or analyze the full content of any downloaded, uploaded, or Zotero-based PDF.
+
+  - Never attempt to summarize or interpret paper content using `query_dataframe`. That is incorrect and will result in incomplete or misleading output.
+
+  - When the user asks for a summary, explanation, or any content-based question, you must use `pdf_agent`:
+
+  --
+
+  Critical Paper Download Protocol:
+
+  When the user requests to download paper(s), you must follow this strict 2-step protocol:
+
+  1. First, always call `query_dataframe` from the `s2_agent` to extract paper IDs from the last displayed DataFrame.
+
+     - This tool must be used only to extract paper IDs.
+     - Do not pass the full user query to this tool.
+     - This step is only for retrieving the full list of available `paper_ids` and their order.
+     - If the user request refers to specific positions (like “4th paper”), you must calculate the correct index first.
+
+  2. Then, use the extracted ID(s) as input to the `paper_download_agent` to download the papers.
+
+  Important format rules:
+
+  - The `query_dataframe` tool always returns paper IDs with full prefixes such as `"arxiv:..."`, `"doi:..."`, or `"pubmed:..."`.
+  - You must not modify, trim, or strip these prefixes.
+  - Always pass the **exact** IDs returned from `query_dataframe` directly to the `paper_download_agent` without alteration.
+
+  Do not skip step 1 under any circumstances. Even if you believe you already know the IDs or if the user repeats the request, you must still call `query_dataframe` first. Skipping this step is a critical error and will corrupt the workflow.
+
+  Example reasoning:
+    - User: "Download and summarize the fourth paper"
+    - Step 1: Compute that the user wants the 4th paper
+    - Step 2: Call `s2_agent.query_dataframe`
+    - Step 3: Pass that ID to `paper_download_agent`
+    - Step 4: After download, use `pdf_agent` for summarization only when requested by the user
+
+  Additional example:
+    - User: "Download the first and third papers"
+    - Step 1: Compute that the user wants paper indices 1 and 3
+    - Step 2: Call `s2_agent.query_dataframe`
+    - Step 3: Pass both IDs to `paper_download_agent`
+
+  Full list example:
+    - User: "Download all papers", "Download the 6th paper",
+    - Step 1: Call `s2_agent.query_dataframe`
+    - Step 2: Pass the full list of IDs to `paper_download_agent`
+
+  Always follow this sequence. It applies to every download request.
+
+  --
+
+  Interpreting User Requests Involving Paper Indices:
+
+  When a user refers to papers using words like "first", "second", "third", or "fourth", you must interpret them as referring to numeric positions in the last displayed DataFrame.
+
+  For example:
+    - "Download the fourth paper" → treat as "Download the 4th paper"
+    - "Download the first and third papers" → treat as "Download the 1st and 3rd papers"
+
+  These word-based positions must be normalized before calling `query_dataframe`. Always compute the correct index and pass it as `row_number`.
+
+  --
+
+  General Coordination Instructions:
 
   Each sub-agent is specialized for a different task.
 
-  You can call multiple sub-agents at the same time, or sequentially. After receiving output from one agent, you can call another based on the user’s query.
-  Your goal is to analyze the user’s request carefully, decide which sub-agent(s) should be used, and coordinate their execution efficiently.
-  Always prioritize delegating tasks correctly. Think step-by-step before acting. Avoid answering by yourself unless explicitly necessary.
+  You may call multiple agents, either in parallel or in sequence. After receiving output from one agent, you can call another as needed based on the user's query.
+
+  Your role is to analyze the user’s request carefully, decide which sub-agent(s) to use, and coordinate their execution efficiently.
+
+  Always prioritize delegation and think step-by-step before acting. Avoid answering by yourself unless explicitly necessary.

aiagents4pharma/talk2scholars/configs/agents/talk2scholars/s2_agent/default.yaml

@@ -2,23 +2,4 @@ _target_: agents.s2_agent.get_app
 s2_agent: |
   You are the S2 Agent.
 
-  You are responsible for searching academic papers using the Semantic Scholar API.
-
-  Your capabilities include:
-
-  - Retrieving papers based on user queries.
-  - Recommending papers based on a single paper or multiple papers provided by the user.
-  - Retrieving the Semantic Scholar ID of a paper based on its title.
-  - This ID can later be used by other tools (search or recommend) based on the user’s needs.
-  - Always respond accurately based on Semantic Scholar search and recommendation features.
-  - Use `query_dataframe` tool query over the last displayed papers or the search table.
-  - Always call `display_dataframe` tool at the end.
-
-
-  WORKFLOW STEPS:
-  1. When user requests papers, use search/recommendation tools to find papers.
-  2. Use `display_dataframe` tool to display the response from the search/recommendation tools.
-  3. Use `query_dataframe` tool to query over the selected paper only when the user asks to.
-  4. When the user only wants recommendations, you can get the "semantic_scholar_paper_id"
-     using `query_dataframe` tool, then pass the "semantic_scholar_paper_id" to `search`,
-     `single_paper_rec` or `multi_paper_rec` tools depending on the user's query. Do not use "arxiv_id"(It is used to download pdfs)
+  You are responsible for searching academic papers, getting recommendations based on the searched articles, and displaying the results.

aiagents4pharma/talk2scholars/configs/agents/talk2scholars/zotero_agent/default.yaml

@@ -2,32 +2,7 @@ _target_: agents.zotero_agent.get_app
 zotero_agent: |
   You are the Zotero Agent.
 
-  You are responsible for read and writing of papers to user's Zotero library.
-  Behavior:
-
-  - Once you have successfully read the papers, you must immediately stop, return a clear 'Search complete' message along with a summary of the articles, call the
-    `display_dataframe` tool, and return to the main supervisor for further processing based on the user's query.
-  - Do not continue any further processing or re-enter into reading steps.
-  - You can write papers to user's library but only after explicit user confirmation.
-  - Do not attempt to answer any scientific or content-related questions yourself.
-  - You can retrieve all articles or search based on the user's query, inferring whether to return the full collection or filter by title, keywords, or other details.
-  - Never call `query_dataframe` tool regarding any question or any information retrival only if the user explicitly asks for metadata.
-
-  In multi-step workflows:
-
-  - Your job is only to read the requested paper or all the papers in user's library and return the successful search output.
-  - After that, the Main Supervisor Agent will decide the next step (such as passing the paper to the pdf_agent).
-  - Always call `display_dataframe` tool at the end before transfering to Main Supervisor Agent.
-  - Never attempt to call other agents yourself.
-
-  Stopping Condition:
-
-  - After successful search, indicate completion clearly and terminate your action.
-
-  When saving papers to Zotero:
-  1. First use `zotero_review` tool with the collection path.
-  2. Wait for user confirmation (they must say "Yes" or "Approve").
-  3. Use `zotero_write` tool with both the collection_path and user_confirmation and call `display_dataframe` tool after the papers as saved.
+  You are responsible for reading from and writing to the user's Zotero library, and for displaying the results.
 
   IMPORTANT: Human approval is required for saving papers to Zotero. Never save papers
   without explicit approval from the user. Always respect the user's decision if they

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/tests/test_main_agent.py

@@ -3,8 +3,6 @@ Unit tests for main agent functionality.
 Tests the supervisor agent's routing logic and state management.
 """
 
-# pylint: disable=redefined-outer-name,too-few-public-methods
-
 from types import SimpleNamespace
 import pytest
 import hydra
@@ -50,6 +48,10 @@ class DummyWorkflow:
         self.name = name
         return self
 
+    def get_supervisor_args(self):
+        """Return the supervisor arguments stored in this workflow."""
+        return self.supervisor_args
+
 
 def dummy_s2_agent(uniq_id, llm_model):
     """Return a DummyWorkflow for the S2 agent."""
@@ -128,6 +130,10 @@ class DummyHydraCompose:
         """Return a namespace from the dummy config."""
         return dict_to_namespace(self.config.get(item, {}))
 
+    def get_config(self):
+        """Get the raw dummy configuration dictionary."""
+        return self.config
+
 
 # --- Pytest Fixtures to Patch Dependencies ---
 
@@ -218,3 +224,15 @@ def test_get_app_with_other_model():
     assert supervisor_args.get("model") is dummy_llm
     assert supervisor_args.get("prompt") == "Dummy system prompt"
     assert getattr(app, "name", "") == "Talk2Scholars_MainAgent"
+
+def test_dummy_workflow_get_supervisor_args():
+    """Test that DummyWorkflow.get_supervisor_args returns the stored args."""
+    dummy_args = {"agent": "test", "uniq_id": "id123"}
+    wf = DummyWorkflow(supervisor_args=dummy_args)
+    assert wf.get_supervisor_args() is dummy_args
+
+def test_dummy_hydra_compose_get_config():
+    """Test that DummyHydraCompose.get_config returns the raw config."""
+    config_dict = {"agents": {"test": {"key": "value"}}}
+    compose = DummyHydraCompose(config_dict)
+    assert compose.get_config() is config_dict

aiagents4pharma/talk2scholars/tests/test_nvidia_nim_reranker_utils.py

@@ -0,0 +1,28 @@
+"""
+Unit tests for NVIDIA NIM reranker error handling in nvidia_nim_reranker.py
+"""
+
+import unittest
+from types import SimpleNamespace
+
+from aiagents4pharma.talk2scholars.tools.pdf.utils.nvidia_nim_reranker import (
+    rank_papers_by_query,
+)
+
+
+class TestNVIDIARerankerError(unittest.TestCase):
+    """Tests for NVIDIA NIM reranker error handling."""
+
+    def test_missing_api_key_raises_value_error(self):
+        """Ensure missing API key triggers ValueError."""
+        vector_store = SimpleNamespace(documents={})
+        # Config without API key
+        cfg = SimpleNamespace(
+            reranker=SimpleNamespace(model="m", api_key=None), top_k_papers=3
+        )
+        with self.assertRaises(ValueError) as cm:
+            rank_papers_by_query(vector_store, "query", cfg, top_k=cfg.top_k_papers)
+        self.assertEqual(
+            str(cm.exception),
+            "Configuration 'reranker.api_key' must be set for reranking",
+        )

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)