universal-mcp-agents 0.1.22__tar.gz → 0.1.23rc2__tar.gz

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.22
+Version: 0.1.23rc2
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications
@@ -12,8 +12,8 @@ Requires-Dist: langchain-google-genai>=2.1.10
 Requires-Dist: langchain-openai>=0.3.32
 Requires-Dist: langgraph>=0.6.6
 Requires-Dist: typer>=0.17.4
-Requires-Dist: universal-mcp-applications>=0.1.24
-Requires-Dist: universal-mcp>=0.1.24rc25
+Requires-Dist: universal-mcp-applications>=0.1.25
+Requires-Dist: universal-mcp>=0.1.24rc26
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-agents"
-version = "0.1.22"
+version = "0.1.23-rc2"
 description = "Add your description here"
 readme = "README.md"
 authors = [
@@ -19,8 +19,8 @@ dependencies = [
     "langchain-openai>=0.3.32",
     "langgraph>=0.6.6",
     "typer>=0.17.4",
-    "universal-mcp>=0.1.24rc25",
-    "universal-mcp-applications>=0.1.24",
+    "universal-mcp>=0.1.24rc26",
+    "universal-mcp-applications>=0.1.25",
 ]
 
 [project.license]

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/src/universal_mcp/agents/__init__.py

@@ -9,7 +9,7 @@ from universal_mcp.agents.simple import SimpleAgent
 
 
 def get_agent(
-    agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-script", "codeact-repl"],
+    agent_name: Literal["react", "simple", "builder", "bigtool", "codeact-repl"],
 ):
     if agent_name == "react":
         return ReactAgent
@@ -23,7 +23,7 @@ def get_agent(
         return CodeActPlaybookAgent
     else:
         raise ValueError(
-            f"Unknown agent: {agent_name}. Possible values:  react, simple, builder, bigtool, codeact-script, codeact-repl"
+            f"Unknown agent: {agent_name}. Possible values:  react, simple, builder, bigtool, codeact-repl"
         )
 
 

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/src/universal_mcp/agents/cli.py

@@ -25,7 +25,7 @@ def run(name: str = "react"):
     client = AgentrClient()
     params = {
         "instructions": "You are a helpful assistant",
-        "model": "anthropic/claude-sonnet-4-20250514",
+        "model": "azure/gpt-4.1",
         "registry": AgentrRegistry(client=client),
         "memory": MemorySaver(),
     }

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/src/universal_mcp/agents/codeact0/__main__.py

@@ -13,15 +13,12 @@ async def main():
     agent = CodeActPlaybookAgent(
         name="CodeAct Agent",
         instructions="Be very concise in your answers.",
-        model="anthropic:claude-4-sonnet-20250514",
-        tools={"google_mail": ["list_messages"]},
+        model="azure/gpt-4.1",
         registry=AgentrRegistry(),
         memory=memory,
     )
     print("Starting agent...")
-    result = await agent.invoke(
-        user_input="Fetch unsubscribe links from my Gmail inbox for promo emails I have received in the last 7 days"
-    )
+    result = await agent.invoke(user_input="load all the tools of reddit which can be used to search subreddit")
     print(messages_to_list(result["messages"]))
 
 

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/src/universal_mcp/agents/codeact0/agent.py

@@ -1,35 +1,36 @@
+import copy
 import json
 import re
-from typing import Literal, cast
 import uuid
+from typing import Literal, cast
 
+from langchain_anthropic import ChatAnthropic
 from langchain_core.messages import AIMessage, ToolMessage
 from langchain_core.tools import StructuredTool
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import START, StateGraph
 from langgraph.types import Command, RetryPolicy, StreamWriter
 from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolConfig, ToolFormat
+from universal_mcp.types import ToolFormat
 
 from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.codeact0.llm_tool import smart_print
 from universal_mcp.agents.codeact0.prompts import (
     PLAYBOOK_GENERATING_PROMPT,
-    PLAYBOOK_PLANNING_PROMPT,
     PLAYBOOK_META_PROMPT,
+    PLAYBOOK_PLANNING_PROMPT,
     create_default_prompt,
 )
 from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell, handle_execute_ipython_cell
-from universal_mcp.agents.codeact0.state import CodeActState, PlaybookCode, PlaybookPlan, PlaybookMeta
+from universal_mcp.agents.codeact0.state import CodeActState, PlaybookCode, PlaybookMeta, PlaybookPlan
 from universal_mcp.agents.codeact0.tools import (
     create_meta_tools,
     enter_playbook_mode,
     get_valid_tools,
 )
-from universal_mcp.agents.codeact0.utils import add_tools
+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
-from universal_mcp.agents.codeact0.utils import get_connected_apps_string
 
 
 class CodeActPlaybookAgent(BaseAgent):
@@ -39,7 +40,6 @@ class CodeActPlaybookAgent(BaseAgent):
         instructions: str,
         model: str,
         memory: BaseCheckpointSaver | None = None,
-        tools: ToolConfig | None = None,
         registry: ToolRegistry | None = None,
         playbook_registry: object | None = None,
         sandbox_timeout: int = 20,
@@ -54,17 +54,18 @@ class CodeActPlaybookAgent(BaseAgent):
         )
         self.model_instance = load_chat_model(model)
         self.playbook_model_instance = load_chat_model("azure/gpt-4.1")
-        self.tools_config = tools or {}
         self.registry = registry
         self.playbook_registry = playbook_registry
         self.playbook = playbook_registry.get_agent() if playbook_registry else None
+        self.tools_config = self.playbook.tools if self.playbook else {}
         self.eval_fn = eval_unsafe
         self.sandbox_timeout = sandbox_timeout
-        self.default_tools = {
+        self.default_tools_config = {
             "llm": ["generate_text", "classify_data", "extract_data", "call_llm"],
         }
-        add_tools(self.tools_config, self.default_tools)
-
+        self.final_instructions = ""
+        self.tools_context = {}
+        self.exported_tools = []
 
     async def _build_graph(self):
         meta_tools = create_meta_tools(self.registry)
@@ -72,28 +73,47 @@ class CodeActPlaybookAgent(BaseAgent):
         self.additional_tools = [
             t if isinstance(t, StructuredTool) else StructuredTool.from_function(t) for t in additional_tools
         ]
+
         if self.tools_config:
-            # Convert dict format to list format if needed
             if isinstance(self.tools_config, dict):
                 self.tools_config = [
                     f"{provider}__{tool}" for provider, tools in self.tools_config.items() for tool in tools
                 ]
-            if not self.registry:
-                raise ValueError("Tools are configured but no registry is provided")
+                if not self.registry:
+                    raise ValueError("Tools are configured but no registry is provided")
+            await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
+
+        await self.registry.export_tools(self.default_tools_config, ToolFormat.LANGCHAIN)
 
         async def call_model(state: CodeActState) -> Command[Literal["execute_tools"]]:
-            messages = [{"role": "system", "content": self.final_instructions}] + state["messages"]
-
-            # Run the model and potentially loop for reflection
-            model_with_tools = self.model_instance.bind_tools(
-                tools=[
-                    execute_ipython_cell,
-                    enter_playbook_mode,
-                    meta_tools["search_functions"],
-                    meta_tools["load_functions"],
-                ],
-                tool_choice="auto",
-            )
+            """This node now only ever binds the four meta-tools to the LLM."""
+            messages = build_anthropic_cache_message(self.final_instructions) + state["messages"]
+
+            agent_facing_tools = [
+                execute_ipython_cell,
+                enter_playbook_mode,
+                meta_tools["search_functions"],
+                meta_tools["load_functions"],
+            ]
+
+            if isinstance(self.model_instance, ChatAnthropic):
+                model_with_tools = self.model_instance.bind_tools(
+                    tools=agent_facing_tools,
+                    tool_choice="auto",
+                    cache_control={"type": "ephemeral", "ttl": "1h"},
+                )
+                if isinstance(messages[-1].content, str):
+                    pass
+                else:
+                    last = copy.deepcopy(messages[-1])
+                    last.content[-1]["cache_control"] = {"type": "ephemeral", "ttl": "5m"}
+                    messages[-1] = last
+            else:
+                model_with_tools = self.model_instance.bind_tools(
+                    tools=agent_facing_tools,
+                    tool_choice="auto",
+                )
+
             response = cast(AIMessage, model_with_tools.invoke(messages))
             if response.tool_calls:
                 return Command(goto="execute_tools", update={"messages": [response]})
@@ -107,15 +127,16 @@ class CodeActPlaybookAgent(BaseAgent):
 
             tool_messages = []
             new_tool_ids = []
-            ask_user = False
-            ai_msg = ""
             tool_result = ""
             effective_previous_add_context = state.get("add_context", {})
             effective_existing_context = state.get("context", {})
+            # logging.info(f"Initial new_tool_ids_for_context: {new_tool_ids_for_context}")
 
             for tool_call in tool_calls:
+                tool_name = tool_call["name"]
+                tool_args = tool_call["args"]
                 try:
-                    if tool_call["name"] == "enter_playbook_mode":
+                    if tool_name == "enter_playbook_mode":
                         tool_message = ToolMessage(
                             content=json.dumps("Entered Playbook Mode."),
                             name=tool_call["name"],
@@ -125,11 +146,11 @@ class CodeActPlaybookAgent(BaseAgent):
                             goto="playbook",
                             update={"playbook_mode": "planning", "messages": [tool_message]},  # Entered Playbook mode
                         )
-                    elif tool_call["name"] == "execute_ipython_cell":
+                    elif tool_name == "execute_ipython_cell":
                         code = tool_call["args"]["snippet"]
                         output, new_context, new_add_context = await handle_execute_ipython_cell(
                             code,
-                            self.tools_context,
+                            self.tools_context,  # Uses the dynamically updated context
                             self.eval_fn,
                             effective_previous_add_context,
                             effective_existing_context,
@@ -137,19 +158,22 @@ class CodeActPlaybookAgent(BaseAgent):
                         effective_existing_context = new_context
                         effective_previous_add_context = new_add_context
                         tool_result = output
-                    elif tool_call["name"] == "load_functions":  # Handle load_functions separately
-                        valid_tools, unconnected_links = await get_valid_tools(
-                            tool_ids=tool_call["args"]["tool_ids"], registry=self.registry
-                        )
+                    elif tool_name == "load_functions":
+                        # The tool now does all the work of validation and formatting.
+                        tool_result = await meta_tools["load_functions"].ainvoke(tool_args)
+
+                        # We still need to update the sandbox context for `execute_ipython_cell`
+                        valid_tools, _ = await get_valid_tools(tool_ids=tool_args["tool_ids"], registry=self.registry)
                         new_tool_ids.extend(valid_tools)
-                        # Create tool message response
-                        tool_result = f"Successfully loaded {len(valid_tools)} tools: {valid_tools}"
-                        links = "\n".join(unconnected_links)
-                        if links:
-                            ask_user = True
-                            ai_msg = f"Please login to the following app(s) using the following links and let me know in order to proceed:\n {links} "
-                    elif tool_call["name"] == "search_functions":
-                        tool_result = await meta_tools["search_functions"].ainvoke(tool_call["args"])
+                        if new_tool_ids:
+                            newly_exported = await self.registry.export_tools(new_tool_ids, ToolFormat.LANGCHAIN)
+                            _, new_context_for_sandbox = create_default_prompt(
+                                newly_exported, [], "", "", None
+                            )  # is_initial_prompt is False by default
+                            self.tools_context.update(new_context_for_sandbox)
+
+                    elif tool_name == "search_functions":
+                        tool_result = await meta_tools["search_functions"].ainvoke(tool_args)
                     else:
                         raise Exception(
                             f"Unexpected tool call: {tool_call['name']}. "
@@ -165,23 +189,6 @@ class CodeActPlaybookAgent(BaseAgent):
                 )
                 tool_messages.append(tool_message)
 
-            if new_tool_ids:
-                self.tools_config.extend(new_tool_ids)
-                self.exported_tools = await self.registry.export_tools(new_tool_ids, ToolFormat.LANGCHAIN)
-                self.final_instructions, self.tools_context = create_default_prompt(
-                    self.exported_tools, self.additional_tools, self.instructions, await get_connected_apps_string(self.registry)
-                )
-            if ask_user:
-                tool_messages.append(AIMessage(content=ai_msg))
-                return Command(
-                    update={
-                        "messages": tool_messages,
-                        "selected_tool_ids": new_tool_ids,
-                        "context": effective_existing_context,
-                        "add_context": effective_previous_add_context,
-                    }
-                )
-
             return Command(
                 goto="call_model",
                 update={
@@ -196,21 +203,31 @@ class CodeActPlaybookAgent(BaseAgent):
             playbook_mode = state.get("playbook_mode")
             if playbook_mode == "planning":
                 plan_id = str(uuid.uuid4())
-                writer({
-                    "type": "custom",
-                    id: plan_id,
-                    "name": "planning",
-                    "data": {"update": bool(self.playbook)}
-                })
+                writer({"type": "custom", id: plan_id, "name": "planning", "data": {"update": bool(self.playbook)}})
                 planning_instructions = self.instructions + PLAYBOOK_PLANNING_PROMPT
                 messages = [{"role": "system", "content": planning_instructions}] + state["messages"]
 
                 model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookPlan)
                 response = model_with_structured_output.invoke(messages)
                 plan = cast(PlaybookPlan, response)
-                
+
                 writer({"type": "custom", id: plan_id, "name": "planning", "data": {"plan": plan.steps}})
-                return Command(update={"messages": [AIMessage(content=json.dumps(plan.dict()), additional_kwargs={"type": "planning", "plan": plan.steps, "update": bool(self.playbook)})], "playbook_mode": "confirming", "plan": plan.steps})
+                return Command(
+                    update={
+                        "messages": [
+                            AIMessage(
+                                content=json.dumps(plan.model_dump()),
+                                additional_kwargs={
+                                    "type": "planning",
+                                    "plan": plan.steps,
+                                    "update": bool(self.playbook),
+                                },
+                            )
+                        ],
+                        "playbook_mode": "confirming",
+                        "plan": plan.steps,
+                    }
+                )
 
             elif playbook_mode == "confirming":
                 # Deterministic routing based on three exact button inputs from UI
@@ -226,25 +243,58 @@ class CodeActPlaybookAgent(BaseAgent):
 
                 t = user_text.lower()
                 if t == "yes, this is great":
-                    # Generate playbook metadata (name and description) before moving to generation
-                    meta_id = str(uuid.uuid4())
-                    writer({
-                        "type": "custom",
-                        id: meta_id,
-                        "name": "metadata",
-                        "data": {"update": bool(self.playbook)}
-                    })
-                    meta_instructions = self.instructions + PLAYBOOK_META_PROMPT
-                    messages = [{"role": "system", "content": meta_instructions}] + state["messages"]
-
-                    model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookMeta)
-                    meta_response = model_with_structured_output.invoke(messages)
-                    meta = cast(PlaybookMeta, meta_response)
-
-                    writer({"type": "custom", id: meta_id, "name": "metadata", "data": {"name": meta.name, "description": meta.description}})
-                    return Command(goto="playbook", update={"playbook_mode": "generating", "playbook_name": meta.name, "playbook_description": meta.description})
+                    self.meta_id = str(uuid.uuid4())
+                    name, description = None, None
+                    if self.playbook:
+                        # Update flow: use existing name/description and do not re-generate
+                        name = getattr(self.playbook, "name", None)
+                        description = getattr(self.playbook, "description", None)
+                        writer(
+                            {
+                                "type": "custom",
+                                id: self.meta_id,
+                                "name": "generating",
+                                "data": {
+                                    "update": True,
+                                    "name": name,
+                                    "description": description,
+                                },
+                            }
+                        )
+                    else:
+                        writer({"type": "custom", id: self.meta_id, "name": "generating", "data": {"update": False}})
+
+                        meta_instructions = self.instructions + PLAYBOOK_META_PROMPT
+                        messages = [{"role": "system", "content": meta_instructions}] + state["messages"]
+
+                        model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookMeta)
+                        meta_response = model_with_structured_output.invoke(messages)
+                        meta = cast(PlaybookMeta, meta_response)
+                        name, description = meta.name, meta.description
+
+                        # Emit intermediary UI update with created name/description
+                        writer(
+                            {
+                                "type": "custom",
+                                id: self.meta_id,
+                                "name": "generating",
+                                "data": {"update": False, "name": name, "description": description},
+                            }
+                        )
+
+                    return Command(
+                        goto="playbook",
+                        update={
+                            "playbook_mode": "generating",
+                            "playbook_name": name,
+                            "playbook_description": description,
+                        },
+                    )
                 if t == "i would like to modify the plan":
-                    prompt_ai = AIMessage(content="What would you like to change about the plan? Let me know and I'll update the plan accordingly.", additional_kwargs={"stream": "true"})
+                    prompt_ai = AIMessage(
+                        content="What would you like to change about the plan? Let me know and I'll update the plan accordingly.",
+                        additional_kwargs={"stream": "true"},
+                    )
                     return Command(update={"playbook_mode": "planning", "messages": [prompt_ai]})
                 if t == "let's do something else":
                     return Command(goto="call_model", update={"playbook_mode": "inactive"})
@@ -253,16 +303,9 @@ class CodeActPlaybookAgent(BaseAgent):
                 return Command(goto="call_model", update={"playbook_mode": "inactive"})
 
             elif playbook_mode == "generating":
-                generate_id = str(uuid.uuid4())
-                writer({
-                    "type": "custom",
-                    id: generate_id,
-                    "name": "generating",
-                    "data": {"update": bool(self.playbook)}
-                })
                 generating_instructions = self.instructions + PLAYBOOK_GENERATING_PROMPT
                 messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
-                
+
                 model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookCode)
                 response = model_with_structured_output.invoke(messages)
                 func_code = cast(PlaybookCode, response).code
@@ -275,12 +318,12 @@ class CodeActPlaybookAgent(BaseAgent):
                     function_name = "generated_playbook"
 
                 # Use generated metadata if available
-                final_name = state.get("playbook_name") or function_name
+                final_name = state.get("playbook_.pyname") or function_name
                 final_description = state.get("playbook_description") or f"Generated playbook: {function_name}"
 
                 # Save or update an Agent using the helper registry
                 try:
-                    if not self.playbook_registry:  
+                    if not self.playbook_registry:
                         raise ValueError("Playbook registry is not configured")
 
                     # Build instructions payload embedding the plan and function code
@@ -302,25 +345,45 @@ class CodeActPlaybookAgent(BaseAgent):
                 except Exception as e:
                     raise e
 
-                writer({
-                    "type": "custom",
-                    id: generate_id,
-                    "name": "generating",
-                    "data": {"id": str(res.id), "update": bool(self.playbook)}
-                })
-                mock_assistant_message = AIMessage(content=json.dumps(response.dict()), additional_kwargs={"type": "generating", "id": str(res.id), "update": bool(self.playbook)})
-
-                return Command(
-                    update={"messages": [mock_assistant_message], "playbook_mode": "normal"}
+                writer(
+                    {
+                        "type": "custom",
+                        id: self.meta_id,
+                        "name": "generating",
+                        "data": {
+                            "id": str(res.id),
+                            "update": bool(self.playbook),
+                            "name": final_name,
+                            "description": final_description,
+                        },
+                    }
+                )
+                mock_assistant_message = AIMessage(
+                    content=json.dumps(response.model_dump()),
+                    additional_kwargs={
+                        "type": "generating",
+                        "id": str(res.id),
+                        "update": bool(self.playbook),
+                        "name": final_name,
+                        "description": final_description,
+                    },
                 )
 
+                return Command(update={"messages": [mock_assistant_message], "playbook_mode": "normal"})
+
         async def route_entry(state: CodeActState) -> Literal["call_model", "playbook"]:
             """Route to either normal mode or playbook creation"""
-            self.exported_tools = []
-            self.tools_config.extend(state.get("selected_tool_ids", []))
-            self.exported_tools = await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
+            all_tools = await self.registry.export_tools(state["selected_tool_ids"], ToolFormat.LANGCHAIN)
+            # print(all_tools)
+
+            # Create the initial system prompt and tools_context in one go
             self.final_instructions, self.tools_context = create_default_prompt(
-                self.exported_tools, self.additional_tools, self.instructions, await get_connected_apps_string(self.registry)
+                all_tools,
+                self.additional_tools,
+                self.instructions,
+                await get_connected_apps_string(self.registry),
+                self.playbook,
+                is_initial_prompt=True,
             )
             if state.get("playbook_mode") in ["planning", "confirming", "generating"]:
                 return "playbook"
@@ -331,5 +394,4 @@ class CodeActPlaybookAgent(BaseAgent):
         agent.add_node(playbook)
         agent.add_node(execute_tools)
         agent.add_conditional_edges(START, route_entry)
-        # agent.add_edge(START, "call_model")
         return agent.compile(checkpointer=self.memory)

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/src/universal_mcp/agents/codeact0/prompts.py

@@ -3,6 +3,7 @@ import re
 from collections.abc import Sequence
 
 from langchain_core.tools import StructuredTool
+
 from universal_mcp.agents.codeact0.utils import schema_to_signature
 
 uneditable_prompt = """
@@ -137,13 +138,20 @@ def create_default_prompt(
     base_prompt: str | None = None,
     apps_string: str | None = None,
     playbook: object | None = None,
+    is_initial_prompt: bool = False,
 ):
-    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 += "\n\nIn addition to the Python Standard Library, you can use the following external functions:\n"
-    
+    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 += (
+            "\n\nIn addition to the Python Standard Library, you can use the following external functions:\n"
+        )
+    else:
+        system_prompt = ""
+
     tools_context = {}
+    tool_definitions = []
 
     for tool in tools:
         if hasattr(tool, "func") and tool.func is not None:
@@ -152,10 +160,11 @@ def create_default_prompt(
         elif hasattr(tool, "coroutine") and tool.coroutine is not None:
             tool_callable = tool.coroutine
             is_async = True
-        system_prompt += f'''{"async " if is_async else ""}{schema_to_signature(tool.args, tool.name)}:
+        tool_definitions.append(
+            f'''{"async " if is_async else ""}{schema_to_signature(tool.args, tool.name)}:
     """{tool.description}"""
-    ...
-'''
+    ...'''
+        )
         safe_name = make_safe_function_name(tool.name)
         tools_context[safe_name] = tool_callable
 
@@ -166,34 +175,40 @@ def create_default_prompt(
         elif hasattr(tool, "coroutine") and tool.coroutine is not None:
             tool_callable = tool.coroutine
             is_async = True
-        system_prompt += f'''{"async " if is_async else ""}def {tool.name} {str(inspect.signature(tool_callable))}:
+        tool_definitions.append(
+            f'''{"async " if is_async else ""}def {tool.name} {str(inspect.signature(tool_callable))}:
     """{tool.description}"""
-    ...
-'''
+    ...'''
+        )
         safe_name = make_safe_function_name(tool.name)
         tools_context[safe_name] = tool_callable
 
-    if base_prompt and base_prompt.strip():
-        system_prompt += f"Your goal is to perform the following task:\n\n{base_prompt}"
-
-    # Append existing playbook (plan + code) if provided
-    try:
-        if playbook and hasattr(playbook, "instructions"):
-            pb = playbook.instructions or {}
-            plan = pb.get("playbookPlan")
-            code = pb.get("playbookScript")
-            if plan or code:
-                system_prompt += "\n\nExisting Playbook Provided:\n"
-                if plan:
-                    if isinstance(plan, list):
-                        plan_block = "\n".join(f"- {str(s)}" for s in plan)
-                    else:
-                        plan_block = str(plan)
-                    system_prompt += f"Plan Steps:\n{plan_block}\n"
-                if code:
-                    system_prompt += f"\nScript:\n```python\n{str(code)}\n```\n"
-    except Exception:
-        # Silently ignore formatting issues
-        pass
+    system_prompt += "\n".join(tool_definitions)
+
+    if is_initial_prompt:
+        if base_prompt and base_prompt.strip():
+            system_prompt += (
+                f"\n\nUse the following information/instructions while completing your tasks:\n\n{base_prompt}"
+            )
+
+        # Append existing playbook (plan + code) if provided
+        try:
+            if playbook and hasattr(playbook, "instructions"):
+                pb = playbook.instructions or {}
+                plan = pb.get("playbookPlan")
+                code = pb.get("playbookScript")
+                if plan or code:
+                    system_prompt += "\n\nExisting Playbook Provided:\n"
+                    if plan:
+                        if isinstance(plan, list):
+                            plan_block = "\n".join(f"- {str(s)}" for s in plan)
+                        else:
+                            plan_block = str(plan)
+                        system_prompt += f"Plan Steps:\n{plan_block}\n"
+                    if code:
+                        system_prompt += f"\nScript:\n```python\n{str(code)}\n```\n"
+        except Exception:
+            # Silently ignore formatting issues
+            pass
 
     return system_prompt, tools_context

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/src/universal_mcp/agents/codeact0/state.py

@@ -1,11 +1,11 @@
-from typing import Annotated, Any, List
+from typing import Annotated, Any
 
 from langgraph.prebuilt.chat_agent_executor import AgentState
 from pydantic import BaseModel, Field
 
 
 class PlaybookPlan(BaseModel):
-    steps: List[str] = Field(description="The steps of the playbook.")
+    steps: list[str] = Field(description="The steps of the playbook.")
 
 
 class PlaybookCode(BaseModel):

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/src/universal_mcp/agents/codeact0/tools.py

@@ -4,22 +4,18 @@ from collections import defaultdict
 from typing import Annotated, Any
 
 from langchain_core.tools import tool
-from loguru import logger
 from pydantic import Field
 from universal_mcp.agentr.registry import AgentrRegistry
 from universal_mcp.types import ToolFormat
 
+from universal_mcp.agents.codeact0.prompts import create_default_prompt
+
 
 def enter_playbook_mode():
     """Call this function to enter playbook mode. Playbook mode is when the user wants to store a repeated task as a script with some inputs for the future."""
     return
 
 
-def exit_playbook_mode():
-    """Call this function to exit playbook mode. Playbook mode is when the user wants to store a repeated task as a script with some inputs for the future."""
-    return
-
-
 def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
     """Create the meta tools for searching and loading tools"""
 
@@ -105,7 +101,9 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
                 prioritized_app_id_list = [canonical_app_id]
             else:
                 # 1. Perform an initial broad search for tools.
-                initial_tool_search_tasks = [registry.search_tools(query=q, distance_threshold=THRESHOLD) for q in queries]
+                initial_tool_search_tasks = [
+                    registry.search_tools(query=q, distance_threshold=THRESHOLD) for q in queries
+                ]
                 initial_tool_results = await asyncio.gather(*initial_tool_search_tasks)
 
                 # 2. Search for relevant apps.
@@ -198,15 +196,53 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
 
     @tool
     async def load_functions(tool_ids: list[str]) -> str:
-        """Load specific functions by their IDs for use in subsequent steps.
+        """
+        Loads specified functions and returns their Python signatures and docstrings.
+        This makes the functions available for use inside the 'execute_ipython_cell' tool.
+        The agent MUST use the returned information to understand how to call the functions correctly.
 
         Args:
-            tool_ids: Function ids in the form 'app__function'. Example: 'google_mail__send_email'
+            tool_ids: A list of function IDs in the format 'app__function'. Example: ['google_mail__send_email']
 
         Returns:
-            Confirmation message about loaded functions
+            A string containing the signatures and docstrings of the successfully loaded functions,
+            ready for the agent to use in its code.
         """
-        return f"Successfully loaded {len(tool_ids)} functions: {tool_ids}"
+        if not tool_ids:
+            return "No tool IDs provided to load."
+
+        # Step 1: Validate which tools are usable and get login links for others.
+        valid_tool_ids, unconnected_links = await get_valid_tools(tool_ids=tool_ids, registry=tool_registry)
+
+        if not valid_tool_ids:
+            return "Error: None of the provided tool IDs could be validated or loaded."
+
+        # Step 2: Export the schemas of the valid tools.
+        try:
+            # Create a temporary, clean registry to export only the requested tools
+            temp_registry = AgentrRegistry()
+            exported_tools = await temp_registry.export_tools(valid_tool_ids, ToolFormat.LANGCHAIN)
+        except Exception as e:
+            return f"Error exporting tools: {e}"
+
+        # Step 3: Build the informational string for the agent.
+        tool_definitions, _ = create_default_prompt(exported_tools, [], is_initial_prompt=False)
+
+        result_parts = [
+            f"Successfully loaded {len(exported_tools)} functions. They are now available for use inside `execute_ipython_cell`:",
+            tool_definitions,
+        ]
+
+        response_string = "\n\n".join(result_parts)
+
+        # Append login links if any apps were not connected
+        if unconnected_links:
+            links = "\n".join(unconnected_links)
+            response_string += (
+                f"\n\nPlease ask the user to log in to the following app(s) to use their full functionality:\n{links}"
+            )
+
+        return response_string
 
     @tool
     async def web_search(query: str) -> dict:

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/src/universal_mcp/agents/codeact0/utils.py

@@ -10,6 +10,26 @@ from universal_mcp.types import ToolConfig
 MAX_CHARS = 5000
 
 
+def build_anthropic_cache_message(text: str, role: str = "system", ttl: str = "1h") -> list[dict[str, Any]]:
+    """Build a complete Anthropic cache messages array from text.
+
+    Returns a list with a single cache message whose content is the
+    cached Anthropic content array with ephemeral cache control and TTL.
+    """
+    return [
+        {
+            "role": role,
+            "content": [
+                {
+                    "type": "text",
+                    "text": text,
+                    "cache_control": {"type": "ephemeral", "ttl": ttl},
+                }
+            ],
+        }
+    ]
+
+
 def add_tools(tool_config: ToolConfig, tools_to_add: ToolConfig):
     for app_id, new_tools in tools_to_add.items():
         all_tools = tool_config.get(app_id, []) + new_tools
@@ -375,6 +395,7 @@ def schema_to_signature(schema: dict, func_name: str = "my_function") -> str:
     param_str = ",\n    ".join(params)
     return f"def {func_name}(\n    {param_str},\n):"
 
+
 def smart_truncate(
     output: str, max_chars_full: int = 2000, max_lines_headtail: int = 20, summary_threshold: int = 10000
 ) -> str:
@@ -413,21 +434,21 @@ async def get_connected_apps_string(registry) -> str:
     """Get a formatted string of connected applications from the registry."""
     if not registry:
         return ""
-    
+
     try:
         # Get connected apps from registry
         connections = await registry.list_connected_apps()
         if not connections:
             return "No applications are currently connected."
-        
+
         # Extract app names from connections
         connected_app_ids = {connection["app_id"] for connection in connections}
-        
+
         # Format the apps list
         apps_list = []
         for app_id in connected_app_ids:
             apps_list.append(f"- {app_id}")
-        
+
         return "\n".join(apps_list)
     except Exception:
-        return "Unable to retrieve connected applications."
+        return "Unable to retrieve connected applications."

{universal_mcp_agents-0.1.22 → universal_mcp_agents-0.1.23rc2}/uv.lock

@@ -4976,7 +4976,7 @@ wheels = [
 
 [[package]]
 name = "universal-mcp-agents"
-version = "0.1.21"
+version = "0.1.23rc1"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-anthropic" },
@@ -5016,8 +5016,8 @@ requires-dist = [
     { name = "pytest-cov", marker = "extra == 'test'" },
     { name = "ruff", marker = "extra == 'dev'" },
     { name = "typer", specifier = ">=0.17.4" },
-    { name = "universal-mcp", specifier = ">=0.1.24rc25" },
-    { name = "universal-mcp-applications", specifier = ">=0.1.24" },
+    { name = "universal-mcp", specifier = ">=0.1.24rc26" },
+    { name = "universal-mcp-applications", specifier = ">=0.1.25" },
 ]
 provides-extras = ["test", "dev"]
 

universal_mcp_agents-0.1.22/bech.py

@@ -1,38 +0,0 @@
-from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.agents import get_agent
-from langgraph.checkpoint.memory import MemorySaver
-from universal_mcp.agents.utils import messages_to_list
-import time
-from loguru import logger
-
-
-async def main():
-    start_time = time.time()
-    memory = MemorySaver()
-    logger.info(f"Checkpointer: Time consumed: {time.time() - start_time}")
-    agent_cls = get_agent("codeact-repl")
-    logger.info(f"Get class: Time consumed: {time.time() - start_time}")
-    registry = AgentrRegistry()
-    logger.info(f"Init Registry: Time consumed: {time.time() - start_time}")
-    agent = agent_cls(
-        name="CodeAct Agent",
-        instructions="Be very concise in your answers.",
-        model="anthropic:claude-4-sonnet-20250514",
-        tools={},
-        registry=registry,
-        memory=memory,
-    )
-    logger.info(f"Create agent: Time consumed: {time.time() - start_time}")
-    print("Init agent...")
-    await agent.ainit()
-    logger.info(f"Init Agent: Time consumed: {time.time() - start_time}")
-    print("Starting agent...")
-    async for e in agent.stream(user_input="hi"):
-        logger.info(f"First token: Time consumed: {time.time() - start_time}")
-        print(e)
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    asyncio.run(main())