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

minisweagent/models/openrouter_model.py

@@ -1,72 +1,64 @@
 import json
 import logging
 import os
-from dataclasses import asdict, dataclass, field
+import time
 from typing import Any, Literal
 
 import requests
-from tenacity import (
-    before_sleep_log,
-    retry,
-    retry_if_not_exception_type,
-    stop_after_attempt,
-    wait_exponential,
-)
+from pydantic import BaseModel
 
 from minisweagent.models import GLOBAL_MODEL_STATS
+from minisweagent.models.utils.actions_toolcall import (
+    BASH_TOOL,
+    format_toolcall_observation_messages,
+    parse_toolcall_actions,
+)
+from minisweagent.models.utils.anthropic_utils import _reorder_anthropic_thinking_blocks
 from minisweagent.models.utils.cache_control import set_cache_control
+from minisweagent.models.utils.openai_multimodal import expand_multimodal_content
+from minisweagent.models.utils.retry import retry
 
 logger = logging.getLogger("openrouter_model")
 
 
-@dataclass
-class OpenRouterModelConfig:
+class OpenRouterModelConfig(BaseModel):
     model_name: str
-    model_kwargs: dict[str, Any] = field(default_factory=dict)
+    model_kwargs: dict[str, Any] = {}
     set_cache_control: Literal["default_end"] | None = None
     """Set explicit cache control markers, for example for Anthropic models"""
     cost_tracking: Literal["default", "ignore_errors"] = os.getenv("MSWEA_COST_TRACKING", "default")
     """Cost tracking mode for this model. Can be "default" or "ignore_errors" (ignore errors/missing cost info)"""
+    format_error_template: str = "{{ error }}"
+    """Template used when the LM's output is not in the expected format."""
+    observation_template: str = (
+        "{% if output.exception_info %}<exception>{{output.exception_info}}</exception>\n{% endif %}"
+        "<returncode>{{output.returncode}}</returncode>\n<output>\n{{output.output}}</output>"
+    )
+    """Template used to render the observation after executing an action."""
+    multimodal_regex: str = ""
+    """Regex to extract multimodal content. Empty string disables multimodal processing."""
 
 
 class OpenRouterAPIError(Exception):
     """Custom exception for OpenRouter API errors."""
 
-    pass
-
 
 class OpenRouterAuthenticationError(Exception):
     """Custom exception for OpenRouter authentication errors."""
 
-    pass
-
 
 class OpenRouterRateLimitError(Exception):
     """Custom exception for OpenRouter rate limit errors."""
 
-    pass
-
 
 class OpenRouterModel:
+    abort_exceptions: list[type[Exception]] = [OpenRouterAuthenticationError, KeyboardInterrupt]
+
     def __init__(self, **kwargs):
         self.config = OpenRouterModelConfig(**kwargs)
-        self.cost = 0.0
-        self.n_calls = 0
         self._api_url = "https://openrouter.ai/api/v1/chat/completions"
         self._api_key = os.getenv("OPENROUTER_API_KEY", "")
 
-    @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(
-            (
-                OpenRouterAuthenticationError,
-                KeyboardInterrupt,
-            )
-        ),
-    )
     def _query(self, messages: list[dict[str, str]], **kwargs):
         headers = {
             "Authorization": f"Bearer {self._api_key}",
@@ -76,6 +68,7 @@ class OpenRouterModel:
         payload = {
             "model": self.config.model_name,
             "messages": messages,
+            "tools": [BASH_TOOL],
             "usage": {"include": True},
             **(self.config.model_kwargs | kwargs),
         }
@@ -95,11 +88,27 @@ class OpenRouterModel:
         except requests.exceptions.RequestException as e:
             raise OpenRouterAPIError(f"Request failed: {e}") from e
 
+    def _prepare_messages_for_api(self, messages: list[dict]) -> list[dict]:
+        prepared = [{k: v for k, v in msg.items() if k != "extra"} for msg in messages]
+        prepared = _reorder_anthropic_thinking_blocks(prepared)
+        return set_cache_control(prepared, mode=self.config.set_cache_control)
+
     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([{"role": msg["role"], "content": msg["content"]} for msg in messages], **kwargs)
+        for attempt in retry(logger=logger, abort_exceptions=self.abort_exceptions):
+            with attempt:
+                response = self._query(self._prepare_messages_for_api(messages), **kwargs)
+        cost_output = self._calculate_cost(response)
+        GLOBAL_MODEL_STATS.add(cost_output["cost"])
+        message = dict(response["choices"][0]["message"])
+        message["extra"] = {
+            "actions": self._parse_actions(response),
+            "response": response,
+            **cost_output,
+            "timestamp": time.time(),
+        }
+        return message
 
+    def _calculate_cost(self, response) -> dict[str, float]:
         usage = response.get("usage", {})
         cost = usage.get("cost", 0.0)
         if cost <= 0.0 and self.config.cost_tracking != "ignore_errors":
@@ -110,17 +119,50 @@ class OpenRouterModel:
                 "(for example for free/local models), more information at https://klieret.short.gy/mini-local-models "
                 "for more details. Still stuck? Please open a github issue at https://github.com/SWE-agent/mini-swe-agent/issues/new/choose!"
             )
-
-        self.n_calls += 1
-        self.cost += cost
-        GLOBAL_MODEL_STATS.add(cost)
-
+        return {"cost": cost}
+
+    def _parse_actions(self, response: dict) -> list[dict]:
+        """Parse tool calls from the response. Raises FormatError if unknown tool."""
+        tool_calls = response["choices"][0]["message"].get("tool_calls") or []
+        tool_calls = [_DictToObj(tc) for tc in tool_calls]
+        return parse_toolcall_actions(tool_calls, format_error_template=self.config.format_error_template)
+
+    def format_message(self, **kwargs) -> dict:
+        return expand_multimodal_content(kwargs, pattern=self.config.multimodal_regex)
+
+    def format_observation_messages(
+        self, message: dict, outputs: list[dict], template_vars: dict | None = None
+    ) -> list[dict]:
+        """Format execution outputs into tool result messages."""
+        actions = message.get("extra", {}).get("actions", [])
+        return format_toolcall_observation_messages(
+            actions=actions,
+            outputs=outputs,
+            observation_template=self.config.observation_template,
+            template_vars=template_vars,
+            multimodal_regex=self.config.multimodal_regex,
+        )
+
+    def get_template_vars(self, **kwargs) -> dict[str, Any]:
+        return self.config.model_dump()
+
+    def serialize(self) -> dict:
         return {
-            "content": response["choices"][0]["message"]["content"] or "",
-            "extra": {
-                "response": response,  # already is json
-            },
+            "info": {
+                "config": {
+                    "model": self.config.model_dump(mode="json"),
+                    "model_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                },
+            }
         }
 
-    def get_template_vars(self) -> dict[str, Any]:
-        return asdict(self.config) | {"n_model_calls": self.n_calls, "model_cost": self.cost}
+
+class _DictToObj:
+    """Simple wrapper to convert dict to object with attribute access."""
+
+    def __init__(self, d: dict):
+        self._d = d
+        self.id = d.get("id")
+        self.function = _DictToObj(d.get("function", {})) if "function" in d else None
+        self.name = d.get("name")
+        self.arguments = d.get("arguments")

minisweagent/models/openrouter_response_model.py

@@ -0,0 +1,123 @@
+import json
+import logging
+import time
+
+import requests
+
+from minisweagent.models import GLOBAL_MODEL_STATS
+from minisweagent.models.openrouter_model import (
+    OpenRouterAPIError,
+    OpenRouterAuthenticationError,
+    OpenRouterModel,
+    OpenRouterModelConfig,
+    OpenRouterRateLimitError,
+)
+from minisweagent.models.utils.actions_toolcall_response import (
+    BASH_TOOL_RESPONSE_API,
+    format_toolcall_observation_messages,
+    parse_toolcall_actions_response,
+)
+from minisweagent.models.utils.retry import retry
+
+logger = logging.getLogger("openrouter_response_model")
+
+
+class OpenRouterResponseModelConfig(OpenRouterModelConfig):
+    pass
+
+
+class OpenRouterResponseModel(OpenRouterModel):
+    """OpenRouter model using the Responses API with native tool calling.
+
+    Note: OpenRouter's Responses API is stateless - each request must include
+    the full conversation history. previous_response_id is not supported.
+    See: https://openrouter.ai/docs/api/reference/responses/overview
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.config = OpenRouterResponseModelConfig(**kwargs)
+        self._api_url = "https://openrouter.ai/api/v1/responses"
+
+    def _query(self, messages: list[dict[str, str]], **kwargs):
+        headers = {
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": self.config.model_name,
+            "input": messages,
+            "tools": [BASH_TOOL_RESPONSE_API],
+            **(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 OPENROUTER_API_KEY YOUR_KEY`."
+                raise OpenRouterAuthenticationError(error_msg) from e
+            elif response.status_code == 429:
+                raise OpenRouterRateLimitError("Rate limit exceeded") from e
+            else:
+                raise OpenRouterAPIError(f"HTTP {response.status_code}: {response.text}") from e
+        except requests.exceptions.RequestException as e:
+            raise OpenRouterAPIError(f"Request failed: {e}") from e
+
+    def _prepare_messages_for_api(self, messages: list[dict]) -> list[dict]:
+        """Prepare messages for OpenRouter's stateless Responses API.
+
+        Flattens response objects into their output items since OpenRouter
+        doesn't support previous_response_id.
+        """
+        result = []
+        for msg in messages:
+            if msg.get("object") == "response":
+                for item in msg.get("output", []):
+                    result.append({k: v for k, v in item.items() if k != "extra"})
+            else:
+                result.append({k: v for k, v in msg.items() if k != "extra"})
+        return result
+
+    def query(self, messages: list[dict[str, str]], **kwargs) -> dict:
+        for attempt in retry(logger=logger, abort_exceptions=self.abort_exceptions):
+            with attempt:
+                response = self._query(self._prepare_messages_for_api(messages), **kwargs)
+        cost_output = self._calculate_cost(response)
+        GLOBAL_MODEL_STATS.add(cost_output["cost"])
+        message = dict(response)
+        message["extra"] = {
+            "actions": self._parse_actions(response),
+            **cost_output,
+            "timestamp": time.time(),
+        }
+        return message
+
+    def _parse_actions(self, response: dict) -> list[dict]:
+        return parse_toolcall_actions_response(
+            response.get("output", []), format_error_template=self.config.format_error_template
+        )
+
+    def format_message(self, **kwargs) -> dict:
+        role = kwargs.get("role", "user")
+        content = kwargs.get("content", "")
+        extra = kwargs.get("extra")
+        content_items = [{"type": "input_text", "text": content}] if isinstance(content, str) else content
+        msg = {"type": "message", "role": role, "content": content_items}
+        if extra:
+            msg["extra"] = extra
+        return msg
+
+    def format_observation_messages(
+        self, message: dict, outputs: list[dict], template_vars: dict | None = None
+    ) -> list[dict]:
+        """Format execution outputs into tool result messages."""
+        actions = message.get("extra", {}).get("actions", [])
+        return format_toolcall_observation_messages(
+            actions=actions,
+            outputs=outputs,
+            observation_template=self.config.observation_template,
+            template_vars=template_vars,
+            multimodal_regex=self.config.multimodal_regex,
+        )

minisweagent/models/openrouter_textbased_model.py

@@ -0,0 +1,76 @@
+import json
+import logging
+
+import requests
+
+from minisweagent.models.openrouter_model import (
+    OpenRouterAPIError,
+    OpenRouterAuthenticationError,
+    OpenRouterModel,
+    OpenRouterModelConfig,
+    OpenRouterRateLimitError,
+)
+from minisweagent.models.utils.actions_text import format_observation_messages, parse_regex_actions
+
+logger = logging.getLogger("openrouter_textbased_model")
+
+
+class OpenRouterTextbasedModelConfig(OpenRouterModelConfig):
+    action_regex: str = r"```mswea_bash_command\s*\n(.*?)\n```"
+    """Regex to extract the action from the LM's output."""
+    format_error_template: str = (
+        "Please always provide EXACTLY ONE action in triple backticks, found {{actions|length}} actions."
+    )
+    """Template used when the LM's output is not in the expected format."""
+
+
+class OpenRouterTextbasedModel(OpenRouterModel):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.config = OpenRouterTextbasedModelConfig(**kwargs)
+
+    def _query(self, messages: list[dict[str, str]], **kwargs):
+        headers = {
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "model": self.config.model_name,
+            "messages": messages,
+            "usage": {"include": True},
+            **(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 OPENROUTER_API_KEY YOUR_KEY`."
+                raise OpenRouterAuthenticationError(error_msg) from e
+            elif response.status_code == 429:
+                raise OpenRouterRateLimitError("Rate limit exceeded") from e
+            else:
+                raise OpenRouterAPIError(f"HTTP {response.status_code}: {response.text}") from e
+        except requests.exceptions.RequestException as e:
+            raise OpenRouterAPIError(f"Request failed: {e}") from e
+
+    def _parse_actions(self, response: dict) -> list[dict]:
+        """Parse actions from the model response. Raises FormatError if not exactly one action."""
+        content = response["choices"][0]["message"]["content"] or ""
+        return parse_regex_actions(
+            content, action_regex=self.config.action_regex, format_error_template=self.config.format_error_template
+        )
+
+    def format_observation_messages(
+        self, message: dict, outputs: list[dict], template_vars: dict | None = None
+    ) -> list[dict]:
+        """Format execution outputs into observation messages."""
+        return format_observation_messages(
+            outputs,
+            observation_template=self.config.observation_template,
+            template_vars=template_vars,
+            multimodal_regex=self.config.multimodal_regex,
+        )

minisweagent/models/portkey_model.py

@@ -1,21 +1,23 @@
 import json
 import logging
 import os
-from dataclasses import asdict, dataclass, field
+import time
 from pathlib import Path
 from typing import Any, Literal
 
 import litellm
-from tenacity import (
-    before_sleep_log,
-    retry,
-    retry_if_not_exception_type,
-    stop_after_attempt,
-    wait_exponential,
-)
+from pydantic import BaseModel
 
 from minisweagent.models import GLOBAL_MODEL_STATS
+from minisweagent.models.utils.actions_toolcall import (
+    BASH_TOOL,
+    format_toolcall_observation_messages,
+    parse_toolcall_actions,
+)
+from minisweagent.models.utils.anthropic_utils import _reorder_anthropic_thinking_blocks
 from minisweagent.models.utils.cache_control import set_cache_control
+from minisweagent.models.utils.openai_multimodal import expand_multimodal_content
+from minisweagent.models.utils.retry import retry
 
 logger = logging.getLogger("portkey_model")
 
@@ -27,10 +29,14 @@ except ImportError:
     )
 
 
-@dataclass
-class PortkeyModelConfig:
+class PortkeyModelConfig(BaseModel):
     model_name: str
-    model_kwargs: dict[str, Any] = field(default_factory=dict)
+    model_kwargs: dict[str, Any] = {}
+    provider: str = ""
+    """The LLM provider to use (e.g., 'openai', 'anthropic', 'google').
+    If not specified, will be auto-detected from model_name.
+    Required by Portkey when not using a virtual key.
+    """
     litellm_model_registry: Path | str | None = os.getenv("LITELLM_MODEL_REGISTRY_PATH")
     """We currently use litellm to calculate costs. Here you can register additional models to litellm's model registry.
     Note that this might change if we get better support for Portkey and change how we calculate costs.
@@ -44,17 +50,25 @@ class PortkeyModelConfig:
     """Set explicit cache control markers, for example for Anthropic models"""
     cost_tracking: Literal["default", "ignore_errors"] = os.getenv("MSWEA_COST_TRACKING", "default")
     """Cost tracking mode for this model. Can be "default" or "ignore_errors" (ignore errors/missing cost info)"""
+    format_error_template: str = "{{ error }}"
+    """Template used when the LM's output is not in the expected format."""
+    observation_template: str = (
+        "{% if output.exception_info %}<exception>{{output.exception_info}}</exception>\n{% endif %}"
+        "<returncode>{{output.returncode}}</returncode>\n<output>\n{{output.output}}</output>"
+    )
+    """Template used to render the observation after executing an action."""
+    multimodal_regex: str = ""
+    """Regex to extract multimodal content. Empty string disables multimodal processing."""
 
 
 class PortkeyModel:
+    abort_exceptions: list[type[Exception]] = [KeyboardInterrupt, TypeError, ValueError]
+
     def __init__(self, *, config_class: type = PortkeyModelConfig, **kwargs):
         self.config = config_class(**kwargs)
-        self.cost = 0.0
-        self.n_calls = 0
         if self.config.litellm_model_registry and Path(self.config.litellm_model_registry).is_file():
             litellm.utils.register_model(json.loads(Path(self.config.litellm_model_registry).read_text()))
 
-        # Get API key from environment or raise error
         self._api_key = os.getenv("PORTKEY_API_KEY")
         if not self._api_key:
             raise ValueError(
@@ -63,51 +77,79 @@ class PortkeyModel:
                 "`mini-extra config set PORTKEY_API_KEY YOUR_KEY`."
             )
 
-        # Get virtual key from environment
         virtual_key = os.getenv("PORTKEY_VIRTUAL_KEY")
-
-        # Initialize Portkey client
         client_kwargs = {"api_key": self._api_key}
         if virtual_key:
             client_kwargs["virtual_key"] = virtual_key
+        elif self.config.provider:
+            # If no virtual key but provider is specified, pass it
+            client_kwargs["provider"] = self.config.provider
 
         self.client = Portkey(**client_kwargs)
 
-    @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):
-        # return self.client.with_options(metadata={"request_id": request_id}).chat.completions.create(
         return self.client.chat.completions.create(
             model=self.config.model_name,
             messages=messages,
+            tools=[BASH_TOOL],
             **(self.config.model_kwargs | kwargs),
         )
 
+    def _prepare_messages_for_api(self, messages: list[dict]) -> list[dict]:
+        prepared = [{k: v for k, v in msg.items() if k != "extra"} for msg in messages]
+        prepared = _reorder_anthropic_thinking_blocks(prepared)
+        return set_cache_control(prepared, mode=self.config.set_cache_control)
+
     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([{"role": msg["role"], "content": msg["content"]} for msg in messages], **kwargs)
-        cost = self._calculate_cost(response)
-        self.n_calls += 1
-        self.cost += cost
-        GLOBAL_MODEL_STATS.add(cost)
-        return {
-            "content": response.choices[0].message.content or "",
-            "extra": {
-                "response": response.model_dump(),
-                "cost": cost,
-            },
+        for attempt in retry(logger=logger, abort_exceptions=self.abort_exceptions):
+            with attempt:
+                response = self._query(self._prepare_messages_for_api(messages), **kwargs)
+        cost_output = self._calculate_cost(response)
+        GLOBAL_MODEL_STATS.add(cost_output["cost"])
+        message = response.choices[0].message.model_dump()
+        message["extra"] = {
+            "actions": self._parse_actions(response),
+            "response": response.model_dump(),
+            **cost_output,
+            "timestamp": time.time(),
         }
+        return message
+
+    def _parse_actions(self, response) -> list[dict]:
+        """Parse tool calls from the response. Raises FormatError if unknown tool."""
+        tool_calls = response.choices[0].message.tool_calls or []
+        return parse_toolcall_actions(tool_calls, format_error_template=self.config.format_error_template)
+
+    def format_message(self, **kwargs) -> dict:
+        return expand_multimodal_content(kwargs, pattern=self.config.multimodal_regex)
+
+    def format_observation_messages(
+        self, message: dict, outputs: list[dict], template_vars: dict | None = None
+    ) -> list[dict]:
+        """Format execution outputs into tool result messages."""
+        actions = message.get("extra", {}).get("actions", [])
+        return format_toolcall_observation_messages(
+            actions=actions,
+            outputs=outputs,
+            observation_template=self.config.observation_template,
+            template_vars=template_vars,
+            multimodal_regex=self.config.multimodal_regex,
+        )
 
-    def get_template_vars(self) -> dict[str, Any]:
-        return asdict(self.config) | {"n_model_calls": self.n_calls, "model_cost": self.cost}
+    def get_template_vars(self, **kwargs) -> dict[str, Any]:
+        return self.config.model_dump()
+
+    def serialize(self) -> dict:
+        return {
+            "info": {
+                "config": {
+                    "model": self.config.model_dump(mode="json"),
+                    "model_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                },
+            }
+        }
 
-    def _calculate_cost(self, response) -> float:
+    def _calculate_cost(self, response) -> dict[str, float]:
         response_for_cost_calc = response.model_copy()
         if self.config.litellm_model_name_override:
             if response_for_cost_calc.model:
@@ -152,4 +194,4 @@ class PortkeyModel:
                 )
                 logger.critical(msg)
                 raise RuntimeError(msg) from e
-        return cost
+        return {"cost": cost}