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

tooluniverse/dblp_tool.py

@@ -0,0 +1,62 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("DBLPTool")
+class DBLPTool(BaseTool):
+    """
+    Search DBLP Computer Science Bibliography for publications.
+    """
+
+    def __init__(
+        self,
+        tool_config,
+        base_url="https://dblp.org/search/publ/api",
+    ):
+        super().__init__(tool_config)
+        self.base_url = base_url
+
+    def run(self, arguments):
+        query = arguments.get("query")
+        limit = int(arguments.get("limit", 10))
+        if not query:
+            return {"error": "`query` parameter is required."}
+        return self._search(query, limit)
+
+    def _search(self, query, limit):
+        params = {
+            "q": query,
+            "h": max(1, min(limit, 100)),
+            "format": "json",
+        }
+        try:
+            response = requests.get(self.base_url, params=params, timeout=20)
+        except requests.RequestException as e:
+            return {
+                "error": "Network error calling DBLP API",
+                "reason": str(e),
+            }
+
+        if response.status_code != 200:
+            return {
+                "error": f"DBLP API error {response.status_code}",
+                "reason": response.reason,
+            }
+
+        hits = response.json().get("result", {}).get("hits", {}).get("hit", [])
+        results = []
+        for hit in hits:
+            info = hit.get("info", {})
+            results.append(
+                {
+                    "title": info.get("title"),
+                    "authors": info.get("authors", {}).get("author"),
+                    "year": info.get("year"),
+                    "venue": info.get("venue"),
+                    "url": info.get("url"),
+                    "ee": info.get("ee"),
+                }
+            )
+
+        return results

tooluniverse/default_config.py

@@ -33,6 +33,23 @@ default_tool_files = {
     "Enrichr": os.path.join(current_dir, "data", "enrichr_tools.json"),
     "HumanBase": os.path.join(current_dir, "data", "humanbase_tools.json"),
     "OpenAlex": os.path.join(current_dir, "data", "openalex_tools.json"),
+    # Literature search tools
+    "arxiv": os.path.join(current_dir, "data", "arxiv_tools.json"),
+    "crossref": os.path.join(current_dir, "data", "crossref_tools.json"),
+    "dblp": os.path.join(current_dir, "data", "dblp_tools.json"),
+    "pubmed": os.path.join(current_dir, "data", "pubmed_tools.json"),
+    "doaj": os.path.join(current_dir, "data", "doaj_tools.json"),
+    "unpaywall": os.path.join(current_dir, "data", "unpaywall_tools.json"),
+    "biorxiv": os.path.join(current_dir, "data", "biorxiv_tools.json"),
+    "medrxiv": os.path.join(current_dir, "data", "medrxiv_tools.json"),
+    "hal": os.path.join(current_dir, "data", "hal_tools.json"),
+    "core": os.path.join(current_dir, "data", "core_tools.json"),
+    "pmc": os.path.join(current_dir, "data", "pmc_tools.json"),
+    "zenodo": os.path.join(current_dir, "data", "zenodo_tools.json"),
+    "openaire": os.path.join(current_dir, "data", "openaire_tools.json"),
+    "osf_preprints": os.path.join(current_dir, "data", "osf_preprints_tools.json"),
+    "fatcat": os.path.join(current_dir, "data", "fatcat_tools.json"),
+    "wikidata_sparql": os.path.join(current_dir, "data", "wikidata_sparql_tools.json"),
     "agents": os.path.join(current_dir, "data", "agentic_tools.json"),
     "dataset": os.path.join(current_dir, "data", "dataset_tools.json"),
     # 'mcp_clients': os.path.join(current_dir, 'data', 'mcp_client_tools_example.json'),

tooluniverse/doaj_tool.py

@@ -0,0 +1,124 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("DOAJTool")
+class DOAJTool(BaseTool):
+    """
+    Search DOAJ (Directory of Open Access Journals) articles and journals.
+
+    Parameters (arguments):
+        query (str): Query string (Lucene syntax supported by DOAJ)
+        max_results (int): Max number of results (default 10, max 100)
+        type (str): "articles" or "journals" (default: "articles")
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base_url = "https://doaj.org/api/search"
+
+    def run(self, arguments=None):
+        arguments = arguments or {}
+        query = arguments.get("query")
+        search_type = arguments.get("type", "articles")
+        max_results = int(arguments.get("max_results", 10))
+
+        if not query:
+            return {"error": "`query` parameter is required."}
+
+        if search_type not in ["articles", "journals"]:
+            return {"error": "`type` must be 'articles' or 'journals'."}
+
+        endpoint = f"{self.base_url}/{search_type}/{query}"
+        params = {
+            "pageSize": max(1, min(max_results, 100)),
+        }
+        try:
+            resp = requests.get(endpoint, params=params, timeout=20)
+            resp.raise_for_status()
+            data = resp.json()
+        except requests.RequestException as e:
+            return {
+                "error": "Network/API error calling DOAJ",
+                "reason": str(e),
+            }
+        except ValueError:
+            return {"error": "Failed to decode DOAJ response as JSON"}
+
+        results = data.get("results", [])
+        items = []
+        if search_type == "articles":
+            for r in results:
+                b = r.get("bibjson", {})
+                title = b.get("title")
+                year = None
+                try:
+                    year = int((b.get("year") or 0))
+                except Exception:
+                    year = b.get("year")
+                authors = [
+                    a.get("name")
+                    for a in b.get("author", [])
+                    if a.get("name")
+                ]
+                doi = None
+                for i in b.get("identifier", []):
+                    if i.get("type") == "doi":
+                        doi = i.get("id")
+                        break
+                url = None
+                for link_item in b.get("link", []):
+                    if (
+                        link_item.get("type") == "fulltext"
+                        or link_item.get("url")
+                    ):
+                        url = link_item.get("url")
+                        break
+                journal = (b.get("journal") or {}).get("title")
+                items.append(
+                    {
+                        "title": title,
+                        "authors": authors,
+                        "year": year,
+                        "doi": doi,
+                        "venue": journal,
+                        "url": url,
+                        "source": "DOAJ",
+                    }
+                )
+        else:
+            for r in results:
+                b = r.get("bibjson", {})
+                title = b.get("title")
+                publisher = b.get("publisher")
+                eissn = None
+                pissn = None
+                for i in b.get("identifier", []):
+                    if i.get("type") == "eissn":
+                        eissn = i.get("id")
+                    if i.get("type") == "pissn":
+                        pissn = i.get("id")
+                homepage_url = None
+                for link_item in b.get("link", []):
+                    if link_item.get("url"):
+                        homepage_url = link_item.get("url")
+                        break
+                subjects = [
+                    s.get("term")
+                    for s in b.get("subject", [])
+                    if s.get("term")
+                ]
+                items.append(
+                    {
+                        "title": title,
+                        "publisher": publisher,
+                        "eissn": eissn,
+                        "pissn": pissn,
+                        "subjects": subjects,
+                        "url": homepage_url,
+                        "source": "DOAJ",
+                    }
+                )
+
+        return items

tooluniverse/execute_function.py

@@ -25,6 +25,7 @@ Constants:
 """
 
 import copy
+import inspect
 import json
 import random
 import string
@@ -1638,7 +1639,14 @@ class ToolUniverse:
         """
         return "".join(random.choices(string.ascii_letters + string.digits, k=9))
 
-    def run(self, fcall_str, return_message=False, verbose=True, format="llama"):
+    def run(
+        self,
+        fcall_str,
+        return_message=False,
+        verbose=True,
+        format="llama",
+        stream_callback=None,
+    ):
         """
         Execute function calls from input string or data.
 
@@ -1671,7 +1679,9 @@ class ToolUniverse:
                 # return the function call+result message with call id.
                 call_results = []
                 for i in range(len(function_call_json)):
-                    call_result = self.run_one_function(function_call_json[i])
+                    call_result = self.run_one_function(
+                        function_call_json[i], stream_callback=stream_callback
+                    )
                     call_id = self.call_id_gen()
                     function_call_json[i]["call_id"] = call_id
                     call_results.append(
@@ -1691,12 +1701,14 @@ class ToolUniverse:
                 ] + call_results
                 return revised_messages
             else:
-                return self.run_one_function(function_call_json)
+                return self.run_one_function(
+                    function_call_json, stream_callback=stream_callback
+                )
         else:
             error("Not a function call")
             return None
 
-    def run_one_function(self, function_call_json):
+    def run_one_function(self, function_call_json, stream_callback=None):
         """
         Execute a single function call.
 
@@ -1719,8 +1731,13 @@ class ToolUniverse:
         arguments = function_call_json["arguments"]
 
         # Execute the tool
+        tool_instance = None
+        tool_arguments = arguments
         if function_name in self.callable_functions:
-            result = self.callable_functions[function_name].run(arguments)
+            tool_instance = self.callable_functions[function_name]
+            result, tool_arguments = self._execute_tool_with_stream(
+                tool_instance, arguments, stream_callback
+            )
         else:
             if function_name in self.all_tool_dict:
                 self.logger.debug(
@@ -1729,7 +1746,10 @@ class ToolUniverse:
                 tool = self.init_tool(
                     self.all_tool_dict[function_name], add_to_cache=True
                 )
-                result = tool.run(arguments)
+                tool_instance = tool
+                result, tool_arguments = self._execute_tool_with_stream(
+                    tool_instance, arguments, stream_callback
+                )
             else:
                 return f"Tool '{function_name}' not found"
 
@@ -1738,17 +1758,58 @@ class ToolUniverse:
             context = {
                 "tool_name": function_name,
                 "tool_type": (
-                    tool.__class__.__name__ if "tool" in locals() else "unknown"
+                    tool_instance.__class__.__name__
+                    if tool_instance is not None
+                    else "unknown"
                 ),
                 "execution_time": time.time(),
-                "arguments": arguments,
+                "arguments": tool_arguments,
             }
             result = self.hook_manager.apply_hooks(
-                result, function_name, arguments, context
+                result, function_name, tool_arguments, context
             )
 
         return result
 
+    def _execute_tool_with_stream(self, tool_instance, arguments, stream_callback):
+        """Invoke a tool, forwarding stream callbacks when supported."""
+
+        tool_arguments = arguments
+        stream_flag_key = (
+            getattr(tool_instance, "STREAM_FLAG_KEY", None)
+            if stream_callback
+            else None
+        )
+
+        if isinstance(arguments, dict):
+            tool_arguments = dict(arguments)
+
+            if (
+                stream_callback
+                and stream_flag_key
+                and stream_flag_key not in tool_arguments
+            ):
+                tool_arguments[stream_flag_key] = True
+
+        if stream_callback is None:
+            return tool_instance.run(tool_arguments), tool_arguments
+
+        try:
+            signature = inspect.signature(tool_instance.run)
+            if "stream_callback" in signature.parameters:
+                return (
+                    tool_instance.run(
+                        tool_arguments, stream_callback=stream_callback
+                    ),
+                    tool_arguments,
+                )
+        except (ValueError, TypeError):
+            # If inspection fails, fall back to best-effort execution
+            pass
+
+        # Tool doesn't support streaming yet; execute normally
+        return tool_instance.run(tool_arguments), tool_arguments
+
     def toggle_hooks(self, enabled: bool):
         """
         Enable or disable output hooks globally.

tooluniverse/fatcat_tool.py

@@ -0,0 +1,66 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("FatcatScholarTool")
+class FatcatScholarTool(BaseTool):
+    """
+    Search Internet Archive Scholar via Fatcat releases search.
+
+    Parameters (arguments):
+        query (str): Query string
+        max_results (int): Max results (default 10, max 100)
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base_url = "https://api.fatcat.wiki/v0/release/search"
+
+    def run(self, arguments=None):
+        arguments = arguments or {}
+        query = arguments.get("query")
+        max_results = int(arguments.get("max_results", 10))
+
+        if not query:
+            return {"error": "`query` parameter is required."}
+
+        params = {
+            "q": query,
+            "size": max(1, min(max_results, 100)),
+        }
+        try:
+            resp = requests.get(self.base_url, params=params, timeout=20)
+            resp.raise_for_status()
+            data = resp.json()
+        except requests.RequestException as e:
+            return {
+                "error": "Network/API error calling Fatcat",
+                "reason": str(e),
+            }
+        except ValueError:
+            return {"error": "Failed to decode Fatcat response as JSON"}
+
+        results = []
+        for r in data.get("hits", {}).get("hits", []):
+            src = r.get("_source", {})
+            title = src.get("title")
+            year = src.get("release_year")
+            doi = src.get("doi")
+            authors = src.get("contrib_names", [])
+            url = None
+            if src.get("wikidata_qid"):
+                url = f"https://fatcat.wiki/release/{src.get('ident') or ''}"
+            results.append(
+                {
+                    "title": title,
+                    "authors": authors,
+                    "year": year,
+                    "doi": doi,
+                    "url": url,
+                    "source": "Fatcat/IA Scholar",
+                }
+            )
+
+        return results
+

tooluniverse/hal_tool.py

@@ -0,0 +1,77 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("HALTool")
+class HALTool(BaseTool):
+    """
+    Search the French HAL open archive via its public API.
+
+    Arguments:
+        query (str): Search term (Lucene syntax)
+        max_results (int): Max results to return (default 10, max 100)
+    """
+
+    def __init__(
+        self,
+        tool_config,
+        base_url="https://api.archives-ouvertes.fr/search/",
+    ):
+        super().__init__(tool_config)
+        self.base_url = base_url.rstrip("/") + "/"
+
+    def run(self, arguments=None):
+        arguments = arguments or {}
+        query = arguments.get("query")
+        max_results = int(arguments.get("max_results", 10))
+        if not query:
+            return {"error": "`query` parameter is required."}
+        return self._search(query, max_results)
+
+    def _search(self, query, max_results):
+        params = {
+            "q": query,
+            "wt": "json",
+            "rows": max(1, min(max_results, 100)),
+            "fl": (
+                "title_s,authFullName_s,producedDateY_i,uri_s,doiId_s,"
+                "docType_s,abstract_s,source_s"
+            ),
+        }
+        try:
+            resp = requests.get(f"{self.base_url}", params=params, timeout=20)
+            resp.raise_for_status()
+            data = resp.json()
+        except requests.RequestException as e:
+            return {"error": "Network/API error calling HAL", "reason": str(e)}
+        except ValueError:
+            return {"error": "Failed to decode HAL response as JSON"}
+
+        docs = data.get("response", {}).get("docs", [])
+        results = []
+        for d in docs:
+            title = (d.get("title_s") or [None])
+            if isinstance(title, list):
+                title = title[0]
+            authors = d.get("authFullName_s") or []
+            year = d.get("producedDateY_i")
+            doi = d.get("doiId_s")
+            url = d.get("uri_s")
+            abstract = d.get("abstract_s")
+            if isinstance(abstract, list):
+                abstract = abstract[0]
+            source = d.get("source_s")
+            results.append(
+                {
+                    "title": title,
+                    "authors": authors,
+                    "year": year,
+                    "doi": doi,
+                    "url": url,
+                    "abstract": abstract,
+                    "source": source,
+                }
+            )
+
+        return results