mini-swe-agent 1.7.0__tar.gz → 1.8.0__tar.gz

{mini_swe_agent-1.7.0/src/mini_swe_agent.egg-info → mini_swe_agent-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-swe-agent
-Version: 1.7.0
+Version: 1.8.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
@@ -40,7 +40,7 @@ License-File: LICENSE.md
 Requires-Dist: pyyaml
 Requires-Dist: requests
 Requires-Dist: jinja2
-Requires-Dist: litellm
+Requires-Dist: litellm>=1.75.5
 Requires-Dist: tenacity
 Requires-Dist: rich
 Requires-Dist: python-dotenv
@@ -92,7 +92,7 @@ Here's some details:
 
 - **Minimal**: Just [100 lines of python](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/agents/default.py) (+100 total for [env](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/environments/local.py),
 [model](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/models/litellm_model.py), [script](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/run/hello_world.py)) — no fancy dependencies!
-- **Powerful:** Resolves 65% of GitHub issues in the [SWE-bench verified benchmark](https://www.swebench.com/) ([leaderboard](https://swe-bench.com/)).
+- **Powerful:** Resolves 68% of GitHub issues in the [SWE-bench verified benchmark](https://www.swebench.com/) ([leaderboard](https://swe-bench.com/)).
 - **Convenient:** Comes with UIs that turn this into your daily dev swiss army knife!
 - **Deployable:** In addition to local envs, you can use **docker**, **podman**, **singularity**, **apptainer**, and more
 - **Tested:** [![Codecov](https://img.shields.io/codecov/c/github/swe-agent/mini-swe-agent?style=flat-square)](https://codecov.io/gh/SWE-agent/mini-swe-agent)

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/README.md

@@ -24,7 +24,7 @@ Here's some details:
 
 - **Minimal**: Just [100 lines of python](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/agents/default.py) (+100 total for [env](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/environments/local.py),
 [model](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/models/litellm_model.py), [script](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/run/hello_world.py)) — no fancy dependencies!
-- **Powerful:** Resolves 65% of GitHub issues in the [SWE-bench verified benchmark](https://www.swebench.com/) ([leaderboard](https://swe-bench.com/)).
+- **Powerful:** Resolves 68% of GitHub issues in the [SWE-bench verified benchmark](https://www.swebench.com/) ([leaderboard](https://swe-bench.com/)).
 - **Convenient:** Comes with UIs that turn this into your daily dev swiss army knife!
 - **Deployable:** In addition to local envs, you can use **docker**, **podman**, **singularity**, **apptainer**, and more
 - **Tested:** [![Codecov](https://img.shields.io/codecov/c/github/swe-agent/mini-swe-agent?style=flat-square)](https://codecov.io/gh/SWE-agent/mini-swe-agent)

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/pyproject.toml

@@ -34,7 +34,7 @@ dependencies = [
     "pyyaml",
     "requests",
     "jinja2",
-    "litellm",
+    "litellm >= 1.75.5",  # want to have gpt-5 support
     "tenacity",
     "rich",
     "python-dotenv",

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0/src/mini_swe_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-swe-agent
-Version: 1.7.0
+Version: 1.8.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
@@ -40,7 +40,7 @@ License-File: LICENSE.md
 Requires-Dist: pyyaml
 Requires-Dist: requests
 Requires-Dist: jinja2
-Requires-Dist: litellm
+Requires-Dist: litellm>=1.75.5
 Requires-Dist: tenacity
 Requires-Dist: rich
 Requires-Dist: python-dotenv
@@ -92,7 +92,7 @@ Here's some details:
 
 - **Minimal**: Just [100 lines of python](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/agents/default.py) (+100 total for [env](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/environments/local.py),
 [model](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/models/litellm_model.py), [script](https://github.com/SWE-agent/mini-swe-agent/blob/main/src/minisweagent/run/hello_world.py)) — no fancy dependencies!
-- **Powerful:** Resolves 65% of GitHub issues in the [SWE-bench verified benchmark](https://www.swebench.com/) ([leaderboard](https://swe-bench.com/)).
+- **Powerful:** Resolves 68% of GitHub issues in the [SWE-bench verified benchmark](https://www.swebench.com/) ([leaderboard](https://swe-bench.com/)).
 - **Convenient:** Comes with UIs that turn this into your daily dev swiss army knife!
 - **Deployable:** In addition to local envs, you can use **docker**, **podman**, **singularity**, **apptainer**, and more
 - **Tested:** [![Codecov](https://img.shields.io/codecov/c/github/swe-agent/mini-swe-agent?style=flat-square)](https://codecov.io/gh/SWE-agent/mini-swe-agent)

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/src/mini_swe_agent.egg-info/requires.txt

@@ -1,7 +1,7 @@
 pyyaml
 requests
 jinja2
-litellm
+litellm>=1.75.5
 tenacity
 rich
 python-dotenv

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/src/minisweagent/__init__.py

@@ -8,7 +8,7 @@ This file provides:
   unless you want the static type checking.
 """
 
-__version__ = "1.7.0"
+__version__ = "1.8.0"
 
 import os
 from pathlib import Path
@@ -61,7 +61,7 @@ class Agent(Protocol):
     env: Environment
     messages: list[dict[str, str]]
 
-    def run(self, task: str) -> tuple[str, str]: ...
+    def run(self, task: str, **kwargs) -> tuple[str, str]: ...
 
 
 __all__ = ["Agent", "Model", "Environment", "package_dir", "__version__", "global_config_file", "global_config_dir"]

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/src/minisweagent/agents/default.py

@@ -69,11 +69,11 @@ class DefaultAgent:
     def add_message(self, role: str, content: str, **kwargs):
         self.messages.append({"role": role, "content": content, **kwargs})
 
-    def run(self, task: str) -> tuple[str, str]:
+    def run(self, task: str, **kwargs) -> tuple[str, str]:
         """Run step() until agent is finished. Return exit status & message"""
         self.messages = []
         self.add_message("system", self.render_template(self.config.system_template))
-        self.add_message("user", self.render_template(self.config.instance_template, task=task))
+        self.add_message("user", self.render_template(self.config.instance_template, task=task, **kwargs))
         while True:
             try:
                 self.step()
@@ -124,6 +124,6 @@ class DefaultAgent:
 
     def has_finished(self, output: dict[str, str]):
         """Raises Submitted exception with final output if the agent has finished its task."""
-        lines = output.get("output", "").lstrip().splitlines()
+        lines = output.get("output", "").lstrip().splitlines(keepends=True)
         if lines and lines[0].strip() in ["MINI_SWE_AGENT_FINAL_OUTPUT", "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT"]:
-            raise Submitted("\n".join(lines[1:]))
+            raise Submitted("".join(lines[1:]))

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/src/minisweagent/agents/interactive_textual.py

@@ -37,8 +37,8 @@ class TextualAgentConfig(AgentConfig):
     """If the agent wants to finish, do we ask for confirmation from user?"""
 
 
-class TextualAgent(DefaultAgent):
-    def __init__(self, app: "AgentApp", *args, **kwargs):
+class _TextualAgent(DefaultAgent):
+    def __init__(self, app: "TextualAgent", *args, **kwargs):
         """Connects the DefaultAgent to the TextualApp."""
         self.app = app
         super().__init__(*args, config_class=TextualAgentConfig, **kwargs)
@@ -59,9 +59,9 @@ class TextualAgent(DefaultAgent):
         self._current_action_from_human = False
         return super().query()
 
-    def run(self, task: str) -> tuple[str, str]:
+    def run(self, task: str, **kwargs) -> tuple[str, str]:
         try:
-            exit_status, result = super().run(task)
+            exit_status, result = super().run(task, **kwargs)
         except Exception as e:
             result = str(e)
             self.app.call_from_thread(self.app.action_quit)
@@ -123,7 +123,7 @@ def _messages_to_steps(messages: list[dict]) -> list[list[dict]]:
 
 
 class SmartInputContainer(Container):
-    def __init__(self, app: "AgentApp"):
+    def __init__(self, app: "TextualAgent"):
         """Smart input container supporting single-line and multi-line input modes."""
         super().__init__(classes="smart-input-container")
         self._app = app
@@ -239,7 +239,7 @@ class SmartInputContainer(Container):
             return
 
 
-class AgentApp(App):
+class TextualAgent(App):
     BINDINGS = [
         Binding("right,l", "next_step", "Step++", tooltip="Show next step of the agent"),
         Binding("left,h", "previous_step", "Step--", tooltip="Show previous step of the agent"),
@@ -259,24 +259,28 @@ class AgentApp(App):
         Binding("f1,question_mark", "toggle_help_panel", "Help", tooltip="Show help"),
     ]
 
-    def __init__(self, model, env, task: str, **kwargs):
+    def __init__(self, model, env, **kwargs):
         css_path = os.environ.get("MSWEA_MINI_STYLE_PATH", str(Path(__file__).parent.parent / "config" / "mini.tcss"))
         self.__class__.CSS = Path(css_path).read_text()
         super().__init__()
         self.agent_state = "UNINITIALIZED"
-        self.agent_task = task
-        self.agent = TextualAgent(self, model=model, env=env, **kwargs)
+        self.agent = _TextualAgent(self, model=model, env=env, **kwargs)
         self._i_step = 0
         self.n_steps = 1
         self.input_container = SmartInputContainer(self)
         self.log_handler = AddLogEmitCallback(lambda record: self.call_from_thread(self.on_log_message_emitted, record))
         logging.getLogger().addHandler(self.log_handler)
         self._spinner = Spinner("dots")
-        self.exit_status: str | None = None
-        self.result: str | None = None
+        self.exit_status: str = "ExitStatusUnset"
+        self.result: str = ""
 
         self._vscroll = VerticalScroll()
 
+    def run(self, task: str) -> tuple[str, str]:
+        threading.Thread(target=lambda: self.agent.run(task), daemon=True).start()
+        super().run()
+        return self.exit_status, self.result
+
     # --- Basics ---
 
     @property
@@ -305,7 +309,18 @@ class AgentApp(App):
         self.agent_state = "RUNNING"
         self.update_content()
         self.set_interval(1 / 8, self._update_headers)
-        threading.Thread(target=lambda: self.agent.run(self.agent_task), daemon=True).start()
+
+    @property
+    def messages(self) -> list[dict]:
+        return self.agent.messages
+
+    @property
+    def model(self):
+        return self.agent.model
+
+    @property
+    def env(self):
+        return self.agent.env
 
     # --- Reacting to events ---
 

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/src/minisweagent/config/extra/swebench.yaml

@@ -221,6 +221,7 @@ environment:
     LESS: -R
     PIP_PROGRESS_BAR: 'off'
     TQDM_DISABLE: '1'
+  environment_class: docker
 
 model:
   model_name: "claude-sonnet-4-20250514"

mini_swe_agent-1.8.0/src/minisweagent/environments/__init__.py

@@ -0,0 +1,30 @@
+"""Environment implementations for mini-SWE-agent."""
+
+import copy
+import importlib
+
+from minisweagent import Environment
+
+_ENVIRONMENT_MAPPING = {
+    "docker": "minisweagent.environments.docker.DockerEnvironment",
+    "singularity": "minisweagent.environments.singularity.SingularityEnvironment",
+    "local": "minisweagent.environments.local.LocalEnvironment",
+    "swerex_docker": "minisweagent.environments.extra.swerex_docker.SwerexDockerEnvironment",
+}
+
+
+def get_environment_class(spec: str) -> type[Environment]:
+    full_path = _ENVIRONMENT_MAPPING.get(spec, spec)
+    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 environment type: {spec} (resolved to {full_path}, available: {_ENVIRONMENT_MAPPING})"
+        raise ValueError(msg)
+
+
+def get_environment(config: dict, *, default_type: str = "") -> Environment:
+    config = copy.deepcopy(config)
+    environment_class = config.pop("environment_class", default_type)
+    return get_environment_class(environment_class)(**config)

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/src/minisweagent/environments/docker.py

@@ -20,7 +20,7 @@ class DockerEnvironmentConfig:
     """
     timeout: int = 30
     """Timeout for executing commands in the container."""
-    executable: str = "docker"
+    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."""

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/src/minisweagent/environments/singularity.py

@@ -1,8 +1,12 @@
 #!/usr/bin/env python3
 
 import os
+import shutil
 import subprocess
+import tempfile
+import uuid
 from dataclasses import dataclass, field
+from pathlib import Path
 from typing import Any
 
 
@@ -16,7 +20,7 @@ class SingularityEnvironmentConfig:
     """Environment variables to forward to the container."""
     timeout: int = 30
     """Timeout for executing commands in the container."""
-    executable: str = "singularity"
+    executable: str = os.getenv("MSWEA_SINGULARITY_EXECUTABLE", "singularity")
     """Path to the singularity executable."""
 
 
@@ -24,11 +28,20 @@ class SingularityEnvironment:
     def __init__(self, **kwargs):
         """Singularity environment. See `SingularityEnvironmentConfig` for kwargs."""
         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,
+        )
 
     def execute(self, command: str, cwd: str = "") -> dict[str, Any]:
         """Execute a command in a Singularity container and return the result as a dict."""
         cmd = [self.config.executable, "exec"]
 
+        # Do not inherit directories and env vars from host
+        cmd.extend(["--contain", "--cleanenv"])
+
         work_dir = cwd or self.config.cwd
         if work_dir and work_dir != "/":
             cmd.extend(["--pwd", work_dir])
@@ -39,7 +52,7 @@ class SingularityEnvironment:
         for key, value in self.config.env.items():
             cmd.extend(["--env", f"{key}={value}"])
 
-        cmd.extend([self.config.image, "bash", "-c", command])
+        cmd.extend(["--writable", str(self.sandbox_dir), "bash", "-c", command])
         result = subprocess.run(
             cmd,
             text=True,
@@ -50,3 +63,12 @@ class SingularityEnvironment:
             stderr=subprocess.STDOUT,
         )
         return {"output": result.stdout, "returncode": result.returncode}
+
+    def cleanup(self):
+        if self.sandbox_dir.exists():
+            print(f"Removing sandbox {self.sandbox_dir}")
+            shutil.rmtree(self.sandbox_dir)
+
+    def __del__(self):
+        """Cleanup sandbox when object is destroyed."""
+        self.cleanup()

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/src/minisweagent/run/extra/config.py

@@ -34,11 +34,12 @@ This setup will ask you for your model and an API key.
 Here's a few popular models and the required API keys:
 
 [bold green]claude-sonnet-4-20250514[/bold green] ([bold green]ANTHROPIC_API_KEY[/bold green])
-[bold green]o3[/bold green] ([bold green]OPENAI_API_KEY[/bold green])
+[bold green]openai/gpt-5[/bold green] or [bold green]openai/gpt-5-mini[/bold green] ([bold green]OPENAI_API_KEY[/bold green])
 
 [bold yellow]You can leave any setting blank to skip it.[/bold yellow]
 
 More information at https://mini-swe-agent.com/latest/quickstart/
+To find the best model, check the leaderboard at https://swebench.com/
 """
 
 

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/src/minisweagent/run/extra/swebench.py

@@ -17,9 +17,10 @@ import yaml
 from datasets import load_dataset
 from rich.live import Live
 
+from minisweagent import Environment
 from minisweagent.agents.default import DefaultAgent
 from minisweagent.config import builtin_config_dir, get_config_path
-from minisweagent.environments.docker import DockerEnvironment
+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
@@ -74,6 +75,15 @@ def get_swebench_docker_image_name(instance: dict) -> str:
     return image_name
 
 
+def get_sb_environment(config: dict, instance: dict) -> Environment:
+    image_name = get_swebench_docker_image_name(instance)
+    env_config = config.get("environment", {})
+    if env_config.get("environment_class") == "singularity":
+        image_name = "docker://" + image_name
+    env_config["image"] = image_name
+    return get_environment(env_config, default_type="docker")
+
+
 def update_preds_file(output_path: Path, instance_id: str, model_name: str, result: str):
     """Update the output JSON file with results from a single instance."""
     with _OUTPUT_FILE_LOCK:
@@ -102,8 +112,7 @@ def remove_from_preds_file(output_path: Path, instance_id: str):
 def process_instance(
     instance: dict,
     output_dir: Path,
-    model_name: str | None,
-    config_path: str | Path,
+    config: dict,
     progress_manager: RunBatchProgressManager,
 ) -> None:
     """Process a single SWEBench instance."""
@@ -112,10 +121,7 @@ def process_instance(
     # avoid inconsistent state if something here fails and there's leftover previous files
     remove_from_preds_file(output_dir / "preds.json", instance_id)
     (instance_dir / f"{instance_id}.traj.json").unlink(missing_ok=True)
-
-    image_name = get_swebench_docker_image_name(instance)
-    config = yaml.safe_load(get_config_path(config_path).read_text())
-    model = get_model(model_name, config=config.get("model", {}))
+    model = get_model(config=config.get("model", {}))
     task = instance["problem_statement"]
 
     progress_manager.on_instance_start(instance_id)
@@ -125,7 +131,7 @@ def process_instance(
     extra_info = None
 
     try:
-        env = DockerEnvironment(**(config.get("environment", {}) | {"image": image_name}))
+        env = get_sb_environment(config, instance)
         agent = ProgressTrackingAgent(
             model,
             env,
@@ -171,21 +177,22 @@ def filter_instances(
     return instances
 
 
+# fmt: off
 @app.command(help=_HELP_TEXT)
 def main(
-    subset: str = typer.Option("lite", "--subset", help="SWEBench subset to use or path to a dataset"),
-    split: str = typer.Option("dev", "--split", help="Dataset split"),
-    slice_spec: str = typer.Option("", "--slice", help="Slice specification (e.g., '0:5' for first 5 instances)"),
-    filter_spec: str = typer.Option("", "--filter", help="Filter instance IDs by regex"),
-    shuffle: bool = typer.Option(False, "--shuffle", help="Shuffle instances"),
-    output: str = typer.Option("", "-o", "--output", help="Output directory"),
-    workers: int = typer.Option(1, "-w", "--workers", help="Number of worker threads for parallel processing"),
-    model: str | None = typer.Option(None, "-m", "--model", help="Model to use"),
-    redo_existing: bool = typer.Option(False, "--redo-existing", help="Redo existing instances"),
-    config: Path = typer.Option(
-        builtin_config_dir / "extra" / "swebench.yaml", "-c", "--config", help="Path to a config file"
-    ),
+    subset: str = typer.Option("lite", "--subset", help="SWEBench subset to use or path to a dataset", rich_help_panel="Data selection"),
+    split: str = typer.Option("dev", "--split", help="Dataset split", rich_help_panel="Data selection"),
+    slice_spec: str = typer.Option("", "--slice", help="Slice specification (e.g., '0:5' for first 5 instances)", rich_help_panel="Data selection"),
+    filter_spec: str = typer.Option("", "--filter", help="Filter instance IDs by regex", rich_help_panel="Data selection"),
+    shuffle: bool = typer.Option(False, "--shuffle", help="Shuffle instances", rich_help_panel="Data selection"),
+    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"),
+    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"),
 ) -> None:
+    # fmt: on
     dataset_path = DATASET_MAPPING.get(subset, subset)
     print(f"Loading dataset {dataset_path}, split {split}...")
     instances = list(load_dataset(dataset_path, split=split))
@@ -201,6 +208,10 @@ def main(
     print(f"Running on {len(instances)} instances...")
     print(f"Results will be saved to {output_path}")
 
+    config = yaml.safe_load(get_config_path(config_spec).read_text())
+    config.setdefault("environment", {}).setdefault("environment_class", environment_class)
+    config.setdefault("model", {}).setdefault("model_name", model)
+
     progress_manager = RunBatchProgressManager(len(instances), output_path / f"exit_statuses_{time.time()}.yaml")
 
     def process_futures(futures: dict[concurrent.futures.Future, str]):
@@ -218,7 +229,7 @@ def main(
     with Live(progress_manager.render_group, refresh_per_second=4):
         with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
             futures = {
-                executor.submit(process_instance, instance, output_path, model, config, progress_manager): instance[
+                executor.submit(process_instance, instance, output_path, config, progress_manager): instance[
                     "instance_id"
                 ]
                 for instance in instances

mini_swe_agent-1.8.0/src/minisweagent/run/extra/swebench_single.py

@@ -0,0 +1,57 @@
+"""Run on a single SWE-Bench instance."""
+
+from pathlib import Path
+
+import typer
+import yaml
+from datasets import load_dataset
+
+from minisweagent.agents.interactive import InteractiveAgent
+from minisweagent.config import builtin_config_dir, get_config_path
+from minisweagent.models import get_model
+from minisweagent.run.extra.swebench import (
+    DATASET_MAPPING,
+    get_sb_environment,
+)
+
+app = typer.Typer(add_completion=False)
+
+
+# fmt: off
+@app.command()
+def main(
+    subset: str = typer.Option("lite", "--subset", help="SWEBench subset to use or path to a dataset", rich_help_panel="Data selection"),
+    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"),
+    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"),
+) -> None:
+    # fmt: on
+    """Run on a single SWE-Bench instance."""
+    dataset_path = DATASET_MAPPING.get(subset, subset)
+    print(f"Loading dataset from {dataset_path}, split {split}...")
+    instances = {
+        inst["instance_id"]: inst  # type: ignore
+        for inst in load_dataset(dataset_path, split=split)
+    }
+    if instance_spec.isnumeric():
+        instance_spec = sorted(instances.keys())[int(instance_spec)]
+    instance: dict = instances[instance_spec]  # type: ignore
+
+    config = yaml.safe_load(get_config_path(config_path).read_text())
+    config.setdefault("environment", {}).setdefault("environment_class", environment_class)
+    if exit_immediately:
+        config.setdefault("agent", {})["confirm_exit"] = False
+    env = get_sb_environment(config, instance)
+    agent = InteractiveAgent(
+        get_model(model_name, config.get("model", {})),
+        env,
+        **(config.get("agent", {}) | {"mode": "yolo"}),
+    )
+    agent.run(instance["problem_statement"])
+
+
+if __name__ == "__main__":
+    app()

{mini_swe_agent-1.7.0 → mini_swe_agent-1.8.0}/src/minisweagent/run/mini.py

@@ -14,9 +14,9 @@ from prompt_toolkit.history import FileHistory
 from prompt_toolkit.shortcuts import PromptSession
 from rich.console import Console
 
-from minisweagent import Environment, Model, global_config_dir
+from minisweagent import global_config_dir
 from minisweagent.agents.interactive import InteractiveAgent
-from minisweagent.agents.interactive_textual import AgentApp
+from minisweagent.agents.interactive_textual import TextualAgent
 from minisweagent.config import builtin_config_dir, get_config_path
 from minisweagent.environments.local import LocalEnvironment
 from minisweagent.models import get_model
@@ -41,36 +41,6 @@ More information about the usage: [bold green]https://mini-swe-agent.com/latest/
 """
 
 
-def run_interactive(model: Model, env: Environment, agent_config: dict, task: str, output: Path | None = None) -> Any:
-    agent = InteractiveAgent(
-        model,
-        env,
-        **agent_config,
-    )
-
-    exit_status, result = None, None
-    try:
-        exit_status, result = agent.run(task)
-    finally:
-        if output:
-            save_traj(agent, output, exit_status=exit_status, result=result)
-    return agent
-
-
-def run_textual(model: Model, env: Environment, agent_config: dict, task: str, output: Path | None = None) -> Any:
-    agent_app = AgentApp(
-        model,
-        env,
-        task,
-        **agent_config,
-    )
-    try:
-        agent_app.run()
-    finally:
-        if output:
-            save_traj(agent_app.agent, output, exit_status=agent_app.exit_status, result=agent_app.result)
-
-
 @app.command(help=_HELP_TEXT)
 def main(
     visual: bool = typer.Option(
@@ -119,10 +89,17 @@ def main(
     env = LocalEnvironment(**config.get("env", {}))
 
     # Both visual flag and the MSWEA_VISUAL_MODE_DEFAULT flip the mode, so it's essentially a XOR
+    agent_class = InteractiveAgent
     if visual == (os.getenv("MSWEA_VISUAL_MODE_DEFAULT", "false") == "false"):
-        return run_textual(model, env, config["agent"], task, output)  # type: ignore[arg-type]
-    else:
-        return run_interactive(model, env, config["agent"], task, output)  # type: ignore[arg-type]
+        agent_class = TextualAgent
+    exit_status, result = None, None
+    agent = agent_class(model, env, **config.get("agent", {}))
+    try:
+        exit_status, result = agent.run(task)  # type: ignore[arg-type]
+    finally:
+        if output:
+            save_traj(agent, output, exit_status=exit_status, result=result)  # type: ignore[arg-type]
+    return agent
 
 
 if __name__ == "__main__":

mini_swe_agent-1.7.0/src/minisweagent/environments/__init__.py

@@ -1 +0,0 @@
-"""Environment implementations for mini-SWE-agent."""

mini_swe_agent-1.7.0/src/minisweagent/run/extra/swebench_single.py

@@ -1,53 +0,0 @@
-"""Run on a single SWE-Bench instance."""
-
-from pathlib import Path
-
-import typer
-import yaml
-from datasets import load_dataset
-
-from minisweagent.agents.interactive import InteractiveAgent
-from minisweagent.config import builtin_config_dir, get_config_path
-from minisweagent.environments.docker import DockerEnvironment
-from minisweagent.models import get_model
-from minisweagent.run.extra.swebench import DATASET_MAPPING, get_swebench_docker_image_name
-
-app = typer.Typer(add_completion=False)
-
-
-@app.command()
-def main(
-    subset: str = typer.Option("lite", "--subset", help="SWEBench subset to use or path to a dataset"),
-    split: str = typer.Option("dev", "--split", help="Dataset split"),
-    instance_spec: str = typer.Option(None, "-i", "--instance", help="SWE-Bench instance ID"),
-    model_name: str | None = typer.Option(None, "-m", "--model", help="Model to use"),
-    config_path: Path = typer.Option(
-        builtin_config_dir / "extra" / "swebench.yaml", "-c", "--config", help="Path to a config file"
-    ),
-) -> None:
-    """Run on a single SWE-Bench instance."""
-    try:
-        dataset_path = DATASET_MAPPING[subset]
-    except KeyError:
-        dataset_path = subset
-    print(f"Loading dataset {dataset_path}, split {split}...")
-    instances = {
-        inst["instance_id"]: inst  # type: ignore
-        for inst in load_dataset(dataset_path, split=split)
-    }
-    if instance_spec.isnumeric():
-        instance_spec = sorted(instances.keys())[int(instance_spec)]
-    instance: dict = instances[instance_spec]  # type: ignore
-
-    _config = yaml.safe_load(get_config_path(config_path).read_text())
-    env = DockerEnvironment(**(_config.get("environment", {}) | {"image": get_swebench_docker_image_name(instance)}))
-    agent = InteractiveAgent(
-        get_model(model_name, _config.get("model", {})),
-        env,
-        **(_config.get("agent", {}) | {"mode": "yolo"}),
-    )
-    agent.run(instance["problem_statement"])
-
-
-if __name__ == "__main__":
-    app()