universal-mcp-agents 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

universal_mcp/agents/builder.py

@@ -1,4 +1,5 @@
 import asyncio
+from collections import defaultdict
 from collections.abc import Sequence
 from typing import Annotated, TypedDict
 
@@ -15,7 +16,7 @@ from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.llm import load_chat_model
 from universal_mcp.agents.shared.tool_node import build_tool_node_graph
 from universal_mcp.agents.utils import messages_to_list
-from collections import defaultdict
+
 
 class Agent(BaseModel):
     """Agent that can be created by the builder."""
@@ -24,9 +25,7 @@ class Agent(BaseModel):
     description: str = Field(description="A small description of the agent.")
     expertise: str = Field(description="The expertise of the agent.")
     instructions: str = Field(description="The instructions for the agent to follow.")
-    schedule: str | None = Field(
-        description="The cron expression for the agent to run on.", default=None
-    )
+    schedule: str | None = Field(description="The cron expression for the agent to run on.", default=None)
 
 
 class BuilderState(TypedDict):
@@ -79,9 +78,7 @@ Create an agent that feels thoughtfully designed, intelligent, and professionall
 """
 
 
-async def generate_agent(
-    llm: BaseChatModel, task: str, old_agent: Agent | None = None
-) -> Agent:
+async def generate_agent(llm: BaseChatModel, task: str, old_agent: Agent | None = None) -> Agent:
     """Generates an agent from a task, optionally modifying an existing one."""
     prompt_parts = [AGENT_BUILDER_INSTRUCTIONS]
     if old_agent:
@@ -111,7 +108,7 @@ class BuilderAgent(BaseAgent):
     ):
         super().__init__(name, instructions, model, memory, **kwargs)
         self.registry = registry
-        self.llm: BaseChatModel = load_chat_model(model)
+        self.llm: BaseChatModel = load_chat_model(model, thinking=False)
 
     async def _create_agent(self, state: BuilderState):
         last_message = state["messages"][-1]
@@ -129,11 +126,7 @@ class BuilderAgent(BaseAgent):
         yield {
             "user_task": task,
             "generated_agent": generated_agent,
-            "messages": [
-                AIMessage(
-                    content=("I've designed an agent to help you with your task.")
-                )
-            ],
+            "messages": [AIMessage(content=("I've designed an agent to help you with your task."))],
         }
 
     async def _create_tool_config(self, state: BuilderState):
@@ -146,7 +139,7 @@ class BuilderAgent(BaseAgent):
             ]
         }
         tool_finder_graph = build_tool_node_graph(self.llm, self.registry)
-        
+
         initial_state = {
             "original_task": task,
             "messages": [HumanMessage(content=task)],
@@ -165,9 +158,7 @@ class BuilderAgent(BaseAgent):
                     apps_with_tools[app_id].extend(tool_ids)
 
             # Convert to a regular dict and remove any duplicate tool_ids for the same app
-            tool_config = {
-                app_id: list(set(tools)) for app_id, tools in apps_with_tools.items()
-            }
+            tool_config = {app_id: list(set(tools)) for app_id, tools in apps_with_tools.items()}
             final_message = "I have selected the necessary tools for the agent. The agent is ready!"
         else:
             # Handle the case where the graph failed to create a plan
@@ -175,9 +166,7 @@ class BuilderAgent(BaseAgent):
 
         yield {
             "tool_config": tool_config,
-            "messages": [
-                AIMessage(content=final_message)
-            ],
+            "messages": [AIMessage(content=final_message)],
         }
 
     async def _build_graph(self):
@@ -205,6 +194,7 @@ async def main():
         "Send a daily email to manoj@agentr.dev with daily agenda of the day",
     )
     from rich import print
+
     print(messages_to_list(result["messages"]))
     print(result["generated_agent"])
     print(result["tool_config"])

universal_mcp/agents/cli.py

@@ -20,7 +20,6 @@ def run(name: str = "react"):
     """Run the agent CLI"""
     import asyncio
 
-
     setup_logger(log_file=None, level="ERROR")
     client = AgentrClient()
     params = {
@@ -30,7 +29,7 @@ def run(name: str = "react"):
         "memory": MemorySaver(),
         "tools": {
             "google_mail": ["send_email"],
-        }
+        },
     }
     agent_cls = get_agent(name)
     agent = agent_cls(name, **params)

universal_mcp/agents/codeact/__init__.py

@@ -1,3 +1,3 @@
 from .agent import CodeActAgent
 
-__all__ = ["CodeActAgent"]
+__all__ = ["CodeActAgent"]

universal_mcp/agents/codeact/__main__.py

@@ -1,23 +1,33 @@
 import asyncio
 
+from langgraph.checkpoint.memory import MemorySaver
+from rich import print
 from universal_mcp.agentr.registry import AgentrRegistry
+
 from universal_mcp.agents.codeact.agent import CodeActAgent
 from universal_mcp.agents.utils import messages_to_list
 
 
 async def main():
+    memory = MemorySaver()
     agent = CodeActAgent(
         "CodeAct Agent",
         instructions="Be very concise in your answers.",
-        model="azure/gpt-4o",
-        tools={"google_mail": ["send_email"]},
+        model="anthropic:claude-4-sonnet-20250514",
+        tools={"google_mail": ["list_messages"]},
         registry=AgentrRegistry(),
+        memory=memory,
     )
+    print("Starting agent...")
+    # await agent.ainit()
+    # await agent.run_interactive()
+    # async for event in agent.stream(
+    #     user_input="Fetch unsubscribe links from my Gmail inbox for promo emails I have received in the last 7 days"
+    # ):
+    #     print(event.content, end="")
     result = await agent.invoke(
-        "Send an email to manoj@agentr.dev from my Gmail account with a subject 'testing codeact agent' and body 'This is a test of the codeact agent.'"
+        user_input="Fetch unsubscribe links from my Gmail inbox for promo emails I have received in the last 7 days"
     )
-    from rich import print
-
     print(messages_to_list(result["messages"]))
 
 

universal_mcp/agents/codeact/agent.py

@@ -1,25 +1,23 @@
-import inspect
-from typing import Callable, Union
+from collections.abc import Callable
 
-from langchain_core.language_models import BaseChatModel
-from langchain_core.tools import StructuredTool, tool as create_tool
+from langchain_core.messages import AIMessageChunk
+from langchain_core.tools import StructuredTool
+from langchain_core.tools import tool as create_tool
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import END, StateGraph
-from loguru import logger
+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.llm import load_chat_model
 from universal_mcp.agents.codeact.prompts import (
     create_default_prompt,
     make_safe_function_name,
-    REFLECTION_PROMPT,
-    RETRY_PROMPT,
 )
 from universal_mcp.agents.codeact.sandbox import eval_unsafe
 from universal_mcp.agents.codeact.state import CodeActState
 from universal_mcp.agents.codeact.utils import extract_and_combine_codeblocks
+from universal_mcp.agents.llm import load_chat_model
 
 
 class CodeActAgent(BaseAgent):
@@ -31,51 +29,29 @@ class CodeActAgent(BaseAgent):
         memory: BaseCheckpointSaver | None = None,
         tools: ToolConfig | None = None,
         registry: ToolRegistry | None = None,
-        *,
-        reflection_prompt: str = None,
-        reflection_model: BaseChatModel = None,
-        max_reflections: int = 3,
+        sandbox_timeout: int = 20,
         **kwargs,
     ):
         super().__init__(name, instructions, model, memory, **kwargs)
-        self.model_instance = load_chat_model(model)
+        self.model_instance = load_chat_model(model, thinking=False)
         self.tools_config = tools or {}
         self.registry = registry
         self.eval_fn = eval_unsafe
-        self.reflection_prompt = reflection_prompt
-        self.reflection_model = reflection_model or self.model_instance
-        self.max_reflections = max_reflections if reflection_prompt else 0
-        self.tools_context = {}
-        self.processed_tools: list[Union[StructuredTool, Callable]] = []
+        self.sandbox_timeout = sandbox_timeout
+        self.processed_tools: list[StructuredTool | Callable] = []
 
     async def _build_graph(self):
         if self.tools_config:
             if not self.registry:
                 raise ValueError("Tools are configured but no registry is provided")
             # Langchain tools are fine
-            exported_tools = await self.registry.export_tools(
-                self.tools_config, ToolFormat.LANGCHAIN
-            )
-            self.processed_tools = [
-                t if isinstance(t, StructuredTool) else create_tool(t)
-                for t in exported_tools
-            ]
+            exported_tools = await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
+            self.processed_tools = [t if isinstance(t, StructuredTool) else create_tool(t) for t in exported_tools]
 
-        self.instructions = create_default_prompt(
-            self.processed_tools, self.instructions
-        )
-
-        for tool in self.processed_tools:
-            safe_name = make_safe_function_name(tool.name)
-            tool_callable = (
-                tool.coroutine
-                if hasattr(tool, "coroutine") and tool.coroutine is not None
-                else tool.func
-            )
-            self.tools_context[safe_name] = tool_callable
+        self.instructions = create_default_prompt(self.processed_tools, self.instructions)
 
         agent = StateGraph(CodeActState)
-        agent.add_node("call_model", lambda state, config: self.call_model(state, config))
+        agent.add_node("call_model", self.call_model)
         agent.add_node("sandbox", self.sandbox)
 
         agent.set_entry_point("call_model")
@@ -91,81 +67,72 @@ class CodeActAgent(BaseAgent):
         return agent.compile(checkpointer=self.memory)
 
     def should_run_sandbox(self, state: CodeActState) -> str:
+        last_message = state["messages"][-1]
+        if isinstance(last_message.content, str) and "TASK_COMPLETE" in last_message.content:
+            return END
+
         if state.get("script"):
             return "sandbox"
         return END
 
-    def call_model(self, state: CodeActState, config: dict) -> dict:
-        context = config.get("context", {})
-        instructions = context.get("system_prompt", self.instructions)
-        model = self.model_instance
-        reflection_model = self.reflection_model
-
-        messages = [{"role": "system", "content": instructions}] + state["messages"]
-
-        response = model.invoke(messages)
-
-        code = extract_and_combine_codeblocks(response.content)
-
-        if self.max_reflections > 0 and code:
-            reflection_count = 0
-            while reflection_count < self.max_reflections:
-                conversation_history = "\n".join(
-                    [
-                        f'<message role="{("user" if m.type == "human" else "assistant")}">\n{m.content}\n</message>'
-                        for m in state["messages"]
-                    ]
-                )
-                conversation_history += (
-                    f'\n<message role="assistant">\n{response.content}\n</message>'
-                )
+    def _extract_content(self, response: AIMessageChunk) -> str:
+        if isinstance(response.content, list):
+            content = " ".join([c.get("text", "") for c in response.content])
+        else:
+            content = response.content
+        return content
 
-                formatted_prompt = REFLECTION_PROMPT.format(
-                    conversation_history=conversation_history
-                )
+    async def call_model(self, state: CodeActState) -> dict:
+        logger.debug(f"Calling model with state: {state}")
+        model = self.model_instance
 
-                reflection_messages = [
-                    {"role": "system", "content": self.reflection_prompt},
-                    {"role": "user", "content": formatted_prompt},
-                ]
-                reflection_result = reflection_model.invoke(reflection_messages)
+        # Find the last script and its output in the message history
+        previous_script = state.get("script", "")
+        sandbox_output = state.get("sandbox_output", "")
 
-                if "NONE" in reflection_result.content:
-                    break
+        logger.debug(f"Previous script: {previous_script}")
+        logger.debug(f"Sandbox output: {sandbox_output}")
 
-                retry_prompt = RETRY_PROMPT.format(
-                    reflection_result=reflection_result.content
+        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 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, please generate a new, improved script to continue the task. Remember to replace the old script entirely."
+            prompt_messages.append({"role": "user", "content": feedback_message})
 
-                regeneration_messages = [
-                    {"role": "system", "content": instructions},
-                    *state["messages"],
-                    {"role": "assistant", "content": response.content},
-                    {"role": "user", "content": retry_prompt},
-                ]
-                response = model.invoke(regeneration_messages)
+        logger.debug(f"Prompt messages: {prompt_messages}")
 
-                code = extract_and_combine_codeblocks(response.content)
+        response = await model.ainvoke(prompt_messages)
+        logger.debug(f"Model response: {response}")
 
-                if not code:
-                    break
+        text_content = self._extract_content(response)
+        if not isinstance(text_content, str):
+            raise ValueError(f"Content is not a string: {text_content}")
+        code = extract_and_combine_codeblocks(text_content)
+        logger.debug(f"Extracted code: {code}")
 
-                reflection_count += 1
-
-        if code:
-            return {"messages": [response], "script": code}
-        else:
-            return {"messages": [response], "script": None}
+        return {"messages": [response], "script": code}
 
     async def sandbox(self, state: CodeActState) -> dict:
-        existing_context = state.get("context", {})
-        context = {**existing_context, **self.tools_context}
-        if inspect.iscoroutinefunction(self.eval_fn):
-            output, new_vars = await self.eval_fn(state["script"], context)
-        else:
-            output, new_vars = self.eval_fn(state["script"], context)
-        new_context = {**existing_context, **new_vars}
+        logger.debug(f"Running sandbox with state: {state}")
+        tools_context = {}
+        for tool in self.processed_tools:
+            safe_name = make_safe_function_name(tool.name)
+            tool_callable = tool.coroutine if hasattr(tool, "coroutine") and tool.coroutine is not None else tool.func
+            tools_context[safe_name] = tool_callable
+
+        output, _ = await self.eval_fn(state["script"], tools_context, self.sandbox_timeout)
+        logger.debug(f"Sandbox output: {output}")
         return {
-            "messages": [{"role": "user", "content": output}],
-            "context": new_context,
-        }
+            "messages": [AIMessageChunk(content=output.strip())],
+            "script": None,
+            "sandbox_output": output.strip(),
+        }

universal_mcp/agents/codeact/prompts.py

@@ -1,8 +1,8 @@
 import inspect
 import re
-from typing import Optional, Sequence
+from collections.abc import Sequence
 
-from langchain_core.tools import StructuredTool, tool as create_tool
+from langchain_core.tools import StructuredTool
 
 
 def make_safe_function_name(name: str) -> str:
@@ -20,23 +20,34 @@ def make_safe_function_name(name: str) -> str:
 
 def create_default_prompt(
     tools: Sequence[StructuredTool],
-    base_prompt: Optional[str] = None,
+    base_prompt: str | None = None,
 ):
     """Create default prompt for the CodeAct agent."""
     prompt = f"{base_prompt}\n\n" if base_prompt else ""
-    prompt += """You will be given a task to perform. You should output either
-- a Python code snippet that provides the solution to the task, or a step towards the solution. Any output you want to extract from the code should be printed to the console. Code should be output in a fenced code block.
-- text to be shown directly to the user, if you want to ask for more information or provide the final answer.
+    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 in tools:
         # Use coroutine if it exists, otherwise use func
-        tool_callable = (
-            tool.coroutine
-            if hasattr(tool, "coroutine") and tool.coroutine is not None
-            else tool.func
-        )
+        tool_callable = tool.coroutine if hasattr(tool, "coroutine") and tool.coroutine is not None else tool.func
         # Create a safe function name
         safe_name = make_safe_function_name(tool.name)
         # Determine if it's an async function
@@ -44,20 +55,19 @@ In addition to the Python Standard Library, you can use the following functions:
         # Add appropriate function definition
         prompt += f'''\n{"async " if is_async else ""}def {safe_name}{str(inspect.signature(tool_callable))}:
     """{tool.description}"""
-    ... 
+    ...
 '''
 
-    prompt += """
-
-Variables defined at the top level of previous code snippets can be referenced in your code.
-
-Always 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'.
+    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. Only write code up to the point where you make an API call/tool usage with an output
-2. Print the type/shape and a sample entry of this output, and using that knowledge proceed to write the further code
+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.
 
 This means:
 - Write code that makes the API call or tool usage
@@ -66,27 +76,7 @@ This means:
 - 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"""
-    return prompt
-
+Reminder: use Python code snippets to call tools
 
-REFLECTION_PROMPT = """
-Review the assistant's latest code for as per the quality rules:
-
-<conversation_history>
-{conversation_history}
-</conversation_history>
-
-If you find ANY of these issues, describe the problem briefly and clearly.
-If NO issues are found, respond with EXACTLY: "NONE"
-"""
-
-RETRY_PROMPT = """
-I need you to completely regenerate your previous response based on this feedback:
-
-'''
-{reflection_result}
-'''
-
-DO NOT reference the feedback directly. Instead, provide a completely new response that addresses the issues.
-"""
+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. After you have provided the final output, you MUST end your response with the exact phrase "TASK_COMPLETE"."""
+    return prompt

universal_mcp/agents/codeact/sandbox.py

@@ -4,45 +4,36 @@ import contextlib
 import io
 from typing import Any
 
+from loguru import logger
 
-async def eval_unsafe(code: str, _locals: dict[str, Any]) -> tuple[str, dict[str, Any]]:
-    """
-    Execute code in a non-blocking way and return the output and changed variables.
-    """
+
+async def eval_unsafe(code: str, _locals: dict[str, Any], timeout: int = 10) -> tuple[str, dict[str, Any]]:
+    """Executes a string of Python code in a sandboxed environment."""
+    # Store original keys before execution
+    original_keys = set(_locals.keys())
     result = f"Executing code...\n{code}\n\nOutput:\n"
     result += "=" * 50 + "\n"
-
-    # Create a combined globals/locals environment that includes builtins
-    # and the provided context. This allows nested functions to access tools.
-    execution_env = {**builtins.__dict__, **_locals}
-
-    def sync_eval_in_thread():
-        """Synchronously execute code and capture output."""
-        try:
-            with contextlib.redirect_stdout(io.StringIO()) as f:
-                exec(code, execution_env)
-            output = f.getvalue()
-            if not output:
-                output = "<code ran, no output printed to stdout>"
-            return output
-        except Exception as e:
-            return f"Error during execution: {repr(e)}"
-
-    # Run the synchronous exec in a separate thread to avoid blocking the event loop.
-    output = await asyncio.to_thread(sync_eval_in_thread)
-    result += output
-
-    # Identify all variables that are not part of the original builtins
-    # and were not in the initial _locals, or were changed.
-    changed_vars = {}
-    builtin_keys = set(builtins.__dict__.keys())
-
-    for key, value in execution_env.items():
-        if key in builtin_keys:
-            continue  # Skip builtins
-
-        # Check if the key is new or if the value has changed
-        if key not in _locals or _locals[key] is not value:
-            changed_vars[key] = value
-
-    return result, changed_vars
+    try:
+        logger.debug(f"Executing code with timeout {timeout}")
+        with contextlib.redirect_stdout(io.StringIO()) as f:
+            # Execute the code in the provided locals context
+            # This should define an async function `main`
+            exec(code, builtins.__dict__, _locals)
+
+            if "main" in _locals and asyncio.iscoroutinefunction(_locals["main"]):
+                # Run the main async function
+                await asyncio.wait_for(_locals["main"](), timeout=timeout)
+            else:
+                result += "\nError: No `async def main()` function found in the script."
+
+        output = f.getvalue()
+        result += output
+        if not output:
+            result += "<code ran, no output printed to stdout>"
+    except Exception as e:
+        result += f"Error during execution: {repr(e)}"
+
+    # Determine new variables created during execution
+    new_keys = set(_locals.keys()) - original_keys
+    new_vars = {key: _locals[key] for key in new_keys}
+    return result, new_vars

universal_mcp/agents/codeact/state.py

@@ -1,12 +1,9 @@
-from typing import Any, Optional
-
 from langgraph.graph import MessagesState
+from pydantic import Field
 
 
 class CodeActState(MessagesState):
     """State for CodeAct agent."""
 
-    script: Optional[str]
-    """The Python code script to be executed."""
-    context: dict[str, Any]
-    """Dictionary containing the execution context with available tools and variables."""
+    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.")

universal_mcp/agents/codeact/utils.py

@@ -1,5 +1,7 @@
 import re
 
+from universal_mcp.logger import logger
+
 BACKTICK_PATTERN = r"(?:^|\n)```(.*?)(?:```(?:\n|$))"
 
 
@@ -37,7 +39,12 @@ def extract_and_combine_codeblocks(text: str) -> str:
     """
     # Find all code blocks in the text using regex
     # Pattern matches anything between triple backticks, with or without a language identifier
-    code_blocks = re.findall(BACKTICK_PATTERN, text, re.DOTALL)
+    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 ""
@@ -46,15 +53,15 @@ def extract_and_combine_codeblocks(text: str) -> str:
     processed_blocks = []
     for block in code_blocks:
         # Strip leading and trailing whitespace
-        block = block.strip()
+        cleaned_block = block.strip()
 
         # If the first line looks like a language identifier, remove it
-        lines = block.split("\n")
+        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)
-            block = "\n".join(lines[1:])
+            cleaned_block = "\n".join(lines[1:])
 
-        processed_blocks.append(block)
+        processed_blocks.append(cleaned_block)
 
     # Combine all codeblocks with newlines between them
     combined_code = "\n\n".join(processed_blocks)

universal_mcp/agents/hil.py

@@ -63,12 +63,7 @@ def handle_interrupt(interrupt: Interrupt) -> str | bool:
         value = input("Do you accept this? (y/n): " + interrupt.value["question"])
         return value.lower() in ["y", "yes"]
     elif interrupt_type == "choice":
-        value = input(
-            "Enter your choice: "
-            + interrupt.value["question"]
-            + " "
-            + ", ".join(interrupt.value["choices"])
-        )
+        value = input("Enter your choice: " + interrupt.value["question"] + " " + ", ".join(interrupt.value["choices"]))
         if value in interrupt.value["choices"]:
             return value
         else: