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

universal_mcp/agents/shared/tool_node.py

@@ -0,0 +1,236 @@
+# 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 ToolConfig
+
+# --- LangGraph Agent ---
+
+
+class AgentState(TypedDict):
+    task: str
+    apps_required: bool
+    relevant_apps: list[str]
+    apps_with_tools: ToolConfig
+    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)
+        # Handle both string and list content types
+        if isinstance(response.content, list):
+            content = " ".join([str(item) for item in response.content]).strip()
+        else:
+            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)}.")
+
+        return {
+            **state,
+            "apps_with_tools": apps_with_tools_dict,
+            "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": {},
+            "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/agents/simple.py

@@ -0,0 +1,40 @@
+import asyncio
+from typing import Annotated
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.graph import END, START, StateGraph
+from langgraph.graph.message import add_messages
+from typing_extensions import TypedDict
+
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.llm import load_chat_model
+
+
+class State(TypedDict):
+    messages: Annotated[list, add_messages]
+
+
+class SimpleAgent(BaseAgent):
+    def __init__(self, name: str, instructions: str, model: str, memory: BaseCheckpointSaver = None, **kwargs):
+        super().__init__(name, instructions, model, memory, **kwargs)
+        self.llm = load_chat_model(model)
+
+    async def _build_graph(self):
+        graph_builder = StateGraph(State)
+
+        async def chatbot(state: State):
+            messages = [
+                {"role": "system", "content": self.instructions},
+                *state["messages"],
+            ]
+            return {"messages": [await self.llm.ainvoke(messages)]}
+
+        graph_builder.add_node("chatbot", chatbot)
+        graph_builder.add_edge(START, "chatbot")
+        graph_builder.add_edge("chatbot", END)
+        return graph_builder.compile(checkpointer=self.memory)
+
+
+if __name__ == "__main__":
+    agent = SimpleAgent("Simple Agent", "You are a helpful assistant", "azure/gpt-4o")
+    asyncio.run(agent.run_interactive())

universal_mcp/agents/tools.py

@@ -0,0 +1,35 @@
+import json
+
+from langchain_mcp_adapters.client import MultiServerMCPClient
+
+from universal_mcp.agentr.integration import AgentrIntegration
+from universal_mcp.applications.utils import app_from_slug
+from universal_mcp.tools.adapters import ToolFormat
+from universal_mcp.tools.manager import ToolManager
+from universal_mcp.types import ToolConfig
+
+
+async def load_agentr_tools(agentr_servers: dict):
+    tool_manager = ToolManager()
+    for app_name, tool_names in agentr_servers.items():
+        app = app_from_slug(app_name)
+        integration = AgentrIntegration(name=app_name)
+        app_instance = app(integration=integration)
+        tool_manager.register_tools_from_app(app_instance, tool_names=tool_names["tools"])
+    tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
+    return tools
+
+
+async def load_mcp_tools(mcp_servers: dict):
+    client = MultiServerMCPClient(mcp_servers)
+    tools = await client.get_tools()
+    return tools
+
+
+async def load_tools(path: str) -> ToolConfig:
+    with open(path) as f:
+        data = json.load(f)
+        config = ToolConfig.model_validate(data)
+        agentr_tools = await load_agentr_tools(config.model_dump(exclude_none=True)["agentrServers"])
+        mcp_tools = await load_mcp_tools(config.model_dump(exclude_none=True)["mcpServers"])
+        return agentr_tools + mcp_tools

universal_mcp/agents/utils.py

@@ -0,0 +1,111 @@
+import json
+from contextlib import contextmanager
+
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+
+
+class RichCLI:
+    def __init__(self):
+        self.console = Console()
+
+    def display_welcome(self, agent_name: str):
+        """Display welcome message"""
+        welcome_text = f"""
+# Welcome to {agent_name}!
+
+Available commands:
+- Type your questions naturally
+- `/help` - Show help
+- `/tools` - List available tools
+- `/exit` - Exit the application
+        """
+        self.console.print(Panel(Markdown(welcome_text), title="🤖 AI Agent CLI", border_style="blue"))
+
+    def display_agent_response(self, response: str, agent_name: str):
+        """Display agent response with formatting"""
+        self.console.print(Panel(Markdown(response), title=f"🤖 {agent_name}", border_style="green", padding=(1, 2)))
+
+    @contextmanager
+    def display_agent_response_streaming(self, agent_name: str):
+        """Context manager for streaming agent response updates."""
+
+        with Live(refresh_per_second=10, console=self.console) as live:
+
+            class StreamUpdater:
+                content = []
+
+                def update(self, chunk: str):
+                    self.content.append(chunk)
+                    panel = Panel(
+                        Markdown("".join(self.content)),
+                        title=f"🤖 {agent_name}",
+                        border_style="green",
+                        padding=(1, 2),
+                    )
+                    live.update(panel)
+
+            yield StreamUpdater()
+
+    def display_thinking(self, thought: str):
+        """Display agent's thinking process"""
+        if thought:
+            self.console.print(Panel(thought, title="💭 Thinking", border_style="yellow", padding=(1, 2)))
+
+    def display_tools(self, tools: list):
+        """Display available tools in a table"""
+        table = Table(title="🛠️ Available Tools")
+        table.add_column("Tool Name", style="cyan")
+        table.add_column("Description", style="white")
+
+        for tool in tools:
+            func_info = tool["function"]
+            table.add_row(func_info["name"], func_info["description"])
+
+        self.console.print(table)
+
+    def display_tool_call(self, tool_call: dict):
+        """Display tool call"""
+        tool_call_str = json.dumps(tool_call, indent=2)
+        self.console.print(Panel(tool_call_str, title="🛠️ Tool Call", border_style="green", padding=(1, 2)))
+
+    def display_tool_result(self, tool_result: dict):
+        """Display tool result"""
+        tool_result_str = json.dumps(tool_result, indent=2)
+        self.console.print(Panel(tool_result_str, title="🛠️ Tool Result", border_style="green", padding=(1, 2)))
+
+    def display_error(self, error: str):
+        """Display error message"""
+        self.console.print(Panel(error, title="❌ Error", border_style="red"))
+
+    def get_user_input(self) -> str:
+        """Get user input with rich prompt"""
+        return Prompt.ask("[bold blue]You[/bold blue]", console=self.console)
+
+    def display_info(self, message: str):
+        """Display info message"""
+        self.console.print(f"[bold cyan]ℹ️ {message}[/bold cyan]")
+
+    def clear_screen(self):
+        """Clear the screen"""
+        self.console.clear()
+
+    def handle_interrupt(self, interrupt) -> str | bool:
+        interrupt_type = interrupt.value["type"]
+        if interrupt_type == "text":
+            value = Prompt.ask(interrupt.value["question"])
+            return value
+        elif interrupt_type == "bool":
+            value = Prompt.ask(interrupt.value["question"], choices=["y", "n"], default="y")
+            return value
+        elif interrupt_type == "choice":
+            value = Prompt.ask(
+                interrupt.value["question"], choices=interrupt.value["choices"], default=interrupt.value["choices"][0]
+            )
+            return value
+        else:
+            raise ValueError(f"Invalid interrupt type: {interrupt.value['type']}")

universal_mcp_agents-0.1.2.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: universal-mcp-agents
+Version: 0.1.2
+Summary: Add your description here
+Project-URL: Homepage, https://github.com/universal-mcp/applications
+Project-URL: Repository, https://github.com/universal-mcp/applications
+Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
+License: MIT
+Requires-Python: >=3.13
+Requires-Dist: langchain-anthropic>=0.3.19
+Requires-Dist: langchain-google-genai>=2.1.10
+Requires-Dist: langchain-openai>=0.3.32
+Requires-Dist: langgraph>=0.6.6
+Requires-Dist: universal-mcp
+Requires-Dist: universal-mcp-applications>=0.1.2
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest<9.0.0,>=7.0.0; extra == 'test'

universal_mcp_agents-0.1.2.dist-info/RECORD

@@ -0,0 +1,51 @@
+universal_mcp/agents/__init__.py,sha256=s50fHbQ3ufC_7mwQydHoua4KJOjKjKcUrAgMN0A_34M,588
+universal_mcp/agents/base.py,sha256=zNYbzV1KY0OM-lDvLBMpdDpueKc6Wy54kbuzjFmBa5w,5170
+universal_mcp/agents/builder.py,sha256=duPULxwOEt6IFMK9n0yvaeOFW3Js50WucFi224BMwG8,5956
+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=P03zoUxBfivMa3djt2kmWANxGLg77Tapx1aQJEPVTCo,1592
+universal_mcp/agents/react.py,sha256=EVk59XVelBFV13us3CG-RolzRmu8v7FrhlR7m2QIYUY,2526
+universal_mcp/agents/simple.py,sha256=JL8TFyXlA1F4zcArgKhlqVIbLWXetwM05z4MPDJgFeI,1367
+universal_mcp/agents/tools.py,sha256=J8VdS1xnSEFeEVSmp5Hb47J2-4WJWtsIidUP1lFXhds,1341
+universal_mcp/agents/utils.py,sha256=7kwFpD0Rv6JqHG-LlNCVwSu_xRX-N119mUmiBroHJL4,4109
+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=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=fOr0p547kjpM_CkRyyEcDxmTZ5lEKaTAR98nRCkgsks,8284
+universal_mcp/agents/bigtool/prompts.py,sha256=A6El6Qw9r_D8OD4IZKuYqvrJFJZZmUhrTKlyqFPf6c0,1666
+universal_mcp/agents/bigtool/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
+universal_mcp/agents/bigtool2/__init__.py,sha256=uP52BOl0z1n_ECbybf6lxVvC0PAjNMrBUcXUOibXjvA,1779
+universal_mcp/agents/bigtool2/__main__.py,sha256=C4Mi8vM9kuGa_CryzIc9nL4-u73ZvSK5tOTbMDMN54I,605
+universal_mcp/agents/bigtool2/agent.py,sha256=iwn2kyC-Wft40f_QHlLtg7fPpFUpwkjk7I5LJrrS4i8,434
+universal_mcp/agents/bigtool2/context.py,sha256=1DMp8g4Gb6UUxVh8bcqafV2WpTGKo6GlaDN6Ey7cAbo,930
+universal_mcp/agents/bigtool2/graph.py,sha256=l6LBWmBCsjO0r1TZUXAQHXvz_iqkW_9tGJSlySkcG7A,8373
+universal_mcp/agents/bigtool2/prompts.py,sha256=Kn1sDrjH2xb3js_MPPu5PJHMP45unl93CdOC97Q_hzw,1652
+universal_mcp/agents/bigtool2/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
+universal_mcp/agents/bigtoolcache/__init__.py,sha256=dTPxrFIJGaJKb67a935UEkgqnBGdN9q1ba2HnpNAuq4,1792
+universal_mcp/agents/bigtoolcache/__main__.py,sha256=HkPEQqsdnWtDzWSbYdVBBc_JhpRi82TYuaubxNMtt4w,622
+universal_mcp/agents/bigtoolcache/agent.py,sha256=xLTymzsmpNpJf8-y1Mi8BbuWl09kXsk1sdhbJyVwASU,446
+universal_mcp/agents/bigtoolcache/context.py,sha256=1DMp8g4Gb6UUxVh8bcqafV2WpTGKo6GlaDN6Ey7cAbo,930
+universal_mcp/agents/bigtoolcache/graph.py,sha256=--CuUEc2IKGdKeMueEvsQ-GxCYZVlDclQdKhrf0ctvU,8418
+universal_mcp/agents/bigtoolcache/prompts.py,sha256=bIbuktsi0EkOXxYGkyB-e_rmolllrHo4kDsvWO5p_1c,1874
+universal_mcp/agents/bigtoolcache/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=Cj5Y1BI9uJvrYsr4JrQSPRSszznjdVD2dJHWHHJhxp0,3101
+universal_mcp/agents/planner/prompts.py,sha256=vLViZ4BeinqUe8gXACLl04UUnH-Hie5L2qDyhCmSNe0,32
+universal_mcp/agents/planner/state.py,sha256=EdrIELvxzBZtdC1FpmErYnCC7OSJ3Irx9QGiCBCeomA,279
+universal_mcp/agents/shared/tool_node.py,sha256=IkjEcgzRAgjQTqcoa-i1dDY2LJfgOGj9HF8vihYuk_s,8678
+universal_mcp_agents-0.1.2.dist-info/METADATA,sha256=yLpsTnGK6izBne_twuT9ED4M_CYhD4XBzNR3_E8WBjQ,781
+universal_mcp_agents-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.2.dist-info/RECORD,,

universal_mcp_agents-0.1.2.dist-info/WHEEL

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