universal-mcp 0.1.24rc11__py3-none-any.whl → 0.1.24rc13__py3-none-any.whl

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,82 @@
+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

@@ -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 AgentrToolConfig
+
+
+class State(TypedDict):
+    messages: Annotated[list, add_messages]
+    task: str
+    apps_with_tools: AgentrToolConfig

universal_mcp/agents/shared/agent_node.py

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

@@ -0,0 +1,235 @@
+# 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())

universal_mcp/tools/registry.py

@@ -81,3 +81,8 @@ class ToolRegistry(ABC):
     async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> dict[str, Any]:
         """Call a tool with the given name and arguments."""
         pass
+
+    @abstractmethod
+    async def list_connected_apps(self) -> list[str]:
+        """List all apps that the user has connected."""
+        pass

universal_mcp/types.py

@@ -30,6 +30,9 @@ class MCPConnection(BaseModel):
     headers: dict[str, str] | None = None
 
 
-class ToolConfig(BaseModel):
-    mcpServers: dict[str, MCPConnection] | None = None
+class AgentrToolConfig(BaseModel):
     agentrServers: dict[str, AgentrConnection] | None = None
+
+
+class ToolConfig(AgentrToolConfig):
+    mcpServers: dict[str, MCPConnection] | None = None

{universal_mcp-0.1.24rc11.dist-info → universal_mcp-0.1.24rc13.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc11
+Version: 0.1.24rc13
 Summary: Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more.
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 License: MIT
 License-File: LICENSE
 Requires-Python: >=3.11
+Requires-Dist: agentevals>=0.0.9
 Requires-Dist: black>=25.1.0
 Requires-Dist: cookiecutter>=2.6.0
 Requires-Dist: gql>=4.0.0
@@ -14,6 +15,7 @@ Requires-Dist: jinja2>=3.1.3
 Requires-Dist: jsonref>=1.1.0
 Requires-Dist: keyring>=25.6.0
 Requires-Dist: langchain-anthropic>=0.3.19
+Requires-Dist: langchain-google-genai>=2.1.10
 Requires-Dist: langchain-google-vertexai>=2.0.28
 Requires-Dist: langchain-mcp-adapters>=0.1.9
 Requires-Dist: langchain-openai>=0.3.27
@@ -22,6 +24,7 @@ Requires-Dist: langgraph>=0.5.2
 Requires-Dist: langsmith>=0.4.5
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mcp>=1.10.0
+Requires-Dist: openevals>=0.1.0
 Requires-Dist: posthog>=3.24.0
 Requires-Dist: pydantic-settings>=2.8.1
 Requires-Dist: pydantic>=2.11.1

{universal_mcp-0.1.24rc11.dist-info → universal_mcp-0.1.24rc13.dist-info}/RECORD

@@ -5,35 +5,48 @@ universal_mcp/config.py,sha256=lOlDAgQMT7f6VymmsuCP9sYLlxGKj0hDF3hFcJ2nzS4,8135
 universal_mcp/exceptions.py,sha256=Uen8UFgLHGlSwXgRUyF-nhqTwdiBuL3okgBVRV2AgtA,2150
 universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
 universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-universal_mcp/types.py,sha256=jeUEkUnwdGWo3T_qSRSF83u0fYpuydaWzdKlCYBlCQA,770
+universal_mcp/types.py,sha256=zSKtth1Q9jR4_hrKZ6k9-9LYeM9zzPAvY3KJ6kYqFCM,814
 universal_mcp/agentr/README.md,sha256=t15pVgkCwZM5wzgLgrf0Zv6hVL7dPmKXvAeTf8CiXPQ,6641
 universal_mcp/agentr/__init__.py,sha256=fv1ZnOCduIUiJ9oN4e6Ya_hA2oWQvcEuDU3Ek1vEufI,180
 universal_mcp/agentr/client.py,sha256=TQgwrNc7dEMXuprELf0Q-fdYdrH92Ppd7PUDZoD-KcY,7429
 universal_mcp/agentr/integration.py,sha256=V5GjqocqS02tRoI8MeV9PL6m-BzejwBzgJhOHo4MxAE,4212
-universal_mcp/agentr/registry.py,sha256=GOCltEqVegBca_r-8ljxQqEJnNAlx3MF0DAw-cAUhbQ,6595
+universal_mcp/agentr/registry.py,sha256=rC9n4t55Y9a6NLFtioYOECRp6l2YxlOYc1Pmvdqh2GE,6927
 universal_mcp/agentr/server.py,sha256=bIPmHMiKKwnUYnxmfZVRh1thcn7Rytm_-bNiXTfANzc,2098
-universal_mcp/agents/__init__.py,sha256=AMBDQs3p5PePjzdoHYNoPYEsUK_PLHGNVPGxK7yrKVo,270
-universal_mcp/agents/auto.py,sha256=zQHtWTL0L88j9zFN44xHbGhKzYZ_TEuzHMTVc0TzTRU,25433
-universal_mcp/agents/base.py,sha256=Ta9fOw-ncP4S2j2lXeQzYNPBaWbThcEC_PvJwjzaHzE,5307
+universal_mcp/agents/__init__.py,sha256=zsYE7BuL4Q4p0JYrcljqxlMWoJ4F-BBn8lD2BJjfTqk,480
+universal_mcp/agents/base.py,sha256=zNYbzV1KY0OM-lDvLBMpdDpueKc6Wy54kbuzjFmBa5w,5170
+universal_mcp/agents/builder.py,sha256=XsPmGHQxAL9Mzs-8NHnnh2Ix8-vdcNdNm-EFwgNVK3A,2993
 universal_mcp/agents/cli.py,sha256=7GdRBpu9rhZPiC2vaNQXWI7K-0yCnvdlmE0IFpvy2Gk,539
 universal_mcp/agents/hil.py,sha256=6xi0hhK5g-rhCrAMcGbjcKMReLWPC8rnFZMBOF3N_cY,3687
-universal_mcp/agents/llm.py,sha256=GncfbrM7FbMQJ305jCq78PVN4Jh4hOBskLcdgBd69sY,1419
+universal_mcp/agents/llm.py,sha256=1R8gMh1atZuUe99jUlxA0xLb62k3vCp1yHnqENHrLB0,1590
 universal_mcp/agents/react.py,sha256=bjTq1SzNUSeCCDMrrfXsUBu_F_mGzow_jRx5KrQ-HVg,3032
 universal_mcp/agents/simple.py,sha256=JL8TFyXlA1F4zcArgKhlqVIbLWXetwM05z4MPDJgFeI,1367
 universal_mcp/agents/tools.py,sha256=7Vdw0VZYxXVAzAYSpRKWHzVl9Ll6NOnVRlc4cTXguUQ,1335
 universal_mcp/agents/utils.py,sha256=7kwFpD0Rv6JqHG-LlNCVwSu_xRX-N119mUmiBroHJL4,4109
-universal_mcp/agents/autoagent/__init__.py,sha256=E_vMnFz8Z120qdqaKXPNP_--4Tes4jImen7m_iZvtVo,913
-universal_mcp/agents/autoagent/__main__.py,sha256=cnR5VuuTgcF4bE2XdpJGXVQtA7x_c5M1d-exAff4Mvw,651
+universal_mcp/agents/autoagent/__init__.py,sha256=RruAbcjyMTB-dIRkzFZYtQxrTpZetynBRYd1xD9noj8,836
+universal_mcp/agents/autoagent/__main__.py,sha256=HH5D5gSw6xirrSoj_0CCmQlVq_wfp--b6hZdiHGfXD8,654
 universal_mcp/agents/autoagent/context.py,sha256=RgjW1uCslucxYJpdmi4govd-0V1_9e6Y_kjWl3FpLrE,847
-universal_mcp/agents/autoagent/graph.py,sha256=IWJLV3PL-0dmPvDckrtjJkgO6Zgt47kRk8Yprnn52dY,6768
-universal_mcp/agents/autoagent/prompts.py,sha256=ptnXyOarigq96nVW-P1ceT2WRilKvh7NPfE_Cy0NTz4,719
+universal_mcp/agents/autoagent/graph.py,sha256=zQ8XDPELK5MbdMy5hy9rkJtgd71I1RdPlpbNkqvXtuM,6645
+universal_mcp/agents/autoagent/prompts.py,sha256=v-EwzZ_0XPuBNd_r8aWxmKMSQlZLTVBr0o-dmTQMN1w,892
 universal_mcp/agents/autoagent/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
 universal_mcp/agents/autoagent/studio.py,sha256=nfVRzPXwBjDORHA0wln2k3Nz-zQXNKgZMvgeqBvkdtM,644
 universal_mcp/agents/autoagent/utils.py,sha256=AFq-8scw_WlSZxDnTzxSNrOSiGYsIlqkqtQLDWf_rMU,431
+universal_mcp/agents/bigtool/__init__.py,sha256=gKSEOmOE5ZsIypxu1sUibzJ8acbk83DjApxE0Adawro,1853
+universal_mcp/agents/bigtool/__main__.py,sha256=_4HBqnlmdJwXOgeMITjBgaDHihED-aEgQmSXL9xcj0Y,602
+universal_mcp/agents/bigtool/context.py,sha256=KM_B-rvEulrvXSBrXAJpwxGHVMW0HgiYKMnmrL2pUEQ,688
+universal_mcp/agents/bigtool/graph.py,sha256=QqmJJbJeG8D2LBkKyO3LMIq-CXRRascPEhikK-tIZ3Y,8217
+universal_mcp/agents/bigtool/prompts.py,sha256=A6El6Qw9r_D8OD4IZKuYqvrJFJZZmUhrTKlyqFPf6c0,1666
+universal_mcp/agents/bigtool/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
 universal_mcp/agents/codeact/__init__.py,sha256=5D_I3lI_3tWjZERRoFav_bPe9UDaJ53pDzZYtyixg3E,10097
 universal_mcp/agents/codeact/sandbox.py,sha256=lGRzhuXTHCB1qauuOI3bH1-fPTsyL6Lf9EmMIz4C2xQ,1039
 universal_mcp/agents/codeact/test.py,sha256=AI3qWszpM46hF4wzuQm6A8g_UkhGmcg9KhHtk9u14ro,497
 universal_mcp/agents/codeact/utils.py,sha256=VuMvLTxBBh3pgaJk8RWj5AK8XZFF-1gnZJ6jFLeM_CI,1690
+universal_mcp/agents/planner/__init__.py,sha256=VTLVqIWkVh5SAuFoFupxByoqyNS1vCuc14mdUSr-vKE,1090
+universal_mcp/agents/planner/__main__.py,sha256=nAFabo6SVZh4_4GV-SWCpnGg5GsVXgiHYpm9mhCQ6zw,685
+universal_mcp/agents/planner/graph.py,sha256=Ct6cFJqXXf8pcYoVrlq-76uITemFfyX-mODBafmkjKA,3309
+universal_mcp/agents/planner/prompts.py,sha256=vLViZ4BeinqUe8gXACLl04UUnH-Hie5L2qDyhCmSNe0,32
+universal_mcp/agents/planner/state.py,sha256=m1QF99n4GswqoggYoYvv67pV2zW7HPkjwtfc2z783SE,291
+universal_mcp/agents/shared/agent_node.py,sha256=jXJ9MwysYk16tOwqvEtXBkcQhkK_PcPLnuXANTb9Z7g,1308
+universal_mcp/agents/shared/tool_node.py,sha256=Mmwiy3nUJKU1kXE1JfPdCCxtmbLoA-9pwLg4TbuacOs,8722
 universal_mcp/applications/__init__.py,sha256=HrCnGdAT7w4puw2_VulBfjOLku9D5DuMaOwAuQzu6nI,2067
 universal_mcp/applications/application.py,sha256=pGF9Rb2D6qzlaSwlcfZ-dNqPtsLkQTqL3jpsRuJ6-qE,23835
 universal_mcp/applications/sample/app.py,sha256=E0JwaWD7qytwawb_iWc1pBnJ-Te7MMtab4MxOOebLdc,8972
@@ -51,7 +64,7 @@ universal_mcp/tools/adapters.py,sha256=YJ2oqgc8JgmtsdRRtvO-PO0Q0bKqTJ4Y3J6yxlESo
 universal_mcp/tools/docstring_parser.py,sha256=efEOE-ME7G5Jbbzpn7pN2xNuyu2M5zfZ1Tqu1lRB0Gk,8392
 universal_mcp/tools/func_metadata.py,sha256=F4jd--hoZWKPBbZihVtluYKUsIdXdq4a0VWRgMl5k-Q,10838
 universal_mcp/tools/manager.py,sha256=U2-OQY4FGTDKS4IEOZTLVLcdqMC2vVghS0p_iLXX2Gc,10507
-universal_mcp/tools/registry.py,sha256=etluwUwf2EfiGBoqQFZ1nf2xcPWtrJn0N4Qhcg7UGCU,2440
+universal_mcp/tools/registry.py,sha256=LD0J_bPsd8PRTObyvXglqTW1jfZX98m7KBdyP8Yn7wA,2585
 universal_mcp/tools/tools.py,sha256=Lk-wUO3rfhwdxaRANtC7lQr5fXi7nclf0oHzxNAb79Q,4927
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
 universal_mcp/utils/common.py,sha256=3aJK3AnBkmYf-dbsFLaEu_dGuXQ0Qi2HuqYTueLVhXQ,10968
@@ -72,8 +85,8 @@ universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vH
 universal_mcp/utils/openapi/test_generator.py,sha256=vucBh9klWmQOUA740TFwfM9ry2nkwKWQiNRcsiZ9HbY,12229
 universal_mcp/utils/templates/README.md.j2,sha256=Mrm181YX-o_-WEfKs01Bi2RJy43rBiq2j6fTtbWgbTA,401
 universal_mcp/utils/templates/api_client.py.j2,sha256=972Im7LNUAq3yZTfwDcgivnb-b8u6_JLKWXwoIwXXXQ,908
-universal_mcp-0.1.24rc11.dist-info/METADATA,sha256=wptNoLSs4TFv7_nDGfXDIHpQSuFcNCcAMx_dRNUWra0,3144
-universal_mcp-0.1.24rc11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.24rc11.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.24rc11.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp-0.1.24rc11.dist-info/RECORD,,
+universal_mcp-0.1.24rc13.dist-info/METADATA,sha256=ecj6uZ7xysaWUjoTsuXrEHGygiKWSLdAGaY7Hne7bVg,3255
+universal_mcp-0.1.24rc13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.24rc13.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.24rc13.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.24rc13.dist-info/RECORD,,