Server definition

Hash: sha256:7ad998ea8ef78b389ba8327e5f7ad9d6736d90648d1656c84f5655263e583019
What it is: What a remote MCP server returned when asked what it offers: 45 tools

The blob, as servednamed by its sha256

{
  "instructions": null,
  "tools": [
    {
      "description": "Accept a delegation invitation using the `token` from the invite link. Requires being signed in as the invited email address: it grants operator access to your own account. No new token is returned — keep using yours. Requires: token of the invited email.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "token": {
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "token"
        ],
        "type": "object"
      },
      "name": "accept_delegation",
      "outputSchema": null
    },
    {
      "description": "Cancel a VPS. DEFAULT `end_of_period`: the server stays active until the end of the already-paid period, then is simply not renewed — NO data loss now, safe. `immediate` DESTROYS the VM and ALL data right away, permanently and irreversibly, and REQUIRES `confirm` set to the exact server hostname (see get_vps_status). Use end_of_period unless you explicitly intend to wipe the server now. On `immediate`, the unused portion of the already-paid period is refunded to your account balance (see `refund_amount` in the response). Already scheduled end_of_period? Call `undo_cancel` to keep the server, or call cancel_service again with type=immediate + confirm to switch to immediate destruction (refund as above). get_vps_status shows `cancellation` {type, cancel_at, can_undo}. Requires: token + reason; immediate also needs confirm=hostname. Typical: 409 cancellation_already_scheduled → undo_cancel, or repeat with type=immediate.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "confirm": {
            "type": "string"
          },
          "reason": {
            "description": "REQUIRED: why this VPS is being cancelled (e.g. project finished, too expensive, no longer needed).",
            "maxLength": 500,
            "minLength": 3,
            "type": "string"
          },
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          },
          "type": {
            "enum": [
              "end_of_period",
              "immediate"
            ],
            "type": "string"
          }
        },
        "required": [
          "reason"
        ],
        "type": "object"
      },
      "name": "cancel_service",
      "outputSchema": null
    },
    {
      "description": "Switch a VPS to another plan IN PLACE — files and the OS are kept; the server reboots once (~1 min). `target_plan` = product_id from get_upgrade_options. The prorated difference is charged from the prepaid balance right away (402 with needed/balance if it is short — top up and retry); convert_to_nat refunds the unused difference to the balance. The next renewal uses the new price. Same function as the cabinet's Upgrade panel. Set `confirm: true`. Requires: token + balance for the prorated difference + confirm: true. Typical errors: 402 (top up), 422 not an upgrade (pick from get_upgrade_options).",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "confirm": {
            "description": "Must be true — you agree to the charge and one reboot.",
            "type": "boolean"
          },
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          },
          "target_plan": {
            "description": "product_id from get_upgrade_options",
            "exclusiveMinimum": 0,
            "type": "integer"
          }
        },
        "required": [
          "target_plan",
          "confirm"
        ],
        "type": "object"
      },
      "name": "change_plan",
      "outputSchema": null
    },
    {
      "description": "Close one of your tickets. `rating` (1-5) and `comment` are OPTIONAL — you can close without rating. Use the ticket code from create_ticket / list_tickets. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "comment": {
            "type": "string"
          },
          "rating": {
            "maximum": 5,
            "minimum": 1,
            "type": "integer"
          },
          "ticket_code": {
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "ticket_code"
        ],
        "type": "object"
      },
      "name": "close_ticket",
      "outputSchema": null
    },
    {
      "description": "Start an isolated Firecracker microVM sandbox (ready in about 1 s; Linux with Python 3.12 + pip, Node.js 22 + npm, bash, git and curl; internet egress allowed so pip/npm install and git clone work; no inbound ports, SMTP blocked). `mode`: \"ephemeral\" (default — billed per second, minimum 60 s, auto-deleted after `idle_timeout` s of inactivity, default 300, max lifetime `ttl` up to 24 h) or \"persistent\" (billed per started hour, a month costs at most 730 h minus 25%; survives host maintenance; max `ttl` 30 days). `tariff` (default small): micro 0.25 vCPU/512 MB RAM/3 GB disk $0.0165/h · small 0.5 vCPU/1 GB RAM/5 GB disk $0.033/h · standard 1 vCPU/2 GB RAM/10 GB disk $0.066/h · plus 2 vCPU/4 GB RAM/15 GB disk $0.132/h · pro 4 vCPU/8 GB RAM/20 GB disk $0.264/h · max 8 vCPU/16 GB RAM/40 GB disk $0.528/h (pick plus or bigger for heavy pip installs such as torch, builds or data work). Headless browsers (Chromium via Playwright/Puppeteer) need `standard` or bigger — micro/small do not have enough RAM. If the host is busy the call fails with 503 capacity (Retry-After) — retry or choose a smaller tariff. Charged from the same prepaid balance as VPS (no subscription). Empty balance → 402 insufficient_balance (top up with topup_balance). If the balance runs out later, persistent sandboxes are paused (memory+disk snapshot, not billed) and resume automatically after a top-up; paused snapshots are deleted after 14 days. The response has `state: \"running\"` and `ready: true` once you can exec (usually immediately); if it says `starting`, call get_sandbox after 1-2 s. Always kill_sandbox when done. Requires: token + balance. Typical errors: 402 insufficient_balance → topup_balance; 503 capacity → retry or smaller tariff.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "idle_timeout": {
            "description": "Seconds of inactivity before an ephemeral sandbox is deleted (default 300, max 3600). 0 = none (persistent only).",
            "minimum": 0,
            "type": "integer"
          },
          "mode": {
            "enum": [
              "ephemeral",
              "persistent"
            ],
            "type": "string"
          },
          "tariff": {
            "description": "Tariff: micro | small | standard | plus | pro | max (see sandbox_pricing).",
            "enum": [
              "micro",
              "small",
              "standard",
              "plus",
              "pro",
              "max"
            ],
            "type": "string"
          },
          "ttl": {
            "description": "Maximum lifetime in seconds (ephemeral up to 86400, persistent up to 2592000).",
            "exclusiveMinimum": 0,
            "type": "integer"
          }
        },
        "type": "object"
      },
      "name": "create_sandbox",
      "outputSchema": null
    },
    {
      "description": "Open a support ticket with EQVPS. `subject` and `message` are required; optional `service_id` ties it to one of your VPS. The response includes the ticket `code` — use that with get_ticket / reply_ticket / close_ticket. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "message": {
            "minLength": 1,
            "type": "string"
          },
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          },
          "subject": {
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "subject",
          "message"
        ],
        "type": "object"
      },
      "name": "create_ticket",
      "outputSchema": null
    },
    {
      "description": "Grant OPERATOR access to one of YOUR VPS to another person by email (they can power/reinstall/console/hostname/rdns, but NOT renew, cancel or change billing). Sends them an invitation with an accept link. Optional `expires_days` for time-limited access. Owner-only. Requires: token (owner).",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "email": {
            "format": "email",
            "type": "string"
          },
          "expires_days": {
            "exclusiveMinimum": 0,
            "maximum": 365,
            "type": "integer"
          },
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "email"
        ],
        "type": "object"
      },
      "name": "delegate_service",
      "outputSchema": null
    },
    {
      "description": "Read a SMALL file from the sandbox (absolute `path`, max 5 MB) into this conversation: `content` as UTF-8 text by default, `as_text: false` → `content_base64`. For build artifacts, archives, binaries or anything big use `get_download_url` instead — you get a short-lived link and download it with curl, without pulling base64 into your context. Requires: token + live sandbox_id. Max 5 MB — bigger: get_download_url.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "as_text": {
            "type": "boolean"
          },
          "path": {
            "pattern": "^\\/",
            "type": "string"
          },
          "sandbox_id": {
            "description": "Sandbox id as returned by create_sandbox / list_sandboxes, e.g. \"sb_3f2a…\".",
            "pattern": "^sb_[0-9a-f]{24}$",
            "type": "string"
          }
        },
        "required": [
          "sandbox_id",
          "path"
        ],
        "type": "object"
      },
      "name": "download_file",
      "outputSchema": null
    },
    {
      "description": "Execute a shell command (bash -lc) in a sandbox as root and return {exit_code, stdout, stderr, timed_out, truncated, duration_ms}. Shell operators are fine and never filtered: `apt-get update && pip install x | tee log; echo done > out`. If you call the server with raw HTTP/curl, the JSON body must be valid — escape double quotes inside `command` (\\\") or build the body with a JSON library; a broken body returns a JSON-RPC parse error (-32700), not a firewall block. Optional `cwd` (default /root) and `timeout` (default 30 s, max 55 per call). For commands longer than 55 s (builds, training, long downloads) set `background: true`: you get a `task_id` at once, then poll get_task for output and the exit code; kill_task stops it. Requires: token + live sandbox_id. Typical: timed_out after 55 s → repeat with background: true; 404 → sandbox expired, create a new one.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "background": {
            "type": "boolean"
          },
          "command": {
            "minLength": 1,
            "type": "string"
          },
          "cwd": {
            "type": "string"
          },
          "sandbox_id": {
            "description": "Sandbox id as returned by create_sandbox / list_sandboxes, e.g. \"sb_3f2a…\".",
            "pattern": "^sb_[0-9a-f]{24}$",
            "type": "string"
          },
          "timeout": {
            "description": "Seconds. Synchronous: max 55. With background: true: up to the sandbox's remaining lifetime (default).",
            "minimum": 1,
            "type": "integer"
          }
        },
        "required": [
          "sandbox_id",
          "command"
        ],
        "type": "object"
      },
      "name": "exec_command",
      "outputSchema": null
    },
    {
      "description": "Return the account's prepaid credit balance and currency. `order_vps` spends from this balance automatically when it is sufficient. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "get_balance",
      "outputSchema": null
    },
    {
      "description": "Get a short-lived HTTPS link (default 15 min, `ttl` 60-3600 s) that streams ONE file from the sandbox — e.g. a build artifact or archive up to 2 GB — without base64 in this conversation. Download it with `curl -fL -o <name> <url>` from wherever you work. The link only works while the sandbox runs and only for that path; treat it as a secret. Requires: token + live sandbox_id. The link expires (ttl) and dies with the sandbox.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "path": {
            "pattern": "^\\/",
            "type": "string"
          },
          "sandbox_id": {
            "description": "Sandbox id as returned by create_sandbox / list_sandboxes, e.g. \"sb_3f2a…\".",
            "pattern": "^sb_[0-9a-f]{24}$",
            "type": "string"
          },
          "ttl": {
            "maximum": 3600,
            "minimum": 60,
            "type": "integer"
          }
        },
        "required": [
          "sandbox_id",
          "path"
        ],
        "type": "object"
      },
      "name": "get_download_url",
      "outputSchema": null
    },
    {
      "description": "Status of one sandbox (state running/paused, mode, tariff, expires_at; paused ones show pause_reason and delete_after) plus usage: running seconds, CPU seconds actually used, egress bytes, price per hour, amount already billed and the estimated total so far. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "sandbox_id": {
            "description": "Sandbox id as returned by create_sandbox / list_sandboxes, e.g. \"sb_3f2a…\".",
            "pattern": "^sb_[0-9a-f]{24}$",
            "type": "string"
          }
        },
        "required": [
          "sandbox_id"
        ],
        "type": "object"
      },
      "name": "get_sandbox",
      "outputSchema": null
    },
    {
      "description": "Call this FIRST. Returns the whole flow in one response: the exact order of tools to rent a VPS and to run code in a sandbox (with example arguments), the only human step (paying a crypto checkout_url), auth rules (one account, reusable token), common errors with fixes, limits — and `you_are_here`: if you are authenticated, your balance, servers and the next call to make. Every other tool response also carries `next_steps`, and every error carries `error.fix` + `error.next`. Requires: nothing. Call this first.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "get_started",
      "outputSchema": null
    },
    {
      "description": "Status and NEW output of a background task: `state` (running | done | failed | killed | timeout), `exit_code`, and the stdout/stderr text produced since the offsets you pass. Start with offsets 0, then pass `stdout_next_offset` / `stderr_next_offset` from the previous response to get only new output. `done: true` means finished. Poll every few seconds; each call is quick. Up to 8 MiB per stream is retained (older output is dropped and reported in `*_dropped`). Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "sandbox_id": {
            "description": "Sandbox id as returned by create_sandbox / list_sandboxes, e.g. \"sb_3f2a…\".",
            "pattern": "^sb_[0-9a-f]{24}$",
            "type": "string"
          },
          "stderr_offset": {
            "minimum": 0,
            "type": "integer"
          },
          "stdout_offset": {
            "minimum": 0,
            "type": "integer"
          },
          "task_id": {
            "description": "Task id returned by run_code / exec_command with background: true.",
            "pattern": "^tk_[0-9a-f]{12}$",
            "type": "string"
          }
        },
        "required": [
          "sandbox_id",
          "task_id"
        ],
        "type": "object"
      },
      "name": "get_task",
      "outputSchema": null
    },
    {
      "description": "Read one ticket and its full message thread. Each message has an `author`: `you` or `staff` — a `staff` message is a reply from support. Poll this to see new answers. The ticket code comes from create_ticket / list_tickets. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "ticket_code": {
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "ticket_code"
        ],
        "type": "object"
      },
      "name": "get_ticket",
      "outputSchema": null
    },
    {
      "description": "List the plans this VPS can switch to IN PLACE with its data kept: bigger plans of the same network type (resize: more vCPU/RAM/disk), NAT → dedicated IPv4 (convert: adds a public IP) or dedicated → the equivalent NAT plan (convert_to_nat: drops the IP, the unused price difference is refunded to the balance). Each option: product_id, name, monthly, prorated_topup (charged now for the rest of the current period), mode. Shrinking vCPU/RAM/disk is not possible (a disk cannot be reduced). The server must be active. Requires: token, server active.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "get_upgrade_options",
      "outputSchema": null
    },
    {
      "description": "Get a short-lived HTTPS link to PUT ONE file into the sandbox at `path` (up to 2 GB): `curl -fT <file> <url>`. One request carries at most 95 MB — for bigger files PUT parts in order with `?offset=<bytes already uploaded>` (each response returns `next_offset`; offset 0 overwrites). No base64 through this conversation. Requires: token + live sandbox_id. ≤95 MB per PUT; use ?offset for more.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "max_bytes": {
            "maximum": 2147483648,
            "minimum": 1,
            "type": "integer"
          },
          "path": {
            "pattern": "^\\/",
            "type": "string"
          },
          "sandbox_id": {
            "description": "Sandbox id as returned by create_sandbox / list_sandboxes, e.g. \"sb_3f2a…\".",
            "pattern": "^sb_[0-9a-f]{24}$",
            "type": "string"
          },
          "ttl": {
            "maximum": 3600,
            "minimum": 60,
            "type": "integer"
          }
        },
        "required": [
          "sandbox_id",
          "path"
        ],
        "type": "object"
      },
      "name": "get_upload_url",
      "outputSchema": null
    },
    {
      "description": "Time-series resource metrics (CPU %, memory, network, disk) for a VPS. `timeframe` ∈ hour|day|week|month (default hour). Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          },
          "timeframe": {
            "enum": [
              "hour",
              "day",
              "week",
              "month"
            ],
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "get_vps_metrics",
      "outputSchema": null
    },
    {
      "description": "Get full detail for one VPS: status, specs, live VM state/uptime, and access info (host, port, ready-to-paste `command`; `access.method` = ssh for Linux, rdp for Windows — port follows the plan: dedicated IP 22/3389, NAT 20000+vmid). ROOT PASSWORD (keyless VPS): call with `reveal: true` to retrieve it. It is shown ONCE, and only after the VM has finished booting — at that moment the password is applied to the live VM, so it is guaranteed to work. While the VM is still booting the response carries `password_pending: true` and NO password; just call again with `reveal: true` in ~30-60s (the one-time reveal is NOT spent until a password is actually returned — no reset or reboot needed). Without `reveal`, `password_available: true` means a password is waiting to be revealed. If you supplied an SSH key at order time, log in with that key (no password); `access.ssh_ready` (Linux) / `access.rdp_ready` (Windows) is a LIVE probe of the login port: on a fresh order the first boot applies OS updates, so SSH usually opens 1-5 minutes after the VM is running. While it is false the ready-to-paste `command` is withheld and `ready_note` + `retry_after_seconds` tell you to poll again — do not reset, reboot or reinstall during that window. Use `reset_password` ONLY if the password is lost. Poll this (without `reveal`) after `order_vps` to watch provisioning reach `active`. NAT plans (no dedicated IP): the SSH `port` shown is an EXTERNAL DNAT port forwarded to the VM internal port 22 (`internal_port` in the response). If you configure a host firewall, allow the INTERNAL port — `ufw allow OpenSSH` — NOT the external port, or `ufw enable` will lock SSH out. See `firewall_note` in the response. Requires: token. Typical: access.ssh_ready=false right after an order — not an error, poll again after retry_after_seconds.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "reveal": {
            "type": "boolean"
          },
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "get_vps_status",
      "outputSchema": null
    },
    {
      "description": "Delete a sandbox IMMEDIATELY and IRREVERSIBLY (running or paused): all files, installed packages, background tasks and memory are lost and cannot be recovered — download_file anything you need first. Billing stops; the final partial period is billed (ephemeral per second with the 60 s minimum, persistent per started hour). Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "sandbox_id": {
            "description": "Sandbox id as returned by create_sandbox / list_sandboxes, e.g. \"sb_3f2a…\".",
            "pattern": "^sb_[0-9a-f]{24}$",
            "type": "string"
          }
        },
        "required": [
          "sandbox_id"
        ],
        "type": "object"
      },
      "name": "kill_sandbox",
      "outputSchema": null
    },
    {
      "description": "Stop a running background task and all processes it started. Returns its final state (killed). The sandbox itself keeps running. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "sandbox_id": {
            "description": "Sandbox id as returned by create_sandbox / list_sandboxes, e.g. \"sb_3f2a…\".",
            "pattern": "^sb_[0-9a-f]{24}$",
            "type": "string"
          },
          "task_id": {
            "description": "Task id returned by run_code / exec_command with background: true.",
            "pattern": "^tk_[0-9a-f]{12}$",
            "type": "string"
          }
        },
        "required": [
          "sandbox_id",
          "task_id"
        ],
        "type": "object"
      },
      "name": "kill_task",
      "outputSchema": null
    },
    {
      "description": "List services other owners have delegated operator access to you — the VPS you can operate but don't own. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "list_delegated_to_me",
      "outputSchema": null
    },
    {
      "description": "List outgoing delegations you (the owner) have granted on your services — who has operator access to what, and its status. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "list_delegations",
      "outputSchema": null
    },
    {
      "description": "List all available VPS plans (catalog) with pricing, specs and the OS images each plan can boot: Linux plans (NAT or dedicated IPv4, from $3/mo) and Windows Server 2022 plans (slug windows-*, BYOL — the customer activates their own licence; RDP access, 150 Mbit/s port, from $11/mo). No authentication needed. Use this first to pick a `product` slug and an `os_id` for `order_vps`. Each plan lists `plans[]` (monthly and annual `plan_id`); an active automatic offer shows up as `plans[].promo` and in `meta.promotions`. PROMO until 2026-10-31 23:59 Europe/Kyiv: -25% on ANNUAL billing, first year only, applied automatically (no code) to windows-medium ($171/yr), windows-small-ip ($252/yr) and windows-medium-ip ($324/yr); renewal at the regular annual price; windows-small not included — order with period=\"year\". Requires: nothing.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "list_plans",
      "outputSchema": null
    },
    {
      "description": "List the account's sandboxes (running and paused) with mode, tariff, state and expiry. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "list_sandboxes",
      "outputSchema": null
    },
    {
      "description": "List your support tickets with status and last-message info. `last_message_author: \"staff\"` means support has replied since you last looked. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "list_tickets",
      "outputSchema": null
    },
    {
      "description": "List the account's ACTIVE VPS services — active, provisioning, and suspended servers (deleted/cancelled are excluded). Use the `id` as `service_id` for the management tools. If a server is missing from this list it has been deleted — do not query its status or try to manage it. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "list_vps",
      "outputSchema": null
    },
    {
      "description": "Log in with email + password. Returns a bearer `token` (reusable until `token_expires_at`, 1 year by default or `token_ttl_days`; remembered for the rest of this MCP session). NOTE: accounts created via register_account have NO password by default — keep using the token from register instead. To be able to log in later, call `set_password` once while still authenticated with your register token. Requires: a password set earlier with set_password. Typical error: 401 invalid credentials (register_account accounts have no password until set_password).",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "email": {
            "format": "email",
            "type": "string"
          },
          "password": {
            "minLength": 1,
            "type": "string"
          },
          "token_ttl_days": {
            "description": "Token lifetime in days (default 365).",
            "maximum": 1825,
            "minimum": 1,
            "type": "integer"
          }
        },
        "required": [
          "email",
          "password"
        ],
        "type": "object"
      },
      "name": "login",
      "outputSchema": null
    },
    {
      "description": "Order a VPS. `product` = plan slug from list_plans; `os_id` = an OS id from that plan's images. Optional `hostname` and `ssh_key` (public key — strongly recommended so you get key-based root login). Optional `location`: \"de\" (Germany) or \"fi\" (Finland) — omit it and we pick the location automatically; if the chosen country has no free capacity for that plan the call fails with 409 `location_unavailable` (nothing is charged) and `available` lists the countries that can take it. Optional `period` (\"month\" by default, or \"year\" for annual billing) or an explicit `plan_id` from list_plans `plans[]`; an active automatic offer (`plans[].promo`) is applied to the first invoice and the response then carries `promo`. Windows plans (windows-*) accept only the Windows Server 2022 image, ignore `ssh_key`, and are reached over RDP as Administrator (see get_vps_status → access); the licence is BYOL.\n\nBranching on the response:\n• `paid_from_balance: true` → the prepaid balance covered it; the server is provisioning. Poll `get_vps_status` until status is `active` and the VM is reachable.\n• `paid_from_balance: false` → balance was insufficient; an unpaid `invoice` is returned. Call `pay_invoice` with `invoice.id` to get a crypto `checkout_url`, OR `topup_balance` then re-order. PROMO until 2026-10-31 23:59 Europe/Kyiv: -25% on ANNUAL billing, first year only, applied automatically (no code) to windows-medium ($171/yr), windows-small-ip ($252/yr) and windows-medium-ip ($324/yr); renewal at the regular annual price; windows-small not included — order with period=\"year\". Requires: token + enough balance (else an unpaid invoice is returned). Typical errors: 409 location_unavailable (see `available`), 422 unknown product/os_id (see list_plans).",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "hostname": {
            "type": "string"
          },
          "location": {
            "description": "Optional server country: \"de\" (Germany) or \"fi\" (Finland). Omit for automatic placement.",
            "enum": [
              "de",
              "fi"
            ],
            "type": "string"
          },
          "os_id": {
            "exclusiveMinimum": 0,
            "type": "integer"
          },
          "period": {
            "enum": [
              "month",
              "year"
            ],
            "type": "string"
          },
          "plan_id": {
            "exclusiveMinimum": 0,
            "type": "integer"
          },
          "product": {
            "minLength": 1,
            "type": "string"
          },
          "ssh_key": {
            "type": "string"
          }
        },
        "required": [
          "product",
          "os_id"
        ],
        "type": "object"
      },
      "name": "order_vps",
      "outputSchema": null
    },
    {
      "description": "Initiate payment for an owned, unpaid invoice. Returns a PayRam `checkout_url`; the invoice settles (and the VPS provisions) automatically once the on-chain payment confirms. Requires: token. Pass invoice_id exactly as returned (a code like \"2RUAWV4\"). A human pays checkout_url.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "invoice_id": {
            "description": "Invoice id exactly as returned by order_vps / topup_balance, e.g. \"2RUAWV4\" (a plain number is also accepted).",
            "minLength": 1,
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "pay_invoice",
      "outputSchema": null
    },
    {
      "description": "Power-control a VPS: `start`, `stop` or `reboot`. Requires: token. Typical error: 409 during the first boot (setup still running) → wait and retry.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "action": {
            "enum": [
              "start",
              "stop",
              "reboot"
            ],
            "type": "string"
          },
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "action"
        ],
        "type": "object"
      },
      "name": "power_vps",
      "outputSchema": null
    },
    {
      "description": "Exchange the CURRENT bearer token for a new one before it expires: returns `token` + `token_expires_at` (1 year by default, or `expires_in_days` 1-1825) and REVOKES the old token immediately. Inside this MCP session the new token is used automatically; with raw HTTP save it and stop using the old one. Every REST response carries the header X-Token-Expires-At; get_started shows the expiry and warns 30 days ahead. An already expired token cannot be refreshed — log in again (login) or create a token in the cabinet. Requires: a valid (not yet expired) token. The old token is revoked.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "expires_in_days": {
            "maximum": 1825,
            "minimum": 1,
            "type": "integer"
          }
        },
        "type": "object"
      },
      "name": "refresh_token",
      "outputSchema": null
    },
    {
      "description": "Create a NEW EQVPS customer account (first_name, last_name, email). Use a real email address you control — reserved/test domains such as example.com are not suitable (no recovery, no notifications). Returns a bearer `token` that is reusable for every request until `token_expires_at` (1 year by default; optional `token_ttl_days` 1-1825) — it is NOT single-use; call `refresh_token` before it expires. Inside this MCP session the token is remembered automatically for the following tool calls. If you call the server with raw HTTP/curl instead, save the token to a file right away and send `Authorization: Bearer <token>` on EVERY request — a shell variable does not survive separate commands. Never call register_account again to \"get a new token\": that creates another, empty account. Optional backup: call `set_password` once, then `login` (email + password) returns a fresh token if this one is lost. Requires: nothing. Typical error: 422 email already registered → use login or your saved token instead of a new account.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "email": {
            "format": "email",
            "type": "string"
          },
          "first_name": {
            "minLength": 1,
            "type": "string"
          },
          "last_name": {
            "minLength": 1,
            "type": "string"
          },
          "token_ttl_days": {
            "description": "Token lifetime in days (default 365).",
            "maximum": 1825,
            "minimum": 1,
            "type": "integer"
          }
        },
        "required": [
          "first_name",
          "last_name",
          "email"
        ],
        "type": "object"
      },
      "name": "register_account",
      "outputSchema": null
    },
    {
      "description": "DESTRUCTIVE — all data is lost. REQUIRES confirm = exact hostname (from get_vps_status) or 'DELETE'. Agent must explicitly confirm with the human before calling. Wipes and reinstalls the VPS with the given OS image (`os_id` from list_plans). Provisioning runs asynchronously; poll `get_vps_status`. Requires: token + confirm (hostname or DELETE). Destroys all data.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "confirm": {
            "type": "string"
          },
          "os_id": {
            "exclusiveMinimum": 0,
            "type": "integer"
          },
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "os_id",
          "confirm"
        ],
        "type": "object"
      },
      "name": "reinstall_vps",
      "outputSchema": null
    },
    {
      "description": "Post a reply on one of your tickets. Use the ticket code from create_ticket / list_tickets. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "message": {
            "minLength": 1,
            "type": "string"
          },
          "ticket_code": {
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "ticket_code",
          "message"
        ],
        "type": "object"
      },
      "name": "reply_ticket",
      "outputSchema": null
    },
    {
      "description": "Rotate the root password. The new password is applied to the LIVE VM immediately via the guest-agent (no reboot) and works within ~10-30s; the OLD password stops working. REQUIRES confirm = exact hostname (from get_vps_status) or 'DELETE'. Agent must confirm with the human before calling. Use this ONLY if the password was lost — NOT because SSH was not instant on a fresh order (a new VM needs ~60s to boot; poll get_vps_status with reveal:true instead). New password is NOT in this response — read it ONCE via get_vps_status (reveal:true); also emailed. Requires: token + confirm (hostname or DELETE). Only if the password is lost.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "confirm": {
            "type": "string"
          },
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "confirm"
        ],
        "type": "object"
      },
      "name": "reset_password",
      "outputSchema": null
    },
    {
      "description": "Revoke a delegation by its id (owner revokes access, or a delegate declines their own). The other side is notified. Use list_delegations / list_delegated_to_me to find the id. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "delegation_id": {
            "exclusiveMinimum": 0,
            "type": "integer"
          }
        },
        "required": [
          "delegation_id"
        ],
        "type": "object"
      },
      "name": "revoke_delegation",
      "outputSchema": null
    },
    {
      "description": "Run a code snippet inside a sandbox and return {exit_code, stdout, stderr, timed_out, truncated, duration_ms}. `language`: python (Python 3.12), node (Node.js 22) or bash. Install packages first with exec_command (`pip install …` / `npm i …`). The code is passed to the interpreter on stdin, so it cannot read stdin itself. `timeout` seconds (default 30, max 55 per call). LONGER JOBS: set `background: true` — returns a `task_id` immediately (timeout then defaults to the sandbox's remaining lifetime); poll get_task with the returned offsets to read new output and the exit code, kill_task to stop it. The sandbox keeps billing while a task runs and is not idle-deleted. Output is capped at 1 MiB per stream for synchronous calls. Files and installed state persist between calls in the same sandbox. Requires: token + live sandbox_id. Typical: timed_out after 55 s → repeat with background: true.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "background": {
            "type": "boolean"
          },
          "code": {
            "minLength": 1,
            "type": "string"
          },
          "language": {
            "enum": [
              "python",
              "node",
              "bash"
            ],
            "type": "string"
          },
          "sandbox_id": {
            "description": "Sandbox id as returned by create_sandbox / list_sandboxes, e.g. \"sb_3f2a…\".",
            "pattern": "^sb_[0-9a-f]{24}$",
            "type": "string"
          },
          "timeout": {
            "description": "Seconds. Synchronous: max 55. With background: true: up to the sandbox's remaining lifetime (default).",
            "minimum": 1,
            "type": "integer"
          }
        },
        "required": [
          "sandbox_id",
          "language",
          "code"
        ],
        "type": "object"
      },
      "name": "run_code",
      "outputSchema": null
    },
    {
      "description": "Public: sandbox tariffs — micro 0.25 vCPU/512 MB RAM/3 GB disk · small 0.5 vCPU/1 GB RAM/5 GB disk · standard 1 vCPU/2 GB RAM/10 GB disk · plus 2 vCPU/4 GB RAM/15 GB disk · pro 4 vCPU/8 GB RAM/20 GB disk · max 8 vCPU/16 GB RAM/40 GB disk — with per-second/hour/month prices, the billing model and limits (synchronous exec up to 55 s, background tasks longer; files up to 5 MB per transfer; runtimes: Python 3.12 + pip, Node.js 22 + npm, bash, git, curl). No authentication needed. Writing code instead of calling MCP? Official SDKs on the same REST API and token: Python `pip install eqvps`, TypeScript/JavaScript `npm i @eqvps/sdk` (docs: https://eqvps.com/en/docs/sandboxes). Requires: nothing.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "sandbox_pricing",
      "outputSchema": null
    },
    {
      "description": "Set the VPS hostname (valid DNS name). Applied immediately inside the running server via the guest agent (Linux: hostnamectl + the 127.0.1.1 line in /etc/hosts; Windows: renamed, takes effect after a reboot — the response then has `reboot_required: true`). The server must be running with its guest agent active; otherwise the call fails with 409 `agent_unavailable` and nothing is changed. Your password, SSH host keys and files are not touched. Requires: token, server running. Typical error: 409 agent_unavailable → start the server / wait for boot.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "hostname": {
            "minLength": 1,
            "type": "string"
          },
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          }
        },
        "required": [
          "hostname"
        ],
        "type": "object"
      },
      "name": "set_hostname",
      "outputSchema": null
    },
    {
      "description": "Set a password for THIS account (the one your bearer token belongs to). Accounts from register_account have no password by default — the bearer token is the credential. Call this ONCE to enable email+password `login` as a recovery method in case the token is lost. Needs only the new password (min 8 chars, letters+numbers) — no current password the first time. If a password was already set, this returns 409 (use change-password instead). Requires: token. Typical error: 409 password already set → use login.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "password": {
            "minLength": 8,
            "type": "string"
          }
        },
        "required": [
          "password"
        ],
        "type": "object"
      },
      "name": "set_password",
      "outputSchema": null
    },
    {
      "description": "Create a top-up invoice and return a `checkout_url` (PayRam crypto checkout). The balance is credited automatically once the on-chain payment confirms. `amount` is in account currency (USD); minimum and maximum are enforced server-side. Only one unpaid top-up may exist at a time. Requires: token. A HUMAN must pay checkout_url in crypto; the balance is credited automatically after confirmation.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "amount": {
            "exclusiveMinimum": 0,
            "type": "number"
          }
        },
        "required": [
          "amount"
        ],
        "type": "object"
      },
      "name": "topup_balance",
      "outputSchema": null
    },
    {
      "description": "Keep a VPS whose cancellation was scheduled with type end_of_period: the scheduled cancellation is removed, the server stays active and renews as usual. No money moves (end_of_period never refunds). An immediate cancellation cannot be undone — the VM is destroyed at once. get_vps_status shows `cancellation` {type, cancel_at, can_undo}. Requires: token + a scheduled end_of_period cancellation. Typical error: 409 nothing_to_undo.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "service_id": {
            "description": "Service code as returned by list_vps/order_vps, e.g. \"68J67T5\" (a plain numeric id is also accepted).",
            "minLength": 1,
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "undo_cancel",
      "outputSchema": null
    },
    {
      "description": "Write a file into the sandbox at an absolute `path` (parent directories are created). Give `content` for UTF-8 text OR `content_base64` for binary. Limit 5 MB per file inline — for bigger files call `get_upload_url` and PUT the bytes to the link (no base64 through this chat). Optional `mode` like \"755\". Requires: token + live sandbox_id. Max 5 MB.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "additionalProperties": false,
        "properties": {
          "content": {
            "type": "string"
          },
          "content_base64": {
            "type": "string"
          },
          "mode": {
            "pattern": "^[0-7]{3,4}$",
            "type": "string"
          },
          "path": {
            "pattern": "^\\/",
            "type": "string"
          },
          "sandbox_id": {
            "description": "Sandbox id as returned by create_sandbox / list_sandboxes, e.g. \"sb_3f2a…\".",
            "pattern": "^sb_[0-9a-f]{24}$",
            "type": "string"
          }
        },
        "required": [
          "sandbox_id",
          "path"
        ],
        "type": "object"
      },
      "name": "upload_file",
      "outputSchema": null
    },
    {
      "description": "Return the authenticated account profile (id, name, email). Use to verify the bearer token is valid. Requires: token.",
      "inputSchema": {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "properties": {},
        "type": "object"
      },
      "name": "whoami",
      "outputSchema": null
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:7ad998ea8ef78b389ba8327e5f7ad9d6736d90648d1656c84f5655263e583019 | sha256sum