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

minisweagent/config/extra/swebench_roulette.yaml

@@ -1,233 +0,0 @@
-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 /testbed (this is the working directory for all your subsequent commands)
-    - 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: "anthropic/claude-sonnet-4-5-20250929"
-      model_kwargs:
-        temperature: 0.
-    - model_name: "gpt-5"

minisweagent/config/mini.tcss

@@ -1,86 +0,0 @@
-Screen {
-    layout: grid;
-    grid-size: 1;
-    grid-rows: auto 1fr auto;
-}
-
-#main {
-    height: 100%;
-    padding: 1;
-    layout: vertical;
-}
-
-Footer {
-    dock: bottom;
-    content-align: center middle;
-}
-
-#content {
-    height: auto;
-    min-height: 0;
-}
-
-.smart-input-container {
-    height: auto;
-    margin-top: 0;
-    padding: 0;
-    min-height: 0;
-}
-
-.multi-input {
-    height: auto;
-    max-height: 20;
-    min-height: 3;
-}
-
-.prompt-display {
-    margin-bottom: 1;
-    padding: 0 1;
-    text-style: bold;
-}
-
-.hint-text{
-    margin-top: 1;
-    margin-bottom: 1;
-    padding: 0 1;
-    color: white;
-}
-
-.message-container {
-    margin: 1;
-    padding: 1;
-    background: $surface;
-    height: auto;
-    width: 100%;
-}
-
-.message-header {
-    text-align: left;
-    color: $primary;
-    padding: 0 1;
-    text-style: bold;
-}
-
-.input-request-header {
-    color: $warning;
-}
-
-.message-content {
-    margin-top: 1;
-    padding: 0 1;
-}
-
-Header.running {
-    background: $error;
-}
-
-.button-container {
-    layout: horizontal;
-    align-horizontal: center;
-    margin-top: 1;
-}
-
-.button-container Button {
-    margin: 0 1;
-    min-width: 10;
-}

minisweagent/models/anthropic.py

@@ -1,35 +0,0 @@
-import os
-import warnings
-from typing import Literal
-
-from minisweagent.models.litellm_model import LitellmModel, LitellmModelConfig
-from minisweagent.models.utils.cache_control import set_cache_control
-from minisweagent.models.utils.key_per_thread import get_key_per_thread
-
-
-class AnthropicModelConfig(LitellmModelConfig):
-    set_cache_control: Literal["default_end"] | None = "default_end"
-    """Set explicit cache control markers, for example for Anthropic models"""
-
-
-class AnthropicModel(LitellmModel):
-    """This class is now only a thin wrapper around the LitellmModel class.
-    It is largely kept for backwards compatibility.
-    It will not be selected by `get_model` and `get_model_class` unless explicitly specified.
-    """
-
-    def __init__(self, *, config_class: type = AnthropicModelConfig, **kwargs):
-        super().__init__(config_class=config_class, **kwargs)
-
-    def query(self, messages: list[dict], **kwargs) -> dict:
-        api_key = None
-        # Legacy only
-        if rotating_keys := os.getenv("ANTHROPIC_API_KEYS"):
-            warnings.warn(
-                "ANTHROPIC_API_KEYS is deprecated and will be removed in the future. "
-                "Simply use the ANTHROPIC_API_KEY environment variable instead. "
-                "Key rotation is no longer required."
-            )
-            api_key = get_key_per_thread(rotating_keys.split("::"))
-        messages = set_cache_control(messages, mode="default_end")
-        return super().query(messages, api_key=api_key, **kwargs)

minisweagent/models/litellm_response_api_model.py

@@ -1,82 +0,0 @@
-import logging
-from collections.abc import Callable
-from dataclasses import dataclass
-
-import litellm
-from tenacity import (
-    before_sleep_log,
-    retry,
-    retry_if_not_exception_type,
-    stop_after_attempt,
-    wait_exponential,
-)
-
-from minisweagent.models.litellm_model import LitellmModel, LitellmModelConfig
-from minisweagent.models.utils.openai_utils import coerce_responses_text
-
-logger = logging.getLogger("litellm_response_api_model")
-
-
-@dataclass
-class LitellmResponseAPIModelConfig(LitellmModelConfig):
-    pass
-
-
-class LitellmResponseAPIModel(LitellmModel):
-    def __init__(self, *, config_class: Callable = LitellmResponseAPIModelConfig, **kwargs):
-        super().__init__(config_class=config_class, **kwargs)
-        self._previous_response_id: str | None = None
-
-    @retry(
-        reraise=True,
-        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:
-            # Remove 'timestamp' field added by agent - not supported by OpenAI responses API
-            clean_messages = [{"role": msg["role"], "content": msg["content"]} for msg in messages]
-            resp = litellm.responses(
-                model=self.config.model_name,
-                input=clean_messages if self._previous_response_id is None else clean_messages[-1:],
-                previous_response_id=self._previous_response_id,
-                **(self.config.model_kwargs | kwargs),
-            )
-            self._previous_response_id = getattr(resp, "id", None)
-            return resp
-        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)
-        text = coerce_responses_text(response)
-        try:
-            cost = litellm.cost_calculator.completion_cost(response, model=self.config.model_name)
-        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
-        from minisweagent.models import GLOBAL_MODEL_STATS
-
-        GLOBAL_MODEL_STATS.add(cost)
-        return {
-            "content": text,
-        }

minisweagent/models/portkey_response_api_model.py

@@ -1,75 +0,0 @@
-import logging
-import os
-from dataclasses import dataclass
-
-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
-from minisweagent.models.portkey_model import PortkeyModel, PortkeyModelConfig
-from minisweagent.models.utils.cache_control import set_cache_control
-from minisweagent.models.utils.openai_utils import coerce_responses_text
-
-logger = logging.getLogger("portkey_response_api_model")
-
-
-@dataclass
-class PortkeyResponseAPIModelConfig(PortkeyModelConfig):
-    pass
-
-
-class PortkeyResponseAPIModel(PortkeyModel):
-    def __init__(self, *, config_class: type = PortkeyResponseAPIModelConfig, **kwargs):
-        super().__init__(config_class=config_class, **kwargs)
-        self._previous_response_id: str | None = None
-
-    @retry(
-        reraise=True,
-        stop=stop_after_attempt(int(os.getenv("MSWEA_MODEL_RETRY_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((KeyboardInterrupt, TypeError, ValueError)),
-    )
-    def _query(self, messages: list[dict[str, str]], **kwargs):
-        input_messages = messages if self._previous_response_id is None else messages[-1:]
-        resp = self.client.responses.create(
-            model=self.config.model_name,
-            input=input_messages,
-            previous_response_id=self._previous_response_id,
-            **(self.config.model_kwargs | kwargs),
-        )
-        self._previous_response_id = getattr(resp, "id", None)
-        return resp
-
-    def query(self, messages: list[dict[str, str]], **kwargs) -> dict:
-        if self.config.set_cache_control:
-            messages = set_cache_control(messages, mode=self.config.set_cache_control)
-        response = self._query(messages, **kwargs)
-        text = coerce_responses_text(response)
-        try:
-            cost = litellm.cost_calculator.completion_cost(response, model=self.config.model_name)
-            assert cost > 0.0, f"Cost is not positive: {cost}"
-        except Exception as e:
-            if self.config.cost_tracking != "ignore_errors":
-                raise RuntimeError(
-                    f"Error calculating cost for model {self.config.model_name}: {e}. "
-                    "You can ignore this issue from your config file with cost_tracking: 'ignore_errors' or "
-                    "globally with export MSWEA_COST_TRACKING='ignore_errors' to ignore this error. "
-                ) from e
-            cost = 0.0
-        self.n_calls += 1
-        self.cost += cost
-        GLOBAL_MODEL_STATS.add(cost)
-        return {
-            "content": text,
-            "extra": {
-                "response": response.model_dump() if hasattr(response, "model_dump") else {},
-                "cost": cost,
-            },
-        }

minisweagent/models/utils/key_per_thread.py

@@ -1,20 +0,0 @@
-"""Utility for anthropic where we need different keys for different parallel
-agents to not mess up prompt caching.
-"""
-
-import threading
-import warnings
-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."""
-    warnings.warn("get_key_per_thread is deprecated and will be removed in the future")
-    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/models/utils/openai_utils.py

@@ -1,41 +0,0 @@
-import logging
-from typing import Any
-
-from openai.types.responses.response_output_message import ResponseOutputMessage
-
-logger = logging.getLogger("openai_utils")
-
-
-def coerce_responses_text(resp: Any) -> str:
-    """Helper to normalize OpenAI Responses API result to text.
-
-    Works with both OpenAI client responses and LiteLLM/Portkey responses.
-    """
-    text = getattr(resp, "output_text", None)
-    if isinstance(text, str) and text:
-        return text
-
-    try:
-        output = []
-        for item in resp.output:
-            if isinstance(item, dict):
-                content = item.get("content", [])
-            elif isinstance(item, ResponseOutputMessage):
-                content = item.content
-            else:
-                continue
-
-            for content_item in content:
-                if isinstance(content_item, dict):
-                    text_val = content_item.get("text")
-                elif hasattr(content_item, "text"):
-                    text_val = content_item.text
-                else:
-                    continue
-
-                if text_val:
-                    output.append(text_val)
-        return "\n\n".join(output) or ""
-    except (AttributeError, IndexError, TypeError):
-        logger.warning(f"Could not extract text from response: {resp}")
-        return ""

minisweagent/run/extra/swebench_single.py

@@ -1,79 +0,0 @@
-"""Run on a single SWE-Bench instance."""
-
-import traceback
-from pathlib import Path
-
-import typer
-import yaml
-from datasets import load_dataset
-
-from minisweagent import global_config_dir
-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,
-)
-from minisweagent.run.utils.save import save_traj
-from minisweagent.utils.log import logger
-
-app = typer.Typer(add_completion=False)
-
-DEFAULT_OUTPUT = global_config_dir / "last_swebench_single_run.traj.json"
-
-
-# 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"),
-    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"),
-    output: Path = typer.Option(DEFAULT_OUTPUT, "-o", "--output", help="Output trajectory file", rich_help_panel="Basic"),
-) -> None:
-    # fmt: on
-    """Run on a single SWE-Bench instance."""
-    dataset_path = DATASET_MAPPING.get(subset, subset)
-    logger.info(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_path = get_config_path(config_path)
-    logger.info(f"Loading agent config from '{config_path}'")
-    config = yaml.safe_load(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)
-    agent = InteractiveAgent(
-        get_model(model_name, config.get("model", {})),
-        env,
-        **({"mode": "yolo"} | config.get("agent", {})),
-    )
-
-    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, extra_info=extra_info)  # type: ignore[arg-type]
-
-
-if __name__ == "__main__":
-    app()