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

minisweagent/models/portkey_response_model.py

@@ -0,0 +1,163 @@
+import json
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Any, Literal
+
+import litellm
+from pydantic import BaseModel
+
+from minisweagent.models import GLOBAL_MODEL_STATS
+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("portkey_response_model")
+
+try:
+    from portkey_ai import Portkey
+except ImportError:
+    raise ImportError(
+        "The portkey-ai package is required to use PortkeyResponseAPIModel. Please install it with: pip install portkey-ai"
+    )
+
+
+class PortkeyResponseAPIModelConfig(BaseModel):
+    model_name: str
+    model_kwargs: dict[str, Any] = {}
+    litellm_model_registry: Path | str | None = os.getenv("LITELLM_MODEL_REGISTRY_PATH")
+    litellm_model_name_override: str = ""
+    cost_tracking: Literal["default", "ignore_errors"] = os.getenv("MSWEA_COST_TRACKING", "default")
+    format_error_template: str = "{{ error }}"
+    observation_template: str = (
+        "{% if output.exception_info %}<exception>{{output.exception_info}}</exception>\n{% endif %}"
+        "<returncode>{{output.returncode}}</returncode>\n<output>\n{{output.output}}</output>"
+    )
+    multimodal_regex: str = ""
+
+
+class PortkeyResponseAPIModel:
+    """Portkey model using the Responses API with native tool calling.
+
+    Note: This implementation is stateless - each request must include
+    the full conversation history. previous_response_id is not used.
+    """
+
+    abort_exceptions: list[type[Exception]] = [KeyboardInterrupt, TypeError, ValueError]
+
+    def __init__(self, **kwargs):
+        self.config = PortkeyResponseAPIModelConfig(**kwargs)
+        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()))
+
+        self._api_key = os.getenv("PORTKEY_API_KEY")
+        if not self._api_key:
+            raise ValueError(
+                "Portkey API key is required. Set it via the "
+                "PORTKEY_API_KEY environment variable. You can permanently set it with "
+                "`mini-extra config set PORTKEY_API_KEY YOUR_KEY`."
+            )
+
+        virtual_key = os.getenv("PORTKEY_VIRTUAL_KEY")
+        client_kwargs = {"api_key": self._api_key}
+        if virtual_key:
+            client_kwargs["virtual_key"] = virtual_key
+
+        self.client = Portkey(**client_kwargs)
+
+    def _query(self, messages: list[dict[str, str]], **kwargs):
+        return self.client.responses.create(
+            model=self.config.model_name,
+            input=messages,
+            tools=[BASH_TOOL_RESPONSE_API],
+            **(self.config.model_kwargs | kwargs),
+        )
+
+    def _prepare_messages_for_api(self, messages: list[dict]) -> list[dict]:
+        """Prepare messages for Portkey's stateless Responses API.
+
+        Flattens response objects into their output items.
+        """
+        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 = response.model_dump() if hasattr(response, "model_dump") else dict(response)
+        message["extra"] = {
+            "actions": self._parse_actions(response),
+            **cost_output,
+            "timestamp": time.time(),
+        }
+        return message
+
+    def _parse_actions(self, response) -> list[dict]:
+        """Parse tool calls from the response API response."""
+        output = response.output if hasattr(response, "output") else response.get("output", [])
+        return parse_toolcall_actions_response(output, format_error_template=self.config.format_error_template)
+
+    def _calculate_cost(self, response) -> dict[str, float]:
+        try:
+            cost = litellm.cost_calculator.completion_cost(
+                response, model=self.config.litellm_model_name_override or 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
+        return {"cost": cost}
+
+    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,
+        )
+
+    def get_template_vars(self, **kwargs) -> dict:
+        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__}",
+                },
+            }
+        }

minisweagent/models/requesty_model.py

@@ -1,27 +1,40 @@
 import json
 import logging
 import os
-from dataclasses import asdict, dataclass, field
-from typing import Any
+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("requesty_model")
 
 
-@dataclass
-class RequestyModelConfig:
+class RequestyModelConfig(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"""
+    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 RequestyAPIError(Exception):
@@ -43,25 +56,13 @@ class RequestyRateLimitError(Exception):
 
 
 class RequestyModel:
+    abort_exceptions: list[type[Exception]] = [RequestyAuthenticationError, KeyboardInterrupt]
+
     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(
-        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(
-            (
-                RequestyAuthenticationError,
-                KeyboardInterrupt,
-            )
-        ),
-    )
     def _query(self, messages: list[dict[str, str]], **kwargs):
         headers = {
             "Authorization": f"Bearer {self._api_key}",
@@ -73,6 +74,7 @@ class RequestyModel:
         payload = {
             "model": self.config.model_name,
             "messages": messages,
+            "tools": [BASH_TOOL],
             **(self.config.model_kwargs | kwargs),
         }
 
@@ -91,30 +93,78 @@ class RequestyModel:
         except requests.exceptions.RequestException as e:
             raise RequestyAPIError(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:
-        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
 
-        # Extract cost from usage information
+    def _calculate_cost(self, response) -> dict[str, float]:
         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 {"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/test_models.py

@@ -1,42 +1,269 @@
 import logging
 import time
-from dataclasses import asdict, dataclass
 from typing import Any
 
+from pydantic import BaseModel
+
 from minisweagent.models import GLOBAL_MODEL_STATS
+from minisweagent.models.utils.actions_text import format_observation_messages
+from minisweagent.models.utils.actions_toolcall import format_toolcall_observation_messages
+from minisweagent.models.utils.actions_toolcall_response import (
+    format_toolcall_observation_messages as format_response_api_observation_messages,
+)
+from minisweagent.models.utils.openai_multimodal import expand_multimodal_content
+
+
+def make_output(content: str, actions: list[dict], cost: float = 1.0) -> dict:
+    """Helper to create an output dict for DeterministicModel.
+
+    Args:
+        content: The response content string
+        actions: List of action dicts, e.g., [{"command": "echo hello"}]
+        cost: Cost to report for this output (default 1.0)
+    """
+    return {
+        "role": "assistant",
+        "content": content,
+        "extra": {"actions": actions, "cost": cost, "timestamp": time.time()},
+    }
+
+
+def make_toolcall_output(content: str | None, tool_calls: list[dict], actions: list[dict]) -> dict:
+    """Helper to create a toolcall output dict for DeterministicToolcallModel.
+
+    Args:
+        content: Optional text content (can be None for tool-only responses)
+        tool_calls: List of tool call dicts in OpenAI format
+        actions: List of parsed action dicts, e.g., [{"command": "echo hello", "tool_call_id": "call_123"}]
+    """
+    return {
+        "role": "assistant",
+        "content": content,
+        "tool_calls": tool_calls,
+        "extra": {"actions": actions, "cost": 1.0, "timestamp": time.time()},
+    }
 
 
-@dataclass
-class DeterministicModelConfig:
-    outputs: list[str]
+def make_response_api_output(content: str | None, actions: list[dict]) -> dict:
+    """Helper to create an output dict for DeterministicResponseAPIToolcallModel.
+
+    Args:
+        content: Optional text content (can be None for tool-only responses)
+        actions: List of action dicts with 'command' and 'tool_call_id' keys
+    """
+    output_items = []
+    if content:
+        output_items.append(
+            {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": content}]}
+        )
+    for action in actions:
+        output_items.append(
+            {
+                "type": "function_call",
+                "call_id": action["tool_call_id"],
+                "name": "bash",
+                "arguments": f'{{"command": "{action["command"]}"}}',
+            }
+        )
+    return {
+        "object": "response",
+        "output": output_items,
+        "extra": {"actions": actions, "cost": 1.0, "timestamp": time.time()},
+    }
+
+
+def _process_test_actions(actions: list[dict]) -> bool:
+    """Process special test actions. Returns True if the query should be retried."""
+    for action in actions:
+        if "raise" in action:
+            raise action["raise"]
+        cmd = action.get("command", "")
+        if cmd.startswith("/sleep "):
+            time.sleep(float(cmd.split("/sleep ")[1]))
+            return True
+        if cmd.startswith("/warning"):
+            logging.warning(cmd.split("/warning")[1])
+            return True
+    return False
+
+
+class DeterministicModelConfig(BaseModel):
+    outputs: list[dict]
+    """List of exact output messages to return in sequence. Each dict should have 'role', 'content', and 'extra' (with 'actions')."""
     model_name: str = "deterministic"
     cost_per_call: float = 1.0
+    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 DeterministicModel:
     def __init__(self, **kwargs):
-        """
-        Initialize with a list of outputs to return in sequence.
-        """
+        """Initialize with a list of output messages 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]))
+        if _process_test_actions(output.get("extra", {}).get("actions", [])):
             return self.query(messages, **kwargs)
-        if "/warning" in output:
-            logging.warning(output.split("/warning")[1])
+        GLOBAL_MODEL_STATS.add(self.config.cost_per_call)
+        return output
+
+    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 observation messages."""
+        return format_observation_messages(
+            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 {
+            "info": {
+                "config": {
+                    "model": self.config.model_dump(mode="json"),
+                    "model_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                },
+            }
+        }
+
+
+class DeterministicToolcallModelConfig(BaseModel):
+    outputs: list[dict]
+    """List of exact output messages with tool_calls to return in sequence."""
+    model_name: str = "deterministic_toolcall"
+    cost_per_call: float = 1.0
+    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 DeterministicToolcallModel:
+    def __init__(self, **kwargs):
+        """Initialize with a list of toolcall output messages to return in sequence."""
+        self.config = DeterministicToolcallModelConfig(**kwargs)
+        self.current_index = -1
+
+    def query(self, messages: list[dict[str, str]], **kwargs) -> dict:
+        self.current_index += 1
+        output = self.config.outputs[self.current_index]
+        if _process_test_actions(output.get("extra", {}).get("actions", [])):
+            return self.query(messages, **kwargs)
+        GLOBAL_MODEL_STATS.add(self.config.cost_per_call)
+        return output
+
+    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 {
+            "info": {
+                "config": {
+                    "model": self.config.model_dump(mode="json"),
+                    "model_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                },
+            }
+        }
+
+
+class DeterministicResponseAPIToolcallModelConfig(BaseModel):
+    outputs: list[dict]
+    """List of exact Response API output messages to return in sequence."""
+    model_name: str = "deterministic_response_api_toolcall"
+    cost_per_call: float = 1.0
+    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 DeterministicResponseAPIToolcallModel:
+    """Deterministic test model using OpenAI Responses API format."""
+
+    def __init__(self, **kwargs):
+        """Initialize with a list of Response API output messages to return in sequence."""
+        self.config = DeterministicResponseAPIToolcallModelConfig(**kwargs)
+        self.current_index = -1
+
+    def query(self, messages: list[dict[str, str]], **kwargs) -> dict:
+        self.current_index += 1
+        output = self.config.outputs[self.current_index]
+        if _process_test_actions(output.get("extra", {}).get("actions", [])):
             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}
+        return output
+
+    def format_message(self, **kwargs) -> dict:
+        """Format message in Responses API format."""
+        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: dict = {"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 function_call_output messages."""
+        actions = message.get("extra", {}).get("actions", [])
+        return format_response_api_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 get_template_vars(self) -> dict[str, Any]:
-        return asdict(self.config) | {"n_model_calls": self.n_calls, "model_cost": self.cost}
+    def serialize(self) -> dict:
+        return {
+            "info": {
+                "config": {
+                    "model": self.config.model_dump(mode="json"),
+                    "model_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                },
+            }
+        }