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

universal_mcp/agents/codeact/__init__.py

@@ -1,243 +0,0 @@
-import inspect
-import re
-from collections.abc import Awaitable, Callable, Sequence
-from typing import Any, TypeVar
-
-from langchain_core.language_models import BaseChatModel
-from langchain_core.tools import StructuredTool
-from langchain_core.tools import tool as create_tool
-from langgraph.graph import END, START, MessagesState, StateGraph
-from langgraph.types import Command
-
-from .utils import extract_and_combine_codeblocks
-
-EvalFunction = Callable[[str, dict[str, Any]], tuple[str, dict[str, Any]]]
-EvalCoroutine = Callable[[str, dict[str, Any]], Awaitable[tuple[str, dict[str, Any]]]]
-
-
-class CodeActState(MessagesState):
-    """State for CodeAct agent."""
-
-    script: str | None
-    """The Python code script to be executed."""
-    context: dict[str, Any]
-    """Dictionary containing the execution context with available tools and variables."""
-
-
-StateSchema = TypeVar("StateSchema", bound=CodeActState)
-StateSchemaType = type[StateSchema]
-
-
-def make_safe_function_name(name: str) -> str:
-    """Convert a tool name to a valid Python function name."""
-    # Replace non-alphanumeric characters with underscores
-    safe_name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
-    # Ensure the name doesn't start with a digit
-    if safe_name and safe_name[0].isdigit():
-        safe_name = f"tool_{safe_name}"
-    # Handle empty name edge case
-    if not safe_name:
-        safe_name = "unnamed_tool"
-    return safe_name
-
-
-def create_default_prompt(tools: list[StructuredTool], base_prompt: str | None = None):
-    """Create default prompt for the CodeAct agent."""
-    tools = [t if isinstance(t, StructuredTool) else create_tool(t) for t in tools]
-    prompt = f"{base_prompt}\n\n" if base_prompt else ""
-    prompt += """You will be given a task to perform. You should output either
-- a Python code snippet that provides the solution to the task, or a step towards the solution. Any output you want to extract from the code should be printed to the console. Code should be output in a fenced code block.
-- text to be shown directly to the user, if you want to ask for more information or provide the final answer.
-
-In addition to the Python Standard Library, you can use the following functions:
-"""
-
-    for tool in tools:
-        # Use coroutine if it exists, otherwise use func
-        tool_callable = tool.coroutine if hasattr(tool, "coroutine") and tool.coroutine is not None else tool.func
-        # Create a safe function name
-        safe_name = make_safe_function_name(tool.name)
-        # Determine if it's an async function
-        is_async = inspect.iscoroutinefunction(tool_callable)
-        # Add appropriate function definition
-        prompt += f'''
-{"async " if is_async else ""}def {safe_name}{str(inspect.signature(tool_callable))}:
-    """{tool.description}"""
-    ...
-'''
-
-    prompt += """
-
-Variables defined at the top level of previous code snippets can be referenced in your code.
-
-Reminder: use Python code snippets to call tools"""
-    return prompt
-
-
-def create_codeact(
-    model: BaseChatModel,
-    tools: Sequence[StructuredTool | Callable],
-    eval_fn: EvalFunction | EvalCoroutine,
-    *,
-    prompt: str | None = None,
-    reflection_prompt: str | None = None,
-    reflection_model: BaseChatModel | None = None,
-    max_reflections: int = 3,
-    state_schema: StateSchemaType = CodeActState,
-) -> StateGraph:
-    """Create a CodeAct agent.
-
-    Args:
-        model: The language model to use for generating code
-        tools: List of tools available to the agent. Can be passed as python functions or StructuredTool instances.
-        eval_fn: Function or coroutine that executes code in a sandbox. Takes code string and locals dict,
-            returns a tuple of (stdout output, new variables dict)
-        prompt: Optional custom system prompt. If None, uses default prompt.
-            To customize default prompt you can use `create_default_prompt` helper:
-            `create_default_prompt(tools, "You are a helpful assistant.")`
-        reflection_prompt: Optional prompt for reflection. If provided, will be used to evaluate responses.
-            If the reflection output contains "NONE", the response is considered valid, otherwise the
-            reflection output is passed back to the model for regeneration.
-        reflection_model: Optional model to use for reflection. If None, uses the same model as for generation.
-        max_reflections: Maximum number of reflection iterations (default: 3).
-        state_schema: The state schema to use for the agent.
-
-    Returns:
-        A StateGraph implementing the CodeAct architecture
-    """
-    tools = [t if isinstance(t, StructuredTool) else create_tool(t) for t in tools]
-
-    if prompt is None:
-        prompt = create_default_prompt(tools)
-
-    # If no reflection model is provided, use the main model
-    if reflection_model is None:
-        reflection_model = model
-
-    # Make tools available to the code sandbox - use safe names for keys
-    tools_context = {}
-    for tool in tools:
-        safe_name = make_safe_function_name(tool.name)
-        # Use coroutine if it exists, otherwise use func (same as in create_default_prompt)
-        tool_callable = tool.coroutine if hasattr(tool, "coroutine") and tool.coroutine is not None else tool.func
-        # Only use the safe name for consistency with the prompt
-        tools_context[safe_name] = tool_callable
-
-    def call_model(state: StateSchema) -> Command:
-        messages = [{"role": "system", "content": prompt}] + state["messages"]
-
-        # Run the model and potentially loop for reflection
-        response = model.invoke(messages)
-
-        # Extract and combine all code blocks
-        code = extract_and_combine_codeblocks(response.content)
-
-        # Loop for reflection if needed and if code is present
-        if reflection_prompt and code:
-            reflection_count = 0
-            while reflection_count < max_reflections:
-                # Format conversation history with XML-style tags
-                conversation_history = "\n".join(
-                    [
-                        f'<message role="{("user" if m.type == "human" else "assistant")}">\n{m.content}\n</message>'
-                        for m in state["messages"]
-                    ]
-                )
-
-                # Add the current response
-                conversation_history += f'\n<message role="assistant">\n{response.content}\n</message>'
-
-                # Create the reflection prompt with the tagged conversation history
-                formatted_prompt = f"""
-Review the assistant's latest code for as per the quality rules:
-
-<conversation_history>
-{conversation_history}
-</conversation_history>
-
-If you find ANY of these issues, describe the problem briefly and clearly.
-If NO issues are found, respond with EXACTLY: "NONE"
-"""
-
-                # Create messages for reflection with correct ordering
-                reflection_messages = [
-                    {"role": "system", "content": reflection_prompt},
-                    # Include the formatted reflection prompt as the final user message
-                    {"role": "user", "content": formatted_prompt},
-                ]
-                reflection_result = reflection_model.invoke(reflection_messages)
-
-                # Check if reflection passed
-                if "NONE" in reflection_result.content:
-                    # Reflection passed, exit loop
-                    break
-
-                # Reflection didn't pass, regenerate response
-                reflection_messages = [
-                    {"role": "system", "content": prompt},
-                    *state["messages"],
-                    {"role": "assistant", "content": response.content},
-                    {
-                        "role": "user",
-                        "content": f"""
-I need you to completely regenerate your previous response based on this feedback:
-
-'''
-{reflection_result.content}
-'''
-
-DO NOT reference the feedback directly. Instead, provide a completely new response that addresses the issues.
-""",
-                    },
-                ]
-                response = model.invoke(reflection_messages)
-
-                # Extract code from the new response
-                code = extract_and_combine_codeblocks(response.content)
-
-                # If no code in the new response, exit the reflection loop
-                if not code:
-                    break
-
-                # Increment reflection count
-                reflection_count += 1
-
-        # Return appropriate command with only the latest response
-        if code:
-            return Command(goto="sandbox", update={"messages": [response], "script": code})
-        else:
-            # no code block, end the loop and respond to the user
-            return Command(update={"messages": [response], "script": None})
-
-    # If eval_fn is a async, we define async node function.
-    if inspect.iscoroutinefunction(eval_fn):
-
-        async def sandbox(state: StateSchema):
-            existing_context = state.get("context", {})
-            context = {**existing_context, **tools_context}
-            # Execute the script in the sandbox
-            output, new_vars = await eval_fn(state["script"], context)
-            new_context = {**existing_context, **new_vars}
-            return {
-                "messages": [{"role": "user", "content": output}],
-                "context": new_context,
-            }
-    else:
-
-        def sandbox(state: StateSchema):
-            existing_context = state.get("context", {})
-            context = {**existing_context, **tools_context}
-            # Execute the script in the sandbox
-            output, new_vars = eval_fn(state["script"], context)
-            new_context = {**existing_context, **new_vars}
-            return {
-                "messages": [{"role": "user", "content": output}],
-                "context": new_context,
-            }
-
-    agent = StateGraph(state_schema)
-    agent.add_node(call_model, destinations=(END, "sandbox"))
-    agent.add_node(sandbox)
-    agent.add_edge(START, "call_model")
-    agent.add_edge("sandbox", "call_model")
-    return agent

universal_mcp/agents/codeact/sandbox.py

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

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

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

@@ -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