tooluniverse 1.0.5__py3-none-any.whl → 1.0.6__py3-none-any.whl

tooluniverse/pmc_tool.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+PMC (PubMed Central) Tool for searching full-text biomedical literature.
+
+PMC is the free full-text archive of biomedical and life sciences journal
+literature at the U.S. National Institutes of Health's National Library of
+Medicine. This tool provides access to millions of full-text articles.
+"""
+
+import requests
+from typing import Dict, List, Any, Optional
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("PMCTool")
+class PMCTool(BaseTool):
+    """Tool for searching PMC full-text biomedical literature."""
+
+    def __init__(self, tool_config=None):
+        super().__init__(tool_config)
+        self.base_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'ToolUniverse/1.0',
+            'Accept': 'application/json'
+        })
+
+    def _search(self, query: str, limit: int = 10,
+                date_from: Optional[str] = None,
+                date_to: Optional[str] = None,
+                article_type: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        Search for papers using PMC API.
+
+        Args:
+            query: Search query
+            limit: Maximum number of results
+            date_from: Start date filter (YYYY/MM/DD)
+            date_to: End date filter (YYYY/MM/DD)
+            article_type: Article type filter (e.g., 'research-article', 'review')
+
+        Returns:
+            List of paper dictionaries
+        """
+        try:
+            # Step 1: Search PMC for article IDs
+            search_params = {
+                'db': 'pmc',
+                'term': query,
+                'retmax': min(limit, 100),  # NCBI API max limit
+                'retmode': 'json',
+                'sort': 'relevance'
+            }
+
+            # Add date filters if provided
+            if date_from or date_to:
+                date_filter = []
+                if date_from:
+                    date_filter.append(
+                        f"({date_from}[PDAT]:{date_to or '3000/12/31'}[PDAT])"
+                    )
+                else:
+                    date_filter.append(f"(:{date_to}[PDAT])")
+                search_params['term'] += f" AND {' '.join(date_filter)}"
+
+            # Add article type filter if provided
+            if article_type:
+                search_params['term'] += f" AND {article_type}[PT]"
+
+            # Make search request
+            search_response = self.session.get(
+                f"{self.base_url}/esearch.fcgi",
+                params=search_params,
+                timeout=30
+            )
+            search_response.raise_for_status()
+
+            search_data = search_response.json()
+            pmc_ids = search_data.get('esearchresult', {}).get('idlist', [])
+
+            if not pmc_ids:
+                return []
+
+            # Step 2: Get detailed information for each article
+            summary_params = {
+                'db': 'pmc',
+                'id': ','.join(pmc_ids),
+                'retmode': 'json'
+            }
+
+            summary_response = self.session.get(
+                f"{self.base_url}/esummary.fcgi",
+                params=summary_params,
+                timeout=30
+            )
+            summary_response.raise_for_status()
+
+            summary_data = summary_response.json()
+            results = []
+
+            # Parse results
+            for pmc_id in pmc_ids:
+                article_data = summary_data.get('result', {}).get(pmc_id, {})
+
+                paper = {
+                    'title': article_data.get('title', 'No title'),
+                    'abstract': article_data.get('abstract', 'No abstract available'),
+                    'authors': self._extract_authors(article_data.get('authors', [])),
+                    'year': self._extract_year(article_data.get('pubdate')),
+                    'pmc_id': pmc_id,
+                    'pmid': article_data.get('pmid'),
+                    'doi': article_data.get('elocationid'),
+                    'url': f"https://www.ncbi.nlm.nih.gov/pmc/articles/{pmc_id}/",
+                    'venue': article_data.get('source'),
+                    'open_access': True,  # PMC only contains open access articles
+                    'source': 'PMC',
+                    'article_type': (article_data.get('pubtype', ['Unknown'])[0]
+                                     if article_data.get('pubtype') else 'Unknown'),
+                    'citations': article_data.get('pmcrefcount', 0)
+                }
+                results.append(paper)
+
+            return results
+
+        except requests.exceptions.RequestException as e:
+            return [{'error': f'PMC API request failed: {str(e)}'}]
+        except Exception as e:
+            return [{'error': f'PMC API error: {str(e)}'}]
+
+    def _extract_authors(self, authors: List[Dict]) -> List[str]:
+        """Extract author names from PMC API response."""
+        if not authors:
+            return []
+
+        author_names = []
+        for author in authors:
+            name = author.get('name', '')
+            if name:
+                author_names.append(name)
+
+        return author_names
+
+    def _extract_year(self, pubdate: str) -> str:
+        """Extract year from publication date."""
+        if not pubdate:
+            return 'Unknown'
+
+        try:
+            # PMC API returns dates in various formats
+            # Extract year from the beginning of the string
+            return pubdate[:4]
+        except Exception:
+            return 'Unknown'
+
+    def run(self, tool_arguments) -> List[Dict[str, Any]]:
+        """
+        Execute the PMC search.
+
+        Args:
+            tool_arguments: Dictionary containing search parameters
+
+        Returns:
+            List of paper dictionaries
+        """
+        query = tool_arguments.get('query', '')
+        if not query:
+            return [{'error': 'Query parameter is required'}]
+
+        limit = tool_arguments.get('limit', 10)
+        date_from = tool_arguments.get('date_from')
+        date_to = tool_arguments.get('date_to')
+        article_type = tool_arguments.get('article_type')
+
+        return self._search(
+            query=query,
+            limit=limit,
+            date_from=date_from,
+            date_to=date_to,
+            article_type=article_type
+        )

tooluniverse/pubmed_tool.py

@@ -0,0 +1,110 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("PubMedTool")
+class PubMedTool(BaseTool):
+    """
+    Search PubMed using NCBI E-utilities (esearch + esummary) and return
+    articles.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.esearch_url = (
+            "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
+        )
+        self.esummary_url = (
+            "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi"
+        )
+
+    def run(self, arguments):
+        query = arguments.get("query")
+        limit = int(arguments.get("limit", 10))
+        api_key = arguments.get("api_key")  # optional NCBI API key
+        if not query:
+            return {"error": "`query` parameter is required."}
+        return self._search(query, limit, api_key)
+
+    def _search(self, query, limit, api_key=None):
+        params = {
+            "db": "pubmed",
+            "term": query,
+            "retmax": max(1, min(limit, 200)),
+            "retmode": "json",
+        }
+        if api_key:
+            params["api_key"] = api_key
+
+        try:
+            r = requests.get(self.esearch_url, params=params, timeout=20)
+        except requests.RequestException as e:
+            return {
+                "error": "Network error calling PubMed esearch",
+                "reason": str(e),
+            }
+        if r.status_code != 200:
+            return {
+                "error": f"PubMed esearch error {r.status_code}",
+                "reason": r.reason,
+            }
+
+        data = r.json()
+        id_list = data.get("esearchresult", {}).get("idlist", [])
+        if not id_list:
+            return []
+
+        summary_params = {
+            "db": "pubmed",
+            "id": ",".join(id_list),
+            "retmode": "json",
+        }
+        if api_key:
+            summary_params["api_key"] = api_key
+
+        try:
+            s = requests.get(
+                self.esummary_url,
+                params=summary_params,
+                timeout=20,
+            )
+        except requests.RequestException as e:
+            return {
+                "error": "Network error calling PubMed esummary",
+                "reason": str(e),
+            }
+        if s.status_code != 200:
+            return {
+                "error": f"PubMed esummary error {s.status_code}",
+                "reason": s.reason,
+            }
+
+        result = s.json().get("result", {})
+        uids = result.get("uids", [])
+        articles = []
+        for uid in uids:
+            rec = result.get(uid, {})
+            title = rec.get("title")
+            journal = rec.get("fulljournalname") or rec.get("source")
+            year = None
+            pubdate = rec.get("pubdate")
+            if pubdate and len(pubdate) >= 4 and pubdate[:4].isdigit():
+                year = int(pubdate[:4])
+            doi = None
+            for id_obj in rec.get("articleids", []):
+                if id_obj.get("idtype") == "doi":
+                    doi = id_obj.get("value")
+                    break
+            url = f"https://pubmed.ncbi.nlm.nih.gov/{uid}/"
+            articles.append(
+                {
+                    "title": title,
+                    "journal": journal,
+                    "year": year,
+                    "doi": doi,
+                    "url": url,
+                }
+            )
+
+        return articles

tooluniverse/smcp.py

@@ -92,6 +92,7 @@ AI Agent Interface:
 """
 
 import asyncio
+import functools
 import json
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Dict, List, Optional, Union, Callable, Literal
@@ -2292,93 +2293,122 @@ class SMCP(FastMCP):
                             )
                         )
 
-            # Create the async function with dynamic signature
-            if not properties:
-                # Tool has no parameters - create simple function
-                async def dynamic_tool_function() -> str:
-                    """Execute ToolUniverse tool with no arguments."""
-                    try:
-                        # Prepare function call with empty arguments
-                        function_call = {"name": tool_name, "arguments": {}}
-
-                        # Execute in thread pool to avoid blocking
-                        loop = asyncio.get_event_loop()
-                        result = await loop.run_in_executor(
-                            self.executor,
-                            self.tooluniverse.run_one_function,
-                            function_call,
-                        )
-
-                        # Format the result
-                        if isinstance(result, str):
-                            return result
-                        else:
-                            return json.dumps(result, indent=2, default=str)
+            # Add optional streaming parameter to signature
+            stream_field = Field(
+                description="Set to true to receive incremental streaming output (experimental)."
+            )
+            stream_annotation = Annotated[Union[bool, type(None)], stream_field]
+            param_annotations["_tooluniverse_stream"] = stream_annotation
+            func_params.append(
+                inspect.Parameter(
+                    "_tooluniverse_stream",
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    default=None,
+                    annotation=stream_annotation,
+                )
+            )
 
-                    except Exception as e:
-                        error_msg = f"Error executing {tool_name}: {str(e)}"
-                        self.logger.error(error_msg)
-                        return json.dumps({"error": error_msg}, indent=2)
+            # Optional FastMCP context injection for streaming callbacks
+            try:
+                from fastmcp.server.context import Context as MCPContext  # type: ignore
+            except Exception:  # pragma: no cover - context unavailable
+                MCPContext = None  # type: ignore
+
+            if MCPContext is not None:
+                func_params.append(
+                    inspect.Parameter(
+                        "ctx",
+                        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                        default=None,
+                        annotation=MCPContext,
+                    )
+                )
 
-                # Set function metadata
-                dynamic_tool_function.__name__ = tool_name
-                dynamic_tool_function.__signature__ = inspect.Signature([])
-                dynamic_tool_function.__annotations__ = {"return": str}
+            async def dynamic_tool_function(**kwargs) -> str:
+                """Execute ToolUniverse tool with provided arguments."""
+                try:
+                    ctx = kwargs.pop("ctx", None)
+                    stream_flag = bool(kwargs.get("_tooluniverse_stream"))
 
-            else:
-                # Tool has parameters - create function with dynamic signature
-                async def dynamic_tool_function(**kwargs) -> str:
-                    """Execute ToolUniverse tool with provided arguments."""
-                    try:
-                        # Filter out None values for optional parameters
-                        args_dict = {k: v for k, v in kwargs.items() if v is not None}
-
-                        # Validate required parameters
-                        missing_required = [
-                            param for param in required_params if param not in args_dict
-                        ]
-                        if missing_required:
-                            return json.dumps(
-                                {
-                                    "error": f"Missing required parameters: {missing_required}",
-                                    "required": required_params,
-                                    "provided": list(args_dict.keys()),
-                                },
-                                indent=2,
-                            )
-
-                        # Prepare function call
-                        function_call = {"name": tool_name, "arguments": args_dict}
+                    # Filter out None values for optional parameters (preserve streaming flag)
+                    args_dict = {
+                        k: v for k, v in kwargs.items() if v is not None
+                    }
+                    filtered_args = {
+                        k: v
+                        for k, v in args_dict.items()
+                        if k != "_tooluniverse_stream"
+                    }
 
-                        # Execute in thread pool to avoid blocking
-                        loop = asyncio.get_event_loop()
-                        result = await loop.run_in_executor(
-                            self.executor,
-                            self.tooluniverse.run_one_function,
-                            function_call,
+                    # Validate required parameters
+                    missing_required = [
+                        param for param in required_params if param not in filtered_args
+                    ]
+                    if missing_required:
+                        return json.dumps(
+                            {
+                                "error": f"Missing required parameters: {missing_required}",
+                                "required": required_params,
+                                "provided": list(filtered_args.keys()),
+                            },
+                            indent=2,
                         )
 
-                        # Format the result
-                        if isinstance(result, str):
-                            return result
-                        else:
-                            return json.dumps(result, indent=2, default=str)
-
-                    except Exception as e:
-                        error_msg = f"Error executing {tool_name}: {str(e)}"
-                        self.logger.error(error_msg)
-                        return json.dumps({"error": error_msg}, indent=2)
-
-                # Set function metadata
-                dynamic_tool_function.__name__ = tool_name
+                    function_call = {"name": tool_name, "arguments": args_dict}
+
+                    loop = asyncio.get_event_loop()
+                    stream_callback = None
+
+                    if stream_flag and ctx is not None and MCPContext is not None:
+                        def stream_callback(chunk: str) -> None:
+                            if not chunk:
+                                return
+                            try:
+                                future = asyncio.run_coroutine_threadsafe(
+                                    ctx.info(chunk), loop
+                                )
+
+                                def _log_future_result(fut) -> None:
+                                    exc = fut.exception()
+                                    if exc:
+                                        self.logger.debug(
+                                            f"Streaming callback error for {tool_name}: {exc}"
+                                        )
+
+                                future.add_done_callback(_log_future_result)
+                            except Exception as cb_error:  # noqa: BLE001
+                                self.logger.debug(
+                                    f"Failed to dispatch stream chunk for {tool_name}: {cb_error}"
+                                )
+
+                        # Ensure downstream tools see the streaming flag
+                        if "_tooluniverse_stream" not in args_dict:
+                            args_dict["_tooluniverse_stream"] = True
+
+                    run_callable = functools.partial(
+                        self.tooluniverse.run_one_function,
+                        function_call,
+                        stream_callback=stream_callback,
+                    )
 
-                # Set function signature dynamically for tools with parameters
-                if func_params:
-                    dynamic_tool_function.__signature__ = inspect.Signature(func_params)
+                    result = await loop.run_in_executor(self.executor, run_callable)
 
-                # Set annotations for type hints
-                dynamic_tool_function.__annotations__ = param_annotations.copy()
-                dynamic_tool_function.__annotations__["return"] = str
+                    if isinstance(result, str):
+                        return result
+                    else:
+                        return json.dumps(result, indent=2, default=str)
+
+                except Exception as e:
+                    error_msg = f"Error executing {tool_name}: {str(e)}"
+                    self.logger.error(error_msg)
+                    return json.dumps({"error": error_msg}, indent=2)
+
+            # Set function metadata
+            dynamic_tool_function.__name__ = tool_name
+            dynamic_tool_function.__signature__ = inspect.Signature(func_params)
+            annotations = param_annotations.copy()
+            annotations["return"] = str
+            dynamic_tool_function.__annotations__ = annotations
 
             # Create detailed docstring for internal use, but use clean description for FastMCP
             param_docs = []

tooluniverse/test/test_claude_sdk.py

@@ -1,4 +1,6 @@
 import asyncio
+import os
+from pathlib import Path
 
 from claude_agent_sdk import ClaudeAgentOptions, query
 from dotenv import load_dotenv
@@ -18,8 +20,10 @@ async def delegate_task(
     Returns:
         The result of the delegation
     """
-    import os
-    cwd = os.getcwd()
+    # Create sandbox directory if it doesn't exist
+    sandbox_dir = Path(__file__).parent / "sandbox"
+    sandbox_dir.mkdir(exist_ok=True)
+    cwd = str(sandbox_dir)
 
     async for message in query(
         prompt=prompt,
@@ -34,8 +38,11 @@ async def delegate_task(
             mcp_servers={
                 "tooluniverse": {
                     "type": "stdio",
-                    "command": "tooluniverse-smcp-stdio",
-                    "args": [],
+                    "command": "uv",
+                    "args": [
+                        "run",
+                        "tooluniverse-smcp-stdio",
+                    ],
                     "env": {},
                 },
             },

tooluniverse/unpaywall_tool.py

@@ -0,0 +1,63 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("UnpaywallTool")
+class UnpaywallTool(BaseTool):
+    """
+    Query Unpaywall by DOI to check open-access status and OA locations.
+    Requires a contact email.
+    """
+
+    def __init__(self, tool_config, base_url="https://api.unpaywall.org/v2/"):
+        super().__init__(tool_config)
+        self.base_url = base_url.rstrip("/") + "/"
+
+    def run(self, arguments):
+        doi = arguments.get("doi")
+        email = arguments.get("email")  # required by Unpaywall
+        if not doi:
+            return {"error": "`doi` parameter is required."}
+        if not email:
+            return {"error": "`email` parameter is required for Unpaywall."}
+        return self._lookup(doi, email)
+
+    def _lookup(self, doi, email):
+        url = f"{self.base_url}{doi}"
+        params = {"email": email}
+        try:
+            response = requests.get(
+                url,
+                params=params,
+                timeout=20,
+            )
+        except requests.RequestException as e:
+            return {
+                "error": "Network error calling Unpaywall API",
+                "reason": str(e),
+            }
+
+        if response.status_code != 200:
+            return {
+                "error": f"Unpaywall API error {response.status_code}",
+                "reason": response.reason,
+            }
+
+        data = response.json()
+        result = {
+            "is_oa": data.get("is_oa"),
+            "oa_status": data.get("oa_status"),
+            "best_oa_location": data.get("best_oa_location"),
+            "oa_locations": data.get("oa_locations"),
+            "journal_is_oa": data.get("journal_is_oa"),
+            "journal_issn_l": data.get("journal_issn_l"),
+            "journal_issns": data.get("journal_issns"),
+            "doi": data.get("doi"),
+            "title": data.get("title"),
+            "year": data.get("year"),
+            "publisher": data.get("publisher"),
+            "url": data.get("url"),
+        }
+        return result
+

tooluniverse/wikidata_sparql_tool.py

@@ -0,0 +1,61 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("WikidataSPARQLTool")
+class WikidataSPARQLTool(BaseTool):
+    """
+    Run SPARQL queries against Wikidata (powering Scholia views).
+
+    Parameters (arguments):
+        sparql (str): SPARQL query string
+        max_results (int): Optional result limit override
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "https://query.wikidata.org/sparql"
+
+    def run(self, arguments=None):
+        arguments = arguments or {}
+        sparql = arguments.get("sparql")
+        max_results = arguments.get("max_results")
+        if not sparql:
+            return {"error": "`sparql` parameter is required."}
+        if max_results:
+            # naive limit appending if not present
+            if "limit" not in sparql.lower():
+                sparql = f"{sparql}\nLIMIT {int(max_results)}"
+
+        headers = {
+            "Accept": "application/sparql-results+json",
+            "User-Agent": "ToolUniverse/1.0 (https://github.com)"
+        }
+        try:
+            resp = requests.get(
+                self.endpoint,
+                params={"query": sparql, "format": "json"},
+                headers=headers,
+                timeout=30,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+        except requests.RequestException as e:
+            return {
+                "error": "Network/API error calling Wikidata SPARQL",
+                "reason": str(e),
+            }
+        except ValueError:
+            return {"error": "Failed to decode SPARQL response as JSON"}
+
+        bindings = data.get("results", {}).get("bindings", [])
+        # Normalize by unwrapping "value" fields
+        normalized = []
+        for b in bindings:
+            row = {}
+            for k, v in b.items():
+                row[k] = v.get("value")
+            normalized.append(row)
+        return normalized
+