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

minisweagent/environments/local.py

@@ -1,14 +1,17 @@
 import os
 import platform
 import subprocess
-from dataclasses import asdict, dataclass, field
 from typing import Any
 
+from pydantic import BaseModel
 
-@dataclass
-class LocalEnvironmentConfig:
+from minisweagent.exceptions import Submitted
+from minisweagent.utils.serialize import recursive_merge
+
+
+class LocalEnvironmentConfig(BaseModel):
     cwd: str = ""
-    env: dict[str, str] = field(default_factory=dict)
+    env: dict[str, str] = {}
     timeout: int = 30
 
 
@@ -17,22 +20,60 @@ class LocalEnvironment:
         """This class executes bash commands directly on the local machine."""
         self.config = config_class(**kwargs)
 
-    def execute(self, command: str, cwd: str = "", *, timeout: int | None = None):
+    def execute(self, action: dict, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
         """Execute a command in the local environment and return the result as a dict."""
+        command = action.get("command", "")
         cwd = cwd or self.config.cwd or os.getcwd()
-        result = subprocess.run(
-            command,
-            shell=True,
-            text=True,
-            cwd=cwd,
-            env=os.environ | self.config.env,
-            timeout=timeout or self.config.timeout,
-            encoding="utf-8",
-            errors="replace",
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-        )
-        return {"output": result.stdout, "returncode": result.returncode}
-
-    def get_template_vars(self) -> dict[str, Any]:
-        return asdict(self.config) | platform.uname()._asdict() | os.environ
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                text=True,
+                cwd=cwd,
+                env=os.environ | self.config.env,
+                timeout=timeout or self.config.timeout,
+                encoding="utf-8",
+                errors="replace",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+            )
+            output = {"output": result.stdout, "returncode": result.returncode, "exception_info": ""}
+        except Exception as e:
+            raw_output = getattr(e, "output", None)
+            raw_output = (
+                raw_output.decode("utf-8", errors="replace") if isinstance(raw_output, bytes) else (raw_output or "")
+            )
+            output = {
+                "output": raw_output,
+                "returncode": -1,
+                "exception_info": f"An error occurred while executing the command: {e}",
+                "extra": {"exception_type": type(e).__name__, "exception": str(e)},
+            }
+        self._check_finished(output)
+        return output
+
+    def _check_finished(self, output: dict):
+        """Raises Submitted if the output indicates task completion."""
+        lines = output.get("output", "").lstrip().splitlines(keepends=True)
+        if lines and lines[0].strip() == "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT" and output["returncode"] == 0:
+            submission = "".join(lines[1:])
+            raise Submitted(
+                {
+                    "role": "exit",
+                    "content": submission,
+                    "extra": {"exit_status": "Submitted", "submission": submission},
+                }
+            )
+
+    def get_template_vars(self, **kwargs) -> dict[str, Any]:
+        return recursive_merge(self.config.model_dump(), platform.uname()._asdict(), os.environ, kwargs)
+
+    def serialize(self) -> dict:
+        return {
+            "info": {
+                "config": {
+                    "environment": self.config.model_dump(mode="json"),
+                    "environment_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                }
+            }
+        }

minisweagent/environments/singularity.py

@@ -6,18 +6,21 @@ import shutil
 import subprocess
 import tempfile
 import uuid
-from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any
 
+from pydantic import BaseModel
 
-@dataclass
-class SingularityEnvironmentConfig:
+from minisweagent.exceptions import Submitted
+from minisweagent.utils.serialize import recursive_merge
+
+
+class SingularityEnvironmentConfig(BaseModel):
     image: str
     cwd: str = "/"
-    env: dict[str, str] = field(default_factory=dict)
+    env: dict[str, str] = {}
     """Environment variables to set in the container."""
-    forward_env: list[str] = field(default_factory=list)
+    forward_env: list[str] = []
     """Environment variables to forward to the container."""
     timeout: int = 30
     """Timeout for executing commands in the container."""
@@ -57,11 +60,22 @@ class SingularityEnvironment:
                     raise
         return sandbox_dir
 
-    def get_template_vars(self) -> dict[str, Any]:
-        return asdict(self.config)
+    def get_template_vars(self, **kwargs) -> dict[str, Any]:
+        return recursive_merge(self.config.model_dump(), kwargs)
 
-    def execute(self, command: str, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
+    def serialize(self) -> dict:
+        return {
+            "info": {
+                "config": {
+                    "environment": self.config.model_dump(mode="json"),
+                    "environment_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                }
+            }
+        }
+
+    def execute(self, action: dict, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
         """Execute a command in a Singularity container and return the result as a dict."""
+        command = action.get("command", "")
         cmd = [self.config.executable, "exec"]
 
         # Do not inherit directories and env vars from host
@@ -78,16 +92,43 @@ class SingularityEnvironment:
             cmd.extend(["--env", f"{key}={value}"])
 
         cmd.extend(["--writable", str(self.sandbox_dir), "bash", "-c", command])
-        result = subprocess.run(
-            cmd,
-            text=True,
-            timeout=timeout or self.config.timeout,
-            encoding="utf-8",
-            errors="replace",
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-        )
-        return {"output": result.stdout, "returncode": result.returncode}
+        try:
+            result = subprocess.run(
+                cmd,
+                text=True,
+                timeout=timeout or self.config.timeout,
+                encoding="utf-8",
+                errors="replace",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+            )
+            output = {"output": result.stdout, "returncode": result.returncode, "exception_info": ""}
+        except Exception as e:
+            raw_output = getattr(e, "output", None)
+            raw_output = (
+                raw_output.decode("utf-8", errors="replace") if isinstance(raw_output, bytes) else (raw_output or "")
+            )
+            output = {
+                "output": raw_output,
+                "returncode": -1,
+                "exception_info": f"An error occurred while executing the command: {e}",
+                "extra": {"exception_type": type(e).__name__, "exception": str(e)},
+            }
+        self._check_finished(output)
+        return output
+
+    def _check_finished(self, output: dict):
+        """Raises Submitted if the output indicates task completion."""
+        lines = output.get("output", "").lstrip().splitlines(keepends=True)
+        if lines and lines[0].strip() == "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT" and output["returncode"] == 0:
+            submission = "".join(lines[1:])
+            raise Submitted(
+                {
+                    "role": "exit",
+                    "content": submission,
+                    "extra": {"exit_status": "Submitted", "submission": submission},
+                }
+            )
 
     def cleanup(self):
         shutil.rmtree(self.sandbox_dir, ignore_errors=True)

minisweagent/exceptions.py

@@ -0,0 +1,22 @@
+class InterruptAgentFlow(Exception):
+    """Raised to interrupt the agent flow and add messages."""
+
+    def __init__(self, *messages: dict):
+        self.messages = messages
+        super().__init__()
+
+
+class Submitted(InterruptAgentFlow):
+    """Raised when the agent has completed its task."""
+
+
+class LimitsExceeded(InterruptAgentFlow):
+    """Raised when the agent has exceeded its cost or step limit."""
+
+
+class UserInterruption(InterruptAgentFlow):
+    """Raised when the user interrupts the agent."""
+
+
+class FormatError(InterruptAgentFlow):
+    """Raised when the LM's output is not in the expected format."""

minisweagent/models/__init__.py

@@ -28,7 +28,7 @@ class GlobalModelStats:
             self._cost += cost
             self._n_calls += 1
         if 0 < self.cost_limit < self._cost or 0 < self.call_limit < self._n_calls + 1:
-            raise RuntimeError(f"Global cost/call limit exceeded: ${self._cost:.4f} / {self._n_calls + 1}")
+            raise RuntimeError(f"Global cost/call limit exceeded: ${self._cost:.4f} / {self._n_calls}")
 
     @property
     def cost(self) -> float:
@@ -52,9 +52,6 @@ def get_model(input_model_name: str | None = None, config: dict | None = None) -
 
     model_class = get_model_class(resolved_model_name, config.pop("model_class", ""))
 
-    if (from_env := os.getenv("MSWEA_MODEL_API_KEY")) and not str(type(model_class)).endswith("DeterministicModel"):
-        config.setdefault("model_kwargs", {})["api_key"] = from_env
-
     if (
         any(s in resolved_model_name.lower() for s in ["anthropic", "sonnet", "opus", "claude"])
         and "set_cache_control" not in config
@@ -79,12 +76,14 @@ def get_model_name(input_model_name: str | None = None, config: dict | None = No
 
 
 _MODEL_CLASS_MAPPING = {
-    "anthropic": "minisweagent.models.anthropic.AnthropicModel",
     "litellm": "minisweagent.models.litellm_model.LitellmModel",
-    "litellm_response": "minisweagent.models.litellm_response_api_model.LitellmResponseAPIModel",
+    "litellm_textbased": "minisweagent.models.litellm_textbased_model.LitellmTextbasedModel",
+    "litellm_response": "minisweagent.models.litellm_response_model.LitellmResponseModel",
     "openrouter": "minisweagent.models.openrouter_model.OpenRouterModel",
+    "openrouter_textbased": "minisweagent.models.openrouter_textbased_model.OpenRouterTextbasedModel",
+    "openrouter_response": "minisweagent.models.openrouter_response_model.OpenRouterResponseModel",
     "portkey": "minisweagent.models.portkey_model.PortkeyModel",
-    "portkey_response": "minisweagent.models.portkey_response_api_model.PortkeyResponseAPIModel",
+    "portkey_response": "minisweagent.models.portkey_response_model.PortkeyResponseAPIModel",
     "requesty": "minisweagent.models.requesty_model.RequestyModel",
     "deterministic": "minisweagent.models.test_models.DeterministicModel",
 }

minisweagent/models/extra/roulette.py

@@ -1,12 +1,12 @@
 import random
-from dataclasses import asdict, dataclass
+
+from pydantic import BaseModel
 
 from minisweagent import Model
 from minisweagent.models import get_model
 
 
-@dataclass
-class RouletteModelConfig:
+class RouletteModelConfig(BaseModel):
     model_kwargs: list[dict]
     """The models to choose from"""
     model_name: str = "roulette"
@@ -17,30 +17,33 @@ class RouletteModel:
         """This "meta"-model randomly selects one of the models at every call"""
         self.config = config_class(**kwargs)
         self.models = [get_model(config=config) for config in self.config.model_kwargs]
+        self._n_calls = 0
 
-    @property
-    def cost(self) -> float:
-        return sum(model.cost for model in self.models)
-
-    @property
-    def n_calls(self) -> int:
-        return sum(model.n_calls for model in self.models)
-
-    def get_template_vars(self) -> dict:
-        return asdict(self.config) | {"n_model_calls": self.n_calls, "model_cost": self.cost}
+    def get_template_vars(self, **kwargs) -> dict:
+        return self.config.model_dump()
 
     def select_model(self) -> Model:
         return random.choice(self.models)
 
     def query(self, *args, **kwargs) -> dict:
         model = self.select_model()
+        self._n_calls += 1
         response = model.query(*args, **kwargs)
         response["model_name"] = model.config.model_name
         return response
 
+    def serialize(self) -> dict:
+        return {
+            "info": {
+                "config": {
+                    "model": self.config.model_dump(mode="json"),
+                    "model_type": f"{self.__class__.__module__}.{self.__class__.__name__}",
+                },
+            }
+        }
+
 
-@dataclass
-class InterleavingModelConfig:
+class InterleavingModelConfig(BaseModel):
     model_kwargs: list[dict]
     sequence: list[int] | None = None
     """If set to 0, 0, 1, we will return the first model 2 times, then the second model 1 time,
@@ -55,7 +58,7 @@ class InterleavingModel(RouletteModel):
 
     def select_model(self) -> Model:
         if self.config.sequence is None:
-            i_model = self.n_calls % len(self.models)
+            i_model = self._n_calls % len(self.models)
         else:
-            i_model = self.config.sequence[self.n_calls % len(self.config.sequence)]
+            i_model = self.config.sequence[self._n_calls % len(self.config.sequence)]
         return self.models[i_model]

minisweagent/models/litellm_model.py

@@ -1,75 +1,98 @@
 import json
 import logging
 import os
+import time
 from collections.abc import Callable
-from dataclasses import asdict, dataclass, field
 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("litellm_model")
 
 
-@dataclass
-class LitellmModelConfig:
+class LitellmModelConfig(BaseModel):
     model_name: str
-    model_kwargs: dict[str, Any] = field(default_factory=dict)
+    """Model name. Highly recommended to include the provider in the model name, e.g., `anthropic/claude-sonnet-4-5-20250929`."""
+    model_kwargs: dict[str, Any] = {}
+    """Additional arguments passed to the API."""
     litellm_model_registry: Path | str | None = os.getenv("LITELLM_MODEL_REGISTRY_PATH")
+    """Model registry for cost tracking and model metadata. See the local model guide (https://mini-swe-agent.com/latest/models/local_models/) for more details."""
     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 LitellmModel:
+    abort_exceptions: list[type[Exception]] = [
+        litellm.exceptions.UnsupportedParamsError,
+        litellm.exceptions.NotFoundError,
+        litellm.exceptions.PermissionDeniedError,
+        litellm.exceptions.ContextWindowExceededError,
+        litellm.exceptions.AuthenticationError,
+        KeyboardInterrupt,
+    ]
+
     def __init__(self, *, config_class: Callable = LitellmModelConfig, **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()))
 
-    @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(
-            (
-                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:
             return litellm.completion(
-                model=self.config.model_name, messages=messages, **(self.config.model_kwargs | kwargs)
+                model=self.config.model_name,
+                messages=messages,
+                tools=[BASH_TOOL],
+                **(self.config.model_kwargs | kwargs),
             )
         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 _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 = 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 _calculate_cost(self, response) -> dict[str, float]:
         try:
             cost = litellm.cost_calculator.completion_cost(response, model=self.config.model_name)
             if cost <= 0.0:
@@ -87,15 +110,38 @@ class LitellmModel:
                 )
                 logger.critical(msg)
                 raise RuntimeError(msg) from e
-        self.n_calls += 1
-        self.cost += cost
-        GLOBAL_MODEL_STATS.add(cost)
+        return {"cost": cost}
+
+    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, **kwargs) -> dict[str, Any]:
+        return self.config.model_dump()
+
+    def serialize(self) -> dict:
         return {
-            "content": response.choices[0].message.content or "",  # type: ignore
-            "extra": {
-                "response": response.model_dump(),
-            },
+            "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}

minisweagent/models/litellm_response_model.py

@@ -0,0 +1,80 @@
+import logging
+import time
+from collections.abc import Callable
+
+import litellm
+
+from minisweagent.models import GLOBAL_MODEL_STATS
+from minisweagent.models.litellm_model import LitellmModel, LitellmModelConfig
+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("litellm_response_model")
+
+
+class LitellmResponseModelConfig(LitellmModelConfig):
+    pass
+
+
+class LitellmResponseModel(LitellmModel):
+    def __init__(self, *, config_class: Callable = LitellmResponseModelConfig, **kwargs):
+        super().__init__(config_class=config_class, **kwargs)
+
+    def _prepare_messages_for_api(self, messages: list[dict]) -> list[dict]:
+        """Flatten response objects into their output items for stateless API calls."""
+        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):
+        try:
+            return litellm.responses(
+                model=self.config.model_name,
+                input=messages,
+                tools=[BASH_TOOL_RESPONSE_API],
+                **(self.config.model_kwargs | kwargs),
+            )
+        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:
+        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]:
+        return parse_toolcall_actions_response(
+            getattr(response, "output", []), 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 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/litellm_textbased_model.py

@@ -0,0 +1,45 @@
+import litellm
+
+from minisweagent.models.litellm_model import LitellmModel, LitellmModelConfig
+from minisweagent.models.utils.actions_text import format_observation_messages, parse_regex_actions
+
+
+class LitellmTextbasedModelConfig(LitellmModelConfig):
+    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 LitellmTextbasedModel(LitellmModel):
+    def __init__(self, **kwargs):
+        super().__init__(config_class=LitellmTextbasedModelConfig, **kwargs)
+
+    def _query(self, messages: list[dict[str, str]], **kwargs):
+        try:
+            return litellm.completion(
+                model=self.config.model_name, messages=messages, **(self.config.model_kwargs | kwargs)
+            )
+        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 _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,
+        )