mini-swe-agent 1.17.5__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

minisweagent/config/{github_issue.yaml → mini_textbased.yaml}

@@ -9,25 +9,28 @@ agent:
     <format_example>
     Your reasoning and analysis here. Explain why you want to perform the action.
 
-    ```bash
+    ```mswea_bash_command
     your_command_here
     ```
     </format_example>
 
     Failure to follow these rules will cause your response to be rejected.
-    To finish, issue the following command: `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT`
-    without any other command.
   instance_template: |
     Please solve this issue: {{task}}
 
     You can execute bash commands and edit files to implement the necessary changes.
 
     ## Recommended Workflow
+
+    This workflows should be done step-by-step so that you can iterate on your changes and any possible problems.
+
     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
+    6. Submit your changes and finish your work by issuing the following command: `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT`.
+       Do not combine it with any other command. <important>After this command, you cannot continue working on this task.</important>
 
     ## Important Rules
 
@@ -35,8 +38,10 @@ agent:
     2. The action must be enclosed in triple backticks
     3. 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
-    4. To finish, issue the following command: `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT`.
-       Do not combine it with any other command.
+
+    <system_information>
+    {{system}} {{release}} {{version}} {{machine}}
+    </system_information>
 
     ## Formatting your response
 
@@ -45,7 +50,7 @@ agent:
     <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
+    ```mswea_bash_command
     ls -la
     ```
     </example_response>
@@ -54,7 +59,7 @@ agent:
 
     ### Create a new file:
 
-    ```bash
+    ```mswea_bash_command
     cat <<'EOF' > newfile.py
     import numpy as np
     hello = "world"
@@ -64,7 +69,13 @@ agent:
 
     ### Edit files with sed:
 
-    ```bash
+    {%- if system == "Darwin" -%}
+    <important>
+    You are on MacOS. For all the below examples, you need to use `sed -i ''` instead of `sed -i`.
+    </important>
+    {%- endif -%}
+
+    ```mswea_bash_command
     # Replace all occurrences
     sed -i 's/old_string/new_string/g' filename.py
 
@@ -80,17 +91,31 @@ agent:
 
     ### View file content:
 
-    ```bash
+    ```mswea_bash_command
     # View specific lines with numbers
     nl -ba filename.py | sed -n '10,20p'
     ```
 
     ### Any other command you want to run
 
-    ```bash
+    ```mswea_bash_command
     anything
     ```
-  action_observation_template: |
+  step_limit: 0
+  cost_limit: 3.
+  mode: confirm
+environment:
+  env:
+    PAGER: cat
+    MANPAGER: cat
+    LESS: -R
+    PIP_PROGRESS_BAR: 'off'
+    TQDM_DISABLE: '1'
+model:
+  observation_template: |
+    {% if output.exception_info -%}
+    <exception>{{output.exception_info}}</exception>
+    {% endif -%}
     <returncode>{{output.returncode}}</returncode>
     {% if output.output | length < 10000 -%}
     <output>
@@ -115,31 +140,20 @@ agent:
     {{ output.output[-5000:] }}
     </output_tail>
     {%- endif -%}
+  model_kwargs:
+    drop_params: true
   format_error_template: |
     Please always provide EXACTLY ONE action in triple backticks, found {{actions|length}} actions.
-    If you want to end the task, please issue the following command: `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT`
-    without any other command.
-    Else, please format your response exactly as follows:
+
+    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
+    ```mswea_bash_command
     <action>
     ```
     </response_example>
-  step_limit: 0.
-  cost_limit: 0.
 
-environment:
-  image: "python:3.11"
-  cwd: "/testbed"
-  env:
-    PAGER: cat
-    MANPAGER: cat
-    LESS: -R
-    PIP_PROGRESS_BAR: 'off'
-    TQDM_DISABLE: '1'
-model:
-  model_kwargs:
-    drop_params: true
+    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).

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",
+    "swerex_modal": "minisweagent.environments.extra.swerex_modal.SwerexModalEnvironment",
     "bubblewrap": "minisweagent.environments.extra.bubblewrap.BubblewrapEnvironment",
 }
 

minisweagent/environments/docker.py

@@ -1,20 +1,24 @@
 import logging
 import os
+import platform
 import shlex
 import subprocess
 import uuid
-from dataclasses import asdict, dataclass, field
 from typing import Any
 
+from pydantic import BaseModel
 
-@dataclass
-class DockerEnvironmentConfig:
+from minisweagent.exceptions import Submitted
+from minisweagent.utils.serialize import recursive_merge
+
+
+class DockerEnvironmentConfig(BaseModel):
     image: str
     cwd: str = "/"
     """Working directory in which to execute commands."""
-    env: dict[str, str] = field(default_factory=dict)
+    env: dict[str, str] = {}
     """Environment variables to set in the container."""
-    forward_env: list[str] = field(default_factory=list)
+    forward_env: list[str] = []
     """Environment variables to forward to the container.
     Variables are only forwarded if they are set in the host environment.
     In case of conflict with `env`, the `env` variables take precedence.
@@ -23,7 +27,7 @@ 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=lambda: ["--rm"])
+    run_args: list[str] = ["--rm"]
     """Additional arguments to pass to the docker/container executable.
     Default is ["--rm"], which removes the container after it exits.
     """
@@ -31,6 +35,11 @@ class DockerEnvironmentConfig:
     """Max duration to keep container running. Uses the same format as the sleep command."""
     pull_timeout: int = 120
     """Timeout in seconds for pulling images."""
+    interpreter: list[str] = ["bash", "-lc"]
+    """Interpreter to use to execute commands. Default is ["bash", "-lc"].
+    The actual command will be appended as argument to this. Override this to e.g., modify shell flags
+    (e.g., to remove the `-l` flag to disable login shell) or to use python instead of bash to interpret commands.
+    """
 
 
 class DockerEnvironment:
@@ -49,8 +58,18 @@ class DockerEnvironment:
         self.config = config_class(**kwargs)
         self._start_container()
 
-    def get_template_vars(self) -> dict[str, Any]:
-        return asdict(self.config)
+    def get_template_vars(self, **kwargs) -> dict[str, Any]:
+        return recursive_merge(self.config.model_dump(), platform.uname()._asdict(), kwargs)
+
+    def serialize(self) -> dict:
+        return {
+            "info": {
+                "config": {
+                    "environment": self.config.model_dump(mode="json"),
+                    "environment_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                }
+            }
+        }
 
     def _start_container(self):
         """Start the Docker container and return the container ID."""
@@ -79,8 +98,9 @@ class DockerEnvironment:
         self.logger.info(f"Started container {container_name} with ID {result.stdout.strip()}")
         self.container_id = result.stdout.strip()
 
-    def execute(self, command: str, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
+    def execute(self, action: dict, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
         """Execute a command in the Docker container and return the result as a dict."""
+        command = action.get("command", "")
         cwd = cwd or self.config.cwd
         assert self.container_id, "Container not started"
 
@@ -90,18 +110,45 @@ class DockerEnvironment:
                 cmd.extend(["-e", f"{key}={value}"])
         for key, value in self.config.env.items():
             cmd.extend(["-e", f"{key}={value}"])
-        cmd.extend([self.container_id, "bash", "-lc", command])
+        cmd.extend([self.container_id, *self.config.interpreter, command])
 
-        result = subprocess.run(
-            cmd,
-            text=True,
-            timeout=timeout or self.config.timeout,
-            encoding="utf-8",
-            errors="replace",
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-        )
-        return {"output": result.stdout, "returncode": result.returncode}
+        try:
+            result = subprocess.run(
+                cmd,
+                text=True,
+                timeout=timeout or self.config.timeout,
+                encoding="utf-8",
+                errors="replace",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+            )
+            output = {"output": result.stdout, "returncode": result.returncode, "exception_info": ""}
+        except Exception as e:
+            raw_output = getattr(e, "output", None)
+            raw_output = (
+                raw_output.decode("utf-8", errors="replace") if isinstance(raw_output, bytes) else (raw_output or "")
+            )
+            output = {
+                "output": raw_output,
+                "returncode": -1,
+                "exception_info": f"An error occurred while executing the command: {e}",
+                "extra": {"exception_type": type(e).__name__, "exception": str(e)},
+            }
+        self._check_finished(output)
+        return output
+
+    def _check_finished(self, output: dict):
+        """Raises Submitted if the output indicates task completion."""
+        lines = output.get("output", "").lstrip().splitlines(keepends=True)
+        if lines and lines[0].strip() == "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT" and output["returncode"] == 0:
+            submission = "".join(lines[1:])
+            raise Submitted(
+                {
+                    "role": "exit",
+                    "content": submission,
+                    "extra": {"exit_status": "Submitted", "submission": submission},
+                }
+            )
 
     def cleanup(self):
         """Stop and remove the Docker container."""

minisweagent/environments/extra/bubblewrap.py

@@ -17,51 +17,52 @@ import shutil
 import subprocess
 import tempfile
 import uuid
-from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any
 
+from pydantic import BaseModel
 
-@dataclass
-class BubblewrapEnvironmentConfig:
+from minisweagent.exceptions import Submitted
+from minisweagent.utils.serialize import recursive_merge
+
+
+class BubblewrapEnvironmentConfig(BaseModel):
     cwd: str = ""
     """Working directory for the sandbox."""
-    env: dict[str, str] = field(default_factory=dict)
+    env: dict[str, str] = {}
     """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",
-        ]
-    )
+    wrapper_args: list[str] = [
+        "--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."""
 
 
@@ -77,8 +78,9 @@ class BubblewrapEnvironment:
         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 = "", *, timeout: int | None = None) -> dict[str, Any]:
+    def execute(self, action: dict, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
         """Execute a command in the bubblewrap environment and return the result as a dict."""
+        command = action.get("command", "")
         cwd = cwd or self.config.cwd or str(self.working_dir)
 
         cmd = [self.config.executable] + self.config.wrapper_args + ["--bind", cwd, cwd, "--chdir", cwd]
@@ -89,16 +91,43 @@ class BubblewrapEnvironment:
 
         cmd.extend(["bash", "-c", command])
 
-        result = subprocess.run(
-            cmd,
-            text=True,
-            timeout=timeout or self.config.timeout,
-            encoding="utf-8",
-            errors="replace",
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-        )
-        return {"output": result.stdout, "returncode": result.returncode}
+        try:
+            result = subprocess.run(
+                cmd,
+                text=True,
+                timeout=timeout or self.config.timeout,
+                encoding="utf-8",
+                errors="replace",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+            )
+            output = {"output": result.stdout, "returncode": result.returncode, "exception_info": ""}
+        except Exception as e:
+            raw_output = getattr(e, "output", None)
+            raw_output = (
+                raw_output.decode("utf-8", errors="replace") if isinstance(raw_output, bytes) else (raw_output or "")
+            )
+            output = {
+                "output": raw_output,
+                "returncode": -1,
+                "exception_info": f"An error occurred while executing the command: {e}",
+                "extra": {"exception_type": type(e).__name__, "exception": str(e)},
+            }
+        self._check_finished(output)
+        return output
+
+    def _check_finished(self, output: dict):
+        """Raises Submitted if the output indicates task completion."""
+        lines = output.get("output", "").lstrip().splitlines(keepends=True)
+        if lines and lines[0].strip() == "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT" and output["returncode"] == 0:
+            submission = "".join(lines[1:])
+            raise Submitted(
+                {
+                    "role": "exit",
+                    "content": submission,
+                    "extra": {"exit_status": "Submitted", "submission": submission},
+                }
+            )
 
     def cleanup(self):
         if self.working_dir.exists():
@@ -108,5 +137,15 @@ class BubblewrapEnvironment:
         """Cleanup working_dir when object is destroyed."""
         self.cleanup()
 
-    def get_template_vars(self) -> dict[str, Any]:
-        return asdict(self.config) | platform.uname()._asdict()
+    def get_template_vars(self, **kwargs) -> dict[str, Any]:
+        return recursive_merge(self.config.model_dump(), platform.uname()._asdict(), kwargs)
+
+    def serialize(self) -> dict:
+        return {
+            "info": {
+                "config": {
+                    "environment": self.config.model_dump(mode="json"),
+                    "environment_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                }
+            }
+        }

minisweagent/environments/extra/swerex_docker.py

@@ -1,19 +1,21 @@
 import asyncio
-from dataclasses import asdict, dataclass, field
 from typing import Any
 
+from pydantic import BaseModel
 from swerex.deployment.docker import DockerDeployment
 from swerex.runtime.abstract import Command as RexCommand
 
+from minisweagent.exceptions import Submitted
+from minisweagent.utils.serialize import recursive_merge
 
-@dataclass
-class SwerexDockerEnvironmentConfig:
+
+class SwerexDockerEnvironmentConfig(BaseModel):
     image: str
     cwd: str = "/"
     """Working directory in which to execute commands."""
     timeout: int = 30
     """Timeout for executing commands in the container."""
-    deployment_extra_kwargs: dict[str, Any] = field(default_factory=dict)
+    deployment_extra_kwargs: dict[str, Any] = {}
     """Extra kwargs to pass to DockerDeployment."""
 
 
@@ -24,24 +26,55 @@ class SwerexDockerEnvironment:
         self.deployment = DockerDeployment(image=self.config.image, **self.config.deployment_extra_kwargs)
         asyncio.run(self.deployment.start())
 
-    def execute(self, command: str, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
+    def execute(self, action: dict, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
         """Execute a command in the environment and return the raw output."""
-        output = asyncio.run(
-            self.deployment.runtime.execute(
-                RexCommand(
-                    command=command,
-                    shell=True,
-                    check=False,
-                    cwd=cwd or self.config.cwd,
-                    timeout=timeout or self.config.timeout,
-                    merge_output_streams=True,
+        command = action.get("command", "")
+        try:
+            result = asyncio.run(
+                self.deployment.runtime.execute(
+                    RexCommand(
+                        command=command,
+                        shell=True,
+                        check=False,
+                        cwd=cwd or self.config.cwd,
+                        timeout=timeout or self.config.timeout,
+                        merge_output_streams=True,
+                    )
                 )
             )
-        )
+            output = {"output": result.stdout, "returncode": result.exit_code, "exception_info": ""}
+        except Exception as e:
+            output = {
+                "output": str(e) if str(e) else "",
+                "returncode": -1,
+                "exception_info": f"An error occurred while executing the command: {e}",
+                "extra": {"exception_type": type(e).__name__, "exception": str(e)},
+            }
+        self._check_finished(output)
+        return output
+
+    def _check_finished(self, output: dict):
+        """Raises Submitted if the output indicates task completion."""
+        lines = output.get("output", "").lstrip().splitlines(keepends=True)
+        if lines and lines[0].strip() == "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT" and output["returncode"] == 0:
+            submission = "".join(lines[1:])
+            raise Submitted(
+                {
+                    "role": "exit",
+                    "content": submission,
+                    "extra": {"exit_status": "Submitted", "submission": submission},
+                }
+            )
+
+    def get_template_vars(self, **kwargs) -> dict[str, Any]:
+        return recursive_merge(self.config.model_dump(), kwargs)
+
+    def serialize(self) -> dict:
         return {
-            "output": output.stdout,
-            "returncode": output.exit_code,
+            "info": {
+                "config": {
+                    "environment": self.config.model_dump(mode="json"),
+                    "environment_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                }
+            }
         }
-
-    def get_template_vars(self) -> dict[str, Any]:
-        return asdict(self.config)

minisweagent/environments/extra/swerex_modal.py

@@ -0,0 +1,90 @@
+import asyncio
+from typing import Any
+
+from pydantic import BaseModel
+from swerex.deployment.modal import ModalDeployment
+from swerex.runtime.abstract import Command as RexCommand
+
+
+class SwerexModalEnvironmentConfig(BaseModel):
+    image: str
+    """Image to use for the deployment. Can be:
+    - Dockerhub image name (e.g. `python:3.11-slim`)
+    - ECR image name (e.g. `123456789012.dkr.ecr.us-east-1.amazonaws.com/my-image:tag`)
+    - Path to a Dockerfile
+    """
+    cwd: str = "/"
+    """Working directory in which to execute commands."""
+    timeout: int = 30
+    """Timeout for executing commands in the container."""
+    env: dict[str, str] = {}
+    """Environment variables to set when executing commands."""
+    startup_timeout: float = 60.0
+    """The time to wait for the runtime to start."""
+    runtime_timeout: float = 3600.0
+    """The runtime timeout (how long the Modal sandbox can stay alive)."""
+    deployment_timeout: float = 3600.0
+    """The deployment timeout."""
+    install_pipx: bool = True
+    """Whether to install pipx in the container (required for swe-rex runtime)."""
+    modal_sandbox_kwargs: dict[str, Any] = {}
+    """Additional arguments to pass to `modal.Sandbox.create`."""
+
+
+class SwerexModalEnvironment:
+    def __init__(self, **kwargs):
+        """This class executes bash commands in a Modal sandbox using SWE-ReX for remote execution.
+
+        Modal (https://modal.com) provides serverless cloud compute that can be used to run
+        sandboxed environments. This environment class uses SWE-ReX's ModalDeployment to
+        create and manage Modal sandboxes for command execution.
+
+        This is useful for:
+        - Training coding agents at scale with remote execution
+        - Running evaluations in isolated cloud environments
+        - Parallel execution across many instances
+
+        See `SwerexModalEnvironmentConfig` for keyword arguments.
+        """
+        self.config = SwerexModalEnvironmentConfig(**kwargs)
+        self.deployment = ModalDeployment(
+            image=self.config.image,
+            startup_timeout=self.config.startup_timeout,
+            runtime_timeout=self.config.runtime_timeout,
+            deployment_timeout=self.config.deployment_timeout,
+            install_pipx=self.config.install_pipx,
+            modal_sandbox_kwargs=self.config.modal_sandbox_kwargs,
+        )
+        asyncio.run(self.deployment.start())
+
+    def execute(self, command: str, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
+        """Execute a command in the environment and return the raw output."""
+        output = asyncio.run(
+            self.deployment.runtime.execute(
+                RexCommand(
+                    command=command,
+                    shell=True,
+                    check=False,
+                    cwd=cwd or self.config.cwd,
+                    timeout=timeout or self.config.timeout,
+                    merge_output_streams=True,
+                    env=self.config.env if self.config.env else None,
+                )
+            )
+        )
+        return {
+            "output": output.stdout,
+            "returncode": output.exit_code,
+        }
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return self.config.model_dump()
+
+    def stop(self):
+        async def _stop():
+            await asyncio.wait_for(self.deployment.stop(), timeout=10)
+
+        try:
+            asyncio.run(_stop())
+        except Exception:
+            pass