universal-mcp-agents 0.1.23rc6__py3-none-any.whl → 0.1.23rc7__py3-none-any.whl

universal_mcp/agents/codeact0/agent.py

@@ -20,6 +20,7 @@ from universal_mcp.agents.codeact0.prompts import (
     AGENT_BUILDER_META_PROMPT,
     AGENT_BUILDER_PLANNING_PROMPT,
     create_default_prompt,
+    build_tool_definitions
 )
 from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell, handle_execute_ipython_cell
 from universal_mcp.agents.codeact0.state import AgentBuilderCode, AgentBuilderMeta, AgentBuilderPlan, CodeActState
@@ -27,7 +28,7 @@ from universal_mcp.agents.codeact0.tools import (
     create_meta_tools,
     enter_agent_builder_mode,
 )
-from universal_mcp.agents.codeact0.utils import build_anthropic_cache_message, get_connected_apps_string, create_agent_call
+from universal_mcp.agents.codeact0.utils import build_anthropic_cache_message, get_connected_apps_string
 from universal_mcp.agents.llm import load_chat_model
 from universal_mcp.agents.utils import convert_tool_ids_to_dict, filter_retry_on, get_message_text
 
@@ -52,7 +53,7 @@ class CodeActPlaybookAgent(BaseAgent):
             **kwargs,
         )
         self.model_instance = load_chat_model(model)
-        self.agent_builder_model_instance = load_chat_model("azure/gpt-4.1")
+        self.agent_builder_model_instance = load_chat_model("anthropic:claude-sonnet-4-5-20250929", thinking = False)
         self.registry = registry
         self.agent_builder_registry = agent_builder_registry
         self.agent = agent_builder_registry.get_agent() if agent_builder_registry else None
@@ -215,7 +216,7 @@ class CodeActPlaybookAgent(BaseAgent):
             if agent_builder_mode == "planning":
                 plan_id = str(uuid.uuid4())
                 writer({"type": "custom", id: plan_id, "name": "planning", "data": {"update": bool(self.agent)}})
-                planning_instructions = self.instructions + AGENT_BUILDER_PLANNING_PROMPT
+                planning_instructions = self.instructions + AGENT_BUILDER_PLANNING_PROMPT + self.preloaded_defs
                 messages = [{"role": "system", "content": planning_instructions}] + state["messages"]
 
                 model_with_structured_output = self.agent_builder_model_instance.with_structured_output(
@@ -318,7 +319,7 @@ class CodeActPlaybookAgent(BaseAgent):
                 return Command(goto="call_model", update={"agent_builder_mode": "inactive"})
 
             elif agent_builder_mode == "generating":
-                generating_instructions = self.instructions + AGENT_BUILDER_GENERATING_PROMPT
+                generating_instructions = self.instructions + AGENT_BUILDER_GENERATING_PROMPT +  self.preloaded_defs
                 messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
 
                 model_with_structured_output = self.agent_builder_model_instance.with_structured_output(
@@ -359,7 +360,34 @@ class CodeActPlaybookAgent(BaseAgent):
                         tools=tool_dict,
                     )
                 except Exception as e:
-                    raise e
+                    # In case of error, add the code to the exit message content
+
+                    mock_exit_tool_call = {
+                    "name": "exit_agent_builder_mode",
+                    "args": {},
+                    "id": "exit_builder_1"
+                    }
+
+                    # Create a minimal assistant message to maintain flow
+                    mock_assistant_message = AIMessage(
+                        content=json.dumps(response.model_dump()),
+                        tool_calls=[mock_exit_tool_call],
+                        additional_kwargs={
+                            "type": "generating",
+                            "id": "ignore",
+                            "update": bool(self.agent),
+                            "name": final_name.replace(" ", "_"),
+                            "description": final_description,
+                        },
+                    )
+                    mock_exit_tool_response = ToolMessage(
+                        content=json.dumps(
+                            f"An error occurred. Displaying the function code:\n\n{func_code}\nFinal Name: {final_name}\nDescription: {final_description}"
+                        ),
+                        name="exit_agent_builder_mode",
+                        tool_call_id="exit_builder_1"
+                    )
+                    return Command(update={"messages": [mock_assistant_message, mock_exit_tool_response], "agent_builder_mode": "normal"})
 
                 writer(
                     {
@@ -401,18 +429,24 @@ class CodeActPlaybookAgent(BaseAgent):
 
         async def route_entry(state: CodeActState) -> Command[Literal["call_model", "agent_builder", "execute_tools"]]:
             """Route to either normal mode or agent builder creation"""
-            await self.registry.load_tools(state["selected_tool_ids"])
-            all_tools = await self.registry.export_tools(format=ToolFormat.NATIVE)
+            pre_tools = await self.registry.export_tools(format=ToolFormat.NATIVE)
 
             # Create the initial system prompt and tools_context in one go
             self.final_instructions, self.tools_context = create_default_prompt(
-                all_tools,
+                pre_tools,
                 self.additional_tools,
                 self.instructions,
                 await get_connected_apps_string(self.registry),
                 self.agent,
                 is_initial_prompt=True,
             )
+            self.preloaded_defs, _ = build_tool_definitions(pre_tools)
+            self.preloaded_defs = '\n'.join(self.preloaded_defs)
+            await self.registry.load_tools(state["selected_tool_ids"])
+            exported_tools = await self.registry.export_tools(state["selected_tool_ids"],ToolFormat.NATIVE)  # Get definition for only the new tools
+            _, loaded_tools_context = build_tool_definitions(exported_tools)
+            self.tools_context.update(loaded_tools_context)
+            
             if len(state['messages']) == 1 and self.agent: # Inject the agent's script function into add_context for execution
                 script = self.agent.instructions.get('script')
                 add_context = {"functions":[script]}

universal_mcp/agents/codeact0/prompts.py

@@ -25,7 +25,6 @@ Your job is to answer the user's question or perform the task they ask for.
 - If needed, feel free to ask for more information from the user (without using the `execute_ipython_cell` tool) to clarify the task.
 - Always describe in 2-3 lines about the current progress. In each step, mention what has been achieved and what you are planning to do next.
 - DO NOT use the code execution to communicate with the user. The user is not able to see the output of the code cells.
-- Always use `await` when calling an async function. Since this is a Jupyter/async environment, you must not use asyncio.run().
 
 **Coding Best Practices:**
 - Variables defined at the top level of previous code snippets can be referenced in your code.
@@ -35,49 +34,97 @@ Your job is to answer the user's question or perform the task they ask for.
 - You can only import libraries that come pre-installed with Python. However, do consider searching for external functions first, using the search and load tools to access them in the code.
 - For displaying final results to the user, you must present your output in markdown format, including image links, so that they are rendered and displayed to the user. The code output is NOT visible to the user.
 - Call all functions using keyword arguments only, never positional arguments.
-
+- NEVER use execute_ipython_cell for:
+    - Static analysis or commentary
+    - Text that could be written as markdown
+    - Final output summarization after analysis
+    - Anything that's just formatted print statements
 
 **Final Output Requirements:**
-- Once you have all the information about the task, return the text directly to user in markdown format. No need to call `execute_ipython_cell` again.
+- Once you have all the information about the task, return the text directly to user in markdown format. Do NOT call `execute_ipython_cell` again just for summarization.
 - Always respond in github flavoured markdown format.
 - For charts and diagrams, use mermaid chart in markdown directly.
 - Your final response should contain the complete answer to the user's request in a clear, well-formatted manner that directly addresses what they asked for.
 """
 
-AGENT_BUILDER_PLANNING_PROMPT = """Now, you are tasked with creating a reusable agent from the user's previous workflow.
+AGENT_BUILDER_PLANNING_PROMPT = """TASK: Analyze the conversation history and code execution to create a step-by-step non-technical plan for a reusable function.
+Rules:
+- Do NOT include the searching and loading of functions. Assume that the functions have already been loaded.
+- The plan is a sequence of steps corresponding to the key logical steps taken to achieve the user's task in the conversation history, without focusing on technical specifics.
+- You must output a JSON object with a single key "steps", which is a list of strings. Each string is a step in the agent.
+- Identify user-provided information as variables that should become the main agent input parameters using `variable_name` syntax, enclosed by backticks `...`. Intermediate variables should be highlighted using italics, i.e. *...*, NEVER `...`
+- Keep the logic generic and reusable. Avoid hardcoding any names/constants. Instead, keep them as variables with defaults. They should be represented as `variable_name(default = default_value)`.
+- Have a human-friendly plan and inputs format. That is, it must not use internal IDs or keys used by APIs as either inputs or outputs to the overall plan; using them internally is okay.
+- Be as concise as possible, especially for internal processing steps.
+- For steps where the assistant's intelligence was used outside of the code to infer/decide/analyse something, replace it with the use of *llm__* functions in the plan if required.
+
+Example Conversation History:
+User Message: "Create an image using Gemini for Marvel Cinematic Universe in comic style"
+Code snippet: image_result = await google_gemini__generate_image(prompt=prompt)
+Assistant Message: "The image has been successfully generated [image_result]."
+User Message: "Save the image in my OneDrive"
+Code snippet: image_data = base64.b64decode(image_result['data'])
+    temp_file_path = tempfile.mktemp(suffix='.png')
+    with open(temp_file_path, 'wb') as f:
+        f.write(image_data)
+    # Upload the image to OneDrive with a descriptive filename
+    onedrive_filename = "Marvel_Cinematic_Universe_Comic_Style.png"
+
+    print(f"Uploading to OneDrive as: {onedrive_filename}")
+
+    # Upload to OneDrive root folder
+    upload_result = onedrive__upload_file(
+        file_path=temp_file_path,
+        parent_id='root',
+        file_name=onedrive_filename
+    )
+
+Generated Steps:
+"steps": [
+    "Generate an image using Gemini model with `image_prompt` and `style(default = 'comic')`",
+    "Upload the obtained image to OneDrive using `onedrive_filename(default = 'generated_image.png')` and `onedrive_parent_folder(default = 'root')`",
+    "Return confirmation of upload including file name and destination path, and link to the upload"
+  ]
+Note that internal variables like upload_result, image_result are not highlighted in the plan, and intermediate processing details are skipped.
+Now create a plan based on the conversation history. Do not include any other text or explanation in your response. Just the JSON object.
+Note that the following tools are pre-loaded for the agent's use, and can be inluded in your plan if needed as internal variables (especially the llm tools)-\n
+"""
 
-TASK: Analyze the conversation history and code execution to create a step-by-step plan for a reusable function.
-Do not include the searching and loading of tools. Assume that the tools have already been loaded.
-The plan is a sequence of steps.
-You must output a JSON object with a single key "steps", which is a list of strings. Each string is a step in the agent.
 
-Your plan should:
-1. Identify the key steps in the workflow
-2. Mark user-specific variables that should become the main agent function parameters using `variable_name` syntax. Intermediate variables MUST not be highlighted using ``
-3. Keep the logic generic and reusable
-4. Be clear and concise
+AGENT_BUILDER_GENERATING_PROMPT = """
+You are tasked with generating a reusable agent function based on the final confirmed agent plan and preceding conversation history including user messages, assistant messages, and code executions.
+Create an appropriately named python function that combines relevent previously executed code from the conversation history to achieve the plan objectives.
+Rules-
+- Do NOT include the searching and loading of functions. Assume that the functions have already been loaded. Imports should be included.
+- Your response must be **ONLY Python code** for the function.
+- Do not include any text, explanations, or Markdown.
+- The response must start with `def` or `async def` and define a single, complete, executable function.
+- The function parameters **must exactly match the external variables** in the agent plan. External variables are marked using backticks `` `variable_name` ``.  Any variables in italics (i.e. enclosed in *...*) are to be used internally, but not as the main function paramters.
+- Any imports, variables, helper or child functions required must be defined **inside the main top-level function**.  
+- Ensure that the outer function is self-contained and can run independently, based on previously validated code snippets.
 
 Example:
-{
-    "steps": [
-        "Connect to database using `db_connection_string`",
-        "Query user data for `user_id`",
-        "Process results and calculate `metric_name`",
-        "Send notification to `email_address`"
-    ]
-}
 
-Now create a plan based on the conversation history. Do not include any other text or explanation in your response. Just the JSON object.
-"""
+If the plan has:
+
+"steps": [
+"Receive creative description as image_prompt",
+"Generate image using Gemini with style(default = 'comic')",
+"Save temporary image internally as *temp_file_path*",
+"Upload *temp_file_path* to OneDrive folder onedrive_parent_folder(default = 'root')"
+]
 
+Then the function signature should be:
 
-AGENT_BUILDER_GENERATING_PROMPT = """Now, you are tasked with generating the agent function.
-Your response must be ONLY the Python code for the function.
-Do not include any other text, markdown, or explanations in your response.
-Your response should start with `def` or `async def`.
-The function should be a single, complete piece of code that can be executed independently, based on previously executed code snippets that executed correctly.
-The parameters of the function MUST be exactly the same as the final confirmed agent plan. The variables will are indicated using `` in the plan.
-Any additional functions you require should be child functions inside the main top level function, and thus the first function to appear must be the main agent executable function.
+```python
+def image_generator(image_prompt, style="comic", onedrive_parent_folder="root"):
+    #Code based on previously executed snippets
+
+And all internal variables (e.g., *temp_file_path*) should be defined inside the function.
+
+
+Use this convention consistently to generate the final agent function.
+Note that the following tools are pre-loaded for the agent's use, and can be included in your code-\n
 """
 
 
@@ -114,17 +161,39 @@ def make_safe_function_name(name: str) -> str:
     return safe_name
 
 
+# Compile regex once for better performance
+_RAISES_PATTERN = re.compile(r'\n\s*[Rr]aises\s*:.*$', re.DOTALL)
+
+def _clean_docstring(docstring: str | None) -> str:
+    """Remove the 'Raises:' section and everything after it from a docstring."""
+    if not docstring:
+        return ""
+    
+    # Use pre-compiled regex for better performance
+    cleaned = _RAISES_PATTERN.sub('', docstring)
+    return cleaned.strip()
+
+
 def build_tool_definitions(tools: list[Callable]) -> tuple[list[str], dict[str, Callable]]:
     tool_definitions = []
     context = {}
-    for tool in tools:
+    
+    # Pre-allocate lists for better performance
+    tool_definitions = [None] * len(tools)
+    
+    for i, tool in enumerate(tools):
         tool_name = tool.__name__
-        tool_definitions.append(
-            f'''{"async " if inspect.iscoroutinefunction(tool) else ""}def {tool_name} {str(inspect.signature(tool))}:
-    """{tool.__doc__}"""
+        cleaned_docstring = _clean_docstring(tool.__doc__)
+        
+        # Pre-compute string parts to avoid repeated string operations
+        async_prefix = "async " if inspect.iscoroutinefunction(tool) else ""
+        signature = str(inspect.signature(tool))
+        
+        tool_definitions[i] = f'''{async_prefix}def {tool_name} {signature}:
+    """{cleaned_docstring}"""
     ...'''
-        )
         context[tool_name] = tool
+    
     return tool_definitions, context
 
 
@@ -139,7 +208,7 @@ def create_default_prompt(
     if is_initial_prompt:
         system_prompt = uneditable_prompt.strip()
         if apps_string:
-            system_prompt += f"\n\n**Connected external applications (These apps have been logged into by the user):**\n{apps_string}\n\n Use `search_functions` to search for functions you can perform using the above. You can also discover more applications using the `search_functions` tool to find additional tools and integrations, if required.\n"
+            system_prompt += f"\n\n**Connected external applications (These apps have been logged into by the user):**\n{apps_string}\n\n Use `search_functions` to search for functions you can perform using the above. You can also discover more applications using the `search_functions` tool to find additional tools and integrations, if required. However, you MUST not assume the application when multiple apps are connected for a particular usecase.\n"
         system_prompt += (
             "\n\nIn addition to the Python Standard Library, you can use the following external functions:\n"
         )

universal_mcp/agents/codeact0/tools.py

@@ -192,9 +192,9 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
             )
 
         result_parts.append("Call load_functions to select the required functions only.")
-        if len(connected_apps_in_results)>len(apps_in_results):
-            result_parts.append("Unconnected app functions can also be loaded if required by the user, but prefer connected ones.")
-        return " ".join(result_parts)
+        if len(connected_apps_in_results)<len(apps_in_results) and len(connected_apps_in_results)>0:
+            result_parts.append("Unconnected app functions can also be loaded if required by the user, but prefer connected ones. And do ask the user to choose if none of the relevant apps are connected")
+        return "\n".join(result_parts)
 
     @tool
     async def load_functions(tool_ids: list[str]) -> str:

universal_mcp/agents/codeact0/utils.py

@@ -452,78 +452,3 @@ async def get_connected_apps_string(registry) -> str:
         return "\n".join(apps_list)
     except Exception:
         return "Unable to retrieve connected applications."
-
-
-def create_agent_call(agent: object, agent_args: dict[str, Any]) -> AIMessage:
-    """Create an assistant tool-call message to execute the agent script.
-
-    This inspects the agent's generated script (expected at agent.instructions["script"]) to
-    locate the topmost function or async function, then constructs a Python snippet that:
-    - embeds the script as-is,
-    - deserializes the provided arguments as keyword arguments,
-    - invokes the detected function (awaiting it if async), and
-    - prints the result via smart_print.
-
-    If no top-level function is detected or the script cannot be parsed, a safe fallback
-    snippet is produced which simply prints the provided arguments.
-
-    Args:
-        agent: Object that provides an `instructions` mapping with a `script` string.
-        agent_args: Mapping of argument names to values to be passed as keyword args to the function.
-
-    Returns:
-        AIMessage: A synthetic assistant message containing a single tool call for
-        `execute_ipython_cell` with the constructed snippet.
-    """
-    content = "Running the agent with your provided parameters"
-    script = agent.instructions.get("script") if hasattr(agent, "instructions") else None
-    args = agent_args or {}
-
-    func_name = None
-    is_async = False
-
-    if isinstance(script, str) and script.strip():
-        try:
-            tree = ast.parse(script)
-            for node in tree.body:
-                if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                    func_name = node.name
-                    is_async = isinstance(node, ast.AsyncFunctionDef)
-                    break
-        except SyntaxError:
-            func_name = None
-
-    # Fallback content/snippet if no callable function is found
-    if not func_name:
-        snippet = (
-            "import asyncio\n\n# Test fallback: no function detected in script; printing args\n"
-            f"smart_print({repr(args)})\n"
-        )
-    else:
-        import json as _json
-        args_json = _json.dumps(args)
-        if is_async:
-            snippet = (
-                f"{script}\n\n"
-                "import asyncio, json\n"
-                f"_kwargs = json.loads('{args_json}')\n"
-                f"async def __runner():\n    result = await {func_name}(**_kwargs)\n    smart_print(result)\n"
-                "asyncio.run(__runner())\n"
-            )
-        else:
-            snippet = (
-                f"{script}\n\n"
-                "import json\n"
-                f"_kwargs = json.loads('{args_json}')\n"
-                f"result = {func_name}(**_kwargs)\n"
-                "smart_print(result)\n"
-            )
-
-    mock_agent_call = {
-        "name": "execute_ipython_cell",
-        "args": {"snippet": snippet},
-        "id": "initial_agent_call",
-        "type": "tool_call",
-    }
-    mock_assistant_message = AIMessage(content=content, tool_calls=[mock_agent_call])
-    return mock_assistant_message

{universal_mcp_agents-0.1.23rc6.dist-info → universal_mcp_agents-0.1.23rc7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.23rc6
+Version: 0.1.23rc7
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

{universal_mcp_agents-0.1.23rc6.dist-info → universal_mcp_agents-0.1.23rc7.dist-info}/RECORD

@@ -22,15 +22,15 @@ universal_mcp/agents/builder/prompts.py,sha256=8Xs6uzTUHguDRngVMLak3lkXFkk2VV_uQ
 universal_mcp/agents/builder/state.py,sha256=7DeWllxfN-yD6cd9wJ3KIgjO8TctkJvVjAbZT8W_zqk,922
 universal_mcp/agents/codeact0/__init__.py,sha256=8-fvUo1Sm6dURGI-lW-X3Kd78LqySYbb5NMkNJ4NDwg,76
 universal_mcp/agents/codeact0/__main__.py,sha256=YyIoecUcKVUhTcCACzLlSmYrayMDsdwzDEqaV4VV4CE,766
-universal_mcp/agents/codeact0/agent.py,sha256=jaBntdEGydWI6OvRPpDsrLjnNncDdvQtjJbAgkeYp-U,20545
+universal_mcp/agents/codeact0/agent.py,sha256=lixuPcFLEaWl3IgJ7pY9JSLz9UxH5t9F9FJVEIELydA,22507
 universal_mcp/agents/codeact0/config.py,sha256=H-1woj_nhSDwf15F63WYn723y4qlRefXzGxuH81uYF0,2215
 universal_mcp/agents/codeact0/langgraph_agent.py,sha256=8nz2wq-LexImx-l1y9_f81fK72IQetnCeljwgnduNGY,420
 universal_mcp/agents/codeact0/llm_tool.py,sha256=-pAz04OrbZ_dJ2ueysT1qZd02DrbLY4EbU0tiuF_UNU,798
-universal_mcp/agents/codeact0/prompts.py,sha256=zMZyaIb_T1ssPASm6tnEvPSG8SkHm80aJcLzqcTicIk,11144
+universal_mcp/agents/codeact0/prompts.py,sha256=re1DHkfC6kyy1Y2pgmPLMZ_TceKZHZk-0-csCPHnQjw,15344
 universal_mcp/agents/codeact0/sandbox.py,sha256=FcJgJ64upa8NMcFDLXkT7FT69AQvUvPBiXyqW937AUo,4701
 universal_mcp/agents/codeact0/state.py,sha256=cf-94hfVub-HSQJk6b7_SzqBS-oxMABjFa8jqyjdDK0,1925
-universal_mcp/agents/codeact0/tools.py,sha256=i2-WppqEfpJXPa7QouLfX3qXJgInBGVY9qxAGxFOUEg,14896
-universal_mcp/agents/codeact0/utils.py,sha256=F2aFnN0tNXbFfe8imO1iccHXTvWwSSulIbsrkwhhpno,21123
+universal_mcp/agents/codeact0/tools.py,sha256=e-ucTRkXuHEagEAWo2OPWh28UGeYlKzeNhi5cM7lqPc,15007
+universal_mcp/agents/codeact0/utils.py,sha256=a0ux1icTSB6ETIZ_X2azZxlP44LBx95bi7wchQWpnuY,18188
 universal_mcp/agents/shared/__main__.py,sha256=XxH5qGDpgFWfq7fwQfgKULXGiUgeTp_YKfcxftuVZq8,1452
 universal_mcp/agents/shared/prompts.py,sha256=yjP3zbbuKi87qCj21qwTTicz8TqtkKgnyGSeEjMu3ho,3761
 universal_mcp/agents/shared/tool_node.py,sha256=DC9F-Ri28Pam0u3sXWNODVgmj9PtAEUb5qP1qOoGgfs,9169
@@ -39,6 +39,6 @@ universal_mcp/applications/filesystem/app.py,sha256=0TRjjm8YnslVRSmfkXI7qQOAlqWl
 universal_mcp/applications/llm/__init__.py,sha256=_XGRxN3O1--ZS5joAsPf8IlI9Qa6negsJrwJ5VJXno0,46
 universal_mcp/applications/llm/app.py,sha256=4aMDlbBFCJIe_yzSq3Jphtk5ctvjWhHkHfSfnh3_Mso,12714
 universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
-universal_mcp_agents-0.1.23rc6.dist-info/METADATA,sha256=_BtR77yJ3U-Rtfl0JD6fpYJY8M5Q1TEgp_6M3AFT9dw,931
-universal_mcp_agents-0.1.23rc6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.23rc6.dist-info/RECORD,,
+universal_mcp_agents-0.1.23rc7.dist-info/METADATA,sha256=Up-hGsxUw2JH3vSa9FipSTF45ROWOMiySV0DItN4Cx8,931
+universal_mcp_agents-0.1.23rc7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.23rc7.dist-info/RECORD,,