universal-mcp-agents 0.1.19rc1__py3-none-any.whl → 0.1.20rc1__py3-none-any.whl

universal_mcp/agents/codeact/agent.py

@@ -1,240 +0,0 @@
-import ast
-from collections.abc import Callable
-
-from langchain_core.messages import AIMessage, HumanMessage
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.graph import END, START, StateGraph
-from langgraph.types import Command
-from pydantic import BaseModel, Field
-from universal_mcp.logger import logger
-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.codeact.models import SandboxOutput
-from universal_mcp.agents.codeact.prompts import (
-    create_default_prompt,
-    make_safe_function_name,
-)
-from universal_mcp.agents.codeact.sandbox import eval_unsafe
-from universal_mcp.agents.codeact.state import CodeActState
-from universal_mcp.agents.llm import load_chat_model
-
-
-class StructuredCodeResponse(BaseModel):
-    """Structured response for the CodeAct agent."""
-
-    reasoning: str = Field(..., description="The reasoning behind the generated script.")
-    script: str | None = Field(default=None, description="The Python script to be executed.")
-    task_complete: bool = Field(..., description="Whether the task is complete.")
-
-
-class CodeActAgent(BaseAgent):
-    def __init__(
-        self,
-        name: str,
-        instructions: str,
-        model: str,
-        memory: BaseCheckpointSaver | None = None,
-        tools: ToolConfig | None = None,
-        registry: ToolRegistry | None = None,
-        sandbox_timeout: int = 20,
-        **kwargs,
-    ):
-        super().__init__(
-            name=name,
-            instructions=instructions,
-            model=model,
-            memory=memory,
-            **kwargs,
-        )
-        self.model_instance = load_chat_model(model)
-        self.tools_config = tools or {}
-        self.registry = registry
-        self.eval_fn = eval_unsafe
-        self.sandbox_timeout = sandbox_timeout
-        self.processed_tools: dict[str, Callable] = {}
-
-    async def _build_graph(self):
-        if self.tools_config:
-            if not self.registry:
-                raise ValueError("Tools are configured but no registry is provided")
-            # Load native tools, these are python functions
-            exported_tools = await self.registry.export_tools(self.tools_config, ToolFormat.NATIVE)
-            for tool in exported_tools:
-                name = tool.__name__
-                safe_name = make_safe_function_name(name)
-                if name != safe_name:
-                    logger.warning(f"Tool name {name} is not safe, using {safe_name} instead")
-                    raise ValueError(f"Tool name {name} is not safe, using {safe_name} instead")
-                self.processed_tools[safe_name] = tool
-
-        self.instructions = create_default_prompt(self.processed_tools, self.instructions)
-
-        agent = StateGraph(CodeActState)
-        agent.add_node("call_model", self.call_model)
-        agent.add_node("validate_code", self.validate_code)
-        agent.add_node("sandbox", self.sandbox)
-        agent.add_node("final_answer", self.final_answer)
-
-        agent.add_edge(START, "call_model")
-
-        return agent.compile(checkpointer=self.memory)
-
-    async def call_model(self, state: CodeActState) -> Command:
-        logger.debug(f"Calling model with state: {state}")
-        model = self.model_instance.with_structured_output(StructuredCodeResponse)
-
-        # Find the last script and its output in the message history
-        previous_script = state.get("script", "")
-        sandbox_output = state.get("sandbox_output", "")
-        syntax_error = state.get("syntax_error", "")
-
-        logger.debug(f"Previous script:\n {previous_script}")
-        logger.debug(f"Sandbox output:\n {sandbox_output}")
-        logger.debug(f"Syntax error:\n {syntax_error}")
-
-        prompt_messages = [
-            {"role": "system", "content": self.instructions},
-            *state["messages"],
-        ]
-        if previous_script:
-            feedback_message = (
-                f"Here is the script you generated in the last turn:\n\n```python\n{previous_script}\n```\n\n"
-            )
-            if syntax_error:
-                feedback_message += (
-                    f"When parsing the script, it produced the following syntax error:\n\n```\n{syntax_error}\n```\n\n"
-                    "Please fix the syntax and generate a new, correct script."
-                )
-            elif sandbox_output:
-                feedback_message += (
-                    f"When executed, it produced the following output:\n\n```\n{sandbox_output}\n```\n\n"
-                )
-                feedback_message += "Based on this output, decide if the task is complete. If it is, respond the final answer to the user in clean and readable Markdown format. Important: set `task_complete` to `True` and no need to provide script. If the task is not complete, generate a new script to get closer to the solution."
-
-            prompt_messages.append({"role": "user", "content": feedback_message})
-
-        response: StructuredCodeResponse = await model.ainvoke(prompt_messages)
-
-        # We add the reasoning as the AI message content
-        ai_message = AIMessage(content=response.reasoning)
-
-        if response.task_complete:
-            return Command(
-                goto="final_answer",
-                update={
-                    "messages": [ai_message],
-                    "script": response.script,
-                    "task_complete": response.task_complete,
-                    "sandbox_output": sandbox_output,
-                    "syntax_error": None,
-                },
-            )
-        else:
-            return Command(
-                goto="validate_code",
-                update={
-                    "messages": [ai_message],
-                    "script": response.script,
-                    "task_complete": response.task_complete,
-                    "sandbox_output": None,
-                    "syntax_error": None,
-                },
-            )
-
-    async def validate_code(self, state: CodeActState) -> Command:
-        logger.debug(f"Validating code with script:\n {state['script']}")
-        script = state.get("script")
-
-        if not script:
-            return Command(
-                goto="call_model",
-                update={
-                    "syntax_error": "Model did not provide a script but task is not complete. Please provide a script or set task_complete to True."
-                },
-            )
-
-        try:
-            ast.parse(script)
-            logger.debug("AST parsing successful.")
-            return Command(
-                goto="sandbox",
-                update={
-                    "syntax_error": None,
-                },
-            )
-        except SyntaxError as e:
-            logger.warning(f"AST parsing failed: {e}")
-            return Command(
-                goto="call_model",
-                update={
-                    "syntax_error": f"Syntax Error: {e}",
-                },
-            )
-
-    async def sandbox(self, state: CodeActState) -> Command:
-        logger.debug(f"Running sandbox with script:\n {state['script']}")
-        tools_context = {}
-        for tool_name, tool_callable in self.processed_tools.items():
-            tools_context[tool_name] = tool_callable
-
-        output: SandboxOutput
-        output, _ = await self.eval_fn(state["script"], tools_context, self.sandbox_timeout)
-
-        # Format the output for the agent
-        formatted_output = "Code executed.\n\n"
-        MAX_OUTPUT_LEN = 20000  # Maximum number of characters to show for stdout/stderr
-
-        def truncate_output(text, max_len=MAX_OUTPUT_LEN):
-            if text is None:
-                return ""
-            text = text.strip()
-            if len(text) > max_len:
-                return text[:max_len] + "\n... (more output hidden)"
-            return text
-
-        if output.stdout:
-            truncated_stdout = truncate_output(output.stdout)
-            formatted_output += f"STDOUT:\n```\n{truncated_stdout}\n```\n\n"
-        if output.error:
-            truncated_stderr = truncate_output(output.error)
-            formatted_output += f"STDERR / ERROR:\n```\n{truncated_stderr}\n```\n"
-        if output.return_value is not None:
-            formatted_output += f"RETURN VALUE:\n```\n{repr(output.return_value)}\n```\n"
-
-        logger.debug(f"Sandbox output: {formatted_output}")
-        return Command(
-            goto="call_model",
-            update={"sandbox_output": formatted_output.strip()},
-        )
-
-    async def final_answer(self, state: CodeActState) -> Command:
-        logger.debug("Formatting final answer using LLM for markdown formatting.")
-
-        # Extract the original user prompt
-        user_prompt = ""
-        for msg in state["messages"]:
-            if isinstance(msg, HumanMessage):
-                user_prompt = msg.content
-                break
-
-        # Compose a prompt for the LLM to generate a concise, markdown-formatted answer
-        llm_prompt = (
-            "Given the following task and answer, write a concise, well-formatted markdown response suitable for a user.\n\n"
-            f"Task:\n{user_prompt}\n\n"
-            f"Answer:\n{state['sandbox_output']}\n\n"
-            "Respond only with the markdown-formatted answer."
-        )
-
-        # Use the model to generate the final formatted answer
-        response = await self.model_instance.ainvoke([{"role": "user", "content": llm_prompt}])
-        markdown_answer = response.content if hasattr(response, "content") else str(response)
-        logger.debug(f"Final answer:\n {markdown_answer}")
-
-        return Command(
-            goto=END,
-            update={
-                "messages": [AIMessage(content=markdown_answer)],
-            },
-        )

universal_mcp/agents/codeact/models.py

@@ -1,11 +0,0 @@
-from typing import Any
-
-from pydantic import BaseModel
-
-
-class SandboxOutput(BaseModel):
-    """Structured output from the code sandbox."""
-
-    stdout: str
-    error: str | None = None
-    return_value: Any | None = None

universal_mcp/agents/codeact/prompts.py

@@ -1,82 +0,0 @@
-import inspect
-import re
-from collections.abc import Callable
-
-
-def make_safe_function_name(name: str) -> str:
-    """Convert a tool name to a valid Python function name."""
-    # Replace non-alphanumeric characters with underscores
-    safe_name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
-    # Ensure the name doesn't start with a digit
-    if safe_name and safe_name[0].isdigit():
-        safe_name = f"tool_{safe_name}"
-    # Handle empty name edge case
-    if not safe_name:
-        safe_name = "unnamed_tool"
-    return safe_name
-
-
-def create_default_prompt(
-    tools: dict[str, Callable],
-    base_prompt: str | None = None,
-):
-    """Create default prompt for the CodeAct agent."""
-    prompt = f"{base_prompt}\n\n" if base_prompt else ""
-    prompt += """You are a Python programmer. You will be given a task to perform.
-Your goal is to write a self-contained Python script to accomplish the task.
-
-In each turn, you will generate a complete Python script. The script will be executed in a fresh, stateless environment.
-You will be given the previous script you generated and the output it produced.
-Your task is to analyze the output to find errors or opportunities for improvement, and then generate a new, improved script.
-You must take the previous script as a starting point and replace it with a new one that moves closer to the final solution.
-Your final script must be a single, complete piece of code that can be executed independently.
-
-The script must follow this structure:
-1. All necessary imports at the top.
-2. An `async def main():` function containing the core logic.
-3. Do NOT include any code outside of the `async def main()` function, and do NOT call it. The execution environment handles this.
-
-Any output you want to see from the code should be printed to the console from within the `main` function.
-Code should be output in a fenced code block (e.g. ```python ... ```).
-
-If you need to ask for more information or provide the final answer, you can output text to be shown directly to the user.
-
-In addition to the Python Standard Library, you can use the following functions:"""
-
-    for tool_name, tool_callable in tools.items():
-        # Determine if it's an async function
-        is_async = inspect.iscoroutinefunction(tool_callable)
-        # Add appropriate function definition
-        prompt += f'''\n{"async " if is_async else ""}def {tool_name}{str(inspect.signature(tool_callable))}:
-    """{tool_callable.__doc__}"""
-    ...
-'''
-
-    prompt += """\n\n\nAlways use print() statements to explore data structures and function outputs. Simply returning values will not display them back to you for inspection. For example, use print(result) instead of just 'result'.
-
-As you don't know the output schema of the additional Python functions you have access to, start from exploring their contents before building a final solution.
-
-IMPORTANT CODING STRATEGY:
-1. All your code must be inside an `async def main()` function.
-2. Do NOT import `asyncio` or call `main()`. The execution environment handles this.
-3. Since many of the provided tools are async, you must use `await` to call them from within `main()`.
-4. Write code up to the point where you make an API call/tool usage with an output.
-5. Print the type/shape and a sample entry of this output, and using that knowledge proceed to write the further code.
-6. The maximum number of characters that can be printed is 5000. Remove any unnecessary print statements.
-
-This means:
-- Write code that makes the API call or tool usage
-- Print the result with type information: print(f"Type: {type(result)}")
-- Print the shape/structure: print(f"Shape/Keys: {result.keys() if isinstance(result, dict) else len(result) if isinstance(result, (list, tuple)) else 'N/A'}")
-- Print a sample entry: print(f"Sample: {result[0] if isinstance(result, (list, tuple)) and len(result) > 0 else result}")
-- Then, based on this knowledge, write the code to process/use this data
-
-Reminder: use Python code snippets to call tools
-
-When you have completely finished the task, present the final result from your script to the user in a clean and readable Markdown format. Do not just summarize what you did; provide the actual output. For example, if you were asked to find unsubscribe links and your script found them, your final response should be a Markdown-formatted list of those links.
-
-
-Important:
-After you have provided the final output, you MUST set `task_complete` to `True` in your response.
-"""
-    return prompt

universal_mcp/agents/codeact/sandbox.py

@@ -1,85 +0,0 @@
-import asyncio
-import contextlib
-import io
-from collections.abc import Callable
-from typing import Any
-
-from loguru import logger
-
-from .models import SandboxOutput
-
-# Define a whitelist of safe built-in functions
-SAFE_BUILTINS = {
-    "abs": abs,
-    "all": all,
-    "any": any,
-    "bool": bool,
-    "callable": callable,
-    "chr": chr,
-    "dict": dict,
-    "divmod": divmod,
-    "enumerate": enumerate,
-    "filter": filter,
-    "float": float,
-    "getattr": getattr,
-    "hasattr": hasattr,
-    "hash": hash,
-    "id": id,
-    "int": int,
-    "isinstance": isinstance,
-    "iter": iter,
-    "len": len,
-    "list": list,
-    "max": max,
-    "min": min,
-    "next": next,
-    "ord": ord,
-    "pow": pow,
-    "print": print,
-    "range": range,
-    "repr": repr,
-    "reversed": reversed,
-    "round": round,
-    "set": set,
-    "slice": slice,
-    "sorted": sorted,
-    "str": str,
-    "sum": sum,
-    "tuple": tuple,
-    "type": type,
-    "zip": zip,
-}
-
-
-async def eval_unsafe(
-    code: str, _locals: dict[str, Callable], timeout: int = 10
-) -> tuple[SandboxOutput, dict[str, Any]]:
-    """Executes a string of Python code in a sandboxed environment."""
-    original_keys = set(_locals.keys())
-    execution_context = _locals.copy()
-    execution_context["__builtins__"] = __builtins__  # TODO: Use SAFE_BUILTINS instead of __builtins__
-
-    stdout_capture = io.StringIO()
-    output = SandboxOutput(stdout="")
-
-    try:
-        logger.debug(f"Executing code with timeout {timeout}")
-        with contextlib.redirect_stdout(stdout_capture):
-            exec(code, execution_context)
-
-            if "main" in execution_context and asyncio.iscoroutinefunction(execution_context["main"]):
-                return_val = await asyncio.wait_for(execution_context["main"](), timeout=timeout)
-                output.return_value = return_val
-            else:
-                output.error = "No `async def main()` function found in the script."
-
-        output.stdout = stdout_capture.getvalue()
-
-    except Exception as e:
-        output.error = f"{type(e).__name__}: {e}"
-        output.stdout = stdout_capture.getvalue()
-
-    new_keys = set(execution_context.keys()) - original_keys - {"__builtins__"}
-    new_vars = {key: execution_context[key] for key in new_keys}
-
-    return output, new_vars

universal_mcp/agents/codeact/state.py

@@ -1,11 +0,0 @@
-from langgraph.graph import MessagesState
-from pydantic import Field
-
-
-class CodeActState(MessagesState):
-    """State for CodeAct agent."""
-
-    script: str | None = Field(default=None, description="The Python code script to be executed.")
-    sandbox_output: str | None = Field(default=None, description="The output of the Python code script execution.")
-    syntax_error: str | None = Field(default=None, description="The syntax error from the last script validation.")
-    task_complete: bool = Field(default=False, description="Whether the task is complete.")

universal_mcp/agents/codeact/utils.py

@@ -1,68 +0,0 @@
-import re
-
-from universal_mcp.logger import logger
-
-BACKTICK_PATTERN = r"(?:^|\n)```(.*?)(?:```(?:\n|$))"
-
-
-def extract_and_combine_codeblocks(text: str) -> str:
-    """
-    Extracts all codeblocks from a text string and combines them into a single code string.
-
-    Args:
-        text: A string containing zero or more codeblocks, where each codeblock is
-            surrounded by triple backticks (```).
-
-    Returns:
-        A string containing the combined code from all codeblocks, with each codeblock
-        separated by a newline.
-
-    Example:
-        text = '''Here's some code:
-
-        ```python
-        print('hello')
-        ```
-        And more:
-
-        ```
-        print('world')
-        ```'''
-
-        result = extract_and_combine_codeblocks(text)
-
-        Result:
-
-        print('hello')
-
-        print('world')
-    """
-    # Find all code blocks in the text using regex
-    # Pattern matches anything between triple backticks, with or without a language identifier
-    try:
-        code_blocks = re.findall(BACKTICK_PATTERN, text, re.DOTALL)
-    except Exception as e:
-        logger.error(f"Error extracting code blocks: {e}")
-        logger.error(f"Text: {text}")
-        return ""
-
-    if not code_blocks:
-        return ""
-
-    # Process each codeblock
-    processed_blocks = []
-    for block in code_blocks:
-        # Strip leading and trailing whitespace
-        cleaned_block = block.strip()
-
-        # If the first line looks like a language identifier, remove it
-        lines = cleaned_block.split("\n")
-        if lines and (not lines[0].strip() or " " not in lines[0].strip()):
-            # First line is empty or likely a language identifier (no spaces)
-            cleaned_block = "\n".join(lines[1:])
-
-        processed_blocks.append(cleaned_block)
-
-    # Combine all codeblocks with newlines between them
-    combined_code = "\n\n".join(processed_blocks)
-    return combined_code