Inspect overall connectivity, health, and configuration status across all server subsystems (LCU REST/WebSocket, Chrome DevTools Protocol, event buffers, live game engine). Use this tool first when diagnosing connection failures, verifying lockfile detection, or checking effective allowlist rules and allowEval permissions. Behavior: Safe and read-only; requires no client write permissions.

Send a read-only HTTP GET request to any internal League Client Update (LCU) REST API endpoint and return { status, body }. This is the primary and recommended tool to inspect live client state (such as summoner profile, lobby members, or gameflow phase) instead of using lol_eval. For mutating actions (POST, PUT, PATCH, DELETE), use lol_request instead. To discover supported endpoint paths, use lol_endpoints or lol_schema. Prerequisite: League client must be running. Safe and idempotent; requires no write allowlist entries.

Send an HTTP request with any verb (GET, HEAD, POST, PUT, PATCH, DELETE) to an internal League Client Update (LCU) REST endpoint. Use this tool to perform client mutations or call endpoints not covered by dedicated workflow tools. Always prefer this tool over lol_eval for REST API interactions. For safe read-only queries, prefer lol_get. For common automated actions like champion selection or lobby creation, prefer lol_workflow_* tools. Behavior: GET and HEAD are always allowed. Mutating verbs require matching entries in the write allowlist; unauthorized requests are rejected before execution.

Search the curated catalog of League Client Update (LCU) REST API endpoints commonly used for automation and monitoring. Returns matching endpoint paths, HTTP verbs, functional groups, and summary descriptions. Use this tool to quickly discover available endpoints by keyword (e.g. "champ-select", "lobby", "summoner"). For full OpenAPI/Swagger schema definitions, parameter types, or data models, use lol_schema instead. Prerequisite: Works offline without requiring an active League client connection.

Inspect internal LCU API endpoint signatures, parameters, request bodies, and data models using the League client's live OpenAPI/Swagger v2 specification. Use this tool to find the exact request schema, parameter types, or response models before invoking lol_request. For a lightweight list of common endpoints, use lol_endpoints instead. For static game assets (champions, items, runes), use lol_static instead. Prerequisite: League client must be running to fetch swagger doc; cached in memory after first load.

Resolve numeric League of Legends game data IDs to human-readable names and metadata using locally served static client documents. Use this tool to translate raw championId, itemId, perkId, summonerSpellId, mapId, or queueId received from other tools or telemetry events into readable entities. For live client state, use lol_get instead. For OpenAPI endpoint models, use lol_schema instead. Prerequisite: League client must be running to fetch static bundles; results are cached.

Open the League Client WebSocket event tap and buffer live OnJsonApiEvent Create/Update/Delete notifications in memory. Use this tool to monitor real-time client state changes (such as champ select progress, gameflow phase, or lobby party updates). To poll buffered events, call lol_events_poll. To record raw WAMP frames with socket lifecycle diagnostics, use lol_wamp_record_start instead. For static game assets, use lol_static instead. Behavior: Ring buffer evicts oldest events after buffer limit is reached. Calling while running updates URI filters and preserves already buffered events. Prerequisite: League client must be running.

Drain buffered League Client WebSocket events recorded since a given sequence cursor, returning events and the new cursor. Use this tool to incrementally consume live client events after calling lol_events_start. For recording full WAMP traffic frames, use lol_wamp_record_dump instead. If an event payload indicates truncated: true, use lol_get on the entry URI to fetch the full resource. Behavior: Safe and read-only. A non-zero dropped count indicates buffer overflow between polls.

Close the League Client WebSocket event tap and stop buffering live events. Use this tool to pause or end event collection and conserve memory. Buffered events remain readable via lol_events_poll after stopping. For stopping WAMP recording, use lol_wamp_record_stop instead. Behavior: Idempotent; safe to call when already stopped.

Query HTML elements in the active League client Chromium Embedded Framework (CEF) UI DOM using CSS selectors. Use this tool as the primary safe method to inspect live UI elements, verify modal state, or find element identifiers. Do not use lol_eval when a CSS selector query suffices. For arbitrary JavaScript execution or state mutation in the UI page, use lol_eval instead. For capturing visual UI state as an image, use lol_cdp_screenshot instead. Prerequisite: Requires Chrome DevTools Protocol (CDP) enabled via Pengu Loader; check lol_status if connection fails. Note: Pengu Loader is required for CDP tools, but standard LCU REST, WAMP, and game tools work without it.

Execute an arbitrary JavaScript expression within the League client Chromium Embedded Framework (CEF) renderer context and return the evaluated result. CRITICAL: Do NOT use lol_eval for LCU REST API calls (e.g. fetch('/lol-...')) or client state queries. For safe LCU REST queries, ALWAYS use lol_get or lol_request. For automated game actions (lobby, matchmaking, champ-select, runes), ALWAYS use lol_workflow_* tools. For safe DOM structure inspection, prefer lol_dom_query. Use lol_eval ONLY for advanced CEF runtime debugging, custom in-page UI automation, or reading internal renderer properties not exposed via REST. Behavior: Destructive and unsandboxed; bypasses the write allowlist by construction. Security: Gated by allowEval config flag (check lol_status); calls are refused if allowEval is false. Prerequisite: Requires active CDP connection enabled via Pengu Loader (required for CDP tools; not needed for REST/workflow tools).

Open a dedicated secondary WAMP WebSocket connection to the League Client and record raw frames alongside socket lifecycle events into a chronological timeline. Use this tool for deep protocol diagnostics, debugging connection drops, or analyzing WAMP message flows. For lightweight high-level event polling, prefer lol_events_start instead. To dump recorded frames, call lol_wamp_record_dump. Behavior: Captures open, close (with exit codes), errors, reconnect gaps, and message frames. Starting while already recording throws an error unless restart is true.

Retrieve recorded WAMP timeline entries, socket lifecycle events, and cumulative per-URI statistics from the recorder buffer. Use this tool to inspect recorded WebSocket frames and diagnose whether a quiet URI received no traffic or the socket disconnected. Prerequisite: lol_wamp_record_start must have been called. For general timeline correlation across multiple subsystems, use lol_forensics_correlate. Behavior: Returns timestamped entries, dropped frame count, and cumulative per-URI stats surviving eviction.

Terminate the dedicated WAMP recorder WebSocket connection and halt traffic capture. Use this tool when WAMP diagnostic recording is finished. Recorded entries remain accessible via lol_wamp_record_dump. Behavior: Idempotent; safe to call when already stopped.

Attach to the League Client renderer via Chrome DevTools Protocol (CDP) and begin streaming console logs, warnings, and uncaught exceptions into an in-memory buffer. Use this tool before executing UI actions or testing plugins to capture runtime frontend diagnostics. To retrieve buffered entries, call lol_cdp_console_tail. To stop capturing and release memory, call lol_cdp_console_stop. For client log files on disk, use lol_logs_tail instead. Behavior: Non-destructive; automatically survives renderer page reloads with continuity. Prerequisite: Active CDP connection.

Retrieve buffered console logs, warnings, and runtime JavaScript exceptions recorded since the tailer was started or past a given cursor. Use this tool to inspect frontend errors, check component mounting logs, or debug UI scripts. Prerequisite: Must call lol_cdp_console_start first; fails if tailer is not running. For HTTP request traffic, use lol_cdp_network_tail instead. Behavior: Sequential integer cursors ensure gap-free incremental reading without skipping entries.

Detach from the League Client renderer and terminate the console log buffering session. Use this tool when console log capture is complete to release memory and close the CDP socket. For stopping network request capture, use lol_cdp_network_stop instead. Behavior: Discards any remaining unread entries from the in-memory buffer. Idempotent; safe to call when already stopped.

Attach to the League Client renderer via Chrome DevTools Protocol (CDP) and begin capturing outgoing and incoming HTTP/HTTPS network requests into an in-memory buffer. Use this tool to monitor REST traffic, measure endpoint latency, or debug failed API calls made by the client UI. To inspect captured requests, call lol_cdp_network_tail or lol_cdp_network_summary. To read response payload bodies, use lol_cdp_network_body with a request ID. For WebSocket events, use lol_events_* or lol_wamp_record_* instead. Behavior: Captures request metadata, headers, status codes, and timing. Prerequisite: Active CDP connection.

Retrieve captured HTTP network requests from the in-memory buffer, filtered by status, URL pattern, or HTTP method. Use this tool to inspect recent client network calls and identify 4xx/5xx errors or hung requests. Prerequisite: Must call lol_cdp_network_start first; fails if network recording is not running. To fetch full response bodies, pass returned request IDs to lol_cdp_network_body. For aggregated traffic statistics, use lol_cdp_network_summary instead. Behavior: Returns completed requests and active in-flight requests.

Fetch the raw response body payload for a specific captured network request ID from the live renderer. Use this tool after lol_cdp_network_tail to examine the raw payload or JSON response of an interesting request. For high-level request metadata or status codes without bodies, lol_cdp_network_tail suffices. Behavior: Reaches live renderer cache. Prerequisite: Request must have been captured in the current renderer session; fails if evicted or client reloaded.

Aggregate and summarize captured HTTP requests by method and endpoint URL pattern with status breakdown, total byte volume, and median duration. Use this tool to analyze high-volume client polling traffic, discover top endpoints, or spot systemic failure rates over time without reading raw request logs. For individual request inspection with timestamps, use lol_cdp_network_tail instead. Behavior: Safe and read-only; summarizes in-memory buffer without consuming or altering stream cursors.

Detach from the League Client renderer and terminate the network traffic recording session. Use this tool when network analysis is complete to release memory and close the CDP monitoring session. Behavior: Discards in-memory network buffers. Idempotent; safe to call when already stopped.

Terminate and relaunch the League Client user interface frontend (Chromium Embedded Framework renderers) via Riot Client API. Use this tool to recover from a frozen client UI, apply Pengu Loader plugin changes, or reload corrupted UI states without closing the League game process. For gameflow or lobby navigation, use lol_workflow_* tools instead. Behavior: Destructive to current UI state (severs active CDP and WebSocket connections). When waitForReady is true, cleanly polls until LCU HTTP API and CDP page target are restored. Prerequisite: Riot Client and LCU process must be running.

Launch the League of Legends client via Riot Client Services or LeagueClient.exe and optionally wait until the LCU REST API becomes responsive. If the client is already running and responsive, returns immediately without spawning a duplicate process. Behavior: Safe and idempotent. Prerequisite: League of Legends must be installed on the system.

Discover and list all active Chrome DevTools Protocol (CDP) debugging targets (pages, modals, worker contexts) exposed by the League Client. Use this tool to inspect available renderer contexts and discover target IDs before capturing targeted screenshots with lol_cdp_screenshot or tailing console and network. Behavior: Safe and read-only. Prerequisite: League client must be running with remote debugging enabled via Pengu Loader. (Note: Pengu Loader is required for CDP tools; standard LCU REST, events, and workflows work without it).

Capture a visual screenshot image of the active League Client window or a specific renderer target using Chrome DevTools Protocol (CDP). When to use: When visual rendering, modal layout, or graphic verification is needed. When NOT to use: Do not use for automated state checks or element queries (use lol_dom_query) or API data inspection (use lol_get). Behavior: Safe read of visual pixels from the renderer; writes to local filesystem only when savePath is explicitly supplied. Prerequisite: League client must be running with remote debugging enabled via Pengu Loader; check lol_status if disconnected. (Note: Required for CDP tools only). Returns dual-payload MCP content with a base64 image data block plus structured JSON metadata (format, dimensions, byte length, savedTo path).

Inspect Chromium Embedded Framework (CEF) performance and memory metrics for the League client frontend. Gathers JS heap size, DOM node count, layout count, recalc style count, task and script duration, and flags memory pressure warnings. Use this tool to detect memory leaks, detached DOM nodes, or renderer lag in frontend plugins. Prerequisite: Requires Chrome DevTools Protocol (CDP) enabled via Pengu Loader; check lol_status if connection fails. (Note: Pengu Loader is required for CDP tools; standard LCU REST, events, and workflows work without it).

Analyzes captured HTTP network requests to identify latency bottlenecks, slow endpoint patterns, and failed asset loads. Calculates P50, P90, and P99 latencies per normalized endpoint, extracts slowest requests exceeding a threshold duration with initiator stack traces, and groups HTTP 4xx/5xx or transport errors. Use this tool to diagnose frontend lag, sluggish LCU REST endpoints, or broken plugin scripts and missing icons. Prerequisite: Network recording must be active; call lol_cdp_network_start first.

Inspects the League client Chromium Embedded Framework (CEF) DOM hierarchy, active modal stack, invisible blocking backdrops, and current viewport plugin route. Identifies open dialogs (.modal-container, lol-uikit-dialog-frame, [class*="modal"]), unclosed transparent overlays blocking user clicks (frozen UI bug), active rcp-fe-lol-* plugins, and the focused element. Use this tool to diagnose unclickable UI buttons, stuck modals, or verify client screen state. Prerequisite: Requires Chrome DevTools Protocol (CDP) enabled via Pengu Loader; check lol_status if connection fails.

Inspects the League client Chromium Embedded Framework (CEF) localStorage and sessionStorage entries. Extracts active client-side settings, feature flags, cached configurations, and theme preferences. Supports case-insensitive substring filtering on keys and values, JSON auto-parsing, and automatic redaction of auth tokens, passwords, and sensitive cookies. Prerequisite: Requires Chrome DevTools Protocol (CDP) enabled via Pengu Loader; check lol_status if connection fails.

Scans across active LCU WAMP event recordings, CDP console logs, network requests, and client disk logs to detect anomalies and crash patterns. Identifies frontend exception bursts, LCU HTTP server error clusters (500/503), WebSocket disconnects, and fatal crashes with root-cause hypotheses. Behavior: Safe and read-only. Does not interrupt background loggers or active streams.

Exports captured HTTP/HTTPS network traffic from the active network tailer into a standard HAR 1.2 archive. Automatically redacts sensitive authorization headers (Basic/Bearer auth, Riot auth tokens), session cookies, and credentials. If savePath is specified, writes the formatted HAR file directly to disk; otherwise returns the full HAR JSON structure. Prerequisite: Network recording must be active; call lol_cdp_network_start first to begin capturing requests.

Correlate events across LCU WAMP, Chrome DevTools Protocol console logs, network requests, disk logs, and live game telemetry into a unified chronological timeline. Use this tool during incident triage to identify whether client state changes triggered frontend UI errors or network failures. For a complete system report with status snapshots, use lol_forensics_bundle instead. For raw console logs alone, use lol_cdp_console_tail. Behavior: Safe and read-only. Gracefully combines active in-memory streams without interrupting background loggers.

Generate an all-in-one diagnostic bundle combining system connectivity status, correlated telemetry timelines, and recent disk log tails. Use this tool as a single-call comprehensive health check or bug report export when diagnosing complex client issues. For interactive querying of specific streams, use lol_forensics_correlate or subsystem-specific tools. Behavior: Safe and read-only. Returns Markdown report by default, or structured JSON when specified.

Read the most recent log lines from the active or selected League Client, CEF UX, or Game engine disk log file. Use this tool to inspect historical or startup errors recorded on disk. For live streaming log monitoring, use lol_logs_watch_start and lol_logs_watch_poll instead. For in-memory renderer console messages, use lol_cdp_console_tail. Behavior: Safe and read-only. Automatically redacts passwords, auth tokens, and sensitive keys from log output.

Start watching a League Client disk log file for newly appended lines, streaming entries into an in-memory ring buffer. Use this tool before reproducing an issue to capture new disk log entries as they are written. To poll new entries, call lol_logs_watch_poll. When finished, call lol_logs_watch_stop. For one-off historical reads from disk, use lol_logs_tail instead. Behavior: Non-destructive. Ring buffer evicts oldest lines on overflow.

Poll newly buffered disk log entries captured by the active disk log watcher since a given cursor. Use this tool to consume real-time log lines while watching is active. Prerequisite: Requires lol_logs_watch_start to be running; returns empty if stopped. For reading historical lines from file EOF, use lol_logs_tail instead. Behavior: Safe and read-only. Supports cursor-based incremental polling without duplicates.

Stop the active disk log watcher and release file handles and in-memory log buffer. Use this tool to end log watching and free memory when debugging is complete. Behavior: Idempotent; safe to call when already stopped.

List historical and active League Client, UX, or Game log files on disk sorted by modification time, newest first. Use this tool to discover session identifiers or log filenames to pass into lol_logs_tail session parameter. For reading log content directly, use lol_logs_tail. Behavior: Safe and read-only. Scans standard Riot Games log directories on disk.

Fetch complete real-time in-match game state (scores, player inventories, game time, objectives, events) from the live League game engine. Use this tool during an active match to get full game telemetry. For specific player details, use lol_game_player. For game clock and map only, use lol_game_stats. For in-game kill/objective events, use lol_game_events. For client/lobby data outside matches, use lol_get. Behavior: Prerequisite: Match must be currently running (Live Client Data API on port 2999). Safe and read-only. Returns compact summary by default to conserve tokens; pass "raw" for full ~100KB payload.

Fetch basic match status, game clock time, game mode, and map ID from the live League game engine. Use this tool to quickly verify whether a match is currently in progress, check elapsed game time, or identify the game mode. For full match telemetry including players and scores, use lol_game_all instead. Behavior: Safe and read-only. Prerequisite: Match must be currently running (port 2999).

Fetch real-time live match statistics, item inventory, abilities, and runes for the active local player or a named summoner. Use this tool to inspect a specific player's current gold, level, KDA, items, or rune setup during an active match. For all players in the match at once, use lol_game_all instead. Behavior: Safe and read-only. Prerequisite: Match must be currently in progress (port 2999).

Retrieve in-game events (champion kills, dragon/baron objectives, turret destructions, aces) from the live game engine. Use this tool to track recent in-match actions or feed an event timeline. For full match state including player inventories, use lol_game_all instead. Behavior: Safe and read-only. Supports incremental cursor via afterId. Prerequisite: Active match running on port 2999.

Checks matchmaking ready check status and accepts if match is found. Use this tool when automated match acceptance is needed during queue pop. Always prefer this dedicated workflow tool over manual REST calls or lol_eval. For creating a lobby or initiating matchmaking queue search, use lol_workflow_lobby instead. For champion selection, use lol_workflow_champ_select. Behavior: Safe and idempotent; no-op if no ready check is active. Needs "POST /lol-matchmaking/v1/ready-check/accept" on the write allowlist.

Resolves local player action in active champion select, chooses champion by name or ID, and hovers or locks in. Use this tool during draft or blind pick phases to hover or confirm champion selection or ban. Always prefer this dedicated workflow tool over manual REST calls or lol_eval. For adjusting rune/perk pages during champ select, use lol_workflow_runes_set instead. For general lobby management, use lol_workflow_lobby. A lock-in cannot be undone. Needs "PATCH /lol-champ-select/v1/session/actions/*" on the write allowlist.

Creates or updates an editable rune page with specified primary/sub styles and perk IDs and sets it active. Reuses an existing page only when its name matches, so pages the user built by hand are left alone. Use this tool before or during champ select to configure runes for a specific champion build. Always prefer this dedicated workflow tool over manual REST calls or lol_eval. To look up numeric rune IDs from names or styles, query lol_static with kind "perks". Needs "POST /lol-perks/v1/pages" and "PUT /lol-perks/v1/pages/*" on the write allowlist.

Creates a custom or matchmade lobby for a queue (e.g. 420 for Ranked Solo, 450 for ARAM) and optionally starts matchmaking queue search. Replaces the current lobby if it is on another queue. If the search fails after a lobby was created from nothing, that lobby is closed again. Use this tool to set up queues or queue up with a party. Always prefer this dedicated workflow tool over manual REST calls or lol_eval. For accepting the ready check when queue pops, use lol_workflow_matchmaking_accept instead. To look up queue IDs, query lol_static with kind "queues". Needs "POST /lol-lobby/v2/lobby" (and, for startMatchmaking, "POST /lol-lobby/v2/lobby/matchmaking/search" plus "DELETE /lol-lobby/v2/lobby" to undo) on the write allowlist.

Resolves summoner spell names (case-insensitive, e.g. "flash", "ignite", "smite", "teleport") or integer IDs and updates the player's spell selection in active champion select. Use this tool during champion select to equip appropriate summoner spells for your role. For configuring rune pages, use lol_workflow_runes_set instead. For picking or hovering champions, use lol_workflow_champ_select. Behavior: Mutates player spell slots; idempotent when setting the same spells. Requires champion select session to be active. Needs "PATCH /lol-champ-select/v1/session/my-selection" on the write allowlist.

Swaps your active champion with an available champion on the ARAM bench by name or numeric champion ID. Use this tool during ARAM champion select when a preferred champion becomes available on the shared team bench. For regular draft pick, hover, or ban actions, use lol_workflow_champ_select instead. For setting summoner spells, use lol_workflow_spells_set. Behavior: Mutates active player champion assignment; fails cleanly if target champion is not on the bench or champ select is inactive. Needs "POST /lol-champ-select/v1/session/bench/swap/*" on the write allowlist.

Dispatches invitations to one or more summoner PUUIDs to join the current game lobby party. Use this tool after creating a lobby when inviting friends or premade party members. For creating a lobby or starting matchmaking search, use lol_workflow_lobby instead. For accepting match ready checks, use lol_workflow_matchmaking_accept. Behavior: Mutates lobby invitation state; fails with diagnostic error if not currently in a lobby. Needs "POST /lol-lobby/v2/lobby/invitations" on the write allowlist.

Triggers lobby recreation with the previous game queue and party settings from the End of Game or post-match screen. Use this tool after a match completes to quickly return to a queue lobby without manually reselecting game modes. For creating a brand-new lobby with a specific queue ID, use lol_workflow_lobby instead. For honoring teammates, use lol_workflow_honor. Behavior: Mutates client gameflow state; requires client to be in EndOfGame or PreEndOfGame phase. Needs "POST /lol-lobby/v2/play-again" on the write allowlist.

Submits a post-game honor vote for an eligible allied teammate by summoner name, gameName, or summonerId with a selected honor category ("COOL", "SHOTCALLER", or "HEART"). Use this tool when voting on the post-match honor ballot before returning to the lobby. For recreating the previous game lobby, use lol_workflow_play_again. For inspecting post-game match statistics, use lol_analytics_match_detail. Behavior: Submits an irreversible honor vote; fails cleanly if no honor ballot is active or target is not found on ballot. Needs "POST /lol-honor/v1/honor" on the write allowlist.

Calculates total potential Blue Essence (from champion shards) and Orange Essence (from skin shards) along with shard breakdown in player inventory. Use this tool when evaluating available crafting materials, essence totals, or preparing to disenchant duplicate shards. For executing disenchant recipes, use lol_workflow_loot_disenchant. For general store and catalog purchases, use lol_request. Behavior: Safe and read-only; queries local player loot inventory without modifying items. Returns essence summaries and shard lists.

Disenchants specified champion or skin shards by lootId to yield Blue or Orange Essence. Use this tool to convert unwanted or duplicate shards into crafting essence. For viewing total potential essence yields before disenchanting, use lol_analytics_loot_summary first. Behavior: Consumes inventory items; cannot be undone once crafted. Needs "POST /lol-loot/v1/recipes/*/craft" on the write allowlist.

Sends a text chat message into the active champion select, lobby, or custom game conversation, or into a specific conversation ID. Use this tool to communicate team plans, role preferences, or greetings during lobby or draft phases. For updating your summoner availability status or custom status message, use lol_chat_status instead. Behavior: Sends a chat message to client conversations; automatically resolves active team/lobby chat if conversationId is omitted. Needs "POST /lol-chat/v1/conversations/*/messages" on the write allowlist.

Updates the local player's chat availability ("chat", "away", "dnd", "mobile") and custom status headline text visible to friends. Use this tool when setting do-not-disturb, stepping away from the client, or broadcasting a custom status message. For sending chat messages to conversations, use lol_chat_send instead. Behavior: Mutates friend presence state; idempotent when setting the same presence status. Needs "PUT /lol-chat/v1/me" on the write allowlist.

Evaluates comprehensive summoner profile analytics including ranked tiers, LP, winrate %, average KDA, CS per minute, and primary champion pool. Use this tool when assessing a player's skill level, ranked progression, or preferred champions before or after matches. For viewing individual recent matches in a compact list, use lol_analytics_match_history instead. For in-depth post-match breakdown, use lol_analytics_match_detail. Behavior: Safe and read-only; queries local client cache and REST endpoints without modifying game state. Returns structured performance metrics.

Retrieves a token-efficient, compact list of recent match history games for a summoner with resolved champion names, KDA, win/loss, duration, and queue IDs. Use this tool when you need an overview of recent games without filling the context window with raw JSON data. For high-level ranked stats and winrates, use lol_analytics_player instead. For a deep analytical dive into a single game's damage and objectives, use lol_analytics_match_detail. Behavior: Safe and read-only; queries local client match history and static champion data. Returns an array of concise match objects.

Calculates advanced post-game metrics including player damage share %, gold efficiency, kill participation (KP %), vision score, and team objective counts (dragons, barons, towers). Use this tool when analyzing the decisive factors, individual carrying performance, or throws of a specific completed match. For viewing multiple recent matches in brief, use lol_analytics_match_history instead. For live in-progress matches, use lol_analytics_live_combat. Behavior: Safe and read-only; automatically defaults to the most recent match if gameId is omitted. Returns structured objective and player breakdowns.

Scouts active allied team draft in champion select, evaluating physical vs magic damage distribution and detecting composition gaps (e.g. missing frontline, full AD/AP vulnerability). Use this tool during champion select draft to advise on optimal pick choices or role balance before locking in. For locking in, hovering, or banning champions, use lol_workflow_champ_select instead. For setting runes or summoner spells, use lol_workflow_runes_set or lol_workflow_spells_set. Behavior: Safe and read-only; returns cleanly with inChampSelect: false if champion select is inactive. Returns allied draft breakdown and composition warnings.

Extracts real-time combat status, lane gold/level comparisons, match clock, and team score differentials from the in-match Live Game Engine on port 2999. Use this tool during active live games to assess map state, score leads, or lane advantages. For raw live game data or item builds, use lol_game_all or lol_game_player instead. For post-game analysis, use lol_analytics_match_detail. Behavior: Safe and read-only; connects directly to local game client without external network calls. Returns inGame: false if no match is currently running.