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

minisweagent/models/portkey_response_api_model.py

@@ -0,0 +1,74 @@
+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(
+        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)
+            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/requesty_model.py

@@ -0,0 +1,119 @@
+import json
+import logging
+import os
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+import requests
+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("requesty_model")
+
+
+@dataclass
+class RequestyModelConfig:
+    model_name: str
+    model_kwargs: dict[str, Any] = field(default_factory=dict)
+
+
+class RequestyAPIError(Exception):
+    """Custom exception for Requesty API errors."""
+
+    pass
+
+
+class RequestyAuthenticationError(Exception):
+    """Custom exception for Requesty authentication errors."""
+
+    pass
+
+
+class RequestyRateLimitError(Exception):
+    """Custom exception for Requesty rate limit errors."""
+
+    pass
+
+
+class RequestyModel:
+    def __init__(self, **kwargs):
+        self.config = RequestyModelConfig(**kwargs)
+        self.cost = 0.0
+        self.n_calls = 0
+        self._api_url = "https://router.requesty.ai/v1/chat/completions"
+        self._api_key = os.getenv("REQUESTY_API_KEY", "")
+
+    @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(
+            (
+                RequestyAuthenticationError,
+                KeyboardInterrupt,
+            )
+        ),
+    )
+    def _query(self, messages: list[dict[str, str]], **kwargs):
+        headers = {
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://github.com/SWE-agent/mini-swe-agent",
+            "X-Title": "mini-swe-agent",
+        }
+
+        payload = {
+            "model": self.config.model_name,
+            "messages": messages,
+            **(self.config.model_kwargs | kwargs),
+        }
+
+        try:
+            response = requests.post(self._api_url, headers=headers, data=json.dumps(payload), timeout=60)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.HTTPError as e:
+            if response.status_code == 401:
+                error_msg = "Authentication failed. You can permanently set your API key with `mini-extra config set REQUESTY_API_KEY YOUR_KEY`."
+                raise RequestyAuthenticationError(error_msg) from e
+            elif response.status_code == 429:
+                raise RequestyRateLimitError("Rate limit exceeded") from e
+            else:
+                raise RequestyAPIError(f"HTTP {response.status_code}: {response.text}") from e
+        except requests.exceptions.RequestException as e:
+            raise RequestyAPIError(f"Request failed: {e}") from e
+
+    def query(self, messages: list[dict[str, str]], **kwargs) -> dict:
+        response = self._query(messages, **kwargs)
+
+        # Extract cost from usage information
+        usage = response.get("usage", {})
+        cost = usage.get("cost", 0.0)
+
+        # If cost is not available, raise an error
+        if cost == 0.0:
+            raise RequestyAPIError(
+                f"No cost information available from Requesty API for model {self.config.model_name}. "
+                "Cost tracking is required but not provided by the API response."
+            )
+
+        self.n_calls += 1
+        self.cost += cost
+        GLOBAL_MODEL_STATS.add(cost)
+
+        return {
+            "content": response["choices"][0]["message"]["content"] or "",
+            "extra": {
+                "response": response,  # already is json
+            },
+        }
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config) | {"n_model_calls": self.n_calls, "model_cost": self.cost}

minisweagent/models/test_models.py

@@ -0,0 +1,42 @@
+import logging
+import time
+from dataclasses import asdict, dataclass
+from typing import Any
+
+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}
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config) | {"n_model_calls": self.n_calls, "model_cost": self.cost}

minisweagent/models/utils/cache_control.py

@@ -0,0 +1,54 @@
+import copy
+import warnings
+from typing import Literal
+
+
+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], *, mode: Literal["default_end"] | None = "default_end", last_n_messages_offset: int = 0
+) -> list[dict]:
+    """This messages processor adds manual cache control marks to the messages."""
+    # ONLY ADD TO THE LAST MESSAGE
+    if mode != "default_end":
+        raise ValueError(f"Invalid mode: {mode}")
+    if last_n_messages_offset:
+        warnings.warn("last_n_messages_offset is deprecated and will be removed in the future. It has no effect.")
+
+    messages = copy.deepcopy(messages)
+    new_messages = []
+    for i_entry, entry in enumerate(reversed(messages)):
+        _clear_cache_control(entry)
+        if i_entry == 0:
+            _set_cache_control(entry)
+        new_messages.append(entry)
+    return list(reversed(new_messages))

minisweagent/models/utils/key_per_thread.py

@@ -0,0 +1,20 @@
+"""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

@@ -0,0 +1,41 @@
+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/__init__.py

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

minisweagent/run/extra/config.py

@@ -0,0 +1,114 @@
+"""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 Argument, 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 = """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]anthropic/claude-sonnet-4-5-20250929[/bold green] ([bold green]ANTHROPIC_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 green]gemini/gemini-3-pro-preview[/bold green] ([bold green]GEMINI_API_KEY[/bold green])
+
+[bold]Note: Please always include the provider (e.g., "openai/") in the model name.[/bold]
+
+[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/
+"""
+
+
+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., anthropic/claude-sonnet-4-5-20250929): ",
+        default=os.getenv("MSWEA_MODEL_NAME", ""),
+    ).strip()
+    if default_model:
+        set_key(global_config_file, "MSWEA_MODEL_NAME", default_model)
+    console.print(
+        "[bold yellow]If you already have your API keys set as environment variables, you can ignore the next question.[/bold yellow]"
+    )
+    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 | None = Argument(None, help="The key to set"),
+    value: str | None = Argument(None, help="The value to set"),
+):
+    """Set a key in the global config file."""
+    if key is None:
+        key = prompt("Enter the key to set: ")
+    if value is None:
+        value = prompt(f"Enter the value for {key}: ")
+    set_key(global_config_file, key, value)
+
+
+@app.command()
+def unset(key: str | None = Argument(None, help="The key to unset")):
+    """Unset a key in the global config file."""
+    if key is None:
+        key = prompt("Enter the key to unset: ")
+    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()