mini-swe-agent 1.9.0__tar.gz → 1.10.0__tar.gz

{mini_swe_agent-1.9.0/src/mini_swe_agent.egg-info → mini_swe_agent-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-swe-agent
-Version: 1.9.0
+Version: 1.10.0
 Summary: Nano SWE Agent - A simple AI software engineering agent
 Author-email: Kilian Lieret <kilian.lieret@posteo.de>, "Carlos E. Jimenez" <carlosej@princeton.edu>
 License: MIT License
@@ -48,6 +48,7 @@ Requires-Dist: typer
 Requires-Dist: platformdirs
 Requires-Dist: textual
 Requires-Dist: prompt_toolkit
+Requires-Dist: openai!=1.100.0,!=1.100.1
 Provides-Extra: full
 Requires-Dist: mini-swe-agent[dev]; extra == "full"
 Requires-Dist: swe-rex>=1.4.0; extra == "full"
@@ -72,7 +73,7 @@ Dynamic: license-file
 
 # The 100 line AI agent that solves GitHub issues & more
 
-📣 [Run `mini` with GPT-5 and friends: Read here](https://mini-swe-agent.com/latest/quickstart/#gpt-5)
+📣 [New blogpost: Randomly switching between GPT-5 and Sonnet 4 boosts performance](https://www.swebench.com/SWE-bench/blog/2025/08/19/mini-roulette/)
 
 [![Docs](https://img.shields.io/badge/Docs-green?style=for-the-badge&logo=materialformkdocs&logoColor=white)](https://mini-swe-agent.com/latest/)
 [![Slack](https://img.shields.io/badge/Slack-4A154B?style=for-the-badge&logo=slack&logoColor=white)](https://join.slack.com/t/swe-bench/shared_invite/zt-36pj9bu5s-o3_yXPZbaH2wVnxnss1EkQ)

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/README.md

@@ -4,7 +4,7 @@
 
 # The 100 line AI agent that solves GitHub issues & more
 
-📣 [Run `mini` with GPT-5 and friends: Read here](https://mini-swe-agent.com/latest/quickstart/#gpt-5)
+📣 [New blogpost: Randomly switching between GPT-5 and Sonnet 4 boosts performance](https://www.swebench.com/SWE-bench/blog/2025/08/19/mini-roulette/)
 
 [![Docs](https://img.shields.io/badge/Docs-green?style=for-the-badge&logo=materialformkdocs&logoColor=white)](https://mini-swe-agent.com/latest/)
 [![Slack](https://img.shields.io/badge/Slack-4A154B?style=for-the-badge&logo=slack&logoColor=white)](https://join.slack.com/t/swe-bench/shared_invite/zt-36pj9bu5s-o3_yXPZbaH2wVnxnss1EkQ)

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/pyproject.toml

@@ -42,6 +42,7 @@ dependencies = [
     "platformdirs",
     "textual",
     "prompt_toolkit",
+    "openai != 1.100.0,!=1.100.1",  # https://github.com/SWE-agent/mini-swe-agent/issues/446
 ]
 
 [project.optional-dependencies]

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0/src/mini_swe_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-swe-agent
-Version: 1.9.0
+Version: 1.10.0
 Summary: Nano SWE Agent - A simple AI software engineering agent
 Author-email: Kilian Lieret <kilian.lieret@posteo.de>, "Carlos E. Jimenez" <carlosej@princeton.edu>
 License: MIT License
@@ -48,6 +48,7 @@ Requires-Dist: typer
 Requires-Dist: platformdirs
 Requires-Dist: textual
 Requires-Dist: prompt_toolkit
+Requires-Dist: openai!=1.100.0,!=1.100.1
 Provides-Extra: full
 Requires-Dist: mini-swe-agent[dev]; extra == "full"
 Requires-Dist: swe-rex>=1.4.0; extra == "full"
@@ -72,7 +73,7 @@ Dynamic: license-file
 
 # The 100 line AI agent that solves GitHub issues & more
 
-📣 [Run `mini` with GPT-5 and friends: Read here](https://mini-swe-agent.com/latest/quickstart/#gpt-5)
+📣 [New blogpost: Randomly switching between GPT-5 and Sonnet 4 boosts performance](https://www.swebench.com/SWE-bench/blog/2025/08/19/mini-roulette/)
 
 [![Docs](https://img.shields.io/badge/Docs-green?style=for-the-badge&logo=materialformkdocs&logoColor=white)](https://mini-swe-agent.com/latest/)
 [![Slack](https://img.shields.io/badge/Slack-4A154B?style=for-the-badge&logo=slack&logoColor=white)](https://join.slack.com/t/swe-bench/shared_invite/zt-36pj9bu5s-o3_yXPZbaH2wVnxnss1EkQ)

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/mini_swe_agent.egg-info/SOURCES.txt

@@ -23,16 +23,20 @@ src/minisweagent/config/mini.yaml
 src/minisweagent/config/mini_no_temp.yaml
 src/minisweagent/config/extra/__init__.py
 src/minisweagent/config/extra/swebench.yaml
+src/minisweagent/config/extra/swebench_roulette.yaml
 src/minisweagent/environments/__init__.py
 src/minisweagent/environments/docker.py
 src/minisweagent/environments/local.py
 src/minisweagent/environments/singularity.py
 src/minisweagent/environments/extra/__init__.py
+src/minisweagent/environments/extra/bubblewrap.py
 src/minisweagent/environments/extra/swerex_docker.py
 src/minisweagent/models/__init__.py
 src/minisweagent/models/anthropic.py
 src/minisweagent/models/litellm_model.py
 src/minisweagent/models/test_models.py
+src/minisweagent/models/extra/__init__.py
+src/minisweagent/models/extra/roulette.py
 src/minisweagent/models/utils/__init__.py
 src/minisweagent/models/utils/cache_control.py
 src/minisweagent/models/utils/key_per_thread.py

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/mini_swe_agent.egg-info/requires.txt

@@ -9,6 +9,7 @@ typer
 platformdirs
 textual
 prompt_toolkit
+openai!=1.100.0,!=1.100.1
 
 [dev]
 datasets

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/__init__.py

@@ -8,7 +8,7 @@ This file provides:
   unless you want the static type checking.
 """
 
-__version__ = "1.9.0"
+__version__ = "1.10.0"
 
 import os
 from pathlib import Path
@@ -18,6 +18,8 @@ import dotenv
 from platformdirs import user_config_dir
 from rich.console import Console
 
+from minisweagent.utils.log import logger
+
 package_dir = Path(__file__).resolve().parent
 
 global_config_dir = Path(os.getenv("MSWEA_GLOBAL_CONFIG_DIR") or user_config_dir("mini-swe-agent"))
@@ -64,8 +66,18 @@ class Agent(Protocol):
     model: Model
     env: Environment
     messages: list[dict[str, str]]
+    config: Any
 
     def run(self, task: str, **kwargs) -> tuple[str, str]: ...
 
 
-__all__ = ["Agent", "Model", "Environment", "package_dir", "__version__", "global_config_file", "global_config_dir"]
+__all__ = [
+    "Agent",
+    "Model",
+    "Environment",
+    "package_dir",
+    "__version__",
+    "global_config_file",
+    "global_config_dir",
+    "logger",
+]

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/agents/interactive.py

@@ -39,9 +39,9 @@ class InteractiveAgent(DefaultAgent):
         super().__init__(*args, config_class=config_class, **kwargs)
         self.cost_last_confirmed = 0.0
 
-    def add_message(self, role: str, content: str):
+    def add_message(self, role: str, content: str, **kwargs):
         # Extend supermethod to print messages
-        super().add_message(role, content)
+        super().add_message(role, content, **kwargs)
         if role == "assistant":
             console.print(
                 f"\n[red][bold]mini-swe-agent[/bold] (step [bold]{self.model.n_calls}[/bold], [bold]${self.model.cost:.2f}[/bold]):[/red]\n",

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/agents/interactive_textual.py

@@ -44,8 +44,8 @@ class _TextualAgent(DefaultAgent):
         super().__init__(*args, config_class=TextualAgentConfig, **kwargs)
         self._current_action_from_human = False
 
-    def add_message(self, role: str, content: str):
-        super().add_message(role, content)
+    def add_message(self, role: str, content: str, **kwargs):
+        super().add_message(role, content, **kwargs)
         if self.app.agent_state != "UNINITIALIZED":
             self.app.call_from_thread(self.app.on_message_added)
 
@@ -276,13 +276,17 @@ class TextualAgent(App):
 
         self._vscroll = VerticalScroll()
 
-    def run(self, task: str) -> tuple[str, str]:
-        threading.Thread(target=lambda: self.agent.run(task), daemon=True).start()
+    def run(self, task: str, **kwargs) -> tuple[str, str]:
+        threading.Thread(target=lambda: self.agent.run(task, **kwargs), daemon=True).start()
         super().run()
         return self.exit_status, self.result
 
     # --- Basics ---
 
+    @property
+    def config(self):
+        return self.agent.config
+
     @property
     def i_step(self) -> int:
         """Current step index."""

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/config/extra/swebench.yaml

@@ -36,7 +36,7 @@ agent:
     2. Provide exactly ONE bash command to execute
 
     ## Important Boundaries
-    - MODIFY: Regular source code files in {{working_dir}}
+    - MODIFY: Regular source code files in /testbed (this is the working directory for all your subsequent commands)
     - DO NOT MODIFY: Tests, configuration files (pyproject.toml, setup.cfg, etc.)
 
     ## Recommended Workflow

mini_swe_agent-1.10.0/src/minisweagent/config/extra/swebench_roulette.yaml

@@ -0,0 +1,233 @@
+agent:
+  system_template: |
+    You are a helpful assistant that can interact multiple times with a computer shell to solve programming tasks.
+    Your response must contain exactly ONE bash code block with ONE command (or commands connected with && or ||).
+
+    Include a THOUGHT section before your command where you explain your reasoning process.
+    Format your response as shown in <format_example>.
+
+    <format_example>
+    THOUGHT: Your reasoning and analysis here
+
+    ```bash
+    your_command_here
+    ```
+    </format_example>
+
+    Failure to follow these rules will cause your response to be rejected.
+  instance_template: |
+    <pr_description>
+    Consider the following PR description:
+    {{task}}
+    </pr_description>
+
+    <instructions>
+    # Task Instructions
+
+    ## Overview
+    You're a software engineer interacting continuously with a computer by submitting commands.
+    You'll be helping implement necessary changes to meet requirements in the PR description.
+    Your task is specifically to make changes to non-test files in the current directory in order to fix the issue described in the PR description in a way that is general and consistent with the codebase.
+
+    IMPORTANT: This is an interactive process where you will think and issue ONE command, see its result, then think and issue your next command.
+
+    For each response:
+    1. Include a THOUGHT section explaining your reasoning and what you're trying to accomplish
+    2. Provide exactly ONE bash command to execute
+
+    ## Important Boundaries
+    - MODIFY: Regular source code files in {{working_dir}}
+    - DO NOT MODIFY: Tests, configuration files (pyproject.toml, setup.cfg, etc.)
+
+    ## Recommended Workflow
+    1. Analyze the codebase by finding and reading relevant files
+    2. Create a script to reproduce the issue
+    3. Edit the source code to resolve the issue
+    4. Verify your fix works by running your script again
+    5. Test edge cases to ensure your fix is robust
+
+    ## Command Execution Rules
+    You are operating in an environment where
+    1. You write a single command
+    2. The system executes that command in a subshell
+    3. You see the result
+    4. You write your next command
+
+    Each response should include:
+    1. A **THOUGHT** section where you explain your reasoning and plan
+    2. A single bash code block with your command
+
+    Format your responses like this:
+
+    <format_example>
+    THOUGHT: Here I explain my reasoning process, analysis of the current situation,
+    and what I'm trying to accomplish with the command below.
+
+    ```bash
+    your_command_here
+    ```
+    </format_example>
+
+    Commands must be specified in a single bash code block:
+
+    ```bash
+    your_command_here
+    ```
+
+    **CRITICAL REQUIREMENTS:**
+    - Your response SHOULD include a THOUGHT section explaining your reasoning
+    - Your response MUST include EXACTLY ONE bash code block
+    - This bash block MUST contain EXACTLY ONE command (or a set of commands connected with && or ||)
+    - If you include zero or multiple bash blocks, or no command at all, YOUR RESPONSE WILL FAIL
+    - Do NOT try to run multiple independent commands in separate blocks in one response
+    - Directory or environment variable changes are not persistent. Every action is executed in a new subshell.
+    - However, you can prefix any action with `MY_ENV_VAR=MY_VALUE cd /path/to/working/dir && ...` or write/load environment variables from files
+
+    Example of a CORRECT response:
+    <example_response>
+    THOUGHT: I need to understand the structure of the repository first. Let me check what files are in the current directory to get a better understanding of the codebase.
+
+    ```bash
+    ls -la
+    ```
+    </example_response>
+
+    Example of an INCORRECT response:
+    <example_response>
+    THOUGHT: I need to examine the codebase and then look at a specific file. I'll run multiple commands to do this.
+
+    ```bash
+    ls -la
+    ```
+
+    Now I'll read the file:
+
+    ```bash
+    cat file.txt
+    ```
+    </example_response>
+
+    If you need to run multiple commands, either:
+    1. Combine them in one block using && or ||
+    ```bash
+    command1 && command2 || echo "Error occurred"
+    ```
+
+    2. Wait for the first command to complete, see its output, then issue the next command in your following response.
+
+    ## Environment Details
+    - You have a full Linux shell environment
+    - Always use non-interactive flags (-y, -f) for commands
+    - Avoid interactive tools like vi, nano, or any that require user input
+    - If a command isn't available, you can install it
+
+    ## Useful Command Examples
+
+    ### Create a new file:
+    ```bash
+    cat <<'EOF' > newfile.py
+    import numpy as np
+    hello = "world"
+    print(hello)
+    EOF
+    ```
+
+    ### Edit files with sed:
+    ```bash
+    # Replace all occurrences
+    sed -i 's/old_string/new_string/g' filename.py
+
+    # Replace only first occurrence
+    sed -i 's/old_string/new_string/' filename.py
+
+    # Replace first occurrence on line 1
+    sed -i '1s/old_string/new_string/' filename.py
+
+    # Replace all occurrences in lines 1-10
+    sed -i '1,10s/old_string/new_string/g' filename.py
+    ```
+
+    ### View file content:
+    ```bash
+    # View specific lines with numbers
+    nl -ba filename.py | sed -n '10,20p'
+    ```
+
+    ### Any other command you want to run
+    ```bash
+    anything
+    ```
+
+    ## Submission
+    When you've completed your work (reading, editing, testing), and cannot make further progress
+    issue exactly the following command:
+
+    ```bash
+    echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT && git add -A && git diff --cached
+    ```
+
+    This command will submit your work.
+    You cannot continue working (reading, editing, testing) in any way on this task after submitting.
+    </instructions>
+  action_observation_template: |
+    <returncode>{{output.returncode}}</returncode>
+    {% if output.output | length < 10000 -%}
+    <output>
+    {{ output.output -}}
+    </output>
+    {%- else -%}
+    <warning>
+    The output of your last command was too long.
+    Please try a different command that produces less output.
+    If you're looking at a file you can try use head, tail or sed to view a smaller number of lines selectively.
+    If you're using grep or find and it produced too much output, you can use a more selective search pattern.
+    If you really need to see something from the full command's output, you can redirect output to a file and then search in that file.
+    </warning>
+    {%- set elided_chars = output.output | length - 10000 -%}
+    <output_head>
+    {{ output.output[:5000] }}
+    </output_head>
+    <elided_chars>
+    {{ elided_chars }} characters elided
+    </elided_chars>
+    <output_tail>
+    {{ output.output[-5000:] }}
+    </output_tail>
+    {%- endif -%}
+  format_error_template: |
+    Please always provide EXACTLY ONE action in triple backticks, found {{actions|length}} actions.
+
+    Please format your action in triple backticks as shown in <response_example>.
+
+    <response_example>
+    Here are some thoughts about why you want to perform the action.
+
+    ```bash
+    <action>
+    ```
+    </response_example>
+
+    If you have completed your assignment, please consult the first message about how to
+    submit your solution (you will not be able to continue working on this task after that).
+  step_limit: 250
+  cost_limit: 3.
+
+environment:
+  cwd: "/testbed"
+  timeout: 60
+  env:
+    PAGER: cat
+    MANPAGER: cat
+    LESS: -R
+    PIP_PROGRESS_BAR: 'off'
+    TQDM_DISABLE: '1'
+  environment_class: docker
+
+model:
+  model_name: "roulette"
+  model_class: "minisweagent.models.extra.roulette.RouletteModel"
+  model_kwargs:
+    - model_name: "claude-sonnet-4-20250514"
+      model_kwargs:
+        temperature: 0.
+    - model_name: "gpt-5"

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/environments/__init__.py

@@ -10,6 +10,7 @@ _ENVIRONMENT_MAPPING = {
     "singularity": "minisweagent.environments.singularity.SingularityEnvironment",
     "local": "minisweagent.environments.local.LocalEnvironment",
     "swerex_docker": "minisweagent.environments.extra.swerex_docker.SwerexDockerEnvironment",
+    "bubblewrap": "minisweagent.environments.extra.bubblewrap.BubblewrapEnvironment",
 }
 
 

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/environments/docker.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import shlex
 import subprocess
@@ -5,8 +6,6 @@ import uuid
 from dataclasses import asdict, dataclass, field
 from typing import Any
 
-from minisweagent.utils.log import get_logger
-
 
 @dataclass
 class DockerEnvironmentConfig:
@@ -24,18 +23,20 @@ class DockerEnvironmentConfig:
     """Timeout for executing commands in the container."""
     executable: str = os.getenv("MSWEA_DOCKER_EXECUTABLE", "docker")
     """Path to the docker/container executable."""
-    run_args: list[str] = field(default_factory=list)
-    """Additional arguments to pass to the docker/container executable."""
+    run_args: list[str] = field(default_factory=lambda: ["--rm"])
+    """Additional arguments to pass to the docker/container executable.
+    Default is ["--rm"], which removes the container after it exits.
+    """
     container_timeout: str = "2h"
     """Max duration to keep container running. Uses the same format as the sleep command."""
 
 
 class DockerEnvironment:
-    def __init__(self, *, config_class: type = DockerEnvironmentConfig, **kwargs):
+    def __init__(self, *, config_class: type = DockerEnvironmentConfig, logger: logging.Logger | None = None, **kwargs):
         """This class executes bash commands in a Docker container using direct docker commands.
         See `DockerEnvironmentConfig` for keyword arguments.
         """
-        self.logger = get_logger("minisweagent.environment")
+        self.logger = logger or logging.getLogger("minisweagent.environment")
         self.container_id: str | None = None
         self.config = config_class(**kwargs)
         self._start_container()
@@ -97,7 +98,6 @@ class DockerEnvironment:
     def cleanup(self):
         """Stop and remove the Docker container."""
         if getattr(self, "container_id", None) is not None:  # if init fails early, container_id might not be set
-            self.logger.info(f"Stopping container {self.container_id}")
             cmd = f"(timeout 60 {self.config.executable} stop {self.container_id} || {self.config.executable} rm -f {self.container_id}) >/dev/null 2>&1 &"
             subprocess.Popen(cmd, shell=True)
 

mini_swe_agent-1.10.0/src/minisweagent/environments/extra/bubblewrap.py

@@ -0,0 +1,112 @@
+"""
+[Bubblewrap](https://github.com/containers/bubblewrap) is a low-level, unprivileged sandboxing tool for Linux that enables running applications
+in isolated environments with restricted access to the operating system and user data.
+This environment uses bubblewrap to execute commands in a sandboxed environment.
+
+!!! warning
+    This environment is experimental.
+
+!!! warning
+    This environment is not supported on Windows.
+"""
+
+import logging
+import os
+import platform
+import shutil
+import subprocess
+import tempfile
+import uuid
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class BubblewrapEnvironmentConfig:
+    cwd: str = ""
+    """Working directory for the sandbox."""
+    env: dict[str, str] = field(default_factory=dict)
+    """Dictionary of environment variables to set in the sandbox."""
+    timeout: int = 30
+    """Timeout for the command in seconds."""
+    executable: str = os.getenv("MSWEA_BUBBLEWRAP_EXECUTABLE", "bwrap")
+    """Path to the bubblewrap executable."""
+    wrapper_args: list[str] = field(
+        default_factory=lambda: [
+            "--unshare-user-try",
+            "--ro-bind",
+            "/usr",
+            "/usr",
+            "--ro-bind",
+            "/bin",
+            "/bin",
+            "--ro-bind",
+            "/lib",
+            "/lib",
+            "--ro-bind",
+            "/lib64",
+            "/lib64",
+            "--ro-bind",
+            "/etc",
+            "/etc",
+            "--tmpfs",
+            "/tmp",
+            "--proc",
+            "/proc",
+            "--dev",
+            "/dev",
+            "--new-session",
+            "--setenv",
+            "PATH",
+            "/usr/local/bin:/usr/sbin:/usr/bin:/bin",
+        ]
+    )
+    """Arguments to pass to the bubblewrap executable."""
+
+
+class BubblewrapEnvironment:
+    def __init__(
+        self, *, config_class: type = BubblewrapEnvironmentConfig, logger: logging.Logger | None = None, **kwargs
+    ):
+        """This class executes bash commands in a bubblewrap environment and a separate working
+        directory for each environment. See `BubblewrapEnvironmentConfig` for kwargs.
+        """
+        self.logger = logger or logging.getLogger("minisweagent.environment")
+        self.config = config_class(**kwargs)
+        self.working_dir = Path(tempfile.gettempdir()) / f"minisweagent-{uuid.uuid4().hex[:8]}"
+        self.working_dir.mkdir(parents=True)
+
+    def execute(self, command: str, cwd: str = "") -> dict[str, Any]:
+        """Execute a command in the bubblewrap environment and return the result as a dict."""
+        cwd = cwd or self.config.cwd or str(self.working_dir)
+
+        cmd = [self.config.executable] + self.config.wrapper_args + ["--bind", cwd, cwd, "--chdir", cwd]
+
+        # Add environment variables
+        for key, value in self.config.env.items():
+            cmd.extend(["--setenv", key, value])
+
+        cmd.extend(["bash", "-c", command])
+
+        result = subprocess.run(
+            cmd,
+            text=True,
+            timeout=self.config.timeout,
+            encoding="utf-8",
+            errors="replace",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        return {"output": result.stdout, "returncode": result.returncode}
+
+    def cleanup(self):
+        if self.working_dir.exists():
+            shutil.rmtree(self.working_dir)
+
+    def __del__(self):
+        """Cleanup working_dir when object is destroyed."""
+        self.cleanup()
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config) | platform.uname()._asdict()

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/environments/singularity.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 
+import logging
 import os
 import shutil
 import subprocess
@@ -9,8 +10,6 @@ from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any
 
-from minisweagent.utils.log import get_logger
-
 
 @dataclass
 class SingularityEnvironmentConfig:
@@ -24,18 +23,39 @@ class SingularityEnvironmentConfig:
     """Timeout for executing commands in the container."""
     executable: str = os.getenv("MSWEA_SINGULARITY_EXECUTABLE", "singularity")
     """Path to the singularity executable."""
+    sandbox_build_retries: int = 3
+    """Number of retries for building the sandbox if an error occurs."""
 
 
 class SingularityEnvironment:
-    def __init__(self, **kwargs):
+    def __init__(
+        self, *, config_class: type = SingularityEnvironmentConfig, logger: logging.Logger | None = None, **kwargs
+    ):
         """Singularity environment. See `SingularityEnvironmentConfig` for kwargs."""
-        self.logger = get_logger("minisweagent.environment")
-        self.config = SingularityEnvironmentConfig(**kwargs)
-        self.sandbox_dir = Path(tempfile.gettempdir()) / f"minisweagent-{uuid.uuid4().hex[:8]}"
-        subprocess.run(
-            [self.config.executable, "build", "--sandbox", self.sandbox_dir, self.config.image],
-            check=True,
-        )
+        self.logger = logger or logging.getLogger("minisweagent.environment")
+        self.config = config_class(**kwargs)
+        self.sandbox_dir = self._build_sandbox()
+
+    def _build_sandbox(self) -> Path:
+        # Building the sandbox can fail (very rarely), so we retry it
+        max_retries = self.config.sandbox_build_retries
+        for attempt in range(max_retries):
+            sandbox_dir = Path(tempfile.gettempdir()) / f"minisweagent-{uuid.uuid4().hex[:8]}"
+            try:
+                subprocess.run(
+                    [self.config.executable, "build", "--sandbox", sandbox_dir, self.config.image],
+                    check=True,
+                    capture_output=True,
+                )
+                break
+            except subprocess.CalledProcessError as e:
+                shutil.rmtree(sandbox_dir, ignore_errors=True)
+                self.logger.error(
+                    f"Error building image {self.config.image}, stdout: {e.stdout}, stderr: {e.stderr} (attempt {attempt + 1}/{max_retries})"
+                )
+                if attempt == max_retries - 1:
+                    raise
+        return sandbox_dir
 
     def get_template_vars(self) -> dict[str, Any]:
         return asdict(self.config)
@@ -70,9 +90,7 @@ class SingularityEnvironment:
         return {"output": result.stdout, "returncode": result.returncode}
 
     def cleanup(self):
-        if self.sandbox_dir.exists():
-            self.logger.info(f"Removing sandbox {self.sandbox_dir}")
-            shutil.rmtree(self.sandbox_dir)
+        shutil.rmtree(self.sandbox_dir, ignore_errors=True)
 
     def __del__(self):
         """Cleanup sandbox when object is destroyed."""

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/models/__init__.py

@@ -3,6 +3,7 @@ You can ignore this file completely if you explicitly set your model in your run
 """
 
 import copy
+import importlib
 import os
 import threading
 
@@ -49,12 +50,12 @@ def get_model(input_model_name: str | None = None, config: dict | None = None) -
     config = copy.deepcopy(config)
     config["model_name"] = resolved_model_name
 
-    # API key resolution (from env -> config -> None)
-    if "model_kwargs" not in config:
-        config["model_kwargs"] = {}
-    if from_env := os.getenv("MSWEA_MODEL_API_KEY"):
-        config["model_kwargs"]["api_key"] = from_env
-    return get_model_class(resolved_model_name)(**config)
+    model_class = get_model_class(resolved_model_name, config.pop("model_class", ""))
+
+    if (from_env := os.getenv("MSWEA_MODEL_API_KEY")) and not str(type(model_class)).endswith("DeterministicModel"):
+        config.setdefault("model_kwargs", {})["api_key"] = from_env
+
+    return model_class(**config)
 
 
 def get_model_name(input_model_name: str | None = None, config: dict | None = None) -> str:
@@ -63,19 +64,44 @@ def get_model_name(input_model_name: str | None = None, config: dict | None = No
         config = {}
     if input_model_name:
         return input_model_name
-    if from_env := os.getenv("MSWEA_MODEL_NAME"):
-        return from_env
     if from_config := config.get("model_name"):
         return from_config
+    if from_env := os.getenv("MSWEA_MODEL_NAME"):
+        return from_env
     raise ValueError("No default model set. Please run `mini-extra config setup` to set one.")
 
 
-def get_model_class(model_name: str) -> type:
-    """Select the best model class for a given model name."""
+_MODEL_CLASS_MAPPING = {
+    "anthropic": "minisweagent.models.anthropic.AnthropicModel",
+    "litellm": "minisweagent.models.litellm_model.LitellmModel",
+    "deterministic": "minisweagent.models.test_models.DeterministicModel",
+}
+
+
+def get_model_class(model_name: str, model_class: str = "") -> type:
+    """Select the best model class.
+
+    If a model_class is provided (as shortcut name, or as full import path,
+    e.g., "anthropic" or "minisweagent.models.anthropic.AnthropicModel"),
+    it takes precedence over the `model_name`.
+    Otherwise, the model_name is used to select the best model class.
+    """
+    if model_class:
+        full_path = _MODEL_CLASS_MAPPING.get(model_class, model_class)
+        try:
+            module_name, class_name = full_path.rsplit(".", 1)
+            module = importlib.import_module(module_name)
+            return getattr(module, class_name)
+        except (ValueError, ImportError, AttributeError):
+            msg = f"Unknown model class: {model_class} (resolved to {full_path}, available: {_MODEL_CLASS_MAPPING})"
+            raise ValueError(msg)
+
     if any(s in model_name.lower() for s in ["anthropic", "sonnet", "opus", "claude"]):
         from minisweagent.models.anthropic import AnthropicModel
 
         return AnthropicModel
+
+    # Default to LitellmModel
     from minisweagent.models.litellm_model import LitellmModel
 
     return LitellmModel

mini_swe_agent-1.10.0/src/minisweagent/models/extra/roulette.py

@@ -0,0 +1,62 @@
+import random
+from collections.abc import Callable
+from dataclasses import asdict, dataclass
+
+from minisweagent import Model
+from minisweagent.models import get_model
+
+
+@dataclass
+class RouletteModelConfig:
+    model_kwargs: list[dict]
+    """The models to choose from"""
+    model_name: str = "roulette"
+
+
+class RouletteModel:
+    def __init__(self, *, config_class: Callable = RouletteModelConfig, **kwargs):
+        """This "meta"-model randomly selects one of the models at every call"""
+        self.config = config_class(**kwargs)
+        self.models = [get_model(config=config) for config in self.config.model_kwargs]
+
+    @property
+    def cost(self) -> float:
+        return sum(model.cost for model in self.models)
+
+    @property
+    def n_calls(self) -> int:
+        return sum(model.n_calls for model in self.models)
+
+    def get_template_vars(self) -> dict:
+        return asdict(self.config) | {"n_model_calls": self.n_calls, "model_cost": self.cost}
+
+    def select_model(self) -> Model:
+        return random.choice(self.models)
+
+    def query(self, *args, **kwargs) -> dict:
+        model = self.select_model()
+        response = model.query(*args, **kwargs)
+        response["model_name"] = model.config.model_name
+        return response
+
+
+@dataclass
+class InterleavingModelConfig:
+    model_kwargs: list[dict]
+    sequence: list[int] | None = None
+    """If set to 0, 0, 1, we will return the first model 2 times, then the second model 1 time,
+    then the first model again, etc."""
+    model_name: str = "interleaving"
+
+
+class InterleavingModel(RouletteModel):
+    def __init__(self, *, config_class: Callable = InterleavingModelConfig, **kwargs):
+        """This "meta"-model alternates between the models in the sequence for every call"""
+        super().__init__(config_class=config_class, **kwargs)
+
+    def select_model(self) -> Model:
+        if self.config.sequence is None:
+            i_model = self.n_calls % len(self.models)
+        else:
+            i_model = self.config.sequence[self.n_calls % len(self.config.sequence)]
+        return self.models[i_model]

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/models/litellm_model.py

@@ -61,7 +61,15 @@ class LitellmModel:
 
     def query(self, messages: list[dict[str, str]], **kwargs) -> dict:
         response = self._query(messages, **kwargs)
-        cost = litellm.cost_calculator.completion_cost(response)
+        try:
+            cost = litellm.cost_calculator.completion_cost(response)
+        except Exception as e:
+            logger.critical(
+                f"Error calculating cost for model {self.config.model_name}: {e}. "
+                "Please check the 'Updating the model registry' section in the documentation. "
+                "http://bit.ly/4p31bi4 Still stuck? Please open a github issue for help!"
+            )
+            raise
         self.n_calls += 1
         self.cost += cost
         GLOBAL_MODEL_STATS.add(cost)

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/run/extra/swebench.py

@@ -24,7 +24,7 @@ from minisweagent.environments import get_environment
 from minisweagent.models import get_model
 from minisweagent.run.extra.utils.batch_progress import RunBatchProgressManager
 from minisweagent.run.utils.save import save_traj
-from minisweagent.utils.log import add_file_handlers, logger
+from minisweagent.utils.log import add_file_handler, logger
 
 _HELP_TEXT = """Run mini-SWE-agent on SWEBench instances.
 
@@ -78,7 +78,7 @@ def get_swebench_docker_image_name(instance: dict) -> str:
 
 def get_sb_environment(config: dict, instance: dict) -> Environment:
     image_name = get_swebench_docker_image_name(instance)
-    env_config = config.get("environment", {})
+    env_config = config.setdefault("environment", {})
     if env_config.get("environment_class") == "singularity":
         image_name = "docker://" + image_name
     env_config["image"] = image_name
@@ -190,6 +190,7 @@ def main(
     output: str = typer.Option("", "-o", "--output", help="Output directory", rich_help_panel="Basic"),
     workers: int = typer.Option(1, "-w", "--workers", help="Number of worker threads for parallel processing", rich_help_panel="Basic"),
     model: str | None = typer.Option(None, "-m", "--model", help="Model to use", rich_help_panel="Basic"),
+    model_class: str | None = typer.Option(None, "-c", "--model-class", help="Model class to use (e.g., 'anthropic' or 'minisweagent.models.anthropic.AnthropicModel')", rich_help_panel="Advanced"),
     redo_existing: bool = typer.Option(False, "--redo-existing", help="Redo existing instances", rich_help_panel="Data selection"),
     config_spec: Path = typer.Option( builtin_config_dir / "extra" / "swebench.yaml", "-c", "--config", help="Path to a config file", rich_help_panel="Basic"),
     environment_class: str | None = typer.Option( None, "--environment-class", help="Environment type to use. Recommended are docker or singularity", rich_help_panel="Advanced"),
@@ -198,7 +199,7 @@ def main(
     output_path = Path(output)
     output_path.mkdir(parents=True, exist_ok=True)
     logger.info(f"Results will be saved to {output_path}")
-    add_file_handlers(output_path / "minisweagent.log")
+    add_file_handler(output_path / "minisweagent.log")
 
     dataset_path = DATASET_MAPPING.get(subset, subset)
     logger.info(f"Loading dataset {dataset_path}, split {split}...")
@@ -217,6 +218,8 @@ def main(
         config.setdefault("environment", {})["environment_class"] = environment_class
     if model is not None:
         config.setdefault("model", {})["model_name"] = model
+    if model_class is not None:
+        config.setdefault("model", {})["model_class"] = model_class
 
     progress_manager = RunBatchProgressManager(len(instances), output_path / f"exit_statuses_{time.time()}.yaml")
 

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/run/extra/swebench_single.py

@@ -1,5 +1,6 @@
 """Run on a single SWE-Bench instance."""
 
+import traceback
 from pathlib import Path
 
 import typer
@@ -29,6 +30,7 @@ def main(
     split: str = typer.Option("dev", "--split", help="Dataset split", rich_help_panel="Data selection"),
     instance_spec: str = typer.Option(0, "-i", "--instance", help="SWE-Bench instance ID or index", rich_help_panel="Data selection"),
     model_name: str | None = typer.Option(None, "-m", "--model", help="Model to use", rich_help_panel="Basic"),
+    model_class: str | None = typer.Option(None, "-c", "--model-class", help="Model class to use (e.g., 'anthropic' or 'minisweagent.models.anthropic.AnthropicModel')", rich_help_panel="Advanced"),
     config_path: Path = typer.Option( builtin_config_dir / "extra" / "swebench.yaml", "-c", "--config", help="Path to a config file", rich_help_panel="Basic"),
     environment_class: str | None = typer.Option(None, "--environment-class", rich_help_panel="Advanced"),
     exit_immediately: bool = typer.Option( False, "--exit-immediately", help="Exit immediately when the agent wants to finish instead of prompting.", rich_help_panel="Basic"),
@@ -49,6 +51,8 @@ def main(
     config = yaml.safe_load(get_config_path(config_path).read_text())
     if environment_class is not None:
         config.setdefault("environment", {})["environment_class"] = environment_class
+    if model_class is not None:
+        config.setdefault("model", {})["model_class"] = model_class
     if exit_immediately:
         config.setdefault("agent", {})["confirm_exit"] = False
     env = get_sb_environment(config, instance)
@@ -58,11 +62,15 @@ def main(
         **({"mode": "yolo"} | config.get("agent", {})),
     )
 
-    exit_status, result = None, None
+    exit_status, result, extra_info = None, None, None
     try:
         exit_status, result = agent.run(instance["problem_statement"])  # type: ignore[arg-type]
+    except Exception as e:
+        logger.error(f"Error processing instance {instance_spec}: {e}", exc_info=True)
+        exit_status, result = type(e).__name__, str(e)
+        extra_info = {"traceback": traceback.format_exc()}
     finally:
-        save_traj(agent, output, exit_status=exit_status, result=result)  # type: ignore[arg-type]
+        save_traj(agent, output, exit_status=exit_status, result=result, extra_info=extra_info)  # type: ignore[arg-type]
 
 
 if __name__ == "__main__":

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/run/github_issue.py

@@ -48,7 +48,7 @@ def main(
     configure_if_first_time()
 
     _config = yaml.safe_load(get_config_path(config).read_text())
-    _agent_config = _config.get("agent", {})
+    _agent_config = _config.setdefault("agent", {})
     if yolo:
         _agent_config["mode"] = "yolo"
 

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/run/mini.py

@@ -4,6 +4,7 @@
 # Read this first: https://mini-swe-agent.com/latest/usage/mini/  (usage)
 
 import os
+import traceback
 from pathlib import Path
 from typing import Any
 
@@ -22,6 +23,7 @@ from minisweagent.environments.local import LocalEnvironment
 from minisweagent.models import get_model
 from minisweagent.run.extra.config import configure_if_first_time
 from minisweagent.run.utils.save import save_traj
+from minisweagent.utils.log import logger
 
 DEFAULT_CONFIG = Path(os.getenv("MSWEA_MINI_CONFIG_PATH", builtin_config_dir / "mini.yaml"))
 DEFAULT_OUTPUT = global_config_dir / "last_mini_run.traj.json"
@@ -41,29 +43,19 @@ More information about the usage: [bold green]https://mini-swe-agent.com/latest/
 """
 
 
+# fmt: off
 @app.command(help=_HELP_TEXT)
 def main(
-    visual: bool = typer.Option(
-        False,
-        "-v",
-        "--visual",
-        help="Toggle (pager-style) UI (Textual) depending on the MSWEA_VISUAL_MODE_DEFAULT environment setting",
-    ),
-    model_name: str | None = typer.Option(
-        None,
-        "-m",
-        "--model",
-        help="Model to use",
-    ),
+    visual: bool = typer.Option(False, "-v", "--visual", help="Toggle (pager-style) UI (Textual) depending on the MSWEA_VISUAL_MODE_DEFAULT environment setting",),
+    model_name: str | None = typer.Option( None, "-m", "--model", help="Model to use",),
     task: str | None = typer.Option(None, "-t", "--task", help="Task/problem statement", show_default=False),
     yolo: bool = typer.Option(False, "-y", "--yolo", help="Run without confirmation"),
     cost_limit: float | None = typer.Option(None, "-l", "--cost-limit", help="Cost limit. Set to 0 to disable."),
     config_spec: Path = typer.Option(DEFAULT_CONFIG, "-c", "--config", help="Path to config file"),
     output: Path | None = typer.Option(DEFAULT_OUTPUT, "-o", "--output", help="Output trajectory file"),
-    exit_immediately: bool = typer.Option(
-        False, "--exit-immediately", help="Exit immediately when the agent wants to finish instead of prompting."
-    ),
+    exit_immediately: bool = typer.Option( False, "--exit-immediately", help="Exit immediately when the agent wants to finish instead of prompting."),
 ) -> Any:
+    # fmt: on
     configure_if_first_time()
     config = yaml.safe_load(get_config_path(config_spec).read_text())
 
@@ -92,13 +84,18 @@ def main(
     agent_class = InteractiveAgent
     if visual == (os.getenv("MSWEA_VISUAL_MODE_DEFAULT", "false") == "false"):
         agent_class = TextualAgent
-    exit_status, result = None, None
+
     agent = agent_class(model, env, **config.get("agent", {}))
+    exit_status, result, extra_info = None, None, None
     try:
         exit_status, result = agent.run(task)  # type: ignore[arg-type]
+    except Exception as e:
+        logger.error(f"Error running agent: {e}", exc_info=True)
+        exit_status, result = type(e).__name__, str(e)
+        extra_info = {"traceback": traceback.format_exc()}
     finally:
         if output:
-            save_traj(agent, output, exit_status=exit_status, result=result)  # type: ignore[arg-type]
+            save_traj(agent, output, exit_status=exit_status, result=result, extra_info=extra_info)  # type: ignore[arg-type]
     return agent
 
 

{mini_swe_agent-1.9.0 → mini_swe_agent-1.10.0}/src/minisweagent/run/utils/save.py

@@ -1,10 +1,24 @@
+import dataclasses
 import json
 from collections.abc import Callable
 from pathlib import Path
+from typing import Any
 
 from minisweagent import Agent, __version__
 
 
+def _get_class_name_with_module(obj: Any) -> str:
+    """Get the full class name with module path."""
+    return f"{obj.__class__.__module__}.{obj.__class__.__name__}"
+
+
+def _asdict(obj: Any) -> dict:
+    """Convert config objects to dicts."""
+    if dataclasses.is_dataclass(obj):
+        return dataclasses.asdict(obj)  # type: ignore[arg-type]
+    return obj  # let's try our luck
+
+
 def save_traj(
     agent: Agent | None,
     path: Path,
@@ -45,6 +59,14 @@ def save_traj(
         data["info"]["model_stats"]["instance_cost"] = agent.model.cost
         data["info"]["model_stats"]["api_calls"] = agent.model.n_calls
         data["messages"] = agent.messages
+        data["info"]["config"] = {
+            "agent": _asdict(agent.config),
+            "model": _asdict(agent.model.config),
+            "environment": _asdict(agent.env.config),
+            "agent_type": _get_class_name_with_module(agent),
+            "model_type": _get_class_name_with_module(agent.model),
+            "environment_type": _get_class_name_with_module(agent.env),
+        }
     if extra_info:
         data["info"].update(extra_info)
 

mini_swe_agent-1.10.0/src/minisweagent/utils/log.py

@@ -0,0 +1,36 @@
+import logging
+from pathlib import Path
+
+from rich.logging import RichHandler
+
+
+def _setup_root_logger() -> None:
+    logger = logging.getLogger("minisweagent")
+    logger.setLevel(logging.DEBUG)
+    _handler = RichHandler(
+        show_path=False,
+        show_time=False,
+        show_level=False,
+        markup=True,
+    )
+    _formatter = logging.Formatter("%(name)s: %(levelname)s: %(message)s")
+    _handler.setFormatter(_formatter)
+    logger.addHandler(_handler)
+
+
+def add_file_handler(path: Path | str, level: int = logging.DEBUG, *, print_path: bool = True) -> None:
+    logger = logging.getLogger("minisweagent")
+    handler = logging.FileHandler(path)
+    handler.setLevel(level)
+    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    if print_path:
+        print(f"Logging to '{path}'")
+
+
+_setup_root_logger()
+logger = logging.getLogger("minisweagent")
+
+
+__all__ = ["logger"]

mini_swe_agent-1.9.0/src/minisweagent/utils/log.py

@@ -1,32 +0,0 @@
-import logging
-from pathlib import Path
-
-MINI_LOGGERS = {}
-_EXTRA_HANDLERS = []
-
-
-def get_logger(name: str) -> logging.Logger:
-    if name in MINI_LOGGERS:
-        return MINI_LOGGERS[name]
-    logger = logging.getLogger(name)
-    logger.setLevel(logging.DEBUG)
-    handler = logging.StreamHandler()
-    formatter = logging.Formatter("%(name)s: %(levelname)s: %(message)s")
-    handler.setFormatter(formatter)
-    logger.addHandler(handler)
-    for handler in _EXTRA_HANDLERS:
-        logger.addHandler(handler)
-    MINI_LOGGERS[name] = logger
-    return logger
-
-
-def add_file_handlers(path: Path):
-    handler = logging.FileHandler(path)
-    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-    handler.setFormatter(formatter)
-    _EXTRA_HANDLERS.append(handler)
-    for logger in MINI_LOGGERS.values():
-        logger.addHandler(handler)
-
-
-logger = get_logger("minisweagent")