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

    ```mswea_bash_command
    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.</IMPORTANT>

    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 /testbed (this is the working directory for all your subsequent commands)
    - 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 demonstrated within the <format_example> block:

    <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.

    ```mswea_bash_command
    your_command_here
    ```
    </format_example>

    Commands must be specified in a single bash code block:

    ```mswea_bash_command
    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.

    ```mswea_bash_command
    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.

    ```mswea_bash_command
    ls -la
    ```

    Now I'll read the file:

    ```mswea_bash_command
    cat file.txt
    ```
    </example_response>

    If you need to run multiple commands, either:

    1. Combine them in one block using && or ||
    ```mswea_bash_command
    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
    - You can use bash commands or invoke any tool that is available in the environment
    - You can also create new tools or scripts to help you with the task
    - If a tool isn't available, you can also install it

    ## Submission

    When you've completed your work, you MUST submit your changes as a git patch.
    Follow these steps IN ORDER, with SEPARATE commands:

    Step 1: Create the patch file
    Run `git diff -- path/to/file1 path/to/file2 > patch.txt` listing only the source files you modified.
    Do NOT commit your changes.

    <IMPORTANT>
    The patch must only contain changes to the specific source files you modified to fix the issue.
    Do not submit file creations or changes to any of the following files:

    - test and reproduction files
    - helper scripts, tests, or tools that you created
    - installation, build, packaging, configuration, or setup scripts unless they are directly part of the issue you were fixing (you can assume that the environment is already set up for your client)
    - binary or compiled files
    </IMPORTANT>

    Step 2: Verify your patch
    Inspect patch.txt to confirm it only contains your intended changes and headers show `--- a/` and `+++ b/` paths.

    Step 3: Submit (EXACT command required)
    You MUST use this EXACT command to submit:

    ```mswea_bash_command
    echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT && cat patch.txt
    ```

    If the command fails (nonzero exit status), it will not submit.

    <CRITICAL>
    - Creating/viewing the patch and submitting it MUST be separate commands (not combined with &&).
    - If you modify patch.txt after verifying, you SHOULD verify again before submitting.
    - You CANNOT continue working (reading, editing, testing) in any way on this task after submitting.
    </CRITICAL>
    </instructions>
  step_limit: 250
  cost_limit: 3.

environment:
  cwd: "/testbed"
  timeout: 60
  interpreter: ["bash", "-c"]
  env:
    PAGER: cat
    MANPAGER: cat
    LESS: -R
    PIP_PROGRESS_BAR: 'off'
    TQDM_DISABLE: '1'
  environment_class: docker

model:
  observation_template: |
    {% if output.exception_info -%}
    <exception>{{output.exception_info}}</exception>
    {% endif -%}
    <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.

    ```mswea_bash_command
    <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).
  model_name: "anthropic/claude-sonnet-4-5-20250929"
  model_kwargs:
    drop_params: true
    temperature: 0.0