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

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/github_issue.py

@@ -1,87 +0,0 @@
-#!/usr/bin/env python3
-import os
-from pathlib import Path
-
-import requests
-import typer
-import yaml
-from rich.console import Console
-
-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.config import configure_if_first_time
-from minisweagent.run.utils.save import save_traj
-
-DEFAULT_CONFIG = Path(os.getenv("MSWEA_GITHUB_CONFIG_PATH", builtin_config_dir / "github_issue.yaml"))
-console = Console(highlight=False)
-app = typer.Typer(rich_markup_mode="rich", add_completion=False)
-
-
-def fetch_github_issue(issue_url: str) -> str:
-    """Fetch GitHub issue text from the URL."""
-    # Convert GitHub issue URL to API URL
-    api_url = issue_url.replace("github.com", "api.github.com/repos").replace("/issues/", "/issues/")
-
-    headers = {}
-    if github_token := os.getenv("GITHUB_TOKEN"):
-        headers["Authorization"] = f"token {github_token}"
-
-    response = requests.get(api_url, headers=headers)
-    issue_data = response.json()
-
-    title = issue_data["title"]
-    body = issue_data["body"] or ""
-
-    return f"GitHub Issue: {title}\n\n{body}"
-
-
-# fmt: off
-@app.command()
-def main(
-    issue_url: str = typer.Option(prompt="Enter GitHub issue URL", help="GitHub issue URL"),
-    config: Path = typer.Option(DEFAULT_CONFIG, "-c", "--config", help="Path to config file"),
-    model: str | None = typer.Option(None, "-m", "--model", help="Model to use"),
-    model_class: str | None = typer.Option(None, "--model-class", help="Model class to use (e.g., 'anthropic' or 'minisweagent.models.anthropic.AnthropicModel')", rich_help_panel="Advanced"),
-    yolo: bool = typer.Option(False, "-y", "--yolo", help="Run without confirmation"),
-) -> InteractiveAgent:
-    # fmt: on
-    """Run mini-SWE-agent on a GitHub issue"""
-    configure_if_first_time()
-
-    config_path = get_config_path(config)
-    console.print(f"Loading agent config from [bold green]'{config_path}'[/bold green]")
-    _config = yaml.safe_load(config_path.read_text())
-    _agent_config = _config.setdefault("agent", {})
-    if yolo:
-        _agent_config["mode"] = "yolo"
-    if model_class is not None:
-        _config.setdefault("model", {})["model_class"] = model_class
-
-    task = fetch_github_issue(issue_url)
-
-    agent = InteractiveAgent(
-        get_model(model, _config.get("model", {})),
-        DockerEnvironment(**_config.get("environment", {})),
-        **_agent_config,
-    )
-
-    repo_url = issue_url.split("/issues/")[0]
-    if github_token := os.getenv("GITHUB_TOKEN"):
-        repo_url = repo_url.replace("https://github.com/", f"https://{github_token}@github.com/") + ".git"
-
-    agent.env.execute(f"git clone {repo_url} /testbed", cwd="/")
-
-    exit_status, result = None, None
-    try:
-        exit_status, result = agent.run(task)
-    except KeyboardInterrupt:
-        console.print("\n[bold red]KeyboardInterrupt -- goodbye[/bold red]")
-    finally:
-        save_traj(agent, Path("traj.json"), exit_status=exit_status, result=result)
-    return agent
-
-
-if __name__ == "__main__":
-    app()

minisweagent/run/utils/save.py

@@ -1,78 +0,0 @@
-import dataclasses
-import json
-from collections.abc import Callable
-from pathlib import Path
-from typing import Any
-
-from minisweagent import Agent, __version__
-
-
-def _get_class_name_with_module(obj: Any) -> str:
-    """Get the full class name with module path."""
-    return f"{obj.__class__.__module__}.{obj.__class__.__name__}"
-
-
-def _asdict(obj: Any) -> dict:
-    """Convert config objects to dicts."""
-    if dataclasses.is_dataclass(obj):
-        return dataclasses.asdict(obj)  # type: ignore[arg-type]
-    return obj  # let's try our luck
-
-
-def save_traj(
-    agent: Agent | None,
-    path: Path | None,
-    *,
-    print_path: bool = True,
-    exit_status: str | None = None,
-    result: str | None = None,
-    extra_info: dict | None = None,
-    print_fct: Callable = print,
-    **kwargs,
-):
-    """Save the trajectory of the agent to a file.
-
-    Args:
-        agent: The agent to save the trajectory of.
-        path: The path to save the trajectory to.
-        print_path: Whether to print confirmation of path to the terminal.
-        exit_status: The exit status of the agent.
-        result: The result/submission of the agent.
-        extra_info: Extra information to save (will be merged into the info dict).
-        **kwargs: Additional information to save (will be merged into top level)
-
-    """
-    if path is None:
-        return
-    data = {
-        "info": {
-            "exit_status": exit_status,
-            "submission": result,
-            "model_stats": {
-                "instance_cost": 0.0,
-                "api_calls": 0,
-            },
-            "mini_version": __version__,
-        },
-        "messages": [],
-        "trajectory_format": "mini-swe-agent-1",
-    } | kwargs
-    if agent is not None:
-        data["info"]["model_stats"]["instance_cost"] = agent.model.cost
-        data["info"]["model_stats"]["api_calls"] = agent.model.n_calls
-        data["messages"] = agent.messages
-        data["info"]["config"] = {
-            "agent": _asdict(agent.config),
-            "model": _asdict(agent.model.config),
-            "environment": _asdict(agent.env.config),
-            "agent_type": _get_class_name_with_module(agent),
-            "model_type": _get_class_name_with_module(agent.model),
-            "environment_type": _get_class_name_with_module(agent.env),
-        }
-    if extra_info:
-        data["info"].update(extra_info)
-
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(data, indent=2))
-    if print_path:
-        print_fct(f"Saved trajectory to '{path}'")