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

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