rsroute 0.1.0__py3-none-any.whl

rsroute/__init__.py

@@ -0,0 +1,47 @@
+from . import chat_models, agents
+from .base import BaseEstimator, BaseEstimatorAgent
+from .chat_models import (
+    ChatGemini,
+    ChatMistral,
+    ChatMistralAI,
+    MistralAI,
+    ChatGroq,
+    ChatOpenRouter,
+    OpenRouter,
+    ChatGPT,
+    ChatOpenAI,
+)
+from .agents import (
+    GeminiAgent,
+    MistralAgent,
+    GroqAgent,
+    OpenRouterAgent,
+    ChatOpenRouterAgent,
+    GPTAgent,
+    OpenAIAgent,
+    ChatGPTAgent,
+)
+
+__all__ = [
+    "chat_models",
+    "agents",
+    "BaseEstimator",
+    "BaseEstimatorAgent",
+    "ChatGemini",
+    "ChatMistral",
+    "ChatMistralAI",
+    "MistralAI",
+    "ChatGroq",
+    "ChatOpenRouter",
+    "OpenRouter",
+    "ChatGPT",
+    "ChatOpenAI",
+    "GeminiAgent",
+    "MistralAgent",
+    "GroqAgent",
+    "OpenRouterAgent",
+    "ChatOpenRouterAgent",
+    "GPTAgent",
+    "OpenAIAgent",
+    "ChatGPTAgent",
+]

rsroute/agents/__init__.py

@@ -0,0 +1,16 @@
+from .gemini_agent import GeminiAgent
+from .mistral_agent import MistralAgent
+from .groq_agent import GroqAgent
+from .openrouter_agent import OpenRouterAgent, ChatOpenRouterAgent
+from .openai_agent import GPTAgent, OpenAIAgent, ChatGPTAgent
+
+__all__ = [
+    "GeminiAgent",
+    "MistralAgent",
+    "GroqAgent",
+    "OpenRouterAgent",
+    "ChatOpenRouterAgent",
+    "GPTAgent",
+    "OpenAIAgent",
+    "ChatGPTAgent",
+]

rsroute/agents/gemini_agent.py

@@ -0,0 +1,77 @@
+"""Implementation of Gemini Agent Integration by RSRoute"""
+
+from typing import Any, Dict, Optional, List
+
+from rsroute.base import BaseEstimatorAgent
+from rsroute.urls import END_POINTS, URLS
+from langchain_core.tools import StructuredTool
+import warnings
+
+
+class GeminiAgent(BaseEstimatorAgent):
+    """GeminiAgent client for RSRoute."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        tools: List[StructuredTool] = None,
+        master_key: Optional[str] = None,
+        rsroute_url: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        system_prompt: Optional[Any] = None,
+        max_tool_calls: Optional[int] = 10,
+        timeout: int = 120,
+        end_point: Optional[str] = None,
+        thinking_level: Optional[Any] = None,
+        thinking_budget: Optional[int] = None,
+        **kwargs: Any,
+    ):
+        # Determine the target endpoint URL
+        if rsroute_url is None:
+            gemini_url = URLS.get("gemini_agent")
+        else:
+            gemini_url = f"{rsroute_url.rstrip('/')}/{END_POINTS.get('gemini_agent').lstrip('/')}"
+
+        super().__init__(
+            rsroute_url=gemini_url,
+            model=model,
+            max_tool_calls=max_tool_calls,
+            tools=tools,
+            master_key=master_key,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            system_prompt=system_prompt,
+            timeout=timeout,
+            end_point=end_point,
+            thinking_level=thinking_level,
+            thinking_budget=thinking_budget,
+            **kwargs,
+        )
+
+    def ainvoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Send a request to RSRoute Gemini Agent endpoint with the given query."""
+        return super().ainvoke(query=query)
+
+    def invoke(self, query=None):
+        """Generate response from Agent with ReAct Loop"""
+        results: Dict[str, Any] = super().invoke(query)
+        if not isinstance(results.get("content"), list):
+            return results
+        if len(results.get("content", [])) != 1:
+            return results
+
+        try:
+            result = results.copy()  # Safety copy
+            content: Dict[str, Any] = result.get("content")[0]
+            text_result = content.get("text")
+            extras = content.get("extras")
+
+            result["content"] = text_result
+            result["extras"] = extras
+
+            return result
+        except Exception as E:
+            warnings.warn(f"Got Error while extracting the information, {str(E)}")
+
+        return results  # after Exception

rsroute/agents/groq_agent.py

@@ -0,0 +1,54 @@
+"""Implementation of Groq Agent Integration by RSRoute"""
+
+from typing import Any, Dict, Optional, List
+
+from rsroute.base import BaseEstimatorAgent
+from rsroute.urls import END_POINTS, URLS
+from langchain_core.tools import StructuredTool
+
+
+class GroqAgent(BaseEstimatorAgent):
+    """GroqAgent client for RSRoute."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        tools: List[StructuredTool] = None,
+        master_key: Optional[str] = None,
+        rsroute_url: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        system_prompt: Optional[Any] = None,
+        max_tool_calls: Optional[int] = 10,
+        timeout: int = 120,
+        end_point: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        # Determine the target endpoint URL
+        if rsroute_url is None:
+            groq_url = URLS.get("groq_agent")
+        else:
+            groq_url = f"{rsroute_url.rstrip('/')}/{END_POINTS.get('groq_agent').lstrip('/')}"
+
+        super().__init__(
+            rsroute_url=groq_url,
+            model=model,
+            max_tool_calls=max_tool_calls,
+            tools=tools,
+            master_key=master_key,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            system_prompt=system_prompt,
+            timeout=timeout,
+            end_point=end_point,
+            **kwargs,
+        )
+
+    def ainvoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Send a request to RSRoute Groq Agent endpoint with the given query."""
+        return super().ainvoke(query=query)
+
+    def invoke(self, query=None):
+        """Generate response from Agent with ReAct Loop"""
+        return super().invoke(query)
+

rsroute/agents/mistral_agent.py

@@ -0,0 +1,53 @@
+"""Implementation of Mistral Agent Integration by RSRoute"""
+
+from typing import Any, Dict, Optional, List
+
+from rsroute.base import BaseEstimatorAgent
+from rsroute.urls import END_POINTS, URLS
+from langchain_core.tools import StructuredTool
+
+
+class MistralAgent(BaseEstimatorAgent):
+    """MistralAgent client for RSRoute."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        tools: List[StructuredTool] = None,
+        master_key: Optional[str] = None,
+        rsroute_url: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        system_prompt: Optional[Any] = None,
+        max_tool_calls: Optional[int] = 10,
+        timeout: int = 120,
+        end_point: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        # Determine the target endpoint URL
+        if rsroute_url is None:
+            mistral_url = URLS.get("mistral_agent")
+        else:
+            mistral_url = f"{rsroute_url.rstrip('/')}/{END_POINTS.get('mistral_agent').lstrip('/')}"
+
+        super().__init__(
+            rsroute_url=mistral_url,
+            model=model,
+            max_tool_calls=max_tool_calls,
+            tools=tools,
+            master_key=master_key,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            system_prompt=system_prompt,
+            timeout=timeout,
+            end_point=end_point,
+            **kwargs,
+        )
+
+    def ainvoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Send a request to RSRoute Mistral Agent endpoint with the given query."""
+        return super().ainvoke(query=query)
+
+    def invoke(self, query=None):
+        """Generate response from Agent with ReAct Loop"""
+        return super().invoke(query)

rsroute/agents/openai_agent.py

@@ -0,0 +1,88 @@
+"""Implementation of OpenAI Agent Integration by RSRoute"""
+
+from typing import Any, Dict, List, Optional
+import warnings
+
+from rsroute.base import BaseEstimatorAgent, get_org_id
+from rsroute.urls import END_POINTS, URLS
+from langchain_core.tools import StructuredTool
+
+
+class GPTAgent(BaseEstimatorAgent):
+    """GPTAgent (OpenAIAgent) client for RSRoute."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        tools: List[StructuredTool] = None,
+        master_key: Optional[str] = None,
+        rsroute_url: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        system_prompt: Optional[Any] = None,
+        max_tool_calls: Optional[int] = 10,
+        timeout: int = 120,
+        end_point: Optional[str] = None,
+        max_retries: Optional[int] = None,
+        use_response_api: Optional[bool] = None,
+        organization_id: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        # Determine the target endpoint URL
+        if rsroute_url is None:
+            openai_url = URLS.get("openai_agent")
+        else:
+            openai_url = f"{rsroute_url.rstrip('/')}/{END_POINTS.get('openai_agent').lstrip('/')}"
+
+        # Resolve organization_id: explicit arg > org_id alias > .env lookup
+        resolved_org_id = organization_id or get_org_id()
+
+        super().__init__(
+            rsroute_url=openai_url,
+            model=model,
+            max_tool_calls=max_tool_calls,
+            tools=tools,
+            master_key=master_key,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            system_prompt=system_prompt,
+            timeout=timeout,
+            end_point=end_point,
+            max_retries=max_retries,
+            use_response_api=use_response_api,
+            organization_id=resolved_org_id,
+            **kwargs,
+        )
+
+    def ainvoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Send a request to RSRoute OpenAI Agent endpoint with the given query."""
+        return super().ainvoke(query=query)
+
+    def invoke(self, query=None):
+        """Generate response from Agent with ReAct Loop"""
+        results: Dict[str, Any] = super().invoke(query)
+        if not isinstance(results.get("content"), list):
+            return results
+        if len(results.get("content", [])) != 1:
+            return results
+
+        try:
+            result = results.copy()  # Safety copy
+            content: Dict[str, Any] = result.get("content")[0]
+            if isinstance(content, dict) and "text" in content:
+                text_result = content.get("text")
+                extras = content.get("extras")
+
+                result["content"] = text_result
+                result["extras"] = extras
+
+                return result
+        except Exception as E:
+            warnings.warn(f"Got Error while extracting the information, {str(E)}")
+
+        return results
+
+
+# Aliases
+OpenAIAgent = GPTAgent
+ChatGPTAgent = GPTAgent

rsroute/agents/openrouter_agent.py

@@ -0,0 +1,88 @@
+"""Implementation of OpenRouter Agent Integration by RSRoute"""
+
+from typing import Any, Dict, List, Optional
+import warnings
+
+from rsroute.base import BaseEstimatorAgent
+from rsroute.urls import END_POINTS, URLS
+from langchain_core.tools import StructuredTool
+
+
+class OpenRouterAgent(BaseEstimatorAgent):
+    """OpenRouterAgent client for RSRoute."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        tools: List[StructuredTool] = None,
+        master_key: Optional[str] = None,
+        rsroute_url: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        system_prompt: Optional[Any] = None,
+        max_tool_calls: Optional[int] = 10,
+        timeout: int = 120,
+        end_point: Optional[str] = None,
+        app_title: Optional[str] = None,
+        app_url: Optional[str] = None,
+        app_categories: Optional[List[str]] = None,
+        max_retries: Optional[int] = None,
+        providers: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ):
+        # Determine the target endpoint URL
+        if rsroute_url is None:
+            openrouter_url = URLS.get("openrouter_agent")
+        else:
+            openrouter_url = f"{rsroute_url.rstrip('/')}/{END_POINTS.get('openrouter_agent').lstrip('/')}"
+
+        super().__init__(
+            rsroute_url=openrouter_url,
+            model=model,
+            max_tool_calls=max_tool_calls,
+            tools=tools,
+            master_key=master_key,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            system_prompt=system_prompt,
+            timeout=timeout,
+            end_point=end_point,
+            app_title=app_title,
+            app_url=app_url,
+            app_categories=app_categories,
+            max_retries=max_retries,
+            providers=providers,
+            **kwargs,
+        )
+
+    def ainvoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Send a request to RSRoute OpenRouter Agent endpoint with the given query."""
+        return super().ainvoke(query=query)
+
+    def invoke(self, query=None):
+        """Generate response from Agent with ReAct Loop"""
+        results: Dict[str, Any] = super().invoke(query)
+        if not isinstance(results.get("content"), list):
+            return results
+        if len(results.get("content", [])) != 1:
+            return results
+
+        try:
+            result = results.copy()  # Safety copy
+            content: Dict[str, Any] = result.get("content")[0]
+            if isinstance(content, dict) and "text" in content:
+                text_result = content.get("text")
+                extras = content.get("extras")
+
+                result["content"] = text_result
+                result["extras"] = extras
+
+                return result
+        except Exception as E:
+            warnings.warn(f"Got Error while extracting the information, {str(E)}")
+
+        return results
+
+
+ChatOpenRouterAgent = OpenRouterAgent
+

rsroute/base.py

@@ -0,0 +1,324 @@
+from abc import ABC
+import os
+from typing import Any, Dict, Optional, List, Iterable
+import requests
+from langchain_core.tools import StructuredTool
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+from rich import print
+import warnings
+from dotenv import load_dotenv
+
+def _load_env_file(dotenv_path: str = ".env") -> None:
+    """Fallback .env file loader if python-dotenv is not installed."""
+    if os.path.exists(dotenv_path):
+        try:
+            with open(dotenv_path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line or line.startswith("#") or "=" not in line:
+                        continue
+                    k, v = line.split("=", 1)
+                    k = k.strip()
+                    v = v.strip().strip("'\"")
+                    if k and k not in os.environ:
+                        os.environ[k] = v
+        except Exception:
+            pass
+
+def get_org_id():
+    """automatically pick OpenAI Org Id from .env"""
+    try:
+        load_dotenv()
+
+        candidates = [
+            "org_id", "ORG_ID",
+            "organization_id", "ORGANIZATION_ID",
+            "openai_org_id", "OPENAI_ORG_ID"
+        ]
+
+        for candidate in candidates:
+            val = os.getenv(candidate)
+
+            if val:
+                return val
+
+        return None
+    except ModuleNotFoundError:
+        raise "No Module Found dotenv"
+
+def find_master_key(master_key: Optional[str] = None) -> Optional[str]:
+    """Search for rsroute_token, master_key, or rsroute_key in arguments, environment, or .env."""
+    if master_key:
+        return master_key
+
+    # Attempt to load .env using python-dotenv if installed, otherwise use fallback
+    try:
+        from dotenv import find_dotenv, load_dotenv
+        load_dotenv(find_dotenv(usecwd=True))
+    except ImportError:
+        _load_env_file()
+
+    # Search candidates in priority order (both lower and upper case)
+    candidates = [
+        "rsroute_token", "RSROUTE_TOKEN",
+        "master_key", "MASTER_KEY",
+        "rsroute_key", "RSROUTE_KEY",
+        "rsroute_master_key", "RSROUTE_MASTER_KEY",
+    ]
+    for candidate in candidates:
+        val = os.getenv(candidate)
+        if val:
+            return val
+
+    return None
+
+
+class BaseEstimator(ABC):
+    """Base estimator class for RSRoute chat models."""
+
+    @staticmethod
+    def find_master_key(master_key: Optional[str] = None) -> Optional[str]:
+        """Resolve the master key from parameter, environment, or .env file."""
+        return find_master_key(master_key)
+
+    def __init__(
+        self,
+        rsroute_url: str = None,
+        model: Optional[str] = None,
+        timeout: int = 30,
+        master_key: str = None,
+        max_tokens: Optional[int] = None,
+        system_prompt: Optional[Any] = None,
+        **kwargs: Any,
+    ):
+        if rsroute_url is None:
+            raise AttributeError("`rsroute_url` got `None`")
+
+        self.rsroute_url = rsroute_url
+        self.request_data: dict[str, Any] = {}
+        self.timeout = timeout
+
+
+        if system_prompt is None:
+            self.system_prompt = False
+        elif isinstance(system_prompt, str):
+            self.system_prompt = {"role": "system", "content" : system_prompt}
+        elif isinstance(system_prompt, SystemMessage):
+            self.system_prompt = {"role": "system", "content" : system_prompt.content}
+        else:
+            self.system_prompt = {"role": "system", "content" : f"{system_prompt}"}
+
+        resolved_key = self.find_master_key(master_key)
+        if resolved_key is not None:
+            self.master_key = resolved_key
+            self.request_data["master_key"] = resolved_key
+        else:
+            raise ValueError(
+                "`master_key` Can't be None. Please pass master_key or set "
+                "`rsroute_token`, `master_key`, or `rsroute_key` in a .env file or environment variable."
+            )
+
+        if model is not None:
+            self.model = model
+            self.request_data["model"] = model
+        if max_tokens is not None:
+            self.max_tokens = max_tokens
+            self.request_data["max_tokens"] = max_tokens
+
+        for key, value in kwargs.items():
+            if value is not None:
+                self.request_data[key] = value
+
+    def get_params(self) -> Dict[str, Any]:
+        """Return the initialized parameters for the model (excluding master_key)."""
+        params = self.request_data.copy()
+        params.pop("master_key", None)
+        return params
+
+    def __call__(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Callable interface forwarding to invoke."""
+        return self.invoke(query=query)
+
+    def generate(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Generate response forwarding to invoke."""
+        return self.invoke(query=query)
+
+    def invoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Invoke the model endpoint with a query."""
+        request_data = self.request_data.copy()
+
+        if query is not None:
+            if isinstance(query, list):
+                request_data["query"] = query
+            elif self.system_prompt == False:
+                request_data["query"] = [
+                    {"role": "user", "content": f"{query}"}
+                ]
+            else:
+                request_data["query"] = [
+                    self.system_prompt,
+                    {
+                        "role": "user",
+                        "content": f"{query}"
+                    }
+                ]
+
+        try:
+            return requests.post(url=self.rsroute_url, json=request_data, timeout=self.timeout).json()
+        except requests.exceptions.RequestException as exc:
+            raise RuntimeError(
+                f"RSRoute request failed ({type(exc).__name__}). "
+                "Check the server URL, connectivity, and timeout."
+            ) from exc
+
+class BaseEstimatorAgent(BaseEstimator):
+    def __init__(
+        self,
+        rsroute_url: str = None,
+        model: Optional[str] = None,
+        max_tool_calls : Optional[int] = 10,
+        timeout: int = 120,
+        system_prompt: Optional[Any] = None,
+        master_key: str = None,
+        max_tokens: Optional[int] = None,
+        tools: List[StructuredTool] = None,
+        **kwargs: Any,
+    ):
+
+        if tools is None or len(tools) == 0:
+            raise ValueError("Tools can't be Empty")
+
+        # Safety Check
+        for tool in tools:
+            if not isinstance(tool, StructuredTool):
+                raise TypeError("Tool must be Langchain StructuredTool")
+            else:
+                ...
+        
+        # Internal Error Probably
+        if not rsroute_url.endswith("/agent"):
+            raise RuntimeError(f"Agent calls can only work with `/agent` end points, endpoint get = {rsroute_url}")
+
+        # tools information conversion 
+        self.tools_info = self.__convert_tool_to_dict(tools=tools)
+
+
+        super().__init__(
+            rsroute_url=rsroute_url,
+            model=model,
+            timeout=timeout,
+            master_key=master_key,
+            max_tokens=max_tokens,
+            tools_info=self.tools_info,
+            system_prompt=system_prompt,
+            **kwargs,
+        )
+
+        # Important Info to Save
+        self.max_tool_calls = max_tool_calls
+        self.tools = tools
+
+    def ainvoke(self, query = None):
+        return super().invoke(query)
+
+    def invoke(self, query = None):
+        result =  super().invoke(query)
+        tool_used_names = []
+
+        if not result["tool_calls"]:
+            return result
+        # tools mapping 
+        tools_map = self.__map_tools(tools=self.tools)
+        messages = []
+        if self.system_prompt:
+            messages.append(self.system_prompt)
+        messages.extend([
+            {"role": "user", "content": f"{query}"},
+            {"role": "assistant", "content": str(result.get("content", "")), "tool_calls": result.get("tool_calls", [])}
+        ])
+        usage = result.get("usage_metadata")
+        if isinstance(usage, dict):
+            try:
+                input_tokens = usage.get("input_tokens", 0)
+                output_tokens = usage.get("output_tokens", 0)
+                total_tokens = input_tokens + output_tokens
+            except (TypeError, ValueError):
+                warnings.warn("Error while extracting tokens from usage_metadata.")
+                input_tokens = output_tokens = total_tokens = None
+        else:
+            input_tokens = output_tokens = total_tokens = None
+
+        tool_used = 0
+        while result.get("tool_calls"):
+            if tool_used >= self.max_tool_calls:
+                raise BufferError(f"Agent Called More Tool than max_tool_calls which is set to {self.max_tool_calls}")
+
+            tool_call_info = result["tool_calls"][0]
+
+            # choosed tool
+            chosen_tool = tools_map.get(tool_call_info.get("name"))
+            if chosen_tool is None:
+                raise ValueError(f"Tool '{tool_call_info.get('name')}' not found in mapped tools")
+
+            if not tool_call_info.get("args"):
+                raise ValueError("Model provided no parameters for Tool call.")
+
+            tool_result = chosen_tool.invoke(tool_call_info.get("args"))
+
+            tool_used_names.append(chosen_tool.name)
+            messages.append(
+                {
+                    "role": "tool",
+                    "content": f"{tool_result}",
+                    "tool_call_id": tool_call_info["id"]
+                }
+            )
+
+            result = super().invoke(messages)
+            messages.append(
+                {"role": "assistant", "content": str(result.get("content", "")), "tool_calls": result.get("tool_calls", [])}
+            )
+
+            # usage update from new step
+            step_usage = result.get("usage_metadata")
+            if isinstance(step_usage, dict):
+                try:
+                    input_tokens = (input_tokens or 0) + step_usage.get("input_tokens", 0)
+                    output_tokens = (output_tokens or 0) + step_usage.get("output_tokens", 0)
+                    total_tokens = input_tokens + output_tokens
+                except (TypeError, ValueError):
+                    warnings.warn("Error while updating tokens from usage_metadata.")
+
+            tool_used += 1
+
+        if input_tokens is not None:
+            if not isinstance(result.get("usage_metadata"), dict):
+                result["usage_metadata"] = {}
+            result["usage_metadata"]["input_tokens"] = input_tokens
+            result["usage_metadata"]["output_tokens"] = output_tokens
+            result["usage_metadata"]["total_tokens"] = total_tokens
+
+        result["tools_used"] = tool_used_names
+        return result
+
+    def __convert_tool_to_dict(self, tools: List[StructuredTool]) -> List[Dict[str, str]]:
+        tools_info = []
+
+        for tool in tools:
+            tool_info = {
+                "name": tool.name,
+                "description": tool.description
+            }
+
+            tools_info.append(tool_info)
+        
+        return tools_info
+
+    def __map_tools(self, tools: List[StructuredTool]) -> Dict[str, StructuredTool]:
+        tool_map = {}
+
+        for tool in tools:
+            tool_map[tool.name] = tool
+
+        return tool_map
+    

rsroute/chat_models/__init__.py

@@ -0,0 +1,17 @@
+from rsroute.chat_models.gemini_client import ChatGemini
+from rsroute.chat_models.mistral_client import ChatMistral, ChatMistralAI, MistralAI
+from rsroute.chat_models.groq_client import ChatGroq
+from rsroute.chat_models.openrouter_client import ChatOpenRouter, OpenRouter
+from rsroute.chat_models.openai_client import ChatGPT, ChatOpenAI
+
+__all__ = [
+    "ChatGemini",
+    "ChatMistral",
+    "ChatMistralAI",
+    "MistralAI",
+    "ChatGroq",
+    "ChatOpenRouter",
+    "OpenRouter",
+    "ChatGPT",
+    "ChatOpenAI",
+]

rsroute/chat_models/gemini_client.py

@@ -0,0 +1,46 @@
+from typing import Any, Dict, Optional
+
+from rsroute.base import BaseEstimator
+from rsroute.urls import END_POINTS, URLS
+
+
+class ChatGemini(BaseEstimator):
+    """ChatGemini client for RSRoute."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        master_key: Optional[str] = None,
+        rsroute_url: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        system_prompt: Optional[Any] = None,
+        timeout: int = 30,
+        end_point: Optional[str] = None,
+        thinking_level: Optional[Any] = None,
+        thinking_budget: Optional[int] = None,
+        **kwargs: Any,
+    ):
+        # Determine the target endpoint URL
+        if rsroute_url is None:
+            gemini_url = URLS.get("gemini")
+        else:
+            gemini_url = f"{rsroute_url.rstrip('/')}/{END_POINTS.get('gemini').lstrip('/')}"
+
+        super().__init__(
+            rsroute_url=gemini_url,
+            model=model,
+            master_key=master_key,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            system_prompt=system_prompt,
+            timeout=timeout,
+            end_point=end_point,
+            thinking_level=thinking_level,
+            thinking_budget=thinking_budget,
+            **kwargs,
+        )
+
+    def invoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Send a request to RSRoute Gemini chat endpoint with the given query."""
+        return super().invoke(query=query)

rsroute/chat_models/groq_client.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict, Optional
+
+from rsroute.base import BaseEstimator
+from rsroute.urls import END_POINTS, URLS
+
+
+class ChatGroq(BaseEstimator):
+    """ChatGroq client for RSRoute."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        master_key: Optional[str] = None,
+        rsroute_url: Optional[str] = None,
+        system_prompt: Optional[Any] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        timeout: int = 30,
+        end_point: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        # Determine the target endpoint URL
+        if rsroute_url is None:
+            groq_url = URLS.get("groq")
+        else:
+            groq_url = f"{rsroute_url.rstrip('/')}/{END_POINTS.get('groq').lstrip('/')}"
+
+        super().__init__(
+            rsroute_url=groq_url,
+            model=model,
+            master_key=master_key,
+            system_prompt=system_prompt,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            end_point=end_point,
+            **kwargs,
+        )
+
+    def invoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Send a request to RSRoute Groq chat endpoint with the given query."""
+        return super().invoke(query=query)
+

rsroute/chat_models/mistral_client.py

@@ -0,0 +1,46 @@
+from typing import Any, Dict, Optional
+
+from rsroute.base import BaseEstimator
+from rsroute.urls import END_POINTS, URLS
+
+
+class ChatMistral(BaseEstimator):
+    """ChatMistral client for RSRoute."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        master_key: Optional[str] = None,
+        rsroute_url: Optional[str] = None,
+        system_prompt: Optional[Any] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        timeout: int = 30,
+        end_point: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        # Determine the target endpoint URL
+        if rsroute_url is None:
+            mistral_url = URLS.get("mistral")
+        else:
+            mistral_url = f"{rsroute_url.rstrip('/')}/{END_POINTS.get('mistral').lstrip('/')}"
+
+        super().__init__(
+            rsroute_url=mistral_url,
+            model=model,
+            master_key=master_key,
+            system_prompt=system_prompt,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            end_point=end_point,
+            **kwargs,
+        )
+
+    def invoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Send a request to RSRoute Mistral chat endpoint with the given query."""
+        return super().invoke(query=query)
+
+
+ChatMistralAI = ChatMistral
+MistralAI = ChatMistral

rsroute/chat_models/openai_client.py

@@ -0,0 +1,55 @@
+from typing import Any, Dict, Optional
+
+from rsroute.base import BaseEstimator, get_org_id
+from rsroute.urls import END_POINTS, URLS
+
+
+class ChatGPT(BaseEstimator):
+    """ChatGPT (ChatOpenAI) client for RSRoute."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        master_key: Optional[str] = None,
+        rsroute_url: Optional[str] = None,
+        system_prompt: Optional[Any] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        timeout: int = 60,
+        end_point: Optional[str] = None,
+        max_retries: Optional[int] = None,
+        use_response_api: Optional[bool] = None,
+        organization_id: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        # Determine the target endpoint URL
+        if rsroute_url is None:
+            openai_url = URLS.get("openai")
+        else:
+            openai_url = f"{rsroute_url.rstrip('/')}/{END_POINTS.get('openai').lstrip('/')}"
+
+        # Resolve organization_id: explicit arg > org_id alias > .env lookup
+        resolved_org_id = organization_id or get_org_id()
+
+        super().__init__(
+            rsroute_url=openai_url,
+            model=model,
+            master_key=master_key,
+            system_prompt=system_prompt,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            end_point=end_point,
+            max_retries=max_retries,
+            use_response_api=use_response_api,
+            organization_id=resolved_org_id,
+            **kwargs,
+        )
+
+    def invoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Send a request to RSRoute OpenAI chat endpoint with the given query."""
+        return super().invoke(query=query)
+
+
+# Alias
+ChatOpenAI = ChatGPT

rsroute/chat_models/openrouter_client.py

@@ -0,0 +1,56 @@
+from typing import Any, Dict, List, Optional
+
+from rsroute.base import BaseEstimator
+from rsroute.urls import END_POINTS, URLS
+
+
+class ChatOpenRouter(BaseEstimator):
+    """ChatOpenRouter client for RSRoute."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        master_key: Optional[str] = None,
+        rsroute_url: Optional[str] = None,
+        system_prompt: Optional[Any] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        timeout: int = 30,
+        end_point: Optional[str] = None,
+        app_title: Optional[str] = None,
+        app_url: Optional[str] = None,
+        app_categories: Optional[List[str]] = None,
+        max_retries: Optional[int] = None,
+        providers: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ):
+        # Determine the target endpoint URL
+        if rsroute_url is None:
+            openrouter_url = URLS.get("openrouter")
+        else:
+            openrouter_url = f"{rsroute_url.rstrip('/')}/{END_POINTS.get('openrouter').lstrip('/')}"
+
+        super().__init__(
+            rsroute_url=openrouter_url,
+            model=model,
+            master_key=master_key,
+            system_prompt=system_prompt,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            end_point=end_point,
+            app_title=app_title,
+            app_url=app_url,
+            app_categories=app_categories,
+            max_retries=max_retries,
+            providers=providers,
+            **kwargs,
+        )
+
+    def invoke(self, query: Optional[Any] = None) -> Dict[Any, Any]:
+        """Send a request to RSRoute OpenRouter chat endpoint with the given query."""
+        return super().invoke(query=query)
+
+
+OpenRouter = ChatOpenRouter
+

rsroute/urls.py

@@ -0,0 +1,44 @@
+ROOT_URL = "http://0.0.0.0:8000/"
+GEMINI_URL = "http://0.0.0.0:8000/v1/gemini/chat"
+MISTRAL_URL = "http://0.0.0.0:8000/v1/mistral/chat"
+GROQ_URL = "http://0.0.0.0:8000/v1/groq/chat"
+OPENROUTER_URL = "http://0.0.0.0:8000/v1/openrouter/chat"
+OPENAI_URL = "http://0.0.0.0:8000/v1/openai/chat"
+
+
+# Agentic Routes
+GEMINI_AGENT = "http://0.0.0.0:8000/v1/gemini/agent"
+MISTRAL_AGENT = "http://0.0.0.0:8000/v1/mistral/agent"
+GROQ_AGENT = "http://0.0.0.0:8000/v1/groq/agent"
+OPENROUTER_AGENT = "http://0.0.0.0:8000/v1/openrouter/agent"
+OPENAI_AGENT = "http://0.0.0.0:8000/v1/openai/agent"
+
+
+URLS = {
+    "root": ROOT_URL,
+    "gemini": GEMINI_URL,
+    "mistral": MISTRAL_URL,
+    "groq": GROQ_URL,
+    "openrouter": OPENROUTER_URL,
+    "gemini_agent": GEMINI_AGENT,
+    "mistral_agent": MISTRAL_AGENT,
+    "groq_agent": GROQ_AGENT,
+    "openrouter_agent": OPENROUTER_AGENT,
+    "openai": OPENAI_URL,
+    "openai_agent": OPENAI_AGENT
+}
+
+
+END_POINTS = {
+    "root": "/",
+    "gemini": "/v1/gemini/chat",
+    "mistral": "/v1/mistral/chat",
+    "groq": "/v1/groq/chat",
+    "openrouter": "/v1/openrouter/chat",
+    "gemini_agent": "/v1/gemini/agent",
+    "mistral_agent": "/v1/mistral/agent",
+    "groq_agent": "/v1/groq/agent",
+    "openrouter_agent": "/v1/openrouter/agent",
+    "openai": "/v1/openai/chat",
+    "openai_agent": "/v1/openai/agent"
+}

rsroute-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.3
+Name: rsroute
+Version: 0.1.0
+Summary: Python Package Wrapper for RSRoute server
+Author: ItzRustam
+Author-email: ItzRustam <rustambhadouriya7@gmail.com>
+Requires-Dist: requests
+Requires-Dist: langchain-core
+Requires-Dist: rich
+Requires-Dist: python-dotenv
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# rsroute
+
+### What it is
+`rsroute` is a lightweight Python client for [RSRoute](https://www.github.com/ItzRustam/rsroute) — a unified gateway that routes requests across 10+ LLM providers seamlessly.
+
+### Why it is
+Instead of managing disparate SDKs, raw HTTP requests, query parameters, and custom endpoints manually for each provider, `rsroute` provides a simple, unified wrapper so you can connect to your RSRoute server with minimal code.
+
+### Code Example - ChatModel
+```python
+from rsroute.chat_models import ChatGemini, ChatMistral, ChatGroq, ChatOpenRouter
+
+# Gemini
+gemini_model = ChatGemini(
+    model="gemini-3.5-flash-lite",
+    rsroute_url="http://0.0.0.0:8000", # your URL always default to this.
+)
+response = gemini_model.invoke(query="What is GitHub?")
+print(response)
+
+# Groq
+groq_model = ChatGroq(
+    model="openai/gpt-oss-120b",
+    temperature=0.7,
+)
+response = groq_model.invoke(query="Hello Groq!")
+print(response)
+
+# OpenRouter
+openrouter_model = ChatOpenRouter(
+    model="deepseek/deepseek-v4.1-flash",
+    temperature=0.7,
+)
+response = openrouter_model.invoke(query="Hello OpenRouter!")
+print(response)
+```
+
+### Code Example - Agents
+```python
+from rsroute.agents import GeminiAgent, MistralAgent, GroqAgent, OpenRouterAgent
+
+# Gemini Agent
+gemini_agent = GeminiAgent(
+    tools=[web_search], # your tools
+    max_tool_calls=12 # Default to 10
+)
+response = gemini_agent.invoke(query="Latest News of GPT-6 Astra")
+print(response)
+
+# Mistral Agent
+mistral_agent = MistralAgent(
+    tools=[web_search],
+    model="mistral-small-2603"
+)
+response = mistral_agent.invoke(query="What is the weather in Paris?")
+print(response)
+
+# Groq Agent
+groq_agent = GroqAgent(
+    tools=[web_search],
+    model="openai/gpt-oss-120b"
+)
+response = groq_agent.invoke(query="Compute 42 * 42")
+print(response)
+
+# OpenRouter Agent
+openrouter_agent = OpenRouterAgent(
+    tools=[web_search],
+    model="deepseek/deepseek-v4.1-flash"
+)
+response = openrouter_agent.invoke(query="Search latest news")
+print(response)
+```
+
+### Feature
+* automatic `master_key` loading from .env
+* proper request handling
+* Agentic power
+
+### Valid `.env` name
+Any of the following variable names can be used in your `.env` file:
+* `rsroute_token` (or `RSROUTE_TOKEN`)
+* `master_key` (or `MASTER_KEY`)
+* `rsroute_key` (or `RSROUTE_KEY`)
+* `rsroute_master_key` (or `RSROUTE_MASTER_KEY`)
+
+
+### Server
+RSRoute Server repository: [RSRoute GitHub](https://www.github.com/ItzRustam/rsroute)
+
+RSRoute website: [RSRoute Web](https://www.rsroute.freedev.app)

rsroute-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+rsroute/__init__.py,sha256=uPM6GKh79-XtBvQaPJu4rk7oj0QMf6ZKurDuJue9GHw,850
+rsroute/agents/__init__.py,sha256=Gs1uPqjbkQQHIx99L3G8wSO6UYA4-2Nu-yIOJoGyI6U,417
+rsroute/agents/gemini_agent.py,sha256=ymgEgiDcnLq3rbrADXCc_3PbQWUqefS6JcIjl-qLR2o,2625
+rsroute/agents/groq_agent.py,sha256=ZBzmVpaDig8YT7FuY4SBppsm8wP-3DJ211E_XyuIPgQ,1748
+rsroute/agents/mistral_agent.py,sha256=XNL-W8NqZAeMIm0D8g_4CWr9pVUeZTNTpnWZGDAoaLo,1774
+rsroute/agents/openai_agent.py,sha256=u_pOc3k38nCdLEJxDl7vBAwX3pVCi_TKoyGvBr6rjgM,2992
+rsroute/agents/openrouter_agent.py,sha256=7ebWKWNruvvbMUn9QNlkTdQqF5VgO353QH7_-xAo8IM,2988
+rsroute/base.py,sha256=vpoxy0zF7m81gzjWWMEFWYxyOrqalW4NPbj3yjuA7Bk,11365
+rsroute/chat_models/__init__.py,sha256=aEyFNykW73fyBC8VN1a1RYSnhAscps-yxN0ajjVY3YQ,517
+rsroute/chat_models/gemini_client.py,sha256=IeYCcGnFMIA1QMhUS3SrxUBImCDQA_g7FjiffFjaiHE,1516
+rsroute/chat_models/groq_client.py,sha256=_x8snenxthJgUCURki5NjP_S-9GluhcflyKRwbaGzMo,1320
+rsroute/chat_models/mistral_client.py,sha256=tTF15FBReGVAGTYTQ1lIZEmpdJfFVvgqR4pWLC1C3go,1397
+rsroute/chat_models/openai_client.py,sha256=yiNoD5n0pKFEZXoTM6H89EIF5ItkabNu6rkIrwNjH_4,1789
+rsroute/chat_models/openrouter_client.py,sha256=hrDMe9HZogxpXIYLlIDZVIRMPUOnkrFXAnS2P95SnQA,1806
+rsroute/urls.py,sha256=xlxO1DeXFWJILCvPkaiYTyzOS8ts32G_qk1gIwjTNgg,1338
+rsroute-0.1.0.dist-info/WHEEL,sha256=3iQx15CyXwGi4dbygedzA4M5T1eqO_SjwdPfUmqt2Cw,81
+rsroute-0.1.0.dist-info/METADATA,sha256=jfm7DI3HP9kgLCjIB_yXSJcqxF-j68Svfr7raaWwWLI,2873
+rsroute-0.1.0.dist-info/RECORD,,

rsroute-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.24
+Root-Is-Purelib: true
+Tag: py3-none-any