# variable system error list

## the way an autoresponder works is:

* **parse.** mimu reads from ➜ right to determine what actions are needed. parsing is done serially and conquentially; allowing mimu to form an ordered plan of execution for the AR.
  * during this phase, small errors are caught and already visible. these errors are usually found in previews; such as `/autoresponder show`. [#parsing-errors](#parsing-errors "mention")
* **replace.** mimu substitutes placeholders (e.g. `{user}`) to their real values (e.g. `@iara`).
  * there are very, very few limitations to placeholders; they rarely have any errors. [#placeholder-errors](#placeholder-errors "mention")
* **verify**. mimu checks for all required permissions and that other conditions are met.
  * errors are generally expected. these errors often indicate the AR is working as expected; and are failsafe mechanisms to ensure a command doesn't run when it should not. [#expected-errors-missing-arguments-perms-etc](#expected-errors-missing-arguments-perms-etc "mention")
* **run**. when, and only when all the above are good ➜ mimu runs the functions in strict chronological order.

### because of how unique and complicated autoresponders work, you may run into errors of all types. this place serves as an index of all such errors.

{% hint style="success" %}
long-form errors, such as `PERMISSION_ERROR`: `DENIED_PERMISSIONS` can be disabled with the `{silent}` variable. you can also set a custom error when it occurs, with `{silent: you don't have the things needed to use this!}`
{% endhint %}

### parsing errors

these refer to errors that happen at the first step; typically due to inconsistent information or wrong information being passed into function variables (such as typing gibberish where a number is expected).&#x20;

{% hint style="info" %}
while these errors **should be paid attention to**, it is important to be reminded that errors shown in previews may not be representative of a full error, but more of a warning.

sometimes parsing does not have things determined yet; such as arguments with \[$N] are not properly set in an `/autoresponder show`. it is strongly recommended for you to run the autoresponder or `/send` first.
{% endhint %}

| error code                                                | description                                                                                                                                                                                                                                           | limiting variable                                                                                                                      |                                                                                                                                                                                                        |                                                          |                     |
| --------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------- | ------------------- |
| `MODIFYINV_ERROR` : `INVALID_MODIFY_AMOUNT`               | the amount you specified for an inventory change is **not a valid number** (for example, `sdjfkdsjf`)                                                                                                                                                 | `{modifyinv:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `ITEM_ERROR` : `TOO_MANY_ITEM_USER_DENY`                  | autoresponders can only deny up to 3 users' inventory items.                                                                                                                                                                                          | `{denyitem:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `ROLE_ERROR` : `INVALID_ROLE_PROVIDED`                    | one of the roles you used in your addrole / removerole configuration is invalid or could not be resolved by mimu.                                                                                                                                     | `{addrole:}` and `{removerole:}`                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `ROLE_ERROR` : `INVALID_ROLE_POSITION`                    | mimu’s highest role is **below** the role you are trying to add or remove, so discord does not allow the action.                                                                                                                                      | `{addrole:}` and `{removerole:}`                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `EMBED_ERROR` : `EMBED_NOT_FOUND`                         | the premade embed name you used does not exist, *or* the embed color / object is missing. mimu cannot find the embed to render.                                                                                                                       | `{embed:}`                                                                                                                             |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_ROLE`                                            | <p>a role you provided is not valid or could not be found in the server. this usually happens if:</p><ul><li>the role id / mention / name is wrong</li><li>the role was deleted</li><li>mimu can’t resolve it from the text you typed</li></ul>       | `{requirerole:}` and `{denyrole:}`                                                                                                     |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_PERMISSION`                                      | <p>the permission name you provided is not a valid discord permission.<br>for example: <code>ADMINSTRATOR</code> instead of <code>ADMINISTRATOR</code>.</p>                                                                                           | `{requireperm:}` / `{denyperm:}`                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `CHANNEL_ERROR`: `INVALID_CHANNEL`                        | the autoresponder is used in a channel *not* listed in `{requirechannel:}`                                                                                                                                                                            | `{requirechannel:}`                                                                                                                    |                                                                                                                                                                                                        |                                                          |                     |
| `CHANNEL_ERROR`: `DENIED_CHANNEL`                         | the autoresponder is used in a channel listed in `{denychannel:}`                                                                                                                                                                                     | `{denychannel:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `USER_ERROR`: `REQUIRED_USER_MISMATCH`                    | the invoking user is *not* listed in `{requireuser:}`                                                                                                                                                                                                 | `{requireuser:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `USER_ERROR`: `DENIED_USER`                               | the invoking user *is* listed in `{denyuser:}`                                                                                                                                                                                                        | `{denyuser:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `ROLE_ERROR`: `DENIED_ROLES`                              | the member has a role listed in `{denyrole:}`                                                                                                                                                                                                         | `{denyrole:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `PERMISSION_ERROR`: `INSUFFICIENT_PERMISSIONS`            | the member does *not* have the permissions listed in `{requireperm:}`                                                                                                                                                                                 | `{requireperm:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `PERMISSION_ERROR`: `DENIED_PERMISSIONS`                  | the member *has* a permission listed in `{denyperm:}`                                                                                                                                                                                                 | `{denyperm:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `ITEM_ERROR`: `DENIED_ITEM`                               | the user has an item or amount blocked by `{denyitem:}`                                                                                                                                                                                               | `{denyitem:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `CHANNEL_ERROR` : `INVALID_CHANNEL`                       | <p>the channel you provided is invalid or could not be found in the server. this can happen if:</p><ul><li>the channel id / mention / name is wrong</li><li>the channel was deleted</li><li>mimu doesn’t have access to see that channel</li></ul>    | `{requirechannel:}` / `{denychannel:}`                                                                                                 |                                                                                                                                                                                                        |                                                          |                     |
| `CANNOT_SEND_TO_CHANNEL`                                  | mimu is missing `send messages` or `view channel`                                                                                                                                                                                                     | `{sendto:}` or current channel                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `CANNOT_SEND_EMBED_TO_CHANNEL`                            | missing `embed links` permission in the channel                                                                                                                                                                                                       | \[may be altered with `{sendto:}` as well] `{embed:}`                                                                                  |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER`                                            | <p>the user you provided is invalid or could not be found in the server. this can happen if:</p><ul><li>you typed an id / mention that doesn’t exist</li><li>the user left the server</li><li>mimu can’t resolve the input text to a member</li></ul> | placeholders or configs that expect a valid user (e.g. `{requireuser:}`, user-based args etc, or anything parsing a member from text). |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_REQUSER`                                    | you used `{requireuser:user\|not_valid_user}` but the not\_valid\_user input was not a valid user.                                                                                                                                                    | `{requireuser:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| <p></p><p><code>INVALID\_USER\_DENYUSER</code></p><p></p> | you used `{denyuser:user\|not_valid_user}` but the not\_valid\_user isn't valid.                                                                                                                                                                      | `{denyperm:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_REQPERM`                                    | you used `{requireperm:user\|not_valid_user}` but the not\_valid\_user isn't valid.                                                                                                                                                                   | `{requireperm:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_DENYPERM`                                   | you used `{denyperm:user\|not_valid_user}` but the not\_valid\_user isn't valid.                                                                                                                                                                      | `{denyperm:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_REQROLE`                                    | you used `{requirerole:user\|not_valid_user}` but the not\_valid\_user isn't valid.                                                                                                                                                                   | `{requirerole:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_DENYROLE`                                   | you used `{denyrole:user\|not_valid_user}` but the not\_valid\_user isn't valid.                                                                                                                                                                      | `{denyrole:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_REQBAL`                                     | you used `{requirebal:amount\|user}` but the user part could not be resolved to a valid member.                                                                                                                                                       | `{requirebal:}`                                                                                                                        |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_REQITEM`                                    | you used `{requireitem:item\|amount\|user}` but the target user could not be resolved to a valid member.                                                                                                                                              | `{requireitem:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_DENYITEM`                                   | you used `{denyitem:item\|amount\|user}` but the target user could not be resolved to a valid member.                                                                                                                                                 | `{denyitem:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_IS_BOT`                                     | you tried to modify a balance or inventory for a **bot user**, which is not allowed.                                                                                                                                                                  | `{modifybal:}` or `{modifyinv:}`                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_ITEM_NAME` or `INVALID_ITEM`                     | <p> </p><p>you used <code>{user\_item:}</code> or <code>{user\_item\_count:}</code> without a valid item name or id. typically:</p><ul><li>the item name part is blank, or</li><li>the placeholder couldn’t parse the item name at all</li></ul>      | `{user_item:}` `{user_item_count:}`                                                                                                    |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_ITEM_AMOUNT`                                     | <p>inside <code>{modifyinv:}</code>, the amount (middle part) is not a valid number.<br>for example: <code>{modifyinv:sword                                                                                                                           | abc                                                                                                                                    | @user}</code> wwhere abc is not a number.</p>                                                                                                                                                          | `{modifyinv:}`                                           |                     |
| `INVALID_SHOP_ITEM_ID`                                    | you tried to **add** inventory with `{modifyinv:item\|amount\|user}` using an item id / name that doesn’t match any valid shop product.                                                                                                               | `{modifyinv:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_INVENTORY_ITEM`                                  | you tried to **remove** inventory with `{modifyinv:}` using an item name / id that the user does not have.                                                                                                                                            | user doesn't have this item in inventory                                                                                               |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_INV_OPERATION`                                   | <p>you used <code>{modifyinv:}</code> with an invalid operator.<br>valid operators are <code>+</code> and <code>-</code>. anything else will error.</p>                                                                                               | `{modifyinv:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_AMOUNT`                                          | <p>inside <code>{modifybal:}</code>, the amount is not a valid number.<br>e.g. <code>{modifybal:abc}</code> or <code>{modifybal:+abc                                                                                                                  | @user}</code>.</p>                                                                                                                     | `{modifybal:}`                                                                                                                                                                                         |                                                          |                     |
| `INVALID_BAL_OPERATION`                                   | <p>you used <code>{modifybal:}</code> with an invalid operator.<br>valid ones are: <code>+</code>, <code>-</code>, <code>\*</code>, <code>/</code>, <code>=</code>.</p>                                                                               | `{modifybal:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `TOO_MANY_EMBEDS`                                         | <p>you tried to use <code>{embed}</code> more than the allowed number of times in a single autoresponder.<br>the total premade embed count is capped at <code>10</code>.</p>                                                                          | `{embed:}`                                                                                                                             |                                                                                                                                                                                                        |                                                          |                     |
| `NO_BUTTON_NAME_PROVIDED`                                 | you used `{addbutton:}` without specifying a button name.                                                                                                                                                                                             | `{addbutton:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_BUTTON_NAME`                                     | you used `{addbutton:name}` but that name does not match any existing saved buttonresponder.                                                                                                                                                          | `{addbutton:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `NO_LINKBUTTON_TEXT_PROVIDED`                             | you used `{addlinkbutton:label\|link}` without a text label.                                                                                                                                                                                          | `{addlinkbutton:}`                                                                                                                     |                                                                                                                                                                                                        |                                                          |                     |
| `NO_LINKBUTTON_URL_PROVIDED`                              | you used `{addlinkbutton:text\|}` without a url, url is missing                                                                                                                                                                                       | `{addlinkbutton:}`                                                                                                                     |                                                                                                                                                                                                        |                                                          |                     |
| `LINKBUTTON_INVALID_URL_PROVIDED`                         | the url you provided to `{addlinkbutton:}` is not a valid url. it needs to start with http and be a full link like <https://mimu.bot/>                                                                                                                | `{addlinkbutton:}`                                                                                                                     |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_CHOICES`                                         | you used `{choose}` (or `{choose1}`, `{choose2}`, etc) but didn’t provide **at least 2** valid choices separated by `\|`.                                                                                                                             | `{choose:}`                                                                                                                            |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_ORIGINAL_CHOICE_FOR_LOCK`                        | you tried to use `{lockedchoose}` before a valid `{choose}` was set for that slot. since there’s no original choice index to “lock” to, it can’t work.                                                                                                | `{lockedchoose:}`                                                                                                                      |                                                                                                                                                                                                        |                                                          |                     |
| `INSUFFICIENT_LOCKED_CHOICES`                             | <p>you used <code>{lockedchoose:a                                                                                                                                                                                                                     | b                                                                                                                                      | c}</code> but there isn’t a corresponding choice at the original random index.<br>for example, if the original <code>{choose}</code> picked the third item, but your locked list only has 2 items.</p> | `{lockedchoose:}` list is shorter than `{choose:}` list. |                     |
| `INVALID_WEIGHTS`                                         | <p></p><p>you used <code>{weightedchoose:}</code> but the weights are invalid. for example:</p><ul><li>non-numeric entries</li><li>negative numbers</li><li>all weights are zero</li><li>nothing parseable as a number</li></ul>                      | `{weightedchoose:}`                                                                                                                    |                                                                                                                                                                                                        |                                                          |                     |
| `INSUFFICIENT_WEIGHTS_FOR_CHOOSE`                         | <p>you provided fewer weights than there are choices attached to that slot.<br>for example, <code>{choose:a                                                                                                                                           | b                                                                                                                                      | c}</code> then <code>{weightedchoose:1                                                                                                                                                                 | 2}</code>.</p>                                           | `{weightedchoose:}` |
| `INSUFFICIENT_RANGE`                                      | <p></p><p>you used <code>{range:start-end}</code> but:</p><ul><li><code>start</code> or <code>end</code> is not a valid number, or</li><li><code>start</code> is greater than <code>end</code></li></ul>                                              | `{range:}`                                                                                                                             |                                                                                                                                                                                                        |                                                          |                     |

### expected errors (missing arguments / perms etc)

these refer to errors that are **not breaking**, and are intended to provide more clarity to the user running the trigger (whether that is an autoresponder or a buttonresponder or what else).

these usually mean:

* the autoresponder is working as designed,
* but some **requirement** for it to run was not met (roles, balance, items, arguments, permissions, etc).

| error code                                  | description                                                                                                                                                                                                                                                                                                                           | limiting variable |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- |
| `ROLE_ERROR` : `INSUFFICIENT_ROLES`         | you tried to run an autoresponder that requires at least one role, but the user running it does not have any of the required roles.                                                                                                                                                                                                   | `{requirerole:}`  |
| `BALANCE_ERROR` : `INSUFFICIENT_BALANCE`    | <p></p><p>a user did not have enough currency for the autoresponder to run.<br>for example:</p><blockquote><p><strong>iara</strong> needs (at least) 10 💰 for this autoresponder to run.</p></blockquote>                                                                                                                            | `{requirebal:}`   |
| `INVENTORY_ERROR` : `INSUFFICIENT_ITEM`     | <p>a user is missing an item, or does not have enough of that item, for the autoresponder to run successfully.<br>for example:</p><blockquote><p><strong>xyz</strong> needs <code>1 × apple</code> for this autoresponder to run successfully.</p></blockquote>                                                                       | `{requireitem:}`  |
| `ARGUMENT_ERROR` : `INVALID_ARGUMENTS`      | <p></p><p>one or more of the <strong>required arguments</strong> to your autoresponder are invalid or missing.<br>the error message will tell you <em>which</em> argument failed, and (if possible) show what you typed, e.g.:</p><blockquote><p>the 2nd argument is not a valid number. you wrote <code>abc</code>.</p></blockquote> | `{requirearg:}`   |
| `MODIFYBAL_ERROR` : `INVALID_MODIFY_AMOUNT` | the amount you tried to set a balance to is **not a valid number**.                                                                                                                                                                                                                                                                   | `{modifybal:}`    |

## placeholder errors

very rare but sometimes occurs — pay attention to these!

| error code                               | description                                                    | variable          |
| ---------------------------------------- | -------------------------------------------------------------- | ----------------- |
| `BAL_ERROR` : `TOO_MANY_BAL_REQS`        | autoresponders can only check for up to 3 user balances.       | `{user_balance:}` |
| `ITEM_ERROR` : `TOO_MANY_ITEM_USER_REQS` | autoresponders can only require up to 3 users' inventory items | `{requireitem:}`  |

## runtime errors

these are errors that occur during the running of the autoresponder, at the last step. it is strongly recommended to pay attention to these. :warning:

| error code                                              | description                                                                                                                                                                                              | variable                           |
| ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
| `ROLE_ERROR` : `INVALID_MIMU_PERMISSION`                | mimu tried to **add or remove roles**, but does not have the `Manage Roles` permission in that server.                                                                                                   | `{addrole:}` or `{removerole:}`    |
| `SETNICK_ERROR` : `INVALID_MIMU_PERMISSION`             | mimu tried to **change someone’s nickname**, but does not have the `Manage Nicknames` permission in that server.                                                                                         | `{setnick:}`                       |
| `ADDREACTION_ERROR` : `INVALID_MIMU_PERMISSION`         | mimu tried to **react with emojis** to a message or reply, but does not have the `Add Reactions` permission in that channel.                                                                             | `{reactreply:}` or `` {react:}` `` |
| `MESSAGE_ERROR` : `CANNOT_DELETE_MESSAGE`               | <p></p><p>the autoresponder tried to delete the <strong>trigger message</strong>, but:</p><ul><li>mimu does not have <code>Manage Messages</code>, or</li><li>the message was already deleted.</li></ul> | `{delete}` or `{deletereply:}`     |
| `MESSAGE_ERROR` : `CANNOT_MESSAGE_USER`                 | <p></p><p>the autoresponder tried to <strong>dm the user</strong>, but could not, usually because:</p><ul><li>the user has dms disabled for the server, or</li><li>the user left the server.</li></ul>   | `{dm:}`                            |
| `MODIFYINV_ERROR` : `TOO_MANY_MODIFICATIONS`            | the autoresponder is trying to modify **more than 6 user–item pairs** in a single run. this is capped for safety.                                                                                        | `{modifyinv:}`                     |
| `MODIFYINV_ERROR` : `EXCEED_MODIFYINVENTORY_AMT_NOPREM` | on **non-premium servers**, autoresponder inventory changes **will not apply** if the amount exceeds `10,000` for that item.                                                                             | `{modifyinv:}`                     |
| `MODIFYINV_ERROR` : `EXCEED_MODIFYINVENTORY_AMT`        | autoresponder inventory changes **will not apply** if the amount of the item exceeds `1,000,000,000,000` (1 trillion).                                                                                   | `{modifyinv:}`                     |
| `MODIFYBAL_ERROR` : `TOO_MANY_MODIFICATIONS`            | the autoresponder is trying to modify balances for **more than 3 users** at once. this is capped for safety.                                                                                             | `{modifybal:}`                     |
| `MODIFYBAL_ERROR` : `EXCEED_MODIFYBAL_AMT_NOPREM`       | on **non-premium servers**, autoresponder balance changes are limited to **±100,000**. if the change is bigger, it will not be applied.                                                                  | `{modifybal:}`                     |
| `MODIFYBAL_ERROR` : `EXCEED_MODIFYBAL_AMT`              | autoresponder balance changes are limited to **±1,000,000,000**. above that, the change will not be applied.                                                                                             | `{modifybal:}`                     |
| `ROLE_ERROR` : `TOO_MANY_USERS`                         | you tried to add or remove roles for **more than 3 users** at once in a single autoresponder.                                                                                                            | `{addrole:}` and `{removerole:}`   |
| `ROLE_ERROR` : `TOO_MANY_ROLES`                         | you tried to add / remove **more than 10 roles** for a single user at once.                                                                                                                              | `{addrole:}` and `{removerole:}`   |
| `SETNICK_ERROR` : `TOO_MANY_NICKNAMES`                  | you tried to modify nicknames for **more than 3 users** in a single autoresponder run.                                                                                                                   | `{setnick:}`                       |
| `SETNICK_ERROR` : `NICKNAME_TOO_LONG`                   | the nickname you tried to set is **longer than 32 characters**, which discord does not allow.                                                                                                            | `{setnick:}`                       |
| `SETNICK_ERROR` : `INVALID_ROLE_POSITION`               | mimu tried to change the nickname of someone **higher than or equal to** its own role, or the server owner. discord blocks this.                                                                         | `{setnick:}`                       |
| `ADDREACTION_ERROR` : `TOO_MANY_REACTIONS`              | an autoresponder is trying to add **more than 5 reactions** to the trigger message or reply.                                                                                                             | `{react:}` or `{reactreply:}`      |
| `ADDREACTION_ERROR` : `INVALID_EMOJI`                   | at least one emoji you tried to react with is **invalid or not accessible** to mimu (e.g. from a server mimu is not in).                                                                                 | `{react:}` or `{reactreply:}`      |
| `MESSAGE_ERROR` : `MESSAGE_TOO_LONG`                    | the **final text content** of your autoresponder is over discord’s 4`000` character limit for a single message.                                                                                          | n/a                                |
| `MESSAGE_ERROR` : `EMBED_DESCRIPTION_TOO_LONG`          | the description of one of your embeds is longer than discord’s limit of `4096` characters.                                                                                                               | `{embed:}` (custom embed)          |
| `MESSAGE_ERROR` : `TOO_MANY_EMBED_CHARACTERS`           | the **combined** text across all embeds (titles, descriptions, fields, footers, authors) exceeds discord’s overall embed character limit (`6000` chars).                                                 | `{embed:}`                         |
| `BUTTON_ERROR` : `TOO_MANY_BUTTONS`                     | you tried to create more than `25` buttons in a single autoresponder response (discord limit: 5 buttons × 5 rows).                                                                                       | `{addbutton:}` `{addlinkbutton:}`  |


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.mimu.bot/autoresponder/resources/variable-system-error-list.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
