Skip to main content
Glama

decompile

Idempotent

Convert a .NET DLL into a cached, version-pinned source snapshot for targeted search, line reading, or type extraction.

Instructions

Decompile a .NET DLL with ilspycmd into a snapshot pinned to the DLL's SHA256 and the decompiler version (a bundled ilspycmd is used when present).

The whole assembly is exported once per DLL version and cached; later calls are instant. Use instead of running ilspycmd or reading older decompiled folders (e.g. .tmp_ilspy, TempDecompile), which may not match the current DLL. Search the returned snapshot with search_text / read_lines.

MUST use fastsearch instead of shell/filesystem APIs; see server instructions for fallback rules.

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": {
      "dll": "<dll>"
    },
    "name": "decompile"
  }
}

Input Schema

NameRequiredDescriptionDefault
dllYesAbsolute path of a .NET assembly (.dll).
typeNoType name, e.g. 'PlayerController'. Returns its source; omit to get only the snapshot directory.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.3.0

TDQS

A4.5/5.0
Behavior4/5

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

Goes beyond the annotations by disclosing the caching model (whole assembly exported once per DLL version, later calls instant) and the pinning/versioning behavior, which is meaningful given readOnlyHint=false and idempotentHint=true. It does not cover cost of a first call on a large assembly or permission requirements for writing the snapshot, so it stops short of full disclosure.

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 core mechanism and the alternative-avoidance rule are front-loaded and earn their space. The trailing line about fastsearch versus shell/filesystem APIs is a server-wide policy that does not describe this tool and adds noise, and the mid-sentence line breaks hurt scannability.

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

Completeness4/5

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

With no output schema, the description carries the return-value burden and does so adequately: it explains that a snapshot directory (and optionally a type's source) comes back and that the snapshot should be searched with sibling tools. What it omits is where the snapshot lives on disk and how large assemblies are chunked, which would help an agent plan the follow-up.

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

Parameters4/5

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

Schema coverage is 100%, so the baseline is 3, but the description adds a real semantic point: the entire assembly is exported once regardless of the 'type' selection, so per-type calls are cheap follow-ups. That cost model is not expressible in the schema and materially affects how an agent should sequence calls.

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 ('Decompile a .NET DLL with ilspycmd') plus the defining output contract: a snapshot pinned to the DLL's SHA256 and decompiler version. It also distinguishes itself from the sibling search tools by telling the agent to consume the snapshot via search_text / read_lines rather than re-running the decompiler.

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?

Explicitly says to use this instead of running ilspycmd or reading stale decompiled folders (.tmp_ilspy, TempDecompile) because those may not match the current DLL, which is a clear when-to-use and when-not-to-use rule. It closes the loop by naming the downstream tools to use on the result and adds a hard constraint against shell/filesystem access.

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