mini-swe-agent 1.1.0__py3-none-any.whl

minisweagent/environments/docker.py

@@ -0,0 +1,98 @@
+import os
+import shlex
+import subprocess
+import uuid
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class DockerEnvironmentConfig:
+    image: str
+    cwd: str = "/"
+    """Working directory in which to execute commands."""
+    env: dict[str, str] = field(default_factory=dict)
+    """Environment variables to set in the container."""
+    forward_env: list[str] = field(default_factory=list)
+    """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.
+    """
+    timeout: int = 30
+    """Timeout for executing commands in the container."""
+    executable: str = "docker"
+    """Path to the docker/container executable."""
+    run_args: list[str] = field(default_factory=list)
+    """Additional arguments to pass to the docker/container executable."""
+
+
+class DockerEnvironment:
+    def __init__(self, *, config_class: type = DockerEnvironmentConfig, **kwargs):
+        """This class executes bash commands in a Docker container using direct docker commands.
+        See `DockerEnvironmentConfig` for keyword arguments.
+        """
+        self.container_id: str | None = None
+        self.config = config_class(**kwargs)
+        self._start_container()
+
+    def _start_container(self):
+        """Start the Docker container and return the container ID."""
+        container_name = f"minisweagent-{uuid.uuid4().hex[:8]}"
+        cmd = [
+            self.config.executable,
+            "run",
+            "-d",
+            "--name",
+            container_name,
+            "-w",
+            self.config.cwd,
+            *self.config.run_args,
+            self.config.image,
+            "sleep",
+            "infinity",  # Keep container running
+        ]
+        print(f"Starting container with command: {shlex.join(cmd)}")
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=120,  # docker pull might take a while
+            check=True,
+        )
+        print(f"Started container {container_name} with ID {result.stdout.strip()}")
+        self.container_id = result.stdout.strip()
+
+    def execute(self, command: str, cwd: str = "") -> dict[str, Any]:
+        """Execute a command in the Docker container and return the result as a dict."""
+        cwd = cwd or self.config.cwd
+        assert self.container_id, "Container not started"
+
+        cmd = [self.config.executable, "exec", "-w", cwd]
+        for key in self.config.forward_env:
+            if (value := os.getenv(key)) is not None:
+                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])
+
+        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):
+        """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
+            print(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)
+
+    def __del__(self):
+        """Cleanup container when object is destroyed."""
+        self.cleanup()

minisweagent/environments/extra/swerex_docker.py

@@ -0,0 +1,39 @@
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any
+
+from swerex.deployment.docker import DockerDeployment
+from swerex.runtime.abstract import Command as RexCommand
+
+
+@dataclass
+class SwerexDockerEnvironmentConfig:
+    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)
+    """Extra kwargs to pass to DockerDeployment."""
+
+
+class SwerexDockerEnvironment:
+    def __init__(self, **kwargs):
+        """This class executes bash commands in a Docker container using SWE-ReX for sandboxing."""
+        self.config = SwerexDockerEnvironmentConfig(**kwargs)
+        self.deployment = DockerDeployment(image=self.config.image, **self.config.deployment_extra_kwargs)
+        asyncio.run(self.deployment.start())
+
+    def execute(self, command: str, cwd: str = "") -> 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=self.config.timeout
+                )
+            )
+        )
+        return {
+            "output": f"<stdout>\n{output.stdout}</stdout>\n<stderr>\n{output.stderr}</stderr>",
+            "returncode": output.exit_code,
+        }

minisweagent/environments/local.py

@@ -0,0 +1,33 @@
+import os
+import subprocess
+from dataclasses import dataclass, field
+
+
+@dataclass
+class LocalEnvironmentConfig:
+    cwd: str = ""
+    env: dict[str, str] = field(default_factory=dict)
+    timeout: int = 30
+
+
+class LocalEnvironment:
+    def __init__(self, *, config_class: type = LocalEnvironmentConfig, **kwargs):
+        """This class executes bash commands directly on the local machine."""
+        self.config = config_class(**kwargs)
+
+    def execute(self, command: str, cwd: str = ""):
+        """Execute a command in the local environment and return the result as a dict."""
+        cwd = cwd or self.config.cwd or os.getcwd()
+        result = subprocess.run(
+            command,
+            shell=True,
+            text=True,
+            cwd=cwd,
+            env=os.environ | self.config.env,
+            timeout=self.config.timeout,
+            encoding="utf-8",
+            errors="replace",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        return {"output": result.stdout, "returncode": result.returncode}

minisweagent/environments/singularity.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+
+import os
+import subprocess
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class SingularityEnvironmentConfig:
+    image: str
+    cwd: str = "/"
+    env: dict[str, str] = field(default_factory=dict)
+    """Environment variables to set in the container."""
+    forward_env: list[str] = field(default_factory=list)
+    """Environment variables to forward to the container."""
+    timeout: int = 30
+    """Timeout for executing commands in the container."""
+    executable: str = "singularity"
+    """Path to the singularity executable."""
+
+
+class SingularityEnvironment:
+    def __init__(self, **kwargs):
+        """Singularity environment. See `SingularityEnvironmentConfig` for kwargs."""
+        self.config = SingularityEnvironmentConfig(**kwargs)
+
+    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"]
+
+        work_dir = cwd or self.config.cwd
+        if work_dir and work_dir != "/":
+            cmd.extend(["--pwd", work_dir])
+
+        for key in self.config.forward_env:
+            if (value := os.getenv(key)) is not None:
+                cmd.extend(["--env", f"{key}={value}"])
+        for key, value in self.config.env.items():
+            cmd.extend(["--env", f"{key}={value}"])
+
+        cmd.extend([self.config.image, "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}

minisweagent/models/__init__.py

@@ -0,0 +1,81 @@
+"""This file provides convenience functions for selecting models.
+You can ignore this file completely if you explicitly set your model in your run script.
+"""
+
+import copy
+import os
+import threading
+
+from minisweagent import Model
+
+
+class GlobalModelStats:
+    """Global model statistics tracker with optional limits."""
+
+    def __init__(self):
+        self._cost = 0.0
+        self._n_calls = 0
+        self._lock = threading.Lock()
+        self.cost_limit = float(os.getenv("MSWEA_GLOBAL_COST_LIMIT", "0"))
+        self.call_limit = int(os.getenv("MSWEA_GLOBAL_CALL_LIMIT", "0"))
+        if (self.cost_limit > 0 or self.call_limit > 0) and not os.getenv("MINI_SWE_AGENT_SILENT_STARTUP"):
+            print(f"Global cost/call limit: ${self.cost_limit:.4f} / {self.call_limit}")
+
+    def add(self, cost: float) -> None:
+        """Add a model call with its cost, checking limits."""
+        with self._lock:
+            self._cost += cost
+            self._n_calls += 1
+        if 0 < self.cost_limit < self._cost or 0 < self.call_limit < self._n_calls + 1:
+            raise RuntimeError(f"Global cost/call limit exceeded: ${self._cost:.4f} / {self._n_calls + 1}")
+
+    @property
+    def cost(self) -> float:
+        return self._cost
+
+    @property
+    def n_calls(self) -> int:
+        return self._n_calls
+
+
+GLOBAL_MODEL_STATS = GlobalModelStats()
+
+
+def get_model(input_model_name: str | None = None, config: dict | None = None) -> Model:
+    """Get an initialized model object from any kind of user input or settings."""
+    resolved_model_name = get_model_name(input_model_name, config)
+    if config is None:
+        config = {}
+    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)
+
+
+def get_model_name(input_model_name: str | None = None, config: dict | None = None) -> str:
+    """Get a model name from any kind of user input or settings."""
+    if config is None:
+        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
+    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."""
+    if any(s in model_name.lower() for s in ["anthropic", "sonnet", "opus", "claude"]):
+        from minisweagent.models.anthropic import AnthropicModel
+
+        return AnthropicModel
+    from minisweagent.models.litellm_model import LitellmModel
+
+    return LitellmModel

minisweagent/models/anthropic.py

@@ -0,0 +1,19 @@
+import os
+
+from minisweagent.models.litellm_model import LitellmModel
+from minisweagent.models.utils.cache_control import set_cache_control
+from minisweagent.models.utils.key_per_thread import get_key_per_thread
+
+
+class AnthropicModel(LitellmModel):
+    """For the use of anthropic models, we need to add explicit cache control marks
+    to the messages or we lose out on the benefits of the cache.
+    Because break points are limited per key, we also need to rotate between different keys
+    if running with multiple agents in parallel threads.
+    """
+
+    def query(self, messages: list[dict], **kwargs) -> dict:
+        api_key = None
+        if rotating_keys := os.getenv("ANTHROPIC_API_KEYS"):
+            api_key = get_key_per_thread(rotating_keys.split("::"))
+        return super().query(set_cache_control(messages), api_key=api_key, **kwargs)

minisweagent/models/litellm_model.py

@@ -0,0 +1,64 @@
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+import litellm
+from tenacity import (
+    before_sleep_log,
+    retry,
+    retry_if_not_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from minisweagent.models import GLOBAL_MODEL_STATS
+
+logger = logging.getLogger("litellm_model")
+
+
+@dataclass
+class LitellmModelConfig:
+    model_name: str
+    model_kwargs: dict[str, Any] = field(default_factory=dict)
+
+
+class LitellmModel:
+    def __init__(self, **kwargs):
+        self.config = LitellmModelConfig(**kwargs)
+        self.cost = 0.0
+        self.n_calls = 0
+
+    @retry(
+        stop=stop_after_attempt(10),
+        wait=wait_exponential(multiplier=1, min=4, max=60),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+        retry=retry_if_not_exception_type(
+            (
+                litellm.exceptions.UnsupportedParamsError,
+                litellm.exceptions.NotFoundError,
+                litellm.exceptions.PermissionDeniedError,
+                litellm.exceptions.ContextWindowExceededError,
+                litellm.exceptions.APIError,
+                litellm.exceptions.AuthenticationError,
+                KeyboardInterrupt,
+            )
+        ),
+    )
+    def _query(self, messages: list[dict[str, str]], **kwargs):
+        try:
+            return litellm.completion(
+                model=self.config.model_name, messages=messages, **(self.config.model_kwargs | kwargs)
+            )
+        except litellm.exceptions.AuthenticationError as e:
+            e.message += " You can permanently set your API key with `mini-extra config set KEY VALUE`."
+            raise e
+
+    def query(self, messages: list[dict[str, str]], **kwargs) -> dict:
+        response = self._query(messages, **kwargs)
+        cost = litellm.cost_calculator.completion_cost(response)
+        self.n_calls += 1
+        self.cost += cost
+        GLOBAL_MODEL_STATS.add(cost)
+        return {
+            "content": response.choices[0].message.content or "",  # type: ignore
+        }

minisweagent/models/test_models.py

@@ -0,0 +1,38 @@
+import logging
+import time
+from dataclasses import dataclass
+
+from minisweagent.models import GLOBAL_MODEL_STATS
+
+
+@dataclass
+class DeterministicModelConfig:
+    outputs: list[str]
+    model_name: str = "deterministic"
+    cost_per_call: float = 1.0
+
+
+class DeterministicModel:
+    def __init__(self, **kwargs):
+        """
+        Initialize with a list of outputs to return in sequence.
+        """
+        self.config = DeterministicModelConfig(**kwargs)
+        self.current_index = -1
+        self.cost = 0.0
+        self.n_calls = 0
+
+    def query(self, messages: list[dict[str, str]], **kwargs) -> dict:
+        self.current_index += 1
+        output = self.config.outputs[self.current_index]
+        if "/sleep" in output:
+            print("SLEEPING")
+            time.sleep(float(output.split("/sleep")[1]))
+            return self.query(messages, **kwargs)
+        if "/warning" in output:
+            logging.warning(output.split("/warning")[1])
+            return self.query(messages, **kwargs)
+        self.n_calls += 1
+        self.cost += self.config.cost_per_call
+        GLOBAL_MODEL_STATS.add(self.config.cost_per_call)
+        return {"content": output}

minisweagent/models/utils/cache_control.py

@@ -0,0 +1,42 @@
+def _get_content_text(entry: dict) -> str:
+    if isinstance(entry["content"], str):
+        return entry["content"]
+    assert len(entry["content"]) == 1, "Expected single message in content"
+    return entry["content"][0]["text"]
+
+
+def _clear_cache_control(entry: dict) -> None:
+    if isinstance(entry["content"], list):
+        assert len(entry["content"]) == 1, "Expected single message in content"
+        entry["content"][0].pop("cache_control", None)
+    entry.pop("cache_control", None)
+
+
+def _set_cache_control(entry: dict) -> None:
+    if not isinstance(entry["content"], list):
+        entry["content"] = [  # type: ignore
+            {
+                "type": "text",
+                "text": _get_content_text(entry),
+                "cache_control": {"type": "ephemeral"},
+            }
+        ]
+    else:
+        entry["content"][0]["cache_control"] = {"type": "ephemeral"}
+    if entry["role"] == "tool":
+        # Workaround for weird bug
+        entry["content"][0].pop("cache_control", None)
+        entry["cache_control"] = {"type": "ephemeral"}
+
+
+def set_cache_control(messages: list[dict], last_n_messages_offset: int = 0) -> list[dict]:
+    """This messages processor adds manual cache control marks to the messages."""
+    new_messages = []
+    n_tagged = 0
+    for i_entry, entry in enumerate(reversed(messages)):
+        _clear_cache_control(entry)
+        if n_tagged < 2 and entry["role"] in ["user"] and i_entry >= last_n_messages_offset:
+            _set_cache_control(entry)
+            n_tagged += 1
+        new_messages.append(entry)
+    return list(reversed(new_messages))

minisweagent/models/utils/key_per_thread.py

@@ -0,0 +1,18 @@
+"""Utility for anthropic where we need different keys for different parallel
+agents to not mess up prompt caching.
+"""
+
+import threading
+from typing import Any
+
+_THREADS_THAT_USED_API_KEYS: list[Any] = []
+
+
+def get_key_per_thread(api_keys: list[Any]) -> Any:
+    """Choose key based on thread name. Returns None if no keys are available."""
+    thread_name = threading.current_thread().name
+    if thread_name not in _THREADS_THAT_USED_API_KEYS:
+        _THREADS_THAT_USED_API_KEYS.append(thread_name)
+    thread_idx = _THREADS_THAT_USED_API_KEYS.index(thread_name)
+    key_idx = thread_idx % len(api_keys)
+    return api_keys[key_idx] or None

minisweagent/run/__init__.py

@@ -0,0 +1 @@
+"""Run scripts for mini-SWE-agent."""

minisweagent/run/extra/config.py

@@ -0,0 +1,100 @@
+"""Utility to manage the global config file.
+
+You can also directly edit the `.env` file in the config directory.
+
+It is located at [bold green]{global_config_file}[/bold green].
+"""
+
+import os
+import subprocess
+
+from dotenv import set_key, unset_key
+from prompt_toolkit import prompt
+from rich.console import Console
+from rich.rule import Rule
+from typer import Option, Typer
+
+from minisweagent import global_config_file
+
+app = Typer(
+    help=__doc__.format(global_config_file=global_config_file),  # type: ignore
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    add_completion=False,
+)
+console = Console(highlight=False)
+
+
+_SETUP_HELP = """Welcome to Mini!
+
+To get started, we need to set up your global config file.
+
+You can edit it manually or use the [bold green]mini-extra config set[/bold green] or [bold green]mini-extra config edit[/bold green] commands.
+
+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 yellow]You can leave any setting blank to skip it.[/bold yellow]
+"""
+
+
+def configure_if_first_time():
+    if not os.getenv("MSWEA_CONFIGURED"):
+        console.print(Rule())
+        setup()
+        console.print(Rule())
+
+
+@app.command()
+def setup():
+    """Setup the global config file."""
+    console.print(_SETUP_HELP.format(global_config_file=global_config_file))
+    default_model = prompt(
+        "Enter your default model (e.g., claude-sonnet-4-20250514): ", default=os.getenv("MSWEA_MODEL_NAME", "")
+    ).strip()
+    if default_model:
+        set_key(global_config_file, "MSWEA_MODEL_NAME", default_model)
+    key_name = prompt("Enter your API key name (e.g., ANTHROPIC_API_KEY): ").strip()
+    key_value = None
+    if key_name:
+        key_value = prompt("Enter your API key value (e.g., sk-1234567890): ", default=os.getenv(key_name, "")).strip()
+        if key_value:
+            set_key(global_config_file, key_name, key_value)
+    if not key_value:
+        console.print(
+            "[bold red]API key setup not completed.[/bold red] Totally fine if you have your keys as environment variables."
+        )
+    set_key(global_config_file, "MSWEA_CONFIGURED", "true")
+    console.print(
+        "\n[bold yellow]Config finished.[/bold yellow] If you want to revisit it, run [bold green]mini-extra config setup[/bold green]."
+    )
+
+
+@app.command()
+def set(
+    key: str = Option(..., help="The key to set", prompt=True),
+    value: str = Option(..., help="The value to set", prompt=True),
+):
+    """Set a key in the global config file."""
+    set_key(global_config_file, key, value)
+
+
+@app.command()
+def unset(key: str = Option(..., help="The key to unset")):
+    """Unset a key in the global config file."""
+    unset_key(global_config_file, key)
+
+
+@app.command()
+def edit():
+    """Edit the global config file."""
+    editor = os.getenv("EDITOR", "nano")
+    subprocess.run([editor, global_config_file])
+
+
+if __name__ == "__main__":
+    app()