{
  "notice": "bxzxxr MCP archive: a record of what public MCP servers declared when we listed them (we never call their tools). It is data, not a rating: nothing here says a server is safe, secure, verified or trustworthy, and a server can change after we looked. Secrets we detected are redacted; redacted tool lists are withheld and only their hash is shown.",
  "infrastructure": {
    "host": "rust.wiki",
    "site": "rust.wiki",
    "addresses": [
      {
        "address": "104.21.21.245",
        "endpoints": 1,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "104.21.16.0/20",
          "country": "US"
        }
      },
      {
        "address": "172.67.201.114",
        "endpoints": 1,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "172.67.192.0/20",
          "country": "US"
        }
      },
      {
        "address": "2606:4700:3033::ac43:c972",
        "endpoints": 1,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "2606:4700:3033::/48",
          "country": "US"
        }
      },
      {
        "address": "2606:4700:3030::6815:15f5",
        "endpoints": 1,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "2606:4700:3030::/48",
          "country": "US"
        }
      }
    ],
    "addresses_recorded": true,
    "address_history": [
      {
        "addresses": [
          "104.21.21.245",
          "172.67.201.114",
          "2606:4700:3033::ac43:c972",
          "2606:4700:3030::6815:15f5"
        ],
        "first_seen": "2026-11-21T20:26:01.691Z",
        "last_seen": "2026-11-21T20:26:01.691Z",
        "checks": 1
      }
    ],
    "hosting": [
      {
        "value": "Cloudflare",
        "evidence": "Server header \"cloudflare\""
      }
    ],
    "software": [],
    "server_info": {
      "name": "rust-wiki",
      "version": "1.0.0",
      "protocol_version": "2025-06-18"
    },
    "headers": {
      "server": "cloudflare",
      "strict-transport-security": "max-age=31536000; includeSubDomains; preload"
    },
    "auth": null
  },
  "related": {
    "same_address": {
      "total": 0,
      "sample": []
    },
    "same_site": {
      "total": 0,
      "sample": []
    },
    "same_tool_list": {
      "total": 0,
      "sample": []
    },
    "same_publisher": {
      "publisher": "wiki.rust",
      "total": 0,
      "sample": []
    },
    "same_repository": null,
    "note": "Shared addresses on big platforms (Cloudflare, Vercel and the like) put unrelated servers together; those are marked shared_infrastructure. A match is a pivot, not a link between operators."
  },
  "endpoint": {
    "id": "47883",
    "server_name": "wiki.rust/rust-wiki",
    "url": "https://rust.wiki/mcp",
    "host": "rust.wiki",
    "transport": "streamable-http",
    "last_checked_at": "2026-11-21T20:26:01.691Z",
    "last_state": "listed",
    "last_detail": null,
    "consecutive_failures": 0,
    "current_sha": "13099557f7f24d269fb7f80f57d03af8d6d368bb26b92edc5ff9b4eeb33d652e",
    "first_listed_at": "2026-11-21T20:26:01.691Z",
    "created_at": "2026-11-21T13:35:06.786Z",
    "resolved_addresses": [
      "104.21.21.245",
      "172.67.201.114",
      "2606:4700:3033::ac43:c972",
      "2606:4700:3030::6815:15f5"
    ]
  },
  "server": {
    "name": "wiki.rust/rust-wiki",
    "title": "rust.wiki",
    "description": "Live data for the game Rust: skin prices and history, items, item store, loot tables, servers.",
    "version": "1.0.0",
    "registry_status": "active",
    "repository_url": null,
    "website_url": "https://rust.wiki/mcp",
    "published_at": "2026-10-25T20:59:31.426Z",
    "updated_at": "2026-10-25T20:59:31.426Z",
    "first_seen": "2026-11-21T13:35:06.165Z"
  },
  "other_endpoints": [],
  "intel": {
    "capabilities": [
      "trades"
    ],
    "evm_addresses": [],
    "chains": [],
    "tokens": [],
    "computed_at": "2026-11-22T16:10:07.649Z"
  },
  "operator": {
    "key": "rust.wiki",
    "name": "rust.wiki",
    "platform": false
  },
  "needs_sign_in": false,
  "reachability": {
    "window_days": 30,
    "checks": 1,
    "answered": 1,
    "answered_percent": 100,
    "avg_listing_latency_ms": 1024,
    "first_check_in_window": "2026-11-21T20:26:01.691Z",
    "consecutive_failures_now": 0,
    "days": [
      {
        "day": "2026-11-21",
        "checks": 1,
        "answered": 1,
        "last_state": "listed"
      }
    ]
  },
  "tool_list": {
    "sha256": "13099557f7f24d269fb7f80f57d03af8d6d368bb26b92edc5ff9b4eeb33d652e",
    "tools": 183,
    "resources": 17,
    "prompts": 10,
    "first_seen": "2026-11-21T20:26:02.719Z",
    "tool_names": [
      "rust_overview",
      "search",
      "explain_rust",
      "rust_glossary",
      "whats_new_in_rust",
      "get_item_full",
      "get_monument_full",
      "search_items",
      "browse_items",
      "get_item",
      "get_item_skins",
      "search_skins",
      "browse_skins",
      "get_skin",
      "get_skin_price",
      "get_skin_price_history",
      "list_skin_collections",
      "get_skin_collection",
      "find_skin_deals",
      "get_market_cap",
      "get_market_movers",
      "get_item_store",
      "get_item_store_history",
      "get_store_rotation",
      "search_workshop",
      "list_monuments",
      "get_monument",
      "list_loot_sources",
      "get_loot_table",
      "get_cctv_codes",
      "search_commands",
      "search_world_entities",
      "get_world_entity",
      "get_building_piece",
      "get_raid_costs",
      "get_upkeep_rules",
      "get_rust_updates",
      "search_servers",
      "get_top_servers",
      "get_recent_wipes",
      "get_server",
      "get_data_freshness",
      "get_skin_orderbook",
      "get_skin_marketplace_history",
      "get_market_index",
      "compare_market",
      "get_server_player_history",
      "get_server_stats",
      "get_server_map",
      "get_map",
      "create_map",
      "get_map_job",
      "find_servers_by_map",
      "get_twitch_drops",
      "search_guides",
      "calculate_craft_cost",
      "calculate_recycle_yield",
      "calculate_raid_cost",
      "calculate_upkeep",
      "genetics_best_layout",
      "genetics_predict",
      "resolve_steam_profile",
      "get_player_stats",
      "get_inventory_leaderboard",
      "get_inventory",
      "get_inventory_value_history",
      "get_inventory_valuation",
      "list_inventory_snapshots",
      "get_inventory_snapshot",
      "check_premium_access",
      "get_game_modes",
      "get_weapon_stats",
      "get_tea_recipes",
      "get_best_defences",
      "calculate_base_cost",
      "get_electricity_data",
      "calculate_power",
      "calculate_smelting",
      "get_player_leaderboard",
      "skinlab_list_items",
      "skinlab_get_item",
      "skinlab_link",
      "skinlab_build_outfit",
      "skinlab_render_outfit",
      "skinlab_creator_info",
      "weapon_attachments",
      "simulate_loot_run",
      "simulate_crate_open",
      "get_player_count",
      "breed_animals",
      "plan_farm",
      "get_damage_data",
      "calculate_damage",
      "get_bandit_camp_rules",
      "big_wheel_odds",
      "blackjack_strategy",
      "calculate_decay",
      "calculate_excavator",
      "get_door_code_rules",
      "get_launch_options"
    ],
    "declared": {
      "tools": [
        {
          "name": "rust_overview",
          "title": "Start here: which endpoint/tool answers which Rust question",
          "description": "[Start here] Start here: which endpoint/tool answers which Rust question. The map for AI assistants and new API users: `tasks` (kinds of question -> the MCP tools that answer them,\neach tool named after the endpoint it calls), `concepts` (the concept guides at `/learn/{topic}` - how Rust works,\nfrom the core loop to server settings), `tool_groups` (every MCP tool by area), plus `glossary_terms` and the\nconventions (cents, UTC, vanilla defaults). Read this once, then call the specific tool. START HERE when unsure which tool to use: maps every kind of Rust question to the tools that answer it, lists the concept guides and groups every tool.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "search",
          "title": "Search everything: items, skins, monuments, NPCs, vehicles, commands, settings, guides, servers",
          "description": "[Start here] Search everything: items, skins, monuments, NPCs, vehicles, commands, settings, guides, servers. One search box over the whole network. Each result: `type` (page, item, skin, monument, creature, vehicle,\ncommand, convar, concept, glossary, blog, server), `title`, `summary`, `key`, `url`, and `next` - the tool (and\nits arguments) to call for the full record. Grouped by type, best match first within each; the same item/skin/\nmonument matching as the site's search box. Cached for five minutes per query. One search over items, skins, monuments, animals/NPCs, vehicles, console commands, server settings, concept guides, glossary terms, blog guides and servers. Each result's `next` names the tool and arguments to call.",
          "inputSchema": {
            "type": "object",
            "required": [
              "q"
            ],
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "oil rig"
                ],
                "maxLength": 80,
                "minLength": 2,
                "description": "What to look for: a name, a term, a question keyword (`ak`, `oil rig`, `bear`, `minicopter`, `decay`, `honeycomb`)."
              },
              "limit": {
                "type": "integer",
                "default": 30,
                "maximum": 60,
                "minimum": 1,
                "description": "Most results to return."
              },
              "types": {
                "type": "array",
                "items": {
                  "enum": [
                    "page",
                    "item",
                    "skin",
                    "monument",
                    "creature",
                    "vehicle",
                    "command",
                    "convar",
                    "concept",
                    "glossary",
                    "blog",
                    "server"
                  ],
                  "type": "string"
                },
                "description": "Only these result types (repeatable). Default: all."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "explain_rust",
          "title": "Concept guide: how a part of Rust works",
          "description": "[Start here] Concept guide: how a part of Rust works. A short guide to one part of the game (core loop and progression, building and upkeep, raiding, electricity,\nfarming and genetics, fishing, monuments and puzzles, events, vehicles, NPCs, the economy, wipes, game modes and\neras, server settings, skins and the item store): `sections` of `{heading, text, fact, tools}` - `fact` is a\nnumber-bearing statement read from the current game files or server ConVars (`game_build` cites the build),\n`tools` the MCP tools/endpoints that give exact values - plus `related_topics`. Fixed text, live numbers. How a part of Rust works, in plain words, with the tools that give exact numbers. Use before answering how/why questions ('how does upkeep work', 'what is a soft side', 'how do keycards work').",
          "inputSchema": {
            "type": "object",
            "required": [
              "topic"
            ],
            "properties": {
              "topic": {
                "enum": [
                  "core-loop",
                  "building-and-upkeep",
                  "raiding",
                  "electricity",
                  "farming-and-genetics",
                  "fishing",
                  "monuments-and-puzzles",
                  "events",
                  "vehicles",
                  "npcs",
                  "economy",
                  "wipes",
                  "game-modes",
                  "server-settings",
                  "skins-and-store"
                ],
                "type": "string",
                "examples": [
                  "raiding"
                ],
                "description": "Which guide: core-loop, building-and-upkeep, raiding, electricity, farming-and-genetics, fishing, monuments-and-puzzles, events, vehicles, npcs, economy, wipes, game-modes, server-settings, skins-and-store."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "rust_glossary",
          "title": "Rust glossary: terms and slang mapped to tools",
          "description": "[Start here] Rust glossary: terms and slang mapped to tools. `results`: `{term, definition, tools, pages}` - what a Rust term means and which tools/pages cover it. An exact\nterm or known alias returns one entry; otherwise every term whose name or definition contains the text. Decode Rust slang (BP, TC, soft side, honeycomb, airlock, offline raid, roam, 2x...).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "term": {
                "type": "string",
                "examples": [
                  "soft side"
                ],
                "maxLength": 40,
                "minLength": 1,
                "description": "A term or slang word (BP, TC, soft side, honeycomb, offline raid, 2x...). Omit for the whole glossary."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "whats_new_in_rust",
          "title": "What's new in Rust: latest update, game-data changes, item store, wipes",
          "description": "[Start here] What's new in Rust: latest update, game-data changes, item store, wipes. One call for \"what changed lately\": `updates` (Facepunch's five newest posts with the network's write-up when\nthere is one), `game_data` (the newest build the wiki read from the server files and how many items, recipes,\nloot rows... it changed - details at `/game-data-changes/{build}`), `item_store` (this week's limited-time items\nand when the store rotates) and `force_wipe` (the last and next monthly force wipe). Cached for five minutes. For 'what changed in the latest update': devblogs, game-data changes, item store, force wipe.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_item_full",
          "title": "Everything about one item in one call",
          "description": "[Items] Everything about one item in one call. The item page's whole bundle, trimmed for reading, plus every other dataset that mentions the item:\n`item` (name, description, category, stack size, despawn), `recipe`, `craft_time` (seconds at workbench level 1,\nand with one/two levels above), `blueprint_costs` (research), `tech_tree` (where it sits and what it costs in\nresearch items), `recycle_table`, `vending` (NPC shops selling it / taking it), `loot_sources` (the 15 best\nchances), `used_in`, `weapon` (damage, fire rate, magazine, range - guns), `explosive` (splash radius and hits per\nbuilding grade - explosives), `fishing` (as a catch or as bait), `survival` (spoilage, compost value, armour\ninsert stats/slots, pet stats, mission rewards, keycard/fuse puzzles), `design_notes` (lore from The Art of Rust),\n`skins` (the 5 priciest of `skins_total`) and `tools` - follow-up tools for more. Cached item bundle + pure lookups. Everything about one item in one call - prefer it over several lookups. Shortnames via search.",
          "inputSchema": {
            "type": "object",
            "required": [
              "shortname"
            ],
            "properties": {
              "shortname": {
                "type": "string",
                "examples": [
                  "rifle.ak"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "The item's shortname (find it with `/search` or `/items/search`)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_monument_full",
          "title": "Everything at one monument in one call",
          "description": "[Game reference] Everything at one monument in one call. The monument (`tier`, safe zone, radiation, recyclers, tunnel entrance...) with `loot_sources` (crates and NPC\nloot tables), `placements` (recyclers with efficiency, NPC shops, CCTV camera ids, crates and their spawn points),\n`vending` (each shop's offers - what it sells and for what), `cctv_codes` (the Computer Station codes), `puzzle`\n(keycard/fuse doors in order, resets, radiation and puzzle loot - null when it has none), `missions` (NPC\nmissions given here with rewards) and `design_notes`. Follow up with `/loot-tables/{id}` for odds. Everything at one monument in one call (loot, recyclers, shops, CCTV, puzzle, missions).",
          "inputSchema": {
            "type": "object",
            "required": [
              "slug"
            ],
            "properties": {
              "slug": {
                "type": "string",
                "examples": [
                  "launch-site"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Monument slug from `/monuments` (or `/search`)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "search_items",
          "title": "Item name / shortname typeahead",
          "description": "[Items] Item name / shortname typeahead. Up to 25 live items matching `q`, best match first: a case-insensitive substring match on the display\nname OR the shortname, plus trigram similarity on the display name so typos still resolve (`asault` finds\nthe Assault Rifle) - the same ILIKE + similarity search the site's item pickers use. Each result is\n`{shortname, display_name, category, icon_url}`; use the shortname with `/items/{shortname}`. For filtered,\npaginated results use `/items?search=` instead. Cached for 5 minutes per query.",
          "inputSchema": {
            "type": "object",
            "required": [
              "q"
            ],
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "assault"
                ],
                "maxLength": 80,
                "minLength": 2,
                "description": "Part of an item's display name or shortname (2+ characters)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "browse_items",
          "title": "Browse or search the item catalogue",
          "description": "[Items] Browse or search the item catalogue. One page of live items (seasonal, obsolete and unreleased items are excluded from browsing but still\nresolve by shortname). Each result carries `shortname`, `display_name`, `category`, `icon_url` and\n`is_craftable`; fetch `/items/{shortname}` for everything else. Same ordering and cache as the /items page\non the site (15 minutes).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "name",
                  "category"
                ],
                "type": "string",
                "default": "name",
                "description": "`name` = alphabetical (similarity-ranked while searching); `category` = grouped by category, then name."
              },
              "search": {
                "type": "string",
                "examples": [
                  "assault"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Fuzzy name search: substring match plus trigram similarity, so a typo like `asault` still finds the Assault Rifle. Results are ranked by similarity unless `sort=category`."
              },
              "category": {
                "enum": [
                  "weapon",
                  "construction",
                  "general",
                  "resource",
                  "attire",
                  "tool",
                  "medical",
                  "food",
                  "ammo",
                  "trap",
                  "component",
                  "electrical",
                  "fun",
                  "misc"
                ],
                "type": "string",
                "examples": [
                  "weapon"
                ],
                "description": "Restrict to one of the 14 wiki.facepunch.com item categories."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_item",
          "title": "Full item detail bundle",
          "description": "[Items] Full item detail bundle. Everything the item page shows, in one response: `item` (name, description, category, icon, stack size,\ndespawn seconds, craftable flag), `recipe` (components with quantities), `blueprint_costs` (Research Table scrap\ncost, or `default`), `tech_tree` (each tech tree the item is on: `cost` 1 research item - `currency` is the\nBlueprint Fragment, Page or Book - and `path_cost`, that item with everything before it on the cheapest route;\n`linked` false = in the tree's data but not reachable from its start), `recycle` (rows per `recycler_type`:\n`recycler` = monument 50%, `safe_zone` 40%, `powered` = monument with the Power Plant grid at stage 2+ 60%,\n`red` 75%; `quantity` with `chance`), `recycle_table` (one row per output with `expected`, `min`, `max` per\ntype), `vending` (`sold`: NPC shops selling it and the price; `bought`: shops that take it as payment), `repair`, `loot_sources`\n(every crate/NPC/barrel that drops it, with `chance_pct` and `amount`, highest chance first), `used_in`\n(items this one is an ingredient of), `skins` (the first 24 skins by price, each with `price` and\n`store_price` in USD cents, `subscriptions` and `released`), `skins_total` and `similar` (six items from the\nsame category), `has_3d` and `model_url` (the item page's interactive 3D view of the in-game model, null when\nthe game files have no model for it; item3d 2026-11-16). Page through all skins with `/items/{shortname}/skins`. Cached for 15 minutes.",
          "inputSchema": {
            "type": "object",
            "required": [
              "shortname"
            ],
            "properties": {
              "shortname": {
                "type": "string",
                "examples": [
                  "rifle.ak"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "The item's shortname, e.g. `rifle.ak` or `metal.fragments`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_item_skins",
          "title": "All skins for an item, priced",
          "description": "[Items] All skins for an item, priced. Every skin for one base item, most expensive first (unpriced skins last, then by name) - the same list\nand order as the Skins tab on the item page. Each skin carries `itemdefid`, `name`, `icon_url`,\n`market_hash_name`, `item_collection`, `workshopid`, `price` (canonical wiki price, USD cents, null when\nnothing is listed), `store_price` (its original Rust item-store price, USD cents), `store_change_pct`,\n`subscriptions` (Workshop subscriber count), `released` and the tradable/marketable/banned flags. Prices\nrefresh about every 12 minutes; this list is cached for 15.",
          "inputSchema": {
            "type": "object",
            "required": [
              "shortname"
            ],
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "shortname": {
                "type": "string",
                "examples": [
                  "rifle.ak"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "The item's shortname, e.g. `rifle.ak`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "search_skins",
          "title": "Skin name typeahead",
          "description": "[Skins] Skin name typeahead. Up to 10 skins whose name matches `q`, best match first (the same ILIKE + trigram search the site's search\nboxes use). Each result is `{itemdefid, name, icon_url}`; use the `itemdefid` with the other skin endpoints.\nFor filtered, paginated results use GET /skins with `search=` instead.",
          "inputSchema": {
            "type": "object",
            "required": [
              "q"
            ],
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "tempered"
                ],
                "maxLength": 100,
                "minLength": 2,
                "description": "Part of a skin name (2+ characters)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "browse_skins",
          "title": "Browse skins with the site's filters and sorts",
          "description": "[Skins] Browse skins with the site's filters and sorts. One page of skin cards exactly as the /skins browser shows them: `itemdefid`, `name`, icons, `category`,\n`item_collection`, `market_hash_name`, flags (`is_twitch_drop`, `is_limited_time`, `marketable`, `tradable`,\n`is_permanent`...), `price` (canonical wiki price in cents, null when Steam has no listing), `subscriptions`\n(Workshop subscribers, the site's supply proxy), `store_price` (the original item-store price in cents),\n`store_change_pct` (market price vs store price) and `released` (date accepted into the store). Filters combine\nwith AND. `total` is the filtered count; results are cached for 120 seconds per filter combination.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "item": {
                "type": "string",
                "maxLength": 80,
                "description": "Base item shortname, e.g. `rifle.ak` - every skin of that one item."
              },
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "price_desc",
                  "price_asc",
                  "name",
                  "popularity",
                  "supply_asc",
                  "released_desc",
                  "released_asc",
                  "trending",
                  "marketcap_desc"
                ],
                "type": "string",
                "default": "price_desc",
                "examples": [
                  "price_desc"
                ],
                "description": "Ordering. `popularity` and `supply_asc` use Workshop subscribers; `trending` is the 7-day price change; `marketcap_desc` is price x subscribers."
              },
              "color": {
                "enum": [
                  "red",
                  "orange",
                  "yellow",
                  "green",
                  "cyan",
                  "blue",
                  "purple",
                  "pink",
                  "brown",
                  "white",
                  "gray",
                  "black",
                  "tan",
                  "olive",
                  "navy",
                  "maroon",
                  "silver"
                ],
                "type": "string",
                "description": "Dominant icon colour bucket; matches any of a skin's up to five dominant colours."
              },
              "glows": {
                "type": "boolean",
                "default": false,
                "description": "Only skins with glow-in-the-dark elements."
              },
              "search": {
                "type": "string",
                "maxLength": 100,
                "minLength": 1,
                "description": "Fuzzy name search (trigram similarity; with sort=name results are relevance-ordered). Searches are never cached server-side."
              },
              "creator": {
                "type": "string",
                "maxLength": 100,
                "description": "Workshop creator: a 17-digit SteamID64 for an exact match, or part of the creator's display name."
              },
              "category": {
                "enum": [
                  "weapon",
                  "clothing",
                  "deployable",
                  "decoration",
                  "crate",
                  "resource",
                  "mask",
                  "none"
                ],
                "type": "string",
                "examples": [
                  "weapon"
                ],
                "description": "Skin category."
              },
              "min_subs": {
                "enum": [
                  "1000",
                  "5000",
                  "10000",
                  "25000",
                  "50000"
                ],
                "type": "string",
                "description": "Minimum Steam Workshop subscriber count of the skin's original submission."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "released": {
                "enum": [
                  "2026",
                  "2025",
                  "2024",
                  "2023",
                  "2022",
                  "2021",
                  "2020",
                  "2019",
                  "2018",
                  "2017",
                  "2016",
                  "2015"
                ],
                "type": "string",
                "description": "Year the skin was accepted into the item store."
              },
              "tradable": {
                "type": "boolean",
                "default": false,
                "description": "Only tradable skins."
              },
              "breakable": {
                "type": "boolean",
                "default": false,
                "description": "Only skins with a recycle yield (`recycle_hint`)."
              },
              "commodity": {
                "type": "boolean",
                "default": false,
                "description": "Only Steam commodity items."
              },
              "permanent": {
                "type": "boolean",
                "default": false,
                "description": "Only permanent store items."
              },
              "collection": {
                "type": "string",
                "maxLength": 120,
                "description": "Exact collection name, e.g. `Forest Raiders` (see /skins/collections)."
              },
              "hide_drops": {
                "type": "boolean",
                "default": false,
                "description": "Hide loot-crate drops, publisher drops and Twitch drops (what the site calls DLCs and drops)."
              },
              "marketable": {
                "type": "boolean",
                "default": false,
                "description": "Only Steam-marketable skins."
              },
              "limited_time": {
                "type": "boolean",
                "default": false,
                "description": "Only limited-time store items."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_skin",
          "title": "Full skin detail: price, order book, history, cross-market prices",
          "description": "[Skins] Full skin detail: price, order book, history, cross-market prices. Everything the skin's wiki page shows, as data. `skin` is the full catalogue record (creator, workshop\ntitle and dates, collection, flags, store price and availability, crafting components, glow/cutout ratios,\ncolours). `price` is the canonical wiki price in cents and `price_source` says which side of the book it came\nfrom. `orderbook` is Steam's live book: lowest sell order, highest buy order, order counts, the `buy_orders`\nand `sell_orders` depth ladders (`{price, quantity}`, best first) and `fetched_at`; the headline price\nrefreshes more often than the ladders, so they can briefly trail it. `steam_history` is the last year of\nSteam's own sale history (`recorded_at`, median sale `price`, `volume`; `sale_basis` false means Steam has no\nsale series and the points are our ask-price readings instead) - wider ranges via /skins/{itemdefid}/history.\n`market_stats` is the page's Community & Market Stats card: an archived SCMM snapshot (frozen September 2026)\nof `supply_total`/`supply_total_estimated`/`supply_total_owners_estimated`, Workshop `subscriptions_current`/\n`subscriptions_lifetime`, `favourited_current`, `views`, `votes_up`/`votes_down`, `market_24hr_value`,\n`market_168hr_value`, `market_last_30d_sales`, `market_rank_index`, `market_liquidity_score`, the market\nhigh/low with their dates, `change_7d_percent`/`change_30d_percent`/`change_90d_percent` and `ath_percent`;\nnull for skins SCMM never covere",
          "inputSchema": {
            "type": "object",
            "required": [
              "itemdefid"
            ],
            "properties": {
              "itemdefid": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  10138
                ],
                "description": "The skin's Steam item definition id (also its rust.wiki URL: /skin/{itemdefid})."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_skin_price",
          "title": "Live price, order book depth, extremes and 7d/30d change for one skin",
          "description": "[Skins] Live price, order book depth, extremes and 7d/30d change for one skin. The compact price card the rust.wiki Discord bot's /price command shows, as data. All prices are integer USD\ncents: `price_cents` (the canonical wiki price - Steam's lowest sell order, or the highest buy order when\nnothing is listed), `ask_cents` and `bid_cents` (the two sides of Steam's book), `sell_orders`/`buy_orders`\n(how many orders stand on each side), `sell_ladder` and `buy_ladder` (the top five price levels on each side,\nbest first, as `{price, quantity}`), `ath_cents`/`atl_cents` (the skin's all-time high and low from Steam's\nsale history), `change_7d`/`change_30d` (percent move of today's price against our closest Steam price reading\n7 and 30 days back; null without enough history) and `sales_30d` (units sold on Steam in the last 30 days,\nnull when none). Plus `name`, `icon_url`, `market_hash_name` and `category`. Cached for 5 minutes.",
          "inputSchema": {
            "type": "object",
            "required": [
              "itemdefid"
            ],
            "properties": {
              "itemdefid": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  10138
                ],
                "description": "The skin's item definition id."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_skin_price_history",
          "title": "Steam sale history for one skin",
          "description": "[Skins] Steam sale history for one skin. Steam Community Market's own sale history for the skin, scraped from Steam's listing page: `points` of\n`{recorded_at, price, volume}` where `price` is Steam's median sale price for that interval in cents and\n`volume` the number of sales. Steam reports roughly hourly points for the recent month and daily beyond; ranges\nof a year or more are condensed to one point per day (median price, summed volume). Empty when Steam has no\nsale series for the item (unmarketable skins). History goes back to the skin's first sale, as far as 2015.\nRefreshed continuously; the full series is cached for an hour.",
          "inputSchema": {
            "type": "object",
            "required": [
              "itemdefid"
            ],
            "properties": {
              "range": {
                "enum": [
                  "1d",
                  "1w",
                  "1m",
                  "3m",
                  "6m",
                  "1y",
                  "2y",
                  "5y",
                  "all"
                ],
                "type": "string",
                "default": "1y",
                "examples": [
                  "1y"
                ],
                "description": "How far back: `1d`, `1w`, `1m`, `3m`, `6m`, `1y`, `2y`, `5y` or `all`."
              },
              "itemdefid": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  10138
                ],
                "description": "The skin's item definition id."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_skin_collections",
          "title": "Skin collections with counts and values",
          "description": "[Skins] Skin collections with counts and values. Every skin collection (about 750, e.g. `Forest Raiders`, `Abyss`): `name`, `count` (members), `total_value`\nand `avg_value` (cents, over the priced members only; null when nothing in it is priced) and `icons`, one\n`{url, name}` per member skin. The collection's URL slug is its lower-cased name with non-alphanumerics\ncollapsed to `-` (`Forest Raiders` -> `forest-raiders`), which is what GET /skins/collections/{slug} takes.\nCached for 30 minutes.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "value_desc",
                  "value_asc",
                  "count_desc",
                  "count_asc",
                  "name"
                ],
                "type": "string",
                "default": "value_desc",
                "examples": [
                  "value_desc"
                ],
                "description": "`value_*` sorts by the summed wiki price of the collection's skins, `count_*` by member count."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_skin_collection",
          "title": "One collection with all its skins",
          "description": "[Skins] One collection with all its skins. The collection's `name`, `slug`, `count`, `total_value` and `avg_value` (cents), `released` (the earliest\nmember's store-acceptance date) and `skins`: every member as `{itemdefid, name, icon_url, rarity, category,\nprice}` ordered by price, highest first. The collection's value-over-time series is GET\n/market/collection-value. Cached for 30 minutes.",
          "inputSchema": {
            "type": "object",
            "required": [
              "slug"
            ],
            "properties": {
              "slug": {
                "type": "string",
                "examples": [
                  "forest-raiders"
                ],
                "maxLength": 120,
                "description": "Collection slug (lower-case, hyphenated name), e.g. `forest-raiders`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "find_skin_deals",
          "title": "Executable buy-on-marketplace, sell-on-Steam flips",
          "description": "[Market] Executable buy-on-marketplace, sell-on-Steam flips. Every skin that can be bought on a third-party marketplace for less than it nets on Steam Community Market\nright now, as rust.wiki/skins/deals computes it. Per deal: `buy_market` and `buy_price` (the cheapest in-stock\nlisting we poll, cents), `sell_url` (the Steam listing page), the two Steam references `bid_gross`/`bid_net`\n(highest buy order, and what you actually receive after Steam's 15% fee) and `ask_gross`/`ask_net` (lowest\nsell order, same), then for the chosen `steam_ref`: `sell_price` (the net proceeds), `sell_gross`,\n`spread_abs` (cents) and `spread_pct`. Only rows profitable under the chosen reference are returned. A stale\nbuy order above a fresher ask is capped at the ask. Filters combine with AND; `search` matches the skin name\ncase-insensitively. Marketplace links are not included. Recomputed every ~5 minutes from the marketplace\npoll.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "pct",
                  "abs"
                ],
                "type": "string",
                "default": "pct",
                "examples": [
                  "pct"
                ],
                "description": "Best `pct` (spread as % of buy price) or `abs` (spread in cents) first."
              },
              "search": {
                "type": "string",
                "maxLength": 100,
                "minLength": 1,
                "description": "Case-insensitive substring of the skin name (or Steam market name)."
              },
              "category": {
                "enum": [
                  "weapon",
                  "clothing",
                  "deployable",
                  "decoration",
                  "crate",
                  "resource",
                  "mask",
                  "none"
                ],
                "type": "string",
                "description": "Only skins of this category."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "max_price": {
                "type": "integer",
                "minimum": 0,
                "description": "Maximum buy price in cents."
              },
              "min_price": {
                "type": "integer",
                "minimum": 0,
                "description": "Minimum buy price in cents."
              },
              "steam_ref": {
                "enum": [
                  "buy",
                  "sell"
                ],
                "type": "string",
                "default": "buy",
                "examples": [
                  "buy"
                ],
                "description": "Steam exit price: `buy` = sell instantly into the highest buy order (default), `sell` = list just under the lowest sell order."
              },
              "marketplace": {
                "type": "array",
                "items": {
                  "enum": [
                    "Skinport",
                    "CSDealsMarketplace",
                    "DMarket",
                    "RustTM",
                    "CSTrade",
                    "Waxpeer",
                    "LISSkins",
                    "ManncoStore",
                    "SwapGGTrade",
                    "TradeitGG",
                    "RapidSkins",
                    "LootFarm",
                    "RustSkins",
                    "SkinSell",
                    "TradeRust"
                  ],
                  "type": "string"
                },
                "default": [],
                "description": "Only deals whose cheapest listing is on one of these marketplaces (repeat the parameter)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_market_cap",
          "title": "Market cap of the Rust skin market",
          "description": "[Market] Market cap of the Rust skin market. The rust.wiki Market Cap page as data: `total_value` (cents), `skin_count`, `unit_count`, `by_category`\n(`{category, value}`) and `top`, every skin ranked by value with `{itemdefid, name, icon_url, price, amount,\nvalue}`. Supply is not something Steam exposes, so `amount` is the skin's Steam Workshop subscriber count -\na stated approximation (subscribing is not owning) - and `value` is price x amount. Only marketable skins with\na live Steam price and a linked Workshop submission are included. Cached for 15 minutes.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_market_movers",
          "title": "Stonking, crashing and most-anticipated skins",
          "description": "[Market] Stonking, crashing and most-anticipated skins. The rust.wiki Insights page: `stonking` - the 10 skins trading closest to (or above) their all-time high,\n`crashing` - the 10 closest to their all-time low (each `{itemdefid, name, icon_url, price, reference_price}`,\ncents; the reference is that skin's own all-time high or low from Steam's multi-year history, skins with under\n30 history points excluded), and `anticipated` - the 50 marketable skins with the most Steam Workshop\nsubscribers (`{itemdefid, name, icon_url, subscriptions}`). Refreshed with each price-history run, about every\n6 hours.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_item_store",
          "title": "The current Rust item store",
          "description": "[Item store] The current Rust item store. What is purchasable in Rust's item store right now, in the three sections the wiki shows: `limited_time`\n(this week's rotation, most Workshop subscribers first), `general` (the permanent catalogue) and `dlc_packs`\n(bundles, by name). Each item carries `itemdefid`, `name`, `icon_url`, `category`, `store_price` (cents),\n`market_price` (its Steam Community Market price in cents, null when unlisted), `rarity`, `item_collection`,\n`creator_name`/`creator_avatar_url`, `subscriptions`, `est_supply` with `est_supply_source` (`workshop`\nsubscribers for brand-new items, the market estimate otherwise), `base_item_name` and the usual flags. Also\n`recent_rotations` (the last six, newest first, `is_current` marks the open one), `active_rotation_id` and\n`next_rotation_at` (the open rotation's start + 7 days; rotations land on Thursdays). Steam's own purchase URL\nfor any item is `https://store.steampowered.com/buyitem/252490/{itemdefid}/{quantity}`. Cached 30 minutes.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_item_store_history",
          "title": "Past item-store rotations",
          "description": "[Item store] Past item-store rotations. Every weekly rotation, newest first (the open one included): `id` (the rotation slug, `YYYY-MM-DD-HHMM`, or\n`General` for the permanent catalogue), `name` (Facepunch's label when it had one, usually null), `start`,\n`end` (null while current), `itemdefid_count` and `icons` - every skin in it as `{url, name}`, DLC packs\nexcluded. With `search`, only the rotations that sold a matching skin are returned (same shape, newest first),\nwhich answers \"when was X in the store?\". Full item lists via GET /store/rotations/{rotation_id}. Cached for an\nhour; searches are computed live.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "search": {
                "type": "string",
                "maxLength": 100,
                "minLength": 1,
                "description": "Only rotations that contained a skin whose name matches this (case-insensitive substring), e.g. `Tempered`."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_store_rotation",
          "title": "One rotation's full item list",
          "description": "[Item store] One rotation's full item list. One rotation as the wiki's /store/rotation page shows it: `rotation` (`id`, `name`, `start`, `end`,\n`itemdefid_count` - the number of items that still resolve in the catalogue) and its items split into\n`limited_time`, `general` and `dlc_packs`, each item in the same shape as GET /store, including today's\n`market_price` and `is_available_on_store` (a past rotation can still contain evergreen catalogue items).\nCached for an hour.",
          "inputSchema": {
            "type": "object",
            "required": [
              "rotation_id"
            ],
            "properties": {
              "rotation_id": {
                "type": "string",
                "examples": [
                  "2017-07-13-2006"
                ],
                "maxLength": 40,
                "description": "Rotation id from /store/history, e.g. `2017-07-13-2006`, or `General`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "search_workshop",
          "title": "Browse or search Workshop submissions",
          "description": "[Skins] Browse or search Workshop submissions. One page of submissions. Each carries `workshopid` (the Steam published-file id), `title`,\n`author_steamid64`, `preview_image_url`, `submitted_at` (UTC ISO-8601, may be null), `accepted` and\n`accepted_itemdefid` (the in-game item definition id when Facepunch accepted it - use it with\n`/skins/{itemdefid}`), `target_item_tag`, `subscriptions` and `vote_score` (Steam's 0-1 score; both null\nwhen Steam has not reported them). Same filters, ordering and cache as the /workshop page.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "newest",
                  "popular"
                ],
                "type": "string",
                "default": "newest",
                "description": "`newest` = most recently submitted first; `popular` = most subscribers first."
              },
              "search": {
                "type": "string",
                "examples": [
                  "dragon"
                ],
                "maxLength": 120,
                "minLength": 1,
                "description": "Case-insensitive substring match on the submission title."
              },
              "target": {
                "type": "string",
                "examples": [
                  "AK47"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Only submissions for this target item, exactly as the Workshop tags it (e.g. `AK47`, `Garage Door`); `/workshop/targets` lists every value."
              },
              "accepted": {
                "enum": [
                  "any",
                  "yes",
                  "no"
                ],
                "type": "string",
                "default": "any",
                "description": "`yes` = only submissions Facepunch accepted into the game; `no` = only ones it has not."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_monuments",
          "title": "All 60 fixed monuments",
          "description": "[Game reference] All 60 fixed monuments. Every fixed-location monument, alphabetical, in one response (no pagination - the set is 60 and static).\nEach carries `slug`, `name`, `tier` (1-3, null for safe zones and minor monuments), `is_safezone`,\n`has_radiation` and `radiation_level`, `recyclers` (count on site), `has_tunnel_entrance` (underground rail),\n`has_chinook_drop_zone`, `allows_patrol_heli_crash`, `no_build_area_sqm` and `icon_url`. Moving monuments\n(Cargo Ship) are not included. Cached for one hour.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_monument",
          "title": "One monument with its loot sources",
          "description": "[Game reference] One monument with its loot sources. The same fields as `/monuments` for one monument plus `loot_sources`: every crate/NPC loot table that\nspawns at it (`id`, `name`, `drop_count`), alphabetical - fetch each with `/loot-tables/{id}` - and\n`placements`: what the game's monument scenes put there, one entry per layout (most monuments have one):\n`recyclers` (`type` recycler/safe_zone/red, `count`, `efficiency_pct`, `seconds`), `vending` (NPC shops: `shop`,\n`order_set` - see /vending - and `title`), `cctv` (camera ids for the Computer Station) and `crates` (`name`,\n`source_id` for /loot-tables/{id}, `expected` = average number present with spawns filled, `spawn_points`).\nCached for one hour.",
          "inputSchema": {
            "type": "object",
            "required": [
              "slug"
            ],
            "properties": {
              "slug": {
                "type": "string",
                "examples": [
                  "airfield"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Monument slug from `/monuments`, e.g. `airfield`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_loot_sources",
          "title": "Every loot source (crates, NPCs, barrels)",
          "description": "[Game reference] Every loot source (crates, NPCs, barrels). One page of loot sources, alphabetical. Each carries `id`, `name` (Facepunch's own loot-table name, e.g.\n`Elite Tier Crate`), `drop_count` (how many distinct items it can drop) and `icons` (the icons of its four\nlikeliest drops). Fetch the full drop table with `/loot-tables/{id}`. Cached for 30 minutes.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_loot_table",
          "title": "One loot table with every drop",
          "description": "[Game reference] One loot table with every drop. The loot source's `id` and `name` plus `drops`, highest chance first: for each item `shortname`,\n`display_name`, `icon_url`, `chance_pct` (0-100), `amount_min`/`amount_max` and, for items that spawn\ndamaged, `condition_min_pct`/`condition_max_pct`. Scraped from wiki.facepunch.com; cached for 30 minutes.",
          "inputSchema": {
            "type": "object",
            "required": [
              "source_id"
            ],
            "properties": {
              "source_id": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  1
                ],
                "description": "Loot source id from `/loot-tables`, `/monuments/{slug}` or an item's `loot_sources`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_cctv_codes",
          "title": "CCTV camera codes by monument",
          "description": "[Game reference] CCTV camera codes by monument. The 12 monuments with working CCTV cameras and their Computer Station identifiers (60 codes). `codes`\nare the literal in-game console codes; when `randomized` is true the trailing `****` is a per-wipe random\n4-digit suffix posted near the camera in-game, not a fixed code. `slug` links to `/monuments/{slug}` (null for\nCargo Ship, which is a moving monument). Fixed reference data.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "search_commands",
          "title": "Console and server commands",
          "description": "[Game reference] Console and server commands. One page of Rust console/server commands, alphabetical. Each carries `command`, `syntax`, `description`,\n`category` (Rust's own ConVar namespace, e.g. `server`, `gather`), `command_type` (`command` or `variable`),\n`default_value` (variables only) and `permission_required` (null when any player can run it). Cached for\n30 minutes.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "group": {
                "enum": [
                  "player",
                  "client",
                  "admin",
                  "server-variables"
                ],
                "type": "string",
                "description": "Who runs it: `player` (any player's F1 commands), `client` (your own game settings), `admin` (admin commands) or `server-variables` (server convars) - the /commands/<group> pages."
              },
              "search": {
                "type": "string",
                "examples": [
                  "gather"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Case-insensitive substring match on the command name, its description OR its category (so `workbench` finds every workbench ConVar)."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "admin_only": {
                "type": "boolean",
                "default": false,
                "description": "`true` = only commands that need admin/moderator permission."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "search_world_entities",
          "title": "World entities: animals, NPCs, resource nodes",
          "description": "[Game reference] World entities: animals, NPCs, resource nodes. One page of world entities (anything not tied to one monument), alphabetical. Each carries `slug`,\n`display_name`, `is_npc`, `npc_hp` (null for resources) and `icon_url`. Cached for one hour.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "kind": {
                "enum": [
                  "npc",
                  "resource"
                ],
                "type": "string",
                "examples": [
                  "npc"
                ],
                "description": "`npc` = anything with hit points (animals, scientists, bosses, vehicles); `resource` = nodes, trees, barrels and other harvestables."
              },
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "search": {
                "type": "string",
                "examples": [
                  "scientist"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Case-insensitive substring match on the display name."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_world_entity",
          "title": "One world entity with its loot",
          "description": "[Game reference] One world entity with its loot. The entity's `slug`, `display_name`, `is_npc`, `npc_hp`, `icon_url` and `loot_source_id` (null when it\ndrops nothing), plus `drops` - its five likeliest drops (`shortname`, `display_name`, `icon_url`,\n`chance_pct`, `amount_min`, `amount_max`) - and `drop_count`, the full number of distinct drops. The complete\ntable is `/loot-tables/{loot_source_id}`. Cached for one hour.",
          "inputSchema": {
            "type": "object",
            "required": [
              "slug"
            ],
            "properties": {
              "slug": {
                "type": "string",
                "examples": [
                  "bear"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Entity slug from `/world`, e.g. `bear`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_building_piece",
          "title": "One building piece: costs, durability, siblings",
          "description": "[Game reference] One building piece: costs, durability, siblings. The piece's `slug`, `display_name`, `grade`, `health` and `decay_hours`, plus `costs` (`build`, `repair`\nand `upkeep` lists of `item_name`, `amount` or `min_amount`/`max_amount`, with `shortname`/`icon_url` when\nthe material maps to a catalogue item), `durability` (up to ten entries each for `explosive`, `melee` and\n`bullet` damage: `item_name`, `seconds_taken` to destroy, `required_items` = how many of that weapon/explosive)\nand `siblings` - the same piece at every other grade, Twig to Armored. Cached for one hour.",
          "inputSchema": {
            "type": "object",
            "required": [
              "slug"
            ],
            "properties": {
              "slug": {
                "type": "string",
                "examples": [
                  "stone-wall"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Piece slug from `/building`, e.g. `stone-wall`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_raid_costs",
          "title": "Raid cost table: explosives and sulfur per building piece",
          "description": "[Calculators] Raid cost table: explosives and sulfur per building piece. The dataset behind the raid calculator. `explosives` lists every explosive the building durability data\ncovers: `shortname`, `name`, `icon_url`, `group` (`staples`, `other` or `siege`), `staple` (true for rockets,\nC4, satchel charges, explosive 5.56 ammo and beancans - the page's default set), `sulfur_per_unit` and\n`raw_cost_per_unit` (the crafting recipe resolved down to raw resources such as sulfur, charcoal, metal\nfragments and low grade fuel, per single unit; both null for loot-only explosives like MLRS rockets), `batch`\n(units one craft makes: explosive ammo 2, mortar shells 2) and `recipe_source` (`wiki` = the wiki's own\ncrafting data, `fallback` = Rust's standard recipe where that data has none yet, e.g. rockets). `targets` is\nevery building piece with explosive data (`slug`, `name`, `grade`, `health`), each with `costs` - for every\nexplosive that can damage it, `required` (how many destroy one piece), `damage_per_unit` and `sulfur` (null\nfor loot-only) - and `cheapest_staple`, the single staple explosive that destroys it for the least sulfur.\nDamage from different explosives adds up, so a cheaper mix can be computed from `damage_per_unit` - or use\n/calculators/raid/compute, which runs the page's own mix search. Doors, hatches, high walls and other\ndeployables are included as grade `Deployable` (the `grade` filter takes building grades). Cached for 24 hours. The full table is over 100 KB: pass gra",
          "inputSchema": {
            "type": "object",
            "properties": {
              "grade": {
                "enum": [
                  "Twig",
                  "Wood",
                  "Stone",
                  "Metal",
                  "Armored",
                  "Boat"
                ],
                "type": "string",
                "examples": [
                  "Stone"
                ],
                "description": "Restrict `targets` to one building grade."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_upkeep_rules",
          "title": "Upkeep decay brackets and decay times",
          "description": "[Calculators] Upkeep decay brackets and decay times. Rust's dedicated-server upkeep defaults (the `decay.bracket_*` and `decay.duration_*` ConVars, as most\nservers run them). `brackets` are applied in order to a base's block count: the first 15 blocks cost 10% of\ntheir build cost per day, the next 50 cost 15%, the next 125 cost 20%, and every block beyond 190 costs 33.3%\n(`blocks` null = unbounded); a base's blended daily rate is the block-weighted average of the brackets it\nfills, paid in the resources each piece was built from. `decay_hours` is how long an unmaintained piece of\neach grade takes to decay completely. Fixed constants, no computation happens server-side.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_rust_updates",
          "title": "Facepunch's Rust updates and devblogs",
          "description": "[Updates] Facepunch's Rust updates and devblogs. Every post from rust.facepunch.com/news, newest first. Each carries `slug`, `title`, `summary`,\n`category` (`devblog`, `news`, `update`, ...), `published_date` (UTC date), `thumbnail_url`, `url` (the\nofficial post, or this network's own write-up when `has_blog_post` is true) and `has_blog_post`. Polled every\nfew minutes; the first page is refreshed the moment a new post is found.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "search_servers",
          "title": "Browse, filter and search the server list",
          "description": "[Servers] Browse, filter and search the server list. One page of servers with the same filters, ordering and five-minute cache as the servers.rustprofit.com\nlist and its hub pages (/country/de, /vanilla, /solo, /gather/2x ...). Each result is the full public server\nrecord: identity and connect details (`ip`, `game_port`, `query_port`, `connect` as a `steam://` URI), `map`,\n`world_seed`, `world_size`, `country`/`country_name`, live `current_players`/`max_players`/`queued_players`,\nthe `kind` (official/modded/vanilla) and `is_*` flags, `password_protected`, `vac_enabled`, `gather_rate` with\nits `gather_bucket`, `group_limit` with its `group` label, `tags`, owner-supplied `description` (first 500\ncharacters), `banner_url`, `website_url`, `discord_url`, `first_seen_at`/`last_seen_at`/`last_polled_at`, the\naggregates `votes`, `rating` (1-5 average, null when unrated) and `last_wipe_at`, and the server's page `url`\nplus embeddable `widget_url`/`badge_url`. Ties in every sort are broken by `id` so pages never overlap.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "kind": {
                "enum": [
                  "vanilla",
                  "modded",
                  "official",
                  "pure"
                ],
                "type": "string",
                "examples": [
                  "vanilla"
                ],
                "description": "`vanilla` = not modded; `modded` = reports a modded flag over A2S; `official` = a Facepunch-run public server (by name convention)."
              },
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "players",
                  "votes",
                  "rating",
                  "wiped",
                  "name"
                ],
                "type": "string",
                "default": "players",
                "examples": [
                  "players"
                ],
                "description": "`players` = most players online first (default); `votes` = most community votes; `rating` = highest average rating; `wiped` = most recently wiped; `name` = alphabetical."
              },
              "biome": {
                "enum": [
                  "snow",
                  "desert",
                  "forest",
                  "tundra",
                  "jungle"
                ],
                "type": "string",
                "examples": [
                  "snow"
                ],
                "description": "Only servers whose drawn map is mostly this biome (its share is the highest of the five)."
              },
              "group": {
                "enum": [
                  "solo",
                  "duo",
                  "trio"
                ],
                "type": "string",
                "examples": [
                  "solo"
                ],
                "description": "Team-size cap: `solo` (1), `duo` (2) or `trio` (3). Only servers whose cap is known match."
              },
              "gather": {
                "enum": [
                  "2x",
                  "3x",
                  "5x",
                  "10x"
                ],
                "type": "string",
                "examples": [
                  "2x"
                ],
                "description": "Gather-rate bucket parsed from the server name: `2x` (2-2.99), `3x` (3-4.99), `5x` (5-9.99) or `10x` (10 and above). Servers with no `Nx` in their name never match."
              },
              "online": {
                "type": "boolean",
                "default": true,
                "description": "`true` (default) = only servers that were online at their last poll; `false` = only servers currently marked offline."
              },
              "search": {
                "type": "string",
                "examples": [
                  "rustoria"
                ],
                "maxLength": 120,
                "minLength": 1,
                "description": "Case-insensitive substring match on the server name."
              },
              "country": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}$",
                "examples": [
                  "DE"
                ],
                "maxLength": 2,
                "minLength": 2,
                "description": "ISO 3166-1 alpha-2 country the server is hosted in (GeoIP of its address); `/servers/countries` lists the values in use."
              },
              "count_of": {
                "type": "string",
                "maxLength": 80,
                "description": "With `count_min`/`count_max`: how many of this monument (name or family) the map has, e.g. `Oil Rig` with `count_min=2`."
              },
              "land_max": {
                "type": "integer",
                "maximum": 100,
                "minimum": 0,
                "description": "Land at most this % of the map."
              },
              "land_min": {
                "type": "integer",
                "maximum": 100,
                "minimum": 0,
                "description": "Land at least this % of the map."
              },
              "map_kind": {
                "enum": [
                  "procedural",
                  "custom"
                ],
                "type": "string",
                "description": "`procedural` (generated from seed + size) or `custom` maps."
              },
              "monument": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "examples": [
                  [
                    "Launch Site"
                  ]
                ],
                "maxItems": 5,
                "description": "Only servers whose current map (once drawn) has this monument - a name or a family (`Oil Rig` = large or small, `Military Base`), as `/servers/monument-types` lists them. Repeat for AND (up to 5): `monument=Launch Site&monument=Oil Rig`."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "size_max": {
                "type": "integer",
                "maximum": 10000,
                "minimum": 1000,
                "description": "Map size at most this many metres."
              },
              "size_min": {
                "type": "integer",
                "maximum": 10000,
                "minimum": 1000,
                "description": "Map size at least this many metres."
              },
              "count_max": {
                "type": "integer",
                "maximum": 99,
                "minimum": 0,
                "description": "At most this many `count_of`."
              },
              "count_min": {
                "type": "integer",
                "maximum": 99,
                "minimum": 0,
                "description": "At least this many `count_of` (default 1)."
              },
              "share_min": {
                "type": "integer",
                "maximum": 100,
                "minimum": 1,
                "description": "Minimum % of land in `share_biome`."
              },
              "min_rating": {
                "type": "number",
                "maximum": 5,
                "minimum": 1,
                "examples": [
                  4
                ],
                "description": "Only servers whose average community rating (1-5) is at least this."
              },
              "min_players": {
                "type": "integer",
                "maximum": 10000,
                "minimum": 1,
                "examples": [
                  50
                ],
                "description": "Only servers with at least this many players online right now."
              },
              "share_biome": {
                "enum": [
                  "snow",
                  "desert",
                  "forest",
                  "tundra",
                  "jungle"
                ],
                "type": "string",
                "description": "With `share_min`: a biome that must cover at least `share_min`% of the land."
              },
              "include_hidden": {
                "type": "boolean",
                "description": "Include servers that Rust's in-game server browser doesn't show (`hidden_in_game: true`). Default: left out, except when `search` is given (a name lookup finds them)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_top_servers",
          "title": "Most populated servers right now",
          "description": "[Servers] Most populated servers right now. The online servers with the most players right now - the same query behind the rust.wiki Discord bot's\n`/servers` command - as a compact list: `id`, `name`, `players`, `max_players`, `country` and the server's page\n`url`. Use `/servers?sort=players` for the full records. Cached for 60 seconds.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "limit": {
                "type": "integer",
                "default": 10,
                "maximum": 50,
                "minimum": 1,
                "examples": [
                  10
                ],
                "description": "How many servers to return (1-50)."
              },
              "country": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}$",
                "examples": [
                  "US"
                ],
                "maxLength": 2,
                "minLength": 2,
                "description": "Restrict to one ISO 3166-1 alpha-2 country."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_recent_wipes",
          "title": "Recently wiped servers",
          "description": "[Servers] Recently wiped servers. Wipes detected across every online server in the window, newest first - the feed behind\nservers.rustprofit.com/wipes. A wipe is detected when a server's `world_seed` or `world_size` changes between\ntwo polls, or when the last-wipe time it advertises moves past our previous poll (for servers with A2S rules\ndisabled). Each entry has `detected_at`, the old and new seed/size, and the full server record. Expect\nthousands of entries in the 24 hours after Rust's monthly forced wipe (first Thursday). Cached for five minutes.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "hours": {
                "type": "integer",
                "default": 24,
                "maximum": 168,
                "minimum": 1,
                "examples": [
                  24
                ],
                "description": "Look-back window in hours (1-168). The site's /wipes page shows 24."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_server",
          "title": "One server in full",
          "description": "[Servers] One server in full. Everything the server's page shows except the live player names: the full public record (see `/servers`)\nread fresh, plus `votes`, `rating` (1-5 average) and `rating_count`, the last ten detected `wipes` (newest\nfirst, with the seed/size before and after), `last_wipe_at`, `avg_wipe_cycle_hours` across those wipes,\n`next_wipe_estimate_at` (last wipe + average cycle; a guess, not a schedule), `next_force_wipe_at` (Rust's\nmonthly forced wipe) and `map_preview` - the server's map drawn from the server's own map file (or generated\nfrom its seed + size), null until one is drawn: `image_url` (labelled, 1440 px), `thumbnail_url` (480 px),\n`images`, `total_monuments`, `monuments` (`{type, x, y}`), `monument_types`, `land_percentage`, the five\n`biome_*` percentages, `source_note`, `generated_at` and `is_previous_wipe` (true while a wiped server's new\nmap is still being drawn - see `/servers/{id}/map`). Offline servers still resolve; unknown ids are 404.\nPlayer-count history is at `/servers/{id}/history`. Aggregates are cached for five minutes.",
          "inputSchema": {
            "type": "object",
            "required": [
              "server_id"
            ],
            "properties": {
              "server_id": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  1
                ],
                "description": "The server's numeric id (from `/servers`, or the number in its servers.rustprofit.com/server/{id} URL)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_data_freshness",
          "title": "When each dataset last changed and how often it refreshes",
          "description": "[Status] When each dataset last changed and how often it refreshes. The quota-saver: for every dataset the API serves, `updated_at` (the newest timestamp actually in the\ntable, UTC) and `refresh_seconds` (how often it can change), with the endpoints it feeds. Poll this cheap\nendpoint and only re-fetch a heavy payload such as /market/prices or /servers when its dataset's `updated_at`\nhas moved; cache reference data (items, monuments, ...) locally since it only changes with Facepunch's monthly\npatch. Timestamps are read live from the database and cached for 60 seconds.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_skin_orderbook",
          "title": "Full Steam order book for one skin",
          "description": "[Skins] Full Steam order book for one skin. Steam Community Market's current order book for the skin, straight from our scraper's latest snapshot:\n`lowest_sell_order` and `highest_buy_order` (cents; null when that side is empty), `sell_order_count` and\n`buy_order_count`, the COMPLETE `sell_orders` and `buy_orders` depth ladders as `[{price, quantity}, ...]`\nbest price first (every level Steam publishes, not a top-N cut), and `fetched_at`, when the snapshot was taken.\nThe headline ask is refreshed by a market-wide sweep every ~12 minutes; the depth ladders come from the\nper-item rotation (every few hours), so they can trail it slightly. 404 when the skin has no Steam order book\n(unmarketable items). Not cached: this is one indexed row.",
          "inputSchema": {
            "type": "object",
            "required": [
              "itemdefid"
            ],
            "properties": {
              "itemdefid": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  10138
                ],
                "description": "The skin's item definition id."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_skin_marketplace_history",
          "title": "Price and sales history for one skin on each marketplace",
          "description": "[Skins] Price and sales history for one skin on each marketplace. The skin's history on every marketplace rust.wiki tracks, Steam included. Per site in `sites`:\n`listing` is `[day, low, close, qty]` per UTC day - the lowest listing price we read that day (`low` the day's\nlowest reading, `close` the last) and how many listings stood behind it; `sales` maps a period to\n`[day, volume, avg_price]` rows - `day` and `week` are real sales buckets (`day` = the bucket's first day) from\neach site's own sales data: Rust.tm (years back), CS.Deals, DMarket, Mannco.store and RustSkins; `r1` is\nSkinport's last-24-hours figure recorded once a day against the day it covers; `r7` and `r30` are a site's\nrolling 7- and 30-day figures as we read them that day. Prices are integer USD cents. Listing history\nstarts 2026-10-30. Steam's own sale history\nis GET /skins/{itemdefid}/history. Updated through the day (listings every ~5 minutes).",
          "inputSchema": {
            "type": "object",
            "required": [
              "itemdefid"
            ],
            "properties": {
              "range": {
                "enum": [
                  "1m",
                  "3m",
                  "6m",
                  "1y",
                  "all"
                ],
                "type": "string",
                "default": "1y",
                "examples": [
                  "1y"
                ],
                "description": "How far back: `1m`, `3m`, `6m`, `1y` or `all`."
              },
              "itemdefid": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  43203
                ],
                "description": "The skin's item definition id."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_market_index",
          "title": "Skin market index series",
          "description": "[Market] Skin market index series. The rust.wiki Market Index: a basket of skins rebased to 100 at the start of the window, like a stock\nindex, built from Steam's daily price history (one point per day; weekly beyond two years). Returns `dates`\n(ISO dates), `values` (index level, 100 = the window's first day), `constituent_count` (skins that had a price\nat the baseline; baskets are capped at 300 constituents) and `label`. A skin whose history starts inside the\nwindow joins from its first price. Cached for 24 hours per parameter combination (history only gains a point\nevery 6 hours); the full catalogue, every category and every collection are kept warm server-side.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "range": {
                "enum": [
                  "7d",
                  "30d",
                  "90d",
                  "1y",
                  "2y",
                  "3y",
                  "4y",
                  "5y",
                  "all",
                  "custom"
                ],
                "type": "string",
                "default": "90d",
                "examples": [
                  "90d"
                ],
                "description": "Window: `7d`, `30d`, `90d`, `1y`, `2y`, `3y`, `4y`, `5y`, `all`, or `custom` with `start_date`/`end_date`. Spans over two years are downsampled to one point per week."
              },
              "smooth": {
                "type": "boolean",
                "default": false,
                "description": "Apply a trailing 30-day moving average."
              },
              "end_date": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                "description": "Custom range end (YYYY-MM-DD, inclusive). Only read when range=custom."
              },
              "trim_days": {
                "type": "integer",
                "default": 0,
                "maximum": 90,
                "minimum": 0,
                "description": "Mask each constituent's first N days of history (0-90) to drop launch-week volatility."
              },
              "start_date": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                "description": "Custom range start (YYYY-MM-DD, inclusive). Only read when range=custom."
              },
              "basket_type": {
                "enum": [
                  "all",
                  "high_value",
                  "low_value",
                  "category",
                  "collection",
                  "color",
                  "item",
                  "custom"
                ],
                "type": "string",
                "default": "all",
                "examples": [
                  "category"
                ],
                "description": "Which skins form the index: `all`, `high_value`/`low_value` (300 priciest/cheapest), `category`, `collection`, `color`, `item` (one base item's skins) or `custom` (your own list)."
              },
              "weight_mode": {
                "enum": [
                  "equal",
                  "marketcap"
                ],
                "type": "string",
                "default": "equal",
                "description": "`equal`: every constituent's % move counts the same. `marketcap`: weighted by price x Workshop subscribers, like an S&P-style index."
              },
              "basket_value": {
                "type": "string",
                "examples": [
                  "weapon"
                ],
                "maxLength": 2000,
                "description": "The category, collection name, colour, item shortname, or for `custom` a comma-separated list of up to 300 itemdefids. Ignored for all/high_value/low_value."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "compare_market",
          "title": "Overlay skins, baskets and indices on one date axis",
          "description": "[Market] Overlay skins, baskets and indices on one date axis. The data behind rust.wiki/skins/compare: one shared `dates` axis and a `series` entry per token with\n`key`, `name`, `icon_url`, `is_basket`, `is_index` and `prices` aligned to the axis (null where that entry has\nno data yet). Skin and basket entries are prices in cents (a basket is the plain average of its members'\nprices); index entries are index levels rebased to 100. Spans over two years are downsampled to weekly points.\nCached for 24 hours per parameter combination.",
          "inputSchema": {
            "type": "object",
            "required": [
              "entries"
            ],
            "properties": {
              "range": {
                "enum": [
                  "7d",
                  "30d",
                  "90d",
                  "1y",
                  "2y",
                  "3y",
                  "4y",
                  "5y",
                  "all",
                  "custom"
                ],
                "type": "string",
                "default": "90d",
                "examples": [
                  "90d"
                ],
                "description": "Window: `7d`, `30d`, `90d`, `1y`, `2y`, `3y`, `4y`, `5y`, `all`, or `custom` with `start_date`/`end_date`. Spans over two years are downsampled to one point per week."
              },
              "smooth": {
                "type": "boolean",
                "default": false,
                "description": "Apply a trailing 30-day moving average."
              },
              "entries": {
                "type": "string",
                "examples": [
                  "10337,10148,category:weapon"
                ],
                "maxLength": 400,
                "minLength": 1,
                "description": "Comma-separated, up to 8: an `itemdefid` (that skin's price), `category:weapon` / `collection:Forest Raiders` / `item:shoes.boots` (the basket's average price) or `index:all` / `index:category:weapon` / `index:custom:123.456` (an index entry; custom ids joined with `.`)."
              },
              "end_date": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                "description": "Custom range end (YYYY-MM-DD, inclusive). Only read when range=custom."
              },
              "trim_days": {
                "type": "integer",
                "default": 0,
                "maximum": 90,
                "minimum": 0,
                "description": "Mask each constituent's first N days of history (0-90) to drop launch-week volatility."
              },
              "start_date": {
                "type": "string",
                "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                "description": "Custom range start (YYYY-MM-DD, inclusive). Only read when range=custom."
              },
              "index_weight_mode": {
                "enum": [
                  "equal",
                  "marketcap"
                ],
                "type": "string",
                "default": "equal",
                "description": "Weighting for any `index:` entries (see /market/index)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_server_player_history",
          "title": "Player-count history for one server",
          "description": "[Servers] Player-count history for one server. The per-poll `player_count`/`queued_count` readings behind the server page's 24-hour chart, oldest first,\nas `points` of `{t, players, queued}`. One reading lands per poll cycle (roughly hourly); when the window\nholds more than 500 readings they are averaged into equal time buckets (`resolution_seconds`, null when the\npoints are raw) so a response never exceeds 500 points. Also `peak_players`, `avg_players` and `point_count`.\nA server that has never answered a poll has an empty series. Cached for five minutes.",
          "inputSchema": {
            "type": "object",
            "required": [
              "server_id"
            ],
            "properties": {
              "days": {
                "type": "integer",
                "default": 1,
                "maximum": 30,
                "minimum": 1,
                "examples": [
                  7
                ],
                "description": "How many days back to return (1-30). Snapshots are pruned nightly to the configured retention window (7 days by default - see `snapshot_retention_days` on `/servers/stats`), so longer ranges come back only as far as the table holds."
              },
              "server_id": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  1
                ],
                "description": "The server's numeric id."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_server_stats",
          "title": "Site-wide totals and data freshness",
          "description": "[Servers] Site-wide totals and data freshness. The headline numbers from the servers.rustprofit.com homepage: `online_servers`, `total_players` and\n`queued_players` summed across every online server, `tracked_servers` (every row ever discovered, offline\nincluded), `steam_global_players` (Rust's concurrent player count from Steam, null if Steam did not answer),\n`next_force_wipe_at` (the first Thursday of the month at 2 PM US Eastern: 18:00 UTC during US daylight saving time, 19:00 UTC otherwise), the poller's\nconfiguration (`poll_interval_seconds` between cycles, `offline_after_seconds` before an unanswering server\nis marked offline, `snapshot_retention_days` of per-server history kept) and `workers` - the live heartbeat\nstatus of the discovery, polling and map-generation jobs, so you can tell how fresh the data is. Includes next_force_wipe_at (Rust's monthly forced wipe).",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_server_map",
          "title": "A server's map: images, monuments, biomes",
          "description": "[Servers] A server's map: images, monuments, biomes. The map the server runs, drawn from the server's own map file (or generated from its seed + size):\n`current` = `{map_key, source, source_note, map_file_url, world_seed, world_size, map_size, image_url,\nimages: {labelled: {480, 960, 1440}, plain: {2000}}, total_monuments, monuments: [{name, type, x, y}],\nmonument_types, land_percentage, biomes: {snow, desert, forest, tundra, jungle}, drawn_at}`. Monument\ncoordinates are world metres with the map centre at 0,0 (+y = north); `type` is `major` or a minor kind\n(cave, tunnel, power, rock, ice, well, nature). After a wipe `current` is null until the new map is\ndrawn (`current_job` says how far it is) and `previous` holds the last drawn map; `status` is `drawn`,\n`pending`, `failed` or `none` (nothing to draw from: no map file and no seed). Cached for a minute. The server's map drawn from its own map file: labelled/plain image URLs, every monument with coordinates, biome and land %. After a wipe, `previous` holds the last map until the new one is drawn. Find server ids with search_servers. Show the user images.labelled['960'] or image_url.",
          "inputSchema": {
            "type": "object",
            "required": [
              "server_id"
            ],
            "properties": {
              "server_id": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  1
                ],
                "description": "The server's numeric id (from `/servers`)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_map",
          "title": "Find a drawn map by seed + size, map-file URL, map key or server address",
          "description": "[Servers] Find a drawn map by seed + size, map-file URL, map key or server address. Returns the job view `{job_id, status, source, url, seed, size, requested_at, error, map}` where `map` is\nthe full map (as in `/servers/{id}/map`, with monuments) once drawn. A seed + size lookup also finds a map\ndrawn from a procedural server's own file. 404 when nothing is known yet - ask for it with `POST /maps`.\nWith `address` the answer is the server's view (as `/servers/{id}/map`). Look a map up by seed + size, by the .map URL, by job id, or by a server's ip:port. Not known yet? Ask for it with create_map (asynchronous).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "key": {
                "type": "string",
                "maxLength": 32,
                "minLength": 32,
                "description": "A map key / job id (32 hex characters; the URL hash)."
              },
              "url": {
                "type": "string",
                "maxLength": 2000,
                "description": "A .map file URL exactly as a server publishes it."
              },
              "seed": {
                "type": "integer",
                "maximum": 4294967295,
                "minimum": -2147483648,
                "examples": [
                  1943155550
                ],
                "description": "Procedural seed (with `size`)."
              },
              "size": {
                "type": "integer",
                "maximum": 6000,
                "minimum": 1000,
                "examples": [
                  4000
                ],
                "description": "Map size in metres (with `seed`)."
              },
              "address": {
                "type": "string",
                "maxLength": 64,
                "description": "A server address `ip:port` (game or query port)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "create_map",
          "title": "Ask for a Rust map to be drawn (asynchronous)",
          "description": "Draw a Rust map from a public .map file URL, or generate one from a procedural seed + size. ASYNCHRONOUS: returns a job (job_id + status). If the map already exists you get it straight away; otherwise the job is queued for the background drawer - call get_map_job with the job_id after ~20-60 s (a seed generation takes 6-10 minutes). Use get_server_map / get_map first: most live servers' maps are already drawn. Keyless callers share a small daily budget and can only use url (seed generation needs your own free API key from https://rust.wiki/api-keys).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "url": {
                "type": "string",
                "description": "Public https:// link to a Rust .map file."
              },
              "seed": {
                "type": "integer",
                "description": "Procedural map seed (32-bit). Use with size."
              },
              "size": {
                "type": "integer",
                "maximum": 6000,
                "minimum": 1000,
                "description": "Procedural map size in metres (1000-6000). Use with seed."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_map_job",
          "title": "Status of a map drawing job",
          "description": "[Servers] Status of a map drawing job. `status` is `queued`, `downloading` (map file), `generating` (our own game server building a procedural\nmap - several minutes), `rendering`, `done` or `failed` (`error` says why; failed downloads are retried\nafter 6 h, 24 h, then weekly - `next_attempt_at`). When done, `map` carries the image URLs and summary. Poll a create_map job: queued -> downloading/generating -> rendering -> done (or failed with the reason).",
          "inputSchema": {
            "type": "object",
            "required": [
              "job_id"
            ],
            "properties": {
              "job_id": {
                "type": "string",
                "maxLength": 32,
                "minLength": 32,
                "description": "The job id `POST /maps` returned (the map key)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "find_servers_by_map",
          "title": "Find servers by their map: monuments, counts, size, biomes, land",
          "description": "[Servers] Find servers by their map: monuments, counts, size, biomes, land. Online servers whose CURRENT map (drawn from the server's own map file) matches every filter given -\ne.g. `monument=Launch Site&monument=Oil Rig&share_biome=snow&share_min=25&size_max=4000`. Each result:\n`id`, `name`, `url` (the server page), `connect`, `players`, `max_players`, `country`, and `map`\n(`map_key`, `map_size`, `image_url` 480 px, `land_percentage`, `biomes`, `monument_counts`). Servers whose\nmap isn't drawn yet never match. Same filters as `/servers` and the servers.rustprofit.com list. Cached for\nfive minutes. Use for 'servers with Launch Site and an Oil Rig', 'small maps with lots of snow', 'custom maps with 2+ oil rigs'. Monuments are names or families: Launch Site, Oil Rig (large or small), Large Oilrig, Military Tunnels, Airfield, Outpost, Bandit Town, Arctic Research Base, Military Base, Underwater Lab, Harbor, Excavator... Only servers whose map is already drawn match. Link each server's url.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "players",
                  "size",
                  "land"
                ],
                "type": "string",
                "default": "players",
                "description": "`players` (default), `size` (largest map first) or `land`."
              },
              "biome": {
                "enum": [
                  "snow",
                  "desert",
                  "forest",
                  "tundra",
                  "jungle"
                ],
                "type": "string",
                "description": "The map's dominant biome."
              },
              "country": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}$",
                "examples": [
                  "DE"
                ],
                "maxLength": 2,
                "minLength": 2,
                "description": "ISO country code of the server."
              },
              "count_of": {
                "type": "string",
                "examples": [
                  "Oil Rig"
                ],
                "maxLength": 80,
                "description": "With count_min/count_max: how many of this monument (name or family)."
              },
              "land_max": {
                "type": "integer",
                "maximum": 100,
                "minimum": 0,
                "description": "Land at most this % of the map."
              },
              "land_min": {
                "type": "integer",
                "maximum": 100,
                "minimum": 0,
                "description": "Land at least this % of the map."
              },
              "map_kind": {
                "enum": [
                  "procedural",
                  "custom"
                ],
                "type": "string",
                "description": "`procedural` or `custom` maps."
              },
              "monument": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "examples": [
                  [
                    "Launch Site"
                  ]
                ],
                "maxItems": 5,
                "description": "Monument name or family the map must have (`Launch Site`, `Oil Rig`, `Military Base` - see `/servers/monument-types`). Repeat for AND, up to 5."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "size_max": {
                "type": "integer",
                "maximum": 10000,
                "minimum": 1000,
                "description": "Map size at most (metres)."
              },
              "size_min": {
                "type": "integer",
                "maximum": 10000,
                "minimum": 1000,
                "description": "Map size at least (metres)."
              },
              "count_max": {
                "type": "integer",
                "maximum": 99,
                "minimum": 0,
                "description": "At most this many `count_of`."
              },
              "count_min": {
                "type": "integer",
                "maximum": 99,
                "minimum": 0,
                "description": "At least this many `count_of` (default 1)."
              },
              "share_min": {
                "type": "integer",
                "maximum": 100,
                "minimum": 1,
                "examples": [
                  25
                ],
                "description": "Minimum % of land in share_biome."
              },
              "min_players": {
                "type": "integer",
                "maximum": 10000,
                "minimum": 1,
                "description": "At least this many players online now."
              },
              "share_biome": {
                "enum": [
                  "snow",
                  "desert",
                  "forest",
                  "tundra",
                  "jungle"
                ],
                "type": "string",
                "description": "With share_min: this biome covers at least share_min% of the land."
              },
              "include_hidden": {
                "type": "boolean",
                "default": false,
                "description": "Include servers that Rust's in-game server browser doesn't show (`hidden_in_game: true`); left out by default, like the site's list."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_twitch_drops",
          "title": "Current Rust Twitch and Kick drops",
          "description": "[Skins] Current Rust Twitch and Kick drops. The live drops campaigns (Twitch and Kick: round, dates, general and streamer drops with the skin each one\ngives), the most valuable drop skins ever by Steam price, and past rounds - the data behind rust.wiki/drops.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "search_guides",
          "title": "Search the RustProfit blog's Rust guides",
          "description": "[Guides] Search the RustProfit blog's Rust guides. Published guides from blog.rustprofit.com (monuments, recyclers, farming, base building, raiding, gear, NPCs,\nwipes, update explainers), best match first: every word must appear somewhere in the guide, and title matches\nrank above summary and tag matches, which rank above body-text matches. Link the `url` when citing one. Rust how-to guides from blog.rustprofit.com; cite and link the url.",
          "inputSchema": {
            "type": "object",
            "required": [
              "q"
            ],
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "recycler locations"
                ],
                "maxLength": 100,
                "minLength": 2,
                "description": "Words to find in guide titles, summaries, tags and text."
              },
              "limit": {
                "type": "integer",
                "default": 5,
                "maximum": 20,
                "minimum": 1,
                "description": "Most results to return."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_craft_cost",
          "title": "Raw materials to craft a list of items",
          "description": "[Calculators] Raw materials to craft a list of items. Resolves every recipe down to raw materials, per unit (items made in batches, like gunpowder, are divided by\ntheir batch size), exactly as the craft calculator page does. `raw_materials` is the total, largest first;\n`items` echoes each input with its direct recipe; `unknown` lists inputs that matched no item.",
          "inputSchema": {
            "type": "object",
            "required": [
              "items"
            ],
            "properties": {
              "items": {
                "type": "string",
                "examples": [
                  "rocket:4,explosive.timed:2"
                ],
                "maxLength": 2000,
                "minLength": 1,
                "description": "Comma-separated `shortname:quantity` pairs (display names work too; quantity defaults to 1)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_recycle_yield",
          "title": "What recycling a list of items yields",
          "description": "[Calculators] What recycling a list of items yields. Expected outputs (quantity x per-unit yield x chance) per input and in total, for the chosen recycler type\n(the standard monument recycler unless you say otherwise).",
          "inputSchema": {
            "type": "object",
            "required": [
              "items"
            ],
            "properties": {
              "items": {
                "type": "string",
                "examples": [
                  "gears:10,metalpipe:5"
                ],
                "maxLength": 2000,
                "minLength": 1,
                "description": "Comma-separated `shortname:quantity` pairs (display names work too; quantity defaults to 1)."
              },
              "recycler": {
                "enum": [
                  "recycler",
                  "safe_zone",
                  "powered",
                  "red"
                ],
                "type": "string",
                "default": "recycler",
                "description": "`recycler` (standard monument recycler, 50%), `safe_zone` (Outpost/Bandit Camp/floating cities, 40%), `powered` (monument recycler with the Power Plant grid at stage 2+, 60%) or `red` (the Power Plant's red recycler, 75%, needs grid stage 4)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_raid_cost",
          "title": "Explosives needed to destroy a set of building pieces",
          "description": "[Calculators] Explosives needed to destroy a set of building pieces. The raid calculator page's plan (https://rust.wiki/calculators/raid). Targets are building pieces (slugs from\n/building), doors, hatches, high walls and other deployables (slug or item shortname, e.g. `door.hinged.metal`).\n`plan` is what the page shows: per piece every allowed explosive's count and sulfur, the cheapest single\nexplosive, and the cheapest MIX when combining explosives saves sulfur; then the totals - `total_sulfur`,\n`explosives_to_craft` (with crafts for batch recipes) and `raw_resources` - and a `page` link to the same plan.\n`options` / `cheapest` are single-explosive totals over every piece at once (one explosive for the whole raid).\nDeployables the building data lacks (auto turrets, boxes, tool cupboards, furnaces...: item shortname or name)\ncome back under `game_data_deployables`, from the server files: per target every explosive's `count`, `sulfur`\nand `cheapest`, plus `single_explosive_totals`. Doors, hatches and high walls go in by slug or item shortname (door.hinged.metal); any other deployable (autoturret, box.wooden.large, cupboard.tool...) comes back under game_data_deployables. Use `plan` for the answer the raid calculator page gives (cheapest explosive or mix per piece, totals).",
          "inputSchema": {
            "type": "object",
            "required": [
              "targets"
            ],
            "properties": {
              "mode": {
                "enum": [
                  "mix",
                  "single"
                ],
                "type": "string",
                "default": "mix",
                "description": "`mix` (the page's default: mixing explosives on a piece when that saves sulfur) or `single` (one explosive per piece)."
              },
              "targets": {
                "type": "string",
                "examples": [
                  "stone-wall:2,sheet-metal-wall:1"
                ],
                "maxLength": 2000,
                "minLength": 1,
                "description": "Comma-separated `slug:count` building pieces (slugs from /building, or display names)."
              },
              "explosives": {
                "type": "string",
                "default": "staples",
                "description": "`staples` (rockets, C4, satchels, explosive ammo, beancans), `all`, or a comma list of explosive shortnames."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_upkeep",
          "title": "Daily upkeep for a base",
          "description": "[Calculators] Daily upkeep for a base. The upkeep calculator page's math: the block count walks Rust's default upkeep brackets to a blended daily\nrate, and each resource's daily upkeep is what was spent building times that rate (`per_week` = 7 days).",
          "inputSchema": {
            "type": "object",
            "required": [
              "blocks"
            ],
            "properties": {
              "wood": {
                "type": "number",
                "default": 0,
                "minimum": 0,
                "description": "Total wood spent building the base."
              },
              "stone": {
                "type": "number",
                "default": 0,
                "minimum": 0,
                "description": "Total stone spent."
              },
              "blocks": {
                "type": "integer",
                "maximum": 100000,
                "minimum": 1,
                "description": "Number of building blocks (foundations, walls, floors... each counts one)."
              },
              "metal_fragments": {
                "type": "number",
                "default": 0,
                "minimum": 0,
                "description": "Total metal fragments spent."
              },
              "high_quality_metal": {
                "type": "number",
                "default": 0,
                "minimum": 0,
                "description": "Total high quality metal spent."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "genetics_best_layout",
          "title": "Best crossbreeding layout from a pool of plant clones",
          "description": "[Calculators] Best crossbreeding layout from a pool of plant clones. The gene calculator's beam search, ported exactly: which clones to plant around the centre, how many of each,\nand what the centre will most likely become (with every outcome's chance). Uses the game's gene weights (red\nW/X 1.0, green G/Y/H 0.6).",
          "inputSchema": {
            "type": "object",
            "required": [
              "clones"
            ],
            "properties": {
              "centre": {
                "type": "string",
                "description": "Optional genes of the plant in the centre slot (default: unknown)."
              },
              "clones": {
                "type": "string",
                "examples": [
                  "GGYYHX,GYYHWW,YYGGXH"
                ],
                "maxLength": 400,
                "minLength": 6,
                "description": "Comma-separated 6-letter gene strings of the clones you have (G Y H W X)."
              },
              "target": {
                "type": "string",
                "description": "Optional 6-letter target such as GGGGYY; default: as many G and Y as possible."
              },
              "max_neighbours": {
                "type": "integer",
                "default": 8,
                "maximum": 8,
                "minimum": 1,
                "description": "Most neighbouring plants to use (a planter grid allows 8)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "genetics_predict",
          "title": "What a plant will grow into from its neighbours",
          "description": "[Calculators] What a plant will grow into from its neighbours. Every possible result for the centre plant with its probability, most likely first.",
          "inputSchema": {
            "type": "object",
            "required": [
              "neighbours"
            ],
            "properties": {
              "centre": {
                "type": "string",
                "description": "Genes of the centre plant, if known."
              },
              "neighbours": {
                "type": "string",
                "examples": [
                  "GGYYHX,GGYYHX,YYGGXH"
                ],
                "maxLength": 200,
                "minLength": 6,
                "description": "Comma-separated 6-letter gene strings of the neighbouring plants."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "resolve_steam_profile",
          "title": "Resolve a profile URL or vanity name to a SteamID64",
          "description": "[Players] Resolve a profile URL or vanity name to a SteamID64. Turns any of the accepted identifier forms into a 17-digit SteamID64. Does not fetch the profile. Turn a steamcommunity.com/id/... or /profiles/... link, or a custom URL name, into the SteamID64 the inventory and player tools need.",
          "inputSchema": {
            "type": "object",
            "required": [
              "q"
            ],
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "https://steamcommunity.com/id/willjum"
                ],
                "maxLength": 200,
                "minLength": 1,
                "description": "A steamcommunity.com profile URL, a custom URL name, or a SteamID64."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_player_stats",
          "title": "Player profile, Rust stats and achievements",
          "description": "[Players] Player profile, Rust stats and achievements. Profile summary (name, avatar, country, Steam level, account age), VAC/game bans, Rust playtime, every Rust\nstat Steam exposes grouped into Combat / Animals & NPCs / How you died / Gathering & loot / Building / Travel /\nLife on the island / Fishing / Music / Everything else, six headline figures (kills, deaths, K/D, headshots,\nbullet and arrow accuracy), and all 116 achievements with unlock dates. `stats_private` is true when the\nprofile hides game details, in which case `groups` and `achievements` are empty.",
          "inputSchema": {
            "type": "object",
            "required": [
              "steamid"
            ],
            "properties": {
              "steamid": {
                "type": "string",
                "examples": [
                  "76561199126382502"
                ],
                "description": "17-digit SteamID64. Use /players/resolve for URLs and vanity names."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_inventory_leaderboard",
          "title": "Most valuable inventories ever checked",
          "description": "[Inventory] Most valuable inventories ever checked. The rust.wiki/inventory leaderboard: every inventory anyone has looked up, ranked by total value at its\nlast check (values are re-priced each time an inventory is viewed or by the daily warmer for the top 20). Includes\nthe network-wide totals. 20 per page. No key needed.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page; 20 inventories per page."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_inventory",
          "title": "Value a Steam account's Rust skins",
          "description": "[Inventory] Value a Steam account's Rust skins. Every Rust skin the account holds with `quantity`, unit `price` and `value` (cents), sorted by value, and the\nsame attributes /skins filters on (`collection`, `creator`, `item_shortname`, `item_name`, `est_supply`,\n`released_year`, `colors`, and `flags`: limited_time, permanent, marketable, tradable, breakable, glows,\ncommodity, drop), plus\n`total_value`, `item_count`, `distinct_skins`, a `categories` breakdown with share percentages, the owner's\ndisplay name and avatar, and `value_history` (the current holdings re-priced at each of the last 365 days, in USD\nDOLLARS, not cents, at each day's Steam sale price - so its latest point can be below `total_value`, which is at\ncurrent asking prices).\n`found` is false for private or empty inventories; `stale` is true when Steam was unreachable and the last\nstored snapshot was re-priced instead. Takes a 17-digit SteamID64 (use resolve_steam_profile for a profile URL or custom name); the inventory must be public. Served from the stored copy when the inventory was checked in the last 24 hours, otherwise read live from Steam. No key needed: keyless clients share a daily inventory cap; send your own free key (https://rust.wiki/api-keys) as X-API-Key for a private quota.",
          "inputSchema": {
            "type": "object",
            "required": [
              "steamid"
            ],
            "properties": {
              "steamid": {
                "type": "string",
                "examples": [
                  "76561198869732295"
                ],
                "description": "17-digit SteamID64 (resolve URLs and vanity names with /players/resolve)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_inventory_value_history",
          "title": "Inventory value over time",
          "description": "[Inventory] Inventory value over time. The inventory's value over time: the account's current holdings re-priced at each day's Steam SALE price\n(median sale), `values` in USD cents, oldest first - the line on the rust.wiki inventory chart. It shows how the\nmarket moved, not when items were bought. `headline_total_value` is the total at current Steam ASKING prices\n(lowest sell order) as of `headline_checked_at`, the number shown at the top of the inventory page; for thinly\ntraded skins it can sit well above the latest point here. Only inventories that have been looked up have a\nseries. Read from stored data: never a live Steam call. No key needed. Use this for the value-over-time graph's data points (any range, daily/weekly/monthly); get_inventory only carries a thinned one-year series. Look the inventory up with get_inventory first if it returns found=false.",
          "inputSchema": {
            "type": "object",
            "required": [
              "steamid"
            ],
            "properties": {
              "range": {
                "type": "string",
                "default": "1y",
                "description": "7d, 30d, 90d, 1y, 2y, 3y, 4y, 5y, all, or custom (with start_date/end_date)."
              },
              "steamid": {
                "type": "string",
                "examples": [
                  "76561198869732295"
                ],
                "description": "17-digit SteamID64."
              },
              "end_date": {
                "type": "string",
                "description": "YYYY-MM-DD, with range=custom."
              },
              "interval": {
                "type": "string",
                "default": "auto",
                "description": "daily, weekly, monthly, or auto (daily up to 400 points, then weekly, then monthly past 400 weeks)."
              },
              "start_date": {
                "type": "string",
                "description": "YYYY-MM-DD, with range=custom."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_inventory_valuation",
          "title": "What an inventory is realistically worth",
          "description": "[Inventory] What an inventory is realistically worth. The inventory valued three ways, plus what selling would actually raise. `at_asks` is the headline number\n(each skin at its cheapest Steam listing, falling back to the best buy order); `at_bids` is every skin at its\nbest buy order; `at_recent_sales` is every skin at its latest Steam median sale price (the inventory chart's\nbasis). `sell_now` walks each skin's real buy-order ladder for the quantity held: `units_sellable` of\n`units_held` could be sold instantly for `gross` (what buyers pay) and `net_after_fees` (after Steam's 15%).\n`biggest_ask_gaps` lists the skins whose cheapest listing sits furthest above their recent sales - thin order\nbooks where the headline is least reliable. All cents. Uses the stored holdings (the last lookup) and current\norder books: never a live Steam call; look the inventory up first if `found` is false. No key needed. Use when asked what an inventory is REALLY worth or would sell for: asks vs bids vs recent sales, and instant-sell proceeds after Steam's 15% fee.",
          "inputSchema": {
            "type": "object",
            "required": [
              "steamid"
            ],
            "properties": {
              "steamid": {
                "type": "string",
                "examples": [
                  "76561198869732295"
                ],
                "description": "17-digit SteamID64."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_inventory_snapshots",
          "title": "Dates with a saved daily snapshot",
          "description": "[Inventory] Dates with a saved daily snapshot. Every date (newest first, up to 400) on which a daily snapshot of this inventory was stored, plus `totals`:\neach of those days' total value in cents (that day's holdings at that day's prices). Snapshots are written when\nan inventory is looked up; fetch one with /inventory/{steamid}/snapshots/{date}. No key needed. Only inventories someone has looked up have snapshots. `totals` gives each saved day's total value (that day's holdings at that day's prices).",
          "inputSchema": {
            "type": "object",
            "required": [
              "steamid"
            ],
            "properties": {
              "steamid": {
                "type": "string",
                "examples": [
                  "76561198869732295"
                ],
                "description": "17-digit SteamID64."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_inventory_snapshot",
          "title": "One saved daily snapshot",
          "description": "[Inventory] One saved daily snapshot. The inventory exactly as it was priced on that day: items with quantity and that day's price, total value and\nitem count. Useful for 'what was this worth last month' comparisons. No key needed.",
          "inputSchema": {
            "type": "object",
            "required": [
              "steamid",
              "date"
            ],
            "properties": {
              "date": {
                "type": "string",
                "examples": [
                  "2026-09-30"
                ],
                "description": "ISO date (YYYY-MM-DD) from /inventory/{steamid}/snapshots."
              },
              "steamid": {
                "type": "string",
                "examples": [
                  "76561198869732295"
                ],
                "description": "17-digit SteamID64."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "check_premium_access",
          "title": "Does this account likely have Rust Premium Access? (estimate)",
          "description": "[Inventory] Does this account likely have Rust Premium Access? (estimate). Premium servers (`server.premium true`) only admit accounts Facepunch marks premium: an inventory worth at least\n`required_value` (1500 = $15, the game's own text). This values the account's Rust skins at the wiki price (Steam\nlowest sell order) and compares. `qualifies_estimate` is true/false (null when the inventory is private or empty);\n`status` is likely, borderline_above, borderline_below, unlikely or unknown - values within $12-$18 are borderline\nbecause Facepunch's prices are unknown. `shortfall` is the cents still needed; `suggestions.one_skin` are the cheapest\nliquid skins that close it alone, `suggestions.cheapest` the cheapest liquid skins overall (`suggestions.updating` true:\nthe hourly list is being rebuilt, both lists empty - ask again later). An ESTIMATE: Facepunch\ndoesn't publish its valuation. Same lookup and caching as /inventory/{steamid} (stored copy for 24 h). Use for 'can I join Premium servers' / 'do I have Premium Access': values the account's Rust skins against the $15 minimum. It is an ESTIMATE - say so; Facepunch's valuation is unknown. Takes a SteamID64 (resolve_steam_profile first). Same stored lookup as get_inventory. Link page.",
          "inputSchema": {
            "type": "object",
            "required": [
              "steamid"
            ],
            "properties": {
              "steamid": {
                "type": "string",
                "examples": [
                  "76561198869732295"
                ],
                "description": "17-digit SteamID64 (resolve URLs and vanity names with /players/resolve)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_game_modes",
          "title": "Rust game modes compared (Vanilla, Softcore, Hardcore, Primitive) and the Era system",
          "description": "[Game reference] Rust game modes compared (Vanilla, Softcore, Hardcore, Primitive) and the Era system. `compare`: rule-by-rule table (`values` in the order of `modes`: vanilla, softcore, hardcore, primitive; only rules\nthat differ). `modes`: each mode's own added/removed/changed feature text from the game, the ConVars it sets (`value`\nvs `default`, with `help`), and its tech tree per workbench. `hardcore_items`: the 37 items Hardcore restricts with\n`how` (Loot only = can't be crafted, researched or bought; Not sold; Removed) and `allowed` sources. `eras`: server.era\nvalues and the items tagged with each era (a server set to an era can't loot, craft or buy items of a later era).\n`recipe_overrides`, `era_vending`, `era_missions`, `era_loot`: what Primitive changes. `test_modes`: round-based modes\nin the files that no normal server runs. With `item=`: `{item, name, hardcore, era, primitive_recipe}` (null parts\ndon't apply). Use mode=hardcore etc. for one mode's differences from vanilla, item=<shortname> for an item's Hardcore/era status. Link https://rust.wiki/game-modes.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "item": {
                "type": "string",
                "examples": [
                  "rifle.ak"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "An item shortname: just that item's Hardcore and era status."
              },
              "mode": {
                "type": "string",
                "pattern": "^(vanilla|softcore|hardcore|primitive)$",
                "examples": [
                  "hardcore"
                ],
                "description": "Only this mode's rules."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_weapon_stats",
          "title": "Every weapon's damage, DPS, fire rate, magazine, reload and range",
          "description": "[Game reference] Every weapon's damage, DPS, fire rate, magazine, reload and range. The data behind https://rust.wiki/weapons: every gun, bow, launcher and main melee weapon with `damage` per\nbullet/pellet (standard ammo), `pellets` (shotguns), `hit` (damage x pellets), raw `dps` (hit x `rpm` / 60 -\nignores reloads, recoil, armour and falloff), `magazine`, `reload_s`, `range_m` (damage falloff start-end) /\n`range_end`, `ammo`, `workbench` (level to craft; null = loot only, 0 = no bench) and `notes`. Checked against\nFacepunch's wiki and patch notes (`sources`, `verified`); Facepunch rebalances weapons often.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "sort": {
                "enum": [
                  "dps",
                  "hit",
                  "damage",
                  "rpm",
                  "magazine",
                  "reload_s",
                  "range_end",
                  "name"
                ],
                "type": "string",
                "default": "dps",
                "description": "Sort key: highest first, except `name` and `reload_s` (lowest first)."
              },
              "search": {
                "type": "string",
                "examples": [
                  "rifle"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Case-insensitive match on the weapon name."
              },
              "category": {
                "enum": [
                  "Rifle",
                  "Machine gun",
                  "SMG",
                  "Pistol",
                  "Sniper",
                  "Shotgun",
                  "Bow",
                  "Other",
                  "Launcher",
                  "Melee"
                ],
                "type": "string",
                "description": "Restrict to one weapon type."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_tea_recipes",
          "title": "Every tea recipe: berries, Mixing Table slot order, buff and duration",
          "description": "[Game reference] Every tea recipe: berries, Mixing Table slot order, buff and duration. The data behind https://rust.wiki/teas. Each tea has `name`, `shortname`, `tier` (Basic, Advanced, Pure),\n`ingredients` (`item`, `qty`, `shortname`), `slot_order` / `slots` (the Mixing Table order for Basic teas -\norder matters: Scrap and Warming Tea use the same berries), `effect`, `duration_minutes` and `note` (Advanced\nand Pure values predate Rust's 5 Nov 2026 tea nerf). `notes` covers stacking and mixing rules. Sourced from\nFacepunch's wiki and devblogs (`sources`, `verified`).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "search": {
                "type": "string",
                "examples": [
                  "ore"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Case-insensitive match on the tea's name or effect."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_best_defences",
          "title": "Doors, walls and deployables ranked by sulfur to raid vs build cost",
          "description": "[Game reference] Doors, walls and deployables ranked by sulfur to raid vs build cost. The data behind https://rust.wiki/building/best-value. `doors`, `walls` (walls, foundations and floors at\nevery grade) and `other` (raidable deployables), each hardest to raid first. Every row has `slug`, `name`,\n`health`, `raid` - the cheapest single standard explosive (rockets, C4, satchel charges, explosive 5.56 ammo,\nbeancans) as `explosive` (shortname), `count` and `sulfur` - and `build`, resource name -> amount (a building\nblock's upgrade cost at its grade, a door's or deployable's crafting recipe). Building blocks add `grade` and\n`type`; doors and deployables add `shortname`, `icon_url` and `url`. `explosives` names the shortnames. Raid\ndata cached for 24 hours.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_base_cost",
          "title": "Build cost, daily upkeep and raid cost of a base",
          "description": "[Calculators] Build cost, daily upkeep and raid cost of a base. The base cost calculator page's math (https://rust.wiki/calculators/base). `build_cost` is the total\nresources (a block's upgrade cost at its grade, a door's crafting recipe); `upkeep` is the tool cupboard's\ndaily and weekly cost on the building blocks at Rust's default brackets (the same result as\n/calculators/upkeep/compute); `raid_path` gives each layer's cheapest standard explosive and the total sulfur\nto reach the loot. `unknown` lists inputs that matched nothing.",
          "inputSchema": {
            "type": "object",
            "required": [
              "pieces"
            ],
            "properties": {
              "pieces": {
                "type": "string",
                "examples": [
                  "stone-foundation:4,stone-wall:7,stone-wall-doorway:1,stone-floor:4,door.hinged.metal:1"
                ],
                "maxLength": 2000,
                "minLength": 1,
                "description": "Comma-separated `slug:count` pieces: building blocks by grade slug from /building (`stone-wall`, `metal-foundation`...) and doors or deployables by slug or item shortname (`door.hinged.metal`). Display names work too."
              },
              "raid_path": {
                "type": "string",
                "examples": [
                  "door.hinged.metal,stone-wall"
                ],
                "maxLength": 2000,
                "description": "Optional: the layers a raider breaks through from outside to the loot, in order, same naming as `pieces` (`:n` repeats a layer)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_electricity_data",
          "title": "Electricity data: every component's power draw, sources and batteries",
          "description": "[Calculators] Electricity data: every component's power draw, sources and batteries. The data behind https://rust.wiki/calculators/electricity. `consumers` and `logic` list every powered\ncomponent with `shortname`, `name`, `draw` (power it needs to run) and `note`; logic parts (switches, gates,\ntimers, splitters, branches...) have drawn 0 since April 2024. `sources` are the generators (`max` = best-case\noutput, `sizing` says what that assumes) and `batteries` give `capacity` (rWm) and `max_output` (rW).\n`mechanics` explains how Rust power flows; `verified` is when the numbers were last checked and\n`sources_cited` where. Fixed data, re-checked after Facepunch balance patches.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_power",
          "title": "Power draw of a set of components, and what runs it",
          "description": "[Calculators] Power draw of a set of components, and what runs it. The electricity calculator page's math. `total_draw` is the summed power; `supply` says how many of each\npower source covers it at its best output (`needed`); `batteries` gives each battery's `runtime_minutes` on a\nfull charge, or `enough_output: false` when the load is above what that battery can deliver.",
          "inputSchema": {
            "type": "object",
            "required": [
              "components"
            ],
            "properties": {
              "components": {
                "type": "string",
                "examples": [
                  "autoturret:4,samsite:1,electric.heater:2"
                ],
                "maxLength": 2000,
                "minLength": 1,
                "description": "Comma-separated `shortname:quantity` pairs (display names work too; quantity defaults to 1). Components by shortname or name from /calculators/electricity."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_smelting",
          "title": "Smelting time, wood burned and charcoal made",
          "description": "[Calculators] Smelting time, wood burned and charcoal made. The smelting calculator page's math: `time`/`seconds` to smelt everything, `outputs` (metal fragments,\nsulfur, HQM, low grade fuel), `wood_burned` and `charcoal_made` (about 0.75 per wood), `power_draw` for the\nelectric furnace, and `fits_one_fill` (false = you'll need to refill it). Ore a smelter can't process is\nlisted in `not_smeltable_here`. Server-default speeds; modded servers differ.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "count": {
                "type": "integer",
                "default": 1,
                "maximum": 100,
                "minimum": 1,
                "description": "How many of that smelter share the ore."
              },
              "hqm_ore": {
                "type": "number",
                "default": 0,
                "maximum": 10000000,
                "minimum": 0,
                "description": "High quality metal ore to smelt."
              },
              "smelter": {
                "enum": [
                  "furnace",
                  "furnace.large",
                  "electric.furnace",
                  "small.oil.refinery",
                  "bbq",
                  "campfire",
                  "fireplace.stone",
                  "hobobarrel",
                  "skull_fire_pit",
                  "cursedcauldron"
                ],
                "type": "string",
                "default": "furnace.large",
                "description": "Which smelter (item shortname)."
              },
              "crude_oil": {
                "type": "number",
                "default": 0,
                "maximum": 10000000,
                "minimum": 0,
                "description": "Crude oil to refine (small oil refinery only)."
              },
              "metal_ore": {
                "type": "number",
                "default": 0,
                "maximum": 10000000,
                "minimum": 0,
                "description": "Metal ore to smelt."
              },
              "sulfur_ore": {
                "type": "number",
                "default": 0,
                "maximum": 10000000,
                "minimum": 0,
                "description": "Sulfur ore to smelt."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_player_leaderboard",
          "title": "Rust player leaderboard: most kills, best K/D, hours and more",
          "description": "[Players] Rust player leaderboard: most kills, best K/D, hours and more. The leaderboard on https://rust.wiki/players: Rust players ranked by their official Steam stats.\nBoards: `kills`, `kd` (min 1,000 kills), `headshots` (headshots on anything), `hours` (public playtime only),\n`accuracy` (bullets that hit a player / fired, min 20,000 fired), `scientists`, `animals`, `gathered` (wood +\nstone + metal ore + sulfur ore), `building` (blocks placed), `rockets`, `fish`, `deaths`. Each result has\n`rank`, `steamid`, `name`, `avatar`, `country`, `value` / `value_text`, `kills`, `deaths`, `kd`, `hours` and\n`updated` (the date its stats were last read from Steam). Players are added when looked up on Player Stats or\nwhen their inventory is checked on rust.wiki, refreshed about weekly; only public game details are ranked and\naccounts with VAC or game bans never are. `total` is how many players qualify for the board.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "maximum": 100,
                "minimum": 1
              },
              "board": {
                "enum": [
                  "kills",
                  "kd",
                  "headshots",
                  "hours",
                  "accuracy",
                  "scientists",
                  "animals",
                  "gathered",
                  "building",
                  "rockets",
                  "fish",
                  "deaths"
                ],
                "type": "string",
                "default": "kills",
                "description": "Which leaderboard."
              },
              "country": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}$",
                "examples": [
                  "GB"
                ],
                "description": "Two-letter country code (Steam profile country)."
              },
              "per_page": {
                "type": "integer",
                "default": 20,
                "maximum": 100,
                "minimum": 1
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "skinlab_list_items",
          "title": "Items and skins you can view on the 3D player model (Skin Lab)",
          "description": "[Skin Lab] Items and skins you can view on the 3D player model (Skin Lab). Every item Skin Lab has a 3D model for (clothing, armour, guns and tools, deployables, building skins,\nvehicles), in viewer order. Each row has `shortname`, `name`, `slot` / `slot_name` (where the viewer puts it),\n`group`, `worn` (false = stood beside the player rather than worn), `female_model`, `takes_attachments`,\n`skins_in_3d` (accepted Workshop and built-in skins with 3D textures), `cheapest_skin` / `priciest_skin` (Steam\nlowest listing, USD cents), `viewer_url` (the item in its default look) and the wiki `page`. More skins are added\nas they're processed. Skin Lab is rust.wiki's 3D try-on viewer for Rust skins. Use this to see which items and slots it covers; give the user the viewer_url so they can open it.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "slot": {
                "type": "string",
                "description": "Viewer slot: head, face, eyewear, shirt, jacket, chest-armour, gloves, pants, leg-armour, shoes, back, weapon, deployable, building, vehicle (or its number)."
              },
              "group": {
                "type": "string",
                "description": "`clothing`, `weapon`, `deployable`, `building`, `vehicle` or `misc`."
              },
              "search": {
                "type": "string",
                "examples": [
                  "hoodie"
                ],
                "maxLength": 80,
                "minLength": 2,
                "description": "Case-insensitive match on the item's name or shortname."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "with_skins": {
                "type": "integer",
                "default": 0,
                "maximum": 50,
                "minimum": 0,
                "description": "Also list each item's N most expensive 3D skins (0 = counts only)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "skinlab_get_item",
          "title": "One Skin Lab item with every skin it can be viewed in, in 3D",
          "description": "[Skin Lab] One Skin Lab item with every skin it can be viewed in, in 3D. The item as in /skin-lab/items plus `skins`: every skin with 3D textures, most expensive first, each with\n`itemdefid`, `name`, `price` (USD cents, Steam lowest listing; null = not on the market), `icon`, its own\n`viewer_url` and wiki `page`. Guns also carry `attachments` (what they accept - see /skin-lab/attachments). Every skin of one item that can be viewed in 3D, each with its own viewer_url and price (USD cents).",
          "inputSchema": {
            "type": "object",
            "required": [
              "shortname"
            ],
            "properties": {
              "shortname": {
                "type": "string",
                "examples": [
                  "hoodie"
                ],
                "description": "Item shortname (or its name)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "skinlab_link",
          "title": "A Skin Lab 3D viewer link for one item or skin",
          "description": "[Skin Lab] A Skin Lab 3D viewer link for one item or skin. Answers \"can I see this skin in 3D?\". With a known item and a processed skin: `available_in_3d: true`, the\n`viewer_url` that opens rust.wiki/skin-lab with it on, and `embed` ({o, mode} - the same piece the \"View in 3D\"\ncard on the item and skin pages loads). A real skin that has no 3D textures yet gives `available_in_3d: false`\nwith the reason and a `fallback_url` showing the item's default look. Unknown items are 404 with suggestions. Use when someone asks to SEE a skin or item: returns a rust.wiki/skin-lab link that opens it in 3D (available_in_3d=false says why not, with a fallback link). Share viewer_url with the user.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "item": {
                "type": "string",
                "examples": [
                  "metal.facemask"
                ],
                "maxLength": 80,
                "description": "Item shortname or name. Optional when `skin` is an itemdefid."
              },
              "mode": {
                "type": "string",
                "pattern": "^(outfit|weapon|pov)$",
                "description": "`outfit` (on the player), `weapon` (the item on its own) or `pov` (first person, guns and tools). Default: `outfit` for worn items, `weapon` otherwise."
              },
              "skin": {
                "type": "string",
                "examples": [
                  "20082"
                ],
                "maxLength": 120,
                "description": "Skin itemdefid or name (default look when left out)."
              },
              "attachments": {
                "type": "string",
                "maxLength": 400,
                "description": "Guns only: comma-separated attachment shortnames, e.g. `weapon.mod.holosight,weapon.mod.silencer`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "skinlab_build_outfit",
          "title": "Build and check a Skin Lab outfit: wear-rule clashes, attachments, total price and the 3D link",
          "description": "[Skin Lab] Build and check a Skin Lab outfit: wear-rule clashes, attachments, total price and the 3D link. Puts the pieces on in order, the way the viewer and the game do. Pieces that can't be worn together (the\ngame's own wear rules: two pieces clash when they occupy the same under-layer or over-layer body area - a\nCoffee Can Helmet and a Metal Facemask both cover the head) are reported in `clashes` with the piece they\nconflict with and why; the first piece wins and the later one is left out of the link, exactly as the viewer\nwould; a second piece for a viewer slot that's already filled is a clash too. `invalid_attachments` lists\nattachments a gun doesn't accept or that fight for the same attachment slot; `errors` lists pieces that\ncouldn't be resolved (unknown item, or a skin that isn't in 3D yet). `slots` is the\nnormalised outfit (slot, item, skin, price), `total_price` the sum of the chosen skins' Steam lowest listings\nin USD cents (default looks cost nothing; `unpriced` counts skins with no listing), `valid` is true when\nnothing was dropped, and `viewer_url` opens the outfit in rust.wiki/skin-lab. Use to put together or check a whole Rust outfit (e.g. 'hoodie with the Tempered skin, metal facemask, AK with a holosight'): it applies the game's wear rules, flags pieces that can't be worn together and why, checks gun attachments, totals the skins' Steam price, and returns a viewer_url showing the outfit in 3D. Find skin itemdefids with search_skins or skinlab_get_item.",
          "inputSchema": {
            "type": "object",
            "required": [
              "pieces"
            ],
            "properties": {
              "body": {
                "type": "string",
                "default": "male",
                "pattern": "^(male|female)$",
                "description": "Body model."
              },
              "face": {
                "type": "string",
                "maxLength": 40,
                "description": "Face (head) name for that body, e.g. `Frank` - list in the error when wrong."
              },
              "mode": {
                "type": "string",
                "default": "outfit",
                "pattern": "^(outfit|weapon|pov)$",
                "description": "Viewer mode for the link: `outfit`, `weapon` (the first piece on its own) or `pov` (first person; needs a gun or tool)."
              },
              "pose": {
                "type": "string",
                "maxLength": 40,
                "description": "Pose key, e.g. `idle`, `wave`, `crouch`, `rifle_aim`, `walk` (default `auto`). Invalid keys are listed in the error."
              },
              "pieces": {
                "type": "string",
                "examples": [
                  "metal.facemask:20082,hoodie:43105,pants,shoes.boots,rifle.ak:22003:weapon.mod.holosight~weapon.mod.silencer"
                ],
                "maxLength": 2000,
                "minLength": 2,
                "description": "Comma-separated pieces, each `item[:skin[:attachment~attachment]]` - item by shortname or name, skin by itemdefid or name (left out or 0 = default look), attachments for guns. A bare number is a skin itemdefid. Up to 15 pieces, one per viewer slot."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "skinlab_render_outfit",
          "title": "Render a Skin Lab outfit, gun or item as an image (WebP/PNG)",
          "description": "[Skin Lab] Render a Skin Lab outfit, gun or item as an image (WebP/PNG). Returns `{status: \"done\", url, cached, width, height, format}` with a permanent image URL (same request = same\nURL; images are cached), plus `outfit` (the normalised pieces, their Steam prices and `total_price` in USD cents,\nand any clashes / invalid attachments dropped exactly as /skin-lab/outfit reports them), `viewer_url` (the same\noutfit in the interactive 3D viewer) and `render_quota`. A render that takes longer than `wait` seconds answers\n**202** `{status: \"queued\", position, retry_after}` - call again with the same parameters (no extra quota) after\n`Retry-After` seconds. 429 when the render queue is full or a quota is used up. New images count against a\nseparate render quota (100 per key per UTC day); cached images don't. Use when someone wants to SEE an outfit, skin, gun or item: returns the rendered image inline (you can look at it and show it) plus a permanent image URL, the interactive 3D viewer link, the outfit's pieces and total Steam price. `pieces` uses the same format as skinlab_build_outfit (find skins with search_skins / skinlab_get_item); a gun with attachments in item view = mode `weapon`. Rendering a new image takes a few seconds; if it says pending, call again with the same arguments. Keyless use shares a small daily render budget.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "yaw": {
                "type": "integer",
                "default": 0,
                "maximum": 180,
                "minimum": -180,
                "description": "Turn the character/item, degrees."
              },
              "body": {
                "type": "string",
                "default": "male",
                "pattern": "^(male|female)$",
                "description": "Body model."
              },
              "face": {
                "type": "string",
                "maxLength": 40,
                "description": "Face (head) name for that body, e.g. `Frank` (default: the first face)."
              },
              "mode": {
                "type": "string",
                "default": "outfit",
                "pattern": "^(outfit|weapon|pov)$",
                "description": "`outfit` (on the player), `weapon` (the FIRST piece on its own - guns, tools, deployables) or `pov` (first person; needs a gun or tool)."
              },
              "pose": {
                "type": "string",
                "maxLength": 40,
                "description": "Pose key, e.g. `idle`, `wave`, `crouch`, `rifle_aim` (default `auto`). Moving poses are shown frozen."
              },
              "zoom": {
                "type": "number",
                "default": 1,
                "maximum": 2.5,
                "minimum": 0.4,
                "description": "Camera zoom (1 = the viewer's framing)."
              },
              "light": {
                "type": "string",
                "default": "studio",
                "description": "Lighting: studio, day, golden, overcast, dusk, night. `studio` on an in-game scene = that scene's own daylight."
              },
              "width": {
                "type": "integer",
                "default": 768,
                "maximum": 1024,
                "minimum": 256,
                "description": "Image width, px."
              },
              "format": {
                "type": "string",
                "default": "webp",
                "pattern": "^(webp|png)$",
                "description": "`webp` (small) or `png`."
              },
              "height": {
                "type": "integer",
                "default": 768,
                "maximum": 1024,
                "minimum": 256,
                "description": "Image height, px."
              },
              "pieces": {
                "type": "string",
                "examples": [
                  "hoodie:43105,pants,shoes.boots,metal.facemask:20082"
                ],
                "maxLength": 2000,
                "description": "The outfit, exactly as for /skin-lab/outfit: comma-separated `item[:skin[:attachment~attachment]]` (item by shortname or name, skin by itemdefid or name, attachments for guns; a bare number is a skin itemdefid). Left out = the viewer's starter outfit."
              },
              "weather": {
                "type": "string",
                "default": "auto",
                "description": "In-game scenes only: auto, off, clear, cloudy, fog, rain, storm, snow."
              },
              "background": {
                "type": "string",
                "default": "studio",
                "description": "`studio`, `dark`, `light`, `sky`, `sunset`, or an in-game scene: plains, forest, arctic, desert, beach, set_base, set_garage, set_compound, set_monument, set_launch, set_market, set_military, set_dock, set_coast."
              },
              "transparent": {
                "type": "boolean",
                "default": false,
                "description": "Transparent backdrop (studio-type backgrounds only; the floor disc stays)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "skinlab_creator_info",
          "title": "Workshop skin making for one item: texture groups, max texture size, maps, UV previews",
          "description": "[Skin Lab] Workshop skin making for one item: texture groups, max texture size, maps, UV previews. For Steam Workshop skin makers, from the game's own files. `texture_groups`: each material group the in-game\neditor shows as a tab, with `max_texture_size` (px, square; bigger images are scaled down to it), `covers` (the\nmesh parts it textures), `workflow` (`specular` or `metallic`), `alpha_cutout` (the diffuse alpha is a cut-out\nmask), `texture_maps` (the editor's slots for that material: `slot` property name, `name`, what to paint) and a\n`uv_preview_url` (UV wireframe image, 1024 px) with `uv_coverage` (share of the texture used). Plus\n`max_texture_size` over all groups, `open_for_workshop` (false = the editor doesn't list the item), `editor` (how to\nopen it), `notes` and Facepunch's `docs`. The .obj templates themselves come from the editor's Download button. Use for Workshop skin MAKING questions (e.g. 'what texture size can I use for an AK skin', 'which maps does the hoodie take'): the item's material groups with max texture size, the mesh parts each covers, specular vs metallic workflow, the in-game editor's texture slots and a UV layout preview image, from the game files.",
          "inputSchema": {
            "type": "object",
            "required": [
              "shortname"
            ],
            "properties": {
              "shortname": {
                "type": "string",
                "examples": [
                  "rifle.ak"
                ],
                "description": "Item shortname (or its name)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "weapon_attachments",
          "title": "Weapon attachments: what each gun accepts and what each attachment does",
          "description": "[Skin Lab] Weapon attachments: what each gun accepts and what each attachment does. From the game's own attachment data (as Skin Lab uses it). Each attachment has `shortname`, `name`, `slot`\n(`muzzle`, `sight`, `underbarrel`, `magazine`, `internal`, `targeting` - one attachment per slot), `description`,\n`effects` (readable: `damage x0.75` = 25% less damage, `aimcone_hip +2` = wider hip-fire spread) and the raw\n`stats` multipliers (`scalar`) and additions (`offset`). With `weapon`: that gun's `slots` and `accepts` (the\nattachments that fit it). Without: every gun's accepted list plus every attachment. Which attachments a Rust gun takes and what each does (damage, recoil, zoom...).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "weapon": {
                "type": "string",
                "examples": [
                  "rifle.ak"
                ],
                "maxLength": 80,
                "description": "Gun shortname or name; left out = every gun and every attachment."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "simulate_loot_run",
          "title": "Expected loot from a run of crates, barrels and NPCs",
          "description": "[Calculators] Expected loot from a run of crates, barrels and NPCs. The loot simulator page's exact statistics (https://rust.wiki/calculators/loot-simulator): every item each\ncontainer can drop is rolled on its own chance, with an amount between the table's min and max. For the whole run,\neach item gets `expected_amount` (average total), `chance_at_least_one` and `best_chance_per_container`;\n`expected_item_stacks` is how many item stacks the run gives on average. Chances come from the game's loot tables\n(the /loot-tables data). To actually open crates with the game's own loot roll (seeded, shareable, with exact\nper-open chances), use /calculators/loot-simulator/open. Loot source names/ids come from list_loot_sources. To actually open crates with the game's own loot roll use simulate_crate_open.",
          "inputSchema": {
            "type": "object",
            "required": [
              "run"
            ],
            "properties": {
              "run": {
                "type": "string",
                "examples": [
                  "Elite Crate:3,Military Crate:5"
                ],
                "maxLength": 1000,
                "minLength": 1,
                "description": "Comma-separated `source:count` pairs - a loot source by id (from /loot-tables) or name - count defaults to 1, max 500 each."
              },
              "limit": {
                "type": "integer",
                "default": 100,
                "maximum": 500,
                "minimum": 1,
                "description": "Most items to return (by expected amount)."
              },
              "search": {
                "type": "string",
                "maxLength": 80,
                "minLength": 2,
                "description": "Only items whose name contains this."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "simulate_crate_open",
          "title": "Open a crate, barrel or NPC 1-1,000 times with the game's loot roll",
          "description": "[Calculators] Open a crate, barrel or NPC 1-1,000 times with the game's loot roll. Opens a Rust container with the loot roll ported from the game's server code (LootContainer.PopulateLoot ->\nLootSpawn.SpawnIntoContainer -> Item.MoveToContainer; data from the server files, vanilla settings) - the engine\nof https://rust.wiki/calculators/loot-simulator. Returns the haul: `items` totals (amount, how many opens had it,\naverage condition for items that spawn damaged), `scrap_value` (everything recycled at `recycler`, all the way\ndown, plus loot scrap), `lost_for_room` (loot destroyed because the container was full, as in game), the first\n`breakdown` opens one by one, and `chance_per_open`: every item's exact chance of at least one per open and its\naverage amount (`chance_basis` says when a container that can fill up was simulated instead). `page` opens the\nsame result on the site. A seed reproduces a result; it doesn't predict a real server. Opens a Rust crate, barrel or NPC body with the loot roll ported from the game's server code (seeded: same container, count and seed = same loot). Use for 'what do I get from N locked crates' or 'odds of an AK from an elite crate' (chance_per_open; chance_basis says whether it's exact). Give the user the page link: it shows the same haul. Container keys: locked-crate, elite-crate, military-crate, supply-drop, bradley-crate, heli-crate, blue-barrel, scientist, heavy-scientist, ...",
          "inputSchema": {
            "type": "object",
            "required": [
              "container"
            ],
            "properties": {
              "seed": {
                "type": "string",
                "examples": [
                  "abc123"
                ],
                "maxLength": 16,
                "description": "a-z0-9 seed; the same container, count and seed always give the same loot (here and on the page). Random if left out."
              },
              "count": {
                "type": "integer",
                "default": 1,
                "maximum": 1000,
                "minimum": 1,
                "examples": [
                  100
                ],
                "description": "How many to open (1-1,000)."
              },
              "chances": {
                "type": "integer",
                "default": 25,
                "maximum": 300,
                "minimum": 0,
                "description": "How many rows of the exact chance-per-open table to include."
              },
              "recycler": {
                "type": "string",
                "default": "recycler",
                "examples": [
                  "recycler"
                ],
                "description": "Recycler for scrap_value: recycler (monument, 50%), safe_zone (40%), powered (Power Plant grid stage 2+, 60%) or red (75%)."
              },
              "breakdown": {
                "type": "integer",
                "default": 5,
                "maximum": 50,
                "minimum": 0,
                "description": "How many of the opens to list one by one."
              },
              "container": {
                "type": "string",
                "examples": [
                  "locked-crate"
                ],
                "maxLength": 80,
                "minLength": 2,
                "description": "Container key or name, e.g. locked-crate, elite-crate, supply-drop, bradley-crate, heli-crate, military-crate, blue-barrel, scientist, heavy-scientist. A wrong name lists every key."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_player_count",
          "title": "Rust's player count: live on Steam, every monthly peak since 2013, by region",
          "description": "[Players] Rust's player count: live on Steam, every monthly peak since 2013, by region. The data behind https://rust.wiki/player-count. `live` is Steam's own count of everyone running Rust at the last\ncheck (`updated_at`); `months` is every monthly peak since 2013 as [YYYY-MM, peak] (from SteamCharts' public record\nof Steam's numbers); `record` the all-time monthly peak; `years` each year's peak; `this_month` and\n`same_month_last_year` for comparison; `breakdown` / `regions` split the players on the servers rust.wiki polls by\nregion and server type (null when the server poll has nothing). Server players are always fewer than Steam's figure:\nSteam also counts menus, queues and untracked servers.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "breed_animals",
          "title": "Sheep and cow breeding odds: genes, inbreeding, twins, wool/milk",
          "description": "[Calculators] Sheep and cow breeding odds: genes, inbreeding, twins, wool/milk. The animal breeder page's maths (https://rust.wiki/calculators/animal-breeder). Each gene has two copies and the\nanimal shows the better one; the young gets one random copy of each gene from each parent, so `young_odds` per\ngene is the chance it shows good / ok / bad. It also gets one random family mark from each parent and is inbred\nwhen they match (`chance_inbred`; null when marks weren't given). `chance_all_good_not_inbred`, `chance_twins`\n(needs a good-fertility mother) and `expected_product_per_hour` (wool or milk, inbreeding counted) follow. Gene\nnumbers come from fan tools that read the game files (`gene_confidence`).",
          "inputSchema": {
            "type": "object",
            "required": [
              "mother",
              "father"
            ],
            "properties": {
              "father": {
                "type": "string",
                "examples": [
                  "Y:good/ok,F:ok/ok"
                ],
                "maxLength": 200,
                "description": "Father's genes, same form."
              },
              "mother": {
                "type": "string",
                "examples": [
                  "D:good/ok,Y:good/good,F:good/bad,H:ok/ok"
                ],
                "maxLength": 200,
                "description": "Mother's genes: comma-separated `gene:copy/copy`, gene D (Dung), Y (Yield), F (Fertility) or H (Hardiness), copies good/ok/bad. Genes left out are ok/ok."
              },
              "species": {
                "type": "string",
                "default": "sheep",
                "pattern": "^(sheep|cow)$",
                "description": "`sheep` or `cow`."
              },
              "father_marks": {
                "type": "string",
                "maxLength": 10,
                "description": "Father's two family marks."
              },
              "mother_marks": {
                "type": "string",
                "maxLength": 10,
                "description": "Mother's two family marks (0-15), e.g. `3,7`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "plan_farm",
          "title": "Plant grow time, clones per cut, yield bonus and water use",
          "description": "[Calculators] Plant grow time, clones per cut, yield bonus and water use. The farm planner page's maths (https://rust.wiki/calculators/farm-planner): time to ripe = the plant's base time\n/ (1 + 25% per G), x1.5 unfertilized; `stages` splits it into Seed, Seedling, Sapling, Fruiting and Mature to ripe;\n`yield_bonus_pct` is +25% per Y; `clones_per_cut` adds one per two Y; water is per plant per tick, +10% per W.\nHarvests are relative (Facepunch publishes no base amounts). For the best gene layout use /calculators/genetics/best.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "count": {
                "type": "integer",
                "default": 1,
                "maximum": 200,
                "minimum": 1,
                "description": "How many planters."
              },
              "genes": {
                "type": "string",
                "default": "GGGYYY",
                "examples": [
                  "GGGYYY"
                ],
                "maxLength": 12,
                "description": "The clone's six genes from G, Y, H, W, X."
              },
              "plant": {
                "type": "string",
                "default": "hemp",
                "maxLength": 40,
                "description": "Crop: hemp, corn, pumpkin, potato, wheat, sunflower, rose, orchid, red_berry, blue_berry, green_berry, yellow_berry, white_berry, black_berry (or its name)."
              },
              "planter": {
                "type": "string",
                "default": "planter.large",
                "maxLength": 40,
                "description": "Planter: planter.large, planter.small, planter.triangle, bathtub.planter, minecart.planter, plantpot.single."
              },
              "fertilized": {
                "type": "boolean",
                "default": true,
                "description": "Ground condition 100% (fertilizer). Unfertilized takes about half as long again."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_damage_data",
          "title": "Damage calculator data: weapons, ammo, muzzle attachments, armour and suits",
          "description": "[Calculators] Damage calculator data: weapons, ammo, muzzle attachments, armour and suits. The data behind https://rust.wiki/calculators/damage: `weapons` (guns and bows whose ammo the model covers),\n`ammo` per ammo family as [name, damage multiplier, headshot multiplier, pellets override], `attachments`\n(muzzle damage multipliers), `armour` (projectile protection %, `slot` and `layer`: clothing goes under, armour\nover, dual takes both, single = hands/feet), `suits`, `zones` (hit areas and multipliers; `low` = low confidence),\n`presets`, `rules` and `caveats`.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_damage",
          "title": "Shots and time to kill through armour, per hit area",
          "description": "[Calculators] Shots and time to kill through armour, per hit area. The damage calculator page's maths (https://rust.wiki/calculators/damage). Damage per hit = weapon damage x ammo\nx attachment x hit-area multiplier x (1 - protection); protection of every piece covering the area is added (cap\n100%), +4% per metal insert. Per zone (head, chest, legs, hands, feet): `protection_pct`, `damage_per_hit`,\n`shots_to_kill` (null = never) and `time_to_kill_s` (fire rate plus reloads when the magazine runs out). Close\nrange only - no damage falloff; shotguns assume every pellet hits. Limb multipliers are low confidence.",
          "inputSchema": {
            "type": "object",
            "required": [
              "weapon"
            ],
            "properties": {
              "hp": {
                "type": "number",
                "default": 100,
                "maximum": 1000,
                "minimum": 1,
                "description": "Target health."
              },
              "ammo": {
                "type": "string",
                "examples": [
                  "HV 5.56 Rifle Ammo"
                ],
                "maxLength": 60,
                "description": "Ammo name for that weapon (default: its standard ammo)."
              },
              "suit": {
                "type": "string",
                "maxLength": 40,
                "description": "Full-body suit instead: hazmatsuit or bone.armor.suit."
              },
              "armour": {
                "type": "string",
                "examples": [
                  "metal.facemask,hoodie,metal.plate.torso,pants,roadsign.kilt,roadsign.gloves,shoes.boots"
                ],
                "maxLength": 600,
                "description": "Comma-separated armour and clothing the target wears (shortnames or names). Per slot: one clothing piece under one armour piece; dual pieces take both."
              },
              "weapon": {
                "type": "string",
                "examples": [
                  "rifle.ak"
                ],
                "maxLength": 60,
                "description": "Weapon shortname or name (guns and bows)."
              },
              "inserts": {
                "type": "string",
                "examples": [
                  "chest:2"
                ],
                "maxLength": 100,
                "description": "Metal armour inserts per slot, `slot:n` (head, chest, legs, hands, feet; 0-3)."
              },
              "attachment": {
                "type": "string",
                "maxLength": 40,
                "description": "Muzzle attachment: none, silencer, oilfilter, sodacan, muzzlebrake."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_bandit_camp_rules",
          "title": "Bandit Camp games' rules: Big Wheel, blackjack, poker and slots",
          "description": "[Calculators] Bandit Camp games' rules: Big Wheel, blackjack, poker and slots. The rules behind https://rust.wiki/calculators/big-wheel, /calculators/blackjack and /calculators/poker-odds:\nthe wheel's segments and payout, blackjack's table rules, poker's (no rake) and the slot machines' paytable. Each\nrule carries how sure it is (`confirmed` by Facepunch, `corroborated`, `unconfirmed`). Slot machine odds and the\nhouse's cut aren't published anywhere. These are Rust's in-game scrap games - nothing to do with real money.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "big_wheel_odds",
          "title": "Bandit Camp Big Wheel: odds, house edge and expected result of your bets",
          "description": "[Calculators] Bandit Camp Big Wheel: odds, house edge and expected result of your bets. Exact figures for the Big Wheel (https://rust.wiki/calculators/big-wheel): each number's chance, what it pays\nback per scrap and what the wheel keeps; for your bets the `expected_result` over the session, the return %, and\nthe standard deviation per spin and per session (how far a real session typically lands from the average). The\nwheel layout (12 ones, 6 threes, 4 fives, 2 tens, 1 twenty) comes from fan guides only. The page also simulates\nwhole sessions with a starting bank. Rust's in-game scrap wheel at Bandit Camp, not real-money gambling.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "bets": {
                "type": "string",
                "examples": [
                  "1:10,20:2"
                ],
                "maxLength": 100,
                "description": "Scrap on each number per spin as `number:scrap` (numbers 1, 3, 5, 10, 20). Left out = just the odds table."
              },
              "spins": {
                "type": "integer",
                "default": 80,
                "maximum": 5000,
                "minimum": 1,
                "description": "How many spins."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "blackjack_strategy",
          "title": "Rust blackjack: the best play for a hand, or the whole strategy chart",
          "description": "[Calculators] Rust blackjack: the best play for a hand, or the whole strategy chart. The blackjack page's strategy engine (https://rust.wiki/calculators/blackjack), an exact infinite-deck\ncalculation under Rust's caboose rules: no doubling on a hand with an Ace, one split, 3:2 blackjack, and no\ndealer peek by default. With `hand` + `dealer`: the `best` play and every option's expected value per 1 scrap\nbet. Without: the full `hard`, `soft` and `pairs` charts (H hit, S stand, D double, P split) per dealer card, plus\nthe `house_edge_pct` with perfect play (about 0.82% under Rust's rules). Rust's in-game scrap blackjack (caboose), not real-money gambling.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "hand": {
                "type": "string",
                "examples": [
                  "A,7"
                ],
                "maxLength": 12,
                "description": "Your first two cards, e.g. `A,7` or `10,6` (2-10, J, Q, K, A). Left out = full chart."
              },
              "dealer": {
                "type": "string",
                "examples": [
                  "9"
                ],
                "maxLength": 5,
                "description": "The dealer's face-up card (needed with hand)."
              },
              "dealer_peeks": {
                "type": "boolean",
                "default": false,
                "description": "False = Rust: a dealer blackjack also takes doubles and splits."
              },
              "double_after_split": {
                "type": "boolean",
                "default": true,
                "description": "Doubling after a split allowed."
              },
              "dealer_hits_soft_17": {
                "type": "boolean",
                "default": true,
                "description": "Rust's caboose dealer hits soft 17 (since about Feb 2024)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_decay",
          "title": "When a base decays once the Tool Cupboard runs out, piece or layer by layer",
          "description": "[Calculators] When a base decays once the Tool Cupboard runs out, piece or layer by layer. The decay page's maths (https://rust.wiki/calculators/decay): with no upkeep, an outside piece goes from full\nhealth to nothing in 1 h (twig), 3 h (wood), 5 h (stone), 8 h (sheet metal) or 12 h (armoured); inside pieces\ndecay at a tenth of that. `destroyed_in_hours` counts from now (upkeep first). For `layers`, each layer behind\nthe outer one decays at 10% until the one in front is gone, then at full speed. Vanilla server defaults.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "grade": {
                "type": "string",
                "default": "stone",
                "maxLength": 20,
                "description": "Building grade: twig, wood, stone, metal, hqm."
              },
              "inside": {
                "type": "boolean",
                "default": false,
                "description": "True = the piece is inside the base (decays at 10% speed)."
              },
              "layers": {
                "type": "string",
                "examples": [
                  "hqm,stone,stone"
                ],
                "maxLength": 100,
                "description": "Optional honeycomb: comma-separated grades from the outside in (max 6)."
              },
              "health_pct": {
                "type": "number",
                "default": 100,
                "maximum": 100,
                "minimum": 1,
                "description": "The piece's health left, %."
              },
              "upkeep_hours": {
                "type": "number",
                "default": 0,
                "maximum": 2000,
                "minimum": 0,
                "description": "Hours of upkeep left in the Tool Cupboard."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_excavator",
          "title": "Giant Excavator, quarries and pump jack: output and run time for your diesel",
          "description": "[Calculators] Giant Excavator, quarries and pump jack: output and run time for your diesel. The excavator page's maths (https://rust.wiki/calculators/excavator): run time and output for the diesel. The\nGiant Excavator's yields per diesel are Facepunch's own (December 2021); the monument quarries' and pump jack's\ncome from community guides (`confidence`). Vanilla server rates.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "diesel": {
                "type": "integer",
                "default": 20,
                "maximum": 10000,
                "minimum": 1,
                "description": "Diesel fuel."
              },
              "machine": {
                "type": "string",
                "maxLength": 40,
                "description": "Machine key or name (left out = every machine's rates): excavator_stone, excavator_metal, excavator_sulfur, excavator_hqm, quarry_sulfur, quarry_stone, quarry_hqm, pumpjack."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_door_code_rules",
          "title": "Code lock facts and what makes a door code easy to guess",
          "description": "[Calculators] Code lock facts and what makes a door code easy to guess. The facts behind https://rust.wiki/calculators/door-code: the code lock's rules (`facts`: 4 digits, a shock per\nwrong guess, 8 wrong tries then a 15-minute lockout, guest codes), the ten most common four-digit codes (cited\nfrom DataGenetics' 2012 PIN study), the `patterns` the page flags as guessable and how long a full brute force\ntakes. The API deliberately doesn't generate or check codes: the page makes them in your own browser and never\nsends them anywhere - open the page for a code. For a random code use generate_door_code; to rate a code use check_door_code.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_launch_options",
          "title": "Rust launch options that work, the myths, and a Steam launch line builder",
          "description": "[Game reference] Rust launch options that work, the myths, and a Steam launch line builder. The data behind https://rust.wiki/launch-options: `groups` of options Rust (Facepunch) and Unity 6 actually read,\neach with its value and what it does, plus `myths` (popular 'FPS boost' flags nothing shows Rust reads). With\n`line`: `check.line` is the cleaned launch line (known options only, one forced graphics API) and `check.options`\nsays what each one is (`rust`, `unity`, `myth`, `unknown`, `conflict`) with any warning.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "line": {
                "type": "string",
                "examples": [
                  "-cpu_priority high +gc.buffer 4096 -maxMem=16000"
                ],
                "maxLength": 500,
                "description": "Optional: options to check and clean up, as you'd paste them into Steam."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "make_key_bind",
          "title": "Make a Rust key bind command (auto-run, crafting, chat, gestures...)",
          "description": "[Calculators] Make a Rust key bind command (auto-run, crafting, chat, gestures...). The bind maker page (https://rust.wiki/calculators/bind-maker). Returns the `bind` line to paste into the F1\nconsole and `writecfg` to save it. Without `preset`: every preset with its fields and suggested key, the bind\nsyntax and the key names.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "a": {
                "type": "string",
                "maxLength": 200,
                "description": "The preset's first field (item ID, message, gesture, FOV, or the custom command)."
              },
              "b": {
                "type": "string",
                "maxLength": 50,
                "description": "The preset's second field (craft amount, second FOV)."
              },
              "key": {
                "type": "string",
                "maxLength": 20,
                "description": "Key name, e.g. `x`, `f1`, `mouse3` (default: the preset's suggestion)."
              },
              "preset": {
                "type": "string",
                "maxLength": 40,
                "description": "What the key does: autorun, sprintjump, crouch, autoattack, light_ads, craft, chat, teamchat, gesture, fov, voice, hoverloot, combatlog, kill, disconnect, custom. Left out = list the presets."
              },
              "modifier": {
                "type": "string",
                "pattern": "^(leftshift|leftcontrol|leftalt)?$",
                "description": "Optional held key for a combo: leftshift, leftcontrol, leftalt."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "build_conveyor_filter",
          "title": "Build an Industrial Conveyor filter to paste into the game",
          "description": "[Calculators] Build an Industrial Conveyor filter to paste into the game. The conveyor page's filter builder (https://rust.wiki/calculators/conveyor). `filter_json` is exactly what the\nin-game conveyor copies and pastes (a list of {TargetCategory, TargetItemName, MaxAmountInOutput, BufferAmount,\nMinAmountInInput, IsBlueprint}); paste it on the conveyor's filter screen. A conveyor holds 30 filters; `unknown`\nlists names that matched nothing.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "items": {
                "type": "string",
                "examples": [
                  "metal.ore,sulfur.ore,hq.metal.ore,wood"
                ],
                "maxLength": 1500,
                "description": "Comma-separated item shortnames or names."
              },
              "buffer": {
                "type": "integer",
                "default": 0,
                "maximum": 1000000,
                "minimum": 0,
                "description": "BufferAmount for every filter."
              },
              "min_in": {
                "type": "integer",
                "default": 0,
                "maximum": 1000000,
                "minimum": 0,
                "description": "MinAmountInInput for every filter."
              },
              "max_out": {
                "type": "integer",
                "default": 0,
                "maximum": 1000000,
                "minimum": 0,
                "description": "MaxAmountInOutput for every filter (0 = no limit)."
              },
              "starter": {
                "type": "string",
                "maxLength": 40,
                "description": "Start from a ready-made list: Furnace feed, Smelted output, Tool Cupboard upkeep, Raid box, Boom crafting, Meds, Fuel, Recycler run."
              },
              "categories": {
                "type": "string",
                "maxLength": 300,
                "description": "Comma-separated whole categories: weapon, construction, general, resource, attire, tool, medical, food, ammo, trap, misc, component, electrical, fun."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "plan_loot_room",
          "title": "Plan a loot room: which item categories go in which box, with each box's filter",
          "description": "[Calculators] Plan a loot room: which item categories go in which box, with each box's filter. The conveyor page's loot-room planner: each category needs (its item types x fill) slots; categories go biggest\nfirst into the tightest box they fit, spilling across the emptiest boxes when none is big enough. Each box gets\nthe conveyor `filter_json` for its categories; `not_enough_room` says what didn't fit.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "fill_pct": {
                "type": "number",
                "default": 40,
                "maximum": 100,
                "minimum": 10,
                "description": "How much of each category you'll keep, % of its item types."
              },
              "categories": {
                "type": "string",
                "maxLength": 300,
                "description": "Categories to store (default: everything but food, fun and attire)."
              },
              "large_boxes": {
                "type": "integer",
                "default": 8,
                "maximum": 60,
                "minimum": 0,
                "description": "Large Wood Boxes (48 slots)."
              },
              "small_boxes": {
                "type": "integer",
                "default": 0,
                "maximum": 60,
                "minimum": 0,
                "description": "Small Wood Boxes (18 slots)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_circuit_parts",
          "title": "Circuit simulator parts: every electrical part's inputs, outputs and rules",
          "description": "[Calculators] Circuit simulator parts: every electrical part's inputs, outputs and rules. The parts and rules behind https://rust.wiki/calculators/circuit-simulator (Rust's power rules since the April\n2024 rework): `parts` as [kind, name, shortname, group, inputs, outputs, settings], `devices` as [name, shortname,\npower draw], `rules` and `caveats`. The board and its solver run in the browser - build circuits on the page;\nfor a plain power budget use /calculators/electricity/compute.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_update",
          "title": "One Facepunch devblog: what it added - new skins, their value, drops, player peak",
          "description": "[Updates] One Facepunch devblog: what it added - new skins, their value, drops, player peak. The data behind https://rust.wiki/updates/<slug> (devblogs only): Facepunch's `summary` and link, the RustProfit\nblog explainer when there is one, every skin released in the update's `window` (until the next devblog) with\nits price (USD cents, Steam lowest listing; first 60 listed, `skin_count` for all), how many were store skins vs\nTwitch/Kick drops, their total value now, the drop collections, that month's Steam player peak and the previous /\nnext devblog. Devblog slugs come from get_rust_updates.",
          "inputSchema": {
            "type": "object",
            "required": [
              "slug"
            ],
            "properties": {
              "slug": {
                "type": "string",
                "examples": [
                  "printed_and_polished"
                ],
                "maxLength": 120,
                "description": "The devblog's slug from /updates."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_skin_creators",
          "title": "Workshop artists behind Rust's skins, by total value",
          "description": "[Skins] Workshop artists behind Rust's skins, by total value. Everyone whose Workshop skins Facepunch accepted into Rust (https://rust.wiki/creators): `steamid`, `name` (from\ntheir latest skin), `avatar_url`, `count` of accepted skins, `total_value` (sum of their skins' Steam lowest\nlistings, USD cents), `newest` release date and a few `icons` of their priciest skins.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "maximum": 1000,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "type": "string",
                "default": "value_desc",
                "pattern": "^(value_desc|count_desc|newest|name)$",
                "description": "`value_desc` (total value of their skins), `count_desc`, `newest` or `name`."
              },
              "per_page": {
                "type": "integer",
                "default": 24,
                "maximum": 100,
                "minimum": 1,
                "description": "Results per page (max 100)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_skin_creator",
          "title": "One Workshop artist: every accepted Rust skin they made and what it's worth",
          "description": "[Skins] One Workshop artist: every accepted Rust skin they made and what it's worth. The data behind https://rust.wiki/creators/<steamid>: the artist's skins with prices (USD cents), count, total and\naverage value, top skin, first and last release, and the split by item, collection and category.",
          "inputSchema": {
            "type": "object",
            "required": [
              "steamid"
            ],
            "properties": {
              "steamid": {
                "type": "string",
                "pattern": "^\\d{17}$",
                "examples": [
                  "76561198035849663"
                ],
                "description": "The artist's SteamID64 (from /creators or a skin's creator)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_sulfur",
          "title": "Sulfur, charcoal and raw materials for any number of explosives",
          "description": "[Calculators] Sulfur, charcoal and raw materials for any number of explosives. The sulfur calculator page (https://rust.wiki/calculators/sulfur): each explosive's crafting recipe resolved down\nto raw materials (gunpowder and explosives broken into sulfur and charcoal - the raid calculator's own numbers).\n`resources` is the shopping list (sulfur first), `to_farm` the sulfur ore (smelts 1:1) and wood to burn for the\ncharcoal, and with `sulfur` the `budget` table: how many rockets, C4, satchels... that sulfur makes. Every\nexplosive's `sulfur_each` is in the budget table and in /calculators/raid.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "sulfur": {
                "type": "number",
                "maximum": 10000000,
                "minimum": 0,
                "description": "Optional: the sulfur you have - how many of each standard explosive it makes."
              },
              "explosives": {
                "type": "string",
                "examples": [
                  "ammo.rocket.basic:4,explosive.timed:2"
                ],
                "maxLength": 1000,
                "description": "Comma-separated `shortname:count` explosives (names work too), e.g. rockets, C4, satchels, explosive ammo, beancans."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "track_blueprints",
          "title": "Blueprint tracker: what you've unlocked and the scrap, fragments, pages and books left",
          "description": "[Calculators] Blueprint tracker: what you've unlocked and the scrap, fragments, pages and books left. The blueprint tracker page (https://rust.wiki/calculators/blueprints) for a list of blueprints you have. Tech\ntree blueprints cost research items, not scrap: 1 Blueprint Fragment each on the Workbench Level 1 and Engineering\nWorkbench trees, 1 Blueprint Page on Level 2, 1 Blueprint Book on Level 3 (game default; a server can add a tax).\nUnlocking one also unlocks every locked blueprint on the cheapest route to it, 1 item each. `trees` gives, per\ntree, the blueprints unlocked, the research items spent and left, and the cheapest locked ones with `cost_now`\n(what reaching it costs from what you have). `research_items` totals those per item. `research_table` is the\nResearch Table side: scrap by rarity (20/40/100/300, default blueprints 10), spent and left. `page` opens the\ntracker with the same ticks. The full list is /calculators/blueprints. Give the user the page link: it opens the tracker with their blueprints ticked. Tech tree blueprints cost Blueprint Fragments/Pages/Books, never scrap.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "unlocked": {
                "type": "string",
                "examples": [
                  "rifle.ak,explosive.timed,ammo.rocket.basic"
                ],
                "maxLength": 6000,
                "description": "Comma-separated shortnames (or names) of the blueprints you have. Left out = nothing unlocked yet."
              },
              "remaining": {
                "type": "integer",
                "default": 25,
                "maximum": 500,
                "minimum": 0,
                "description": "How many still-locked blueprints to list per tech tree and for the Research Table (cheapest first)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_tech_tree",
          "title": "One tech tree: nodes and prerequisite edges",
          "description": "[Game reference] One tech tree: nodes and prerequisite edges. The full research graph for one workbench, from the game's own tech tree data. Every node costs ONE research\nitem, never scrap: `currency` says which - a Blueprint Fragment (Workbench Level 1 and Engineering Workbench), a\nBlueprint Page (Level 2) or a Blueprint Book (Level 3) - at default server settings (a server can add a tax).\nUnlocking a node also unlocks every locked node on the cheapest route back to the tree's start, one item each.\n`nodes` carry `id`, `shortname`, `name`, `icon_url`, `cost` (1), `path_cost` (items to unlock it from scratch\nwith everything before it), `inputs` (prerequisite node ids - any one is enough) and `x`/`y`: LAYOUT PIXELS\n(the top-left of a 110x78 card, see `card_size`) from the game's own graph positions. `edges` are the\nprerequisite links (`from_id` before `to_id`) with the card-centre endpoints `x1`,`y1`,`x2`,`y2` the page\ndraws. `unlinked` lists nodes that are in the tree's data but have no route from its start (mostly moved to\nthe Engineering Workbench tree). Node ids are only stable until the tree is re-seeded. Cached for one hour. Costs are research items (Blueprint Fragment, Page or Book), never scrap. Link https://rust.wiki/tech-tree?tree=<tree>.",
          "inputSchema": {
            "type": "object",
            "required": [
              "tree"
            ],
            "properties": {
              "tree": {
                "enum": [
                  "workbench1",
                  "workbench2",
                  "workbench3",
                  "engineering"
                ],
                "type": "string",
                "examples": [
                  "workbench1"
                ],
                "description": "Which research graph: Workbench Level 1/2/3 or the Engineering Workbench."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_npc_vending",
          "title": "NPC vending machines and shopkeepers: every shop, offer and price",
          "description": "[Game reference] NPC vending machines and shopkeepers: every shop, offer and price. Every NPC shop in the game files (Outpost, Bandit Camp, fishing villages, stables, water wells, floating\ncities, the Travelling Vendor, plus order sets no standard monument uses). `order_sets` carry `key`, `title`,\n`offers` (`sell` item, `sell_amount`, `sell_bp`, `currency` item, `price`, `price_text`, and `random` - weight\nand price range - for shops that show 7 random offers: `picks`), and `where` (monuments, with\n`dynamic_pricing`). `locations` lists the shops per monument. Listed prices are the base: with dynamic\npricing (the default) a scrap price starts at double on a fresh map and drifts between half and double with\ndemand every few hours; water-well shopkeepers, the Travelling Vendor and deep-sea vendors keep the listed\nprice. With `item`, `sold` and `bought` list just that item's offers. Cached for one hour. Use item= for 'where can I buy X' / 'what can I sell X for'. Prices are the listed base; most NPC shops move between half and double with demand. Link https://rust.wiki/vending.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "item": {
                "type": "string",
                "examples": [
                  "metal.refined"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Only offers that sell this item or take it as payment (shortname, e.g. `rifle.ak` or `scrap`)."
              },
              "monument": {
                "type": "string",
                "examples": [
                  "bandit-camp"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Only the shops at this monument (slug from `/monuments`, e.g. `outpost`)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_tips",
          "title": "Rust's official game and loading-screen tips, in any rust.wiki language",
          "description": "[Game reference] Rust's official game and loading-screen tips, in any rust.wiki language. `groups`: topics, each with its `tips` - `key` (the game's phrase key), `kind` (game = in-game hint, menu = loading\nscreen), `text` with key binds filled in as `[Key]` (Rust's default binds), `segments` (`k`: t text / k key / v value),\n`source` (official = Facepunch's own wording; machine = our translation for Indonesian/Thai, which Rust doesn't ship;\nenglish = the game has no translation in that language), `links` (related wiki pages). `binds`: the default keys used. lang= gives the tips in Facepunch's own translation (id/th are ours). Keys are Rust's defaults. Link https://rust.wiki/tips.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "lang": {
                "type": "string",
                "default": "en",
                "examples": [
                  "de"
                ],
                "maxLength": 8,
                "description": "Language code: en or one of the wiki's 18 (de, es, ja, ru, zh, pt-br, ...)."
              },
              "group": {
                "type": "string",
                "examples": [
                  "fishing"
                ],
                "maxLength": 60,
                "description": "Only one topic, e.g. `staying-alive`, `building-your-base`, `fishing`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_achievements",
          "title": "Every Rust achievement: exact unlock condition from the game code + global unlock %",
          "description": "[Game reference] Every Rust achievement: exact unlock condition from the game code + global unlock %. `achievements` (most common first): `key` (Steam api name), `name`, `desc` (Steam's text), `pct` (share of all\nRust players who have it), `how` (the exact condition, from the server code; for `type` client it is Steam's text),\n`type` (server_direct / server_field / steam_stat / client / new), `hidden`, `progress_max` + `stat` for counter\nachievements, `items` (shortnames), `note` (caveats). `stats`: the counters the game tracks and what increments them.\n`global_rules`: achievements only unlock on official servers. Use q= to find one. `how` is the exact condition from the game code (type client = Steam's text). Achievements only unlock on official servers. Link https://rust.wiki/achievements#<KEY>.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "angler"
                ],
                "maxLength": 80,
                "description": "Filter by words in the name, description or key."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_achievement",
          "title": "One Rust achievement: how to unlock it, from the game code",
          "description": "[Game reference] One Rust achievement: how to unlock it, from the game code. Same fields as one row of `/achievements`, plus `global_rules`. Link https://rust.wiki/achievements#<KEY>.",
          "inputSchema": {
            "type": "object",
            "required": [
              "key"
            ],
            "properties": {
              "key": {
                "type": "string",
                "examples": [
                  "PRO_ANGLER"
                ],
                "maxLength": 60,
                "minLength": 2,
                "description": "Steam api name, e.g. `PRO_ANGLER` (case-insensitive)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_seasonal_events",
          "title": "Rust seasonal events: Advent Calendar by day, birthday, Christmas, Halloween, Easter",
          "description": "[Game reference] Rust seasonal events: Advent Calendar by day, birthday, Christmas, Halloween, Easter. From the server code. `advent`: `days` (Dec 16-25) with `rewards`, `primitive` alternatives and `by_era` (what\nPrimitive/Medieval/Frontier/Modern servers give or skip), `rules`, `clock` (server-clock dates), the calendar `item`.\n`birthday`: Dec 7-16 window, cake + party hat. `christmas`: `rules`, `convars`, `presents`/`stockings`/`gift_box`\nloot odds (`chance_pct`, `min`/`max`), `tree`, `dungeon`, sleigh. `halloween`/`easter`: hunts, prizes, convars.\n`status`: whether the dated events are on now (UTC) or days until they start. `how_servers_switch_it_on`: commands.\nEvery rule has a `source` (decompiled file:line or prefab). event=advent for the calendar by day. Dates are by the server's own clock (usually UTC). Link https://rust.wiki/advent-calendar, /christmas, /birthday-event or /seasonal-events.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "event": {
                "type": "string",
                "pattern": "^(advent|birthday|christmas|halloween|easter)$",
                "examples": [
                  "advent"
                ],
                "description": "Only one event."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_monument_puzzles",
          "title": "Monument puzzles: keycards, fuses, radiation and puzzle loot for every monument",
          "description": "[Game reference] Monument puzzles: keycards, fuses, radiation and puzzle loot for every monument. One row per monument the game files have puzzle, radiation or bench data for: `cards` (keycard colours its doors\ntake), `fuse_boxes`, `doors` (number of puzzle doors), `rad` (highest radiation zone, rads/s before protection: you\nneed that much radiation protection to take none), `reset` (puzzle reset timer), `loot` (best things the puzzle\nrooms respawn, with `max` per reset and `url`), `amenities` (recycler, research_table, repair_bench, workbench\nlevels). `rules`: fuse life, keycard swipes, radiation tiers, reset-radiation convars. Fetch one monument's full\nroute with `/monument-puzzles/{slug}`. Use card=red etc. for 'which monuments need a red card'. Link https://rust.wiki/monument-puzzles.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "card": {
                "type": "string",
                "pattern": "^(green|blue|red)$",
                "examples": [
                  "red"
                ],
                "description": "Only monuments with a door for this keycard."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_monument_puzzle",
          "title": "One monument's puzzle: every door, what opens it in order, resets and loot",
          "description": "[Game reference] One monument's puzzle: every door, what opens it in order, resets and loot. `doors`: each puzzle door (`door` kind, `card` colour or null, `count` identical doors, `area` = the room's name in the\ngame files when it has one) with `ways` to open it - ordered `steps` (`t` = grid/fuse/switch/timer/card/button with\n`seconds`, `colour`, `stage`, and a readable `text`) and `stays_open` - plus `exit_button` and `resets` (indexes into\n`resets`). `resets`: each PuzzleReset (`seconds`, `players_block` + `radius` or `ai_zone`, `pause_until_looted`,\n`radiation_push`) with the `loot` it respawns (`name`, `max` per reset, `url` to the loot table or item).\n`radiation`: zones by tier. `missions`: missions the monument's NPCs give. Steps are in order (power grid, fuse, switch, timer, card, button). Radiation: protection equal to the rad number blocks it. Link https://rust.wiki/monument/<slug>#puzzle.",
          "inputSchema": {
            "type": "object",
            "required": [
              "slug"
            ],
            "properties": {
              "slug": {
                "type": "string",
                "examples": [
                  "military-tunnel"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Monument slug from `/monuments`, e.g. `military-tunnel`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_spoilage",
          "title": "Food spoil times, fridges, and composting fertilizer per item",
          "description": "[Game reference] Food spoil times, fridges, and composting fertilizer per item. `spoil`: every food that spoils (`item`, `hours` of normal storage, `becomes` = the spoiled item). `spoil_rules`:\npowered fridge / vending machine multipliers (0 = paused), the arctic biome (0), stack-merge limits. `compost`: every\nitem a composter takes (`item`, `fertilizer` produced per item - fractions are rounded up at random) and\n`compost_rules` (`cycle_s` per item per stack, `slots`). Names come with each row. Use item=<shortname> for one food. A powered fridge stops spoiling. Link https://rust.wiki/spoilage.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "item": {
                "type": "string",
                "examples": [
                  "bearmeat"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "One item's spoil time and compost value (shortname)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_armour_inserts",
          "title": "Armour inserts: protection added, clothing with insert slots, slot odds",
          "description": "[Game reference] Armour inserts: protection added, clothing with insert slots, slot odds. `inserts`: each insert with `protection` per damage type in percent (added to the clothing's own, per insert) and\n`speed_reduction`. `clothing`: every item with insert slots (`min`/`max` slots, `crafted_only` - looted armour has\nnone, `covers` body parts, base `protection_pct`). `slot_odds`: chance of each slot count at craft time, keyed\n\"min-max\", with no crafting-quality bonus. Insert protection is added per insert, on top of the clothing. Link https://rust.wiki/armour-inserts.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_pet_gear",
          "title": "Frankenstein pet parts and the stats they change",
          "description": "[Game reference] Frankenstein pet parts and the stats they change. `parts`: each Frankenstein head/torso/legs part with flat changes to the pet's `speed`, `max_health`,\n`attack_damage` and `attack_rate_s` (seconds between attacks: positive = slower). The only pet gear in this build. Link https://rust.wiki/pet-gear.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_missions",
          "title": "NPC missions: where they're given, steps, rewards, time limits, repeat timers",
          "description": "[Game reference] NPC missions: where they're given, steps, rewards, time limits, repeat timers. `locations`: each monument with mission givers and its `missions` - `name`, `desc`, ordered `objectives`\n(`text`), `rewards` (`item` shortname + `amount`, or `other` for non-item rewards like the Outpost spawn unlock),\n`time_limit`, `repeat` (cooldown after success, or \"once per wipe\"), `requires` (missions to finish first).\nWithout `monument`, also `tutorial` (tutorial-island missions) and `unplaced` (in the files, not offered on standard\nmaps). Use monument=<slug> for one place. Link https://rust.wiki/missions.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "monument": {
                "type": "string",
                "examples": [
                  "outpost"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Only missions given at this monument (slug)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_gestures",
          "title": "Every gesture: console name, unlock (free, pack, DLC, admin), length and limits",
          "description": "[Game reference] Every gesture: console name, unlock (free, pack, DLC, admin), length and limits. `gestures`: one per gesture - `command` (the console name: `bind g \"gesture <command>\"`), `name`, `desc`\n(`desc_source` \"game\" = Facepunch's text, \"rust.wiki\" = ours), `unlock` (`type` free / steam_item (an Item Store pack,\nwith `itemdefid` + `name`) / dlc (`appid` + `name`) / cinematic = admins, or everyone with server.cinematic on),\n`unlock_text`, `unlock_url`, `duration_s`, `loops`, `full_body` (can't be used mounted, swimming or crouched),\n`can_move`, `in_wheel` (false = the game plays it for you), `two_player`, `bind` (a ready bind line). `command` is what goes in a bind: bind g \"gesture <command>\". Link https://rust.wiki/gestures.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "unlock": {
                "type": "string",
                "pattern": "^(free|steam_item|dlc|cinematic)$",
                "examples": [
                  "free"
                ],
                "description": "Only gestures unlocked this way."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_dlc",
          "title": "Rust DLC and Item Store packs: what each unlocks in game, Twitch drops",
          "description": "[Game reference] Rust DLC and Item Store packs: what each unlocks in game, Twitch drops. `dlc`: each Steam DLC (`key`, `name`, `appid`, `store_url`, `items` it unlocks). `packs`: every Steam inventory\nitem (mostly Item Store packs) that unlocks game items - `itemdefid`, `name`, `desc`, `limited`, `url` (Steam item\nstore), `items`. `twitch`: every Twitch-drop Steam item in the files and the items it unlocks (most are skins and\nunlock nothing new). With `item`: just that item's requirement (`kind` dlc / steam_item / twitch, or null when\nanyone can craft it). Each DLC also carries `steam_price`: today's US Steam store price (`price`, `initial`, in\ncents; `discount` percent; `price_text`) or `on_steam` false when Steam doesn't sell it; `prices_fetched_at` says\nwhen it was read (refreshed every few hours; null before the first read). Use item=<shortname> for 'what do I need to craft X'. Link https://rust.wiki/dlc.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "item": {
                "type": "string",
                "examples": [
                  "piano"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "One item: which DLC or Steam item unlocks it (shortname)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_survival_mechanics",
          "title": "Healing, comfort and heat sources, food/water drain, radiation, fall damage - from the code",
          "description": "[Game reference] Healing, comfort and heat sources, food/water drain, radiation, fall damage - from the code. Everything on https://rust.wiki/survival-mechanics. `k`: the constants read from the decompiled game code (heal\nconditions `heal_*`, drains, temperature, wetness, bleeding, radiation `rad_*`, fall damage `fall_*`, gravity).\n`limits`: the player's metabolism ranges. `heal`: HP/s by calories and comfort for a 100 HP player. `drain`:\ncalories and water per minute by activity. `comfort`: every comfort source (`comfort` 0-1, `full_within` and\n`zero_at` metres, `radius`, `kind` deployable / map-placed / monument, `count` in the files). `heat`: every heat,\ncold and shade source (`temperature`, `full_within`, `radius`; `shade` rows cool by `shade_cools` in daylight).\n`falls`: damage at common heights (awake player, estimated gravity - see calculate_fall_damage). Use section= to keep it short (healing, comfort, heat, food, fall). Link https://rust.wiki/survival-mechanics.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "section": {
                "type": "string",
                "pattern": "^(healing|comfort|heat|food|fall|constants)$",
                "examples": [
                  "comfort"
                ],
                "description": "Only one part: healing, comfort, heat, food, fall or constants."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_fall_damage",
          "title": "Fall damage from a height or a landing speed",
          "description": "[Calculators] Fall damage from a height or a landing speed. Damage = 500 x InverseLerp(15, 100, landing speed m/s), before clothing protection (BasePlayer.\nApplyFallDamageFromVelocity), plus bleeding 0.5 x the same fraction. Returns `damage`, `bleeding`, `speed_ms`,\n`height_m`, `safe_height_m` (no damage below), `lethal_height_m` (100 damage), `gravity_ms2` and\n`height_is_estimate`. Speed -> damage is exact; heights assume no air resistance. Speed to damage is exact; heights for awake players are an estimate (client-side movement). Link https://rust.wiki/survival-mechanics#fall.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "speed": {
                "type": "number",
                "maximum": 500,
                "minimum": 0,
                "examples": [
                  20
                ],
                "description": "Landing speed in m/s (overrides height)."
              },
              "height": {
                "type": "number",
                "maximum": 2000,
                "minimum": 0,
                "examples": [
                  10
                ],
                "description": "Fall height in metres."
              },
              "player": {
                "type": "string",
                "default": "awake",
                "pattern": "^(awake|sleeping)$",
                "description": "awake (gravity estimated - awake movement runs on the client) or sleeping (the server's own fall for sleeping/wounded players, from the code)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_instruments",
          "title": "Playable instruments: notes, mouse notes, octaves, keyboard maps, autoplay songs",
          "description": "[Game reference] Playable instruments: notes, mouse notes, octaves, keyboard maps, autoplay songs. Every instrument (`item` shortname, `name`, `dlc`): `notes` (pitch names, lowest first; drum kit = drum\npieces), `lowest`/`highest`, `primary_click`/`secondary_click` (mouse notes), `default_octave`/`shifted_octave`,\n`max_notes_at_once`, `keyboard` (full-keyboard mode: key label -> note, UK QWERTY as the game's map), `song` (the\nbuilt-in autoplay song: `notes`, `seconds`, `lowest`/`highest`, `chords` - described, no audio). `tips`: the game's\nown control tips.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_instrument",
          "title": "One instrument: notes, mouse notes, octaves, keyboard map, autoplay song",
          "description": "[Game reference] One instrument: notes, mouse notes, octaves, keyboard map, autoplay song. One instrument from `/instruments` with the same fields. Link https://rust.wiki/instruments#<item>.",
          "inputSchema": {
            "type": "object",
            "required": [
              "item"
            ],
            "properties": {
              "item": {
                "type": "string",
                "examples": [
                  "piano"
                ],
                "maxLength": 40,
                "minLength": 1,
                "description": "Item shortname (e.g. `piano`, `fun.guitar`) or short name (`acousticguitar`)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_skin_game_files",
          "title": "A skin as Rust's own approved-skin list has it: workshop id, base item, flags, release batch",
          "description": "[Skins] A skin as Rust's own approved-skin list has it: workshop id, base item, flags, release batch. From Rust.Workshop.dll (Approved.cs) - exact, not matched by name: `workshopid`, `item` (base item shortname),\n`tradable`, `marketable`, `crate_drop`, `twitch_drop`, `added` (the date of the store-update batch it shipped in) and\n`batch`. 404 for skins older than the list (2015 workshop skins) or newer than the game build. Exact workshop id and flags from the game's own approved-skin list. Link https://rust.wiki/skin/<itemdefid>.",
          "inputSchema": {
            "type": "object",
            "required": [
              "itemdefid"
            ],
            "properties": {
              "itemdefid": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  20518
                ],
                "description": "The skin's Steam item definition id."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "poker_odds",
          "title": "Texas Hold'em win odds and pot odds for a hand (Bandit Camp poker)",
          "description": "[Calculators] Texas Hold'em win odds and pot odds for a hand (Bandit Camp poker). The poker odds page's simulation (https://rust.wiki/calculators/poker-odds): the rest of the board and every\nopponent's cards are dealt at random `trials` times. `win_pct` = you win outright, `split_pct` = your share of\nsplit pots, `equity_pct` = both; `margin_pct` is the 95% margin of error. With `to_call`, `pot_odds_need_pct`\n(call / (pot + call)) and a `verdict` (call or fold); `made_hands` is how often you end with each hand and how\noften that hand wins. Bandit Camp's poker is Rust's in-game scrap game (no rake) - nothing to do with real money. Rust's in-game scrap poker at Bandit Camp, not real-money gambling.",
          "inputSchema": {
            "type": "object",
            "required": [
              "hand"
            ],
            "properties": {
              "pot": {
                "type": "number",
                "default": 0,
                "maximum": 10000000,
                "minimum": 0,
                "description": "Scrap in the pot (for pot odds)."
              },
              "hand": {
                "type": "string",
                "examples": [
                  "As,Kd"
                ],
                "maxLength": 20,
                "minLength": 4,
                "description": "Your two cards, e.g. `As,Kd` (ranks 2-10 J Q K A or T, suits s h d c)."
              },
              "seed": {
                "type": "integer",
                "maximum": 2147483647,
                "minimum": 0,
                "description": "Optional random seed for a repeatable answer."
              },
              "board": {
                "type": "string",
                "examples": [
                  "Qs,Js,2c"
                ],
                "maxLength": 40,
                "description": "Community cards so far (0-5)."
              },
              "trials": {
                "type": "integer",
                "default": 20000,
                "maximum": 20000,
                "minimum": 1000,
                "description": "Random deals to simulate (the page uses 20,000; fewer is faster but rougher)."
              },
              "to_call": {
                "type": "number",
                "default": 0,
                "maximum": 10000000,
                "minimum": 0,
                "description": "Scrap you need to call (0 = nothing to call)."
              },
              "opponents": {
                "type": "integer",
                "default": 1,
                "maximum": 5,
                "minimum": 1,
                "description": "Other players still in the hand (1-5, as on the page)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "generate_door_code",
          "title": "Random code lock codes that avoid the ones raiders try first",
          "description": "[Calculators] Random code lock codes that avoid the ones raiders try first. The door code generator (https://rust.wiki/calculators/door-code): random four-digit codes from the server's\ncryptographic random source, re-drawn until they match none of the guessable patterns the page checks (the 10\nmost common codes, one digit four times, runs like 1234, repeated pairs, mirrors, years, dates, two-digit codes),\neach with a different guest code. Codes are made fresh per request and never stored (the response is marked\nno-store); for a code that never leaves your device, use the page, which makes them in your browser. Give the user the code and guest code; they set them on the lock in game.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "count": {
                "type": "integer",
                "default": 1,
                "maximum": 10,
                "minimum": 1,
                "description": "How many code pairs to make."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "check_door_code",
          "title": "Is this door code easy to guess?",
          "description": "[Calculators] Is this door code easy to guess?. The door code page's checker: `verdict` is `good`, `guessable` (a weak pattern: a year, a date, doubled digits,\na mirror, only two digits) or `easy to guess` (a top-10 code, one digit four times, a run, a repeated pair), with\nthe `reasons`. Check a code BEFORE you set it - don't send the code that's on your door now. Ask for a code the user is THINKING of using, not the one on their door now.",
          "inputSchema": {
            "type": "object",
            "required": [
              "code"
            ],
            "properties": {
              "code": {
                "type": "string",
                "examples": [
                  "1987"
                ],
                "maxLength": 8,
                "minLength": 4,
                "description": "A four-digit code to check."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_crosshair_presets",
          "title": "Rust crosshair presets, styles and colours (the in-game crosshair editor's codes)",
          "description": "[Calculators] Rust crosshair presets, styles and colours (the in-game crosshair editor's codes). The data behind https://rust.wiki/crosshair: Rust's built-in crosshair editor (Options > User Interface >\nCrosshair, since October 2025) shares crosshairs as codes like `RUST-FceIG-V4T`. `presets` are ready-made\ncrosshairs with their codes and settings; `styles`, `colors` and `outline_colors` are the editor's choices\n(index = the value in a code); `ranges` are the sliders' min, max and step. Build or read a code with\n/crosshair/code.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "make_crosshair",
          "title": "Make a Rust crosshair code from settings, or read one",
          "description": "[Calculators] Make a Rust crosshair code from settings, or read one. The crosshair generator (https://rust.wiki/crosshair): start from `code` (or the game's default crosshair),\nchange any setting, and get back the shareable `code`, the `console` line to paste into F1\n(`crosshair.load_code ...`), the page's console `commands` form, the full `settings` and a `page` link that\nopens it in the editor preview. Values are rounded to the editor's precision (0.01 for dot and spacing, 0.1 for\nlength and width), as codes store them. Rust's built-in crosshair editor imports these codes; give the user `console` to paste into F1.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "dot": {
                "type": "number",
                "maximum": 5,
                "minimum": 0,
                "description": "Dot size 0-5 (0 = no dot)."
              },
              "code": {
                "type": "string",
                "examples": [
                  "RUST-FceIG-V4T"
                ],
                "maxLength": 30,
                "description": "A crosshair code to read (e.g. `RUST-FceIG-V4T`); other settings given with it are changed on top of it."
              },
              "color": {
                "type": "string",
                "maxLength": 10,
                "description": "White, Green, Blue, Red, Yellow, Magenta, Cyan or Black (or 0-7)."
              },
              "style": {
                "type": "string",
                "maxLength": 10,
                "description": "Default, Dot or T-Shape (or 0-2)."
              },
              "width": {
                "type": "number",
                "maximum": 8,
                "minimum": 1,
                "description": "Line width, 1-8."
              },
              "length": {
                "type": "number",
                "maximum": 20,
                "minimum": 1,
                "description": "Line length, 1-20."
              },
              "outline": {
                "type": "boolean",
                "description": "Draw an outline."
              },
              "spacing": {
                "type": "number",
                "maximum": 3,
                "minimum": 0,
                "description": "Gap from the centre, 0-3."
              },
              "outline_color": {
                "type": "string",
                "maxLength": 10,
                "description": "Outline colour: Black, Green, Blue, Red, Yellow, Magenta, Cyan or White (or 0-7)."
              },
              "dynamic_spacing": {
                "type": "boolean",
                "description": "Spread the lines with weapon spread (the game's dynamic spacing)."
              },
              "dynamic_visibility": {
                "type": "boolean",
                "description": "Hide the crosshair while aiming down sights / moving (the game's dynamic visibility)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "simulate_circuit",
          "title": "Simulate a Rust circuit: power on every wire and which devices run",
          "description": "[Calculators] Simulate a Rust circuit: power on every wire and which devices run. The circuit simulator's solver (https://rust.wiki/calculators/circuit-simulator), Rust's power rules since the\nApril 2024 rework: each part's `inputs` and `outputs` (rW), whether it's `on`, device and battery `status`\n(\"Needs 10, gets 4\", \"Empty in 4 h 0 min\"), the power on every wire, `power_generated`, `devices_on` of\n`devices_total`, and a `page` link that opens the same circuit on the board. A device takes its full draw or\nnothing; splitters share evenly between connected outputs; batteries give only what the parts after them draw,\nup to their maximum. Wiring something back into itself is reported as `short_circuit`. Part and device names come from get_circuit_parts / get_electricity_data. Give the user the page link: it opens the circuit on the interactive board.",
          "inputSchema": {
            "type": "object",
            "required": [
              "parts"
            ],
            "properties": {
              "parts": {
                "type": "string",
                "examples": [
                  "s:Large Solar Panel,b:Large Battery,t:Auto Turret,l:Ceiling Light"
                ],
                "maxLength": 3000,
                "minLength": 3,
                "description": "Comma-separated `label:Part` - a part from /calculators/circuit-simulator (Large Solar Panel, Wind Turbine, Large Battery, Splitter, Electrical Branch, Switch, AND Switch...) or a powered device by name (Auto Turret, Ceiling Light, SAM Site...). Settings in brackets: `b:Large Battery(charge=50)`, `br:Electrical Branch(b=10)`, `sw:Switch(state=0)`."
              },
              "wires": {
                "type": "string",
                "examples": [
                  "s>b,b>t,t>l"
                ],
                "maxLength": 3000,
                "description": "Comma-separated `from>to` wires between labels, each end optionally `.port` - a port name or 1-based number (`sp.Out 2>t`, `br.Branch Out>l`, `g>sw.Switch On`). Default: first output to first input."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "price_loadout",
          "title": "Price a skin loadout: 7 clothing slots and 6 hotbar slots",
          "description": "[Skins] Price a skin loadout: 7 clothing slots and 6 hotbar slots. The loadout builder (https://rust.wiki/loadout): every slot's skin with its price (USD cents, the wiki's Steam\nprice: lowest listing, else highest buy order) and the `total_price`; `unpriced` counts skins with no price and\n`unknown` itemdefids that matched no skin. `page` opens the same loadout. Find itemdefids with /skins/search; to\ncheck that the clothing can be worn together and see it in 3D, use /skin-lab/outfit. Find skin itemdefids with search_skins first. For wear-rule checks and a 3D view use skinlab_build_outfit.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "hotbar": {
                "type": "string",
                "examples": [
                  "10137"
                ],
                "maxLength": 200,
                "description": "Up to 6 comma-separated skin itemdefids on the hotbar (weapons, tools, anything)."
              },
              "clothing": {
                "type": "string",
                "examples": [
                  "10180,14179"
                ],
                "maxLength": 200,
                "description": "Up to 7 comma-separated skin itemdefids worn (any clothing or armour skins)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "evaluate_base_design",
          "title": "Price a Rust base: build/upgrade cost, upkeep, decay, HP and the cheapest raid path",
          "description": "[Calculators] Price a Rust base: build/upgrade cost, upkeep, decay, HP and the cheapest raid path. The base designer's numbers for one design (https://rust.wiki/base-designer): `cost` (twig `placement`,\n`upgrade`, `deployables` = door/deployable recipes, `total`), `upkeep` (`per_day`/`per_week` by resource, `rate_pct`\n= the bracketed tax rate over `blocks`, `group_multiplier`), `hp`, `decay` (if the TC runs dry: `first_piece_hours`,\n`tc_open_hours` = when a free way in to the TC opens, `all_gone_hours`), and `raid`: the cheapest path from outside to\nthe TC (`raid.tc`), to each loot room (`raid.loot`) and the whole raid (`raid.full`, TC first then each loot room).\nEach path has `sulfur` (or `seconds`/`tools` in eco mode), `explosives`, `raw` resources and its `layers` in order\n(piece index, name, the explosives for that layer, `side` soft/hard for eco raids, `splash` onto nearby pieces).\nLayers marked `unverified` are foundation steps, priced like a wall of the same grade as the game files say (pending\nan in-game check). `page` opens the same base in the 3D designer. Pieces the design gets wrong come back in `warnings`. Use for 'how much to build / upkeep / raid my base': pass size=2x2 (+ floors, grade, door) for a plain base, template= for an example, or design= (JSON or a rust.wiki/base-designer link the user shares). raid.tc is the cheapest way to the tool cupboard, layer by layer. Give the user `page`: it opens the base in the 3D designer.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "eco": {
                "enum": [
                  "jackhammer",
                  "salvaged-icepick",
                  "pickaxe",
                  "salvaged-axe",
                  "hatchet"
                ],
                "type": "string",
                "default": "jackhammer",
                "description": "Tool for `mode=eco`."
              },
              "door": {
                "type": "string",
                "default": "door.hinged.metal",
                "description": "With `size`: the front door's item shortname."
              },
              "mode": {
                "enum": [
                  "mix",
                  "single",
                  "eco"
                ],
                "type": "string",
                "default": "mix",
                "description": "`mix` (cheapest mix of explosives per piece, the raid calculator's default), `single` (one explosive per piece) or `eco` (melee, priced in seconds of work - soft sides matter)."
              },
              "size": {
                "type": "string",
                "pattern": "^[1-8]x[1-8]$",
                "examples": [
                  "2x2"
                ],
                "description": "Instead of `design`: a plain rectangular base of W x D square foundations, walls all round, one front door, the TC and two large boxes inside - e.g. 2x2."
              },
              "decay": {
                "type": "boolean",
                "default": true,
                "description": "Run the no-upkeep decay simulation."
              },
              "grade": {
                "enum": [
                  "twig",
                  "wood",
                  "stone",
                  "metal",
                  "armored"
                ],
                "type": "string",
                "default": "stone",
                "description": "With `size`: the grade of every piece."
              },
              "design": {
                "type": "string",
                "maxLength": 120000,
                "description": "A design as JSON: {\"v\":1,\"p\":[pieces]}, each piece {\"t\": type, \"g\": grade, \"x\": m, \"z\": m, \"l\": level, \"r\": degrees[, \"y\": m for wall/ceiling deployables]} - see /base-designer/pieces for the types (every placeable deployable included) and the coordinate rules. A rust.wiki/base-designer#d=... share link (or just its d= code) works too."
              },
              "floors": {
                "type": "integer",
                "default": 1,
                "maximum": 6,
                "minimum": 1,
                "description": "With `size`: storeys (stairs are added)."
              },
              "players": {
                "type": "integer",
                "default": 1,
                "maximum": 200,
                "minimum": 1,
                "description": "Players authorised on the TC (5 or more pay group upkeep)."
              },
              "template": {
                "enum": [
                  "showcase",
                  "starter",
                  "2x2",
                  "2x2-2f",
                  "3x3-metal"
                ],
                "type": "string",
                "description": "One of the example bases instead of `design`."
              },
              "timeline": {
                "type": "boolean",
                "default": false,
                "description": "Include the decay timeline (hours, piece index) per destroyed piece."
              },
              "explosives": {
                "type": "string",
                "default": "staples",
                "description": "`staples` (rockets, C4, satchels, explosive ammo, beancans), `all`, or a comma list of explosive shortnames."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_base_designer_pieces",
          "title": "Base designer pieces: every building piece, door, insert and deployable with HP and costs",
          "description": "[Calculators] Base designer pieces: every building piece, door, insert and deployable with HP and costs. What a base designer design can contain, and how pieces are placed. Building pieces have a cost and HP per grade\n(twig, wood, stone, metal = sheet metal, armored); inserts (doors, hatches, window bars) go INTO a doorway, wall frame,\nwindow or floor frame; deployables (tool cupboard, boxes...) stand inside a cell. `coordinates` explains the grid. Piece types, HP and costs, and the coordinate rules for writing a design by hand.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "deployables": {
                "type": "string",
                "maxLength": 60,
                "description": "Deployables are many (380+): give a search word (\"turret\", \"box\"), a category (Storage & utility, Building, Electrical, Traps & defence, Farming & food, Fun & decor, Misc) or `all`. Left out, only the categories and their counts are listed."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_vehicles",
          "title": "Every vehicle: health, fuel per minute, seats, storage and vendor price",
          "description": "[Game reference] Every vehicle: health, fuel per minute, seats, storage and vendor price. One row per vehicle (`key`, `name`, `category` air/water/land/rail, `hp`, `seats`, `storage_slots`, `fuel_per_min` at full\nthrottle, `buy_scrap` at the Air Wolf or boat vendor, `url`). Fetch everything about one with `/vehicles/{key}`. Vehicle keys for get_vehicle. Link https://rust.wiki/vehicles.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "category": {
                "type": "string",
                "pattern": "^(air|water|land|rail)$",
                "examples": [
                  "air"
                ],
                "description": "Only this kind of vehicle."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_vehicle",
          "title": "One vehicle: HP, damage taken, fuel, decay, price, repair cost, explosives to destroy",
          "description": "[Game reference] One vehicle: HP, damage taken, fuel, decay, price, repair cost, explosives to destroy. `hp`; `damage_taken` (% of each damage type it takes after its armour - 300% = triple); `fuel` (`per_min` at full\nthrottle, `idle_per_min`, `tank`, `tank_minutes`); `seats`, `storage_slots`; `decay` (each timer with its ConVar);\n`buy` (scrap at the vendor), `craft`, `repair_full` (cost from near-zero to full); `explosives` (direct hits of each\nexplosive to destroy it from full HP); `engine` (kW / thrust, `max_speed_kmh` for trains); `horse` (gaits and breeds);\n`convars` (the server settings behind the numbers, with their defaults). `modular-car` also returns `car`: chassis,\nevery module (HP, seats, engine kW, fuel use, storage, recipe) and engine parts by tier. Use for vehicle HP, fuel per minute, decay, vendor price, repair cost or 'how many rockets to kill a minicopter'. All vanilla defaults; servers can change the listed convars. Link https://rust.wiki/vehicles/<key>.",
          "inputSchema": {
            "type": "object",
            "required": [
              "key"
            ],
            "properties": {
              "key": {
                "type": "string",
                "examples": [
                  "minicopter"
                ],
                "maxLength": 60,
                "minLength": 1,
                "description": "Vehicle key from `/vehicles`, e.g. `minicopter`, `rhib`, `modular-car`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_creatures",
          "title": "Every animal, NPC and boss: HP, hardest hit, aggro range, top speed",
          "description": "[Game reference] Every animal, NPC and boss: HP, hardest hit, aggro range, top speed. One row per creature (`key`, `name`, `group`, `hp`, `max_hit`, `aggro_range` in metres, `top_speed` m/s,\n`players_reaction` attacks/flees for animals, `url`). Fetch one with `/bestiary/{key}`. Animal/NPC/boss keys for get_creature. Link https://rust.wiki/bestiary.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "group": {
                "type": "string",
                "pattern": "^(predators|prey|livestock|npcs|event|bosses)$",
                "examples": [
                  "predators"
                ],
                "description": "Only this group."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_creature",
          "title": "One animal, NPC or boss: HP, attacks, senses, speeds, gather yields, weapons, loot",
          "description": "[Game reference] One animal, NPC or boss: HP, attacks, senses, speeds, gather yields, weapons, loot. `hp`, `damage_taken` (% per damage type), `attacks` (`damage`, `type`), `attack_interval_s`, `attack_range`,\n`senses` (vision/sense range and angle, hearing), `aggro_range`, `speeds` (m/s per gait), `chase_speed`,\n`flee_below_health`, `gather` (full-harvest yields), `weapons` (NPCs: per-shot damage after the NPC's damage scale),\n`wear`, `loot_url` (opens the loot simulator on its body/crate). Bosses add guns, rockets, crates, respawn and\nexplosives to destroy. Use for animal/NPC health, damage, aggro range, speed, harvest yield; loot_url opens the loot simulator. Link https://rust.wiki/bestiary/<key>.",
          "inputSchema": {
            "type": "object",
            "required": [
              "key"
            ],
            "properties": {
              "key": {
                "type": "string",
                "examples": [
                  "bear"
                ],
                "maxLength": 60,
                "minLength": 1,
                "description": "Creature key from `/bestiary`, e.g. `bear`, `heavy-scientist`, `bradley-apc`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_trap",
          "title": "Turrets and traps: damage, range, arc, ammo, power, HP, recipe, TC rules",
          "description": "[Game reference] Turrets and traps: damage, range, arc, ammo, power, HP, recipe, TC rules. Every player trap/turret plus the NPC safe-zone turrets: `hp`, `damage_text`, the raw damage fields, `sight_range`,\n`arc_degrees`, `range`, `power` (electricity), ammo/fuel, `craft` recipe, `needs_privilege_to_use`, `notes` (targeting\nand Tool Cupboard rules), `explosives` to destroy. key= for one defence (autoturret, flameturret, guntrap, trap-landmine, trap-bear, samsite, electric-teslacoil). Link https://rust.wiki/traps-and-turrets.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "key": {
                "type": "string",
                "examples": [
                  "autoturret"
                ],
                "maxLength": 40,
                "minLength": 1,
                "description": "Just one, e.g. `autoturret`, `samsite`, `guntrap`, `trap-landmine`, `electric-teslacoil`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_event_timers",
          "title": "World event timers: Cargo Ship, Patrol Heli, Chinook, Bradley, airdrops, satellite, Deep Sea",
          "description": "[Game reference] World event timers: Cargo Ship, Patrol Heli, Chinook, Bradley, airdrops, satellite, Deep Sea. Each event's `every` (in-game hours and the real-time equivalent with the default day length), its `facts`\n(durations, crates, hack timer...), the `convars` that control it and `links`. `clan_score`: points per clan event.\nVanilla defaults; servers can change them. Intervals are in-game hours with real-time equivalents for the default day length; vanilla defaults. Link https://rust.wiki/events.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_apartment_rules",
          "title": "Apartment Complex: rooms, prices, minimum rent, tax table, eviction rules",
          "description": "[Game reference] Apartment Complex: rooms, prices, minimum rent, tax table, eviction rules. `rooms` (`size`, `label`, `count`, `price` scrap, `min_rent` scrap per day), `tax` (scrap per full stack of each\ntaxed item), `rent_scaling` (0 by default: rent is just the minimum), eviction/free-rent/master-key/break-in values.\nWork out a rent with `/apartments/rent`. Link https://rust.wiki/apartments.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_apartment_rent",
          "title": "Daily apartment rent for a room size and what you keep in it",
          "description": "[Game reference] Daily apartment rent for a room size and what you keep in it. The game's formula: `max(minimum rent, sum(tax per stack x amount / stack size) x apartment.rentscaling)` scrap per\nreal day, taken continuously from the room's upkeep terminal; evicted after `eviction_after_s` unpaid. Vanilla apartment.rentscaling is 0, so rent is the room's minimum unless the server raised it. Link https://rust.wiki/apartments.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "size": {
                "type": "integer",
                "default": 2,
                "maximum": 3,
                "minimum": 1,
                "examples": [
                  2
                ],
                "description": "1 small, 2 medium, 3 large."
              },
              "items": {
                "type": "string",
                "default": "",
                "examples": [
                  "sulfur:5000,diesel_barrel:20"
                ],
                "maxLength": 600,
                "description": "Comma-separated `shortname:amount` you store in the room or carry nearby, e.g. `sulfur:5000,metal.fragments:10000`."
              },
              "rent_scaling": {
                "type": "number",
                "maximum": 100,
                "minimum": 0,
                "examples": [
                  1
                ],
                "description": "Override apartment.rentscaling (the server's value; vanilla 0)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_horse_breeds",
          "title": "Every horse breed: gallop speed, health and spawn chance, fastest first",
          "description": "[Game reference] Every horse breed: gallop speed, health and spawn chance, fastest first. One row per breed, fastest first: `speed_mult` (multiplies the gallop only), `gallop_kmh` / `gallop_ms` with no gear,\n`gallop_road_kmh` on a road or railway, `best_kmh` (High Quality Horse Shoes + road + apple boost), `hp`,\n`spawn_pct` (breeds are rolled at random when a horse spawns; horses can't be bred). Answers \"which horse is fastest\". Use for 'which horse is fastest' / 'best horse breed'. Breed multiplies only the gallop; walk, trot and canter are the same for all. Horses can't be bred. Link https://rust.wiki/horses#breeds.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "calculate_horse_speed",
          "title": "Top speed of a horse for a breed and its gear, on or off road",
          "description": "[Game reference] Top speed of a horse for a breed and its gear, on or off road. The game's formula (RidableHorse.GetCurrentMaxSpeed): at a gallop, `(14 + road bonus + every gear speed change + boost)\nx breed speed multiplier`. Returns `gallop_kmh`/`gallop_ms`, every gait's top speed, the extra `storage_slots` and\n`stamina_seconds_full` (how long a full 60 stamina gallops). 422 for an unknown breed/item or more than 4 gear items. Gear and boosts are added before the breed multiplier. km/h = m/s x 3.6. Vanilla values. Link https://rust.wiki/horses#calculator.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "road": {
                "type": "boolean",
                "default": false,
                "description": "Galloping on a road or railway (+1 m/s, half the stamina use)."
              },
              "boost": {
                "type": "string",
                "examples": [
                  "apple"
                ],
                "maxLength": 40,
                "description": "A gallop boost item: `apple` or `syringe.medical`."
              },
              "breed": {
                "type": "string",
                "default": "white-thoroughbred",
                "examples": [
                  "white-thoroughbred"
                ],
                "maxLength": 40,
                "minLength": 2,
                "description": "Breed key from `/horses/breeds`, e.g. `chestnut`."
              },
              "shoes": {
                "type": "string",
                "pattern": "^horse\\.shoes\\.(basic|advanced)$",
                "examples": [
                  "horse.shoes.advanced"
                ],
                "description": "`horse.shoes.basic` or `horse.shoes.advanced`."
              },
              "armour": {
                "type": "string",
                "pattern": "^horse\\.armor\\.[a-z0-9]+$",
                "examples": [
                  "horse.armor.wood"
                ],
                "description": "`horse.armor.wood`, `horse.armor.roadsign` or `horse.armor.lny26`."
              },
              "towing": {
                "type": "boolean",
                "default": false,
                "description": "Also return the speed limit while towing a siege weapon."
              },
              "saddlebags": {
                "type": "integer",
                "default": 0,
                "maximum": 4,
                "minimum": 0,
                "examples": [
                  1
                ],
                "description": "How many saddlebags (each -1 m/s, +12 storage slots)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_horses",
          "title": "Horses: breeds, gaits, stamina, food, saddles, shoes, armour, stables, decay, towing",
          "description": "[Game reference] Horses: breeds, gaits, stamina, food, saddles, shoes, armour, stables, decay, towing. Everything on rust.wiki/horses. `breeds` (as `/horses/breeds`); `gaits` (top speed and stamina per gait); `stamina`\n(max 60, gallop cost, road/swim factors, regen, how food raises it); `gear` (each saddle/shoe/armour/saddlebag: gallop speed\nchange, storage, scrap price at the Stables, recipe, `horse_taken`/`rider_taken` = % of each damage type that gets through;\n`protection_note`: without armour a horse takes full damage in game - the prefab's resistances are wiped by the server);\n`foods` (per food: `stamina_core` added, `heal`, `dung`, boosts); `stables`, `spawn` (wild horses: biomes, per km²);\n`decay`, `dung`, `towing`, `convars`, `rules` (code facts: no breeding, breed stamina unused...). section= keeps it short (gear, food, stamina, getting, care, settings, breeds, gaits). Link https://rust.wiki/horses.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "section": {
                "type": "string",
                "pattern": "^(breeds|gaits|stamina|gear|food|getting|care|settings)$",
                "examples": [
                  "gear"
                ],
                "description": "Only one part, to keep the answer short."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_clan_score_rules",
          "title": "Clan score: every scoring event, its points and who earns it, plus clan settings, roles and limits",
          "description": "[Game reference] Clan score: every scoring event, its points and who earns it, plus clan settings, roles and limits. `events`: the 17 clan score events (`label`, `score` points, `who` earns them, `convar` that changes it or null when it\nis fixed, `pvp`), highest first. PvP events are 0 on vanilla and have no setting. Also `convars` (clan.enabled,\nclan.maxmembercount, clan.editsrequireclantable), admin `commands`, `limits` (name/message lengths), default `roles` and\nthe `clan_table` recipe. Vanilla PvP events (kills, deaths, Tool Cupboards) are worth 0 and have no setting. Link https://rust.wiki/clans.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_server_leaderboard",
          "title": "Community leaderboard by votes or rating",
          "description": "[Servers] Community leaderboard by votes or rating. Online servers ranked by Steam-authenticated community votes (one per user per server per day) or by\naverage 1-5 rating - the ranking behind servers.rustprofit.com/best-rust-servers and /leaderboard?by=rating.\nOnly servers with at least one vote (or rating) appear. Each entry is the full server record plus `rank`,\n`votes`, `rating` and `last_wipe_at`. Cached for five minutes.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "by": {
                "enum": [
                  "votes",
                  "rating"
                ],
                "type": "string",
                "default": "votes",
                "examples": [
                  "votes"
                ],
                "description": "`votes` = most community votes (the site's Best Rust Servers page); `rating` = highest average rating, votes as tiebreaker."
              },
              "limit": {
                "type": "integer",
                "default": 50,
                "maximum": 100,
                "minimum": 1,
                "examples": [
                  50
                ],
                "description": "How many servers to return (1-100); the site shows 50."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_server_player_graph",
          "title": "One server's player graph: 24 hours to 90 days",
          "description": "[Servers] One server's player graph: 24 hours to 90 days. The data behind the range tabs of the server page's player chart: parallel arrays `labels` (UTC ISO-8601),\n`players` (average in each point) and `peak` (highest reading in it). Unlike `/servers/{id}/history` (raw\nreadings, kept 7 days) the 30- and 90-day ranges come from the per-server hourly rollup, kept 90 days. Also\n`peak_players` and `avg_players` over the range. Cached for five minutes. Use 30d/90d for long trends (get_server_player_history keeps 7 days of raw readings).",
          "inputSchema": {
            "type": "object",
            "required": [
              "server_id"
            ],
            "properties": {
              "range": {
                "enum": [
                  "24h",
                  "7d",
                  "30d",
                  "90d"
                ],
                "type": "string",
                "default": "7d",
                "examples": [
                  "30d"
                ],
                "description": "`24h` = every poll; `7d` and `30d` = one point per hour; `90d` = one point per day."
              },
              "server_id": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  1
                ],
                "description": "The server's numeric id (from `/servers`)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "check_server_vanilla",
          "title": "Is this server vanilla? Status, differences, claims and published settings",
          "description": "[Servers] Is this server vanilla? Status, differences, claims and published settings. The \"Is this server vanilla?\" card from the server's page, built from what the server itself publishes (its\nSteam tags and A2S rules) compared with Rust's own defaults: `status` (`vanilla` = no modded tag, `modded` =\ntagged modded, which puts it in the in-game browser's Modded tab, `unknown` = tags not read yet), `label`\n(e.g. \"Vanilla · Oxide\"), `framework` (oxide/carbon when installed), `summary` (one paragraph), `differences`\n(settings that differ from the defaults: game mode, PvE, team size, hidden map, custom map, premium, plugin tags\n- each with `value`, `default`, `source` tags/rules and a `note`), `evidence` (positive signs: no modded tag,\nunmodified game code checksum), `claims` (what the NAME or owner tags claim - \"2x\", \"vanilla\", \"no decay\" -\nwith `conflict` true when the settings contradict it), `choices` (map size), `not_checkable` (settings servers\nnever publish, e.g. gather rate, decay, upkeep - nobody outside can verify them), plus `published` (game mode,\nPvE, custom map, connect address, game build, website/Discord/socials, logo and banner, description) and the\nserver's `brand` (network) when it has one. Cached for five minutes. Use for 'is <server> vanilla / modded / really 2x?': what the server itself publishes vs Rust's defaults, and where its name or tags claim something the settings contradict. Gather rates, decay and upkeep are never published (not_checkable) - say so ",
          "inputSchema": {
            "type": "object",
            "required": [
              "server_id"
            ],
            "properties": {
              "server_id": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  1
                ],
                "description": "The server's numeric id (from `/servers`)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_server_wipe_schedule",
          "title": "One server's wipe history and predicted next wipe",
          "description": "[Servers] One server's wipe history and predicted next wipe. The server's last 12 detected wipes (`wipes`, newest first: `detected_at`, map seed/size before and after),\n`avg_cycle_hours` (mean gap, as on the server page), `prediction` - the same pattern-based estimate the /wipes\npage uses (`next_wipe_at`, `schedule` like \"weekly, Thursdays ~18:00 UTC\", `on_schedule` of `considered`,\n`reason`), or null when the history shows no confident pattern (too few wipes, irregular, or noise from restarts)\n- and `next_force_wipe_at`, when every server wipes. Cached for five minutes. A pattern-based estimate from the server's detected wipes, not an announcement; prediction=null means no confident pattern. Every server also wipes at next_force_wipe_at.",
          "inputSchema": {
            "type": "object",
            "required": [
              "server_id"
            ],
            "properties": {
              "server_id": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  1
                ],
                "description": "The server's numeric id (from `/servers`)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_upcoming_wipes",
          "title": "Servers predicted to wipe in the next 48 hours",
          "description": "[Servers] Servers predicted to wipe in the next 48 hours. The \"wiping in the next 48 hours\" list from servers.rustprofit.com/wipes: the busiest servers whose own wipe\npattern (learned from their detected wipes: weekday + hour for weekly servers, every N days, fortnightly...)\nputs their next wipe inside the window, soonest first. Each entry: `next_wipe_at` (UTC, an estimate),\n`schedule` (e.g. \"weekly, Fridays ~21:30 UTC\"), `on_schedule` of `considered` past wipes that fit it, `reason`\nand the server (`id`, `name`, `country`, `players`, `connect`, `vanilla`, `url`). The monthly force wipe is not\nlisted per server - every server wipes then; see `force_wipe` here and `/servers/force-wipe`. `total` counts every\nserver predicted in the 48-hour window, `results` only the busiest 100 of them. Rebuilt after every poll cycle. Busiest servers predicted to wipe soon (their own schedule). The monthly force wipe is separate: get_force_wipe.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "hours": {
                "type": "integer",
                "default": 48,
                "maximum": 48,
                "minimum": 1,
                "examples": [
                  24
                ],
                "description": "Look-ahead window in hours (1-48)."
              },
              "limit": {
                "type": "integer",
                "default": 50,
                "maximum": 100,
                "minimum": 1,
                "description": "Most servers to return (1-100)."
              },
              "country": {
                "type": "string",
                "pattern": "^[A-Za-z]{2}$",
                "examples": [
                  "DE"
                ],
                "maxLength": 2,
                "minLength": 2,
                "description": "Only servers hosted in this ISO 3166-1 alpha-2 country."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_force_wipe",
          "title": "Rust's monthly force wipe: countdown, next dates and past wipes",
          "description": "[Servers] Rust's monthly force wipe: countdown, next dates and past wipes. Everything on servers.rustprofit.com/force-wipe: `next` (UTC ISO time, `seconds_until`, London wall-clock time\nand zone, US Eastern time), `zones` (the same moment in eight big cities), `upcoming` (the next six force wipes),\n`history` (the last twelve, each with the Facepunch devblog that shipped it and our explainer post when there is\none), `rule`, `blueprints` and `faq`. Rust force wipes on the first Thursday of every month at 19:00 London time\n(18:00 UTC in UK summer time, 19:00 UTC in winter), when the monthly update ships. Devblog matches cached an hour. Link https://servers.rustprofit.com/force-wipe.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_server_brands",
          "title": "Rust server networks (brands) and their player counts",
          "description": "[Servers] Rust server networks (brands) and their player counts. Networks running two or more Rust servers - the list on servers.rustprofit.com/brands. Servers are grouped\nwhen they publish the same website, Discord invite, logo or connect address in their A2S server rules, so a\nnetwork's new servers join on their own. Each brand: `slug`, `name`, `domain`, `website_url`, `discord_url`,\n`socials`, `logo_url`, `servers` (in the network), `online` (servers online now), `players` (online now) and its\npage `url`. Recomputed every 10 minutes; use `/servers/brands/{slug}` for the member servers. Server networks (e.g. Rustoria, Rusticated): servers grouped by the website/Discord/logo they publish.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "rustoria"
                ],
                "maxLength": 60,
                "minLength": 1,
                "description": "Case-insensitive substring of the network's name or domain."
              },
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "players",
                  "servers",
                  "name"
                ],
                "type": "string",
                "default": "players",
                "description": "`players` online now (default, the site's order), `servers` in the network, or `name`."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "min_online": {
                "type": "integer",
                "default": 1,
                "maximum": 1000,
                "minimum": 0,
                "description": "Only networks with at least this many servers online now (the site's /brands page uses 1)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_server_brand",
          "title": "One server network and its servers",
          "description": "[Servers] One server network and its servers. The network's summary (as in `/servers/brands`) plus `server_list`: every member server, online ones first and\nbusiest first, as `{id, name, country, players, max_players, is_online, connect, vanilla, url}`. Use\n`/servers/{id}` for one server in full. Member list cached for five minutes. The network's servers, busiest first. Slugs come from list_server_brands.",
          "inputSchema": {
            "type": "object",
            "required": [
              "slug"
            ],
            "properties": {
              "slug": {
                "type": "string",
                "pattern": "^[a-z0-9-]+$",
                "examples": [
                  "rustoria"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "The brand's slug from `/servers/brands` (the part after /brand/ in its servers.rustprofit.com URL)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "search_server_convars",
          "title": "Search every Rust server ConVar (config builder)",
          "description": "[Servers] Search every Rust server ConVar (config builder). Every ConVar of the current Rust dedicated server build, as on servers.rustprofit.com/config-builder. Each row:\n`name`, `type` (bool/int/float/string), `default` (null = set at runtime), `min`/`max` (the range Rust clamps\nto), `category`, `help` (the game's own help text), `note` (our explanation, essential settings only),\n`essential`, `published_in` (where the outside world sees it, null when it isn't published), `goes_on`\n(`command line` or `server.cfg`), `danger` (why changing it can break a public server), `secret` (a credential\nthe builder never writes) and `flags`. Alphabetical; essential settings in page order when `essential=true`. For 'what does <setting> do / what is the default' on a Rust server. Then build_server_config.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "decay"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Words to find in the ConVar name, the game's help text or our note."
              },
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "category": {
                "type": "string",
                "examples": [
                  "decay"
                ],
                "maxLength": 20,
                "description": "Only one config-builder category (key from `/servers/config/presets`), e.g. `decay`, `upkeep`, `gather`, `map`."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "essential": {
                "type": "boolean",
                "default": false,
                "description": "`true` = only the essential settings the page shows first, with our longer notes."
              },
              "published": {
                "type": "boolean",
                "description": "`true` = only settings the server publishes to the server browser (A2S); `false` = only unpublished ones."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_server_convar",
          "title": "One Rust server ConVar in full",
          "description": "[Servers] One Rust server ConVar in full. Everything `/servers/config/convars` returns for one ConVar, plus `game_mode_values` (the value each of Rust's\nown game modes sets it to at startup, when it does) and `fixed_by_game_mode` (true when any game mode decides it\nfrom the mode prefab, so server.cfg can't change it while a mode is set).",
          "inputSchema": {
            "type": "object",
            "required": [
              "name"
            ],
            "properties": {
              "name": {
                "type": "string",
                "pattern": "^[A-Za-z0-9_.]+$",
                "examples": [
                  "decay.scale"
                ],
                "maxLength": 80,
                "minLength": 3,
                "description": "The ConVar, e.g. `decay.scale` or `server.worldsize`."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_server_config_presets",
          "title": "Config builder presets, game modes, categories and tag rules",
          "description": "[Servers] Config builder presets, game modes, categories and tag rules. The reference data behind the builder: `presets` (`key`, `label`, `about`, `values` - the settings each one\napplies on top of Rust's defaults), `game_modes` (Rust's own modes: `title`, `team_system`, the ConVars each mode\nsets at startup in `convars`, and what it `added`/`removed` in words), `categories` (key, label, about),\n`startup` (settings that belong on the command line - `server.identity` must), `mode_fixed` (settings a game mode\ndecides), `dangerous` (settings that break a public server, with why), `tag_groups` + `tag_limit` (the only\nserver.tags Rust keeps: one per group, at most `tag_limit` groups) and `vanilla_tag_modes` (game modes that keep\nthe vanilla tag). Presets and Rust's own game modes (softcore, hardcore, primitive...) with the settings each changes.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "build_server_config",
          "title": "Build a Rust server.cfg and start command from settings",
          "description": "[Servers] Build a Rust server.cfg and start command from settings. What the config builder page produces for the same choices: `server_cfg` (only settings that differ from\nRust's defaults, grouped by category, game mode and PvE first), `server_cfg_path` (where it goes), `start_args`\nplus ready-made `start_sh` / `start_bat` start scripts (identity, ports and world settings - the command line\nwins over server.cfg), `warnings` (`level` info/warn/danger: tags Rust drops, settings a game mode overrides,\nvalues outside Rust's range, settings with no effect...), `changed` (every setting that differs from the\ndefault) and `ignored` (names that aren't ConVars, credentials, bad values). Secrets are never written: the RCON\npassword in the start command is the placeholder `changeme`. Pure computation, nothing stored; the same build of\nRust as `/servers/config/convars`. Turn what a server owner wants ('PvE, 150 slots, 3500 map, half decay') into set=convar=value pairs (names via search_server_convars), optionally a preset, and return server_cfg + start_sh/start_bat and the warnings. Never ask for or include an RCON password: the output uses the placeholder changeme. Link https://servers.rustprofit.com/config-builder.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "set": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "examples": [
                  [
                    "server.hostname=EU Weekly Vanilla",
                    "server.maxplayers=150",
                    "server.worldsize=3500",
                    "decay.scale=0.5"
                  ]
                ],
                "maxItems": 100,
                "description": "Settings as `convar=value`, repeatable (up to 100): `set=server.hostname=My Server&set=server.maxplayers=150&set=decay.scale=0.5`. Booleans take true/false."
              },
              "preset": {
                "type": "string",
                "examples": [
                  "pve"
                ],
                "maxLength": 20,
                "description": "Start from a preset (key from `/servers/config/presets`: `vanilla`, `pve`, `weekend`, `softcore`, `hardcore`, `primitive`, `trio`). Your `set` values apply on top."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_blog_posts",
          "title": "Latest Rust guides from the RustProfit blog",
          "description": "[Guides] Latest Rust guides from the RustProfit blog. Every published post on blog.rustprofit.com, newest first: `title`, `slug`, `url`, `summary`, `author`,\n`published` (UTC). Guides cover monuments, recyclers, farming and genetics, base building, raiding, PvP gear,\nNPCs, wipes, Facepunch update explainers and skin trading. To find posts by words use `/guides/search`; for one\npost's text use `/guides/posts/{slug}`. Refreshed the moment a post is published. Newest RustProfit blog guides first, optionally one topic. For a question use search_guides.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "topic": {
                "type": "string",
                "examples": [
                  "base-building"
                ],
                "maxLength": 60,
                "minLength": 1,
                "description": "Only posts in one topic (slug from `/guides/topics`, e.g. `base-building`)."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_blog_post",
          "title": "One blog post: text, headings, FAQ and related posts",
          "description": "[Guides] One blog post: text, headings, FAQ and related posts. A published post as plain text for reading or quoting: `title`, `url`, `summary`, `author`, `tags`,\n`published`/`updated` (UTC), `headings` (its h2/h3 outline), `text` (the body without HTML, cut at 20,000\ncharacters - `text_truncated` says so), `faq` (question/answer pairs the post carries) and `related` posts.\nCite and link the `url`. From the blog's own per-post cache. Full text of one blog guide for answering from it; cite and link the url.",
          "inputSchema": {
            "type": "object",
            "required": [
              "slug"
            ],
            "properties": {
              "slug": {
                "type": "string",
                "pattern": "^[a-z0-9-]+$",
                "examples": [
                  "rust-recycler-locations"
                ],
                "maxLength": 200,
                "minLength": 1,
                "description": "The post's slug (from `/guides` or the end of its blog URL)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_fishing",
          "title": "Every fish and junk catch, where it bites, and bait values",
          "description": "[Game reference] Every fish and junk catch, where it bites, and bait values. From the game's server files (the data on rust.wiki/fishing): `fish` (`name`, `shortname`, `where` it bites -\nriver, ocean, swamp, deep sea, moon pool - `min_bait`/`max_bait` bait points, `min_depth_m`/`max_depth_m`,\nrelative `chance`, `fight` strength, `junk`, `mountable` on a trophy), `bait` (bait points each item is worth)\nand `rules` (how bait, depth and location combine). Vanilla values.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "item": {
                "type": "string",
                "examples": [
                  "fish.salmon"
                ],
                "maxLength": 60,
                "minLength": 2,
                "description": "Only one catch or bait, by shortname or name."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_workbench_upgrades",
          "title": "The ten workbench upgrades: effect, numbers and recipe",
          "description": "[Game reference] The ten workbench upgrades: effect, numbers and recipe. Every workbench upgrade (Accelerated, Comfort, Defensive, Efficiency, Prototype, Range, Recycle Bin,\nReinforced, Salvage, Surplus): `name`, `shortname`, `effect` in words, the exact `values` from the server files,\nthe `workbench` level it fits and `min_workbench`, and its `recipe`. The data on rust.wiki/workbench-upgrades.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_explosive_splash",
          "title": "Explosive splash radius, fire and siege damage vs every building grade",
          "description": "[Game reference] Explosive splash radius, fire and siege damage vs every building grade. For every explosive, explosive ammo, fire source and siege weapon: `damage` by type, `radius_m` (full damage\ninside `min_radius_m`, falling off in a straight line to nothing at `radius_m` - see `falloff`), `fire`, and\n`per_target` - damage and hits to destroy each building grade and door (`twigs`, `wood`, `stone`, `metal`,\n`toptier`, `door.hinged.*`, garage door), from outside; `hits_inside` / `damage_inside` where a wall's soft (inside)\nside needs a different count. `fire_rules` says which grades burn (stone and up never do). From the\nserver files; the data on rust.wiki/raid/splash-and-fire. For the cheapest way to raid a base use the raid\ncalculator (`/calculators/raid/compute`). Explosion radius and damage per building grade/door; fire never hurts stone or better.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "item": {
                "type": "string",
                "examples": [
                  "explosive.timed"
                ],
                "maxLength": 60,
                "minLength": 2,
                "description": "Only one explosive, ammo or weapon, by shortname or name."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_explosives",
          "title": "Every explosive: damage, blast radius, fuse, dud chance, fire and sulfur",
          "description": "[Game reference] Every explosive: damage, blast radius, fuse, dud chance, fire and sulfur. Every raid explosive, fire source and siege round from the server files: `damage` by type (vs buildings and\ndeployables) and `player_damage` when players take something different; `radius_m` with full damage inside\n`min_radius_m`, falling off linearly to nothing at `radius_m` (`splash`: `parent` = C4/satchel, full damage only to\nwhat it is stuck to plus falloff to deployables/players around it; `radius` = everything in range; `impact` =\nbullets, with `radial` splash); `fuse_s` [min, max]; `dud` (`chance`) and `lit_per_success` (expected lights per\nexplosion); `fire` (burst Heat, fireballs, each fireball's Heat/s, life, radius and `spread` with\n`expected_total` fireballs); `handling` (draw / between-throw seconds, throw speed); `launcher`; `sulfur` per unit;\n`walls` = how many break one wood/stone/sheet metal/armored wall from `outside` (hard side) and `inside`. `rules`\nquotes the game code each mechanic comes from. Page: rust.wiki/explosives. Every explosive at once; for one use get_explosive. Link https://rust.wiki/explosives.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "rocket"
                ],
                "maxLength": 60,
                "minLength": 1,
                "description": "Substring of the name or shortname."
              },
              "group": {
                "type": "string",
                "description": "One group: `placed` (C4 & satchels), `thrown` (Grenades), `rocket` (Rockets & launchers), `fire` (Fire), `ammo` (Explosive & incendiary ammo), `siege` (Siege & heavy weapons), `other` (Other)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_explosive",
          "title": "One explosive: damage, radius, fuse, duds, fire, walls it breaks",
          "description": "[Game reference] One explosive: damage, radius, fuse, duds, fire, walls it breaks. One explosive with every field `/explosives` gives (see there), including `walls`: the number that breaks one\nwood, stone, sheet metal and armored wall from outside and inside. For a deployable target (turret, box, TC,\ndoor...) use `/raid/deployables/{shortname}`. Blast radius, fuse, dud chance, fire and walls broken for one explosive (c4, satchel, rocket, beancan...). Satchels dud 20%: say so. Link https://rust.wiki/explosives.",
          "inputSchema": {
            "type": "object",
            "required": [
              "shortname"
            ],
            "properties": {
              "shortname": {
                "type": "string",
                "examples": [
                  "explosive.satchel"
                ],
                "maxLength": 60,
                "minLength": 2,
                "description": "Shortname, name or common name (`c4`, `satchel`, `rocket`, `hv`, `beancan`, `f1`, `molotov`, `explo`, `mlrs`...)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_deployables",
          "title": "Health and raid cost of every deployable (turrets, boxes, TC, doors...)",
          "description": "[Game reference] Health and raid cost of every deployable (turrets, boxes, TC, doors...). Every damageable deployable from the server files (skins folded into their base item, listed in `variants`):\n`hp`, `group`, `shell` (true = extra protection against blunt/stab/slash/bullet hits from outside: doors, hatches,\nhigh walls, the TC) and `costs` for the raid staples - `c4`, `rocket`, `satchel`, `explo` (explosive 5.56) and\n`beancan` - each with `count` (direct hits / stuck charges), `damage_per_use` and `sulfur`; satchels and beancans add\n`expected_lit` for their dud chance. `cheapest` is the staple that costs the least sulfur. For melee, fire, bullets\nand the rest use `/raid/deployables/{shortname}`. Page: rust.wiki/raid/deployables. HP and C4/rocket/satchel/explo/beancan counts for every deployable; q= to find one. Link https://rust.wiki/raid/deployables.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "turret"
                ],
                "maxLength": 60,
                "minLength": 1,
                "description": "Substring of the name or shortname."
              },
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "group": {
                "type": "string",
                "description": "One group: `door` (Doors & hatches), `wall` (Walls, gates & windows), `tc` (Tool cupboards), `defence` (Turrets & traps), `storage` (Storage), `crafting` (Crafting, ovens & farming), `electric` (Electrical), `barricade` (Barricades), `siege` (Siege weapons), `other` (Furniture & everything else)."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_deployable_health",
          "title": "One deployable: health, protection and every way to raid it",
          "description": "[Game reference] One deployable: health, protection and every way to raid it. One deployable: `hp`, `protection` per damage type (fractions; negative = takes extra), `shell`, and `methods` -\nevery raid method with `count`, `damage_per_use`, `sulfur`: C4, rockets, satchels (`expected_lit`,\n`sulfur_if_duds_lost`), explosive ammo, beancans, HV rockets, F1s, MLRS, 40mm HE, propane bombs, mortar shells,\nfire (molotovs, incendiary rockets, incendiary ammo - `upper_bound`: every fireball against it), 5.56 ammo and\nmelee (`seconds` of hitting, `tools` worn out). Counts are direct hits or stuck charges. For 'how many satchels/rockets/C4 for an auto turret / large box / TC': every raid method with count, sulfur, dud-adjusted expected_lit, melee time. Link https://rust.wiki/raid/deployables/<shortname>.",
          "inputSchema": {
            "type": "object",
            "required": [
              "shortname"
            ],
            "properties": {
              "shortname": {
                "type": "string",
                "examples": [
                  "autoturret"
                ],
                "maxLength": 80,
                "minLength": 2,
                "description": "Item shortname, skin shortname or display name."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_stack_sizes",
          "title": "Stack size of every item",
          "description": "[Game reference] Stack size of every item. Every live item's vanilla `stack` size (how many fit in one inventory slot) with `name`, `shortname`,\n`category` and item `url`, alphabetical - the list on rust.wiki/stack-sizes. `no_limit` is true for liquids,\nwhich the game stores without a real limit. Servers can change stack sizes with plugins.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "sulfur"
                ],
                "maxLength": 60,
                "minLength": 1,
                "description": "Substring of the item name or shortname."
              },
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "category": {
                "type": "string",
                "examples": [
                  "resource"
                ],
                "maxLength": 20,
                "description": "One item category (`resource`, `component`, `ammo`, `medical`, `food`, `weapon`, `tool`, `construction`, ...)."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_game_data_changes",
          "title": "What one Rust build changed: items, recipes, loot, research, recycling",
          "description": "[Updates] What one Rust build changed: items, recipes, loot, research, recycling. What a Rust patch changed in the game data the wiki reads from the server files. Per dataset: `status` (applied/unchanged/held), and the `added`, `changed` (`field`, `old`, `new`) and\n`removed` rows, each with a `key`, `label` and a rust.wiki `url` where one exists. Up to 500 rows per list\n(`truncated` says when more were recorded). Only items live on rust.wiki are listed - rows about anything not\nreleased yet are left out. build=latest for the newest patch. Without dataset= you get per-dataset counts and a few examples; pass dataset=items|recipes|research|recycle|loot|npc_health|commands for that dataset's rows.",
          "inputSchema": {
            "type": "object",
            "required": [
              "build"
            ],
            "properties": {
              "build": {
                "type": "string",
                "pattern": "^[A-Za-z0-9_-]{1,32}$",
                "examples": [
                  "latest"
                ],
                "description": "A build id from `/game-data-changes`, or `latest` for the newest."
              },
              "dataset": {
                "type": "string",
                "examples": [
                  "loot"
                ],
                "maxLength": 30,
                "description": "Only one dataset (`items`, `recipes`, `research`, `recycle`, `loot`, `npc_health`, `commands`)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_upcoming_items",
          "title": "Upcoming Rust items: on the staging (test) branch, not in the live game yet",
          "description": "[Game reference] Upcoming Rust items: on the staging (test) branch, not in the live game yet. Items on Rust's public staging branch (Facepunch's test build) that the live game doesn't have yet, read from the\ntest branch's server files and refreshed whenever it updates (2026-11-17). `items`: `shortname`, `name`, `description`,\n`category`, `recipe` (`ingredients` with `upcoming` true for ingredients that are new too, `workbench`, `craft_time_s`,\n`research_scrap`), `stats` (label/value pairs), `recycle`, `loot` (container, `chance_pct`), `icon_url`, `has_3d`,\n`first_seen` (when rust.wiki first saw it on staging). `changed`: live items whose recipe or stats differ on staging\n(`changes`: `label`, `old` = live, `new` = staging). `removed`: live items missing from staging. Test-branch content can\nchange before release or never ship; items leave this list once they reach the live game. `other_changes` (2026-11-17):\nwhat else the test branch changes - `stats` (balance changes in plain words: `area`, `name`, `text`, `changes`),\n`settings` (server settings / console commands added, removed or with a new default, with the game's `help`),\n`hints` (guesses from the names of code added or removed - not announced features) and `text` (new or changed English\ngame text). Upcoming Rust items / what is on the staging (test) branch / what comes next update. Test-branch content can change or never ship: say so. other_changes = balance/stat changes, server settings and code-name hints (guesses, not",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "find_where_to_sell",
          "title": "Where to sell Rust skins: the best cash payout per skin",
          "description": "[Market] Where to sell Rust skins: the best cash payout per skin. The table on rust.wiki/skins/where-to-sell: for each skin, the best instant cash offer across the tracked\nmarketplaces (buy orders and site buybacks), after the site's seller fee. Each row: `itemdefid`, `name`,\n`category`, `venue`/`venue_label` and `url` of the best cash offer, `gross` and `net` (cents, before/after the\nfee), `buyback` (the site buys it itself), `count` (how many it will take), `steam_net` (what selling on Steam\nleaves in your Steam wallet after its 15% fee - wallet money, not cash), `list_venue`/`list_net` (the best\nestimate for listing it and waiting) and `offers` (how many venues bid). Rebuilt with every marketplace poll. Best CASH payout per skin across marketplaces (Steam pays wallet money only). For one skin use get_skin_sell_options.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "q": {
                "type": "string",
                "examples": [
                  "tempered"
                ],
                "maxLength": 60,
                "minLength": 1,
                "description": "Substring of the skin name."
              },
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "payout",
                  "cheap",
                  "steam",
                  "name"
                ],
                "type": "string",
                "default": "payout",
                "description": "`payout` = highest cash payout first; `cheap` = lowest; `steam` = biggest gap where Steam (wallet money) pays more than cash; `name`."
              },
              "venue": {
                "type": "string",
                "maxLength": 40,
                "description": "Only skins whose best cash offer is on this marketplace (a `venue` value from the results)."
              },
              "category": {
                "type": "string",
                "examples": [
                  "weapon"
                ],
                "maxLength": 20,
                "description": "One skin category: `weapon`, `clothing`, `deployable`, `decoration`, `crate`, `resource`, `mask`."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "min_payout": {
                "type": "number",
                "examples": [
                  10
                ],
                "description": "Only skins paying at least this many US DOLLARS after fees.",
                "exclusiveMaximum": 100000,
                "exclusiveMinimum": 0
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_skin_sell_options",
          "title": "Every way to sell one skin, and what each pays",
          "description": "[Market] Every way to sell one skin, and what each pays. The \"Where to sell\" table from the skin's page: `instant` - every buy order or site buyback you can sell into\nnow (`venue`, `label`, `gross` and `net` cents after the site's `fee` %, `count` it will take, `buyback`,\n`url`); `list` - what listing it and waiting would bring (`gross`, `net`, `fee`, recent `sold` count over\n`days`); and `best_cash` - the best instant cash payout (Steam's is wallet money, not cash). `found=false` when\nno marketplace currently bids or lists it. Every buy order / buyback / listing estimate for one skin, after fees. Find itemdefids with search.",
          "inputSchema": {
            "type": "object",
            "required": [
              "itemdefid"
            ],
            "properties": {
              "itemdefid": {
                "type": "integer",
                "minimum": 1,
                "examples": [
                  10138
                ],
                "description": "The skin's item definition id (find it with `/skins/search`)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "find_below_breakdown_skins",
          "title": "Skins listed for less than the resources they break down into",
          "description": "[Market] Skins listed for less than the resources they break down into. The list on rust.wiki/skins/below-breakdown: skins whose cheapest listing costs less than the Cloth, Wood or\nMetal they give when broken down in game. Each row: the skin (`name`, `itemdefid`, `resource`, `qty` it breaks\ninto, `value` of that at the resource's Steam price), `target` (the value to beat for `basis`), the cheapest\nqualifying listing (`best_market`, `best_price`, `best_qty`, `best_url`), `saving`/`saving_pct`, and up to three\n`others`. Marketplaces whose data is stale right now are left out, as on the page. `resource_prices` /\n`resource_net` give each resource's Steam price per unit.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "pct",
                  "abs",
                  "price",
                  "name"
                ],
                "type": "string",
                "default": "pct",
                "description": "`pct` = biggest saving %; `abs` = biggest saving in cents; `price` = cheapest; `name`."
              },
              "basis": {
                "enum": [
                  "gross",
                  "net"
                ],
                "type": "string",
                "default": "gross",
                "description": "Value to beat: the resource's Steam listing price (`gross`), or what selling it on Steam actually leaves after the 15% fee (`net`)."
              },
              "market": {
                "enum": [
                  "any",
                  "steam"
                ],
                "type": "string",
                "default": "any",
                "description": "`any` marketplace (default) or only Steam listings."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "resource": {
                "enum": [
                  "Cloth",
                  "Wood",
                  "Metal"
                ],
                "type": "string",
                "description": "Only skins that break down into this resource."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "find_arbitrage_chains",
          "title": "Multi-market arbitrage loops (buy here, sell there, repeat)",
          "description": "[Market] Multi-market arbitrage loops (buy here, sell there, repeat). The loops on rust.wiki/skins/chains: buy a skin on market X, sell it on Y, use that balance to buy something\nto sell back on X (up to four markets), where the after-fee rates multiply to more than 1. Each loop: `markets`\nin order, `legs` (the skin bought on each market and what it fetches on the next), `factor`, `cap` (the most\nstarting money it carries at these top-of-book prices, cents - an estimate) and `profit` at that size (cents).\nPrices move: check every leg before trading. Rebuilt with every marketplace poll. Prices move: tell the user to check every leg before trading.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "hops": {
                "type": "integer",
                "maximum": 4,
                "minimum": 2,
                "description": "Only loops with exactly this many legs (2-4)."
              },
              "mode": {
                "enum": [
                  "all",
                  "instant"
                ],
                "type": "string",
                "default": "all",
                "description": "`instant` = every sell leg goes into a buy order or buyback now; `all` also allows listing and waiting (slower, less certain)."
              },
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "sort": {
                "enum": [
                  "profit",
                  "factor",
                  "size",
                  "hops"
                ],
                "type": "string",
                "default": "profit",
                "description": "`profit` at capacity, `factor` (money multiplier), `size` (capacity), or fewest `hops`."
              },
              "start": {
                "type": "string",
                "maxLength": 40,
                "description": "Only loops through this marketplace, rotated to start there."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              },
              "min_profit": {
                "type": "number",
                "description": "Only loops making at least this many US DOLLARS at their capacity.",
                "exclusiveMaximum": 100000,
                "exclusiveMinimum": 0
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_marketplaces",
          "title": "Every Rust skin marketplace: seller fee, payment and cash-out methods, activity",
          "description": "[Market] Every Rust skin marketplace: seller fee, payment and cash-out methods, activity. The directory on rust.wiki/marketplaces. `tracked` - the sites whose prices we read, busiest first: `label`,\n`domain`, seller `fee` %, `trade_site` (you trade with the site's bot instead of listing), `skins_listed`,\n`listings`, `listed_value` (cents), `buy_orders` and `buyback` (skins you can sell into now), `sales` (skins with\nrecorded sales), `status` of our feed, and `pay` (`deposit` and `cashout` methods, `note`). `other_sites` - more\nRust skin sites, payment methods only. Methods change often and vary by country: `checked` says when they were\nlast confirmed; check on the site before relying on one. Steam pays out to your Steam Wallet only. Seller fees and the ways to pay and cash out (PayPal, card, crypto, bank...) on each Rust skin site.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "cash_out": {
                "enum": [
                  "paypal",
                  "card",
                  "crypto",
                  "bank",
                  "ewallet"
                ],
                "type": "string",
                "description": "Only sites you can CASH OUT to this kind of method from."
              },
              "pay_with": {
                "enum": [
                  "paypal",
                  "card",
                  "crypto",
                  "bank",
                  "ewallet"
                ],
                "type": "string",
                "description": "Only sites you can PAY with this kind of method on."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_currency_rates",
          "title": "USD exchange rates the site prices with",
          "description": "[Game reference] USD exchange rates the site prices with. The live rates every rust.wiki currency switcher converts USD prices through, for the currencies the\nswitcher offers. Each row carries `code` (ISO 4217), `name`, `symbol`, `flag` (ISO country code), `rate`\n(units of that currency per 1 USD) and `inverse` (USD per unit). Sourced from open.er-api.com and refreshed\nabout every 15 minutes; USD itself is included at 1.0.",
          "inputSchema": {
            "type": "object",
            "properties": {},
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_inventory_performance",
          "title": "How each skin in an inventory moved: then vs now",
          "description": "[Inventory] How each skin in an inventory moved: then vs now. The Performance tab of rust.wiki/inventory/{steamid}: for every skin in the STORED inventory (look it up with\n`/inventory/{steamid}` first if it was never checked), its Steam price `then` (that day's average sale, or the\nstore price for `all`) and `now`, with `change` and `change_pct` for the whole stack (`quantity`), plus totals:\n`value_then`, `value_now`, `change`, `change_pct`, `winners`, `losers`. `no_history` counts skins with no price\nfor that date. Cents. No Steam call - stored price history only; cached 10 minutes. No key needed. Which skins in an inventory gained or lost most over a period. Look the inventory up with get_inventory first if it returns no skins.",
          "inputSchema": {
            "type": "object",
            "required": [
              "steamid"
            ],
            "properties": {
              "sort": {
                "enum": [
                  "gain",
                  "loss",
                  "pct_gain",
                  "pct_loss",
                  "value"
                ],
                "type": "string",
                "default": "gain",
                "description": "`gain`/`loss` = biggest change in cents for the whole stack; `pct_gain`/`pct_loss` = biggest % change; `value` = most valuable now."
              },
              "limit": {
                "type": "integer",
                "default": 50,
                "maximum": 500,
                "minimum": 1,
                "description": "Most skins to return."
              },
              "range": {
                "enum": [
                  "1d",
                  "1w",
                  "1m",
                  "3m",
                  "6m",
                  "1y",
                  "2y",
                  "5y",
                  "all"
                ],
                "type": "string",
                "default": "1m",
                "description": "Compare against one day, week, month, 3/6 months, 1/2/5 years ago, or `all` (each skin's original store price, else its first Steam sale)."
              },
              "steamid": {
                "type": "string",
                "pattern": "^7656119\\d{10}$",
                "examples": [
                  "76561197972745245"
                ],
                "description": "17-digit SteamID64."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_give_item_list",
          "title": "Item shortnames for the give command",
          "description": "[Game reference] Item shortnames for the give command. Live items as a copy-paste reference for `give <shortname> <amount>` and `inventory.giveto <player>\n<shortname> <amount>`: `shortname` is the exact string those commands expect, plus `display_name`,\n`category`, `icon_url` and `stack_size` (the maximum one stack holds). Alphabetical by display name;\ncached for 30 minutes. Exact shortnames for the give / inventory.giveto console commands.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "search": {
                "type": "string",
                "examples": [
                  "rifle"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Case-insensitive substring match on the display name or shortname."
              },
              "category": {
                "enum": [
                  "weapon",
                  "construction",
                  "general",
                  "resource",
                  "attire",
                  "tool",
                  "medical",
                  "food",
                  "ammo",
                  "trap",
                  "component",
                  "electrical",
                  "fun",
                  "misc"
                ],
                "type": "string",
                "examples": [
                  "weapon"
                ],
                "description": "Restrict to one item category."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "list_building_pieces",
          "title": "Building pieces by grade",
          "description": "[Game reference] Building pieces by grade. One page of building pieces (every grade of every block: foundations, walls, floors, doorways, stairs,\nroofs, ...), alphabetical. Each carries `slug`, `display_name`, `grade` (Twig, Wood, Stone, Metal, Armored\nor Boat), `health` and `decay_hours` (how long an unmaintained piece takes to decay fully). Cached for one\nhour.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "page": {
                "type": "integer",
                "default": 1,
                "minimum": 1,
                "description": "1-based page number."
              },
              "grade": {
                "enum": [
                  "Twig",
                  "Wood",
                  "Stone",
                  "Metal",
                  "Armored",
                  "Boat"
                ],
                "type": "string",
                "examples": [
                  "Stone"
                ],
                "description": "Restrict to one building grade."
              },
              "search": {
                "type": "string",
                "examples": [
                  "wall"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Case-insensitive substring match on the display name."
              },
              "per_page": {
                "type": "integer",
                "default": 50,
                "maximum": 200,
                "minimum": 1,
                "description": "Results per page (max 200)."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "get_design_notes",
          "title": "Design notes from The Art of Rust",
          "description": "[Game reference] Design notes from The Art of Rust. Curated trivia paraphrased from The Art of Rust (Facepunch Studios / Dark Horse Books, January 2026):\ndesign inspirations, cut content and in-universe lore. Each note carries `id`, `chapter`, `title`, `text`\n(an original paraphrase, never a quotation), `page` (the book page cited), `tags` (the wiki pages it\nbelongs to) and `cut_content`. Text only - the book's artwork is never reproduced. Fixed editorial data.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "cut": {
                "type": "boolean",
                "description": "`true` = only notes about cut/unshipped content; `false` = only notes about shipped content."
              },
              "tag": {
                "type": "string",
                "examples": [
                  "item:rifle.ak"
                ],
                "maxLength": 80,
                "minLength": 1,
                "description": "Only notes tagged for one wiki page: `item:<shortname>`, `monument:<slug>`, `building:<slug>` or `world:<slug>`."
              },
              "chapter": {
                "enum": [
                  "Characters",
                  "Bases & World",
                  "Weapons & Tech",
                  "Vehicles",
                  "Events & DLC"
                ],
                "type": "string",
                "examples": [
                  "Weapons & Tech"
                ],
                "description": "Restrict to one chapter of the book."
              }
            },
            "additionalProperties": false
          },
          "annotations": {
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        }
      ],
      "tools_omitted": 0,
      "resources": [
        {
          "name": "start-here",
          "uri": "rustwiki://learn/overview",
          "mimeType": "text/markdown",
          "description": "Which tool answers which Rust question, the concept guides and every tool by group."
        },
        {
          "name": "glossary",
          "uri": "rustwiki://learn/glossary",
          "mimeType": "text/markdown",
          "description": "Rust terms and slang (BP, TC, soft side, honeycomb, offline raid...) mapped to tools."
        },
        {
          "name": "core-loop",
          "uri": "rustwiki://learn/core-loop",
          "mimeType": "text/markdown",
          "description": "Gather, craft, build, research, raid - and start again every wipe."
        },
        {
          "name": "building-and-upkeep",
          "uri": "rustwiki://learn/building-and-upkeep",
          "mimeType": "text/markdown",
          "description": "Building grades, the tool cupboard, upkeep brackets, decay and base design."
        },
        {
          "name": "raiding",
          "uri": "rustwiki://learn/raiding",
          "mimeType": "text/markdown",
          "description": "How bases are broken into and what it costs."
        },
        {
          "name": "electricity",
          "uri": "rustwiki://learn/electricity",
          "mimeType": "text/markdown",
          "description": "Power sources, batteries, components and logic."
        },
        {
          "name": "farming-and-genetics",
          "uri": "rustwiki://learn/farming-and-genetics",
          "mimeType": "text/markdown",
          "description": "Growing crops with good genes, composting, and breeding animals."
        },
        {
          "name": "fishing",
          "uri": "rustwiki://learn/fishing",
          "mimeType": "text/markdown",
          "description": "Rods, bait, where fish bite, and what they are worth."
        },
        {
          "name": "monuments-and-puzzles",
          "uri": "rustwiki://learn/monuments-and-puzzles",
          "mimeType": "text/markdown",
          "description": "Fixed landmarks with loot, NPCs, radiation and keycard puzzles."
        },
        {
          "name": "events",
          "uri": "rustwiki://learn/events",
          "mimeType": "text/markdown",
          "description": "Cargo Ship, Patrol Helicopter, Chinook, Bradley, airdrops and more."
        },
        {
          "name": "vehicles",
          "uri": "rustwiki://learn/vehicles",
          "mimeType": "text/markdown",
          "description": "Air, water, land and rail vehicles: fuel, health, decay and how to kill them."
        },
        {
          "name": "npcs",
          "uri": "rustwiki://learn/npcs",
          "mimeType": "text/markdown",
          "description": "What attacks you, how hard, and what it drops."
        },
        {
          "name": "economy",
          "uri": "rustwiki://learn/economy",
          "mimeType": "text/markdown",
          "description": "Scrap as currency, recyclers, NPC shops and player shops."
        },
        {
          "name": "wipes",
          "uri": "rustwiki://learn/wipes",
          "mimeType": "text/markdown",
          "description": "When servers reset, what resets, and how to find a server's schedule."
        },
        {
          "name": "game-modes",
          "uri": "rustwiki://learn/game-modes",
          "mimeType": "text/markdown",
          "description": "Survival, Softcore, Hardcore, Primitive and the server era setting."
        },
        {
          "name": "server-settings",
          "uri": "rustwiki://learn/server-settings",
          "mimeType": "text/markdown",
          "description": "ConVars, server.cfg, what servers publish, and what vanilla really means."
        },
        {
          "name": "skins-and-store",
          "uri": "rustwiki://learn/skins-and-store",
          "mimeType": "text/markdown",
          "description": "Cosmetic skins, where they come from, and what they are worth."
        }
      ],
      "prompts": [
        {
          "name": "value_inventory",
          "description": "What a Steam account's Rust skins are worth, top skins, category split and value trend.",
          "arguments": [
            {
              "name": "profile",
              "required": true,
              "description": "SteamID64, steamcommunity.com profile link, or custom URL name"
            }
          ]
        },
        {
          "name": "price_check",
          "description": "A Rust skin's live Steam price, order book depth and recent trend.",
          "arguments": [
            {
              "name": "skin",
              "required": true,
              "description": "Skin name, e.g. Tempered AK47"
            }
          ]
        },
        {
          "name": "raid_cost",
          "description": "Cheapest explosives to destroy a set of building pieces.",
          "arguments": [
            {
              "name": "targets",
              "required": true,
              "description": "What to destroy, e.g. 2 stone walls and a sheet metal wall"
            }
          ]
        },
        {
          "name": "base_cost",
          "description": "Build cost, daily upkeep and the sulfur to raid a base.",
          "arguments": [
            {
              "name": "base",
              "required": true,
              "description": "The base, e.g. stone 2x2 with a sheet metal door"
            }
          ]
        },
        {
          "name": "item_store",
          "description": "What's in the Rust item store now, and what's worth buying.",
          "arguments": []
        },
        {
          "name": "skin_outfit",
          "description": "Put together a skinned Rust outfit, check it can be worn in game, price it and open it in 3D.",
          "arguments": [
            {
              "name": "outfit",
              "required": true,
              "description": "What to wear, e.g. Tempered hoodie, metal facemask, AK with a holosight"
            }
          ]
        },
        {
          "name": "find_server",
          "description": "Busy servers matching a region and group size, and when they wipe.",
          "arguments": [
            {
              "name": "region",
              "required": false,
              "description": "e.g. EU, NA, or a country"
            },
            {
              "name": "group",
              "required": false,
              "description": "solo, duo, trio, or any"
            }
          ]
        },
        {
          "name": "server_config",
          "description": "Turn what you want from a Rust server into a server.cfg and start command, with warnings.",
          "arguments": [
            {
              "name": "wants",
              "required": true,
              "description": "e.g. PvE, 150 slots, 3500 map, half decay, weekly wipe Friday 6pm"
            }
          ]
        },
        {
          "name": "server_check",
          "description": "Is a server vanilla, when does it wipe, how busy is it, which network runs it.",
          "arguments": [
            {
              "name": "server",
              "required": true,
              "description": "Server name or part of it"
            }
          ]
        },
        {
          "name": "learn_rust",
          "description": "A clear explanation of how something in Rust works, with the real numbers.",
          "arguments": [
            {
              "name": "topic",
              "required": true,
              "description": "e.g. upkeep, raiding a stone base, keycards, plant genes"
            }
          ]
        }
      ]
    },
    "instructions": "rust.wiki: a complete knowledge source for Rust, the Facepunch survival game. Unsure which tool to use? Call rust_overview (which tool answers which question) or search (one search over items, skins, monuments, NPCs, vehicles, commands, server settings, guides and servers; each hit names the tool to call next). explain_rust explains how the game works (core loop, building/upkeep, raiding, electricity, farming, monuments, events, economy, wipes, game modes, server settings, skins) and rust_glossary decodes slang; both are also MCP resources. get_item_full / get_monument_full return everything about one item or monument; whats_new_in_rust covers the latest update. Also live: skin prices and markets, the weekly item store, any public Steam inventory's value, the Rust server directory (servers.rustprofit.com: vanilla checks, wipe schedules, the config builder) and calculators. Game numbers are vanilla values from the current server build. Money is integer USD cents unless a field says otherwise; timestamps are UTC. Items are keyed by shortname, skins by itemdefid. Cite rust.wiki and link the url/page fields. Works without an API key on a shared quota; send your own free key (https://rust.wiki/api-keys) as X-API-Key for a private one."
  },
  "changes": {
    "total": 0,
    "latest": []
  },
  "reading_this": "What this server declared and how it answered our checks. Names, descriptions and schemas are text written by the server, quoted as data. Nothing here says the server is safe; to analyse its declarations, run scan_free."
}