universal-mcp-agents 0.1.2__py3-none-any.whl

universal_mcp/agents/codeact/sandbox.py

@@ -0,0 +1,27 @@
+import builtins
+import contextlib
+import io
+from typing import Any
+
+
+def eval_unsafe(code: str, _locals: dict[str, Any]) -> tuple[str, dict[str, Any]]:
+    # Store original keys before execution
+    original_keys = set(_locals.keys())
+    result = f"Executing code...\n{code}\n\nOutput:\n"
+    result += "=" * 50 + "\n"
+    try:
+        with contextlib.redirect_stdout(io.StringIO()) as f:
+            # Execute the code in the provided locals context
+            # Using exec to allow dynamic code execution
+            # This is a simplified version; in production, consider security implications
+            exec(code, builtins.__dict__, _locals)
+        result += f.getvalue()
+        if not result:
+            result = "<code ran, no output printed to stdout>"
+    except Exception as e:
+        result += f"Error during execution: {repr(e)}"
+
+    # Determine new variables created during execution
+    new_keys = set(_locals.keys()) - original_keys
+    new_vars = {key: _locals[key] for key in new_keys}
+    return result, new_vars

universal_mcp/agents/codeact/test.py

@@ -0,0 +1,15 @@
+from universal_mcp.agentr import Agentr
+from universal_mcp.agents.codeact import create_codeact
+from universal_mcp.agents.codeact.sandbox import eval_unsafe
+from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.tools.adapters import ToolFormat
+
+model = load_chat_model("gpt-4.1")
+
+agentr = Agentr()
+agentr.load_tools(["google-mail_send_email"])
+
+tools = agentr.list_tools(format=ToolFormat.NATIVE)
+
+code_act = create_codeact(model, tools, eval_unsafe)
+agent = code_act.compile()

universal_mcp/agents/codeact/utils.py

@@ -0,0 +1,61 @@
+import re
+
+BACKTICK_PATTERN = r"(?:^|\n)```(.*?)(?:```(?:\n|$))"
+
+
+def extract_and_combine_codeblocks(text: str) -> str:
+    """
+    Extracts all codeblocks from a text string and combines them into a single code string.
+
+    Args:
+        text: A string containing zero or more codeblocks, where each codeblock is
+            surrounded by triple backticks (```).
+
+    Returns:
+        A string containing the combined code from all codeblocks, with each codeblock
+        separated by a newline.
+
+    Example:
+        text = '''Here's some code:
+
+        ```python
+        print('hello')
+        ```
+        And more:
+
+        ```
+        print('world')
+        ```'''
+
+        result = extract_and_combine_codeblocks(text)
+
+        Result:
+
+        print('hello')
+
+        print('world')
+    """
+    # Find all code blocks in the text using regex
+    # Pattern matches anything between triple backticks, with or without a language identifier
+    code_blocks = re.findall(BACKTICK_PATTERN, text, re.DOTALL)
+
+    if not code_blocks:
+        return ""
+
+    # Process each codeblock
+    processed_blocks = []
+    for block in code_blocks:
+        # Strip leading and trailing whitespace
+        block = block.strip()
+
+        # If the first line looks like a language identifier, remove it
+        lines = block.split("\n")
+        if lines and (not lines[0].strip() or " " not in lines[0].strip()):
+            # First line is empty or likely a language identifier (no spaces)
+            block = "\n".join(lines[1:])
+
+        processed_blocks.append(block)
+
+    # Combine all codeblocks with newlines between them
+    combined_code = "\n\n".join(processed_blocks)
+    return combined_code

universal_mcp/agents/hil.py

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,81 @@
+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 .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": {}}
+
+        apps_with_tools = tool_finder_state.get("apps_with_tools", {})
+        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"):
+            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=tool_config,
+        )
+
+        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

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

universal_mcp/agents/planner/state.py

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

universal_mcp/agents/react.py

@@ -0,0 +1,76 @@
+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.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):
+        tools = []
+        if self.tools:
+            if not self.registry:
+                raise ValueError("Tools are configured but no registry is provided")
+
+            tools = await self.registry.export_tools(self.tools, ToolFormat.LANGCHAIN)
+            logger.debug(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):
+        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={"google-mail": ["send_email"]},
+        registry=AgentrRegistry(),
+    )
+    result = asyncio.run(agent.invoke("Send an email with the subject 'testing react agent' to manoj@agentr.dev"))
+    logger.info(result["messages"][-1].content)