Skip to main content
Glama

list_all_input_mappings

Read-onlyIdempotent

Aggregate every Enhanced Input and legacy key-to-action binding, flagging keys mapped to multiple actions so you can detect conflicts before claiming a new key.

Instructions

Which keys are already TAKEN, and which ones CONFLICT: aggregates every key-to-action binding across ALL Enhanced Input mapping context assets plus the legacy InputSettings action/axis mappings, and flags any key bound to more than one distinct action. Run it BEFORE claiming a new key -- a keybinding collision does not fail to compile, it surfaces weeks later inside another system. This is the aggregate you can trust: the Python route (InputMappingContext.mappings) is deprecated and returns an EMPTY list, which reads as "every key is free" even when every letter is taken. Use find_free_input_key for the complement (what is still unbound), get_input_mapping_context for one context.

Returns: { contexts:[{context_path,context_name,mapping_count}], context_count, key_bindings:[{key,display_name,bindings:[{action,source,context_path}],binding_count,distinct_action_count,conflict}], bound_key_count, conflicts:[...], conflict_count, legacy_action_mapping_count, legacy_axis_mapping_count }

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
filterNoOptional case-insensitive substring on the key name to narrow the returned key_bindings.
conflicts_onlyNoWhen true, return only keys flagged as conflicts (more than one distinct action on the same key). Default false.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv1.1.0

TDQS

A4.6/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations cover read-only/idempotent/non-destructive, and the description adds genuinely new behavioral context beyond them: the deprecation trap where InputMappingContext.mappings returns an empty list that reads as 'every key is free', and the fact that collisions fail silently rather than at compile time. This is exactly the extra context annotations cannot express.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the core question ('Which keys are already TAKEN') and the aggregate promise, then usage guidance and alternatives. The deprecation aside and Returns block are dense but each carries real information; slightly long, though nothing is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is a complex aggregation with no output schema, yet the description enumerates the full return shape (contexts, key_bindings with conflict flags, conflict_count, legacy mapping counts), so an agent knows exactly what it gets. Combined with usage timing and alternatives, nothing material is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so both parameters are already documented in the schema. The description mentions 'conflicts' and aggregates key_bindings, which loosely maps to conflicts_only, but adds no syntax or format detail beyond the schema. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('aggregates every key-to-action binding across ALL Enhanced Input mapping context assets plus legacy InputSettings') and adds conflict detection as the differentiating outcome. It clearly separates itself from find_free_input_key and get_input_mapping_context by naming both siblings and their distinct scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit timing ('Run it BEFORE claiming a new key') with a consequence-based rationale (collisions surface weeks later, not at compile time), and names the alternatives plus when to prefer them ('find_free_input_key for the complement', 'get_input_mapping_context for one context'). Nothing is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Deploy Server

Other Tools