universal-mcp-agents 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

universal_mcp/agents/bigtool2/graph.py

@@ -1,155 +0,0 @@
-import json
-from datetime import UTC, datetime
-from typing import Literal, cast
-
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import AIMessage, ToolMessage
-from langchain_core.tools import BaseTool
-from langgraph.graph import StateGraph
-from langgraph.types import Command
-from universal_mcp.logger import logger
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolFormat
-
-from universal_mcp.agents.bigtool2.meta_tools import create_meta_tools
-from universal_mcp.agents.bigtool2.state import State
-
-
-def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel, system_prompt: str, default_tools: list[BaseTool]):
-    # Instantiate meta tools (search, load, web_search)
-    search_tools, load_tools, web_search = create_meta_tools(tool_registry)
-
-    async def call_model(
-        state: State,
-    ) -> Command[Literal["select_tools", "call_tools"]]:
-        logger.info("Calling model...")
-        try:
-            system_message = system_prompt.format(system_time=datetime.now(tz=UTC).isoformat())
-            messages = [
-                {"role": "system", "content": system_message},
-                *state["messages"],
-            ]
-
-            logger.info(f"Selected tool IDs: {state['selected_tool_ids']}")
-            if len(state["selected_tool_ids"]) > 0:
-                selected_tools = await tool_registry.export_tools(
-                    tools=state["selected_tool_ids"], format=ToolFormat.LANGCHAIN
-                )
-                logger.info(f"Exported {len(selected_tools)} tools for model.")
-            else:
-                selected_tools = []
-
-            model = llm
-
-            tools = [search_tools, load_tools, web_search, *default_tools, *selected_tools]
-            # Remove duplicates based on tool name
-            seen_names = set()
-            unique_tools = []
-            for tool in tools:
-                if tool.name not in seen_names:
-                    seen_names.add(tool.name)
-                    unique_tools.append(tool)
-            tools = unique_tools
-            model_with_tools = model.bind_tools(
-                tools,
-                tool_choice="auto",
-            )
-            response = cast(AIMessage, await model_with_tools.ainvoke(messages))
-
-            if response.tool_calls:
-                logger.info(f"Model responded with {len(response.tool_calls)} tool calls.")
-                return Command(goto="call_tools", update={"messages": [response]})
-            else:
-                logger.info("Model responded with a message, ending execution.")
-                return Command(update={"messages": [response]})
-        except Exception as e:
-            logger.error(f"Error in call_model: {e}")
-            raise
-
-    async def select_tools(state: State) -> Command[Literal["call_model"]]:
-        logger.info("Selecting tools...")
-        try:
-            tool_call = state["messages"][-1].tool_calls[0]
-            searched_tools = await search_tools.ainvoke(input=tool_call["args"])
-            tool_msg = ToolMessage(
-                f"Available tool_ids: {searched_tools}. Call load_tools to select the required tools only.",
-                tool_call_id=tool_call["id"],
-            )
-            return Command(goto="call_model", update={"messages": [tool_msg]})
-        except Exception as e:
-            logger.error(f"Error in select_tools: {e}")
-            raise
-
-    async def call_tools(state: State) -> Command[Literal["call_model"]]:
-        logger.info("Calling tools...")
-        outputs = []
-        recent_tool_ids = []
-        for tool_call in state["messages"][-1].tool_calls:
-            try:
-                # Handle special tools internally (no export needed)
-                if tool_call["name"] == search_tools.name:
-                    search_result = await search_tools.ainvoke(input=tool_call["args"])
-                    outputs.append(
-                        ToolMessage(
-                            content=search_result,
-                            name=tool_call["name"],
-                            tool_call_id=tool_call["id"],
-                        )
-                    )
-                    continue
-
-                if tool_call["name"] == load_tools.name:
-                    selected_tool_ids = await load_tools.ainvoke(tool_call["args"])
-                    outputs.append(
-                        ToolMessage(
-                            content=json.dumps(f"Loaded tools- {selected_tool_ids}"),
-                            name=tool_call["name"],
-                            tool_call_id=tool_call["id"],
-                        )
-                    )
-                    recent_tool_ids = selected_tool_ids
-                    continue
-
-                if tool_call["name"] == web_search.name:
-                    web_search_result = await web_search.ainvoke(input=tool_call["args"])
-                    outputs.append(
-                        ToolMessage(
-                            content=json.dumps(f"Web search result: {web_search_result}"),
-                            name=tool_call["name"],
-                            tool_call_id=tool_call["id"],
-                        )
-                    )
-                    continue
-
-                # For other tools: export and call via registry
-                await tool_registry.export_tools([tool_call["name"]], ToolFormat.LANGCHAIN)
-                tool_result = await tool_registry.call_tool(tool_call["name"], tool_call["args"])
-                outputs.append(
-                    ToolMessage(
-                        content=json.dumps(tool_result),
-                        name=tool_call["name"],
-                        tool_call_id=tool_call["id"],
-                    )
-                )
-                recent_tool_ids.append(tool_call["name"])
-            except Exception as e:
-                logger.error(f"Error executing tool '{tool_call['name']}': {e}")
-                outputs.append(
-                    ToolMessage(
-                        content=json.dumps("Error: " + str(e)),
-                        name=tool_call["name"],
-                        tool_call_id=tool_call["id"],
-                    )
-                )
-        return Command(
-            goto="call_model",
-            update={"messages": outputs, "selected_tool_ids": recent_tool_ids},
-        )
-
-    builder = StateGraph(State)
-
-    builder.add_node(call_model)
-    builder.add_node(select_tools)
-    builder.add_node(call_tools)
-    builder.set_entry_point("call_model")
-    return builder

universal_mcp/agents/bigtool2/meta_tools.py

@@ -1,120 +0,0 @@
-import asyncio
-from typing import Any
-
-from langchain_core.tools import BaseTool, tool
-from universal_mcp.logger import logger
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolFormat
-
-
-def create_meta_tools(tool_registry: ToolRegistry) -> list[BaseTool]:
-    @tool
-    async def search_tools(queries: list[str]) -> str:
-        """Search tools for a given list of queries
-        Each single query should be atomic (doable with a single tool).
-        For tasks requiring multiple tools, add separate queries for each subtask"""
-        logger.info(f"Searching tools for queries: '{queries}'")
-        try:
-            all_tool_candidates = ""
-
-            async def fetch_app_and_connection_metadata():
-                return await asyncio.gather(
-                    tool_registry.list_all_apps(),
-                    tool_registry.list_connected_apps(),
-                )
-
-            app_ids, connections = await fetch_app_and_connection_metadata()
-            connection_ids = set([connection["app_id"] for connection in connections])
-            connected_apps = [app["id"] for app in app_ids if app["id"] in connection_ids]
-            app_tools: dict[str, list[str]] = {}
-
-            async def find_tools_for_app(task_query: str, app_id: str) -> list[dict[str, Any]]:
-                return await tool_registry.search_tools(task_query, limit=5, app_id=app_id)
-
-            async def find_tools_for_query(task_query: str) -> list[str]:
-                apps_list = await tool_registry.search_apps(task_query, limit=5)
-                per_app_tool_lists = await asyncio.gather(
-                    *(find_tools_for_app(task_query, app_entry["id"]) for app_entry in apps_list)
-                )
-                tools_flat = [tool for sublist in per_app_tool_lists for tool in sublist]
-                return [f"{tool['id']}: {tool['description']}" for tool in tools_flat]
-
-            # Run all queries concurrently
-            query_results = await asyncio.gather(*(find_tools_for_query(q) for q in queries))
-
-            # Aggregate per-app with cap of 5 per app across all queries
-            for tool_desc in [tool for result in query_results for tool in result]:
-                app = tool_desc.split("__")[0]
-                if app not in app_tools:
-                    app_tools[app] = []
-                if len(app_tools[app]) < 5 and tool_desc not in app_tools[app]:
-                    app_tools[app].append(tool_desc)
-            for app in app_tools:
-                app_status = "connected" if app in connected_apps else "NOT connected"
-                all_tool_candidates += f"Tools from {app} (status: {app_status} by user):\n"
-                for tool in app_tools[app]:
-                    all_tool_candidates += f" - {tool}\n"
-                all_tool_candidates += "\n"
-
-            return all_tool_candidates
-        except Exception as e:
-            logger.error(f"Error retrieving tools: {e}")
-            return "Error: " + str(e)
-
-    @tool
-    async def load_tools(tool_ids: list[str]) -> list[str]:
-        """
-        Load the tools for the given tool ids. Returns the valid tool ids after loading.
-        Tool ids are of form 'appid__toolid'. Example: 'google_mail__send_email'
-        """
-        correct, incorrect = [], []
-        app_tool_list: dict[str, list[str]] = {}
-
-        # Group tool_ids by app for fewer registry calls
-        app_to_tools: dict[str, list[str]] = {}
-        for tool_id in tool_ids:
-            if "__" not in tool_id:
-                incorrect.append(tool_id)
-                continue
-            app, tool = tool_id.split("__", 1)
-            app_to_tools.setdefault(app, []).append((tool_id, tool))
-
-        # Fetch all apps concurrently
-        async def fetch_tools(app: str):
-            try:
-                tools_dict = await tool_registry.list_tools(app)
-                return app, {tool_unit["name"] for tool_unit in tools_dict}
-            except Exception:
-                return app, None
-
-        results = await asyncio.gather(*(fetch_tools(app) for app in app_to_tools))
-
-        # Build map of available tools per app
-        for app, tools in results:
-            if tools is not None:
-                app_tool_list[app] = tools
-
-        # Validate tool_ids
-        for app, tool_entries in app_to_tools.items():
-            available = app_tool_list.get(app)
-            if available is None:
-                incorrect.extend(tool_id for tool_id, _ in tool_entries)
-                continue
-            for tool_id, tool in tool_entries:
-                if tool in available:
-                    correct.append(tool_id)
-                else:
-                    incorrect.append(tool_id)
-
-        return correct
-
-    @tool
-    async def web_search(query: str) -> str:
-        """Search the web for the given query. Returns the search results. Do not use for app-specific searches (for example, reddit or linkedin searches should be done using the app's tools)"""
-        await tool_registry.export_tools(["exa__search_with_filters"], ToolFormat.LANGCHAIN)
-        response = await tool_registry.call_tool(
-            "exa__search_with_filters", {"query": query, "contents": {"summary": True}}
-        )
-        return response
-
-    return [search_tools, load_tools, web_search]

universal_mcp/agents/bigtool2/prompts.py

@@ -1,15 +0,0 @@
-"""Default prompts used by the agent."""
-
-SYSTEM_PROMPT = """You are a helpful AI assistant.
-
-**Core Directives:**
-1.  **Always Use Tools for Tasks:** For any user request that requires an action (e.g., sending an email, searching for information, creating an event, displaying a chart), you MUST use a tool. Do not refuse a task if a tool might exist for it.
-
-2. Check if your existing tools or knowledge can handle the user's request. If they can, use them. If they cannot, you must call the `search_tools` function to find the right tools for the user's request.You must not use the same/similar query multiple times in the list. The list should have multiple queries only if the task has clearly different sub-tasks. If you do not find any specific relevant tools, use the pre-loaded generic tools.
-
-3.  **Load Tools:** After looking at the output of `search_tools`, you MUST call the `load_tools` function to load only the tools you want to use. Provide the full tool ids, not just the app names. Use your judgement to eliminate irrelevant apps that came up just because of semantic similarity. However, sometimes, multiple apps might be relevant for the same task. Prefer connected apps over unconnected apps while breaking a tie. If more than one relevant app (or none of the relevant apps) are connected, you must ask the user to choose the app. In case the user asks you to use an app that is not connected, call the apps tools normally. The tool will return a link for connecting that you should pass on to the user.
-
-4.  **Strictly Follow the Process:** Your only job in your first turn is to analyze the user's request and answer using existing tools/knowledge or `search_tools` with a concise query describing the core task. Do not engage in conversation, or extend the conversation beyond the user's request.
-
-{instructions}
-"""

universal_mcp/agents/bigtoolcache/state.py

@@ -1,27 +0,0 @@
-from typing import Annotated
-
-from langgraph.prebuilt.chat_agent_executor import AgentState
-
-
-def _enqueue(left: list, right: list) -> list:
-    """Treat left as a FIFO queue, append new items from right (preserve order),
-    keep items unique, and cap total size to 20 (drop oldest items)."""
-    max_size = 30
-    preferred_size = 20
-    if len(right) > preferred_size:
-        preferred_size = min(max_size, len(right))
-    queue = list(left or [])
-
-    for item in right[:preferred_size] or []:
-        if item in queue:
-            queue.remove(item)
-        queue.append(item)
-
-    if len(queue) > preferred_size:
-        queue = queue[-preferred_size:]
-
-    return queue
-
-
-class State(AgentState):
-    selected_tool_ids: Annotated[list[str], _enqueue]

universal_mcp/agents/builder.py

@@ -1,204 +0,0 @@
-import asyncio
-from collections import defaultdict
-from collections.abc import Sequence
-from typing import Annotated, TypedDict
-
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.graph import END, START, StateGraph
-from langgraph.graph.message import add_messages
-from pydantic import BaseModel, Field
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolConfig
-
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.llm import load_chat_model
-from universal_mcp.agents.shared.tool_node import build_tool_node_graph
-from universal_mcp.agents.utils import messages_to_list
-
-
-class Agent(BaseModel):
-    """Agent that can be created by the builder."""
-
-    name: str = Field(description="Name of the agent.")
-    description: str = Field(description="A small description of the agent.")
-    expertise: str = Field(description="The expertise of the agent.")
-    instructions: str = Field(description="The instructions for the agent to follow.")
-    schedule: str | None = Field(description="The cron expression for the agent to run on.", default=None)
-
-
-class BuilderState(TypedDict):
-    user_task: str
-    generated_agent: Agent | None
-    tool_config: ToolConfig | None
-    messages: Annotated[Sequence[BaseMessage], add_messages]
-
-
-AGENT_BUILDER_INSTRUCTIONS = r"""
-You are a specialized Agent Generation AI, tasked with creating intelligent, effective, and context-aware AI agents based on user requests.
-
-When given a user's request, immediately follow this structured process:
-
-# 1. Intent Breakdown
-- Clearly identify the primary goal the user wants the agent to achieve.
-- Recognize any special requirements, constraints, formatting requests, or interaction rules.
-- Summarize your understanding briefly to ensure alignment with user intent.
-
-# 2. Agent Profile Definition
-- **Name (2-4 words)**: Concise, clear, and memorable name reflecting core functionality.
-- **Description (1-2 sentences)**: Captures the unique value and primary benefit to users.
-- **Expertise**: Precise domain-specific expertise area. Avoid vague or overly general titles.
-- **Instructions**: Compose detailed, highly actionable system instructions that directly command the agent's behavior. Respond in markdown as this text will be rendered in a rich text editor. Write instructions as clear imperatives, without preamble, assuming the agent identity is already established externally.
-- **Schedule**: If the user specifies a schedule, you should also provide a cron expression for the agent to run on. The schedule should be in a proper cron expression and nothing more. Do not respond with any other information or explain your reasoning for the schedule, otherwise this will cause a parsing error that is undesirable.
-
-## ROLE & RESPONSIBILITY
-- Clearly state the agent's primary mission, e.g., "Your primary mission is...", "Your core responsibility is...".
-- Outline the exact tasks it handles, specifying expected input/output clearly.
-
-## INTERACTION STYLE
-- Define exactly how to communicate with users: tone, format, response structure.
-- Include explicit commands, e.g., "Always wrap responses in \`\`\`text\`\`\` blocks.", "Never add greetings or meta-information.", "Always provide outputs in user's requested languages."
-
-## OUTPUT FORMATTING RULES
-- Clearly specify formatting standards required by the user (e.g., JSON, plain text, markdown).
-- Include explicit examples to illustrate correct formatting.
-
-## LIMITATIONS & CONSTRAINTS
-- Explicitly define boundaries of the agent's capabilities.
-- Clearly state what the agent must never do or say.
-- Include exact phrases for declining requests outside scope.
-
-## REAL-WORLD EXAMPLES
-Provide two explicit interaction examples showing:
-- User's typical request.
-- Final agent response demonstrating perfect compliance.
-
-Create an agent that feels thoughtfully designed, intelligent, and professionally reliable, perfectly matched to the user's original intent.
-"""
-
-
-async def generate_agent(llm: BaseChatModel, task: str, old_agent: Agent | None = None) -> Agent:
-    """Generates an agent from a task, optionally modifying an existing one."""
-    prompt_parts = [AGENT_BUILDER_INSTRUCTIONS]
-    if old_agent:
-        prompt_parts.append(
-            "\nThe user wants to modify the following agent design. "
-            "Incorporate their feedback into a new design.\n\n"
-            f"{old_agent.model_dump_json(indent=2)}"
-        )
-    else:
-        prompt_parts.append(f"\n\n**Task:** {task}")
-
-    prompt = "\n".join(prompt_parts)
-    structured_llm = llm.with_structured_output(Agent)
-    agent = await structured_llm.ainvoke(prompt)
-    return agent
-
-
-class BuilderAgent(BaseAgent):
-    def __init__(
-        self,
-        name: str,
-        instructions: str,
-        model: str,
-        registry: ToolRegistry,
-        memory: BaseCheckpointSaver | None = None,
-        **kwargs,
-    ):
-        super().__init__(name, instructions, model, memory, **kwargs)
-        self.registry = registry
-        self.llm: BaseChatModel = load_chat_model(model, thinking=False)
-
-    async def _create_agent(self, state: BuilderState):
-        last_message = state["messages"][-1]
-        task = last_message.content
-        agent = state.get("generated_agent")
-
-        yield {
-            "messages": [
-                AIMessage(
-                    content="Thinking... I will now design an agent to handle your request.",
-                )
-            ],
-        }
-        generated_agent = await generate_agent(self.llm, task, agent)
-        yield {
-            "user_task": task,
-            "generated_agent": generated_agent,
-            "messages": [AIMessage(content=("I've designed an agent to help you with your task."))],
-        }
-
-    async def _create_tool_config(self, state: BuilderState):
-        task = state["user_task"]
-        yield {
-            "messages": [
-                AIMessage(
-                    content="Great! Now, I will select the appropriate tools for this agent. This may take a moment.",
-                )
-            ]
-        }
-        tool_finder_graph = build_tool_node_graph(self.llm, self.registry)
-
-        initial_state = {
-            "original_task": task,
-            "messages": [HumanMessage(content=task)],
-            "decomposition_attempts": 0,
-        }
-        final_state = await tool_finder_graph.ainvoke(initial_state)
-        execution_plan = final_state.get("execution_plan")
-        tool_config = {}
-        if execution_plan:
-            # Use defaultdict to easily group tools by app_id
-            apps_with_tools = defaultdict(list)
-            for step in execution_plan:
-                app_id = step.get("app_id")
-                tool_ids = step.get("tool_ids")
-                if app_id and tool_ids:
-                    apps_with_tools[app_id].extend(tool_ids)
-
-            # Convert to a regular dict and remove any duplicate tool_ids for the same app
-            tool_config = {app_id: list(set(tools)) for app_id, tools in apps_with_tools.items()}
-            final_message = "I have selected the necessary tools for the agent. The agent is ready!"
-        else:
-            # Handle the case where the graph failed to create a plan
-            final_message = "I was unable to find the right tools for this task. Please try rephrasing your request."
-
-        yield {
-            "tool_config": tool_config,
-            "messages": [AIMessage(content=final_message)],
-        }
-
-    async def _build_graph(self):
-        builder = StateGraph(BuilderState)
-        builder.add_node("create_agent", self._create_agent)
-        builder.add_node("create_tool_config", self._create_tool_config)
-
-        builder.add_edge(START, "create_agent")
-        builder.add_edge("create_agent", "create_tool_config")
-        builder.add_edge("create_tool_config", END)
-        return builder.compile(checkpointer=self.memory)
-
-
-async def main():
-    from universal_mcp.agentr.registry import AgentrRegistry
-
-    registry = AgentrRegistry()
-    agent = BuilderAgent(
-        name="Builder Agent",
-        instructions="You are a builder agent that creates other agents.",
-        model="gemini/gemini-1.5-pro",
-        registry=registry,
-    )
-    result = await agent.invoke(
-        "Send a daily email to manoj@agentr.dev with daily agenda of the day",
-    )
-    from rich import print
-
-    print(messages_to_list(result["messages"]))
-    print(result["generated_agent"])
-    print(result["tool_config"])
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

universal_mcp_agents-0.1.11.dist-info/RECORD

@@ -1,42 +0,0 @@
-universal_mcp/agents/__init__.py,sha256=oPoHMITGbHN4Ey68ZrVbmy7sNzVYhoXQgVII9fZwqL8,1245
-universal_mcp/agents/base.py,sha256=KXBxf3TXrVHi-wBVD-cs6PSKfMtUnm73l-hC83FjOog,6753
-universal_mcp/agents/builder.py,sha256=Xl_dGmzbtop3lICH2njnN6yxFF0SnEGY8u1tOIJy2Pk,8677
-universal_mcp/agents/cli.py,sha256=-luC55FHCTwnpcRgqnV95yQa-mGlLYDlseUjLqFrAfs,1014
-universal_mcp/agents/hil.py,sha256=_xLlBte4v5ex-RxXy5H3LqwFhtd3KE1QUHX1QDGIl2w,3760
-universal_mcp/agents/llm.py,sha256=hVRwjZs3MHl5_3BWedmurs2Jt1oZDfFX0Zj9F8KH7fk,1787
-universal_mcp/agents/react.py,sha256=0OZvdBTnQdFF3Wliv2l4wiF2BMd0VG1cVflOaWDC8r0,3166
-universal_mcp/agents/simple.py,sha256=W5_zb2DAGtAx_p5weSQGIC3gheZwxhmwZBuKKBTjd04,1938
-universal_mcp/agents/utils.py,sha256=lnRmP6HBIme4W-iKy1BOb9gTyb9-ooJxXwCyWAQFP9k,4712
-universal_mcp/agents/bigtool2/__init__.py,sha256=i4virR9r1_1FcS_-iuSHZWgEzYZwOroT6J44qPb0ZgM,2462
-universal_mcp/agents/bigtool2/__main__.py,sha256=t6fWhLh3SnpN_05cww3LA_r_5Rb0gaF_U4FH1Mpsv1Y,655
-universal_mcp/agents/bigtool2/agent.py,sha256=4GIQIy2VQgdXOezmET8G7tvP_37Vv8C027bGdGXJbTI,437
-universal_mcp/agents/bigtool2/graph.py,sha256=FuW1XyTIr1aUbAC4ea8JWRR0JENvLfZGUSgQFmk0h3A,6544
-universal_mcp/agents/bigtool2/meta_tools.py,sha256=02xOsGdxZpXBirn2KWk63UqYPQjI41nQ2KGj2zKBf7Y,5306
-universal_mcp/agents/bigtool2/prompts.py,sha256=rQFtZDkwU9z8d4PWdt6jpohGhyab658Xvk8hvNVBFBA,1843
-universal_mcp/agents/bigtool2/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
-universal_mcp/agents/bigtoolcache/__init__.py,sha256=qrUwYqhZNE0PdmUCGc5jRQt45Tr1xPDSfBxCPJA1DDM,2260
-universal_mcp/agents/bigtoolcache/__main__.py,sha256=noqT7Nqr17q7Eeiib-Dk2qG6AH4LkNyveeU_ceNDfMA,473
-universal_mcp/agents/bigtoolcache/agent.py,sha256=NCF6fdBPwVcaOyhv8xbAy5DBqbGxJiv8_fLqKib7QJc,267
-universal_mcp/agents/bigtoolcache/context.py,sha256=ny7gd-vvVpUOYAeQbAEUT0A6Vm6Nn2qGywxTzPBzYFg,929
-universal_mcp/agents/bigtoolcache/graph.py,sha256=9KUjsVu5dtPdnyNkqJ5LsMnfH-IF_4H2me_L5aHgsug,4315
-universal_mcp/agents/bigtoolcache/prompts.py,sha256=Rz30qNGdscDG65vMj9d0Vfe7X1pQjBDQBBNc3BuyC94,1886
-universal_mcp/agents/bigtoolcache/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
-universal_mcp/agents/bigtoolcache/tools.py,sha256=ynyEj9mVwKKDhxm76sjspyH51SFi63g2Vydi39pY0qY,5562
-universal_mcp/agents/codeact/__init__.py,sha256=rLE8gvOo5H4YSr71DRq76b3RV3uuotxuAy_VnBVaVwk,60
-universal_mcp/agents/codeact/__main__.py,sha256=FRfIkgcZfawP-M66v4ePijA6J2fs7nQv92G_8cj5qYA,1142
-universal_mcp/agents/codeact/agent.py,sha256=yB99aTRHWOdl4b67UxRstuV7WplrTjUZuqP1odwSS5o,5586
-universal_mcp/agents/codeact/prompts.py,sha256=6NZkWQCaS7X7CLOTV-hMZgeWa1jf6iKbAT00INuluM0,4668
-universal_mcp/agents/codeact/sandbox.py,sha256=pG6M1elzWw4KS46ewl-2d_U9Ap8HnHJDY9Rna_76sRI,1489
-universal_mcp/agents/codeact/state.py,sha256=K25HcEljNNJDaeUgG5P68Kj752XzWTh8BwILY8w_EtE,357
-universal_mcp/agents/codeact/utils.py,sha256=JUbT_HYGS_D1BzmzoVpORIe7SGur1KgJguTZ_1tZ4JY,1918
-universal_mcp/agents/planner/__init__.py,sha256=9P1UL-ABvrTIWTJ8wcvZmkqT8uyROZxsmUFhpjTK-Q4,1313
-universal_mcp/agents/planner/__main__.py,sha256=OfhTfYDZK_ZUfc8sX-Sa6TWk-dNqD2rl13Ln64mNAtw,771
-universal_mcp/agents/planner/graph.py,sha256=70hhIoEZOcYojpiyVSCedgYpnmxVP7aqdn8s6VBu-D4,3228
-universal_mcp/agents/planner/prompts.py,sha256=_JoHqiAvswtqCDu90AGUHmfsu8eWE1-_yI4LLn3pqMU,657
-universal_mcp/agents/planner/state.py,sha256=qqyp-jSGsCxe1US-PRLT4-y1sITAcVE6nCMlQLnvop0,278
-universal_mcp/agents/shared/prompts.py,sha256=VOsXSUEwBXPaAuxJTUF6bgDGr41u6uctUNQSMRt_OJc,6414
-universal_mcp/agents/shared/tool_node.py,sha256=Ua_wzMt4YgIx4zLp3_ZCow-28qORwrZ2FvKqLPt3RlI,10415
-universal_mcp/applications/ui/app.py,sha256=uaS1KrwrGxw9oexdLj2Jok77DrZQAmby3uVxCONQyV8,11276
-universal_mcp_agents-0.1.11.dist-info/METADATA,sha256=MosDAsvQTSvUr41527xNHF8QpEeatOh7g0bpBDr7lW0,878
-universal_mcp_agents-0.1.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.11.dist-info/RECORD,,