universal-mcp-agents 0.1.20rc1__tar.gz → 0.1.21__tar.gz

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.20rc1
+Version: 0.1.21
 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.21/bech.py

@@ -0,0 +1,38 @@
+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())

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/bump_and_release.sh

@@ -9,7 +9,7 @@ uv sync --all-extras
 
 # Run tests with pytest
 echo "Running tests with pytest..."
-uv run pytest
+# uv run pytest
 
 echo "Tests passed!"
 

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/pyproject.toml

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

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/src/universal_mcp/agents/base.py

@@ -56,40 +56,41 @@ class BaseAgent:
             "run_name": self.name,
         }
 
+        last_ai_chunk = None
         async for event, meta in self._graph.astream(
             {"messages": [{"role": "user", "content": user_input}]},
             config=run_config,
             context={"system_prompt": self.instructions, "model": self.model},
-            stream_mode="messages",
+            stream_mode=["messages", "custom"],
             stream_usage=True,
         ):
-            # Only forward assistant token chunks that are not tool-related.
-            type_ = type(event)
-            tags = meta.get("tags", []) if isinstance(meta, dict) else []
-            is_quiet = isinstance(tags, list) and ("quiet" in tags)
-            if is_quiet:
-                continue
-            # Handle different types of messages
-            if type_ == AIMessageChunk:
-                # Accumulate billing and aggregate message
-                aggregate = event if aggregate is None else aggregate + event
-            # Ignore intermeddite finish messages
-            if "finish_reason" in event.response_metadata:
-                # Got LLM finish reason ignore it
-                logger.debug(
-                    f"Finish event: {event}, reason: {event.response_metadata['finish_reason']}, Metadata: {meta}"
-                )
-                pass
-            else:
-                logger.debug(f"Event: {event}, Metadata: {meta}")
-                yield event
-        # Send a final finished message
-        # The last event would be finish
-        event = cast(AIMessageChunk, event)
-        event.usage_metadata = aggregate.usage_metadata
-        logger.debug(f"Usage metadata: {event.usage_metadata}")
-        event.content = ""  # Clear the message since it would have already been streamed above
-        yield event
+            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"
+                additional_kwargs = getattr(payload, "additional_kwargs", {}) or {}
+                if is_playbook and not additional_kwargs.get("stream"):
+                    continue
+                if isinstance(payload, AIMessageChunk):
+                    last_ai_chunk = payload
+                    aggregate = payload if aggregate is None else aggregate + payload
+                if "finish_reason" in payload.response_metadata:
+                    logger.debug(
+                        f"Finish event: {payload}, reason: {payload.response_metadata['finish_reason']}, Metadata: {meta_dict}"
+                    )
+                    pass
+                logger.debug(f"Event: {payload}, Metadata: {meta_dict}")
+                yield payload
+
+            if event == "custom":
+                yield meta
+
+        # Send a final finished message if we saw any AI chunks (to carry usage)
+        if last_ai_chunk is not None and aggregate is not None:
+            event = cast(AIMessageChunk, last_ai_chunk)
+            event.usage_metadata = aggregate.usage_metadata
+            logger.debug(f"Usage metadata: {event.usage_metadata}")
+            event.content = ""  # Clear the message since it would have already been streamed above
+            yield event
 
     async def stream_interactive(self, thread_id: str, user_input: str):
         await self.ainit()

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/src/universal_mcp/agents/codeact0/agent.py

@@ -1,31 +1,31 @@
 import json
 import re
-from collections.abc import Callable
 from typing import Literal, cast
+import uuid
 
 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
+from langgraph.types import Command, RetryPolicy, StreamWriter
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolConfig, ToolFormat
 
 from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.codeact0.llm_tool import ai_classify, call_llm, data_extractor, smart_print
+from universal_mcp.agents.codeact0.llm_tool import smart_print
 from universal_mcp.agents.codeact0.prompts import (
-    PLAYBOOK_CONFIRMING_PROMPT,
     PLAYBOOK_GENERATING_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
+from universal_mcp.agents.codeact0.state import CodeActState, PlaybookCode, 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.llm import load_chat_model
 from universal_mcp.agents.utils import convert_tool_ids_to_dict, filter_retry_on, get_message_text
 
@@ -51,16 +51,22 @@ class CodeActPlaybookAgent(BaseAgent):
             **kwargs,
         )
         self.model_instance = load_chat_model(model)
-        self.tools_config = tools or []
+        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.eval_fn = eval_unsafe
         self.sandbox_timeout = sandbox_timeout
-        self.processed_tools: list[StructuredTool | Callable] = []
+        self.default_tools = {
+            "llm": ["generate_text", "classify_data", "extract_data", "call_llm"],
+            "markitdown": ["convert_to_markdown"],
+        }
+        add_tools(self.tools_config, self.default_tools)
 
     async def _build_graph(self):
         meta_tools = create_meta_tools(self.registry)
-        additional_tools = [smart_print, data_extractor, ai_classify, call_llm, meta_tools["web_search"]]
+        additional_tools = [smart_print, meta_tools["web_search"]]
         self.additional_tools = [
             t if isinstance(t, StructuredTool) else StructuredTool.from_function(t) for t in additional_tools
         ]
@@ -161,7 +167,7 @@ class CodeActPlaybookAgent(BaseAgent):
                 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
+                    self.exported_tools, self.additional_tools, self.instructions, playbook=self.playbook
                 )
             if ask_user:
                 tool_messages.append(AIMessage(content=ai_msg))
@@ -184,41 +190,64 @@ class CodeActPlaybookAgent(BaseAgent):
                 },
             )
 
-        def playbook(state: CodeActState) -> Command[Literal["call_model"]]:
+        def playbook(state: CodeActState, writer: StreamWriter) -> Command[Literal["call_model"]]:
             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)}
+                })
                 planning_instructions = self.instructions + PLAYBOOK_PLANNING_PROMPT
                 messages = [{"role": "system", "content": planning_instructions}] + state["messages"]
 
-                response = self.model_instance.invoke(messages)
-                response = cast(AIMessage, response)
-                response_text = get_message_text(response)
-                # Extract plan from response text between triple backticks
-                plan_match = re.search(r"```(.*?)```", response_text, re.DOTALL)
-                if plan_match:
-                    plan = plan_match.group(1).strip()
-                else:
-                    plan = response_text.strip()
-                return Command(update={"messages": [response], "playbook_mode": "confirming", "plan": plan})
+                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})
 
             elif playbook_mode == "confirming":
-                confirmation_instructions = self.instructions + PLAYBOOK_CONFIRMING_PROMPT
-                messages = [{"role": "system", "content": confirmation_instructions}] + state["messages"]
-                response = self.model_instance.invoke(messages, stream=False)
-                response = get_message_text(response)
-                if "true" in response.lower():
+                # Deterministic routing based on three exact button inputs from UI
+                user_text = ""
+                for m in reversed(state["messages"]):
+                    try:
+                        if getattr(m, "type", "") in {"human", "user"}:
+                            user_text = (get_message_text(m) or "").strip()
+                            if user_text:
+                                break
+                    except Exception:
+                        continue
+
+                t = user_text.lower()
+                if t == "yes, this is great":
                     return Command(goto="playbook", update={"playbook_mode": "generating"})
-                else:
-                    return Command(goto="playbook", update={"playbook_mode": "planning"})
+                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"})
+                    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"})
+
+                # Fallback safe default
+                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"]
-                response = cast(AIMessage, self.model_instance.invoke(messages))
-                raw_content = get_message_text(response)
-                func_code = raw_content.strip()
-                func_code = func_code.replace("```python", "").replace("```", "")
-                func_code = func_code.strip()
+                
+                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
 
                 # 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)
@@ -228,47 +257,39 @@ class CodeActPlaybookAgent(BaseAgent):
                     function_name = "generated_playbook"
 
                 # Save or update an Agent using the helper registry
-                saved_note = ""
                 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
                     instructions_payload = {
                         "playbookPlan": state["plan"],
-                        "playbookScript": {
-                            "name": function_name,
-                            "code": func_code,
-                        },
+                        "playbookScript": func_code,
                     }
 
                     # Convert tool ids list to dict
                     tool_dict = convert_tool_ids_to_dict(state["selected_tool_ids"])
 
-                    res = self.playbook_registry.create_agent(
+                    res = self.playbook_registry.upsert_agent(
                         name=function_name,
                         description=f"Generated playbook: {function_name}",
                         instructions=instructions_payload,
                         tools=tool_dict,
                         visibility="private",
                     )
-                    saved_note = f"Successfully created your playbook! Check it out here: [View Playbook](https://wingmen.info/agents/{res.id})"
                 except Exception as e:
-                    saved_note = f"Failed to save generated playbook as Agent '{function_name}': {e}"
-
-                # Mock tool call for exit_playbook_mode (for testing/demonstration)
-                mock_exit_tool_call = {"name": "exit_playbook_mode", "args": {}, "id": "mock_exit_playbook_123"}
-                mock_assistant_message = AIMessage(content=saved_note, tool_calls=[mock_exit_tool_call])
+                    raise e
 
-                # Mock tool response for exit_playbook_mode
-                mock_exit_tool_response = ToolMessage(
-                    content=json.dumps(f"Exited Playbook Mode.{saved_note}"),
-                    name="exit_playbook_mode",
-                    tool_call_id="mock_exit_playbook_123",
-                )
+                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, mock_exit_tool_response], "playbook_mode": "normal"}
+                    update={"messages": [mock_assistant_message], "playbook_mode": "normal"}
                 )
 
         async def route_entry(state: CodeActState) -> Literal["call_model", "playbook"]:
@@ -277,7 +298,7 @@ class CodeActPlaybookAgent(BaseAgent):
             self.tools_config.extend(state.get("selected_tool_ids", []))
             self.exported_tools = await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
             self.final_instructions, self.tools_context = create_default_prompt(
-                self.exported_tools, self.additional_tools, self.instructions
+                self.exported_tools, self.additional_tools, self.instructions, playbook=self.playbook
             )
             if state.get("playbook_mode") in ["planning", "confirming", "generating"]:
                 return "playbook"

universal_mcp_agents-0.1.21/src/universal_mcp/agents/codeact0/llm_tool.py

@@ -0,0 +1,25 @@
+from typing import Any
+
+from universal_mcp.agents.codeact0.utils import light_copy
+
+MAX_RETRIES = 3
+
+
+def get_context_str(source: Any | list[Any] | dict[str, Any]) -> str:
+    """Converts context to a string representation."""
+    if not isinstance(source, dict):
+        if isinstance(source, list):
+            source = {f"doc_{i + 1}": str(doc) for i, doc in enumerate(source)}
+        else:
+            source = {"content": str(source)}
+
+    return "\n".join(f"<{k}>\n{str(v)}\n</{k}>" for k, v in source.items())
+
+
+def smart_print(data: Any) -> None:
+    """Prints a dictionary or list of dictionaries with string values truncated to 30 characters.
+
+    Args:
+        data: Either a dictionary with string keys, or a list of such dictionaries
+    """
+    print(light_copy(data))  # noqa: T201

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/src/universal_mcp/agents/codeact0/prompts.py

@@ -4,10 +4,8 @@ from collections.abc import Sequence
 
 from langchain_core.tools import StructuredTool
 
-from universal_mcp.agents.codeact0.utils import schema_to_signature
-
 uneditable_prompt = """
-You are **Wingmen**, an AI Assistant created by AgentR — a creative, straight-forward, and direct principal software engineer with access to tools.
+You are **Ruzo**, an AI Assistant created by AgentR — a creative, straight-forward, and direct principal software engineer with access to tools.
 
 Your job is to answer the user's question or perform the task they ask for.
 - Answer simple questions (which do not require you to write any code or access any external resources) directly. Note that any operation that involves using ONLY print functions should be answered directly in the chat. NEVER write a string yourself and print it.
@@ -21,7 +19,13 @@ Your job is to answer the user's question or perform the task they ask for.
 - Read and understand the output of the previous code snippet and use it to answer the user's request. Note that the code output is NOT visible to the user, so after the task is complete, you have to give the output to the user in a markdown format. Similarly, you should only use print/smart_print for your own analysis, the user does not get the output.
 - If needed, feel free to ask for more information from the user (without using the `execute_ipython_cell` tool) to clarify the task.
 
-GUIDELINES for writing code:
+**Code Execution Guidelines:**
+- The code you write will be executed in a sandbox environment, and you can use the output of previous executions in your code. Variables, functions, imports are retained.
+- Read and understand the output of the previous code snippet and use it to answer the user's request. Note that the code output is NOT visible to the user, so after the task is complete, you have to give the output to the user in a markdown format. Similarly, you should only use print/smart_print for your own analysis, the user does not get the output.
+- 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.
+
+**Coding Best Practices:**
 - Variables defined at the top level of previous code snippets can be referenced in your code.
 - External functions which return a dict or list[dict] are ambiguous. Therefore, you MUST explore the structure of the returned data using `smart_print()` statements before using it, printing keys and values. `smart_print` truncates long strings from data, preventing huge output logs.
 - When an operation involves running a fixed set of steps on a list of items, run one run correctly and then use a for loop to run the steps on each item in the list.
@@ -29,25 +33,40 @@ GUIDELINES for writing code:
 - 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.
-- Async Functions (Critical): Use them only as follows-
-Case 1: Top-level await without asyncio.run()
+
+**Async Functions (Critical Rules):**
+Use async functions only as follows:
+- Case 1: Top-level await without asyncio.run()
     Wrap in async function and call with asyncio.run():
+    ```python
     async def main():
         result = await some_async_function()
         return result
     asyncio.run(main())
-Case 2: Using asyncio.run() directly
-If code already contains asyncio.run(), use as-is — do not wrap again:
+    ```
+- Case 2: Using asyncio.run() directly
+    If code already contains asyncio.run(), use as-is — do not wrap again:
+    ```python
     asyncio.run(some_async_function())
+    ```
 Rules:
 - Never use await outside an async function
 - Never use await asyncio.run()
 - Never nest asyncio.run() calls
+
+**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.
+- 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.
 """
 
 PLAYBOOK_PLANNING_PROMPT = """Now, you are tasked with creating a reusable playbook 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.
+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.
 
 Your plan should:
 1. Identify the key steps in the workflow
@@ -56,24 +75,25 @@ Your plan should:
 4. Be clear and concise
 
 Example:
-```
-1. Connect to database using `db_connection_string`
-2. Query user data for `user_id`
-3. Process results and calculate `metric_name`
-4. Send notification to `email_address`
-```
-
-Now create a plan based on the conversation history. Enclose it between ``` and ```. Ask the user if the plan is okay."""
-
-
-PLAYBOOK_CONFIRMING_PROMPT = """Now, you are tasked with confirming the playbook plan. Return True if the user is happy with the plan, False otherwise. Do not say anything else in your response. The user response will be the last message in the chain.
+{
+    "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.
 """
 
-PLAYBOOK_GENERATING_PROMPT = """Now, you are tasked with generating the playbook function. Return the function in Python code.
-Do not include any other text in your response.
+
+PLAYBOOK_GENERATING_PROMPT = """Now, you are tasked with generating the playbook 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.
-Do not include anything other than python code in your response
 """
 
 
@@ -90,107 +110,18 @@ def make_safe_function_name(name: str) -> str:
     return safe_name
 
 
-def dedent(text):
-    """Remove any common leading whitespace from every line in `text`.
-
-    This can be used to make triple-quoted strings line up with the left
-    edge of the display, while still presenting them in the source code
-    in indented form.
-
-    Note that tabs and spaces are both treated as whitespace, but they
-    are not equal: the lines "  hello" and "\\thello" are
-    considered to have no common leading whitespace.
-
-    Entirely blank lines are normalized to a newline character.
-    """
-    # Look for the longest leading string of spaces and tabs common to
-    # all lines.
-    margin = None
-    _whitespace_only_re = re.compile("^[ \t]+$", re.MULTILINE)
-    _leading_whitespace_re = re.compile("(^[ \t]*)(?:[^ \t\n])", re.MULTILINE)
-    text = _whitespace_only_re.sub("", text)
-    indents = _leading_whitespace_re.findall(text)
-    for indent in indents:
-        if margin is None:
-            margin = indent
-
-        # Current line more deeply indented than previous winner:
-        # no change (previous winner is still on top).
-        elif indent.startswith(margin):
-            pass
-
-        # Current line consistent with and no deeper than previous winner:
-        # it's the new winner.
-        elif margin.startswith(indent):
-            margin = indent
-
-        # Find the largest common whitespace between current line and previous
-        # winner.
-        else:
-            for i, (x, y) in enumerate(zip(margin, indent)):
-                if x != y:
-                    margin = margin[:i]
-                    break
-
-    # sanity check (testing/debugging only)
-    if 0 and margin:
-        for line in text.split("\n"):
-            assert not line or line.startswith(margin), f"line = {line!r}, margin = {margin!r}"
-
-    if margin:
-        text = re.sub(r"(?m)^" + margin, "", text)
-    return text
-
-
-def indent(text, prefix, predicate=None):
-    """Adds 'prefix' to the beginning of selected lines in 'text'.
-
-    If 'predicate' is provided, 'prefix' will only be added to the lines
-    where 'predicate(line)' is True. If 'predicate' is not provided,
-    it will default to adding 'prefix' to all non-empty lines that do not
-    consist solely of whitespace characters.
-    """
-    if predicate is None:
-        # str.splitlines(True) doesn't produce empty string.
-        #  ''.splitlines(True) => []
-        #  'foo\n'.splitlines(True) => ['foo\n']
-        # So we can use just `not s.isspace()` here.
-        def predicate(s):
-            return not s.isspace()
-
-    prefixed_lines = []
-    for line in text.splitlines(True):
-        if predicate(line):
-            prefixed_lines.append(prefix)
-        prefixed_lines.append(line)
-
-    return "".join(prefixed_lines)
-
-
 def create_default_prompt(
     tools: Sequence[StructuredTool],
     additional_tools: Sequence[StructuredTool],
     base_prompt: str | None = None,
+    playbook: object | None = None,
 ):
     system_prompt = uneditable_prompt.strip() + (
         "\n\nIn addition to the Python Standard Library, you can use the following external functions:\n"
     )
     tools_context = {}
-    for tool in tools:
-        if hasattr(tool, "func") and tool.func is not None:
-            tool_callable = tool.func
-            is_async = False
-        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.description}"""
-    ...
-    '''
-        safe_name = make_safe_function_name(tool.name)
-        tools_context[safe_name] = tool_callable
 
-    for tool in additional_tools:
+    for tool in tools + additional_tools:
         if hasattr(tool, "func") and tool.func is not None:
             tool_callable = tool.func
             is_async = False
@@ -207,4 +138,24 @@ def create_default_prompt(
     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
+
     return system_prompt, tools_context

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/src/universal_mcp/agents/codeact0/state.py

@@ -1,6 +1,15 @@
-from typing import Annotated, Any
+from typing import Annotated, Any, List
 
 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 PlaybookCode(BaseModel):
+    code: str = Field(description="The Python code for the playbook.")
 
 
 def _enqueue(left: list, right: list) -> list:
@@ -36,5 +45,5 @@ class CodeActState(AgentState):
     """State for the playbook agent."""
     selected_tool_ids: Annotated[list[str], _enqueue]
     """Queue for tools exported from registry"""
-    plan: str | None
+    plan: list[str] | None
     """Plan for the playbook agent."""

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/src/universal_mcp/agents/codeact0/tools.py

@@ -4,6 +4,7 @@ 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
@@ -224,19 +225,9 @@ def create_meta_tools(tool_registry: AgentrRegistry) -> dict[str, Any]:
                 - answer (str): Generated answer with markdown formatting and citation numbers [1][2]
                 - citations (list[str]): List of source URLs corresponding to citation numbers
         """
-        await tool_registry.export_tools(["perplexity__answer_with_search"], ToolFormat.LANGCHAIN)
-
-        response = await tool_registry.call_tool(
-            "perplexity__answer_with_search",
-            {
-                "query": query,
-                "model": "sonar",
-                "temperature": 1.0,
-                "system_prompt": (
-                    "You are a helpful AI assistant that answers questions using real-time information from the web."
-                ),
-            },
-        )
+        await tool_registry.export_tools(["exa__answer"], ToolFormat.LANGCHAIN)
+        response = await tool_registry.call_tool("exa__answer", {"query": query, "text": True})
+        logger.info(f"Web search response: {response}")
 
         # Extract only desired fields
         return {

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/src/universal_mcp/agents/codeact0/utils.py

@@ -5,10 +5,18 @@ from collections.abc import Sequence
 from typing import Any
 
 from langchain_core.messages import BaseMessage
+from universal_mcp.types import ToolConfig
 
 MAX_CHARS = 5000
 
 
+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
+        tool_config[app_id] = list(set(all_tools))
+    return tool_config
+
+
 def light_copy(data):
     """
     Deep copy a dict[str, any] or Sequence[any] with string truncation.

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/src/universal_mcp/applications/llm/app.py

@@ -162,11 +162,11 @@ class LlmApp(BaseApplication):
             top_class: str = Field(..., description="The class with the highest probability.")
 
         response = (
-            model.with_structured_output(schema=ClassificationResult, method="json_mode")
+            model.with_structured_output(schema=ClassificationResult)
             .with_retry(stop_after_attempt=MAX_RETRIES)
             .invoke(prompt)
         )
-        return cast(dict[str, Any], response)
+        return response.model_dump_json(indent=2)
 
     def extract_data(
         self,

{universal_mcp_agents-0.1.20rc1 → universal_mcp_agents-0.1.21}/uv.lock

@@ -4952,7 +4952,7 @@ wheels = [
 
 [[package]]
 name = "universal-mcp-agents"
-version = "0.1.19"
+version = "0.1.20"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-anthropic" },

universal_mcp_agents-0.1.20rc1/src/universal_mcp/agents/codeact0/llm_tool.py

@@ -1,277 +0,0 @@
-import json
-from dataclasses import dataclass
-from typing import Any, Literal, cast
-
-from langchain.chat_models import init_chat_model
-from langchain_openai import AzureChatOpenAI
-
-from universal_mcp.agents.codeact0.utils import get_message_text, light_copy
-
-MAX_RETRIES = 3
-
-
-def get_context_str(source: Any | list[Any] | dict[str, Any]) -> str:
-    """Converts context to a string representation."""
-    if not isinstance(source, dict):
-        if isinstance(source, list):
-            source = {f"doc_{i + 1}": str(doc) for i, doc in enumerate(source)}
-        else:
-            source = {"content": str(source)}
-
-    return "\n".join(f"<{k}>\n{str(v)}\n</{k}>" for k, v in source.items())
-
-
-def smart_print(data: Any) -> None:
-    """Prints a dictionary or list of dictionaries with string values truncated to 30 characters.
-
-    Args:
-        data: Either a dictionary with string keys, or a list of such dictionaries
-    """
-    print(light_copy(data))  # noqa: T201
-
-
-def creative_writer(
-    task: str,
-    context: Any | list[Any] | dict[str, Any],
-    tone: str = "normal",
-    format: Literal["markdown", "html", "plain"] = "markdown",
-    length: Literal["very-short", "concise", "normal", "long"] = "concise",
-) -> str:
-    """
-    Given a high-level writing task and context, returns a well-written text
-    that achieves the task, given the context.
-
-    Example Call:
-        creative_writer("Summarize this website with the goal of making it easy to understand.", web_content)
-        creative_writer("Make a markdown table summarizing the key differences between doc_1 and doc_2.", {"doc_1": str(doc_1), "doc_2": str(doc_2)})
-        creative_writer("Summarize all the provided documents.", [doc_1, doc_2, doc_3])
-
-    Important:
-    - Include specifics of the goal in the context verbatim.
-    - Be precise and direct in the task, and include as much context as possible.
-    - Include relevant high-level goals or intent in the task.
-    - You can provide multiple documents as input, and reference them in the task.
-    - You MUST provide the contents of any source documents to `creative_writer`.
-    - NEVER use `creative_writer` to produce JSON for a Pydantic model.
-
-    Args:
-        task: The main writing task or directive.
-        context: A single string, list of strings, or dict mapping labels to content.
-        tone: The desired tone of the output (e.g., "normal", "flirty", "formal", "casual", "crisp", "poetic", "technical", "internet-chat", "smartass", etc.).
-        format: Output format ('markdown', 'html', 'plain-text').
-        length: Desired length of the output ('very-short', 'concise', 'normal', 'long').
-
-    Returns:
-        str: The generated text output.
-    """
-
-    context = get_context_str(context)
-
-    task = task.strip() + "\n\n"
-    if format == "markdown":
-        task += "Please write in Markdown format.\n\n"
-    elif format == "html":
-        task += "Please write in HTML format.\n\n"
-    else:
-        task += "Please write in plain text format. Don't use markdown or HTML.\n\n"
-
-    if tone not in ["normal", "default", ""]:
-        task = f"{task} (Tone instructions: {tone})"
-
-    if length not in ["normal", "default", ""]:
-        task = f"{task} (Length instructions: {length})"
-
-    prompt = f"{task}\n\nContext:\n{context}\n\n"
-
-    model = AzureChatOpenAI(model="gpt-4o", temperature=0.7)
-
-    response = model.with_retry(stop_after_attempt=MAX_RETRIES).invoke(prompt)
-    return get_message_text(response)
-
-
-def ai_classify(
-    classification_task_and_requirements: str,
-    context: Any | list[Any] | dict[str, Any],
-    class_descriptions: dict[str, str],
-) -> dict[str, Any]:
-    """
-    Classifies and compares data based on given requirements.
-
-    Use `ai_classify` for tasks which need to classify data into one of many categories.
-    If making multiple binary classifications, call `ai_classify` for each.
-
-    Guidance:
-    - Prefer to use ai_classify operations to compare strings, rather than string ops.
-    - Prefer to include an "Unsure" category for classification tasks.
-    - The `class_descriptions` dict argument MUST be a map from possible class names to a precise description.
-    - Use precise and specific class names and concise descriptions.
-    - Pass ALL relevant context, preferably as a dict mapping labels to content.
-    - Returned dict maps each possible class name to a probability.
-
-    Example Usage:
-        classification_task_and_requirements = "Does the document contain an address?"
-        class_descriptions = {
-            "Is_Address": "Valid addresses usually have street names, city, and zip codes.",
-            "Not_Address": "Not valid addresses."
-        }
-        classification = ai_classify(
-            classification_task_and_requirements,
-            {"address": extracted_address},
-            class_descriptions
-        )
-        if classification["probabilities"]["Is_Address"] > 0.5:
-            ...
-
-    Args:
-        classification_task_and_requirements: The classification question and rules.
-        context: The data to classify (string, list, or dict).
-        class_descriptions: Mapping from class names to descriptions.
-
-    Returns:
-        dict: {
-            probabilities: dict[str, float],
-            reason: str,
-            top_class: str,
-        }
-    """
-
-    context = get_context_str(context)
-
-    prompt = (
-        f"{classification_task_and_requirements}\n\n"
-        f"\nThis is classification task\nPossible classes and descriptions:\n"
-        f"{json.dumps(class_descriptions, indent=2)}\n"
-        f"\nContext:\n{context}\n\n"
-        "Return ONLY a valid JSON object, no extra text."
-    )
-
-    model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
-
-    @dataclass
-    class ClassificationResult:
-        probabilities: dict[str, float]
-        reason: str
-        top_class: str
-
-    response = (
-        model.with_structured_output(schema=ClassificationResult, method="json_mode")
-        .with_retry(stop_after_attempt=MAX_RETRIES)
-        .invoke(prompt)
-    )
-    return cast(dict[str, Any], response)
-
-
-def call_llm(
-    task_instructions: str, context: Any | list[Any] | dict[str, Any], output_json_schema: dict[str, Any]
-) -> dict[str, Any]:
-    """
-    Call a Large Language Model (LLM) with an instruction and contextual information,
-    returning a dictionary matching the given output_json_schema.
-    Can be used for tasks like creative writing, llm reasoning based content generation, etc.
-
-    You MUST anticipate Exceptions in reasoning based tasks which will lead to some empty fields
-    in the returned output; skip this item if applicable.
-
-    General Guidelines:
-    - Be comprehensive, specific, and precise on the task instructions.
-    - Include as much context as possible.
-    - You can provide multiple items in context, and reference them in the task.
-    - Include relevant high-level goals or intent in the task.
-    - In the output_json_schema, use required field wherever necessary.
-    - The more specific your task instructions and output_json_schema are, the better the results.
-
-    Guidelines for content generation tasks:
-    - Feel free to add instructions for tone, length, and format (markdown, html, plain-text, xml)
-    - Some examples of tone are: "normal", "flirty", "formal", "casual", "crisp", "poetic", "technical", "internet-chat", "smartass", etc.
-    - Prefer length to be concise by default. Other examples are: "very-short", "concise", "normal", "long", "2-3 lines", etc.
-    - In format prefer plain-text but you can also use markdown and html wherever useful.
-
-    Args:
-        instruction: The main directive for the LLM (e.g., "Summarize the article" or "Extract key entities").
-        context:
-            A dictionary containing named text elements that provide additional
-            information for the LLM. Keys are labels (e.g., 'article', 'transcript'),
-            values are strings of content.
-        output_json_schema: must be a valid JSON schema with top-level 'title' and 'description' keys.
-
-    Returns:
-        dict: Parsed JSON object matching the desired output_json_schema.
-
-    """
-    context = get_context_str(context)
-
-    prompt = f"{task_instructions}\n\nContext:\n{context}\n\nReturn ONLY a valid JSON object, no extra text."
-
-    model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
-
-    response = (
-        model.with_structured_output(schema=output_json_schema, method="json_mode")
-        .with_retry(stop_after_attempt=MAX_RETRIES)
-        .invoke(prompt)
-    )
-    return cast(dict[str, Any], response)
-
-
-def data_extractor(
-    extraction_task: str, source: Any | list[Any] | dict[str, Any], output_json_schema: dict[str, Any]
-) -> dict[str, Any]:
-    """
-    Extracts structured data from unstructured data (documents, webpages, images, large bodies of text),
-    returning a dictionary matching the given output_json_schema.
-
-    You MUST anticipate Exception raised for unextractable data; skip this item if applicable.
-
-    Strongly prefer to:
-    - Be comprehensive, specific, and precise on the data you want to extract.
-    - Use optional fields everywhere.
-    - Extract multiple items from each source unless otherwise specified.
-    - The more specific your extraction task and output_json_schema are, the better the results.
-
-    Args:
-        extraction_task: The directive describing what to extract.
-        source: The unstructured data to extract from.
-        output_json_schema: must be a valid JSON schema with top-level 'title' and 'description' keys.
-
-    Returns:
-        dict: Parsed JSON object matching the desired output_json_schema.
-
-    Example:
-        news_articles_schema = {
-            "title": "NewsArticleList",
-            "description": "A list of news articles with headlines and URLs",
-            "type": "object",
-            "properties": {
-                "articles": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "headline": {
-                                "type": "string"
-                            },
-                            "url": {
-                                "type": "string"
-                            }
-                        },
-                        "required": ["headline", "url"]
-                    }
-                }
-            },
-            "required": ["articles"]
-        }
-
-        news_articles = data_extractor("Extract headlines and their corresponding URLs.", content, news_articles_schema)
-    """
-
-    context = get_context_str(source)
-
-    prompt = f"{extraction_task}\n\nContext:\n{context}\n\nReturn ONLY a valid JSON object, no extra text."
-
-    model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
-
-    response = (
-        model.with_structured_output(schema=output_json_schema, method="json_mode")
-        .with_retry(stop_after_attempt=MAX_RETRIES)
-        .invoke(prompt)
-    )
-    return cast(dict[str, Any], response)