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

tooluniverse/llm_clients.py

@@ -367,3 +367,204 @@ class GeminiClient(BaseLLMClient):
                 retries += 1
                 time.sleep(retry_delay * retries)
         return None
+
+
+class OpenRouterClient(BaseLLMClient):
+    """
+    OpenRouter client using OpenAI SDK with custom base URL.
+    Supports models from OpenAI, Anthropic, Google, Qwen, and many other providers.
+    """
+
+    # Default model limits based on latest OpenRouter offerings
+    DEFAULT_MODEL_LIMITS: Dict[str, Dict[str, int]] = {
+        "openai/gpt-5": {"max_output": 128_000, "context_window": 400_000},  
+        "openai/gpt-5-codex": {"max_output": 128_000, "context_window": 400_000},
+        "google/gemini-2.5-flash": {"max_output": 65_536, "context_window": 1_000_000},
+        "google/gemini-2.5-pro": {"max_output": 65_536, "context_window": 1_000_000},
+        "anthropic/claude-sonnet-4.5": {"max_output": 16_384, "context_window": 1_000_000},
+    }
+
+    def __init__(self, model_id: str, logger):
+        try:
+            from openai import OpenAI as _OpenAI  # type: ignore
+            import openai as _openai  # type: ignore
+        except Exception as e:  # pragma: no cover
+            raise RuntimeError("openai client is not available") from e
+        
+        self._OpenAI = _OpenAI
+        self._openai = _openai
+        self.model_name = model_id
+        self.logger = logger
+
+        api_key = os.getenv("OPENROUTER_API_KEY")
+        if not api_key:
+            raise ValueError("OPENROUTER_API_KEY not set")
+        
+        # Optional headers for OpenRouter
+        default_headers = {}
+        if site_url := os.getenv("OPENROUTER_SITE_URL"):
+            default_headers["HTTP-Referer"] = site_url
+        if site_name := os.getenv("OPENROUTER_SITE_NAME"):
+            default_headers["X-Title"] = site_name
+        
+        self.client = self._OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=api_key,
+            default_headers=default_headers if default_headers else None,
+        )
+
+        # Load env overrides for model limits
+        env_limits_raw = os.getenv("OPENROUTER_DEFAULT_MODEL_LIMITS")
+        self._default_limits: Dict[str, Dict[str, int]] = (
+            self.DEFAULT_MODEL_LIMITS.copy()
+        )
+        if env_limits_raw:
+            try:
+                env_limits = _json.loads(env_limits_raw)
+                for k, v in env_limits.items():
+                    if isinstance(v, dict):
+                        base = self._default_limits.get(k, {}).copy()
+                        base.update(
+                            {
+                                kk: int(vv)
+                                for kk, vv in v.items()
+                                if isinstance(vv, (int, float, str))
+                            }
+                        )
+                        self._default_limits[k] = base
+            except Exception:
+                pass
+
+    def _resolve_default_max_tokens(self, model_id: str) -> Optional[int]:
+        """Resolve default max tokens for a model."""
+        # Highest priority: explicit env per-model tokens mapping
+        mapping_raw = os.getenv("OPENROUTER_MAX_TOKENS_BY_MODEL")
+        mapping: Dict[str, Any] = {}
+        if mapping_raw:
+            try:
+                mapping = _json.loads(mapping_raw)
+            except Exception:
+                mapping = {}
+        
+        if model_id in mapping:
+            try:
+                return int(mapping[model_id])
+            except Exception:
+                pass
+        
+        # Check for prefix match
+        for k, v in mapping.items():
+            try:
+                if model_id.startswith(k):
+                    return int(v)
+            except Exception:
+                continue
+        
+        # Next: built-in/default-limits map
+        if model_id in self._default_limits:
+            return int(self._default_limits[model_id].get("max_output", 0)) or None
+        
+        # Check for prefix match in default limits
+        for k, v in self._default_limits.items():
+            try:
+                if model_id.startswith(k):
+                    return int(v.get("max_output", 0)) or None
+            except Exception:
+                continue
+        
+        return None
+
+    def test_api(self) -> None:
+        """Test API connectivity with minimal token usage."""
+        test_messages = [{"role": "user", "content": "ping"}]
+        token_attempts = [1, 4, 16, 32]
+        last_error: Optional[Exception] = None
+        
+        for tok in token_attempts:
+            try:
+                self.client.chat.completions.create(
+                    model=self.model_name,
+                    messages=test_messages,
+                    max_tokens=tok,
+                    temperature=0,
+                )
+                return
+            except Exception as e:  # noqa: BLE001
+                last_error = e
+                msg = str(e).lower()
+                if (
+                    "max_tokens" in msg
+                    or "model output limit" in msg
+                    or "finish the message" in msg
+                ) and tok != token_attempts[-1]:
+                    continue
+                break
+        
+        if last_error:
+            raise ValueError(f"OpenRouter API test failed: {last_error}")
+        raise ValueError("OpenRouter API test failed: unknown error")
+
+    def infer(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: Optional[float],
+        max_tokens: Optional[int],
+        return_json: bool,
+        custom_format: Any = None,
+        max_retries: int = 5,
+        retry_delay: int = 5,
+    ) -> Optional[str]:
+        """Execute inference using OpenRouter."""
+        retries = 0
+        call_fn = (
+            self.client.chat.completions.parse
+            if custom_format is not None
+            else self.client.chat.completions.create
+        )
+        
+        response_format = (
+            custom_format
+            if custom_format is not None
+            else ({"type": "json_object"} if return_json else None)
+        )
+        
+        eff_max = (
+            max_tokens
+            if max_tokens is not None
+            else self._resolve_default_max_tokens(self.model_name)
+        )
+        
+        while retries < max_retries:
+            try:
+                kwargs: Dict[str, Any] = {
+                    "model": self.model_name,
+                    "messages": messages,
+                }
+                
+                if response_format is not None:
+                    kwargs["response_format"] = response_format
+                if temperature is not None:
+                    kwargs["temperature"] = temperature
+                if eff_max is not None:
+                    kwargs["max_tokens"] = eff_max
+                
+                resp = call_fn(**kwargs)
+                
+                if custom_format is not None:
+                    return resp.choices[0].message.parsed.model_dump()
+                return resp.choices[0].message.content
+                
+            except self._openai.RateLimitError:  # type: ignore[attr-defined]
+                self.logger.warning(
+                    f"Rate limit exceeded. Retrying in {retry_delay} seconds..."
+                )
+                retries += 1
+                time.sleep(retry_delay * retries)
+            except Exception as e:  # noqa: BLE001
+                self.logger.error(f"OpenRouter error: {e}")
+                import traceback
+                traceback.print_exc()
+                break
+        
+        self.logger.error("Max retries exceeded. Unable to complete the request.")
+        return None

tooluniverse/mcp_tool_registry.py

@@ -327,13 +327,12 @@ def _start_server_for_port(port: int, **kwargs):
 
     print(f"🚀 Starting MCP server on port {port} with {len(tools)} tools...")
 
-    # Create SMCP server with stateless mode for compatibility
+    # Create SMCP server for compatibility
     server = _get_smcp()(
         name=config["server_name"],
         auto_expose_tools=False,  # We'll add tools manually
         search_enabled=True,
         max_workers=config.get("max_workers", 5),
-        stateless_http=True,  # Enable stateless mode for MCPAutoLoaderTool compatibility
         **kwargs,
     )
 
@@ -347,8 +346,9 @@ def _start_server_for_port(port: int, **kwargs):
     # Start server in background thread
     def run_server():
         try:
+            # Enable stateless mode for MCPAutoLoaderTool compatibility
             server.run_simple(
-                transport=config["transport"], host=config["host"], port=port
+                transport=config["transport"], host=config["host"], port=port, stateless_http=True
             )
         except Exception as e:
             print(f"❌ Error running MCP server on port {port}: {e}")

tooluniverse/odphp_tool.py

@@ -0,0 +1,226 @@
+import re
+import requests
+from typing import Dict, Any, Optional, List
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+# Optional but recommended: text extraction for HTML
+try:
+    from bs4 import BeautifulSoup  # pip install beautifulsoup4
+except ImportError:
+    BeautifulSoup = None  # We’ll guard uses so the tool still loads
+
+ODPHP_BASE_URL = "https://odphp.health.gov/myhealthfinder/api/v4"
+
+
+class ODPHPRESTTool(BaseTool):
+    """Base class for ODPHP (MyHealthfinder) REST API tools."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = tool_config["fields"]["endpoint"]
+
+    def _make_request(self, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        url = f"{ODPHP_BASE_URL}{self.endpoint}"
+        try:
+            resp = requests.get(url, params=params, timeout=30)
+            resp.raise_for_status()
+            data = resp.json()
+            return {
+                "data": data.get("Result"),
+                "metadata": {
+                    "source": "ODPHP MyHealthfinder",
+                    "endpoint": url,
+                    "query": params,
+                },
+            }
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {str(e)}"}
+        except ValueError as e:
+            return {"error": f"Failed to parse JSON: {str(e)}"}
+
+
+def _sections_array(resource: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Tolerant accessor for the sections array.
+    Data sometimes uses Sections.Section (capital S) and sometimes Sections.section (lowercase).
+    """
+    sect = resource.get("Sections") or {}
+    arr = sect.get("Section")
+    if not isinstance(arr, list):
+        arr = sect.get("section")
+    return arr if isinstance(arr, list) else []
+
+
+def _strip_html_to_text(html: str) -> str:
+    if not html:
+        return ""
+    if BeautifulSoup is None:
+        # fallback: very light tag remover
+        text = re.sub(r"<[^>]+>", " ", html)
+        return re.sub(r"\s+", " ", text).strip()
+    soup = BeautifulSoup(html, "html.parser")
+    # remove scripts/styles
+    for t in soup(["script", "style", "noscript"]):
+        t.decompose()
+    text = soup.get_text("\n", strip=True)
+    text = re.sub(r"\n{2,}", "\n\n", text)
+    return text.strip()
+
+
+@register_tool("ODPHPMyHealthfinder")
+class ODPHPMyHealthfinder(ODPHPRESTTool):
+    """Search for demographic-specific health recommendations (MyHealthfinder)."""
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+        if "lang" in arguments:
+            params["lang"] = arguments["lang"]
+        if "age" in arguments:
+            params["age"] = arguments["age"]
+        if "sex" in arguments:
+            params["sex"] = arguments["sex"]
+        if "pregnant" in arguments:
+            params["pregnant"] = arguments["pregnant"]
+
+        res = self._make_request(params)
+
+        # Optional: attach PlainSections if requested
+        if isinstance(res, dict) and not res.get("error") and arguments.get("strip_html"):
+            data = res.get("data") or {}
+            resources = (((data.get("Resources") or {}).get("All") or {}).get("Resource")) or []
+            if isinstance(resources, list):
+                for r in resources:
+                    plain = []
+                    for sec in _sections_array(r):
+                        plain.append({
+                            "Title": sec.get("Title", ""),
+                            "PlainContent": _strip_html_to_text(sec.get("Content", "")),
+                        })
+                    if plain:
+                        r["PlainSections"] = plain
+        return res
+
+
+@register_tool("ODPHPItemList")
+class ODPHPItemList(ODPHPRESTTool):
+    """Retrieve list of topics or categories."""
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+        if "lang" in arguments:
+            params["lang"] = arguments["lang"]
+        if "type" in arguments:
+            params["type"] = arguments["type"]
+        return self._make_request(params)
+
+
+@register_tool("ODPHPTopicSearch")
+class ODPHPTopicSearch(ODPHPRESTTool):
+    """Search for health topics by ID, category, or keyword."""
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+        if "lang" in arguments:
+            params["lang"] = arguments["lang"]
+        if "topicId" in arguments:
+            params["topicId"] = arguments["topicId"]
+        if "categoryId" in arguments:
+            params["categoryId"] = arguments["categoryId"]
+        if "keyword" in arguments:
+            params["keyword"] = arguments["keyword"]
+
+        res = self._make_request(params)
+
+        # Optional: attach PlainSections if requested
+        if isinstance(res, dict) and not res.get("error") and arguments.get("strip_html"):
+            data = res.get("data") or {}
+            resources = ((data.get("Resources") or {}).get("Resource")) or []
+            if isinstance(resources, list):
+                for r in resources:
+                    plain = []
+                    for sec in _sections_array(r):
+                        plain.append({
+                            "Title": sec.get("Title", ""),
+                            "PlainContent": _strip_html_to_text(sec.get("Content", "")),
+                        })
+                    if plain:
+                        r["PlainSections"] = plain
+        return res
+
+
+@register_tool("ODPHPOutlinkFetch")
+class ODPHPOutlinkFetch(BaseTool):
+    """
+    Fetch article pages referenced by AccessibleVersion / RelatedItems.Url and return readable text.
+    - HTML: extracts main/article/body text; strips nav/aside/footer/script/style.
+    - PDF or non-HTML: returns metadata + URL so the agent can surface it.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.timeout = 30
+
+    def _extract_text(self, html: str) -> Dict[str, str]:
+        if BeautifulSoup is None:
+            # fallback: crude extraction
+            title = ""
+            # attempt to find <title>
+            m = re.search(r"<title[^>]*>(.*?)</title>", html, flags=re.I | re.S)
+            if m:
+                title = re.sub(r"\s+", " ", m.group(1)).strip()
+            text = re.sub(r"<[^>]+>", " ", html)
+            text = re.sub(r"\s+", " ", text).strip()
+            return {"title": title, "text": text}
+
+        soup = BeautifulSoup(html, "html.parser")
+        # remove non-content
+        for tag in soup(["script", "style", "noscript", "footer", "nav", "aside"]):
+            tag.decompose()
+
+        candidate = soup.find("main") or soup.find("article") or soup.body or soup
+        title = ""
+        # prefer main/article heading, else <title>
+        h = candidate.find(["h1", "h2"]) if candidate else None
+        if h:
+            title = h.get_text(" ", strip=True)
+        elif soup.title and soup.title.string:
+            title = soup.title.string.strip()
+
+        text = candidate.get_text("\n", strip=True) if candidate else soup.get_text("\n", strip=True)
+        text = re.sub(r"\n{2,}", "\n\n", text)
+        return {"title": title, "text": text}
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        urls: List[str] = arguments.get("urls", [])
+        max_chars: Optional[int] = arguments.get("max_chars")
+        return_html: bool = bool(arguments.get("return_html", False))
+
+        if not urls or not isinstance(urls, list):
+            return {"error": "Missing required parameter 'urls' (array of 1–3 URLs)."}
+
+        out: List[Dict[str, Any]] = []
+        for u in urls[:3]:
+            try:
+                resp = requests.get(u, timeout=self.timeout, allow_redirects=True)
+                ct = resp.headers.get("Content-Type", "")
+                item: Dict[str, Any] = {"url": u, "status": resp.status_code, "content_type": ct}
+
+                if "text/html" in ct or (not ct and resp.text.startswith("<!")):
+                    ex = self._extract_text(resp.text)
+                    if isinstance(max_chars, int) and max_chars > 0:
+                        ex["text"] = ex["text"][:max_chars]
+                    item.update(ex)
+                    if return_html:
+                        item["html"] = resp.text
+                elif "pdf" in ct or u.lower().endswith(".pdf"):
+                    item["title"] = "(PDF Document)"
+                    item["text"] = f"[PDF file: {u}]"
+                else:
+                    item["title"] = ""
+                    item["text"] = ""
+                out.append(item)
+            except requests.exceptions.RequestException as e:
+                out.append({"url": u, "status": 0, "content_type": "", "title": "", "text": "", "error": str(e)})
+
+        return {"results": out, "metadata": {"source": "ODPHP OutlinkFetch"}}

tooluniverse/remote/boltz/boltz_mcp_server.py

@@ -17,7 +17,7 @@ except FileNotFoundError as e:
     )
     sys.exit(1)
 
-server = FastMCP("Your MCP Server", stateless_http=True)
+server = FastMCP("Your MCP Server")
 agents = {}
 for tool_config in boltz_tools:
     agents[tool_config["name"]] = Boltz2DockingTool(tool_config=tool_config)
@@ -47,4 +47,4 @@ def run_boltz2(query: dict):
 
 
 if __name__ == "__main__":
-    server.run(transport="streamable-http", host="0.0.0.0", port=8080)
+    server.run(transport="streamable-http", host="0.0.0.0", port=8080, stateless_http=True)

tooluniverse/remote/uspto_downloader/uspto_downloader_mcp_server.py

@@ -18,7 +18,7 @@ except FileNotFoundError as e:
     )
     sys.exit(1)
 
-server = FastMCP("Your MCP Server", stateless_http=True)
+server = FastMCP("Your MCP Server")
 agents = {}
 for tool_config in uspto_downloader_tools:
     agents[tool_config["name"]] = USPTOPatentDocumentDownloader(tool_config=tool_config)
@@ -58,4 +58,4 @@ def download_full_text(query: dict):
 
 
 if __name__ == "__main__":
-    server.run(transport="streamable-http", host="0.0.0.0", port=8081)
+    server.run(transport="streamable-http", host="0.0.0.0", port=8081, stateless_http=True)