mini-swe-agent 1.9.1__py3-none-any.whl → 1.11.0__py3-none-any.whl

{mini_swe_agent-1.9.1.dist-info → mini_swe_agent-1.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-swe-agent
-Version: 1.9.1
+Version: 1.11.0
 Summary: Nano SWE Agent - A simple AI software engineering agent
 Author-email: Kilian Lieret <kilian.lieret@posteo.de>, "Carlos E. Jimenez" <carlosej@princeton.edu>
 License: MIT License
@@ -48,7 +48,7 @@ Requires-Dist: typer
 Requires-Dist: platformdirs
 Requires-Dist: textual
 Requires-Dist: prompt_toolkit
-Requires-Dist: openai<=1.99.5
+Requires-Dist: openai!=1.100.0,!=1.100.1
 Provides-Extra: full
 Requires-Dist: mini-swe-agent[dev]; extra == "full"
 Requires-Dist: swe-rex>=1.4.0; extra == "full"
@@ -73,7 +73,7 @@ Dynamic: license-file
 
 # The 100 line AI agent that solves GitHub issues & more
 
-📣 [Run `mini` with GPT-5 and friends: Read here](https://mini-swe-agent.com/latest/quickstart/#gpt-5)
+📣 [New blogpost: Randomly switching between GPT-5 and Sonnet 4 boosts performance](https://www.swebench.com/SWE-bench/blog/2025/08/19/mini-roulette/)
 
 [![Docs](https://img.shields.io/badge/Docs-green?style=for-the-badge&logo=materialformkdocs&logoColor=white)](https://mini-swe-agent.com/latest/)
 [![Slack](https://img.shields.io/badge/Slack-4A154B?style=for-the-badge&logo=slack&logoColor=white)](https://join.slack.com/t/swe-bench/shared_invite/zt-36pj9bu5s-o3_yXPZbaH2wVnxnss1EkQ)

{mini_swe_agent-1.9.1.dist-info → mini_swe_agent-1.11.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-mini_swe_agent-1.9.1.dist-info/licenses/LICENSE.md,sha256=D3luWPkdHAe7LBsdD4vzqDAXw6Xewb3G-uczss0uh1s,1094
-minisweagent/__init__.py,sha256=28OQ0MKY6EvqfdiNiDiiP-a1aGELpGBdUjRR5rsc3-Y,1997
+mini_swe_agent-1.11.0.dist-info/licenses/LICENSE.md,sha256=D3luWPkdHAe7LBsdD4vzqDAXw6Xewb3G-uczss0uh1s,1094
+minisweagent/__init__.py,sha256=km0yBZPAHXfBk30MPY1oRyjdgOZAG_G9Kv6xwpE6Tt4,2014
 minisweagent/__main__.py,sha256=FIyAOiw--c3FQ2g240FOM1FdL0lk_PxSpixu0pQ7WFo,194
 minisweagent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 minisweagent/agents/__init__.py,sha256=cpjJLzg1IGxLM-tZpoMJV9S33ye13XtdBO0x7DU_Lrk,48
-minisweagent/agents/default.py,sha256=znoeQPSnSLNvrvVC07kwgEb-rqi0yxf3Kv7JPeMDNsI,5624
+minisweagent/agents/default.py,sha256=sxvACv-Yn3A-KQD9-Q-apHiU1gwkyX_-GPOikFVyuOI,5690
 minisweagent/agents/interactive.py,sha256=NBeNamRuqww9ZRhOg1q8xPO9ziUw2gpAVV6hCPbpBxU,7470
-minisweagent/agents/interactive_textual.py,sha256=rvD1zoEQSjWd1MklCRGT01cCFoMh46iFrDPBklAWW_A,17984
+minisweagent/agents/interactive_textual.py,sha256=9RAJ-gUVVNL2qEq_HT2UcwJJorrSlp6WYoRwOgoCngI,18054
 minisweagent/config/README.md,sha256=ABd9anA4aRWtx7Oh37z36Wv6ARvcxD2w9lPUE24R2mY,435
 minisweagent/config/__init__.py,sha256=0KzHaaIqWgRy2zbwIzhrg6BJPDzOvYi3jb4eBNY4sAU,823
 minisweagent/config/default.yaml,sha256=OHK9-7PkCa9ZzgYykF1zGYC_AWkiAdOrEpDuurF-1Rk,5143
@@ -14,38 +14,43 @@ minisweagent/config/mini.tcss,sha256=fmAP9cYAp2n7Ps2Dw3e-ZOGEF2E8JcwTgK1LDcis-x4
 minisweagent/config/mini.yaml,sha256=mDfN7KputHf7kOGidJFX5-5CDKg97vxxu2cdYYlPoM8,5159
 minisweagent/config/mini_no_temp.yaml,sha256=n0W-017tBmMx57U9SLt7Fy9WJxI9x2vdTWBWeSngGMc,5204
 minisweagent/config/extra/__init__.py,sha256=e1MoAlDn_wc9HnXNoncf1P-B4DQ-iRf6n7Q_txjZGRI,52
-minisweagent/config/extra/swebench.yaml,sha256=5FKblpcNTHmVUNE1JLHo5_AsupvlwsrLj8I3R2mRItk,7680
-minisweagent/environments/__init__.py,sha256=tTnNjNAhMvIuB1mlesreBV5TLdQBp79qj_Mxr7HGzNk,1180
-minisweagent/environments/docker.py,sha256=tL0XL2kIxNGLswcmPTDklpoa3RGkQJr7HkEEE2rxzNQ,4049
+minisweagent/config/extra/swebench.yaml,sha256=2LzqIM60eYqZZhB0U1q9e6fBiL1MvHvSUF63xI5U6kE,7738
+minisweagent/config/extra/swebench_roulette.yaml,sha256=in235myH4BCJ8fyGtXuTlv16Ky3JTytV4H9-wvd-iTM,7801
+minisweagent/environments/__init__.py,sha256=x80Ulx0UK21GAwg5jSTkOFeiZ7CQsGBP8cI_5BhazAo,1266
+minisweagent/environments/docker.py,sha256=NJhdpYINEZC20URto2ZCkTCj44PEGqUn_sIWYvrA8XA,4281
 minisweagent/environments/local.py,sha256=dV05j4jPrmY0k5O_UtF_qrRqqdilyPUUkbn-YUhRC3M,1236
-minisweagent/environments/singularity.py,sha256=dHH_SS4MOm3cP7k1kSErvIjVijTL_-VFTOHtCyjUKVw,2671
+minisweagent/environments/singularity.py,sha256=o7R_3aXbODsA_DPx0aH13eZhLU7yhMUtxGyRKybfVr4,3633
 minisweagent/environments/extra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+minisweagent/environments/extra/bubblewrap.py,sha256=So8MY3qprylkVhM78XUt05U3sAXVpxK47042eKWYxhA,3620
 minisweagent/environments/extra/swerex_docker.py,sha256=wu2F_9moa8yj5IgCEquFOoxEXJ8Vi6BF19rJvRdoJIs,1665
-minisweagent/models/__init__.py,sha256=wZguR-mGijqlxovIYfs1WcCiaHyYPywml0AacBJtg5c,2890
+minisweagent/models/__init__.py,sha256=Boq3-r9eo4ptqnADMxAwtfevq9TmmE75mxSK5rS4ij0,4016
 minisweagent/models/anthropic.py,sha256=D8nHvvbgzPjla0He8p0O9kaXASPWg1Sai0pHsAj_Yn8,855
-minisweagent/models/litellm_model.py,sha256=tEwAV2dzslJ4HFDXApXSPo5OWsiz8soy52P8-r9p4Xg,2538
+minisweagent/models/litellm_model.py,sha256=h6VHpiomiLo5Xi9fOxk818KjgAefMCumZdno-tIWtXo,2993
+minisweagent/models/openrouter_model.py,sha256=85ccv7IFZnlU8F5nm9CfwEFi8M2baMgIOzb90i352zU,3729
 minisweagent/models/test_models.py,sha256=ItCA6ddntzkYA7dzSuUEaLMV-AE8TBuXBFP8CzpiO3U,1351
+minisweagent/models/extra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+minisweagent/models/extra/roulette.py,sha256=SqLj_wz9Vkbxou7i9Ef4Uzmg_eheDouNySkkV7pm2Ys,2093
 minisweagent/models/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 minisweagent/models/utils/cache_control.py,sha256=mG9cE56HQaUwXfoqvXoH6LcbMV_G1vlEE1aBBpikXYg,1608
 minisweagent/models/utils/key_per_thread.py,sha256=Vlxt--rapNNYCgIHrMCu1WVAkuiVIhC_awbarkbnkZQ,644
 minisweagent/run/__init__.py,sha256=WIoYgHVl7iZF2YncrfV3IttupG6P5KogroKHKECka3A,38
-minisweagent/run/github_issue.py,sha256=GWOkGM09jOYV93p6xIM_kKWmC1yP_d5lprafWlqoBN0,2748
+minisweagent/run/github_issue.py,sha256=LS4_7LktE0pitcFZJyBJADF74xZMBDgovUa4KwU9RN0,3073
 minisweagent/run/hello_world.py,sha256=erLnEwNmPFLxq3-8zyv66Vy1kIqMqQf97vISX7LrQXg,959
 minisweagent/run/inspector.py,sha256=QnY3oYzm-yq3w9Jzs112Lco2Rg84vSocAWrQRVz_1lc,7127
-minisweagent/run/mini.py,sha256=09WKk4ERzhQ_hoSg0kNUYGtCRjLqMrLOSUqQtxjVwlo,4459
+minisweagent/run/mini.py,sha256=EMU-hXAaTsgbdtTmZRxPYZ2bjYRTD6NQDr5Eta5Ybe8,4814
 minisweagent/run/mini_extra.py,sha256=ecA1PnTWElpO60G9RktvVLtUOf3bZ_ESmnSttS6izhQ,1465
 minisweagent/run/extra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-minisweagent/run/extra/config.py,sha256=CEsEr8AdEm64Jods2ZRURChHKMILSatkBLkLmRywkrw,3672
-minisweagent/run/extra/swebench.py,sha256=3zGn7PUZCCf5vcVYy6vsIgjdJHUVh8cr-ztJwTsUWUo,10826
-minisweagent/run/extra/swebench_single.py,sha256=RGfs0FPD_3cznR5Y-J90CopYCC0_Vg9NYusRB1wKllc,3309
+minisweagent/run/extra/config.py,sha256=L5Xe7VGX1HMBlPac9aBufPnHA9duJpZYrbqXVtr8O6w,3845
+minisweagent/run/extra/swebench.py,sha256=sheaYoTxFmw5NdRGiRHPd_epVHRdhYtfIgI-RMvTSQc,11650
+minisweagent/run/extra/swebench_single.py,sha256=BwalUCgQTDlg4WOFmhPmW8K0wzbNoktTdGWzPoAiryE,3607
 minisweagent/run/extra/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 minisweagent/run/extra/utils/batch_progress.py,sha256=xhJ7FmsaTBGz-yh8pzYl4yMoUGjn7GA24eYrP-nHj60,6804
 minisweagent/run/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-minisweagent/run/utils/save.py,sha256=MzIvUyCiqbq3EaQc8cKtaD0MEkcyXmUyl4ZcxYzZW_Y,1680
+minisweagent/run/utils/save.py,sha256=2xd-UnUzI7Fr_AUZ5KEJ53Aa4kpuuGYxkLwyUcvqyMM,2503
 minisweagent/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 minisweagent/utils/log.py,sha256=ruDMNKMrVC9NPvCeHwO3QYz5jsVNUGQB2dRAEAPAWp8,996
-mini_swe_agent-1.9.1.dist-info/METADATA,sha256=iJsC920Z-2YoGsdpRgwk1wwKvq9SWi9qcTHSQjqPetc,13828
-mini_swe_agent-1.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mini_swe_agent-1.9.1.dist-info/entry_points.txt,sha256=d1_yRbTaGjs1UXHa6JQK0sKDGBIVGm8oeW0k2kfbJgQ,182
-mini_swe_agent-1.9.1.dist-info/top_level.txt,sha256=zKF4t8bFpV87fdVABZt2Da-vnb4Vkh_CxkwQx5YT4Ew,13
-mini_swe_agent-1.9.1.dist-info/RECORD,,
+mini_swe_agent-1.11.0.dist-info/METADATA,sha256=FAhb6b9hKIxgQTFMAd1Vjy5uKbYi9Zn1oyKUsWfymuw,13888
+mini_swe_agent-1.11.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mini_swe_agent-1.11.0.dist-info/entry_points.txt,sha256=d1_yRbTaGjs1UXHa6JQK0sKDGBIVGm8oeW0k2kfbJgQ,182
+mini_swe_agent-1.11.0.dist-info/top_level.txt,sha256=zKF4t8bFpV87fdVABZt2Da-vnb4Vkh_CxkwQx5YT4Ew,13
+mini_swe_agent-1.11.0.dist-info/RECORD,,

minisweagent/__init__.py

@@ -8,7 +8,7 @@ This file provides:
   unless you want the static type checking.
 """
 
-__version__ = "1.9.1"
+__version__ = "1.11.0"
 
 import os
 from pathlib import Path
@@ -66,6 +66,7 @@ class Agent(Protocol):
     model: Model
     env: Environment
     messages: list[dict[str, str]]
+    config: Any
 
     def run(self, task: str, **kwargs) -> tuple[str, str]: ...
 

minisweagent/agents/default.py

@@ -5,7 +5,7 @@ import subprocess
 from collections.abc import Callable
 from dataclasses import asdict, dataclass
 
-from jinja2 import Template
+from jinja2 import StrictUndefined, Template
 
 from minisweagent import Environment, Model
 
@@ -63,7 +63,9 @@ class DefaultAgent:
 
     def render_template(self, template: str, **kwargs) -> str:
         template_vars = asdict(self.config) | self.env.get_template_vars() | self.model.get_template_vars()
-        return Template(template).render(**kwargs, **template_vars, **self.extra_template_vars)
+        return Template(template, undefined=StrictUndefined).render(
+            **kwargs, **template_vars, **self.extra_template_vars
+        )
 
     def add_message(self, role: str, content: str, **kwargs):
         self.messages.append({"role": role, "content": content, **kwargs})

minisweagent/agents/interactive_textual.py

@@ -283,6 +283,10 @@ class TextualAgent(App):
 
     # --- Basics ---
 
+    @property
+    def config(self):
+        return self.agent.config
+
     @property
     def i_step(self) -> int:
         """Current step index."""

minisweagent/config/extra/swebench.yaml

@@ -36,7 +36,7 @@ agent:
     2. Provide exactly ONE bash command to execute
 
     ## Important Boundaries
-    - MODIFY: Regular source code files in {{working_dir}}
+    - MODIFY: Regular source code files in /testbed (this is the working directory for all your subsequent commands)
     - DO NOT MODIFY: Tests, configuration files (pyproject.toml, setup.cfg, etc.)
 
     ## Recommended Workflow

minisweagent/config/extra/swebench_roulette.yaml

@@ -0,0 +1,233 @@
+agent:
+  system_template: |
+    You are a helpful assistant that can interact multiple times with a computer shell to solve programming tasks.
+    Your response must contain exactly ONE bash code block with ONE command (or commands connected with && or ||).
+
+    Include a THOUGHT section before your command where you explain your reasoning process.
+    Format your response as shown in <format_example>.
+
+    <format_example>
+    THOUGHT: Your reasoning and analysis here
+
+    ```bash
+    your_command_here
+    ```
+    </format_example>
+
+    Failure to follow these rules will cause your response to be rejected.
+  instance_template: |
+    <pr_description>
+    Consider the following PR description:
+    {{task}}
+    </pr_description>
+
+    <instructions>
+    # Task Instructions
+
+    ## Overview
+    You're a software engineer interacting continuously with a computer by submitting commands.
+    You'll be helping implement necessary changes to meet requirements in the PR description.
+    Your task is specifically to make changes to non-test files in the current directory in order to fix the issue described in the PR description in a way that is general and consistent with the codebase.
+
+    IMPORTANT: This is an interactive process where you will think and issue ONE command, see its result, then think and issue your next command.
+
+    For each response:
+    1. Include a THOUGHT section explaining your reasoning and what you're trying to accomplish
+    2. Provide exactly ONE bash command to execute
+
+    ## Important Boundaries
+    - MODIFY: Regular source code files in {{working_dir}}
+    - DO NOT MODIFY: Tests, configuration files (pyproject.toml, setup.cfg, etc.)
+
+    ## Recommended Workflow
+    1. Analyze the codebase by finding and reading relevant files
+    2. Create a script to reproduce the issue
+    3. Edit the source code to resolve the issue
+    4. Verify your fix works by running your script again
+    5. Test edge cases to ensure your fix is robust
+
+    ## Command Execution Rules
+    You are operating in an environment where
+    1. You write a single command
+    2. The system executes that command in a subshell
+    3. You see the result
+    4. You write your next command
+
+    Each response should include:
+    1. A **THOUGHT** section where you explain your reasoning and plan
+    2. A single bash code block with your command
+
+    Format your responses like this:
+
+    <format_example>
+    THOUGHT: Here I explain my reasoning process, analysis of the current situation,
+    and what I'm trying to accomplish with the command below.
+
+    ```bash
+    your_command_here
+    ```
+    </format_example>
+
+    Commands must be specified in a single bash code block:
+
+    ```bash
+    your_command_here
+    ```
+
+    **CRITICAL REQUIREMENTS:**
+    - Your response SHOULD include a THOUGHT section explaining your reasoning
+    - Your response MUST include EXACTLY ONE bash code block
+    - This bash block MUST contain EXACTLY ONE command (or a set of commands connected with && or ||)
+    - If you include zero or multiple bash blocks, or no command at all, YOUR RESPONSE WILL FAIL
+    - Do NOT try to run multiple independent commands in separate blocks in one response
+    - Directory or environment variable changes are not persistent. Every action is executed in a new subshell.
+    - However, you can prefix any action with `MY_ENV_VAR=MY_VALUE cd /path/to/working/dir && ...` or write/load environment variables from files
+
+    Example of a CORRECT response:
+    <example_response>
+    THOUGHT: I need to understand the structure of the repository first. Let me check what files are in the current directory to get a better understanding of the codebase.
+
+    ```bash
+    ls -la
+    ```
+    </example_response>
+
+    Example of an INCORRECT response:
+    <example_response>
+    THOUGHT: I need to examine the codebase and then look at a specific file. I'll run multiple commands to do this.
+
+    ```bash
+    ls -la
+    ```
+
+    Now I'll read the file:
+
+    ```bash
+    cat file.txt
+    ```
+    </example_response>
+
+    If you need to run multiple commands, either:
+    1. Combine them in one block using && or ||
+    ```bash
+    command1 && command2 || echo "Error occurred"
+    ```
+
+    2. Wait for the first command to complete, see its output, then issue the next command in your following response.
+
+    ## Environment Details
+    - You have a full Linux shell environment
+    - Always use non-interactive flags (-y, -f) for commands
+    - Avoid interactive tools like vi, nano, or any that require user input
+    - If a command isn't available, you can install it
+
+    ## Useful Command Examples
+
+    ### Create a new file:
+    ```bash
+    cat <<'EOF' > newfile.py
+    import numpy as np
+    hello = "world"
+    print(hello)
+    EOF
+    ```
+
+    ### Edit files with sed:
+    ```bash
+    # Replace all occurrences
+    sed -i 's/old_string/new_string/g' filename.py
+
+    # Replace only first occurrence
+    sed -i 's/old_string/new_string/' filename.py
+
+    # Replace first occurrence on line 1
+    sed -i '1s/old_string/new_string/' filename.py
+
+    # Replace all occurrences in lines 1-10
+    sed -i '1,10s/old_string/new_string/g' filename.py
+    ```
+
+    ### View file content:
+    ```bash
+    # View specific lines with numbers
+    nl -ba filename.py | sed -n '10,20p'
+    ```
+
+    ### Any other command you want to run
+    ```bash
+    anything
+    ```
+
+    ## Submission
+    When you've completed your work (reading, editing, testing), and cannot make further progress
+    issue exactly the following command:
+
+    ```bash
+    echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT && git add -A && git diff --cached
+    ```
+
+    This command will submit your work.
+    You cannot continue working (reading, editing, testing) in any way on this task after submitting.
+    </instructions>
+  action_observation_template: |
+    <returncode>{{output.returncode}}</returncode>
+    {% if output.output | length < 10000 -%}
+    <output>
+    {{ output.output -}}
+    </output>
+    {%- else -%}
+    <warning>
+    The output of your last command was too long.
+    Please try a different command that produces less output.
+    If you're looking at a file you can try use head, tail or sed to view a smaller number of lines selectively.
+    If you're using grep or find and it produced too much output, you can use a more selective search pattern.
+    If you really need to see something from the full command's output, you can redirect output to a file and then search in that file.
+    </warning>
+    {%- set elided_chars = output.output | length - 10000 -%}
+    <output_head>
+    {{ output.output[:5000] }}
+    </output_head>
+    <elided_chars>
+    {{ elided_chars }} characters elided
+    </elided_chars>
+    <output_tail>
+    {{ output.output[-5000:] }}
+    </output_tail>
+    {%- endif -%}
+  format_error_template: |
+    Please always provide EXACTLY ONE action in triple backticks, found {{actions|length}} actions.
+
+    Please format your action in triple backticks as shown in <response_example>.
+
+    <response_example>
+    Here are some thoughts about why you want to perform the action.
+
+    ```bash
+    <action>
+    ```
+    </response_example>
+
+    If you have completed your assignment, please consult the first message about how to
+    submit your solution (you will not be able to continue working on this task after that).
+  step_limit: 250
+  cost_limit: 3.
+
+environment:
+  cwd: "/testbed"
+  timeout: 60
+  env:
+    PAGER: cat
+    MANPAGER: cat
+    LESS: -R
+    PIP_PROGRESS_BAR: 'off'
+    TQDM_DISABLE: '1'
+  environment_class: docker
+
+model:
+  model_name: "roulette"
+  model_class: "minisweagent.models.extra.roulette.RouletteModel"
+  model_kwargs:
+    - model_name: "claude-sonnet-4-20250514"
+      model_kwargs:
+        temperature: 0.
+    - model_name: "gpt-5"

minisweagent/environments/__init__.py

@@ -10,6 +10,7 @@ _ENVIRONMENT_MAPPING = {
     "singularity": "minisweagent.environments.singularity.SingularityEnvironment",
     "local": "minisweagent.environments.local.LocalEnvironment",
     "swerex_docker": "minisweagent.environments.extra.swerex_docker.SwerexDockerEnvironment",
+    "bubblewrap": "minisweagent.environments.extra.bubblewrap.BubblewrapEnvironment",
 }
 
 

minisweagent/environments/docker.py

@@ -23,18 +23,22 @@ class DockerEnvironmentConfig:
     """Timeout for executing commands in the container."""
     executable: str = os.getenv("MSWEA_DOCKER_EXECUTABLE", "docker")
     """Path to the docker/container executable."""
-    run_args: list[str] = field(default_factory=list)
-    """Additional arguments to pass to the docker/container executable."""
+    run_args: list[str] = field(default_factory=lambda: ["--rm"])
+    """Additional arguments to pass to the docker/container executable.
+    Default is ["--rm"], which removes the container after it exits.
+    """
     container_timeout: str = "2h"
     """Max duration to keep container running. Uses the same format as the sleep command."""
+    pull_timeout: int = 120
+    """Timeout in seconds for pulling images."""
 
 
 class DockerEnvironment:
-    def __init__(self, *, config_class: type = DockerEnvironmentConfig, **kwargs):
+    def __init__(self, *, config_class: type = DockerEnvironmentConfig, logger: logging.Logger | None = None, **kwargs):
         """This class executes bash commands in a Docker container using direct docker commands.
         See `DockerEnvironmentConfig` for keyword arguments.
         """
-        self.logger = logging.getLogger("minisweagent.environment")
+        self.logger = logger or logging.getLogger("minisweagent.environment")
         self.container_id: str | None = None
         self.config = config_class(**kwargs)
         self._start_container()
@@ -63,7 +67,7 @@ class DockerEnvironment:
             cmd,
             capture_output=True,
             text=True,
-            timeout=120,  # docker pull might take a while
+            timeout=self.config.pull_timeout,  # docker pull might take a while
             check=True,
         )
         self.logger.info(f"Started container {container_name} with ID {result.stdout.strip()}")

minisweagent/environments/extra/bubblewrap.py

@@ -0,0 +1,112 @@
+"""
+[Bubblewrap](https://github.com/containers/bubblewrap) is a low-level, unprivileged sandboxing tool for Linux that enables running applications
+in isolated environments with restricted access to the operating system and user data.
+This environment uses bubblewrap to execute commands in a sandboxed environment.
+
+!!! warning
+    This environment is experimental.
+
+!!! warning
+    This environment is not supported on Windows.
+"""
+
+import logging
+import os
+import platform
+import shutil
+import subprocess
+import tempfile
+import uuid
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class BubblewrapEnvironmentConfig:
+    cwd: str = ""
+    """Working directory for the sandbox."""
+    env: dict[str, str] = field(default_factory=dict)
+    """Dictionary of environment variables to set in the sandbox."""
+    timeout: int = 30
+    """Timeout for the command in seconds."""
+    executable: str = os.getenv("MSWEA_BUBBLEWRAP_EXECUTABLE", "bwrap")
+    """Path to the bubblewrap executable."""
+    wrapper_args: list[str] = field(
+        default_factory=lambda: [
+            "--unshare-user-try",
+            "--ro-bind",
+            "/usr",
+            "/usr",
+            "--ro-bind",
+            "/bin",
+            "/bin",
+            "--ro-bind",
+            "/lib",
+            "/lib",
+            "--ro-bind",
+            "/lib64",
+            "/lib64",
+            "--ro-bind",
+            "/etc",
+            "/etc",
+            "--tmpfs",
+            "/tmp",
+            "--proc",
+            "/proc",
+            "--dev",
+            "/dev",
+            "--new-session",
+            "--setenv",
+            "PATH",
+            "/usr/local/bin:/usr/sbin:/usr/bin:/bin",
+        ]
+    )
+    """Arguments to pass to the bubblewrap executable."""
+
+
+class BubblewrapEnvironment:
+    def __init__(
+        self, *, config_class: type = BubblewrapEnvironmentConfig, logger: logging.Logger | None = None, **kwargs
+    ):
+        """This class executes bash commands in a bubblewrap environment and a separate working
+        directory for each environment. See `BubblewrapEnvironmentConfig` for kwargs.
+        """
+        self.logger = logger or logging.getLogger("minisweagent.environment")
+        self.config = config_class(**kwargs)
+        self.working_dir = Path(tempfile.gettempdir()) / f"minisweagent-{uuid.uuid4().hex[:8]}"
+        self.working_dir.mkdir(parents=True)
+
+    def execute(self, command: str, cwd: str = "") -> dict[str, Any]:
+        """Execute a command in the bubblewrap environment and return the result as a dict."""
+        cwd = cwd or self.config.cwd or str(self.working_dir)
+
+        cmd = [self.config.executable] + self.config.wrapper_args + ["--bind", cwd, cwd, "--chdir", cwd]
+
+        # Add environment variables
+        for key, value in self.config.env.items():
+            cmd.extend(["--setenv", key, value])
+
+        cmd.extend(["bash", "-c", command])
+
+        result = subprocess.run(
+            cmd,
+            text=True,
+            timeout=self.config.timeout,
+            encoding="utf-8",
+            errors="replace",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        )
+        return {"output": result.stdout, "returncode": result.returncode}
+
+    def cleanup(self):
+        if self.working_dir.exists():
+            shutil.rmtree(self.working_dir)
+
+    def __del__(self):
+        """Cleanup working_dir when object is destroyed."""
+        self.cleanup()
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config) | platform.uname()._asdict()

minisweagent/environments/singularity.py

@@ -23,18 +23,39 @@ class SingularityEnvironmentConfig:
     """Timeout for executing commands in the container."""
     executable: str = os.getenv("MSWEA_SINGULARITY_EXECUTABLE", "singularity")
     """Path to the singularity executable."""
+    sandbox_build_retries: int = 3
+    """Number of retries for building the sandbox if an error occurs."""
 
 
 class SingularityEnvironment:
-    def __init__(self, **kwargs):
+    def __init__(
+        self, *, config_class: type = SingularityEnvironmentConfig, logger: logging.Logger | None = None, **kwargs
+    ):
         """Singularity environment. See `SingularityEnvironmentConfig` for kwargs."""
-        self.logger = logging.getLogger("minisweagent.environment")
-        self.config = SingularityEnvironmentConfig(**kwargs)
-        self.sandbox_dir = Path(tempfile.gettempdir()) / f"minisweagent-{uuid.uuid4().hex[:8]}"
-        subprocess.run(
-            [self.config.executable, "build", "--sandbox", self.sandbox_dir, self.config.image],
-            check=True,
-        )
+        self.logger = logger or logging.getLogger("minisweagent.environment")
+        self.config = config_class(**kwargs)
+        self.sandbox_dir = self._build_sandbox()
+
+    def _build_sandbox(self) -> Path:
+        # Building the sandbox can fail (very rarely), so we retry it
+        max_retries = self.config.sandbox_build_retries
+        for attempt in range(max_retries):
+            sandbox_dir = Path(tempfile.gettempdir()) / f"minisweagent-{uuid.uuid4().hex[:8]}"
+            try:
+                subprocess.run(
+                    [self.config.executable, "build", "--sandbox", sandbox_dir, self.config.image],
+                    check=True,
+                    capture_output=True,
+                )
+                break
+            except subprocess.CalledProcessError as e:
+                shutil.rmtree(sandbox_dir, ignore_errors=True)
+                self.logger.error(
+                    f"Error building image {self.config.image}, stdout: {e.stdout}, stderr: {e.stderr} (attempt {attempt + 1}/{max_retries})"
+                )
+                if attempt == max_retries - 1:
+                    raise
+        return sandbox_dir
 
     def get_template_vars(self) -> dict[str, Any]:
         return asdict(self.config)
@@ -69,8 +90,7 @@ class SingularityEnvironment:
         return {"output": result.stdout, "returncode": result.returncode}
 
     def cleanup(self):
-        if self.sandbox_dir.exists():
-            shutil.rmtree(self.sandbox_dir)
+        shutil.rmtree(self.sandbox_dir, ignore_errors=True)
 
     def __del__(self):
         """Cleanup sandbox when object is destroyed."""

minisweagent/models/__init__.py

@@ -3,6 +3,7 @@ You can ignore this file completely if you explicitly set your model in your run
 """
 
 import copy
+import importlib
 import os
 import threading
 
@@ -49,12 +50,12 @@ def get_model(input_model_name: str | None = None, config: dict | None = None) -
     config = copy.deepcopy(config)
     config["model_name"] = resolved_model_name
 
-    # API key resolution (from env -> config -> None)
-    if "model_kwargs" not in config:
-        config["model_kwargs"] = {}
-    if from_env := os.getenv("MSWEA_MODEL_API_KEY"):
-        config["model_kwargs"]["api_key"] = from_env
-    return get_model_class(resolved_model_name)(**config)
+    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
+
+    return model_class(**config)
 
 
 def get_model_name(input_model_name: str | None = None, config: dict | None = None) -> str:
@@ -70,12 +71,38 @@ def get_model_name(input_model_name: str | None = None, config: dict | None = No
     raise ValueError("No default model set. Please run `mini-extra config setup` to set one.")
 
 
-def get_model_class(model_name: str) -> type:
-    """Select the best model class for a given model name."""
+_MODEL_CLASS_MAPPING = {
+    "anthropic": "minisweagent.models.anthropic.AnthropicModel",
+    "litellm": "minisweagent.models.litellm_model.LitellmModel",
+    "openrouter": "minisweagent.models.openrouter_model.OpenRouterModel",
+    "deterministic": "minisweagent.models.test_models.DeterministicModel",
+}
+
+
+def get_model_class(model_name: str, model_class: str = "") -> type:
+    """Select the best model class.
+
+    If a model_class is provided (as shortcut name, or as full import path,
+    e.g., "anthropic" or "minisweagent.models.anthropic.AnthropicModel"),
+    it takes precedence over the `model_name`.
+    Otherwise, the model_name is used to select the best model class.
+    """
+    if model_class:
+        full_path = _MODEL_CLASS_MAPPING.get(model_class, model_class)
+        try:
+            module_name, class_name = full_path.rsplit(".", 1)
+            module = importlib.import_module(module_name)
+            return getattr(module, class_name)
+        except (ValueError, ImportError, AttributeError):
+            msg = f"Unknown model class: {model_class} (resolved to {full_path}, available: {_MODEL_CLASS_MAPPING})"
+            raise ValueError(msg)
+
     if any(s in model_name.lower() for s in ["anthropic", "sonnet", "opus", "claude"]):
         from minisweagent.models.anthropic import AnthropicModel
 
         return AnthropicModel
+
+    # Default to LitellmModel
     from minisweagent.models.litellm_model import LitellmModel
 
     return LitellmModel

minisweagent/models/extra/roulette.py

@@ -0,0 +1,62 @@
+import random
+from collections.abc import Callable
+from dataclasses import asdict, dataclass
+
+from minisweagent import Model
+from minisweagent.models import get_model
+
+
+@dataclass
+class RouletteModelConfig:
+    model_kwargs: list[dict]
+    """The models to choose from"""
+    model_name: str = "roulette"
+
+
+class RouletteModel:
+    def __init__(self, *, config_class: Callable = RouletteModelConfig, **kwargs):
+        """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]
+
+    @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 select_model(self) -> Model:
+        return random.choice(self.models)
+
+    def query(self, *args, **kwargs) -> dict:
+        model = self.select_model()
+        response = model.query(*args, **kwargs)
+        response["model_name"] = model.config.model_name
+        return response
+
+
+@dataclass
+class InterleavingModelConfig:
+    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,
+    then the first model again, etc."""
+    model_name: str = "interleaving"
+
+
+class InterleavingModel(RouletteModel):
+    def __init__(self, *, config_class: Callable = InterleavingModelConfig, **kwargs):
+        """This "meta"-model alternates between the models in the sequence for every call"""
+        super().__init__(config_class=config_class, **kwargs)
+
+    def select_model(self) -> Model:
+        if self.config.sequence is None:
+            i_model = self.n_calls % len(self.models)
+        else:
+            i_model = self.config.sequence[self.n_calls % len(self.config.sequence)]
+        return self.models[i_model]

minisweagent/models/litellm_model.py

@@ -61,12 +61,23 @@ class LitellmModel:
 
     def query(self, messages: list[dict[str, str]], **kwargs) -> dict:
         response = self._query(messages, **kwargs)
-        cost = litellm.cost_calculator.completion_cost(response)
+        try:
+            cost = litellm.cost_calculator.completion_cost(response)
+        except Exception as e:
+            logger.critical(
+                f"Error calculating cost for model {self.config.model_name}: {e}. "
+                "Please check the 'Updating the model registry' section in the documentation. "
+                "http://bit.ly/4p31bi4 Still stuck? Please open a github issue for help!"
+            )
+            raise
         self.n_calls += 1
         self.cost += cost
         GLOBAL_MODEL_STATS.add(cost)
         return {
             "content": response.choices[0].message.content or "",  # type: ignore
+            "extra": {
+                "response": response,
+            },
         }
 
     def get_template_vars(self) -> dict[str, Any]:

minisweagent/models/openrouter_model.py

@@ -0,0 +1,118 @@
+import json
+import logging
+import os
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+import requests
+from tenacity import (
+    before_sleep_log,
+    retry,
+    retry_if_not_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from minisweagent.models import GLOBAL_MODEL_STATS
+
+logger = logging.getLogger("openrouter_model")
+
+
+@dataclass
+class OpenRouterModelConfig:
+    model_name: str
+    model_kwargs: dict[str, Any] = field(default_factory=dict)
+
+
+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:
+    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(
+        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(
+            (
+                OpenRouterAuthenticationError,
+                KeyboardInterrupt,
+            )
+        ),
+    )
+    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 query(self, messages: list[dict[str, str]], **kwargs) -> dict:
+        response = self._query(messages, **kwargs)
+
+        # Extract cost from usage information
+        usage = response.get("usage", {})
+        cost = usage.get("cost", 0.0)
+
+        # If total_cost is not available, raise an error
+        if cost == 0.0:
+            raise OpenRouterAPIError(
+                f"No cost information available from OpenRouter 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 {
+            "content": response["choices"][0]["message"]["content"] or "",
+            "extra": {
+                "response": response,
+            },
+        }
+
+    def get_template_vars(self) -> dict[str, Any]:
+        return asdict(self.config) | {"n_model_calls": self.n_calls, "model_cost": self.cost}

minisweagent/run/extra/config.py

@@ -33,8 +33,11 @@ This setup will ask you for your model and an API key.
 
 Here's a few popular models and the required API keys:
 
-[bold green]claude-sonnet-4-20250514[/bold green] ([bold green]ANTHROPIC_API_KEY[/bold green])
+[bold green]anthropic/claude-sonnet-4-20250514[/bold green] ([bold green]ANTHROPIC_API_KEY[/bold green])
 [bold green]openai/gpt-5[/bold green] or [bold green]openai/gpt-5-mini[/bold green] ([bold green]OPENAI_API_KEY[/bold green])
+[bold green]gemini/gemini-2.5-pro[/bold green] ([bold green]GEMINI_API_KEY[/bold green])
+
+[bold]Note: Please always include the provider in the model name.[/bold]
 
 [bold yellow]You can leave any setting blank to skip it.[/bold yellow]
 

minisweagent/run/extra/swebench.py

@@ -15,6 +15,7 @@ from pathlib import Path
 import typer
 import yaml
 from datasets import load_dataset
+from jinja2 import StrictUndefined, Template
 from rich.live import Live
 
 from minisweagent import Environment
@@ -72,17 +73,25 @@ def get_swebench_docker_image_name(instance: dict) -> str:
         # Docker doesn't allow double underscore, so we replace them with a magic token
         iid = instance["instance_id"]
         id_docker_compatible = iid.replace("__", "_1776_")
-        image_name = f"swebench/sweb.eval.x86_64.{id_docker_compatible}:latest".lower()
+        image_name = f"docker.io/swebench/sweb.eval.x86_64.{id_docker_compatible}:latest".lower()
     return image_name
 
 
 def get_sb_environment(config: dict, instance: dict) -> Environment:
+    env_config = config.setdefault("environment", {})
+    env_config["environment_class"] = env_config.get("environment_class", "docker")
     image_name = get_swebench_docker_image_name(instance)
-    env_config = config.get("environment", {})
-    if env_config.get("environment_class") == "singularity":
-        image_name = "docker://" + image_name
-    env_config["image"] = image_name
-    return get_environment(env_config, default_type="docker")
+    if env_config["environment_class"] == "docker":
+        env_config["image"] = image_name
+    elif env_config["environment_class"] == "singularity":
+        env_config["image"] = "docker://" + image_name
+    env = get_environment(env_config)
+    if startup_command := config.get("run", {}).get("env_startup_command"):
+        startup_command = Template(startup_command, undefined=StrictUndefined).render(**instance)
+        out = env.execute(startup_command)
+        if out["returncode"] != 0:
+            raise RuntimeError(f"Error executing startup command: {out}")
+    return env
 
 
 def update_preds_file(output_path: Path, instance_id: str, model_name: str, result: str):
@@ -190,6 +199,7 @@ def main(
     output: str = typer.Option("", "-o", "--output", help="Output directory", rich_help_panel="Basic"),
     workers: int = typer.Option(1, "-w", "--workers", help="Number of worker threads for parallel processing", rich_help_panel="Basic"),
     model: str | None = typer.Option(None, "-m", "--model", help="Model to use", rich_help_panel="Basic"),
+    model_class: str | None = typer.Option(None, "-c", "--model-class", help="Model class to use (e.g., 'anthropic' or 'minisweagent.models.anthropic.AnthropicModel')", rich_help_panel="Advanced"),
     redo_existing: bool = typer.Option(False, "--redo-existing", help="Redo existing instances", rich_help_panel="Data selection"),
     config_spec: Path = typer.Option( builtin_config_dir / "extra" / "swebench.yaml", "-c", "--config", help="Path to a config file", rich_help_panel="Basic"),
     environment_class: str | None = typer.Option( None, "--environment-class", help="Environment type to use. Recommended are docker or singularity", rich_help_panel="Advanced"),
@@ -217,6 +227,8 @@ def main(
         config.setdefault("environment", {})["environment_class"] = environment_class
     if model is not None:
         config.setdefault("model", {})["model_name"] = model
+    if model_class is not None:
+        config.setdefault("model", {})["model_class"] = model_class
 
     progress_manager = RunBatchProgressManager(len(instances), output_path / f"exit_statuses_{time.time()}.yaml")
 

minisweagent/run/extra/swebench_single.py

@@ -30,6 +30,7 @@ def main(
     split: str = typer.Option("dev", "--split", help="Dataset split", rich_help_panel="Data selection"),
     instance_spec: str = typer.Option(0, "-i", "--instance", help="SWE-Bench instance ID or index", rich_help_panel="Data selection"),
     model_name: str | None = typer.Option(None, "-m", "--model", help="Model to use", rich_help_panel="Basic"),
+    model_class: str | None = typer.Option(None, "-c", "--model-class", help="Model class to use (e.g., 'anthropic' or 'minisweagent.models.anthropic.AnthropicModel')", rich_help_panel="Advanced"),
     config_path: Path = typer.Option( builtin_config_dir / "extra" / "swebench.yaml", "-c", "--config", help="Path to a config file", rich_help_panel="Basic"),
     environment_class: str | None = typer.Option(None, "--environment-class", rich_help_panel="Advanced"),
     exit_immediately: bool = typer.Option( False, "--exit-immediately", help="Exit immediately when the agent wants to finish instead of prompting.", rich_help_panel="Basic"),
@@ -50,6 +51,8 @@ def main(
     config = yaml.safe_load(get_config_path(config_path).read_text())
     if environment_class is not None:
         config.setdefault("environment", {})["environment_class"] = environment_class
+    if model_class is not None:
+        config.setdefault("model", {})["model_class"] = model_class
     if exit_immediately:
         config.setdefault("agent", {})["confirm_exit"] = False
     env = get_sb_environment(config, instance)

minisweagent/run/github_issue.py

@@ -37,20 +37,25 @@ def fetch_github_issue(issue_url: str) -> str:
     return f"GitHub Issue: {title}\n\n{body}"
 
 
+# fmt: off
 @app.command()
 def main(
     issue_url: str = typer.Option(prompt="Enter GitHub issue URL", help="GitHub issue URL"),
     config: Path = typer.Option(DEFAULT_CONFIG, "-c", "--config", help="Path to config file"),
     model: str | None = typer.Option(None, "-m", "--model", help="Model to use"),
+    model_class: str | None = typer.Option(None, "--model-class", help="Model class to use (e.g., 'anthropic' or 'minisweagent.models.anthropic.AnthropicModel')", rich_help_panel="Advanced"),
     yolo: bool = typer.Option(False, "-y", "--yolo", help="Run without confirmation"),
 ) -> InteractiveAgent:
+    # fmt: on
     """Run mini-SWE-agent on a GitHub issue"""
     configure_if_first_time()
 
     _config = yaml.safe_load(get_config_path(config).read_text())
-    _agent_config = _config.get("agent", {})
+    _agent_config = _config.setdefault("agent", {})
     if yolo:
         _agent_config["mode"] = "yolo"
+    if model_class is not None:
+        _config.setdefault("model", {})["model_class"] = model_class
 
     task = fetch_github_issue(issue_url)
 

minisweagent/run/mini.py

@@ -48,12 +48,13 @@ More information about the usage: [bold green]https://mini-swe-agent.com/latest/
 def main(
     visual: bool = typer.Option(False, "-v", "--visual", help="Toggle (pager-style) UI (Textual) depending on the MSWEA_VISUAL_MODE_DEFAULT environment setting",),
     model_name: str | None = typer.Option( None, "-m", "--model", help="Model to use",),
+    model_class: str | None = typer.Option(None, "--model-class", help="Model class to use (e.g., 'anthropic' or 'minisweagent.models.anthropic.AnthropicModel')", rich_help_panel="Advanced"),
     task: str | None = typer.Option(None, "-t", "--task", help="Task/problem statement", show_default=False),
     yolo: bool = typer.Option(False, "-y", "--yolo", help="Run without confirmation"),
     cost_limit: float | None = typer.Option(None, "-l", "--cost-limit", help="Cost limit. Set to 0 to disable."),
     config_spec: Path = typer.Option(DEFAULT_CONFIG, "-c", "--config", help="Path to config file"),
     output: Path | None = typer.Option(DEFAULT_OUTPUT, "-o", "--output", help="Output trajectory file"),
-    exit_immediately: bool = typer.Option( False, "--exit-immediately", help="Exit immediately when the agent wants to finish instead of prompting."),
+    exit_immediately: bool = typer.Option( False, "--exit-immediately", help="Exit immediately when the agent wants to finish instead of prompting.", rich_help_panel="Advanced"),
 ) -> Any:
     # fmt: on
     configure_if_first_time()
@@ -72,11 +73,14 @@ def main(
         )
         console.print("[bold green]Got that, thanks![/bold green]")
 
-    config["agent"]["mode"] = "confirm" if not yolo else "yolo"
+    if yolo:
+        config.setdefault("agent", {})["mode"] = "yolo"
     if cost_limit:
-        config["agent"]["cost_limit"] = cost_limit
+        config.setdefault("agent", {})["cost_limit"] = cost_limit
     if exit_immediately:
-        config["agent"]["confirm_exit"] = False
+        config.setdefault("agent", {})["confirm_exit"] = False
+    if model_class is not None:
+        config.setdefault("model", {})["model_class"] = model_class
     model = get_model(model_name, config.get("model", {}))
     env = LocalEnvironment(**config.get("env", {}))
 

minisweagent/run/utils/save.py

@@ -1,10 +1,24 @@
+import dataclasses
 import json
 from collections.abc import Callable
 from pathlib import Path
+from typing import Any
 
 from minisweagent import Agent, __version__
 
 
+def _get_class_name_with_module(obj: Any) -> str:
+    """Get the full class name with module path."""
+    return f"{obj.__class__.__module__}.{obj.__class__.__name__}"
+
+
+def _asdict(obj: Any) -> dict:
+    """Convert config objects to dicts."""
+    if dataclasses.is_dataclass(obj):
+        return dataclasses.asdict(obj)  # type: ignore[arg-type]
+    return obj  # let's try our luck
+
+
 def save_traj(
     agent: Agent | None,
     path: Path,
@@ -45,6 +59,14 @@ def save_traj(
         data["info"]["model_stats"]["instance_cost"] = agent.model.cost
         data["info"]["model_stats"]["api_calls"] = agent.model.n_calls
         data["messages"] = agent.messages
+        data["info"]["config"] = {
+            "agent": _asdict(agent.config),
+            "model": _asdict(agent.model.config),
+            "environment": _asdict(agent.env.config),
+            "agent_type": _get_class_name_with_module(agent),
+            "model_type": _get_class_name_with_module(agent.model),
+            "environment_type": _get_class_name_with_module(agent.env),
+        }
     if extra_info:
         data["info"].update(extra_info)