PythonAgentOut: |-
  The return code should be like
  ```Python
  <You code>
  ```

MarkdownOut: |-
  The return content should be like the format below(Please note tha "````" is used to avoid confliction of "```" in markdown file)
  ````markdown
  <the content of markdown file>
  ````

BatchEditOut: |-
  You should return an edition that applies to multiple files in a workspace in JSON.
  Except for the model file, other files should not be renamed.
  Files that do not need modifications should not be included in the returned text.

  For example:
  Inject the code into the folder. Your file name should always contain the suffix. Your file name keys should be unique to avoid delete or replace conflicts.
  {
      <file name1>: "<code>",  // indicate writing <code> into <file name1> (create a new file or update an existing file)
      {% if with_del %}
      <file name2>: "__DEL__"  // indicate removing file name2. When we want to just remove a file or replace a file to a new one, we usually use this
      {% else %}
      <file name2> (optional): "<code>"  // indicate writing <code> into <file name2> (create a new file or update an existing file)
      {% endif %}
  }

PythonBatchEditOut: |-
  You should return an edition that applies to multiple files in a workspace.
  Except for the model file, other files should not be renamed.
  Files that do not need modifications should not be included in the returned text.

  Response format should be like:
  ```<file name 1>
  <code>
  ```
  ```<file name 2>
  <code>
  ```
  {% if with_del %}
  ```<file name 3>
  __DEL__
  ```
  {% endif %}
  ...

  NOTE:
  - The file name should always contain the suffix.
  - The file name should be unique to prevent conflicts during removal or replacement.
  - To indicate writing code into a file, provide the corresponding code to replace "<code>" (creating a new file or updating an existing one).
  {% if with_del %}
  - To explicitly remove a file, provide only `__DEL__` within the code block for that file.
  - To replace a file with a new one, first provide ` __DEL__` for the original file, then include a separate entry with new file name and the new code.
  {% endif %}


# The following prompt is modified from https://cookbook.openai.com/examples/gpt4-1_prompting_guide
PythonBatchPatchOut: |-
  This is a custom utility that makes it more convenient to add, remove, move, or edit code files. `apply_patch` effectively allows you to execute a diff/patch against a file, but the format of the diff specification is unique to this task, so pay careful attention to these instructions. To use the `apply_patch` command, you should pass a message of the following structure as "input":

  %%bash
  apply_patch <<"EOF"
  *** Begin Patch
  [YOUR_PATCH]
  *** End Patch
  EOF

  Where [YOUR_PATCH] is the actual content of your patch, specified in the following V4A diff format.

  *** [ACTION] File: [path/to/file] -> ACTION can be one of Add, Update, or Delete.
  For each snippet of code that needs to be changed, repeat the following:
  [context_before] -> See below for further instructions on context.
  - [old_code] -> Precede the old code with a minus sign.
  + [new_code] -> Precede the new, replacement code with a plus sign.
  [context_after] -> See below for further instructions on context.

  For instructions on [context_before] and [context_after]:
  - By default, show 3 lines of code immediately above and 3 lines immediately below each change. If a change is within 3 lines of a previous change, do NOT duplicate the first change’s [context_after] lines in the second change’s [context_before] lines.
  - If 3 lines of context is insufficient to uniquely identify the snippet of code within the file, use the @@ operator to indicate the class or function to which the snippet belongs. For instance, we might have:
  @@ class BaseClass
  [3 lines of pre-context]
  - [old_code]
  + [new_code]
  [3 lines of post-context]

  - If a code block is repeated so many times in a class or function such that even a single @@ statement and 3 lines of context cannot uniquely identify the snippet of code, you can use multiple `@@` statements to jump to the right context. For instance:

  @@ class BaseClass
  @@ 	def method():
  [3 lines of pre-context]
  - [old_code]
  + [new_code]
  [3 lines of post-context]

  Note, then, that we do not use line numbers in this diff format, as the context is enough to uniquely identify code. An example of a message that you might pass as "input" to this function, in order to apply a patch, is shown below.

  %%bash
  apply_patch <<"EOF"
  *** Begin Patch
  *** Update File: pygorithm/searching/binary_search.py
  @@ class BaseClass
  @@     def search():
  -          pass
  +          raise NotImplementedError()

  @@ class Subclass
  @@     def search():
  -          pass
  +          raise NotImplementedError()

  *** End Patch
  EOF