Skip to main content
Glama
Godot MCP Server

Godot MCP Server

by neondeex

connect_game_signal

Listen for a signal on a node in the running Godot game for a set duration and return the fired events, enabling AI-driven debugging and gameplay verification.

Instructions

Listen to a signal on a node in the running game and return fired events.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "node_path": "<node_path>",
      "signal_name": "<signal_name>"
    },
    "name": "connect_game_signal"
  }
}

Input Schema

NameRequiredDescriptionDefault
durationNoHow long to listen in seconds (default: 2.0)
node_pathYesNode path in the running game
signal_nameYesSignal to listen for

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv1.0.0

TDQS

C2.9/5.0
Behavior2/5

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

With no annotations, the description carries the full behavioral burden and it omits the key traits: that the call blocks for up to `duration` seconds, what happens when nothing fires (empty result vs. timeout error), and whether the game must be running or paused. It also fails to clarify how this differs behaviorally from connect_signal, which is the single most likely confusion for a caller.

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?

A single, front-loaded sentence with no filler; verb, resource, and result are all in the first clause. It is efficient, though its brevity is what leaves the behavioral gaps unfilled.

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

Completeness2/5

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

For a runtime-listen tool with zero annotations and no output schema, the definition should describe the shape of returned events (event list, arguments, timestamps) and blocking/timeout behavior. Neither is covered, leaving an agent unsure what a successful call actually yields.

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 description coverage is 100%, including the duration default of 2.0, so the schema already documents all three parameters. The description adds only the notion that listening yields 'fired events,' without elaborating on the timing/window semantics of duration beyond what the schema states.

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

Purpose4/5

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

States a specific verb+resource pairing: listening for a named signal on a given node in the running game, and adds what comes back ('return fired events'). It does not reference the closely related sibling connect_signal or get_game_signals, so an agent must infer the distinction between a persistent connection and this temporary listen.

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

Usage Guidelines2/5

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

The phrase 'in the running game' implies a runtime-observation context, but there is no explicit when-to-use, no exclusion, and no pointer to connect_signal/disconnect_signal for callers who want a persistent handler instead of a one-shot listen. Guidance is left entirely 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