MCP for AI agents

Get all platform accounts linked to the calling user.

No parameters.

{
  "type": "object",
  "properties": {
    "accounts": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer"
          },
          "platform": {
            "type": "string",
            "enum": [
              "TELEGRAM",
              "VK",
              "APPLE"
            ]
          },
          "username": {
            "type": [
              "string",
              "null"
            ]
          },
          "firstName": {
            "type": "string"
          },
          "lastName": {
            "type": [
              "string",
              "null"
            ]
          },
          "canReceiveDm": {
            "type": "boolean"
          }
        },
        "required": [
          "id",
          "platform",
          "username",
          "firstName",
          "lastName",
          "canReceiveDm"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "accounts"
  ],
  "additionalProperties": false
}

Bind the current private DM to a target group chat. After binding, every chat-scoped action (createEvent, registerFor, splitTeams, finishEvent, …) targets the bound group; the event card lives there. Replies still come back to this DM only. Only callable from a private DM. Use unbindTargetChat to clear.

List group chats the calling user can manage from a private DM: chats where the user has past messages OR has created an event. For each chat returns name, active event (id, title, date) when present, lastSeenAt, and `isCurrentTarget` — true when the chat is the one the current DM is already bound to (so the agent can say "this is the chat you are working with right now").

No parameters.

Clear the target-chat binding on the current DM. Subsequent messages stop being routed to the group; event creation in the DM will be refused again.

No parameters.

Record that a player transferred the game fee to the organizer (self-report). Marks the dues entries as "claimed" — the organizer later confirms them against their bank app. One call covers everyone the transfer paid for. Without userIds the sender claims for themselves.

Delete a bank (treasury) expense/income entry by its id — for correcting a mistake. Get ids from getBudget. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Treasury of this chat: the rolling bank balance (collected fees + income − expenses), the per-game collected-fees breakdown, the expense/income ledger, and the current bank holder. Use for "сколько в кассе / банке", "покажи бюджет / расходы".

No parameters.

Cross-game debts of this chat: who still owes game fees (unpaid or merely claimed but not confirmed) across finished events, grouped per player with totals. Use for "кто должен?" and for reminding debtors.

No parameters.

Dues state of one event: per-head amount, per-player payment entries with statuses (unpaid | claimed | confirmed | waived), counters, and the chat transfer requisites with provenance (who set them, when).

Record a movement of the team cash pot (bank) that is NOT a player fee: an expense (pitch rental, bibs, ball) or miscellaneous income (sponsor, carry-over). The rolling bank balance is collected fees + income − expenses. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Designate the member who physically holds the team cash pot (bank/treasury), or clear it. Shown in the budget and on "кто держит банк / кассу". Requires caller to be OWNER of the target event. Returns {error} otherwise — do not call speculatively.

Set, update, or remove the chat-level payment instructions players follow to pay game fees. This is ONE free-text field: store whatever the organizer wrote, exactly as they wrote it. remove: true wipes it. Requires caller to be OWNER of the target event. Returns {error} otherwise — do not call speculatively.

Organizer-side dues transition: confirm received transfers, reset a wrong mark back to unpaid, or waive a fee. Target either explicit userIds OR allExcept (= every confirmed participant except the listed ones). Exactly one of the two must be provided. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Copy all EventFeature settings (event types, max players, deadline, etc.) from the most recent previous event in this chat to the given event. Call this when the organizer confirms they want the same settings as last time. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Archive the event — removes it from the default event list but preserves all data. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Create a new event (game/meeting) owned by the calling user. When called from a chat-bound agent, the event is also linked to the current chat and previous-event suggestions come from that chat. If another event in the same chat is still active (not finished, not archived) the behaviour depends on whether the previous event has any signs of life: • 0 confirmed registrations OR no activity for 24+ hours → it is auto-finished (replacedPreviousEvent in the response with reason=empty|inactivity, plus a system note posted to the chat) and the new event is created. • ≥1 confirmed registration AND fresh activity (registration, log entry, or just-created) → the call returns error=collection_in_progress with the active eventId and registrationsCount so the agent can ask the organizer to confirm before discarding their work. Over MCP, the event is stand-alone and previous-event suggestions come from events the caller has created.

Finish the event. Writes an event_finish entry to the event log and marks the event as finished. After this, the event stops being the active one in the chat. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Get event details (title, date, status, registrations, teams). Accepts eventId; if omitted and called from a chat-bound agent context, falls back to the active event of the current chat. Over MCP, eventId is required.

Current chat-level naming scheme for auto-created events (used when createEvent is called without an explicit title), plus a preview of what the next auto-created event would be called. Use for "как называются наши игры", "какая сейчас схема названий".

No parameters.

List events the calling user has a relationship with (created or participated in). Supports cursor-based pagination. Pass the `nextCursor` from the previous page to fetch the next one.

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer"
          },
          "title": {
            "type": [
              "string",
              "null"
            ]
          },
          "date": {
            "type": "string"
          },
          "status": {
            "type": "string",
            "enum": [
              "collecting",
              "finished",
              "archived"
            ]
          },
          "isCreator": {
            "type": "boolean"
          },
          "registrationsCount": {
            "type": "integer"
          }
        },
        "required": [
          "id",
          "title",
          "date",
          "status",
          "isCreator",
          "registrationsCount"
        ],
        "additionalProperties": false
      }
    },
    "nextCursor": {
      "type": "string"
    }
  },
  "required": [
    "items"
  ],
  "additionalProperties": false
}

Undo a previous finishEvent. Cancels the last event_finish log entry and clears finishedAt. If eventId is omitted, reopens the most recent finished event in this chat. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Add, update, or remove a generic feature for an event (e.g. payment, maxPlayers, deadline, mvp). Typed features (rollcall, teams) do not need this — they activate automatically. Pass remove: true to deactivate a feature. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Set the chat-level default naming scheme applied to events auto-created without an explicit title. Presets: "sequential" — "{label} #{n}" (e.g. "Игра #14"); "weekday" — "{Weekday} #{n}" (e.g. "Вторник #14"); "date" — "{label}, {day} {month}" (e.g. "Игра, 20 июля"), no number. `label` replaces the default word "Игра" (e.g. "Футбол", "Тренировка") — ignored by "weekday". Only affects FUTURE auto-created events; past titles never change. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Patch an existing event: rename (`title`), change description, or reschedule (`date`). Pass only the fields you want to change. Other fields stay untouched. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Add or update one event type for logging at a sports or team event. Call once per type. Multiple calls add multiple types. Event types are universal — usable from Watch, chat, or any other logger. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Record one entry into the live game log from chat: a scoring play (goal, point), a card/foul, match-clock control (a type carrying timeEffect: start/pause/reset), or a phase marker. The entry type must already exist in the event catalog — see getScoringConfig / addEventType. The scorer is resolved server-side by badgeNum or exact roster name; scoreDelta and timer effect come from the type config, not from you. Call once per entry.

Undo a previously logged game entry by writing an amendment — the score recomputes automatically. Without localId, cancels the most recent still-active non-structural entry (a scoring play or card, not a timer/phase marker). Get a specific localId from getEventLog.

Return the chronological match log for an event (or a specific game inside it). Already accounts for cancellations and amendment chains — only entries that are still in effect are returned. Each item carries: type, label, team name, player name, occurredAt (ISO), and matchTime (M:SS — game-clock time at the moment, derived from timer_start/pause/reset events). Use this when the user asks for the match protocol, full list of goals/cards, "кто забил во втором тайме", or any time-on-clock detail. Prefer this over getGameState when scoreboard summary is not enough.

Get the live game state for an event: structured score (mode-aware: GOAL_TIMER / SET_POINT / RACE_TO / ROUND_JUDGE), a short `summary` string of the current scoreboard, and `recentEvents` — the full chronological list of non-cancelled log entries (goals, assists, cards, timer marks) with team and player labels. Always call this when the user asks for the score, who scored, who assisted, the match summary, or any per-player breakdown — never answer those from memory or the static event snapshot.

Return the event's logging catalog and scoring setup: every configured event type with its system attributes (scoreDelta, scoreTarget, timeEffect for clock control, requiresTeam/requiresPlayer), the scoringMode, the timer/set/finish/round configs, and the active game id. Call before addLogEntry when unsure which types exist or what their ids are.

Update scoring configuration of an event without touching event types. Use to tweak an already-applied preset (e.g. change setsToWin, targetScore, participantFormat). Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Semantic search over saved player facts in this chat. Use to answer "что я знаю про X" or to find players by trait ("кто хорошо играет в защите").

{
  "type": "object",
  "properties": {
    "facts": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "userId": {
            "type": "integer"
          },
          "text": {
            "type": "string"
          },
          "similarity": {
            "type": "number"
          }
        },
        "required": [
          "userId",
          "text",
          "similarity"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "facts"
  ],
  "additionalProperties": false
}

Save a long-term fact about a PLAYER (how they play, position/role, reliability, preferences). Requires an explicit userId — resolve the name first via findChatUsers. One concise fact per call.

Send a test notification to the current user through the notification pipeline (delivered as a Telegram bot DM for now). Use to verify push infrastructure. Always targets only the requesting user.

Apply a sport preset to an event. Atomically replaces event_types config with preset types, scoringMode, setConfig, timerConfig, finishCondition, roundConfig and participantFormat. Optional overrides let you tune a preset without creating a new one (team size, period length, setsToWin, etc). This is the recommended way to configure a new event. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

List all sport presets available for applyPreset. Optionally filter by scoringMode (GOAL_TIMER, WEIGHTED_TIMER, SET_POINT, RACE_TO, ROUND_JUDGE).

{
  "type": "object",
  "properties": {
    "presets": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "emoji": {
            "type": "string"
          },
          "scoringMode": {
            "type": "string",
            "enum": [
              "GOAL_TIMER",
              "WEIGHTED_TIMER",
              "SET_POINT",
              "RACE_TO",
              "ROUND_JUDGE"
            ]
          },
          "participantFormat": {
            "type": "string",
            "enum": [
              "team_vs_team",
              "1v1",
              "2v2",
              "3v3"
            ]
          }
        },
        "required": [
          "id",
          "name",
          "emoji",
          "scoringMode",
          "participantFormat"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "presets"
  ],
  "additionalProperties": false
}

Get users known to the calling user, sorted by recent activity. Agent (chat-bound): participants of the current chat, by messages and registrations. MCP: users who participated in events created by the caller (registrations or team memberships).

No parameters.

{
  "type": "object",
  "properties": {
    "users": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer"
          },
          "firstName": {
            "type": [
              "string",
              "null"
            ]
          },
          "lastName": {
            "type": [
              "string",
              "null"
            ]
          },
          "username": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "required": [
          "id",
          "firstName",
          "lastName",
          "username"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "users"
  ],
  "additionalProperties": false
}

Get all registrations for an event, ordered by badge number.

{
  "type": "object",
  "properties": {
    "eventId": {
      "type": "integer"
    },
    "registrations": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "badgeNum": {
            "type": "integer"
          },
          "userId": {
            "type": "integer"
          },
          "name": {
            "type": "string"
          },
          "status": {
            "type": "string"
          },
          "isVirtual": {
            "type": "boolean"
          },
          "registeredAt": {
            "type": "string"
          }
        },
        "required": [
          "badgeNum",
          "userId",
          "name",
          "status",
          "isVirtual",
          "registeredAt"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "eventId",
    "registrations"
  ],
  "additionalProperties": false
}

Register the calling user for an event. Accepts eventId; if omitted and called from a chat-bound agent context, falls back to the active event of the current chat. If the event has a max players limit, the user may be auto-placed on the waiting list.

Cancel the calling user's registration for an event. Accepts eventId; if omitted and called from a chat-bound agent context, falls back to the active event of the current chat.

Register another person for the active event. Use userId (from findChatUsers) for known chat members. Use guestName to search for similar users before creating a new one. Use confirmedNewName only after guestName returned candidates and organizer confirmed this is a new person.

Rename a guest (a bot-created virtual participant) in place — keeps their badge number and registration. Identify the guest by badgeNum (preferred) or userId. Works ONLY on guests; a real platform user keeps their own name and the tool returns an error.

Single entry point for a pasted full/"final" lineup. Two shapes: a flat ORDERED list → pass `userIds` (array order = badge order); a lineup grouped under 2+ team names ("Yellow: …, Purple: …") → pass `teams` — registers everyone AND assigns the named teams in one step. Prefer this over per-name registerFor calls. Resolve names to userId first (getRegistrations + findChatUsers); create unknown guests with registerFor(guestName) and pass the returned userId. By default removes nobody and returns `toRemove` (registered people absent from the list) — show them to the user and re-call with removeMissing:true only after they confirm.

Promote a waiting player to confirmed or move a confirmed player to the waiting list. Accepts either badgeNum or userId to identify the player. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Cancel registration of another player (by userId) for an event. Accepts eventId; if omitted and called from a chat-bound agent context, falls back to the active event of the current chat. Use leaveEvent when the caller wants to cancel their own registration.

Cancel (deactivate) a scheduled prompt by id. The prompt stops firing. Use listScheduledPrompts first if the id is unknown.

List scheduled prompts configured for the current chat (active and paused).

No parameters.

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "integer"
          },
          "prompt": {
            "type": "string"
          },
          "runAt": {
            "type": "string"
          },
          "recurring": {
            "type": "boolean"
          },
          "status": {
            "type": "string"
          },
          "enabled": {
            "type": "boolean"
          }
        },
        "required": [
          "id",
          "prompt",
          "runAt",
          "recurring",
          "status",
          "enabled"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "items"
  ],
  "additionalProperties": false
}

Schedule a natural-language instruction to run later in THIS chat — one-shot (absolute `at`) or recurring (`recurrence`). At fire time the instruction is fed to the agent exactly as if the user typed it, so it can create events, remind, split teams, finish events, etc. Provide EITHER `at` (ISO 8601) OR `recurrence`, never both. The tool asks the user to confirm before saving. Each run consumes chat credits.

Get the chat's live CSV export feeds for spreadsheets (Google Sheets / Excel). Returns per-feed URLs (events, attendance, player stats; optionally dues and cash ledger) plus a ready =IMPORTDATA(...) formula. Calling again returns the same link. includeMoney omitted = keep the link's current setting (new links start without money feeds). Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Read a PUBLIC Google Sheets link ("anyone with the link") as CSV text. Use it when someone shares their spreadsheet to migrate a roster into the chat. Reads the tab the URL points at (#gid=...), else the first tab. Fails on private sheets — the person must either open link access or paste the table as text. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Revoke the chat's CSV export link: every copy of the URL stops working immediately, including formulas already pasted into spreadsheets. getSheetExportLink afterwards mints a fresh link. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

No parameters.

Create a public sign-up link for an event — a game card anyone can open in a browser to see the roster and sign themselves up after logging in. Made for teams whose chat has no assistant (WhatsApp and the like): share the URL there and sign-ups still land on this roster. Each call creates a NEW link, so one game can have several with different rules; use listSignupLinks to see the existing ones before making another. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Lists an event's public sign-up links with their settings and how many sign-ups each has brought in. Use before creating another one. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Get a public spectator link (live score screen) for an event. Anyone with the link can watch the score and event timeline in a browser without logging in. Enables sharing when it is not enabled yet; calling again returns the same link. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Move a participant to a different team, or remove them from their current team if toTeamId is omitted. If the participant is not yet assigned to any team, they will be added to the target team. Accepts either badgeNum or userId to identify the participant. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Set or clear a role for a team member (e.g. captain, goalkeeper). Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

Split registered members into teams by an explicit split ACTION: strategy "random" ("разбей на 2"), or strategy "manual" when the organizer assigns already-known members to teams interactively. For a PASTED full lineup (flat or grouped under team names) use saveRoster instead. Requires caller to be ORGANIZER of the target event. Returns {error} otherwise — do not call speculatively.

A user's track record in THIS chat: participation (events attended/registered, games played, member since, how often they show up), whether they organize or just play, per-event-type tallies (goals / points / aces — whatever this chat logs), and saved notes. Use to answer "что за игрок X", "расскажи про X", "часто ли ходит X". Resolve names to a userId via findChatUsers first.

{
  "type": "object",
  "properties": {
    "users": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "identity": {
            "type": "object",
            "properties": {
              "userId": {
                "type": "integer"
              },
              "firstName": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "lastName": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "username": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "isVirtual": {
                "type": "boolean"
              }
            },
            "required": [
              "userId",
              "firstName",
              "lastName",
              "username",
              "isVirtual"
            ],
            "additionalProperties": false
          },
          "participation": {
            "type": "object",
            "properties": {
              "eventsRegistered": {
                "type": "integer"
              },
              "eventsAttended": {
                "type": "integer"
              },
              "gamesPlayed": {
                "type": "integer"
              },
              "organizerCount": {
                "type": "integer"
              },
              "eventsPerMonth": {
                "type": [
                  "number",
                  "null"
                ]
              },
              "firstSeenAt": {
                "type": [
                  "string",
                  "null"
                ]
              },
              "lastSeenAt": {
                "type": [
                  "string",
                  "null"
                ]
              }
            },
            "required": [
              "eventsRegistered",
              "eventsAttended",
              "gamesPlayed",
              "organizerCount",
              "eventsPerMonth",
              "firstSeenAt",
              "lastSeenAt"
            ],
            "additionalProperties": false
          },
          "performance": {
            "type": "object",
            "additionalProperties": {
              "type": "object",
              "properties": {
                "count": {
                  "type": "integer"
                },
                "label": {
                  "type": "string"
                }
              },
              "required": [
                "count"
              ],
              "additionalProperties": false
            }
          },
          "notes": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "required": [
          "identity"
        ],
        "additionalProperties": false
      }
    },
    "computedAt": {
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "users",
    "computedAt"
  ],
  "additionalProperties": false
}