Skip to main content
Glama

diagnose

Parses crash logs, checks dependencies, finds mod conflicts, diffs dynamic traces, and suggests load orders or bisect plans for game modding, dispatching each request by module and action.

Instructions

Diagnosis helpers. Dispatches by module+action.

Modules/actions: diagnose: parse_crash_log (path), check_dependencies (game_dir), find_conflicts (mods), bisect_plan (items), suggest_load_order (mods) dynamic: trace_diff (trace_a, trace_b) external: check_dependencies (tool list)

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": {
      "module": "<module>",
      "action": "<action>"
    },
    "name": "diagnose"
  }
}

Input Schema

NameRequiredDescriptionDefault
actionYes
moduleYes
paramsNo

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

B3.2/5.0
Behavior2/5

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

No annotations are supplied, so the description carries the entire behavioral burden, and it says nothing about whether these actions are read-only or mutating, whether bisect_plan or suggest_load_order change state, what filesystem access is implied by path/game_dir, or what errors look like. The parenthesized arguments hint at local file access, but no safety or side-effect profile is disclosed.

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?

The dispatch table is front-loaded and dense, with every listed pair carrying new information and no filler prose. The grouped indentation is slightly awkward to parse as flat text but makes the module-to-action mapping unambiguous.

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

Completeness3/5

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

An output schema exists, so return values needn't be explained, and the action matrix covers the hardest part of calling a dispatcher. Still, with three parameters, no schema descriptions, and no annotations, the definition leaves the agent without per-action behavior, argument formats, or any note on the overlapping check_dependencies entries.

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 0% and module/action are opaque strings, so the dispatch matrix is genuinely valuable: it tells the agent which module+action pairs are valid and which arguments each expects. However, the argument names (items, mods, trace_a) are bare labels with no types, formats, or meaning, so it only partially compensates for the empty schema.

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?

"Diagnosis helpers. Dispatches by module+action." is vague on its own, but the enumerated module/action matrix (parse_crash_log, find_conflicts, bisect_plan, suggest_load_order, trace_diff) makes the tool's actual capabilities concrete. It never contrasts itself with siblings like validate or inspect, so the agent must infer that boundary.

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

Usage Guidelines3/5

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

Action names imply their use cases (parse_crash_log for crashes, find_conflicts for mod clashes), so usage is inferable rather than stated. There is no explicit when-to-use, when-not-to-use, or routing advice between overlapping entries such as the two differently-scoped check_dependencies actions, and no guidance against the sibling diagnose-adjacent tools.

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