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

minisweagent/models/utils/actions_text.py

@@ -0,0 +1,60 @@
+"""Parse actions & format observations without toolcalls.
+This was the method used for mini-swe-agent v1.0 and the original SWE-agent.
+As of mini-swe-agent v2.0, we strongly recommend to use toolcalls instead.
+"""
+
+import re
+import time
+
+from jinja2 import StrictUndefined, Template
+
+from minisweagent.exceptions import FormatError
+from minisweagent.models.utils.openai_multimodal import expand_multimodal_content
+
+
+def parse_regex_actions(content: str, *, action_regex: str, format_error_template: str) -> list[dict]:
+    """Parse actions from text content using regex. Raises FormatError if not exactly one action."""
+    actions = [a.strip() for a in re.findall(action_regex, content, re.DOTALL)]
+    if len(actions) != 1:
+        raise FormatError(
+            {
+                "role": "user",
+                "content": Template(format_error_template, undefined=StrictUndefined).render(actions=actions),
+                "extra": {
+                    "interrupt_type": "FormatError",
+                    "n_actions": len(actions),
+                    "model_response": content,
+                },
+            }
+        )
+    return [{"command": action} for action in actions]
+
+
+def format_observation_messages(
+    outputs: list[dict],
+    *,
+    observation_template: str,
+    template_vars: dict | None = None,
+    multimodal_regex: str = "",
+) -> list[dict]:
+    """Format execution outputs into user observation messages."""
+    results = []
+    for output in outputs:
+        content = Template(observation_template, undefined=StrictUndefined).render(
+            output=output, **(template_vars or {})
+        )
+        msg: dict = {
+            "role": "user",
+            "content": content,
+            "extra": {
+                "raw_output": output.get("output", ""),
+                "returncode": output.get("returncode"),
+                "timestamp": time.time(),
+                "exception_info": output.get("exception_info"),
+                **output.get("extra", {}),
+            },
+        }
+        if multimodal_regex:
+            msg = expand_multimodal_content(msg, pattern=multimodal_regex)
+        results.append(msg)
+    return results

minisweagent/models/utils/actions_toolcall.py

@@ -0,0 +1,102 @@
+"""Parse actions & format observations with toolcalls"""
+
+import json
+import time
+
+from jinja2 import StrictUndefined, Template
+
+from minisweagent.exceptions import FormatError
+from minisweagent.models.utils.openai_multimodal import expand_multimodal_content
+
+BASH_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "bash",
+        "description": "Execute a bash command",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "The bash command to execute",
+                }
+            },
+            "required": ["command"],
+        },
+    },
+}
+
+
+def parse_toolcall_actions(tool_calls: list, *, format_error_template: str) -> list[dict]:
+    """Parse tool calls from the response. Raises FormatError if unknown tool or invalid args."""
+    if not tool_calls:
+        raise FormatError(
+            {
+                "role": "user",
+                "content": Template(format_error_template, undefined=StrictUndefined).render(
+                    error="No tool calls found in the response. Every response MUST include at least one tool call."
+                ),
+                "extra": {"interrupt_type": "FormatError"},
+            }
+        )
+    actions = []
+    for tool_call in tool_calls:
+        error_msg = ""
+        args = {}
+        try:
+            args = json.loads(tool_call.function.arguments)
+        except Exception as e:
+            error_msg = f"Error parsing tool call arguments: {e}. "
+        if tool_call.function.name != "bash":
+            error_msg += f"Unknown tool '{tool_call.function.name}'."
+        if "command" not in args:
+            error_msg += "Missing 'command' argument in bash tool call."
+        if error_msg:
+            raise FormatError(
+                {
+                    "role": "user",
+                    "content": Template(format_error_template, undefined=StrictUndefined).render(
+                        error=error_msg.strip()
+                    ),
+                    "extra": {"interrupt_type": "FormatError"},
+                }
+            )
+        actions.append({"command": args["command"], "tool_call_id": tool_call.id})
+    return actions
+
+
+def format_toolcall_observation_messages(
+    *,
+    actions: list[dict],
+    outputs: list[dict],
+    observation_template: str,
+    template_vars: dict | None = None,
+    multimodal_regex: str = "",
+) -> list[dict]:
+    """Format execution outputs into tool result messages."""
+    not_executed = {"output": "", "returncode": -1, "exception_info": "action was not executed"}
+    padded_outputs = outputs + [not_executed] * (len(actions) - len(outputs))
+    results = []
+    for action, output in zip(actions, padded_outputs):
+        content = Template(observation_template, undefined=StrictUndefined).render(
+            output=output, **(template_vars or {})
+        )
+        msg = {
+            "content": content,
+            "extra": {
+                "raw_output": output.get("output", ""),
+                "returncode": output.get("returncode"),
+                "timestamp": time.time(),
+                "exception_info": output.get("exception_info"),
+                **output.get("extra", {}),
+            },
+        }
+        if "tool_call_id" in action:
+            msg["tool_call_id"] = action["tool_call_id"]
+            msg["role"] = "tool"
+        else:
+            msg["role"] = "user"  # human issued commands
+        if multimodal_regex:
+            msg = expand_multimodal_content(msg, pattern=multimodal_regex)
+        results.append(msg)
+    return results

minisweagent/models/utils/actions_toolcall_response.py

@@ -0,0 +1,110 @@
+"""Parse actions & format observations for OpenAI Responses API toolcalls"""
+
+import json
+import time
+
+from jinja2 import StrictUndefined, Template
+
+from minisweagent.exceptions import FormatError
+
+# OpenRouter/OpenAI Responses API uses a flat structure (no nested "function" key)
+BASH_TOOL_RESPONSE_API = {
+    "type": "function",
+    "name": "bash",
+    "description": "Execute a bash command",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "command": {
+                "type": "string",
+                "description": "The bash command to execute",
+            }
+        },
+        "required": ["command"],
+    },
+}
+
+
+def _format_error_message(error_text: str) -> dict:
+    """Create a FormatError message in Responses API format."""
+    return {
+        "type": "message",
+        "role": "user",
+        "content": [{"type": "input_text", "text": error_text}],
+        "extra": {"interrupt_type": "FormatError"},
+    }
+
+
+def parse_toolcall_actions_response(output: list, *, format_error_template: str) -> list[dict]:
+    """Parse tool calls from a Responses API response output.
+
+    Filters for function_call items and parses them.
+    Response API format has name/arguments at top level with call_id:
+    {"type": "function_call", "call_id": "...", "name": "bash", "arguments": "..."}
+    """
+    tool_calls = []
+    for item in output:
+        item_type = item.get("type") if isinstance(item, dict) else getattr(item, "type", None)
+        if item_type == "function_call":
+            tool_calls.append(
+                item.model_dump() if hasattr(item, "model_dump") else dict(item) if not isinstance(item, dict) else item
+            )
+    if not tool_calls:
+        error_text = Template(format_error_template, undefined=StrictUndefined).render(
+            error="No tool calls found in the response. Every response MUST include at least one tool call.",
+        )
+        raise FormatError(_format_error_message(error_text))
+    actions = []
+    for tool_call in tool_calls:
+        error_msg = ""
+        args = {}
+        try:
+            args = json.loads(tool_call.get("arguments", "{}"))
+        except Exception as e:
+            error_msg = f"Error parsing tool call arguments: {e}. "
+        if tool_call.get("name") != "bash":
+            error_msg += f"Unknown tool '{tool_call.get('name')}'."
+        if "command" not in args:
+            error_msg += "Missing 'command' argument in bash tool call."
+        if error_msg:
+            error_text = Template(format_error_template, undefined=StrictUndefined).render(error=error_msg.strip())
+            raise FormatError(_format_error_message(error_text))
+        actions.append({"command": args["command"], "tool_call_id": tool_call.get("call_id") or tool_call.get("id")})
+    return actions
+
+
+def format_toolcall_observation_messages(
+    *,
+    actions: list[dict],
+    outputs: list[dict],
+    observation_template: str,
+    template_vars: dict | None = None,
+    multimodal_regex: str = "",
+) -> list[dict]:
+    """Format execution outputs into function_call_output messages for Responses API."""
+    not_executed = {"output": "", "returncode": -1, "exception_info": "action was not executed"}
+    padded_outputs = outputs + [not_executed] * (len(actions) - len(outputs))
+    results = []
+    for action, output in zip(actions, padded_outputs):
+        content = Template(observation_template, undefined=StrictUndefined).render(
+            output=output, **(template_vars or {})
+        )
+        msg: dict = {
+            "extra": {
+                "raw_output": output.get("output", ""),
+                "returncode": output.get("returncode"),
+                "timestamp": time.time(),
+                "exception_info": output.get("exception_info"),
+                **output.get("extra", {}),
+            },
+        }
+        if "tool_call_id" in action:
+            msg["type"] = "function_call_output"
+            msg["call_id"] = action["tool_call_id"]
+            msg["output"] = content
+        else:  # human issued commands
+            msg["type"] = "message"
+            msg["role"] = "user"
+            msg["content"] = [{"type": "input_text", "text": content}]
+        results.append(msg)
+    return results

minisweagent/models/utils/anthropic_utils.py

@@ -0,0 +1,28 @@
+"""Utilities for Anthropic API compatibility."""
+
+
+def _is_anthropic_thinking_block(block) -> bool:
+    """Check if a content block is a thinking-type block."""
+    if not isinstance(block, dict):
+        return False
+    return block.get("type") in ("thinking", "redacted_thinking")
+
+
+def _reorder_anthropic_thinking_blocks(messages: list[dict]) -> list[dict]:
+    """Reorder thinking blocks so they are not the final block in assistant messages.
+
+    This is an Anthropic API requirement: thinking blocks must come before other blocks.
+    """
+    result = []
+    for msg in messages:
+        if msg.get("role") == "assistant" and isinstance(msg.get("content"), list):
+            content = msg["content"]
+            thinking_blocks = [b for b in content if _is_anthropic_thinking_block(b)]
+            if thinking_blocks:
+                other_blocks = [b for b in content if not _is_anthropic_thinking_block(b)]
+                if other_blocks:
+                    msg = {**msg, "content": thinking_blocks + other_blocks}
+                else:
+                    msg = {**msg, "content": thinking_blocks + [{"type": "text", "text": ""}]}
+        result.append(msg)
+    return result

minisweagent/models/utils/cache_control.py

@@ -1,9 +1,15 @@
+"""Cache control utilities are mostly for Anthropic models.
+They are used to explicitly set cache control points.
+"""
+
 import copy
 import warnings
 from typing import Literal
 
 
-def _get_content_text(entry: dict) -> str:
+def _get_content_text(entry: dict) -> str | None:
+    if entry["content"] is None:
+        return None
     if isinstance(entry["content"], str):
         return entry["content"]
     assert len(entry["content"]) == 1, "Expected single message in content"
@@ -14,10 +20,16 @@ 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)
+    # Note: entry["content"] can be None for assistant messages with only tool_use
     entry.pop("cache_control", None)
 
 
 def _set_cache_control(entry: dict) -> None:
+    # Handle None content (e.g., assistant messages with only tool_use)
+    if entry["content"] is None:
+        entry["cache_control"] = {"type": "ephemeral"}
+        return
+
     if not isinstance(entry["content"], list):
         entry["content"] = [  # type: ignore
             {
@@ -38,7 +50,8 @@ 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 is None:
+        return messages
     if mode != "default_end":
         raise ValueError(f"Invalid mode: {mode}")
     if last_n_messages_offset:

minisweagent/models/utils/content_string.py

@@ -0,0 +1,74 @@
+"""Helper function for pretty-printing content strings."""
+
+import json
+
+
+def _format_tool_call(args_str: str) -> str:
+    """Format tool call arguments, extracting command if it's a bash call."""
+    try:
+        args = json.loads(args_str) if isinstance(args_str, str) else args_str
+        if isinstance(args, dict) and "command" in args:
+            return f"```\n{args['command']}\n```"
+    except Exception:
+        pass
+    return f"```\n{args_str}\n```"
+
+
+def _format_observation(content: str) -> str | None:
+    """Try to format an observation JSON as key-value pairs."""
+    try:
+        data = json.loads(content)
+        if isinstance(data, dict) and "returncode" in data:
+            lines = []
+            for key, value in data.items():
+                lines.append(f"<{key}>")
+                lines.append(str(value))
+            return "\n".join(lines)
+        return content
+    except Exception:
+        return content
+
+
+def get_content_string(message: dict) -> str:
+    """Extract text content from any message format for display.
+
+    Handles:
+    - Traditional chat: {"content": "text"}
+    - Multimodal chat: {"content": [{"type": "text", "text": "..."}]}
+    - Observation messages: {"content": "{\"returncode\": 0, \"output\": \"...\"}"}
+    - Traditional tool calls: {"tool_calls": [{"function": {"name": "...", "arguments": "..."}}]}
+    - Responses API: {"output": [{"type": "message", "content": [...]}]}
+    """
+    texts = []
+
+    # Extract content (string or multimodal list)
+    content = message.get("content")
+    if isinstance(content, str):
+        texts.append(_format_observation(content))
+    elif isinstance(content, list):
+        texts.append("\n".join(item.get("text", "") for item in content if isinstance(item, dict)))
+
+    # Handle traditional tool_calls format (OpenAI/LiteLLM style)
+    if tool_calls := message.get("tool_calls"):
+        for tc in tool_calls:
+            func = tc.get("function", {}) if isinstance(tc, dict) else getattr(tc, "function", None)
+            if func:
+                args = func.get("arguments", "{}") if isinstance(func, dict) else getattr(func, "arguments", "{}")
+                texts.append(_format_tool_call(args))
+
+    # Handle Responses API format (output array)
+    if output := message.get("output"):
+        if isinstance(output, str):
+            texts.append(_format_observation(output))
+        elif isinstance(output, list):
+            for item in output:
+                if not isinstance(item, dict):
+                    continue
+                if item.get("type") == "message":
+                    for c in item.get("content", []):
+                        if isinstance(c, dict) and (text := c.get("text")):
+                            texts.append(text)
+                elif item.get("type") == "function_call":
+                    texts.append(_format_tool_call(item.get("arguments", "{}")))
+
+    return "\n\n".join(t for t in texts if t)

minisweagent/models/utils/openai_multimodal.py

@@ -0,0 +1,50 @@
+"""Utilities for handling multimodal content in OpenAI-style messages."""
+
+import copy
+import re
+from typing import Any
+
+DEFAULT_MULTIMODAL_REGEX = (
+    r"(?s)<MSWEA_MULTIMODAL_CONTENT><CONTENT_TYPE>(.+?)</CONTENT_TYPE>(.+?)</MSWEA_MULTIMODAL_CONTENT>"
+)
+
+
+def _expand_content_string(*, content: str, pattern: str) -> list[dict]:
+    """Expand a content string, replacing multimodal tags with structured content."""
+    matches = list(re.finditer(pattern, content))
+    if not matches:
+        return [{"type": "text", "text": content}]
+    result = []
+    last_end = 0
+    for match in matches:
+        text_before = content[last_end : match.start()]
+        if text_before:
+            result.append({"type": "text", "text": text_before})
+        content_type = match.group(1).strip()
+        extracted = match.group(2).strip()
+        if content_type == "image_url":
+            result.append({"type": "image_url", "image_url": {"url": extracted}})
+        last_end = match.end()
+    text_after = content[last_end:]
+    if text_after:
+        result.append({"type": "text", "text": text_after})
+    return result
+
+
+def expand_multimodal_content(content: Any, *, pattern: str) -> Any:
+    """Recursively expand multimodal content in messages.
+    Note: Returns copy of content, original content is not modified.
+    """
+    if not pattern:
+        return content
+    content = copy.deepcopy(content)
+    if isinstance(content, str):
+        return _expand_content_string(content=content, pattern=pattern)
+    if isinstance(content, list):
+        return [expand_multimodal_content(item, pattern=pattern) for item in content]
+    if isinstance(content, dict):
+        if "content" not in content:
+            return content
+        content["content"] = expand_multimodal_content(content["content"], pattern=pattern)
+        return content
+    return str(content)

minisweagent/models/utils/retry.py

@@ -0,0 +1,25 @@
+"""Retry utility for model queries."""
+
+import logging
+import os
+
+from tenacity import Retrying, before_sleep_log, retry_if_not_exception_type, stop_after_attempt, wait_exponential
+
+
+def retry(*, logger: logging.Logger, abort_exceptions: list[type[Exception]]) -> Retrying:
+    """Thin wrapper around tenacity.Retrying to make use of global config etc.
+
+    Args:
+        logger: Logger to use for reporting retries
+        abort_exceptions: Exceptions to abort on.
+
+    Returns:
+        A tenacity.Retrying object.
+    """
+    return Retrying(
+        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(tuple(abort_exceptions)),
+    )

minisweagent/run/benchmarks/__init__.py

@@ -0,0 +1 @@
+"""Benchmark run scripts for mini-SWE-agent (e.g., SWE-bench)."""