universal-mcp-agents 0.1.23rc2__tar.gz → 0.1.23rc3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.23rc2
+Version: 0.1.23rc3
 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.23rc2 → universal_mcp_agents-0.1.23rc3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-agents"
-version = "0.1.23-rc2"
+version = "0.1.23-rc3"
 description = "Add your description here"
 readme = "README.md"
 authors = [

{universal_mcp_agents-0.1.23rc2 → universal_mcp_agents-0.1.23rc3}/src/universal_mcp/agents/base.py

@@ -66,9 +66,9 @@ class BaseAgent:
         ):
             if event == "messages" and isinstance(meta, (tuple, list)) and len(meta) == 2:
                 payload, meta_dict = meta
-                is_playbook = isinstance(meta_dict, dict) and meta_dict.get("langgraph_node") == "playbook"
+                is_agent_builder = isinstance(meta_dict, dict) and meta_dict.get("langgraph_node") == "agent_builder"
                 additional_kwargs = getattr(payload, "additional_kwargs", {}) or {}
-                if is_playbook and not additional_kwargs.get("stream"):
+                if is_agent_builder and not additional_kwargs.get("stream"):
                     continue
                 if isinstance(payload, AIMessageChunk):
                     last_ai_chunk = payload

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

@@ -16,16 +16,16 @@ 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_META_PROMPT,
-    PLAYBOOK_PLANNING_PROMPT,
+    AGENT_BUILDER_GENERATING_PROMPT,
+    AGENT_BUILDER_META_PROMPT,
+    AGENT_BUILDER_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, PlaybookMeta, PlaybookPlan
+from universal_mcp.agents.codeact0.state import CodeActState, AgentBuilderCode, AgentBuilderMeta, AgentBuilderPlan
 from universal_mcp.agents.codeact0.tools import (
     create_meta_tools,
-    enter_playbook_mode,
+    enter_agent_builder_mode,
     get_valid_tools,
 )
 from universal_mcp.agents.codeact0.utils import build_anthropic_cache_message, get_connected_apps_string
@@ -41,7 +41,7 @@ class CodeActPlaybookAgent(BaseAgent):
         model: str,
         memory: BaseCheckpointSaver | None = None,
         registry: ToolRegistry | None = None,
-        playbook_registry: object | None = None,
+        agent_builder_registry: object | None = None,
         sandbox_timeout: int = 20,
         **kwargs,
     ):
@@ -53,11 +53,11 @@ class CodeActPlaybookAgent(BaseAgent):
             **kwargs,
         )
         self.model_instance = load_chat_model(model)
-        self.playbook_model_instance = load_chat_model("azure/gpt-4.1")
+        self.agent_builder_model_instance = load_chat_model("azure/gpt-4.1")
         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.agent_builder_registry = agent_builder_registry
+        self.agent = agent_builder_registry.get_agent() if agent_builder_registry else None
+        self.tools_config = self.agent.tools if self.agent else {}
         self.eval_fn = eval_unsafe
         self.sandbox_timeout = sandbox_timeout
         self.default_tools_config = {
@@ -91,7 +91,7 @@ class CodeActPlaybookAgent(BaseAgent):
 
             agent_facing_tools = [
                 execute_ipython_cell,
-                enter_playbook_mode,
+                enter_agent_builder_mode,
                 meta_tools["search_functions"],
                 meta_tools["load_functions"],
             ]
@@ -120,7 +120,7 @@ class CodeActPlaybookAgent(BaseAgent):
             else:
                 return Command(update={"messages": [response], "model_with_tools": model_with_tools})
 
-        async def execute_tools(state: CodeActState) -> Command[Literal["call_model", "playbook"]]:
+        async def execute_tools(state: CodeActState) -> Command[Literal["call_model", "agent_builder"]]:
             """Execute tool calls"""
             last_message = state["messages"][-1]
             tool_calls = last_message.tool_calls if isinstance(last_message, AIMessage) else []
@@ -128,6 +128,8 @@ class CodeActPlaybookAgent(BaseAgent):
             tool_messages = []
             new_tool_ids = []
             tool_result = ""
+            ask_user = False
+            ai_msg = ""
             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}")
@@ -136,15 +138,15 @@ class CodeActPlaybookAgent(BaseAgent):
                 tool_name = tool_call["name"]
                 tool_args = tool_call["args"]
                 try:
-                    if tool_name == "enter_playbook_mode":
+                    if tool_name == "enter_agent_builder_mode":
                         tool_message = ToolMessage(
-                            content=json.dumps("Entered Playbook Mode."),
+                            content=json.dumps("Entered Agent Builder Mode."),
                             name=tool_call["name"],
                             tool_call_id=tool_call["id"],
                         )
                         return Command(
-                            goto="playbook",
-                            update={"playbook_mode": "planning", "messages": [tool_message]},  # Entered Playbook mode
+                            goto="agent_builder",
+                            update={"agent_builder_mode": "planning", "messages": [tool_message]},  # Entered Agent Builder mode
                         )
                     elif tool_name == "execute_ipython_cell":
                         code = tool_call["args"]["snippet"]
@@ -160,24 +162,21 @@ class CodeActPlaybookAgent(BaseAgent):
                         tool_result = output
                     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)
-
+                        tool_result, new_context_for_sandbox, valid_tools, unconnected_links = 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)
                         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)
+                        if unconnected_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 {unconnected_links} "
 
                     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']}. "
-                            "tool calls must be one of 'enter_playbook_mode', 'execute_ipython_cell', 'load_functions', or 'search_functions'. For using functions, call them in code using 'execute_ipython_cell'."
+                            "tool calls must be one of 'enter_agent_builder_mode', 'execute_ipython_cell', 'load_functions', or 'search_functions'. For using functions, call them in code using 'execute_ipython_cell'."
                         )
                 except Exception as e:
                     tool_result = str(e)
@@ -188,6 +187,17 @@ class CodeActPlaybookAgent(BaseAgent):
                     tool_call_id=tool_call["id"],
                 )
                 tool_messages.append(tool_message)
+            
+            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",
@@ -199,17 +209,17 @@ class CodeActPlaybookAgent(BaseAgent):
                 },
             )
 
-        def playbook(state: CodeActState, writer: StreamWriter) -> Command[Literal["call_model"]]:
-            playbook_mode = state.get("playbook_mode")
-            if playbook_mode == "planning":
+        def agent_builder(state: CodeActState, writer: StreamWriter) -> Command[Literal["call_model"]]:
+            agent_builder_mode = state.get("agent_builder_mode")
+            if agent_builder_mode == "planning":
                 plan_id = str(uuid.uuid4())
-                writer({"type": "custom", id: plan_id, "name": "planning", "data": {"update": bool(self.playbook)}})
-                planning_instructions = self.instructions + PLAYBOOK_PLANNING_PROMPT
+                writer({"type": "custom", id: plan_id, "name": "planning", "data": {"update": bool(self.agent)}})
+                planning_instructions = self.instructions + AGENT_BUILDER_PLANNING_PROMPT
                 messages = [{"role": "system", "content": planning_instructions}] + state["messages"]
 
-                model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookPlan)
+                model_with_structured_output = self.agent_builder_model_instance.with_structured_output(AgentBuilderPlan)
                 response = model_with_structured_output.invoke(messages)
-                plan = cast(PlaybookPlan, response)
+                plan = cast(AgentBuilderPlan, response)
 
                 writer({"type": "custom", id: plan_id, "name": "planning", "data": {"plan": plan.steps}})
                 return Command(
@@ -220,16 +230,16 @@ class CodeActPlaybookAgent(BaseAgent):
                                 additional_kwargs={
                                     "type": "planning",
                                     "plan": plan.steps,
-                                    "update": bool(self.playbook),
+                                    "update": bool(self.agent),
                                 },
                             )
                         ],
-                        "playbook_mode": "confirming",
+                        "agent_builder_mode": "confirming",
                         "plan": plan.steps,
                     }
                 )
 
-            elif playbook_mode == "confirming":
+            elif agent_builder_mode == "confirming":
                 # Deterministic routing based on three exact button inputs from UI
                 user_text = ""
                 for m in reversed(state["messages"]):
@@ -245,10 +255,10 @@ class CodeActPlaybookAgent(BaseAgent):
                 if t == "yes, this is great":
                     self.meta_id = str(uuid.uuid4())
                     name, description = None, None
-                    if self.playbook:
+                    if self.agent:
                         # Update flow: use existing name/description and do not re-generate
-                        name = getattr(self.playbook, "name", None)
-                        description = getattr(self.playbook, "description", None)
+                        name = getattr(self.agent, "name", None)
+                        description = getattr(self.agent, "description", None)
                         writer(
                             {
                                 "type": "custom",
@@ -264,12 +274,12 @@ class CodeActPlaybookAgent(BaseAgent):
                     else:
                         writer({"type": "custom", id: self.meta_id, "name": "generating", "data": {"update": False}})
 
-                        meta_instructions = self.instructions + PLAYBOOK_META_PROMPT
+                        meta_instructions = self.instructions + AGENT_BUILDER_META_PROMPT
                         messages = [{"role": "system", "content": meta_instructions}] + state["messages"]
 
-                        model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookMeta)
+                        model_with_structured_output = self.agent_builder_model_instance.with_structured_output(AgentBuilderMeta)
                         meta_response = model_with_structured_output.invoke(messages)
-                        meta = cast(PlaybookMeta, meta_response)
+                        meta = cast(AgentBuilderMeta, meta_response)
                         name, description = meta.name, meta.description
 
                         # Emit intermediary UI update with created name/description
@@ -283,11 +293,11 @@ class CodeActPlaybookAgent(BaseAgent):
                         )
 
                     return Command(
-                        goto="playbook",
+                        goto="agent_builder",
                         update={
-                            "playbook_mode": "generating",
-                            "playbook_name": name,
-                            "playbook_description": description,
+                            "agent_builder_mode": "generating",
+                            "agent_name": name,
+                            "agent_description": description,
                         },
                     )
                 if t == "i would like to modify the plan":
@@ -295,52 +305,51 @@ class CodeActPlaybookAgent(BaseAgent):
                         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]})
+                    return Command(update={"agent_builder_mode": "planning", "messages": [prompt_ai]})
                 if t == "let's do something else":
-                    return Command(goto="call_model", update={"playbook_mode": "inactive"})
+                    return Command(goto="call_model", update={"agent_builder_mode": "inactive"})
 
                 # Fallback safe default
-                return Command(goto="call_model", update={"playbook_mode": "inactive"})
+                return Command(goto="call_model", update={"agent_builder_mode": "inactive"})
 
-            elif playbook_mode == "generating":
-                generating_instructions = self.instructions + PLAYBOOK_GENERATING_PROMPT
+            elif agent_builder_mode == "generating":
+                generating_instructions = self.instructions + AGENT_BUILDER_GENERATING_PROMPT
                 messages = [{"role": "system", "content": generating_instructions}] + state["messages"]
 
-                model_with_structured_output = self.playbook_model_instance.with_structured_output(PlaybookCode)
+                model_with_structured_output = self.agent_builder_model_instance.with_structured_output(AgentBuilderCode)
                 response = model_with_structured_output.invoke(messages)
-                func_code = cast(PlaybookCode, response).code
+                func_code = cast(AgentBuilderCode, response).code
 
                 # Extract function name (handle both regular and async functions)
                 match = re.search(r"^\s*(?:async\s+)?def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(", func_code, re.MULTILINE)
                 if match:
                     function_name = match.group(1)
                 else:
-                    function_name = "generated_playbook"
+                    function_name = "generated_agent"
 
                 # Use generated metadata if available
-                final_name = state.get("playbook_.pyname") or function_name
-                final_description = state.get("playbook_description") or f"Generated playbook: {function_name}"
+                final_name = state.get("agent_name") or function_name
+                final_description = state.get("agent_description") or f"Generated agent: {function_name}"
 
                 # Save or update an Agent using the helper registry
                 try:
-                    if not self.playbook_registry:
-                        raise ValueError("Playbook registry is not configured")
+                    if not self.agent_builder_registry:
+                        raise ValueError("AgentBuilder registry is not configured")
 
                     # Build instructions payload embedding the plan and function code
                     instructions_payload = {
-                        "playbookPlan": state["plan"],
-                        "playbookScript": func_code,
+                        "plan": state["plan"],
+                        "script": func_code,
                     }
 
                     # Convert tool ids list to dict
                     tool_dict = convert_tool_ids_to_dict(state["selected_tool_ids"])
 
-                    res = self.playbook_registry.upsert_agent(
+                    res = self.agent_builder_registry.upsert_agent(
                         name=final_name,
                         description=final_description,
                         instructions=instructions_payload,
                         tools=tool_dict,
-                        visibility="private",
                     )
                 except Exception as e:
                     raise e
@@ -352,7 +361,7 @@ class CodeActPlaybookAgent(BaseAgent):
                         "name": "generating",
                         "data": {
                             "id": str(res.id),
-                            "update": bool(self.playbook),
+                            "update": bool(self.agent),
                             "name": final_name,
                             "description": final_description,
                         },
@@ -363,16 +372,16 @@ class CodeActPlaybookAgent(BaseAgent):
                     additional_kwargs={
                         "type": "generating",
                         "id": str(res.id),
-                        "update": bool(self.playbook),
+                        "update": bool(self.agent),
                         "name": final_name,
                         "description": final_description,
                     },
                 )
 
-                return Command(update={"messages": [mock_assistant_message], "playbook_mode": "normal"})
+                return Command(update={"messages": [mock_assistant_message], "agent_builder_mode": "normal"})
 
-        async def route_entry(state: CodeActState) -> Literal["call_model", "playbook"]:
-            """Route to either normal mode or playbook creation"""
+        async def route_entry(state: CodeActState) -> Literal["call_model", "agent_builder"]:
+            """Route to either normal mode or agent builder creation"""
             all_tools = await self.registry.export_tools(state["selected_tool_ids"], ToolFormat.LANGCHAIN)
             # print(all_tools)
 
@@ -382,16 +391,16 @@ class CodeActPlaybookAgent(BaseAgent):
                 self.additional_tools,
                 self.instructions,
                 await get_connected_apps_string(self.registry),
-                self.playbook,
+                self.agent,
                 is_initial_prompt=True,
             )
-            if state.get("playbook_mode") in ["planning", "confirming", "generating"]:
-                return "playbook"
+            if state.get("agent_builder_mode") in ["planning", "confirming", "generating"]:
+                return "agent_builder"
             return "call_model"
 
         agent = StateGraph(state_schema=CodeActState)
         agent.add_node(call_model, retry_policy=RetryPolicy(max_attempts=3, retry_on=filter_retry_on))
-        agent.add_node(playbook)
+        agent.add_node(agent_builder)
         agent.add_node(execute_tools)
         agent.add_conditional_edges(START, route_entry)
         return agent.compile(checkpointer=self.memory)

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

@@ -63,16 +63,16 @@ Rules:
 - 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.
 """
 
-PLAYBOOK_PLANNING_PROMPT = """Now, you are tasked with creating a reusable playbook from the user's previous workflow.
+AGENT_BUILDER_PLANNING_PROMPT = """Now, you are tasked with creating a reusable agent from the user's previous workflow.
 
 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 playbook.
+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 playbook function parameters using `variable_name` syntax. Intermediate variables should not be highlighted using ``
+2. Mark user-specific variables that should become the main agent function parameters using `variable_name` syntax. Intermediate variables should not be highlighted using ``
 3. Keep the logic generic and reusable
 4. Be clear and concise
 
@@ -90,26 +90,26 @@ Now create a plan based on the conversation history. Do not include any other te
 """
 
 
-PLAYBOOK_GENERATING_PROMPT = """Now, you are tasked with generating the playbook function.
+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 should be the same as the final confirmed playbook plan.
+The parameters of the function should be the same as the final confirmed agent plan.
 """
 
 
-PLAYBOOK_META_PROMPT = """
-You are preparing metadata for a reusable playbook based on the confirmed step-by-step plan.
+AGENT_BUILDER_META_PROMPT = """
+You are preparing metadata for a reusable agent based on the confirmed step-by-step plan.
 
-TASK: Create a concise, human-friendly name and a short description for the playbook.
+TASK: Create a concise, human-friendly name and a short description for the agent.
 
 INPUTS:
 - Conversation context and plan steps will be provided in prior messages
 
 REQUIREMENTS:
 1. Name: 3-6 words, Title Case, no punctuation except hyphens if needed
-2. Description: Single sentence, <= 140 characters, clearly states what the playbook does
+2. Description: Single sentence, <= 140 characters, clearly states what the agent does
 
 OUTPUT: Return ONLY a JSON object with exactly these keys:
 {
@@ -137,7 +137,7 @@ def create_default_prompt(
     additional_tools: Sequence[StructuredTool],
     base_prompt: str | None = None,
     apps_string: str | None = None,
-    playbook: object | None = None,
+    agent: object | None = None,
     is_initial_prompt: bool = False,
 ):
     if is_initial_prompt:
@@ -191,14 +191,14 @@ def create_default_prompt(
                 f"\n\nUse the following information/instructions while completing your tasks:\n\n{base_prompt}"
             )
 
-        # Append existing playbook (plan + code) if provided
+        # Append existing agent (plan + code) if provided
         try:
-            if playbook and hasattr(playbook, "instructions"):
-                pb = playbook.instructions or {}
-                plan = pb.get("playbookPlan")
-                code = pb.get("playbookScript")
+            if agent and hasattr(agent, "instructions"):
+                pb = agent.instructions or {}
+                plan = pb.get("plan")
+                code = pb.get("script")
                 if plan or code:
-                    system_prompt += "\n\nExisting Playbook Provided:\n"
+                    system_prompt += "\n\nExisting Agent Provided:\n"
                     if plan:
                         if isinstance(plan, list):
                             plan_block = "\n".join(f"- {str(s)}" for s in plan)

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

@@ -4,16 +4,16 @@ 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.")
+class AgentBuilderPlan(BaseModel):
+    steps: list[str] = Field(description="The steps of the agent.")
 
 
-class PlaybookCode(BaseModel):
-    code: str = Field(description="The Python code for the playbook.")
+class AgentBuilderCode(BaseModel):
+    code: str = Field(description="The Python code for the agent.")
 
 
-class PlaybookMeta(BaseModel):
-    name: str = Field(description="Concise, title-cased playbook name (3-6 words).")
+class AgentBuilderMeta(BaseModel):
+    name: str = Field(description="Concise, title-cased agent name (3-6 words).")
     description: str = Field(description="Short, one-sentence description (<= 140 chars).")
 
 
@@ -46,13 +46,13 @@ class CodeActState(AgentState):
     """Dictionary containing the execution context with available tools and variables."""
     add_context: dict[str, Any]
     """Dictionary containing the additional context (functions, classes, imports) to be added to the execution context."""
-    playbook_mode: str | None
-    """State for the playbook agent."""
+    agent_builder_mode: str | None
+    """State for the agent builder agent."""
     selected_tool_ids: Annotated[list[str], _enqueue]
     """Queue for tools exported from registry"""
     plan: list[str] | None
-    """Plan for the playbook agent."""
-    playbook_name: str | None
-    """Generated playbook name after confirmation."""
-    playbook_description: str | None
+    """Plan for the agent builder agent."""
+    agent_name: str | None
+    """Generated agent name after confirmation."""
+    agent_description: str | None
     """Generated short description after confirmation."""

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

@@ -11,8 +11,8 @@ 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."""
+def enter_agent_builder_mode():
+    """Call this function to enter agent builder mode. Agent builder mode is when the user wants to store a repeated task as a script with some inputs for the future."""
     return
 
 
@@ -212,21 +212,18 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
             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)
+        valid_tools, unconnected_links = await get_valid_tools(tool_ids=tool_ids, registry=tool_registry)
 
-        if not valid_tool_ids:
+        if not valid_tools:
             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}"
+        all_exported_tools = await tool_registry.export_tools(valid_tools, ToolFormat.LANGCHAIN)
+        exported_tools = [tool for tool in all_exported_tools if tool.name in valid_tools]
+
 
         # Step 3: Build the informational string for the agent.
-        tool_definitions, _ = create_default_prompt(exported_tools, [], is_initial_prompt=False)
+        tool_definitions, new_tools_context = 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`:",
@@ -234,15 +231,9 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
         ]
 
         response_string = "\n\n".join(result_parts)
+        unconnected_links = "\n".join(unconnected_links)
 
-        # 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
+        return response_string, new_tools_context, valid_tools, unconnected_links
 
     @tool
     async def web_search(query: str) -> dict:

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

@@ -4976,7 +4976,7 @@ wheels = [
 
 [[package]]
 name = "universal-mcp-agents"
-version = "0.1.23rc1"
+version = "0.1.23rc2"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-anthropic" },