universal-mcp 0.1.24rc14__py3-none-any.whl → 0.1.24rc17__py3-none-any.whl

universal_mcp/agents/hil.py

@@ -1,104 +0,0 @@
-from typing import Annotated, TypedDict
-
-from langchain_core.messages import HumanMessage
-from langgraph.constants import END, START
-from langgraph.graph import StateGraph
-from langgraph.graph.message import add_messages
-from langgraph.types import Interrupt, interrupt
-
-from .base import BaseAgent
-from .llm import load_chat_model
-
-
-class State(TypedDict):
-    messages: Annotated[list, add_messages]
-    name: str | None = None
-    favourite_color: str | None = None
-    human: bool | None = None
-
-
-def ask_name_node(state: State) -> State:
-    if state.get("name") is not None:
-        return state
-    name = interrupt({"question": "What is your name?", "type": "text"})
-    state.update(name=name, messages=[HumanMessage(content=f"My name is {name}")])
-    return state
-
-
-def ask_bool_node(state: State) -> State:
-    if state.get("human") is not None:
-        return state
-    bool = interrupt({"question": "Are you a human?", "type": "bool"})
-
-    if bool:
-        state.update(human=True, messages=[HumanMessage(content="I am human")])
-    else:
-        state.update(human=False, messages=[HumanMessage(content="I am AI agent")])
-    return state
-
-
-def ask_favourite_color_node(state: State) -> State:
-    if state.get("favourite_color") is not None:
-        return state
-    favourite_color = interrupt(
-        {"question": "What is your favourite color?", "type": "choice", "choices": ["red", "green", "blue"]}
-    )
-    state.update(
-        favourite_color=favourite_color, messages=[HumanMessage(content=f"My favourite color is {favourite_color}")]
-    )
-    return state
-
-
-def handle_interrupt(interrupt: Interrupt) -> str | bool:
-    interrupt_type = interrupt.value["type"]
-    if interrupt_type == "text":
-        value = input(interrupt.value["question"])
-        return value
-    elif interrupt_type == "bool":
-        value = input("Do you accept this? (y/n): " + interrupt.value["question"])
-        return value.lower() in ["y", "yes"]
-    elif interrupt_type == "choice":
-        value = input("Enter your choice: " + interrupt.value["question"] + " " + ", ".join(interrupt.value["choices"]))
-        if value in interrupt.value["choices"]:
-            return value
-        else:
-            return interrupt.value["choices"][0]
-    else:
-        raise ValueError(f"Invalid interrupt type: {interrupt.value['type']}")
-
-
-class HilAgent(BaseAgent):
-    def __init__(self, name: str, instructions: str, model: str):
-        super().__init__(name, instructions, model)
-        self.llm = load_chat_model(model)
-        self._graph = self._build_graph()
-
-    def chatbot(self, state: State):
-        return {"messages": [self.llm.invoke(state["messages"])]}
-
-    def _build_graph(self):
-        graph_builder = StateGraph(State)
-        graph_builder.add_node("ask_name_node", ask_name_node)
-        graph_builder.add_node("ask_bool_node", ask_bool_node)
-        graph_builder.add_node("ask_favourite_color_node", ask_favourite_color_node)
-        graph_builder.add_node("chatbot", self.chatbot)
-        graph_builder.add_edge(START, "ask_name_node")
-        graph_builder.add_edge("ask_name_node", "ask_bool_node")
-        graph_builder.add_edge("ask_bool_node", "ask_favourite_color_node")
-        graph_builder.add_edge("ask_favourite_color_node", "chatbot")
-        graph_builder.add_edge("chatbot", END)
-        return graph_builder.compile(checkpointer=self.memory)
-
-    @property
-    def graph(self):
-        return self._graph
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    agent = HilAgent(
-        "Hil Agent", "You are a friendly agent that asks for the user's name and greets them.", "openrouter/auto"
-    )
-
-    asyncio.run(agent.run_interactive())

universal_mcp/agents/llm.py

@@ -1,45 +0,0 @@
-from langchain_anthropic import ChatAnthropic
-from langchain_core.language_models import BaseChatModel
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_openai import AzureChatOpenAI
-
-
-def load_chat_model(
-    fully_specified_name: str, temperature: float = 1.0, tags: list[str] | None = None
-) -> BaseChatModel:
-    """Load a chat model from a fully specified name.
-    Args:
-        fully_specified_name (str): String in the format 'provider/model'.
-    """
-    provider, model = fully_specified_name.split("/", maxsplit=1)
-    if provider == "anthropic":
-        return ChatAnthropic(
-            model=model,
-            temperature=temperature,
-            thinking={"type": "enabled", "budget_tokens": 2048},
-            max_tokens=4096,
-            tags=tags,
-            stream_usage=True,
-        )  # pyright: ignore[reportCallIssue]
-    elif provider == "azure":
-        return AzureChatOpenAI(
-            model=model,
-            api_version="2024-12-01-preview",
-            azure_deployment=model,
-            temperature=temperature,
-            tags=tags,
-            stream_usage=True,
-        )
-    elif provider == "gemini":
-        return ChatGoogleGenerativeAI(model=model, temperature=temperature)
-    else:
-        raise ValueError(f"Unsupported provider: {provider}")
-
-
-if __name__ == "__main__":
-    from loguru import logger
-
-    models_to_test = ["azure/gpt-5-chat", "anthropic/claude-4-sonnet-20250514", "gemini/gemini-2.5-pro"]
-    for model in models_to_test:
-        llm = load_chat_model(model)
-        logger.info(llm.invoke("Hi!"))

universal_mcp/agents/planner/__init__.py

@@ -1,37 +0,0 @@
-from langgraph.checkpoint.base import BaseCheckpointSaver
-
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.llm import load_chat_model
-from universal_mcp.agents.react import ReactAgent
-from universal_mcp.tools.registry import ToolRegistry
-
-from .graph import build_graph
-
-
-class PlannerAgent(BaseAgent):
-    def __init__(
-        self,
-        name: str,
-        instructions: str,
-        model: str,
-        registry: ToolRegistry,
-        memory: BaseCheckpointSaver | None = None,
-        executor_agent_cls: type[BaseAgent] = ReactAgent,
-        **kwargs,
-    ):
-        super().__init__(name, instructions, model, memory, **kwargs)
-        self.app_registry = registry
-        self.llm = load_chat_model(model)
-        self.executor_agent_cls = executor_agent_cls
-
-    async def _build_graph(self):
-        return build_graph(self.llm, self.app_registry, self.instructions, self.model, self.executor_agent_cls).compile(
-            checkpointer=self.memory
-        )
-
-    @property
-    def graph(self):
-        return self._graph
-
-
-__all__ = ["PlannerAgent"]

universal_mcp/agents/planner/__main__.py

@@ -1,24 +0,0 @@
-import asyncio
-
-from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.agents.planner import PlannerAgent
-
-
-async def main():
-    registry = AgentrRegistry()
-    agent = PlannerAgent(
-        name="planner-agent",
-        instructions="You are a helpful assistant.",
-        model="gemini/gemini-2.5-flash",
-        registry=registry,
-    )
-    from rich.console import Console
-
-    console = Console()
-    console.print("Starting agent...", style="yellow")
-    async for event in agent.stream(user_input="Send an email to manoj@agentr.dev'", thread_id="xyz"):
-        console.print(event.content, style="red")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

universal_mcp/agents/planner/graph.py

@@ -1,82 +0,0 @@
-from typing import Any
-
-from langchain_core.messages import AIMessage
-from langgraph.graph import END, START, StateGraph
-from loguru import logger
-
-from universal_mcp.agents.shared.tool_node import build_tool_node_graph
-from universal_mcp.types import AgentrToolConfig, ToolConfig
-
-from .state import State
-
-
-def build_graph(llm, registry, instructions, model, executor_agent_cls):
-    """Build the graph for the planner agent."""
-    graph_builder = StateGraph(State)
-
-    async def _tool_finder_node(state: State) -> dict[str, Any]:
-        """Runs the tool finder subgraph to identify necessary tools."""
-        task = state["messages"][-1].content
-        logger.info(f"Running tool finder for task: {task}")
-        tool_finder_graph = build_tool_node_graph(llm, registry)
-        tool_finder_state = await tool_finder_graph.ainvoke({"task": task, "messages": state["messages"]})
-
-        if not tool_finder_state.get("apps_required"):
-            logger.info("Tool finder determined no apps are required.")
-            return {"apps_with_tools": AgentrToolConfig(agentrServers={})}
-
-        apps_with_tools = tool_finder_state.get("apps_with_tools", AgentrToolConfig(agentrServers={}))
-        logger.info(f"Tool finder identified apps and tools: {apps_with_tools}")
-        return {"apps_with_tools": apps_with_tools, "task": task}
-
-    def _should_continue(state: State) -> str:
-        """Determines whether to continue to the executor or end."""
-        if state.get("apps_with_tools") and state["apps_with_tools"].agentrServers:
-            return "continue"
-        return "end"
-
-    async def _executor_node(state: State) -> dict[str, Any]:
-        """Executes the task with the identified tools."""
-        tool_config = state["apps_with_tools"]
-
-        logger.info(f"Preparing executor with tools: {tool_config}")
-        agent = executor_agent_cls(
-            name="executor-agent",
-            instructions=instructions,
-            model=model,
-            registry=registry,
-            tools=ToolConfig(agentrServers=tool_config.agentrServers),
-        )
-
-        await agent.ainit()
-        react_graph = agent._graph
-        logger.info("Invoking executor agent with tools.")
-        # We invoke the agent to make it run the tool
-        response = await react_graph.ainvoke({"messages": state["messages"]})
-
-        final_message = AIMessage(content=response["messages"][-1].content)
-        return {"messages": [final_message]}
-
-    async def _no_tools_node(state: State) -> dict[str, Any]:
-        """Handles tasks that don't require tools by invoking the LLM directly."""
-        logger.info("No tools required. Invoking LLM directly.")
-        response = await llm.ainvoke(state["messages"])
-        return {"messages": [response]}
-
-    graph_builder.add_node("tool_finder", _tool_finder_node)
-    graph_builder.add_node("executor", _executor_node)
-    graph_builder.add_node("no_tools_executor", _no_tools_node)
-
-    graph_builder.add_edge(START, "tool_finder")
-    graph_builder.add_conditional_edges(
-        "tool_finder",
-        _should_continue,
-        {
-            "continue": "executor",
-            "end": "no_tools_executor",
-        },
-    )
-    graph_builder.add_edge("executor", END)
-    graph_builder.add_edge("no_tools_executor", END)
-
-    return graph_builder

universal_mcp/agents/planner/prompts.py

@@ -1 +0,0 @@
-# Prompts for the planner agent

universal_mcp/agents/planner/state.py

@@ -1,12 +0,0 @@
-from typing import Annotated
-
-from langgraph.graph.message import add_messages
-from typing_extensions import TypedDict
-
-from universal_mcp.types import AgentrToolConfig
-
-
-class State(TypedDict):
-    messages: Annotated[list, add_messages]
-    task: str
-    apps_with_tools: AgentrToolConfig

universal_mcp/agents/react.py

@@ -1,84 +0,0 @@
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.prebuilt import create_react_agent
-from loguru import logger
-
-from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.llm import load_chat_model
-from universal_mcp.agents.tools import load_mcp_tools
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolConfig, ToolFormat
-
-
-class ReactAgent(BaseAgent):
-    def __init__(
-        self,
-        name: str,
-        instructions: str,
-        model: str,
-        memory: BaseCheckpointSaver | None = None,
-        tools: ToolConfig | None = None,
-        registry: ToolRegistry | None = None,
-        max_iterations: int = 10,
-        **kwargs,
-    ):
-        super().__init__(name, instructions, model, memory, **kwargs)
-        self.llm = load_chat_model(model)
-        self.tools = tools
-        self.max_iterations = max_iterations
-        self.registry = registry
-
-    async def _build_graph(self):
-        if self.tools:
-            config = self.tools.model_dump(exclude_none=True)
-            if config.get("agentrServers") and not self.registry:
-                raise ValueError("Agentr servers are configured but no registry is provided")
-            agentr_tools = (
-                await self.registry.export_tools(self.tools, ToolFormat.LANGCHAIN)
-                if config.get("agentrServers")
-                else []
-            )
-            logger.debug(agentr_tools)
-            mcp_tools = await load_mcp_tools(config["mcpServers"]) if config.get("mcpServers") else []
-            logger.debug(mcp_tools)
-            tools = agentr_tools + mcp_tools
-        else:
-            tools = []
-        logger.debug(f"Initialized ReactAgent: name={self.name}, model={self.model}")
-        return create_react_agent(
-            self.llm,
-            tools,
-            prompt=self._build_system_message(),
-            checkpointer=self.memory,
-        )
-
-    def _build_system_message(self) -> str:
-        system_message = f"""You are {self.name}.
-
-You have access to various tools that can help you answer questions and complete tasks. When you need to use a tool:
-
-1. Think about what information you need
-2. Call the appropriate tool with the right parameters
-3. Use the tool results to provide a comprehensive answer
-
-Always explain your reasoning and be thorough in your responses. If you need to use multiple tools to answer a question completely, do so.
-
-{self.instructions}
-"""
-        return system_message
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    agent = ReactAgent(
-        "Universal React Agent",
-        instructions="",
-        model="azure/gpt-4o",
-        tools=ToolConfig(agentrServers={"google-mail": {"tools": ["send_email"]}}),
-        registry=AgentrRegistry(),
-    )
-    result = asyncio.run(
-        agent.invoke(user_input="Send an email with the subject 'testing react agent' to manoj@agentr.dev")
-    )
-    logger.info(result["messages"][-1].content)

universal_mcp/agents/shared/agent_node.py

@@ -1,34 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class Agent(BaseModel):
-    name: str = Field(description="The name of the agent")
-    description: str = Field(description="A small paragraph description of the agent")
-    expertise: str = Field(description="Agents expertise. Growth expert, SEO expert, etc")
-    instructions: str = Field(description="The instructions for the agent")
-    schedule: str = Field(
-        description="The schedule for the agent in crontab syntax (e.g., '0 9 * * *' for daily at 9 AM)"
-    )
-
-
-AGENT_PROMPT = """You are an AI assistant that creates autonomous agents based on user requests.
-
-Your task is to analyze the user's request and create a structured agent definition that includes:
-- A clear name for the agent
-- A concise description of what the agent does
-- The agent's area of expertise
-- Detailed instructions for executing the task
-- A cron schedule for when the agent should run
-- A list of apps/services the agent will need to use
-
-Be specific and actionable in your agent definitions. Consider the user's intent and create agents that can effectively accomplish their goals.
-
-<query>
-{query}
-</query>
-"""
-
-
-async def generate_agent(llm, query):
-    response = await llm.with_structured_output(Agent).ainvoke(input=AGENT_PROMPT.format(query=query))
-    return response

universal_mcp/agents/shared/tool_node.py

@@ -1,235 +0,0 @@
-# tool_node.py
-
-import asyncio
-from typing import Annotated, TypedDict
-
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import AIMessage, AnyMessage, HumanMessage
-from langgraph.graph import END, StateGraph
-from langgraph.graph.message import add_messages
-from loguru import logger
-from pydantic import BaseModel, Field
-
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import AgentrConnection, AgentrToolConfig
-
-# --- LangGraph Agent ---
-
-
-class AgentState(TypedDict):
-    task: str
-    apps_required: bool
-    relevant_apps: list[str]
-    apps_with_tools: AgentrToolConfig
-    messages: Annotated[list[AnyMessage], add_messages]
-    reasoning: str
-
-
-class ToolSelectionOutput(BaseModel):
-    tool_ids: list[str] = Field(description="The ids of the tools to use")
-
-
-def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGraph:
-    """Builds the LangGraph workflow."""
-
-    async def _check_if_app_needed(state: AgentState) -> AgentState:
-        """Checks if an external application is needed for the given task."""
-        task = state["task"]
-        prompt = f"""
-            Given the user's task: "{task}"
-            Does this task require an external application to be completed?
-            Your answer should be a simple "Yes" or "No", followed by a brief explanation.
-            For example:
-            Yes, an external application is needed to send emails.
-            No, this is a general question that can be answered directly.
-            """
-        response = await llm.ainvoke(prompt)
-        content = response.content.strip()
-        reasoning = f"Initial check for app requirement. LLM response: {content}"
-
-        if content.lower().startswith("yes"):
-            return {
-                **state,
-                "messages": [AIMessage(content=content)],
-                "apps_required": True,
-                "reasoning": reasoning,
-            }
-        else:
-            return {
-                **state,
-                "messages": [AIMessage(content=content)],
-                "apps_required": False,
-                "reasoning": reasoning,
-            }
-
-    async def _find_relevant_apps(state: AgentState) -> AgentState:
-        """Identifies relevant apps for the given task, preferring connected apps."""
-        task = state["task"]
-        all_apps = await registry.list_all_apps()
-        connected_apps = await registry.list_connected_apps()
-        prompt = """
-You are an expert at identifying which applications are needed to complete specific tasks.
-
-TASK: "{task}"
-
-AVAILABLE APPS:
-{all_apps}
-
-CONNECTED APPS (user has already authenticated these):
-{connected_apps}
-
-INSTRUCTIONS:
-1. Analyze the task carefully to understand what functionality is required.
-2. Review the available apps and their descriptions to identify which ones could help.
-3. If multiple apps can perform the task, prefer connected apps, but you MUST include all relevant apps.
-4. Consider apps that provide complementary functionality for complex tasks.
-5. Only suggest apps that are directly relevant to the core task requirements.
-6. Your output should be a list of app IDs.
-
-"""
-
-        class AppList(BaseModel):
-            app_list: list[str]
-            reasoning: str
-
-        response = await llm.with_structured_output(AppList).ainvoke(
-            input=prompt.format(task=task, all_apps=all_apps, connected_apps=connected_apps)
-        )
-        app_list = response.app_list
-        reasoning = f"Found relevant apps: {app_list}. Reasoning: {response.reasoning}"
-        logger.info(f"Found relevant apps: {app_list}.")
-
-        return {
-            **state,
-            "messages": [AIMessage(content=f"Identified relevant apps: {', '.join(app_list)}")],
-            "relevant_apps": app_list,
-            "reasoning": state.get("reasoning", "") + "\n" + reasoning,
-        }
-
-    async def _select_tools(task: str, tools: list[dict]) -> list[str]:
-        """Selects the most appropriate tools from a list for a given task."""
-        tool_candidates = [f"{tool['name']}: {tool['description']}" for tool in tools]
-
-        SELECT_TOOL_PROMPT = f"""You are an AI assistant that helps the user perform tasks using various apps (each app has multiple tools).
-You will be provided with a task and a list of tools which might be relevant for this task.
-
-Your goal is to select the most appropriate tool for the given task.
-<task>
-{task}
-</task>
-
-<tool_candidates>
- - {tool_candidates}
-</tool_candidates>
-
-Only return tool ids.
-"""
-
-        response = await llm.with_structured_output(schema=ToolSelectionOutput).ainvoke(input=SELECT_TOOL_PROMPT)
-
-        selected_tool_ids = response.tool_ids
-        return selected_tool_ids
-
-    async def _generate_search_query(task: str) -> str:
-        """Generates a concise search query from the user's task."""
-        prompt = f"""
-You are an expert at summarizing a user's task into a concise search query for finding relevant tools.
-The query should capture all the main actions or intents of the task.
-
-For example:
-Task: "Send an email to abc@the-read-example.com with the subject 'Hello'"
-Query: "send email"
-
-Task: "Create a new contact in my CRM for John Doe"
-Query: "create contact"
-
-Task: "Find the latest news about artificial intelligence"
-Query: "search news"
-
-Task: "Post a message to the #general channel in Slack and create a new issue in Jira"
-Query: "send message, create issue"
-
-Task: "{task}"
-"""
-
-        class SearchQuery(BaseModel):
-            query: str
-
-        response = await llm.with_structured_output(SearchQuery).ainvoke(input=prompt.format(task=task))
-        query = response.query
-        logger.info(f"Generated search query '{query}' for task '{task}'")
-        return query
-
-    async def _search_tools(state: AgentState) -> AgentState:
-        """Searches for and filters tools in the relevant apps."""
-        task = state["task"]
-        logger.info(f"Searching for tools in relevant apps for task: {task}")
-        search_query = await _generate_search_query(task)
-        apps_with_tools_dict = {}
-        reasoning_steps = []
-        for app_name in state["relevant_apps"]:
-            logger.info(f"Searching for tools in {app_name} for task: {task} with query '{search_query}'")
-            found_tools = await registry.search_tools(query=search_query, app_id=app_name)
-            selected_tools = await _select_tools(task, found_tools)
-            apps_with_tools_dict[app_name] = selected_tools
-            reasoning_steps.append(f"For '{app_name}', selected tool(s): {', '.join(selected_tools)}.")
-
-        agentr_servers = {app_name: AgentrConnection(tools=tools) for app_name, tools in apps_with_tools_dict.items()}
-        tool_config = AgentrToolConfig(agentrServers=agentr_servers)
-
-        return {
-            **state,
-            "apps_with_tools": tool_config,
-            "reasoning": state.get("reasoning", "") + "\n" + "\n".join(reasoning_steps),
-        }
-
-    def _handle_no_apps_found(state: AgentState) -> AgentState:
-        """Handles the case where no relevant apps are found."""
-        reasoning = "No suitable application was found among the available apps."
-        return {
-            **state,
-            "apps_with_tools": AgentrToolConfig(agentrServers={}),
-            "reasoning": state.get("reasoning", "") + "\n" + reasoning,
-        }
-
-    workflow = StateGraph(AgentState)
-
-    workflow.add_node("check_if_app_needed", _check_if_app_needed)
-    workflow.add_node("find_relevant_apps", _find_relevant_apps)
-    workflow.add_node("search_tools", _search_tools)
-    workflow.add_node("handle_no_apps_found", _handle_no_apps_found)
-
-    workflow.set_entry_point("check_if_app_needed")
-
-    workflow.add_conditional_edges(
-        "check_if_app_needed",
-        lambda state: "find_relevant_apps" if state["apps_required"] else END,
-    )
-    workflow.add_conditional_edges(
-        "find_relevant_apps",
-        lambda state: "search_tools" if state["relevant_apps"] else "handle_no_apps_found",
-    )
-
-    workflow.add_edge("search_tools", END)
-    workflow.add_edge("handle_no_apps_found", END)
-
-    return workflow.compile()
-
-
-async def main():
-    from universal_mcp.agentr.registry import AgentrRegistry
-    from universal_mcp.agents.llm import load_chat_model
-
-    registry = AgentrRegistry()
-    llm = load_chat_model("gemini/gemini-2.5-flash")
-    graph = build_tool_node_graph(llm, registry)
-    initial_state = {
-        "task": "Send an email to manoj@agentr.dev",
-        "messages": [HumanMessage(content="Send an email to manoj@agentr.dev")],
-    }
-    result = await graph.ainvoke(initial_state)
-    print(result)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())